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