To this

bool CConfigor::LoadFromString(char* Input, unsigned long Length)
{
    CConfigerLexNodeList lexed = Lexify(Input, Length);

    m_CurrentParseLine = 1;

    IConfigorNode* pCurrentNode = GetRootNode();
    IConfigorNode* pNewNode = 0;

    for(auto it = lexed.begin(); it != lexed.end(); it++)
    {
        CConfigerLexNode* node = *it;
        switch(node->Type)
        {
        case ConfigorLexType::NewLine:
            m_CurrentParseLine++;
            break;
        case ConfigorLexType::None:
            {
                string err = *(string*)&node->Value;
                m_Error = err;
                return false;
            }
            break;
        case ConfigorLexType::String:
            {
                auto it2 = it;
                it2++;

                char* pName = (char*)node->Value;
                unsigned long mLength = node->Length;
                unsigned char* pData = 0;
                unsigned long dLength = 0;

                if(it2 != lexed.end() || (*it2)->Type == ConfigorLexType::String)
                {
                    it++;
                    pData = (unsigned char*)(*it2)->Value;
                    dLength = (*it2)->Length;
                }

                IConfigorNode* node = new CConfigorNode(pCurrentNode, string(pName, mLength), pData, dLength);
                pNewNode = node;
            }
            break;
        case ConfigorLexType::Token:
            {
                char Token = (char)node->Value;

                switch(Token)
                {
                case '{':
                    {
                        if(!pNewNode) // We don't have a node to asign to!
                        {
                            stringstream ss;
                            ss << m_CurrentParseLine;
                            m_Error = "Node expected to group near line " + ss.str();
                            return false;
                        }
                        pCurrentNode = pNewNode;
                        pNewNode = 0;
                    }
                    break;
                case '}':
                    {
                        pCurrentNode = pCurrentNode->GetParent();
                        if(!pCurrentNode) // One too many }'s
                        {
                            stringstream ss;
                            ss << m_CurrentParseLine;
                            m_Error = "EOF expected near line " + ss.str();
                            return false;
                        }
                        pNewNode = 0;
                    }
                    break;
                default:
                    m_Error = "Unexpected token " + Token;
                }
            }
            break;
        }
    }

    return true;
}