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); } }