Example #1
0
        private static DiscoveredPeripheral.Register[] TranslateStructureFieldsToRegisters(ParsedStructure obj, ParsedHeaderFile parsedFile)
        {
            ConstructedRegisterList    lst = new ConstructedRegisterList();
            RegisterTranslationContext ctx = new RegisterTranslationContext();

            lst.TranslateStructureFieldsToRegistersRecursively(obj, parsedFile, ref ctx, "");
            return(lst.Complete());
        }
Example #2
0
            public void TranslateStructureFieldsToRegistersRecursively(ParsedStructure obj, ParsedHeaderFile parsedFile, ref RegisterTranslationContext ctx, string prefix)
            {
                foreach (var field in obj.Entries)
                {
                    var type = field.Type
                               .Where(t => t.Type == CppTokenizer.TokenType.Identifier)
                               .Select(t => t.Value)
                               .Where(t => t != "__IO" && t != "__I" && t != "__IM" && t != "__O" && t != "const")
                               .ToArray();

                    bool isReadOnly = field.Type.Count(t => t.Value == "__I" || t.Value == "const") > 0;

                    if (type.Length > 1)
                    {
                        throw new Exception("Could not reduce register type to a single token: " + string.Join("", type));
                    }

                    int size;

                    switch (type[0])
                    {
                    case "int32_t":
                    case "uint32_t":
                        size = 4;
                        break;

                    case "int16_t":
                    case "uint16_t":
                        size = 2;
                        break;

                    case "int8_t":
                    case "uint8_t":
                        size = 1;
                        break;

                    case "RSSLIB_S_CloseExitHDP_TypeDef":       //Actually a function pointer
                        size = 4;
                        break;

                    default:
                        for (int i = 0; i < field.ArraySize; i++)
                        {
                            string extraPrefix;
                            if (field.ArraySize == 1)
                            {
                                extraPrefix = $"{field.Name}.";
                            }
                            else
                            {
                                extraPrefix = $"{field.Name}[{i}].";
                            }

                            TranslateStructureFieldsToRegistersRecursively(parsedFile.Structures[type[0]], parsedFile, ref ctx, prefix + extraPrefix);
                        }
                        continue;
                    }

                    if ((ctx.CurrentOffset % size) != 0)
                    {
                        ctx.CurrentOffset += (size - (ctx.CurrentOffset % size));
                    }

                    for (int i = 0; i < field.ArraySize; i++)
                    {
                        string nameSuffix = "";
                        if (field.ArraySize > 1)
                        {
                            nameSuffix = $"[{i}]";
                        }

                        if (!field.Name.StartsWith("RESERVED", StringComparison.InvariantCultureIgnoreCase))
                        {
                            _Registers.Add(new DiscoveredPeripheral.Register
                            {
                                Offset         = (uint)ctx.CurrentOffset,
                                Name           = prefix + field.Name + nameSuffix,
                                SizeInBytes    = size,
                                IsReadOnly     = isReadOnly,
                                OriginalField  = field,
                                ZeroBasedIndex = i,
                            });
                        }

                        ctx.CurrentOffset += size;
                    }
                }
            }