template<typename T> struct alignment_trick { char c; T member; };
#define ALIGNOF(type) offsetof (alignment_trick<type>, member)
#define PADDING(x, y) ((ALIGNOF(y) - ((uintptr_t)(x) & (ALIGNOF(y) - 1))) & (ALIGNOF(y) - 1))

    void *getStruct(std::string &name, std::string format, size_t len)
    {
        std::vector<std::string *> strs_alloced;
        std::string *str;
        char *s = &(get(name))[0];
        char *buf = new char[len];
        char *bufpos = buf;
        char *f, *snext;
        size_t pos;

        char *fmt = &format[0];
        while ((f = strsep(&fmt, ",")) && s) {
            bool is_unsigned = false;
            int width = 0;
            char valtype = *f;

            width = (int)strtol(f + 1, &f, 10);
            if (width && valtype == 's')
                valtype = 'i';

            switch (*f) {
                case 'u':
                    is_unsigned = true;
                    /* FALLTHROUGH */
                case 'i':
                    if (width == 16) {
                        bufpos += PADDING(bufpos, u16);
                        if ((bufpos - buf) + sizeof(u16) <= len) {
                            if (is_unsigned)
                                *(u16 *)bufpos = (u16)strtoul(s, &s, 10);
                            else
                                *(s16 *)bufpos = (s16)strtol(s, &s, 10);
                        }
                        bufpos += sizeof(u16);
                    } else if (width == 32) {
                        bufpos += PADDING(bufpos, u32);
                        if ((bufpos - buf) + sizeof(u32) <= len) {
                            if (is_unsigned)
                                *(u32 *)bufpos = (u32)strtoul(s, &s, 10);
                            else
                                *(s32 *)bufpos = (s32)strtol(s, &s, 10);
                        }
                        bufpos += sizeof(u32);
                    } else if (width == 64) {
                        bufpos += PADDING(bufpos, u64);
                        if ((bufpos - buf) + sizeof(u64) <= len) {
                            if (is_unsigned)
                                *(u64 *)bufpos = (u64)strtoull(s, &s, 10);
                            else
                                *(s64 *)bufpos = (s64)strtoll(s, &s, 10);
                        }
                        bufpos += sizeof(u64);
                    }
                    s = strchr(s, ',');
                    break;
                case 'b':
                    snext = strchr(s, ',');
                    if (snext)
                        *snext++ = 0;

                    bufpos += PADDING(bufpos, bool);
                    if ((bufpos - buf) + sizeof(bool) <= len)
                        *(bool *)bufpos = is_yes(std::string(s));
                    bufpos += sizeof(bool);

                    s = snext;
                    break;
                case 'f':
                    bufpos += PADDING(bufpos, float);
                    if ((bufpos - buf) + sizeof(float) <= len)
                        *(float *)bufpos = strtof(s, &s);
                    bufpos += sizeof(float);

                    s = strchr(s, ',');
                    break;
                case 's':
                    while (*s == ' ' || *s == '\t')
                        s++;
                    if (*s++ != '"') //error, expected string
                        goto fail;
                    snext = s;

                    while (snext[0] && !(snext[-1] != '\\' && snext[0] == '"'))
                        snext++;
                    *snext++ = 0;

                    bufpos += PADDING(bufpos, std::string *);

                    str = new std::string(s);
                    pos = 0;
                    while ((pos = str->find("\\\"", pos)) != std::string::npos)
                        str->erase(pos, 1);

                    if ((bufpos - buf) + sizeof(std::string *) <= len)
                        *(std::string **)bufpos = str;
                    bufpos += sizeof(std::string *);
                    strs_alloced.push_back(str);

                    s = *snext ? snext + 1 : NULL;
                    break;
                case 'v':
                    while (*s == ' ' || *s == '\t')
                        s++;
                    if (*s++ != '(') //error, expected vector
                        goto fail;

                    if (width == 2) {
                        bufpos += PADDING(bufpos, v2f);

                        if ((bufpos - buf) + sizeof(v2f) <= len) {
                        v2f *v = (v2f *)bufpos;
                            v->X = strtof(s, &s);
                            s++;
                            v->Y = strtof(s, &s);
                        }

                        bufpos += sizeof(v2f);
                    } else if (width == 3) {
                        bufpos += PADDING(bufpos, v3f);
                        if ((bufpos - buf) + sizeof(v3f) <= len) {
                            v3f *v = (v3f *)bufpos;
                            v->X = strtof(s, &s);
                            s++;
                            v->Y = strtof(s, &s);
                            s++;
                            v->Z = strtof(s, &s);
                        }

                        bufpos += sizeof(v3f);
                    }
                    s = strchr(s, ',');
            }

            if (s && *s == ',')
                s++;

            if ((bufpos - buf) > len) //error, buffer too small
                goto fail;
        }

        if (f && *f) { //error, mismatched number of fields and values
fail:
            for (int i = 0; i != strs_alloced.size(); i++)
                delete strs_alloced[i];
            delete[] buf;
            buf = NULL;
        }

        return buf;
    }