найти ошибки в коде

#include "lexicalanalyzer.h"
#include <sstream>
 
string toStr(int i){//число в строку
    stringstream ss;//через строковый поток
    string s;
    ss << i;//в поток число
    s= ss.str();//содержимое как строка
    return s;
    }
 
LexicalAnalyzer::LexicalAnalyzer(){
    null.insert(' ');
    null.insert('\0');
    null.insert('\t');
    null.insert('\n');
    insertChars(letters, "_ABCDFGHIJKLMNOPQRSTUVWXYZabcdfghijklmnopqrstuvwxyz");
    insertChars(expLetters, "eE");
    insertChars(numerals, "123456789");
    keywords.insert("function");
    keywords.insert("end");
    keywords.insert("program");
    keywords.insert("stop");
    keywords.insert("endprogram");
    keywords.insert("do");//объединяется при лекс. разборе
    keywords.insert("while");//объединяется при лекс. разборе
    keywords.insert("dowhile");
    keywords.insert("exit");
    keywords.insert("enddo");
    keywords.insert("if");
    keywords.insert("then");
    keywords.insert("else");
    keywords.insert("endif");
    keywords.insert("implicit");//объединяется при лекс. разборе
    keywords.insert("none");//объединяется при лекс. разборе
    keywords.insert("implicitnone");
    keywords.insert("parameter");
 
    keywords.insert("read");
    keywords.insert("print");
 
    types.insert("real");
    types.insert("integer");
 
    inlinefuncs.insert("sin");
    inlinefuncs.insert("cos");
    inlinefuncs.insert("mod");
    inlinefuncs.insert("abs");
    inlinefuncs.insert("sqrt");
    inlinefuncs.insert("cmplx");//*/
 
    blocks.insert("program");
    blocks.insert("do");
    blocks.insert("if");
 
    logicwords.insert(".true.");
 
    logicsigns.insert("<");
    logicsigns.insert(">");
    logicsigns.insert("<=");
    logicsigns.insert(">=");
    logicsigns.insert("==");
 
    signs.insert("=");
    signs.insert("::");
    signs.insert("(");
    signs.insert(")");
    signs.insert("+");
    signs.insert("-");
    signs.insert("*");
    signs.insert("/");
    signs.insert("**");
    signs.insert(",");
 
    string opChars= "+-*/=:<>;,)(.";//знаки операторов
    insertChars(opsigns, opChars);
    opsigns.insert('\'');
    opsigns.insert('"');
    int PrepOuts[COUNT_STATE][COUNT_SYMBOL] = {//выходные сообщения:
       //  a 9 0  + - * /  = : < >  ; , ) (  . ' " e
        {1,1,1,1, 1,1,1,1, 1,1,1,1, 1,1,1,1, 1,1,1,1},//Space
        {2,1,1,1, 2,2,2,2, 2,2,2,2, 2,2,2,2, 2,0,0,1},//2: 'a-Z'
        {3,0,1,1, 3,3,3,3, 3,0,3,3, 3,3,3,0, 1,0,0,0},//3: '1-9'
        {3,0,0,0, 3,3,3,3, 3,0,3,3, 3,3,3,0, 1,0,0,0},//'0'
 
        {4,4,4,4, 0,4,0,0, 0,0,0,0, 0,0,0,4, 0,0,0,4},//4: '+,-,/'
        {4,4,4,4, 0,4,0,0, 1,0,0,0, 0,0,0,4, 1,0,0,4},//'='
        {0,0,0,0, 0,0,0,0, 0,1,0,0, 0,0,0,0, 0,0,0,0},//':'
        {4,4,4,4, 0,4,0,0, 1,0,0,0, 0,0,0,4, 0,0,0,4},//'<'
 
        {4,4,4,4, 0,4,0,0, 1,0,0,0, 0,0,0,4, 0,0,0,4},//'>'
        {4,4,4,4, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,4},//';'
        {4,4,4,4, 0,0,1,0, 0,0,0,0, 0,0,0,0, 4,4,4,4},//','
        {4,4,4,4, 4,4,4,4, 4,0,4,4, 4,4,4,0, 4,0,0,4},//')'
 
        {4,4,4,4, 0,4,4,0, 0,0,0,0, 0,0,4,4, 4,4,4,4},//'('
        {7,0,1,1, 7,7,7,7, 7,0,7,7, 7,7,7,0, 0,0,0,1},//7: real
        {5,5,5,5, 0,5,0,0, 0,0,0,0, 0,0,0,5, 5,0,0,5},//5: Dsign
        {1,1,1,1, 1,1,1,1, 1,1,1,1, 1,1,1,1, 1,6,1,1},//6: Literal in ''
 
        {1,1,1,1, 1,1,1,1, 1,1,1,1, 1,1,1,1, 1,1,6,1},//Literal in ""
        {0,0,0,0, 1,1,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0},//_preexp
        {7,0,1,1, 7,7,7,7, 7,0,7,7, 7,7,7,0, 0,0,0,0},//_exp
        {0,1,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 1,0,0,1},//8: _logic
 
        {8,8,0,0, 0,0,0,0, 8,0,0,0, 8,8,8,8, 0,0,0,8},//_endlogic
        {4,4,4,4, 0,4,1,0, 0,0,0,0, 0,4,4,4, 0,0,0,4},//4: '*'
        };
    Statement DefSt[COUNT_SYMBOL]= {//переходы по умолчанию после указанных в комментариях знаков:
        _Space,     //null - разделители
        _aZ,        //letters - буквы
        _19,        //1-9
        _0,         //0
 
        _arifm,     //+
        _arifm,     //-
        _mul,       //*
        _arifm,     //'/'
 
        _eq,        //=
        _colon,     //:
        _less,      //<
        _gr,        //>
 
        _semicolon, //;
        _comma,     //,
        _close,     //)
        _open,      //(
 
        _logic,     //.
        _lit,       //'
        _lit2,      //"
        _aZ         //eE
        };
    Statement PrepSt[COUNT_STATE][COUNT_SYMBOL];//выходные состояния
    for(int i= 0; i<COUNT_STATE; i++)//заполнение по умолчанию:
        for(int j= 0; j<COUNT_SYMBOL; j++)
            PrepSt[i][j]= DefSt[j];
    PrepSt[1][2]= _aZ;//'a-Z'
    PrepSt[1][3]= _aZ;
    PrepSt[2][3]= _19;//0 после 1-9
 
    PrepSt[2][16]= _real;
    PrepSt[3][16]= _real;
    PrepSt[13][2]= _real;//real
    PrepSt[13][3]= _real;
    PrepSt[13][19]=_preexp;
    PrepSt[17][4]= _exp;//preexp
    PrepSt[17][5]= _exp;
    PrepSt[18][2]= _exp;//exp
    PrepSt[18][3]= _exp;
 
    PrepSt[19][1]= _logic;
    PrepSt[19][19]=_logic;
    PrepSt[19][16]=_endlogic;
 
    PrepSt[5][8]= _dsign;//'=='
    PrepSt[6][9]= _dsign;//'::'
    PrepSt[7][8]= _dsign;//'<='
    PrepSt[8][8]= _dsign;//'>='
    PrepSt[21][6]=_dsign;//'**'
    for(int j= 0; j<COUNT_SYMBOL; j++) PrepSt[15][j]= _lit;//Literal in ''
    PrepSt[15][17]= _Space;
    for(int j= 0; j<COUNT_SYMBOL; j++) PrepSt[16][j]= _lit2;//Literal in ""
    PrepSt[16][18]= _Space;
    Output out[COUNT_STATE][COUNT_SYMBOL];
    for(int i= 0; i<COUNT_STATE; i++)//матрица выходов:
        for(int j= 0; j<COUNT_SYMBOL; j++)
            out[i][j]= Output(PrepOuts[i][j],PrepSt[i][j]);//сигналы и новые состояния
 
    for(int i= 0; i<COUNT_STATE; i++){//заполнение таблицы перехода состояний:
        for (set<char>::iterator it= null.begin(); it!=null.end(); it++)
            tableState[Input((*it), Statement(i))]= out[i][0];
        for (set<char>::iterator it= letters.begin(); it!=letters.end(); it++)
            tableState[Input((*it), Statement(i))]= out[i][1];
        for (set<char>::iterator it= numerals.begin(); it!=numerals.end(); it++)
            tableState[Input((*it), Statement(i))]= out[i][2];
        tableState[Input('0', Statement(i))]= out[i][3];
        for(int j= 4; j<17; j++) tableState[Input(opChars[j-4], Statement(i))]= out[i][j];
        tableState[Input('\'', Statement(i))]= out[i][17];//апостроф
        tableState[Input('"', Statement(i))]= out[i][18];//кавычка
        for (set<char>::iterator it= expLetters.begin(); it!=expLetters.end(); it++)
            tableState[Input((*it), Statement(i))]= out[i][19];
        }
    }
 
