Meh OBJ parser

struct ObjLexNode
{
    enum NodeType { None, Vertex, Normal, TextureUV, Face, Group, ObjectName } Type;
    union UData
    {
        struct Face_lex
        {
            bool Quad;
            struct Face_part_lex
            {
                unsigned int VertID;
                unsigned int TextureCordsID;
                unsigned int NormID;
            } Part1, Part2, Part3, Part4;
        } Face;
        struct Vertex_lex
        {
            double X, Y, Z;
        } Vertex;
        struct Normal_lex
        {
            double X, Y, Z;
        } Normal;
        struct TextureCord_lex
        {
            double U, V, W;
        } TextureCord;
    } Data;
};

void LexObj(const char* pContents, std::list<ObjLexNode*>& out)
{
    unsigned int len = strlen(pContents);
    unsigned int i;

    function<void(void)> ReadToNewLine = [&]()
    {
        while(i < len)
        {
            char x = pContents[i];
            if(x == '\n')
                return;
            i++;
        }
    };

    function<void(void)> ReadToNoneSpace = [&]()
    {
        while(i < len)
        {
            char x = pContents[i];
            if(x != ' ' && x != '\t')
                return;
            i++;
        }
    };

    function<bool(const char*)> Peak = [&](const char* pStr) -> bool
    {
        size_t len2 = strlen(pStr);
        for(size_t n = 0; n < len2; n++)
            if(n + i >= len || pStr[n] != pContents[i+n])
                return false;
        return true;
    };

    function<bool(void)> PeakIsNumber = [&]() -> bool
    {
        char pc = pContents[i];
        return pc == '-' || (pc >= 48 && pc <= 57);
    };

    function<bool(double&)> ReadDouble = [&](double& out) -> bool
    {
        stringstream ss;
        bool wrotesome = false;

        while(i < len)
        {
            char x = pContents[i];

            if( (x >= 48 && x <= 57) || x == '.' || x == '-' )
            {
                ss << x;
                wrotesome = true;
            }else break;

            i++;
        }

        out = 0.0;
        if(wrotesome)
            ss >> out;

        return wrotesome;
    };

    function<bool(int&)> ReadInt = [&](int& out) -> bool
    {
        stringstream ss;
        bool wrotesome = false;

        while(i < len)
        {
            char x = pContents[i];

            if( x >= 48 && x <= 57 )
            {
                ss << x;
                wrotesome = true;
            }else break;

            i++;
        }

        if(wrotesome)
            ss >> out;

        return wrotesome;
    };

    function<bool(void)> HandelVert = [&]() -> bool
    {
        double x,y,z;
        i++;
        ReadToNoneSpace();
        if(!ReadDouble(x))
            return false;
        ReadToNoneSpace();
        if(!ReadDouble(y))
            return false;
        ReadToNoneSpace();
        if(!ReadDouble(z))
            return false;

        ObjLexNode* node = new ObjLexNode;
        node->Type = node->Vertex;
        node->Data.Vertex.X = x;
        node->Data.Vertex.Y = y;
        node->Data.Vertex.Z = z;
        out.push_back(node);
    };

    function<bool(void)> HandelNorm = [&]() -> bool
    {
        double x,y,z;
        i++;
        ReadToNoneSpace();
        if(!ReadDouble(x))
            return false;
        ReadToNoneSpace();
        if(!ReadDouble(y))
            return false;
        ReadToNoneSpace();
        if(!ReadDouble(z))
            return false;

        ObjLexNode* node = new ObjLexNode;
        node->Type = node->Normal;
        node->Data.Normal.X = x;
        node->Data.Normal.Y = y;
        node->Data.Normal.Z = z;
        out.push_back(node);
    };

    function<bool(void)> HandelTextCord = [&]() -> bool
    {
        double u,v,w;
        i++;
        ReadToNoneSpace();
        if(!ReadDouble(u))
            return false;
        ReadToNoneSpace();
        ReadDouble(v);
        ReadToNoneSpace();
        ReadDouble(w);

        ObjLexNode* node = new ObjLexNode;
        node->Type = node->TextureUV;
        node->Data.TextureCord.U = u;
        node->Data.TextureCord.V = v;
        node->Data.TextureCord.W = w;
        out.push_back(node);
    };

    function<bool(void)> HandelFace = [&]() -> bool
    {
        i++;
        int v1_lvl = 1, v2_lvl = 1, v3_lvl = 1, v4_lvl = 1;
        int v1 = 0, v1tc = 0, v1n = 0, // Vertex 1, Vert1 text cord, vert 1 normal
            v2 = 0, v2tc = 0, v2n = 0,
            v3 = 0, v3tc = 0, v3n = 0,
            v4 = 0, v4tc = 0, v4n = 0;
        ReadToNoneSpace();

        // Vert 1
        if(!ReadInt(v1))
            return false;
        if(Peak("/"))
        {
            v1_lvl++;
            if(!ReadInt(v1tc)) return false;
            if(Peak("/"))
            {
                if(!ReadInt(v1n)) return false;
                v1_lvl++;
            }
        }
        ReadToNoneSpace();

        //Vert 2
        if(!ReadInt(v2))
            return false;
        if(Peak("/"))
        {
            v2_lvl++;
            if(!ReadInt(v2tc)) return false;
            if(Peak("/"))
            {
                if(!ReadInt(v2n)) return false;
                v2_lvl++;
            }
        }
        ReadToNoneSpace();

        //Vert 3
        if(!ReadInt(v3))
            return false;
        if(Peak("/"))
        {
            v3_lvl++;
            if(!ReadInt(v3tc)) return false;
            if(Peak("/"))
            {
                ReadInt(v3n);
                v3_lvl++;
            }
        }
        ReadToNoneSpace();

        bool isquad = false;

        // Vert 4?
        if(PeakIsNumber()) // Is a number present
        {
            isquad = true;

            // Read vert4
            if(!ReadInt(v4))
                return false;
            if(Peak("/"))
            {
                v4_lvl++;
                if(!ReadInt(v4tc)) return false;
                if(Peak("/"))
                {
                    ReadInt(v4n);
                    v4_lvl++;
                }
            }
            ReadToNoneSpace();
        }

        ObjLexNode* node = new ObjLexNode;
        node->Data.Face.Quad = isquad;

        node->Type = node->Face;
        node->Data.Face.Part1.VertID = v1;
        node->Data.Face.Part1.TextureCordsID = v1tc;
        node->Data.Face.Part1.NormID = v1n;

        node->Data.Face.Part2.VertID = v2;
        node->Data.Face.Part2.TextureCordsID = v2tc;
        node->Data.Face.Part2.NormID = v2n;

        node->Data.Face.Part3.VertID = v3;
        node->Data.Face.Part3.TextureCordsID = v3tc;
        node->Data.Face.Part3.NormID = v3n;

        node->Data.Face.Part4.VertID = v4;
        node->Data.Face.Part4.TextureCordsID = v4tc;
        node->Data.Face.Part4.NormID = v4n;

        out.push_back(node);

        return true;
    };

    for(i = 0; i < len; i++)
    {
        char x = pContents[i];

        if(x == '#')
            ReadToNewLine();

        ReadToNoneSpace();

        if(Peak("v "))
            HandelVert();
        else if(Peak("f "))
            HandelFace();
        else if(Peak("vn "))
            HandelNorm();
        else if(Peak("vt "))
            HandelTextCord();
    }
}

int main()
{
    CFileSystem fs;

    ifstream ifs(fs.GetModel("teapot.obj"));

    char* inf;
    ifs.seekg(0, ios::end);
    size_t length = ifs.tellg();
    ifs.seekg(0, ios::beg);

    inf = new char[length];
    ifs.read(inf, length);

    list<ObjLexNode*> lexed;

    LexObj(inf, lexed);

    cout << "Found nodes:" << lexed.size() << '\n';

    delete [] inf;
    // delete node shit too
    return 0;
}