Exemplo n.º 1
0
        public List <Data.Module> FromProtocol(Messages.Protocol protocol)
        {
            var modules = new List <Data.Module>();
            var types   = new Dictionary <string, Data.Type>();

            var protocolModule = new Data.Module(protocol.Name);

            modules.Add(protocolModule);

            foreach (var protocolType in protocol.Types)
            {
                BuildType(protocol, protocolType, protocolModule, 0);
            }

            foreach (var protocolMessage in protocol.Messages)
            {
                var messageAsType = new Messages.Type
                {
                    Fields  = protocolMessage.Fields,
                    Name    = protocolMessage.Name,
                    NumBits = 0
                };
                BuildType(protocol, messageAsType, protocolModule, 0);
            }

            return(modules);
        }
Exemplo n.º 2
0
        public void BuildType(Messages.Protocol protocol, Messages.Type protoType, Data.Module module, int depth)
        {
            if (module.GetType(protoType.Name) != null)
            {
                return;
            }

            if (depth == 100)
            {
                // Save to assume this is nested waaaay too deep
                throw new Exception($"Too much type nesting in protocol {protocol.Name}");
            }

            if (protoType.Fields != null && protoType.Fields.Count > 0)
            {
                // Ensure all types of our fields exist
                int bitOffset = 0;
                var fields    = new List <Data.Field>();
                foreach (var field in protoType.Fields)
                {
                    var fieldType = protocol.Types.FirstOrDefault(t => t.Name == field.Type);
                    if (fieldType == null)
                    {
                        throw new Exception($"Missing type {field.Type} in protocol {protocol.Name}");
                    }
                    BuildType(protocol, fieldType, module, depth + 1);

                    var type = module.GetType(field.Type);
                    fields.Add(new Data.Field(type, field.Name, bitOffset / 8, bitOffset % 8));
                    bitOffset += type.SizeInBits;
                }
                // Create our type
                module.AddType(new Data.Type(module, protoType.Name, fields));
            }
            else
            {
                // Create our type
                module.AddType(new Data.Type(module, protoType.Name, protoType.NumBits));
            }
        }
Exemplo n.º 3
0
        public void WriteModule(TextWriter output, TemplateLibrary library, Data.Module module)
        {
            var baseDict = new Dictionary <string, IInsertable>()
            {
                { "module_name", new StringLiteral(module.Name) },
            };

            var objectsContainer = new InsertableContainer()
            {
                AutoIndentAndNewline = true
            };

            foreach (var type in module.Types.Values)
            {
                if (!library.CustomTypeTemplates.TryGetValue(type.Name, out TemplateLibrary.TypeTemplates typeTemplates))
                {
                    typeTemplates = library.GenericTypeTemplates;
                }

                var typeDict = new NestedDictionary <string, IInsertable>(baseDict)
                {
                    { "obj_name", new StringLiteral(type.Name) },
                };
                typeDict.Add("obj_type", new TemplateInsert(typeTemplates.TypeNameTemplate, typeDict));


                // Functions
                var functionsContainer = new InsertableContainer()
                {
                    AutoIndentAndNewline = true
                };

                // Read and write functions for this type

                var readCallContainer = new InsertableContainer()
                {
                    AutoIndentAndNewline = true
                };

                var writeCallContainer = new InsertableContainer()
                {
                    AutoIndentAndNewline = true
                };

                // Fields
                var fieldsContainer = new InsertableContainer()
                {
                    AutoIndentAndNewline = true
                };

                foreach (var field in type.Fields)
                {
                    if (!library.CustomTypeTemplates.TryGetValue(field.Type.Name, out TemplateLibrary.TypeTemplates fieldTypeTemplates))
                    {
                        fieldTypeTemplates = library.GenericTypeTemplates;
                    }

                    var fieldDict = new NestedDictionary <string, IInsertable>(typeDict)
                    {
                        { "field_type", new TemplateInsert(fieldTypeTemplates.TypeNameTemplate, new NestedDictionary <string, IInsertable>(baseDict)
                            {
                                { "obj_name", new StringLiteral(field.Type.Name) }
                            }) },
                        { "field_name", new StringLiteral(field.Name) },
                        { "field_byte_offset", new StringLiteral(field.ByteOffset.ToString()) },
                        { "field_bit_offset", new StringLiteral(field.BitOffset.ToString()) },
                    };

                    readCallContainer.Insertables.Add(new TemplateInsert(fieldTypeTemplates.ReadCall, fieldDict));
                    writeCallContainer.Insertables.Add(new TemplateInsert(fieldTypeTemplates.WriteCall, fieldDict));
                    fieldsContainer.Insertables.Add(new TemplateInsert(typeTemplates.TypeFieldTemplate, fieldDict));
                }

                var readFuncDict = new NestedDictionary <string, IInsertable>(typeDict)
                {
                    { "read_fields", readCallContainer }
                };
                functionsContainer.Insertables.Add(new TemplateInsert(typeTemplates.ReadFunction, readFuncDict));

                var writeFuncDict = new NestedDictionary <string, IInsertable>(typeDict)
                {
                    { "write_fields", writeCallContainer }
                };
                functionsContainer.Insertables.Add(new TemplateInsert(typeTemplates.WriteFunction, writeFuncDict));


                typeDict.Add("fields", fieldsContainer);
                typeDict.Add("functions", functionsContainer);

                // Write out
                objectsContainer.Insertables.Add(new TemplateInsert(typeTemplates.TypeTemplate, typeDict));
            }

            var fileDict = new NestedDictionary <string, IInsertable>(baseDict)
            {
                { "constants", new StringLiteral("") },
                { "objects", objectsContainer }
            };

            library.FileTemplate.Apply(output, fileDict, 0);
        }