void LexicalAnalyzer::split(ifstream &file){//формирование ряда лексем
    curnum= 0;
    int line= 1;
    Token token;//лексема
    string lexeme;//значение
    string textprog;//исходный текстe
    Input in;//входная пара
    Output out;//выходная пара
    Statement curState= _Space; //начальное состояние
    char sym; //знак
 
    while(file.peek() != -1){//по есть знаки
        file.get(sym);//считываем их
        textprog.push_back(sym);//добавляя в строку
        }
    textprog.push_back(' ');//пробел в конец
 
    for(int i= 0;i<textprog.length();i++){//проходим по строке:
        sym= textprog.at(i);//смотрим тек. знак
        if(sym=='\n')//считаем строки
            line++;
        if(!isalnum(sym)&&!(sym=='_')&&!contains<char>(sym,opsigns)&&!isspace(sym)){//если непонятный знак
            if(curState==_lit || curState==_lit2) lexeme.push_back(sym);
            else throw LexErr("Line: "+ toStr(line) +". Unknown symbol \'"+sym+"\'");//сообщаем
 
            }
        else{
            token.value.clear();//очищаем тек. значения:
            token.type.clear();
            in.first= sym;//берем знак
            in.second= curState;//и тек. состояние
            out= tableState.at(in);//и узнаём, куда перешли
            curState= out.second;//получая новое состояние
            if(out.first > 1){
                switch(out.first){//смотрим выходное сообщение:
                    case 2:
                        std::transform(lexeme.begin(), lexeme.end(), lexeme.begin(), ::tolower);
                        if(isKey(lexeme)){
                            token.type= "key";//если нашли ключевое слово
                            if(tokens.size()>0){
                                if(isBlock(lexeme) && tokens.back().isKey("end")){//объединение
                                    tokens.pop_back();//удаление последнего end
                                    lexeme= "end"+lexeme;//нужное название
                                    }
                                else if(lexeme=="none" && tokens.back().isKey("implicit")){//объединение
                                    tokens.pop_back();//удаление последнего
                                    lexeme= "implicitnone";//нужное название
                                    }
                                else if(lexeme=="while" && tokens.back().isKey("do")){//объединение
                                    tokens.pop_back();//удаление последнего
                                    lexeme= "dowhile";//нужное название
                                    }
                                }
                            }
                        else token.type= "ident";//иначе - идентификатор:
                        break;
                    case 3:
                        token.type= "int"; //если нашли число
                        break;
                        //4-5 - одно- и двузнаковые операторы
                    case 6:
                        token.type= "lit"; //если нашли строковую константу
                        break;
                    case 7:
                        token.type= "real"; //если нашли строковую константу
                        break;
                    case 8:
                        std::transform(lexeme.begin(), lexeme.end(), lexeme.begin(), ::tolower);
                        if(contains<string>(lexeme,logicwords)) token.type= "logic";//если нашли слово
                        else throw LexErr("Line: "+ toStr(line) +". Unknown token: "+lexeme);
 
                        break;
                    default:
                        if(out.first==4 && lexeme==";"){
                            token.type= "split";
                            if(tokens.size()>0 && tokens.back().isSplit()) tokens.pop_back();
                            }
                        else if(isSign(lexeme)) token.type= "sign";
                        else throw LexErr("Line: "+ toStr(line) +". Unknown sign: "+lexeme);
 
                    }
                token.value= lexeme;//берем значение
                tokens.push_back(token);//добавляем лексему в ряд
                lexeme.clear();//и очищаем
                }
            else if(out.first == 0) throw LexErr("Line: "+ toStr(line) +". Unknown expression: "+lexeme);//иначе если ошибка:
 
            if((out.second != _Space) && !(((sym=='\'') && (out.second==_lit)) || ((sym=='"') && (out.second==_lit2)))) lexeme.push_back(sym);//если не начальное состояние - добавляем знак к тек. лексеме
            if(out.second==_Space && sym=='\n' && tokens.size()>0 && !tokens.back().isSplit()){//добавляем разделитель выражений:
                token.value= "nl";//новая строка
                token.type= "split";
                tokens.push_back(token);//добавляем лексему в ряд
                }
            }
        }
    if(tokens.back().type!="split"){
        token.value= "nl";//новая строка
        token.type= "split";
        tokens.push_back(token);//добавляем лексему в ряд
        }
    }
 
Token LexicalAnalyzer::Next(){//получение очередной лексемы из ряда
    curnum++;//переходим на след.
    if(curnum < tokens.size()) stToken= tokens.at(curnum);//если естьберём
    else stToken.type= "";//иначе пустая
    return stToken;//возвращаем
    }
 
void LexicalAnalyzer::insertChars(CharSet &charSet, string chars){
    int l= chars.size();//длина строки
    for(int i= 0; i<l; i++) charSet.insert(chars[i]); //проход по строке с добавлением каждого знака во множество
    }
 
bool LexicalAnalyzer::isInlineFunc(string s){
    return contains<string>(s,inlinefuncs);
    }
bool LexicalAnalyzer::isType(string s){
    return contains<string>(s,types);
    }
bool LexicalAnalyzer::isBlock(string s){
    return contains<string>(s,blocks);
    }
bool LexicalAnalyzer::isKey(string s){
    return /*isInlineFunc(s) ||//*/ isType(s) || isBlock(s) || contains<string>(s,keywords);
    }
bool LexicalAnalyzer::isLogicSign(string s){
    return contains<string>(s,logicsigns);
    }
bool LexicalAnalyzer::isSign(string s){
    return isLogicSign(s) || contains<string>(s,signs);
    }