コード例 #1
0
        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();
            }
        }
コード例 #2
0
        /// <summary>
        /// Writes a datatype to the stream.
        /// </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);

            AddTemplate(
                template,
                "<!-- ArrayDeclaration -->",
                TemplatePath + "Array.xml",
                new DataType[] { datatype },
                null,
                new WriteTemplateEventHandler(WriteTemplate_Array));

            ComplexType complexType = datatype as ComplexType;

            if (complexType != null)
            {
                if (!IsNull(complexType.BaseType))
                {
                    DataType basetype = Validator.ResolveType(complexType.BaseType);

                    if (basetype == null)
                    {
                        throw new ApplicationException(String.Format("Could not find base type '{0}' for complex type '{1}'.", complexType.BaseType, complexType.QName));
                    }

                    template.AddReplacement("_BaseType_", GetXmlSchemaTypeName(basetype.QName, -1));
                }

                AddTemplate(
                    template,
                    "<!-- ListOfFields -->",
                    TemplatePath + "Field.xml",
                    complexType.Field,
                    new LoadTemplateEventHandler(LoadTemplate_Field),
                    null);
            }

            EnumeratedType enumeratedType = datatype as EnumeratedType;

            if (enumeratedType != null)
            {
                AddTemplate(
                    template,
                    "<!-- ListOfValues -->",
                    TemplatePath + "EnumeratedValue.xml",
                    enumeratedType.Value,
                    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));
        }
コード例 #3
0
        /// <summary>
        /// Imports a datatype.
        /// </summary>
        private void ImportDataType(DataType datatype, string targetNamespace)
        {
            if (datatype == null)
            {
                return;
            }

            if (!IsValidName(datatype.Name))
            {
                throw Exception("'{0}' is not a valid datatype name.", datatype.Name);
            }

            datatype.QName = new XmlQualifiedName(datatype.Name, targetNamespace);

            if (m_datatypes.ContainsKey(datatype.QName))
            {
                throw Exception("The datatype name '{0}' already used by another datatype.", datatype.Name);
            }

            ComplexType complexType = datatype as ComplexType;

            if (complexType != null)
            {
                if (complexType.Field != null)
                {
                    foreach (FieldType fieldType in complexType.Field)
                    {
                        if (fieldType.ComplexType != null)
                        {
                            ImportDataType(fieldType.ComplexType, targetNamespace);
                        }
                    }
                }
            }

            ServiceType serviceType = datatype as ServiceType;

            if (serviceType != null)
            {
                if (serviceType.Request != null)
                {
                    foreach (FieldType fieldType in serviceType.Request)
                    {
                        if (fieldType.ComplexType != null)
                        {
                            ImportDataType(fieldType.ComplexType, targetNamespace);
                        }
                    }
                }

                if (serviceType.Response != null)
                {
                    foreach (FieldType fieldType in serviceType.Response)
                    {
                        if (fieldType.ComplexType != null)
                        {
                            ImportDataType(fieldType.ComplexType, targetNamespace);
                        }
                    }
                }
            }

            m_datatypes.Add(datatype.QName, datatype);
        }