Beispiel #1
0
        public static void GenerateCode(string inputDir, string outputDir)
        {
            List <string> files = GetInputFileList();

            Overrides.XmlBindings.Settings overridesXmlData = XmlBindings.Utilities.LoadXmlData <Overrides.XmlBindings.Settings>(inputDir, "Settings.xml");
            Formatter.Prefix       = overridesXmlData.Prefix.Value;
            Formatter.Subnamespace = overridesXmlData.Subnamespace.Value;

            var filenameBase = overridesXmlData.FilenameBase.Value;

            List <D2DTypes> typeDocuments = new List <D2DTypes>();
            Dictionary <string, QualifiableType> typeDictionary = new Dictionary <string, QualifiableType>();
            OutputDataTypes outputDataTypes = new OutputDataTypes();

            foreach (string fileName in files)
            {
                XmlBindings.D2DTypes xmlDocument = XmlBindings.Utilities.LoadXmlData <XmlBindings.D2DTypes>(inputDir, fileName);
                typeDocuments.Add(new D2DTypes(xmlDocument, overridesXmlData, typeDictionary, outputDataTypes));
            }

            Directory.CreateDirectory(outputDir);
            OutputFiles outputFiles = new OutputFiles();

            using (Formatter cppStreamWriter = new Formatter(Path.Combine(outputDir, filenameBase + ".codegen.cpp")),
                   idlStreamWriter = new Formatter(Path.Combine(outputDir, filenameBase + ".codegen.idl")))
            {
                outputFiles.CppFile = cppStreamWriter;
                outputFiles.IdlFile = idlStreamWriter;

                outputDataTypes.OutputCode(typeDictionary, outputFiles);
            }
        }
Beispiel #2
0
        public void OverridesAreWellFormed()
        {
            List <string> files = CodeGen.Program.GetInputFileList();

            string inputDir = "codegen/in";

            Overrides.XmlBindings.Settings overridesXmlData = XmlBindings.Utilities.LoadXmlData <Overrides.XmlBindings.Settings>(inputDir, "Settings.xml");
            Formatter.Prefix       = overridesXmlData.Prefix.Value;
            Formatter.Subnamespace = overridesXmlData.Subnamespace.Value;

            List <D2DTypes> typeDocuments = new List <D2DTypes>();
            Dictionary <string, QualifiableType> typeDictionary = new Dictionary <string, QualifiableType>();
            OutputDataTypes outputDataTypes = new OutputDataTypes();

            foreach (string fileName in files)
            {
                XmlBindings.D2DTypes xmlDocument = XmlBindings.Utilities.LoadXmlData <XmlBindings.D2DTypes>(inputDir, fileName);
                typeDocuments.Add(new D2DTypes(xmlDocument, overridesXmlData, typeDictionary, outputDataTypes));
            }

            foreach (Overrides.XmlBindings.Primitive overridePrimitive in overridesXmlData.Primitives)
            {
                Assert.IsTrue(typeDictionary.ContainsKey(overridePrimitive.Name), "Unexpected override primitive: " + overridePrimitive.Name);
            }

            foreach (Overrides.XmlBindings.Namespace overrideNamespace in overridesXmlData.Namespaces)
            {
                // Skip Effects namespace because it have different logic
                if (overrideNamespace.Name == "Effects")
                {
                    continue;
                }

                Assert.IsTrue(overrideNamespace.Name == "D2D" || overrideNamespace.Name == "D2D1", "Unexpected override namespace: " + overrideNamespace.Name);

                foreach (Overrides.XmlBindings.Struct overrideStruct in overrideNamespace.Structs)
                {
                    string nameKey = overrideNamespace.Name + "::" + overrideStruct.Name;
                    Assert.IsTrue(typeDictionary.ContainsKey(nameKey), "Unexpected override struct: " + overrideStruct.Name);
                }

                foreach (Overrides.XmlBindings.Enum overrideEnum in overrideNamespace.Enums)
                {
                    string nameKey = overrideNamespace.Name + "::" + overrideEnum.Name;
                    Assert.IsTrue(typeDictionary.ContainsKey(nameKey), "Unexpected override enum: " + overrideEnum.Name);

                    CodeGen.Enum e = (CodeGen.Enum)(typeDictionary[nameKey]);
                    foreach (Overrides.XmlBindings.EnumValue overrideEnumValue in overrideEnum.Values)
                    {
                        CodeGen.EnumValue match = e.Values.Find(x => x.RawNameComponent == overrideEnumValue.Name);
                        Assert.IsNotNull(match, "Unexpected override enum value: " + overrideEnum + "::" + overrideEnumValue.Name);
                    }
                }
            }
        }
Beispiel #3
0
        public D2DTypes(XmlBindings.D2DTypes xmlData, Overrides.XmlBindings.Settings overrides, Dictionary <string, QualifiableType> typeDictionary, OutputDataTypes outputDataTypes)
        {
            const Namespace globalNamespace = null; // Using null as the namespace parameter indicates the global namespace.

            m_primitiveList = new List <Primitive>();
            foreach (XmlBindings.Primitive p in xmlData.Primitives)
            {
                Overrides.XmlBindings.Primitive overridePrimitive = null;
                if (overrides != null)
                {
                    overridePrimitive = overrides.Primitives.Find(x => x.Name == p.Name);
                }

                m_primitiveList.Add(new Primitive(p, overridePrimitive, typeDictionary));
            }

            m_structList = new List <Struct>();
            foreach (XmlBindings.Struct s in xmlData.Structs)
            {
                Overrides.XmlBindings.Struct overrideStruct = null;
                if (overrides != null)
                {
                    overrideStruct = overrides.Structs.Find(x => x.Name == s.Name);
                }

                m_structList.Add(new Struct(globalNamespace, s, overrideStruct, typeDictionary, outputDataTypes));
            }

            m_namespaceList = new List <Namespace>();
            foreach (XmlBindings.Namespace n in xmlData.Namespaces)
            {
                Overrides.XmlBindings.Namespace overrideNamespace = null;
                if (overrides != null)
                {
                    overrideNamespace = overrides.Namespaces.Find(x => x.Name == n.Name);
                }

                m_namespaceList.Add(new Namespace(n, overrideNamespace, overrides.RootNamespace.Value, typeDictionary, outputDataTypes));
            }
        }
Beispiel #4
0
        public static ProcessedInputFiles ProcessInputFiles(string inputDir)
        {
            ProcessedInputFiles result = new ProcessedInputFiles();

            List <string> files = GetInputFileList();

            Overrides.XmlBindings.Settings overridesXmlData = XmlBindings.Utilities.LoadXmlData <Overrides.XmlBindings.Settings>(inputDir, "Settings.xml");
            Formatter.Prefix = overridesXmlData.Prefix.Value;

            result.FilenameBase = overridesXmlData.FilenameBase.Value;

            List <D2DTypes> typeDocuments = new List <D2DTypes>();

            result.TypeDictionary  = new Dictionary <string, QualifiableType>();
            result.OutputDataTypes = new OutputDataTypes();
            foreach (string fileName in files)
            {
                XmlBindings.D2DTypes xmlDocument = XmlBindings.Utilities.LoadXmlData <XmlBindings.D2DTypes>(inputDir, fileName);
                typeDocuments.Add(new D2DTypes(xmlDocument, overridesXmlData, result.TypeDictionary, result.OutputDataTypes));
            }

            return(result);
        }