Structure Dumper Generator

#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include <stdbool.h>

// Ref struct
/*
typedef struct
{
    uint32_t VersionID;
    uint8_t KeyID[16];
    uint8_t CertifyingKeyID[16];
    uint32_t KeyUsageFlag;
    uint8_t PlatformBindingInfo;
    uint8_t Reserved[15];
    uint32_t PublicExponentSize;
    uint32_t ModulusSize;
    PSPRSAKey RSAKeyData;
} PSPRSAKeyHdr;
* */

const char Structure[] =
"typedef struct\n"
"{\n"
"   uint32_t VersionID;\n"
"   uint8_t KeyID[16];\n"
"   uint8_t CertifyingKeyID[16];\n"
"   uint32_t KeyUsageFlag;\n"
"   uint8_t PlatformBindingInfo;\n"
"   uint8_t Reserved[15];\n"
"   uint32_t PublicExponentSize;\n"
"   uint32_t ModulusSize;\n"
"   PSPRSAKey RSAKeyData;\n"
"} PSPRSAKeyHdr;\n";

typedef struct StructMember_s
{
    char *TypeStr;
    char *NameStr;
    uint32_t TypeSize;
    uint32_t ArraySize;
    struct StructMember_s *next;
} StructMember;

char *CarveStr(const char *Src, size_t StartOffset, size_t Len)
{
    //char *TmpBuf = (char *)malloc(sizeof(char) * (Len + 1));
    char TmpBuf[256];
    char *Output;

    memcpy(TmpBuf, Src + StartOffset, Len);
    TmpBuf[Len] = 0x00;
    Output = strdup(TmpBuf);
    //free(TmpBuf);

    return(Output);
}

int main(int argc, char **argv)
{
    //char *inputstruct = Structure;
    StructMember *MemberList = NULL;

    if(argc != 2)
    {
        printf("Usage: %s <structure definition>\n", argv[0]);
        return(-1);
    }

    char *inputstruct = (char *)malloc(strlen(argv[1]) + 1);
    strcpy(inputstruct, argv[1]);

    for(char *line = strtok(inputstruct, "\n"); line; line = strtok(NULL, "\n"))
    {
        StructMember *memb = MemberList;

        // If the line does not have a semicolon, it can be
        // safely ignored.
        if(!strchr(line, ';'))
            continue;

        // First, is this really a type?
        uint32_t SizeOfType;
        char *NamePos, *NameEnd, *TypePos, *TypeEnd, *ArrStart, *ArrEnd;

        TypePos = strstr(line, "uint");

        if(TypePos)
        {
            // Is it uint8_t? If so, stash the info in variables
            if(TypePos[4] == '8' && TypePos[5] == '_' && TypePos[6] == 't')
            {
                NamePos = TypePos + strlen("uint8_t");
                SizeOfType = 1;
            }
            // Is it uint16_t? Same deal.
            else if(TypePos[4] == '1' && TypePos[5] == '6' && TypePos[6] == '_' && TypePos[7] == 't')
            {
                NamePos = TypePos + strlen("uint16_t");
                SizeOfType = 2;
            }
            // Same for uint32_t...
            else if(TypePos[4] == '3' && TypePos[5] == '2' && TypePos[6] == '_' && TypePos[7] == 't')
            {
                NamePos = TypePos + strlen("uint32_t");
                SizeOfType = 4;
            }
            // Ditto for uint64_t.
            else if(TypePos[4] == '6' && TypePos[5] == '4' && TypePos[6] == '_' && TypePos[7] == 't')
            {
                NamePos = TypePos + strlen("uint64_t");
                SizeOfType = 8;
            }

            if(!memb) MemberList = memb = (StructMember *)malloc(sizeof(StructMember));
            else
            {
                //  Skip all previous members
                for(memb = MemberList; memb->next; memb = memb->next);

                memb = memb->next = (StructMember *)malloc(sizeof(StructMember));
            }

            memset(memb, 0x00, sizeof(StructMember));
            TypeEnd = TypePos;

            while(!isspace(*TypeEnd)) TypeEnd++;

            //printf("TypeEnd = %s\nTypePos = %s\n", TypeEnd, TypePos);
            NamePos = TypeEnd + 1;
            NameEnd = strchr(NamePos, ';') - 1;

            if(!NameEnd)
            {
                printf("Error: Malformed line %s\n", line);
                exit(1);
            }

            memb->TypeStr = CarveStr(TypePos, 0x00, (SizeOfType == 1) ? 7 : 8);
            memb->NameStr = CarveStr(NamePos, 0x00, NameEnd - NamePos + 1);
            memb->TypeSize = SizeOfType;

            // Is it an array?
            ArrStart = strchr(memb->NameStr, '[');

            // If so, get the size.
            if(ArrStart)
            {
                ArrEnd = strchr(memb->NameStr, ']');
                memb->ArraySize = strtoul(ArrStart + 1, NULL, 0);
                // Cut the array notation off the name.
                ArrStart[0] = 0x00;
            }

            memb->next = NULL;
        }
        else
        {
            printf("Warning: Line not recognized: '%s'\n", line);
        }
    }

    // Info harvested; time to generate code.
    for(StructMember *CurMemb = MemberList; CurMemb; CurMemb = CurMemb->next)
    {
        char *TypeSpecifier = NULL;

        //printf("TypeStr = %s\nNameStr = %s\nArraySize = %d\n", CurMemb->TypeStr, CurMemb->NameStr, CurMemb->ArraySize);

        if(CurMemb->TypeSize == 1) TypeSpecifier = "0x%02X";
        else if(CurMemb->TypeSize == 2) TypeSpecifier = "0x%04X";
        else if(CurMemb->TypeSize == 4) TypeSpecifier = "0x%08X";
        else if(CurMemb->TypeSize == 8) TypeSpecifier = "0x%016llX";
        else printf("How did you even get here?");

        printf("printf(\"%s: ", CurMemb->NameStr);

        if(CurMemb->ArraySize)
        {
            printf("\");\n");
            printf("\nfor(int i = 0; i < %d; ++i)\n", CurMemb->ArraySize);
            printf("\tprintf(\"%s, \", dmp->%s[i]);\n\n", TypeSpecifier, CurMemb->NameStr);
            printf("putchar('\\n');\n");
        }
        else
        {
            printf("%s\\n\", dmp->%s);\n", TypeSpecifier, CurMemb->NameStr);
        }
    }



    return(0);
}