public FieldForm(UPnPComplexType[] ComplexTypes, UPnPComplexType.ContentData cd)
{
//
// Required for Windows Form Designer support
//
InitializeComponent();
ComplexTypeList = ComplexTypes;
foreach(UPnPComplexType ct in ComplexTypes)
{
TypeComboBox.Items.Add(ct);
}
if(cd==null)
{
TypeComboBox.SelectedIndex=11;
}
else
{
if(cd.GetType() == typeof(UPnPComplexType.Element))
{
ElementRadioButton.Checked = true;
}
else
{
AttributeRadioButton.Checked = true;
}
this.NameTextBox.Text = cd.Name;
this.MinOccursTextBox.Text = cd.MinOccurs;
if(cd.MaxOccurs == "UNBOUNDED")
{
this.MaxOccursRadio2.Checked = true;
}
else
{
this.MaxOccursRadio2.Checked = false;
this.MaxOccursTextBox.Text = cd.MaxOccurs;
}
bool ok=false;
foreach(UPnPComplexType ct in ComplexTypes)
{
if(ct.Name_LOCAL == cd.Type && ct.Name_NAMESPACE==cd.TypeNS)
{
ok=true;
TypeComboBox.SelectedItem = ct;
break;
}
}
if(!ok)
{
TypeComboBox.SelectedItem = cd.Type;
}
}
//
// TODO: Add any constructor code after InitializeComponent call
//
}
public ComplexTypeProperty(UPnPComplexType c)
{
//
// Required for Windows Form Designer support
//
InitializeComponent();
if (c != null)
{
NamespaceTextBox.Text = c.Name_NAMESPACE;
LocalNameTextBox.Text = c.Name_LOCAL;
}
//
// TODO: Add any constructor code after InitializeComponent call
//
}
public static UPnPComplexType[] Parse(string xml)
{
// Parse the XSD Schema
ArrayList a = new ArrayList(); // ComplexTypes
Hashtable g = new Hashtable(); // Table of Groups
StringReader s = new StringReader(xml);
XmlTextReader X = new XmlTextReader(s);
while (X.Read())
{
switch (X.NodeType)
{
case XmlNodeType.Element:
switch (X.LocalName)
{
case "complexType":
UPnPComplexType _complextype = ParseComplexType(X);
a.Add(_complextype);
g[_complextype.Name_NAMESPACE + ":" + _complextype.Name_LOCAL] = _complextype;
break;
case "group":
Group _group = (Group)ParseComplexType(X, new Group());
g[_group.Name_NAMESPACE + ":" + _group.Name_LOCAL] = _group;
a.Add(_group);
break;
}
break;
case XmlNodeType.EndElement:
break;
case XmlNodeType.Text:
break;
}
}
return((UPnPComplexType[])a.ToArray(typeof(UPnPComplexType)));
}
public ContainerProperty(UPnPComplexType[] ComplexTypes, UPnPComplexType.GenericContainer gc)
{
//
// Required for Windows Form Designer support
//
InitializeComponent();
BaseComboBox.SelectedIndex=0;
foreach(UPnPComplexType ct in ComplexTypes)
{
BaseComboBox.Items.Add(ct);
}
if(gc.GetType()==typeof(UPnPComplexType.ComplexContent))
{
UPnPComplexType.ComplexContent cc = (UPnPComplexType.ComplexContent)gc;
if(cc.RestExt != null && cc.RestExt.GetType()==typeof(UPnPComplexType.Restriction))
{
UPnPComplexType.Restriction r = (UPnPComplexType.Restriction)((UPnPComplexType.ComplexContent)gc).RestExt;
PatternTextBox.Text = r.PATTERN;
}
}
else if(gc.GetType()==typeof(UPnPComplexType.SimpleContent))
{
UPnPComplexType.SimpleContent cc = (UPnPComplexType.SimpleContent)gc;
if(cc.RestExt != null && cc.RestExt.GetType()==typeof(UPnPComplexType.Restriction))
{
UPnPComplexType.Restriction r = (UPnPComplexType.Restriction)((UPnPComplexType.ComplexContent)gc).RestExt;
PatternTextBox.Text = r.PATTERN;
}
}
//
// TODO: Add any constructor code after InitializeComponent call
//
}
public void AddComplexTypeToDisplayTree(UPnPComplexType ct, TreeView T)
{
TreeNode n = new TreeNode();
n.Text = ct.ToString();
n.Tag = ct;
foreach(UPnPComplexType.GenericContainer gc in ct.Containers)
{
AddComplexTypeToDisplayTree_ProcessContainer(gc,n);
}
T.Nodes.Add(n);
}
public static void BuildComplexTypeSerializer_ContentData(CodeProcessor cs,int VarX,UPnPComplexType.ContentData cd,UPnPComplexType CT,string pc_methodPrefix)
{
if (cd.TypeNS=="http://www.w3.org/2001/XMLSchema")
{
// XSD Simple Type
cs.Append(" if ((Var"+VarX.ToString()+" = (char*)malloc(");
cs.Append(((cd.Name.Length*2)+5).ToString()+"+");
switch(cd.Type)
{
case "unsignedByte":
case "unsignedInt":
case "unsignedShort":
case "unsignedLong":
cs.Append(ulong.MaxValue.ToString().Length.ToString());
break;
case "boolean":
case "int":
case "integer":
case "positiveInteger":
case "negativeInteger":
case "nonNegativeInteger":
case "nonPositiveInteger":
case "long":
case "short":
cs.Append(long.MaxValue.ToString().Length.ToString());
break;
case "decimal":
case "float":
case "double":
cs.Append(double.MaxValue.ToString().Length.ToString());
break;
default:
cs.Append("(int)strlen(s->"+cd.Name+")");
break;
}
cs.Append(")) == NULL) ILIBCRITICALEXIT(254);" + cl);
cs.Append(" len += sprintf(Var"+VarX.ToString()+",\"<"+cd.Name+">%");
switch(cd.Type)
{
case "unsignedByte":
case "unsignedInt":
case "unsignedShort":
case "unsignedLong":
cs.Append("u");
break;
case "boolean":
case "int":
case "integer":
case "positiveInteger":
case "negativeInteger":
case "nonNegativeInteger":
case "nonPositiveInteger":
case "long":
case "short":
cs.Append("d");
break;
case "decimal":
case "float":
case "double":
cs.Append("f");
break;
default:
cs.Append("s");
break;
}
cs.Append("</"+cd.Name+">\",s->"+cd.Name+");"+cl);
}
else
{
// XSD User Defined
cs.Append(" temp = "+pc_methodPrefix+"Serialize_"+cd.Type+"(s->"+cd.Name+");"+cl);
cs.Append(" if ((Var" + VarX.ToString() + " = (char*)malloc(" + (6 + cd.Name.Length * 2).ToString() + " + (int)strlen(temp))) == NULL) ILIBCRITICALEXIT(254);" + cl);
// cs.Append(" Var"+VarX.ToString()+" = "+pc_methodPrefix+"Serialize_"+cd.Type+"(s->"+cd.Name+");"+cl);
cs.Append(" len += sprintf(Var"+VarX.ToString()+",\"<"+cd.Name+">%s</"+cd.Name+">\",temp);"+cl);
cs.Append(" free(temp);"+cl);
// cs.Append(" len += (int)strlen(Var"+VarX.ToString()+");"+cl);
}
}
private void RefreshFieldNodes(TreeNode ItemCollectionNode, UPnPComplexType.ItemCollection ic)
{
Queue q = new Queue();
foreach(UPnPComplexType.ContentData cd in ic.Items)
{
q.Enqueue(cd);
}
foreach(TreeNode n in ItemCollectionNode.Nodes)
{
if(n.Tag.GetType().BaseType==typeof(UPnPComplexType.ContentData))
{
UPnPComplexType.ContentData d = (UPnPComplexType.ContentData)q.Dequeue();
n.Text = d.ToString();
n.Tag = d;
}
}
}
public UPnPComplexType[] GetComplexTypeList()
{
UPnPComplexType[] RetVal;
int i = 0;
IDictionaryEnumerator en = ComplexTypeTable.GetEnumerator();
while (en.MoveNext())
{
if (en.Value.GetType() == typeof(UPnPComplexType))
{
++i;
}
}
RetVal = new UPnPComplexType[i];
en.Reset();
i = 0;
while (en.MoveNext())
{
if (en.Value.GetType() == typeof(UPnPComplexType))
{
RetVal[i] = (UPnPComplexType)en.Value;
++i;
}
}
return (RetVal);
}
public UPnPStateVariable(String VarName, UPnPComplexType CT)
{
SendEvent = false;
DefValue = null;
CurrentValue = null;
VariableName = VarName;
Allowed = null;
AssociationList = new ArrayList();
VarType = "string";
_ComplexType = CT;
}
private void AddComplexType_Click(object sender, System.EventArgs e)
{
UPnPComplexType c;
TreeNode n = new TreeNode();
ComplexTypeProperty ctp = new ComplexTypeProperty();
if(ctp.ShowDialog()==DialogResult.OK)
{
c = new UPnPComplexType(ctp.LocalName,ctp.Namespace);
upnpService.AddComplexType(c);
n.Tag = c;
n.Text = c.ToString();
TypesView.Nodes.Add(n);
}
}
private static UPnPComplexType ParseComplexType(XmlTextReader X, UPnPComplexType RetVal)
{
string elementName = X.LocalName;
int count = 0;
bool done = false;
DText P = new DText();
P.ATTRMARK = ":";
RetVal.AddContainer(new GenericContainer());
do
{
switch (X.NodeType)
{
case XmlNodeType.Element:
switch (X.LocalName)
{
case "complexType":
case "group":
++count;
if (X.HasAttributes)
{
for (int i = 0; i < X.AttributeCount; i++)
{
X.MoveToAttribute(i);
if (X.Name == "name")
{
P[0] = X.Value;
if (P.DCOUNT() == 1)
{
RetVal.LocalName = X.Value;
RetVal.NameSpace = X.LookupNamespace("");
}
else
{
RetVal.LocalName = P[2];
RetVal.NameSpace = X.LookupNamespace(P[1]);
}
}
else if (X.Name == "ref")
{
// NOP
}
}
X.MoveToElement();
}
break;
case "sequence":
case "choice":
RetVal.CurrentContainer.AddCollection(ParseComplexType_SequenceChoice(X));
//ParseComplexType_Sequence(X,RetVal);
break;
case "complexContent":
RetVal.AddContainer(new ComplexContent());
break;
case "simpleContent":
RetVal.AddContainer(new SimpleContent());
break;
case "restriction":
Restriction r = new Restriction();
if (RetVal.CurrentContainer.GetType() == typeof(ComplexContent))
{
((ComplexContent)RetVal.CurrentContainer).RestExt = r;
}
else if (RetVal.CurrentContainer.GetType() == typeof(SimpleContent))
{
((SimpleContent)RetVal.CurrentContainer).RestExt = r;
}
if (X.HasAttributes)
{
for (int i = 0; i < X.AttributeCount; i++)
{
X.MoveToAttribute(i);
if (X.Name == "base")
{
P[0] = X.Value;
if (P.DCOUNT() == 1)
{
r.baseType = X.Value;
r.baseTypeNS = X.LookupNamespace("");
}
else
{
r.baseType = P[2];
r.baseTypeNS = X.LookupNamespace(P[1]);
}
}
}
X.MoveToElement();
}
break;
}
break;
case XmlNodeType.EndElement:
if (X.LocalName == elementName)
{
--count;
if (count == 0)
{
done = true;
}
}
break;
case XmlNodeType.Text:
break;
}
} while(!done && X.Read());
return(RetVal);
}
public static void BuildComplexTypeDefinitionsAndHeaders_Containers(ref int idx, CodeProcessor cs, UPnPComplexType.GenericContainer gc, UPnPService s, Hashtable SequenceTable, Hashtable ChoiceTable)
{
foreach (UPnPComplexType.ItemCollection ic in gc.Collections)
{
BuildComplexTypeDefinitionsAndHeaders_Collections(ref idx, cs, ic, s, SequenceTable, ChoiceTable);
}
}
public static void BuildComplexTypeDefinitionsAndHeaders_FillInner(CodeProcessor cs, UPnPService service, UPnPComplexType.ContentData[] Items)
{
string varType = "";
foreach (UPnPComplexType.ContentData cd in Items)
{
switch (cd.TypeNS)
{
case "http://www.w3.org/2001/XMLSchema":
// XSD Simple Types
switch (cd.Type)
{
case "unsignedByte":
varType = "unsigned byte";
break;
case "byte":
varType = "byte";
break;
case "unsignedInt":
varType = "unsigned int";
break;
case "unsignedShort":
varType = "unsigned short";
break;
case "unsignedLong":
varType = "unsigned long";
break;
case "boolean":
case "int":
case "integer":
case "positiveInteger":
case "negativeInteger":
case "nonNegativeInteger":
case "nonPositiveInteger":
varType = "int";
break;
case "long":
varType = "long";
break;
case "short":
varType = "short";
break;
case "decimal":
case "float":
varType = "single";
break;
case "double":
varType = "double";
break;
default:
varType = "char*";
break;
}
if (varType != "char*" && cd.MinOccurs == "0")
{
varType = varType + "*";
}
break;
default:
// User Defined Types
UPnPComplexType temp = service.GetComplexType(cd.TypeNS, cd.Type);
if (temp != null)
{
varType = "struct " + cd.Type + "*";
}
else
{
// Unknown type
varType = "char*";
}
break;
}
if (varType != "")
{
cs.Append(" " + varType + " " + cd.Name + ";" + cl);
}
}
}
public static void BuildComplexTypeSerializer_Sequence_PreDeclaration(CodeProcessor cs, UPnPComplexType CT, Hashtable SeqTable, UPnPComplexType.Sequence s,string pc_methodPrefix, string pc_methodLibPrefix)
{
// int VarX=0;
// int SeqX=0;
// int ChoX=0;
cs.Append("char* "+pc_methodPrefix+"Serialize_"+CT.Name_LOCAL+"_SEQUENCE"+SeqTable[s].ToString()+"(struct SEQUENCE_"+SeqTable[s].ToString()+" *s);"+cl);
// foreach(UPnPComplexType.ItemCollection ic in s.NestedCollections)
// {
// if (ic.GetType()==typeof(UPnPComplexType.Sequence))
// {
// ++SeqX;
// ++VarX;
// cs.Append("void "+pc_methodPrefix+"FREE_"+CT.Name_LOCAL+"_SEQUENCE"+SeqTable[ic].ToString()+"(s->_sequence_"+SeqX.ToString()+");"+cl);
// }
// else if (ic.GetType()==typeof(UPnPComplexType.Choice))
// {
// ++ChoX;
// ++VarX;
// //ToDo: Add code for Choice
// }
// }
}
public static void BuildComplexTypeDefinitionsAndHeaders_Collections(ref int idx, CodeProcessor cs, UPnPComplexType.ItemCollection ic, UPnPService service, Hashtable SequenceTable, Hashtable ChoiceTable)
{
if (ic.GetType() == typeof(UPnPComplexType.Choice))
{
++idx;
UPnPComplexType.Choice ch = (UPnPComplexType.Choice)ic;
cs.Append(" struct CHOICE_" + ChoiceTable[ic].ToString() + " *_choice_" + idx.ToString() + ";" + cl);
if (ch.MaxOccurs != "" && (ch.MaxOccurs.ToLower() == "unbounded" || int.Parse(ch.MaxOccurs) > 1))
{
cs.Append(" int _choice_" + idx.ToString() + "_Length;" + cl);
}
}
else if (ic.GetType() == typeof(UPnPComplexType.Sequence))
{
++idx;
UPnPComplexType.Sequence sequ = (UPnPComplexType.Sequence)ic;
cs.Append(" struct SEQUENCE_" + SequenceTable[ic].ToString() + " *_sequence_" + idx.ToString() + ";" + cl);
if (sequ.MaxOccurs != "" && (sequ.MaxOccurs.ToLower() == "unbounded" || int.Parse(sequ.MaxOccurs) > 1))
{
cs.Append(" int _sequence_" + idx.ToString() + "_Length;" + cl);
}
}
else
{
BuildComplexTypeDefinitionsAndHeaders_FillInner(cs, service, ic.Items);
}
}
public static void BuildComplexTypeSerializer_Sequence_FREE(CodeProcessor cs, UPnPComplexType CT, Hashtable SeqTable, UPnPComplexType.Sequence s,string pc_methodPrefix)
{
int VarX=0;
int SeqX=0;
int ChoX=0;
cs.Append("void "+pc_methodPrefix+"FREE_"+CT.Name_LOCAL+"_SEQUENCE"+SeqTable[s].ToString()+"(struct SEQUENCE_"+SeqTable[s].ToString()+" *s)"+cl);
cs.Append("{"+cl);
foreach(UPnPComplexType.ItemCollection ic in s.NestedCollections)
{
if (ic.GetType()==typeof(UPnPComplexType.Sequence))
{
++SeqX;
++VarX;
cs.Append(" "+pc_methodPrefix+"FREE_"+CT.Name_LOCAL+"_SEQUENCE"+SeqTable[ic].ToString()+"(s->_sequence_"+SeqX.ToString()+");"+cl);
}
else if (ic.GetType()==typeof(UPnPComplexType.Choice))
{
++ChoX;
++VarX;
//ToDo: Add code for Choice
}
}
foreach(UPnPComplexType.ContentData cd in s.Items)
{
++VarX;
//BuildComplexTypeSerializer_ContentData(cs,VarX,cd,CT,pc_methodPrefix);
if (cd.TypeNS!="http://www.w3.org/2001/XMLSchema")
{
cs.Append(" "+pc_methodPrefix+"FREE_"+cd.Type+"(s->"+cd.Name+");"+cl);
}
}
cs.Append(" free(s);"+cl);
cs.Append("}"+cl);
}
public static void BuildComplexTypeSerializer_Sequence(CodeProcessor cs, UPnPComplexType CT, Hashtable SeqTable, UPnPComplexType.Sequence s,string pc_methodPrefix)
{
int VarX=0;
int SeqX=0;
int ChoX=0;
cs.Append("char* "+pc_methodPrefix+"Serialize_"+CT.Name_LOCAL+"_SEQUENCE"+SeqTable[s].ToString()+"(struct SEQUENCE_"+SeqTable[s].ToString()+" *s)"+cl);
cs.Append("{"+cl);
cs.Append(" int len=0;"+cl);
cs.Append(" char* RetVal;"+cl);
foreach(UPnPComplexType.ItemCollection ic in s.NestedCollections)
{
if (ic.GetType()==typeof(UPnPComplexType.Sequence))
{
++SeqX;
++VarX;
cs.Append(" char* Var"+VarX.ToString()+" = "+pc_methodPrefix+"Serialize_"+CT.Name_LOCAL+"_SEQUENCE"+SeqTable[ic].ToString()+"(s->_sequence_"+SeqX.ToString()+");"+cl);
}
else if (ic.GetType()==typeof(UPnPComplexType.Choice))
{
++ChoX;
++VarX;
}
}
for(int i=1;i<=s.Items.Length;++i)
{
cs.Append(" char* Var"+(VarX+i).ToString()+";"+cl);
}
foreach(UPnPComplexType.ContentData cd in s.Items)
{
if (cd.TypeNS!="http://www.w3.org/2001/XMLSchema")
{
cs.Append(" char* temp;"+cl);
break;
}
}
cs.Append(cl);
for(int i=1;i<=VarX;++i)
{
cs.Append(" len += (int)strlen(Var"+i.ToString()+");"+cl);
}
cs.Append(cl);
foreach(UPnPComplexType.ContentData cd in s.Items)
{
++VarX;
BuildComplexTypeSerializer_ContentData(cs,VarX,cd,CT,pc_methodPrefix);
}
cs.Append(" if ((RetVal = (char*)malloc(len + 1)) == NULL) ILIBCRITICALEXIT(254);" + cl);
cs.Append(" len = 0;"+cl);
for(int i=1;i<=VarX;++i)
{
cs.Append(" len += sprintf(RetVal + len, \"%s\", Var"+i.ToString()+");"+cl);
}
for(int i=1;i<=VarX;++i)
{
cs.Append(" free(Var"+i.ToString()+");"+cl);
}
cs.Append(" return(RetVal);"+cl);
cs.Append("}"+cl);
}
public static void BuildComplexTypeSerializer_FREE(CodeProcessor cs, UPnPComplexType CT, Hashtable SeqTable,string pc_methodPrefix)
{
int VarX=0;
int SeqX=0;
int ChoX=0;
cs.Append("void "+pc_methodPrefix+"FREE_"+CT.Name_LOCAL+"(struct "+CT.Name_LOCAL+" *s)"+cl);
cs.Append("{"+cl);
foreach(UPnPComplexType.GenericContainer gc in CT.Containers)
{
foreach(UPnPComplexType.ItemCollection ic in gc.Collections)
{
if (ic.GetType()==typeof(UPnPComplexType.Sequence))
{
++SeqX;
++VarX;
cs.Append(" "+pc_methodPrefix+"FREE_"+CT.Name_LOCAL+"_SEQUENCE"+SeqTable[ic].ToString()+"(s->_sequence_"+SeqX.ToString()+");"+cl);
}
else if (ic.GetType()==typeof(UPnPComplexType.Choice))
{
++ChoX;
++VarX;
//ToDo: Add code for Choice
}
else
{
//ToDO: Add case for generic Item Collections
}
}
}
cs.Append(" free(s);"+cl);
cs.Append("}"+cl);
}
private void AddComplexTypeToDisplayTree_ProcessCollection(UPnPComplexType.ItemCollection ic, TreeNode n)
{
TreeNode UseNode = n;
if(ic.GetType()!=typeof(UPnPComplexType.ItemCollection))
{
TreeNode child = new TreeNode();
child.Text = ic.GetType().Name;
child.Tag = ic;
UseNode = child;
n.Nodes.Add(child);
}
foreach(UPnPComplexType.ContentData cd in ic.Items)
{
TreeNode subNode = new TreeNode();
subNode.Text = cd.ToString();
subNode.Tag = cd;
UseNode.Nodes.Add(subNode);
}
foreach(UPnPComplexType.ItemCollection ecd in ic.NestedCollections)
{
AddComplexTypeToDisplayTree_ProcessCollection(ecd,UseNode);
}
}
public static void BuildComplexTypeDefinitionsAndHeaders_InnerCollections(CodeProcessor cs, UPnPService service, UPnPComplexType.ItemCollection ic, Hashtable SequenceTable, Hashtable ChoiceTable)
{
if (ic.Items.Length > 0 || ic.NestedCollections.Length > 0)
{
if (ic.GetType() == typeof(UPnPComplexType.Sequence))
{
cs.Append("struct SEQUENCE_" + SequenceTable[ic].ToString() + cl);
cs.Append("{" + cl);
BuildComplexTypeDefinitionsAndHeaders_FillInner(cs, service, ic.Items);
BuildComplexTypeDefinitionsAndHeaders_InnerCollections_Nested(cs, ic.NestedCollections, SequenceTable, ChoiceTable);
cs.Append("};" + cl);
}
else if (ic.GetType() == typeof(UPnPComplexType.Choice))
{
cs.Append("struct CHOICE_" + ChoiceTable[ic].ToString() + cl);
cs.Append("{" + cl);
BuildComplexTypeDefinitionsAndHeaders_FillInner(cs, service, ic.Items);
BuildComplexTypeDefinitionsAndHeaders_InnerCollections_Nested(cs, ic.NestedCollections, SequenceTable, ChoiceTable);
cs.Append("};" + cl);
}
}
foreach (UPnPComplexType.ItemCollection nc in ic.NestedCollections)
{
BuildComplexTypeDefinitionsAndHeaders_InnerCollections(cs, service, nc, SequenceTable, ChoiceTable);
}
}
private void AddComplexTypeToDisplayTree_ProcessContainer(UPnPComplexType.GenericContainer gc, TreeNode n)
{
if(gc.GetType()!=typeof(UPnPComplexType.GenericContainer))
{
TreeNode child = new TreeNode();
child.Text = gc.GetType().Name;
child.Tag = gc;
n.Nodes.Add(child);
foreach(UPnPComplexType.ItemCollection ic in gc.Collections)
{
AddComplexTypeToDisplayTree_ProcessCollection(ic,child);
}
}
else
{
foreach(UPnPComplexType.ItemCollection ic in gc.Collections)
{
AddComplexTypeToDisplayTree_ProcessCollection(ic,n);
}
}
}
public static void BuildComplexTypeDefinitionsAndHeaders_InnerCollections_Nested(CodeProcessor cs, UPnPComplexType.ItemCollection[] icList, Hashtable SequenceTable, Hashtable ChoiceTable)
{
int x = 0;
foreach (UPnPComplexType.ItemCollection ic in icList)
{
if (ic.GetType() == typeof(UPnPComplexType.Sequence))
{
cs.Append(" struct SEQUENCE_" + SequenceTable[ic].ToString() + " *_sequence_" + (++x).ToString() + ";" + cl);
}
else if (ic.GetType() == typeof(UPnPComplexType.Choice))
{
cs.Append(" struct CHOICE_" + ChoiceTable[ic].ToString() + " *_choice_" + (++x).ToString() + ";" + cl);
}
//ToDo: Insert MaxOccurs Logic
}
}
public static void BuildComplexTypeSerializer_Collection(ref int VarIndex, ref int SeqIndex, ref int ChoIndex, Hashtable SequenceTable,Hashtable ChoiceTable,UPnPComplexType CT,CodeProcessor cs,SortedList SortedServiceList,string pc_methodPrefix, UPnPComplexType.ItemCollection ic)
{
// foreach(UPnPComplexType.ItemCollection ec in ic.NestedCollections)
// {
// BuildComplexTypeSerializer_Collection(ref VarIndex,SequenceTable,ChoiceTable,CT,cs,SortedServiceList,pc_methodPrefix,ec);
// }
if (ic.GetType()==typeof(UPnPComplexType.Sequence))
{
++VarIndex;
++SeqIndex;
cs.Append(" char* Var"+VarIndex.ToString()+" = "+pc_methodPrefix+"Serialize_"+CT.Name_LOCAL+"_SEQUENCE"+SequenceTable[ic].ToString()+"(c->_sequence_"+SeqIndex.ToString()+");"+cl);
}
else if (ic.GetType()==typeof(UPnPComplexType.Choice))
{
++VarIndex;
++ChoIndex;
cs.Append(" char* Var"+VarIndex.ToString()+" = "+pc_methodPrefix+"Serialize_"+CT.Name_LOCAL+"_SEQUENCE"+SequenceTable[ic].ToString()+"(c->_choice_"+ChoIndex.ToString()+");"+cl);
}
else
{
// Generic Item Collection
}
}
private static UPnPComplexType ParseComplexType(XmlTextReader X, UPnPComplexType RetVal)
{
string elementName = X.LocalName;
int count = 0;
bool done = false;
DText P = new DText();
P.ATTRMARK = ":";
RetVal.AddContainer(new GenericContainer());
do
{
switch (X.NodeType)
{
case XmlNodeType.Element:
switch (X.LocalName)
{
case "complexType":
case "group":
++count;
if (X.HasAttributes)
{
for (int i = 0; i < X.AttributeCount; i++)
{
X.MoveToAttribute(i);
if (X.Name == "name")
{
P[0] = X.Value;
if (P.DCOUNT() == 1)
{
RetVal.LocalName = X.Value;
RetVal.NameSpace = X.LookupNamespace("");
}
else
{
RetVal.LocalName = P[2];
RetVal.NameSpace = X.LookupNamespace(P[1]);
}
}
else if (X.Name == "ref")
{
// NOP
}
}
X.MoveToElement();
}
break;
case "sequence":
case "choice":
RetVal.CurrentContainer.AddCollection(ParseComplexType_SequenceChoice(X));
//ParseComplexType_Sequence(X,RetVal);
break;
case "complexContent":
RetVal.AddContainer(new ComplexContent());
break;
case "simpleContent":
RetVal.AddContainer(new SimpleContent());
break;
case "restriction":
Restriction r = new Restriction();
if (RetVal.CurrentContainer.GetType() == typeof(ComplexContent))
{
((ComplexContent)RetVal.CurrentContainer).RestExt = r;
}
else if (RetVal.CurrentContainer.GetType() == typeof(SimpleContent))
{
((SimpleContent)RetVal.CurrentContainer).RestExt = r;
}
if (X.HasAttributes)
{
for (int i = 0; i < X.AttributeCount; i++)
{
X.MoveToAttribute(i);
if (X.Name == "base")
{
P[0] = X.Value;
if (P.DCOUNT() == 1)
{
r.baseType = X.Value;
r.baseTypeNS = X.LookupNamespace("");
}
else
{
r.baseType = P[2];
r.baseTypeNS = X.LookupNamespace(P[1]);
}
}
}
X.MoveToElement();
}
break;
}
break;
case XmlNodeType.EndElement:
if (X.LocalName == elementName)
{
--count;
if (count == 0)
{
done = true;
}
}
break;
case XmlNodeType.Text:
break;
}
}while(!done && X.Read());
return(RetVal);
}
public void AddComplexType(UPnPComplexType t)
{
t.ParentService = this;
if (!ComplexType_NamespaceTables.Contains(t.Name_NAMESPACE))
{
ComplexType_NamespaceTables[t.Name_NAMESPACE] = new ArrayList();
SchemaURLS[t.Name_NAMESPACE] = "http://www.vendor.org/Schemas/Sample.xsd";
}
((ArrayList)ComplexType_NamespaceTables[t.Name_NAMESPACE]).Add(t);
ComplexTypeTable[t.Name_LOCAL + ":" + t.Name_NAMESPACE] = t;
if (!this.ComplexType_NamespacePrefix.ContainsKey(t.Name_NAMESPACE))
{
++ComplexType_NamespacePrefixIndex;
this.ComplexType_NamespacePrefix[t.Name_NAMESPACE] = "ct" + this.ComplexType_NamespacePrefixIndex.ToString();
}
}
public static void BuildComplexTypeParser_Collection(string cx, Hashtable SequenceTable, Hashtable ChoiceTable, ref int SeqX, ref int ChoX, CodeProcessor cs, UPnPComplexType.ItemCollection ic, string pc_methodPrefix)
{
int x = 0;
string prefix = "";
int SeqX2 = 0;
int ChoX2 = 0;
if (ic.GetType() == typeof(UPnPComplexType.Sequence))
{
++SeqX;
if (cx == "")
{
cx += "_sequence_" + SeqX.ToString();
}
else
{
cx += "->_sequence_" + SeqX.ToString();
}
prefix = cx + "->";
}
else if (ic.GetType() == typeof(UPnPComplexType.Choice))
{
++ChoX;
if (cx == "")
{
cx += "_choice_" + ChoX.ToString();
}
else
{
cx += "->_choice_" + ChoX.ToString();
}
prefix = cx + "->";
}
foreach (UPnPComplexType.ContentData cd in ic.Items)
{
++x;
cs.Append(" if (node->NameLength==" + cd.Name.Length.ToString() + " && memcmp(node->Name,\"" + cd.Name + "\"," + cd.Name.Length.ToString() + ")==0)" + cl);
cs.Append(" {" + cl);
if (x == 1)
{
Stack st = new Stack();
UPnPComplexType.ItemCollection tc = ic;
DText pp = new DText();
pp.ATTRMARK = "->";
pp[0] = cx;
int ppx = pp.DCOUNT();
while (tc != null)
{
string ps;
ps = "RetVal";
for (int i = 1; i <= ppx; ++i)
{
ps += ("->" + pp[i]);
}
st.Push(new object[2] { ps, tc });
--ppx;
tc = tc.ParentCollection;
}
while (st.Count > 0)
{
object[] foo = (object[])st.Pop();
cs.Append(" if (" + (string)foo[0] + " == NULL)" + cl);
cs.Append(" {" + cl);
if (foo[1].GetType() == typeof(UPnPComplexType.Sequence))
{
cs.Append(" if ((" + (string)foo[0] + " = (struct SEQUENCE_" + SequenceTable[foo[1]].ToString() + "*)malloc(sizeof(struct SEQUENCE_" + SequenceTable[foo[1]].ToString() + "))) == NULL) ILIBCRITICALEXIT(254);" + cl);
cs.Append(" memset(" + (string)foo[0] + ",0,sizeof(struct SEQUENCE_" + SequenceTable[foo[1]].ToString() + "));" + cl);
}
else if (foo[1].GetType() == typeof(UPnPComplexType.Choice))
{
cs.Append(" if ((" + (string)foo[0] + " = (struct CHOICE_" + ChoiceTable[foo[1]].ToString() + "*)malloc(sizeof(struct CHOICE_" + ChoiceTable[foo[1]].ToString() + "))) == NULL) ILIBCRITICALEXIT(254);" + cl);
cs.Append(" memset(" + (string)foo[0] + ",0,sizeof(struct CHOICE_" + ChoiceTable[foo[1]].ToString() + "));" + cl);
}
cs.Append(" }" + cl);
}
// if (ic.GetType()==typeof(UPnPComplexType.Sequence))
// {
// cs.Append(" RetVal->"+cx+" = (struct SEQUENCE_"+SequenceTable[ic].ToString()+"*)malloc(sizeof(struct SEQUENCE_"+SequenceTable[ic].ToString()+"));"+cl);
// }
// else if (ic.GetType()==typeof(UPnPComplexType.Choice))
// {
// cs.Append(" RetVal->"+cx+" = (struct CHOICE_"+ChoiceTable[ic].ToString()+"*)malloc(sizeof(struct CHOICE_"+ChoiceTable[ic].ToString()+"));"+cl);
// }
}
if (cd.TypeNS == "http://www.w3.org/2001/XMLSchema")
{
// XSD Simple Type
switch (cd.Type)
{
case "boolean":
case "int":
case "integer":
case "positiveInteger":
case "negativeInteger":
case "nonNegativeInteger":
case "nonPositiveInteger":
case "long":
case "short":
cs.Append(" RetVal->" + prefix + cd.Name + " = atoi(text);" + cl);
break;
}
}
else
{
// XSD User Defined Type
cs.Append(" RetVal->" + prefix + cd.Name + " = " + pc_methodPrefix + "Parse_" + cd.Type + "(node->Next);" + cl);
}
cs.Append(" }" + cl);
}
foreach (UPnPComplexType.ItemCollection ec in ic.NestedCollections)
{
BuildComplexTypeParser_Collection(cx, SequenceTable, ChoiceTable, ref SeqX2, ref ChoX2, cs, ec, pc_methodPrefix);
}
}
public void RemoveComplexType(UPnPComplexType t)
{
ComplexTypeTable.Remove(t.Name_LOCAL + ":" + t.Name_NAMESPACE);
((ArrayList)this.ComplexType_NamespaceTables[t.Name_NAMESPACE]).Remove(t);
t.ParentService = null;
}
private void Properties_Click(object sender, System.EventArgs e)
{
TreeNode n = TypesView.SelectedNode;
UPnPComplexType c;
if(n.Tag.GetType()==typeof(UPnPComplexType))
{
c = (UPnPComplexType)n.Tag;
ComplexTypeProperty ctp = new ComplexTypeProperty(c);
if(ctp.ShowDialog()==DialogResult.OK)
{
UPnPComplexType NewComplexType = new UPnPComplexType(ctp.LocalName,ctp.Namespace);
NewComplexType.ClearCollections();
foreach(UPnPComplexType.GenericContainer gc in c.Containers)
{
NewComplexType.AddContainer(gc);
}
upnpService.RemoveComplexType(c);
upnpService.AddComplexType(NewComplexType);
n.Tag = NewComplexType;
n.Text = NewComplexType.ToString();
}
}
else if(n.Tag.GetType().BaseType == typeof(UPnPComplexType.GenericContainer))
{
ContainerProperty cp = new ContainerProperty(upnpService.GetComplexTypeList(),(UPnPComplexType.GenericContainer)n.Tag);
if(cp.ShowDialog()==DialogResult.OK)
{
if(n.Tag.GetType()==typeof(UPnPComplexType.ComplexContent))
{
((UPnPComplexType.ComplexContent)n.Tag).RestExt = cp.re;
}
else if(n.Tag.GetType()==typeof(UPnPComplexType.ComplexContent))
{
((UPnPComplexType.SimpleContent)n.Tag).RestExt = cp.re;
}
}
}
}
public static void BuildComplexTypeDefinitionsAndHeaders_InnerCollections_Number(UPnPComplexType CT, CodeProcessor cs, UPnPComplexType.ItemCollection ic, Hashtable SequenceTable, Hashtable ChoiceTable, ref int SequenceCounter, ref int ChoiceCounter)
{
if (ic.GetType() == typeof(UPnPComplexType.Sequence))
{
SequenceTable[ic] = ++SequenceCounter;
((Hashtable)SequenceTable[CT])[ic] = SequenceCounter;
}
else if (ic.GetType() == typeof(UPnPComplexType.Choice))
{
ChoiceTable[ic] = ++ChoiceCounter;
((Hashtable)ChoiceTable[CT])[ic] = ChoiceCounter;
}
foreach (UPnPComplexType.ItemCollection nc in ic.NestedCollections)
{
BuildComplexTypeDefinitionsAndHeaders_InnerCollections_Number(CT, cs, nc, SequenceTable, ChoiceTable, ref SequenceCounter, ref ChoiceCounter);
}
}
public static void BuildComplexTypeSerializer_Container(ref int VarIndex, ref int SeqIndex, ref int ChoIndex, Hashtable SequenceTable,Hashtable ChoiceTable,UPnPComplexType CT,CodeProcessor cs, SortedList SortedServiceList, string pc_methodPrefix, UPnPComplexType.GenericContainer gc)
{
foreach(UPnPComplexType.ItemCollection ic in gc.Collections)
{
BuildComplexTypeSerializer_Collection(ref VarIndex, ref SeqIndex, ref ChoIndex, SequenceTable,ChoiceTable,CT,cs,SortedServiceList,pc_methodPrefix, ic);
}
}
