Esempio n. 1
0
        public static CodeGenData Calculate(ParsedData parsedData, ExternStructInfo[] externStructs)
        {
            var typesMemInfo = new Dictionary <string, TypeMemoryInfo>(Primitives);

            foreach (var structInfo in externStructs)
            {
                DefaultValueInfo dvi;
                switch (structInfo.Kind)
                {
                case ExternStructInfo.StructKind.WithoutValues:
                    dvi = DefaultValueInfo.WriteZeroes();
                    break;

                case ExternStructInfo.StructKind.WithEnumeratedValues:
                    dvi = DefaultValueInfo.AssignTypeMember(structInfo.Values[0]);
                    break;

                case ExternStructInfo.StructKind.PlainBuffersStruct:
                    dvi = DefaultValueInfo.CallWriteDefaultMethod();
                    break;

                default:
                    throw new ArgumentOutOfRangeException();
                }
                typesMemInfo.Add(structInfo.Name, new TypeMemoryInfo(structInfo.Size, structInfo.Alignment, dvi));
            }

            var codeGenTypes = new CodeGenType[parsedData.Types.Length];

            for (var i = 0; i < parsedData.Types.Length; i++)
            {
                CodeGenType codeGenType;
                switch (parsedData.Types[i])
                {
                case ParsedEnum pdEnum:
                    codeGenType = HandleEnum(pdEnum, typesMemInfo);
                    break;

                case ParsedArray pdArray:
                    codeGenType = HandleArray(pdArray, typesMemInfo);
                    break;

                case ParsedStruct pdStruct:
                    codeGenType = HandleStruct(pdStruct, typesMemInfo);
                    break;

                default:
                    throw new Exception($"Unknown type variant {parsedData.Types[i].GetType().Name}");
                }

                codeGenTypes[i] = codeGenType;
            }

            return(new CodeGenData(parsedData.Namespace, codeGenTypes));
        }
Esempio n. 2
0
        private static CodeGenEnum HandleEnum(ParsedEnum pdEnum, IDictionary <string, TypeMemoryInfo> typesMemInfo)
        {
            if (!typesMemInfo.TryGetValue(pdEnum.UnderlyingType, out var memInfo))
            {
                throw new Exception($"Invalid base type `{pdEnum.UnderlyingType}` of enum `{pdEnum.Name}`");
            }

            var items = new CodeGenEnumItem[pdEnum.Items.Length];

            for (var i = 0; i < items.Length; i++)
            {
                items[i] = new CodeGenEnumItem(pdEnum.Items[i].Name, pdEnum.Items[i].Value);
            }

            var defaultValue = DefaultValueInfo.AssignTypeMember(pdEnum.Items[0].Name);

            typesMemInfo.Add(pdEnum.Name, new TypeMemoryInfo(memInfo.Size, memInfo.Size, defaultValue));

            return(new CodeGenEnum(pdEnum.Name, memInfo.Size, pdEnum.UnderlyingType, pdEnum.IsFlags, items));
        }