private bool WriteTemplate_Field(Template template, Context context) { HFEntry entry = context.Target as HFEntry; if (entry != null) { string sVariableName = "hf_opcua_" + entry.FieldName(); string sFieldName = entry.FieldName(); string sDataType = ""; string sBase = "BASE_NONE"; context.BlankLine = false; switch (entry.DataTypeName()) { case "Boolean": sDataType = "FT_BOOLEAN"; break; case "Byte": sDataType = "FT_UINT8"; sBase = "BASE_DEC"; break; case "SByte": sDataType = "FT_INT8"; sBase = "BASE_DEC"; break; case "UInt16": sDataType = "FT_UINT16"; sBase = "BASE_DEC"; break; case "Int16": sDataType = "FT_INT16"; sBase = "BASE_DEC"; break; case "UInt32": sDataType = "FT_UINT32"; sBase = "BASE_DEC"; break; case "Int32": sDataType = "FT_INT32"; sBase = "BASE_DEC"; break; case "UInt64": sDataType = "FT_UINT64"; sBase = "BASE_DEC"; break; case "Int64": sDataType = "FT_INT64"; sBase = "BASE_DEC"; break; case "Float": sDataType = "FT_FLOAT"; break; case "Double": sDataType = "FT_DOUBLE"; break; case "Guid": sDataType = "FT_GUID"; break; case "String": sDataType = "FT_STRING"; break; case "StatusCode": sDataType = "FT_UINT32"; sBase = "BASE_HEX"; break; case "ByteString": sDataType = "FT_BYTES"; sBase = "BASE_HEX"; break; case "XmlElement": sDataType = "FT_BYTES"; sBase = "BASE_HEX"; break; case "DateTime": sDataType = "FT_ABSOLUTE_TIME"; break; default: sDataType = "FT_UNKNOWN"; break; } if (sDataType != "FT_UNKNOWN") { if (context.Token == "// _INDECES_") { string sFormat = "\nint {0} = -1;"; string sEntry = string.Format(sFormat, sVariableName); template.Write(sEntry); } else if (context.Token == "// _EXTERNINDECES_") { string sFormat = "\nextern int {0};"; string sEntry = string.Format(sFormat, sVariableName); template.Write(sEntry); } else if (context.Token == "// _FIELDS_") { string sFormat = "\n {{ &{0}, {{ \"{1}\", \"\", {2}, {3}, NULL, 0x0, \"\", HFILL }} }}"; string sEntry = string.Format(sFormat, sVariableName, sFieldName, sDataType, sBase); if (!context.FirstInList) { template.Write(","); } template.Write(sEntry); } } } return(true); }
private void WriteTemplate_EnumsImplementation(string namespacePrefix, string dictionaryNam) { // get datatypes. List <DataType> datatypes = GetDataTypeList(null, m_exportAll, false); if (datatypes.Count == 0) { return; } // sort types to ensure types are declared in the correct order. List <DataType> sortedTypes = new List <DataType>(); foreach (DataType datatype in datatypes) { AddDataType(datatype, sortedTypes); } datatypes = sortedTypes; string fileName = String.Format(@"{0}\{1}_enumparser.c", OutputDirectory, namespacePrefix); fileName = fileName.ToLower(); StreamWriter writer = new StreamWriter(fileName, false); writer.Write(string.Format(m_sHeader, "OpcUa Enum Type Parser", DateTime.Now)); writer.Write("#ifdef HAVE_CONFIG_H\n" + "# include \"config.h\"\n" + "#endif\n" + "\n" + "#include <gmodule.h>\n" + "#include <epan/packet.h>\n\n" + "#include \"opcua_enumparser.h\"\n\n"); try { foreach (DataType datatype in sortedTypes) { EnumeratedType enumtype = datatype as EnumeratedType; if (enumtype != null) { Template template = new Template(writer, WiresharkTemplatePath + "enumparser.c", Assembly.GetExecutingAssembly()); template.AddReplacement("_NAME_", enumtype.Name); AddTemplate( template, "// _ENTRY_", WiresharkTemplatePath + "enumparser.c", enumtype.Value, null, new WriteTemplateEventHandler(WriteTemplate_Enum)); template.WriteTemplate(null); } } writer.Write("\n/** header field definitions */\n" + "static hf_register_info hf[] =\n" + "{"); int index = 0; int count = 0; // count number of enums foreach (DataType datatype in sortedTypes) { EnumeratedType enumtype = datatype as EnumeratedType; if (enumtype != null) { count++; } } // generate code foreach (DataType datatype in sortedTypes) { EnumeratedType enumtype = datatype as EnumeratedType; if (enumtype != null) { Template template = new Template(writer, WiresharkTemplatePath + "enumregisterinfo.c", Assembly.GetExecutingAssembly()); template.AddReplacement("_NAME_", enumtype.Name); template.WriteTemplate(null); if ((index + 1) < count) { writer.Write(","); } index++; } } writer.Write("\n};\n\n"); writer.Write("/** Register enum types. */\n"); writer.Write("void registerEnumTypes(int proto)\n"); writer.Write("{\n"); writer.Write(" proto_register_field_array(proto, hf, array_length(hf));\n"); writer.Write("}\n"); } finally { writer.Close(); } }
/// <summary> /// Writes the address space declaration file. /// </summary> private void WriteTemplate_BinarySchema(string fileName) { StreamWriter writer = new StreamWriter(String.Format(@"{0}\{1}.bsd", OutputDirectory, fileName), false); try { Template template = new Template(writer, TemplatePath + "File.xml", Assembly.GetExecutingAssembly()); template.Replacements.Add("_BuildDate_", Utils.Format("{0:yyyy-MM-dd}", DateTime.UtcNow)); template.Replacements.Add("_Version_", Utils.Format("{0}.{1}", Utils.GetAssemblySoftwareVersion(), Utils.GetAssemblyBuildNumber())); template.Replacements.Add("_DictionaryUri_", TargetNamespace); StringBuilder buffer = new StringBuilder(); buffer.AppendFormat("xmlns=\"{0}\"", NamespaceUris[0]); if (!m_exportAll) { for (int ii = 1; ii < NamespaceUris.Count; ii++) { buffer.Append(template.NewLine); buffer.Append(" "); buffer.AppendFormat("xmlns:s{0}=\"{1}\"", ii - 1, NamespaceUris[ii]); } } template.Replacements.Add("xmlns:s0=\"ListOfNamespaces\"", buffer.ToString()); List <string> imports = new List <string>(); imports.Add(Namespaces.OpcUaBuiltInTypes); if (!m_exportAll) { for (int ii = 1; ii < NamespaceUris.Count; ii++) { imports.Add(NamespaceUris[ii]); } } AddTemplate( template, "<!-- Imports -->", null, imports, new LoadTemplateEventHandler(LoadTemplate_Imports), null); AddTemplate( template, "<!-- ListOfTypes -->", TemplatePath + "OpaqueType.xml", GetListOfTypes(m_exportAll), new LoadTemplateEventHandler(LoadTemplate_DataType), new WriteTemplateEventHandler(WriteTemplate_DataType)); template.WriteTemplate(null); } finally { writer.Close(); } }
private void WriteTemplate_ComplexTypesImplementation(string namespacePrefix, string dictionaryNam) { // get datatypes. List <DataType> datatypes = GetDataTypeList(null, m_exportAll, false); if (datatypes.Count == 0) { return; } // sort types to ensure types are declared in the correct order. List <DataType> sortedTypes = new List <DataType>(); foreach (DataType datatype in datatypes) { AddDataType(datatype, sortedTypes); } datatypes = sortedTypes; string fileName = String.Format(@"{0}\{1}_complextypeparser.c", OutputDirectory, namespacePrefix); fileName = fileName.ToLower(); List <string> list = new List <string>(); StreamWriter writer = new StreamWriter(fileName, false); writer.Write(string.Format(m_sHeader, "OpcUa Complex Type Parser", DateTime.Now)); writer.Write("#ifdef HAVE_CONFIG_H\n" + "# include \"config.h\"\n" + "#endif\n" + "\n" + "#include <gmodule.h>\n" + "#include <epan/packet.h>\n" + "#include \"opcua_complextypeparser.h\"\n" + "#include \"opcua_enumparser.h\"\n" + "#include \"opcua_simpletypes.h\"\n" + "#include \"opcua_hfindeces.h\"\n\n"); try { foreach (DataType datatype in sortedTypes) { ComplexType complextype = datatype as ComplexType; if (complextype != null) { Template template = new Template(writer, WiresharkTemplatePath + "complexparserfunction.c", Assembly.GetExecutingAssembly()); list.Add(complextype.Name); template.AddReplacement("_NAME_", complextype.Name); if (complextype.BaseType == null) { template.AddReplacement("// _BASE_", ""); } else { template.AddReplacement("// _BASE_", string.Format(" /* parse base class members */ \n parse{0}(subtree, tvb, pOffset, \"[{0}]\");\n /* parse additional members */", complextype.BaseType.Name)); } AddTemplate( template, "// _FIELDS_", WiresharkTemplatePath + "complexparserfunction.c", complextype.Field, null, new WriteTemplateEventHandler(WriteTemplate_Parser)); template.WriteTemplate(null); } } } finally { writer.Write("\n/** Setup protocol subtree array */\n" + "static gint *ett[] =\n{\n"); foreach (string sName in list) { writer.Write(" &ett_opcua_" + sName + ",\n"); } writer.Write("};\n\n"); writer.Write("void registerComplexTypes()\n" + "{\n" + " proto_register_subtree_array(ett, array_length(ett));\n" + "}\n\n"); writer.Close(); } }
/// <summary> /// Writes the /// </summary> private bool WriteTemplate_DataType(Template template, Context context) { DataType datatype = context.Target as DataType; if (datatype == null) { return(false); } template.AddReplacement("_TypeName_", datatype.QName.Name); CreateDescription(template, "_Description_", datatype.Documentation); ComplexType complexType = datatype as ComplexType; if (complexType != null) { List <FieldType> fields = new List <FieldType>(); GetFields(complexType, fields); AddTemplate( template, "<!-- ListOfFields -->", TemplatePath + "Field.xml", fields, new LoadTemplateEventHandler(LoadTemplate_Field), null); } EnumeratedType enumeratedType = datatype as EnumeratedType; if (enumeratedType != null) { uint lengthInBits = 32; bool isOptionSet = false; List <EnumeratedValue> values = new List <EnumeratedValue>(enumeratedType.Value); if (enumeratedType.IsOptionSet) { isOptionSet = true; var baseType = Validator.ResolveType(enumeratedType.BaseType); if (baseType != null) { switch (baseType.Name) { case "SByte": { lengthInBits = 8; break; } case "Byte": { lengthInBits = 8; break; } case "Int16": { lengthInBits = 16; break; } case "UInt16": { lengthInBits = 16; break; } case "Int32": { lengthInBits = 32; break; } case "UInt32": { lengthInBits = 32; break; } case "Int64": { lengthInBits = 64; break; } case "UInt64": { lengthInBits = 64; break; } } } values.Add(new EnumeratedValue() { Name = "None", Value = 0, ValueSpecified = true }); } template.AddReplacement("_LengthInBits_", lengthInBits); template.AddReplacement("_IsOptionSet_", (isOptionSet) ? " IsOptionSet=\"true\"" : ""); AddTemplate( template, "<!-- ListOfValues -->", TemplatePath + "EnumeratedValue.xml", values, new LoadTemplateEventHandler(LoadTemplate_EnumeratedValue), null); } ServiceType serviceType = datatype as ServiceType; if (serviceType != null) { AddTemplate( template, "<!-- ListOfRequestParameters -->", TemplatePath + "Field.xml", serviceType.Request, new LoadTemplateEventHandler(LoadTemplate_Field), null); AddTemplate( template, "<!-- ListOfResponseParameters -->", TemplatePath + "Field.xml", serviceType.Response, new LoadTemplateEventHandler(LoadTemplate_Field), null); } return(template.WriteTemplate(context)); }