Ticket #46260: _NscLib__NscParserRoutines.cpp.patch

File _NscLib__NscParserRoutines.cpp.patch, 14.6 KB (added by jmroot (Joshua Root), 10 years ago)

  • _NscLib/NscParserRoutines.cpp

    old new bool NscBuildSyntaxError (int nToken, YY 
    396396
    397397                switch (nToken)
    398398                {
    399                         case IDENTIFIER:
     399                        case yy::parser::token::IDENTIFIER:
    400400                                if (yylval)
    401401                                        pszToken = yylval ->GetIdentifier ();
    402402                                else
    403403                                        pszToken = "identifier";
    404404                                break;
    405405
    406                         case INTEGER_CONST:
     406                        case yy::parser::token::INTEGER_CONST:
    407407                                pszToken = "integer constant";
    408408                                break;
    409409
    410                         case FLOAT_CONST:
     410                        case yy::parser::token::FLOAT_CONST:
    411411                                pszToken = "float constant";
    412412                                break;
    413413
    414                         case STRING_CONST:
     414                        case yy::parser::token::STRING_CONST:
    415415                                pszToken = "string constant";
    416416                                break;
    417417
    418                         case ADDEQ:
     418                        case yy::parser::token::ADDEQ:
    419419                                pszToken = "+=";
    420420                                break;
    421421
    422                         case SUBEQ:
     422                        case yy::parser::token::SUBEQ:
    423423                                pszToken = "-=";
    424424                                break;
    425425
    426                         case MULEQ:
     426                        case yy::parser::token::MULEQ:
    427427                                pszToken = "*=";
    428428                                break;
    429429
    430                         case DIVEQ:
     430                        case yy::parser::token::DIVEQ:
    431431                                pszToken = "/=";
    432432                                break;
    433433
    434                         case MODEQ:
     434                        case yy::parser::token::MODEQ:
    435435                                pszToken = "%=";
    436436                                break;
    437437
    438                         case XOREQ:
     438                        case yy::parser::token::XOREQ:
    439439                                pszToken = "^=";
    440440                                break;
    441441
    442                         case ANDEQ:
     442                        case yy::parser::token::ANDEQ:
    443443                                pszToken = "&=";
    444444                                break;
    445445
    446                         case OREQ:
     446                        case yy::parser::token::OREQ:
    447447                                pszToken = "|=";
    448448                                break;
    449449
    450                         case SL:
     450                        case yy::parser::token::SL:
    451451                                pszToken = "<<";
    452452                                break;
    453453
    454                         case SR:
     454                        case yy::parser::token::SR:
    455455                                pszToken = ">>";
    456456                                break;
    457457
    458                         case USR:
     458                        case yy::parser::token::USR:
    459459                                pszToken = ">>>";
    460460                                break;
    461461
    462                         case SLEQ:
     462                        case yy::parser::token::SLEQ:
    463463                                pszToken = "<<=";
    464464                                break;
    465465
    466                         case SREQ:
     466                        case yy::parser::token::SREQ:
    467467                                pszToken = ">>=";
    468468                                break;
    469469
    470                         case USREQ:
     470                        case yy::parser::token::USREQ:
    471471                                pszToken = ">>>=";
    472472                                break;
    473473
    474                         case EQ:
     474                        case yy::parser::token::EQ:
    475475                                pszToken = "==";
    476476                                break;
    477477
    478                         case NOTEQ:
     478                        case yy::parser::token::NOTEQ:
    479479                                pszToken = "!=";
    480480                                break;
    481481
    482                         case LTEQ:
     482                        case yy::parser::token::LTEQ:
    483483                                pszToken = "<=";
    484484                                break;
    485485
    486                         case GTEQ:
     486                        case yy::parser::token::GTEQ:
    487487                                pszToken = ">=";
    488488                                break;
    489489
    490                         case ANDAND:
     490                        case yy::parser::token::ANDAND:
    491491                                pszToken = "&&";
    492492                                break;
    493493
    494                         case OROR:
     494                        case yy::parser::token::OROR:
    495495                                pszToken = "||";
    496496                                break;
    497497
    498                         case PLUSPLUS:
     498                        case yy::parser::token::PLUSPLUS:
    499499                                pszToken = "++";
    500500                                break;
    501501
    502                         case MINUSMINUS:
     502                        case yy::parser::token::MINUSMINUS:
    503503                                pszToken = "--";
    504504                                break;
    505505
    506                         case FLOAT_TYPE:
     506                        case yy::parser::token::FLOAT_TYPE:
    507507                                pszToken = "float";
    508508                                break;
    509509
    510                         case INT_TYPE:
     510                        case yy::parser::token::INT_TYPE:
    511511                                pszToken = "int";
    512512                                break;
    513513
    514                         case OBJECT_TYPE:
     514                        case yy::parser::token::OBJECT_TYPE:
    515515                                pszToken = "object";
    516516                                break;
    517517
    518                         case STRING_TYPE:
     518                        case yy::parser::token::STRING_TYPE:
    519519                                pszToken = "string";
    520520                                break;
    521521
    522                         case VOID_TYPE:
     522                        case yy::parser::token::VOID_TYPE:
    523523                                pszToken = "void";
    524524                                break;
    525525
    526                         case STRUCT_TYPE:
     526                        case yy::parser::token::STRUCT_TYPE:
    527527                                pszToken = "struct";
    528528                                break;
    529529
    530                         case VECTOR_TYPE:
     530                        case yy::parser::token::VECTOR_TYPE:
    531531                                pszToken = "vector";
    532532                                break;
    533533
    534                         case ENGINE_TYPE:
     534                        case yy::parser::token::ENGINE_TYPE:
    535535                                if (yylval)
    536536                                {
    537537                                        int nIndex = yylval ->GetType () - NscType_Engine_0;
    … … bool NscBuildSyntaxError (int nToken, YY 
    541541                                        pszToken = "engine-type";
    542542                                break;
    543543
    544                         case ACTION_TYPE:
     544                        case yy::parser::token::ACTION_TYPE:
    545545                                pszToken = "action";
    546546                                break;
    547547
    548                         case OBJECT_SELF_CONST:
     548                        case yy::parser::token::OBJECT_SELF_CONST:
    549549                                pszToken = "OBJECT_SELF";
    550550                                break;
    551551
    552                         case OBJECT_INVALID_CONST:
     552                        case yy::parser::token::OBJECT_INVALID_CONST:
    553553                                pszToken = "OBJECT_INVALID";
    554554                                break;
    555555
    556                         case BREAK:
     556                        case yy::parser::token::BREAK:
    557557                                pszToken = "break";
    558558                                break;
    559559
    560                         case CASE:
     560                        case yy::parser::token::CASE:
    561561                                pszToken = "case";
    562562                                break;
    563563
    564                         case CONTINUE:
     564                        case yy::parser::token::CONTINUE:
    565565                                pszToken = "continue";
    566566                                break;
    567567
    568                         case DEFAULT:
     568                        case yy::parser::token::DEFAULT:
    569569                                pszToken = "default";
    570570                                break;
    571571
    572                         case DO:
     572                        case yy::parser::token::DO:
    573573                                pszToken = "do";
    574574                                break;
    575575
    576                         case ELSE:
     576                        case yy::parser::token::ELSE:
    577577                                pszToken = "else";
    578578                                break;
    579579
    580                         case FOR:
     580                        case yy::parser::token::FOR:
    581581                                pszToken = "for";
    582582                                break;
    583583
    584                         case IF:
     584                        case yy::parser::token::IF:
    585585                                pszToken = "if";
    586586                                break;
    587587
    588                         case RETURN:
     588                        case yy::parser::token::RETURN:
    589589                                pszToken = "return";
    590590                                break;
    591591
    592                         case SWITCH:
     592                        case yy::parser::token::SWITCH:
    593593                                pszToken = "switch";
    594594                                break;
    595595
    596                         case WHILE:
     596                        case yy::parser::token::WHILE:
    597597                                pszToken = "while";
    598598                                break;
    599599
    600                         case NWCONST:
     600                        case yy::parser::token::NWCONST:
    601601                                pszToken = "const";
    602602                                break;
    603603
    … … YYSTYPE NscBuildType (int nType, YYSTYPE 
    657657
    658658        switch (nType)
    659659        {
    660                 case VOID_TYPE:
     660                case yy::parser::token::VOID_TYPE:
    661661                        pOut ->SetType (NscType_Void);
    662662                        break;
    663663
    664                 case INT_TYPE:
     664                case yy::parser::token::INT_TYPE:
    665665                        pOut ->SetType (NscType_Integer);
    666666                        break;
    667667
    668                 case FLOAT_TYPE:
     668                case yy::parser::token::FLOAT_TYPE:
    669669                        pOut ->SetType (NscType_Float);
    670670                        break;
    671671
    672                 case OBJECT_TYPE:
     672                case yy::parser::token::OBJECT_TYPE:
    673673                        pOut ->SetType (NscType_Object);
    674674                        break;
    675675
    676                 case STRING_TYPE:
     676                case yy::parser::token::STRING_TYPE:
    677677                        pOut ->SetType (NscType_String);
    678678                        break;
    679679
    680                 case VECTOR_TYPE:
     680                case yy::parser::token::VECTOR_TYPE:
    681681                        pOut ->SetType (NscType_Vector);
    682682                        break;
    683683
    684                 case ACTION_TYPE:
     684                case yy::parser::token::ACTION_TYPE:
    685685                        if (!g_pCtx ->IsNWScript ())
    686686                        {
    687687                                g_pCtx ->GenerateError ("\"action\" identifier only "
    … … YYSTYPE NscBuildType (int nType, YYSTYPE 
    692692                pOut ->SetType (NscType_Action);
    693693                        break;
    694694
    695                 case STRUCT_TYPE:
     695                case yy::parser::token::STRUCT_TYPE:
    696696                        assert (pId != NULL);
    697697                        {
    698698                                if (!g_pCtx ->IsPhase2 () && !g_pCtx ->IsNWScript ())
    … … YYSTYPE NscBuildType (int nType, YYSTYPE 
    723723                        }
    724724                        break;
    725725
    726                 case ENGINE_TYPE:
     726                case yy::parser::token::ENGINE_TYPE:
    727727                        assert (pId != NULL);
    728728                        {
    729729                                pOut ->SetType (pId ->GetType ());
    … … YYSTYPE NscBuildBinaryOp (int nToken, YY 
    29232923                        }
    29242924                        break;
    29252925
    2926                 case SL:
     2926                case yy::parser::token::SL:
    29272927                        if (nLhsType == NscType_Integer && nRhsType == NscType_Integer)
    29282928                        {
    29292929                                if (g_pCtx ->GetOptExpression () &&
    … … YYSTYPE NscBuildBinaryOp (int nToken, YY 
    29482948                        }
    29492949                        break;
    29502950
    2951                 case SR:
     2951                case yy::parser::token::SR:
    29522952                        if (nLhsType == NscType_Integer && nRhsType == NscType_Integer)
    29532953                        {
    29542954#ifdef NOT_ENABLED_YET
    … … YYSTYPE NscBuildBinaryOp (int nToken, YY 
    29752975                        }
    29762976                        break;
    29772977
    2978                 case USR:
     2978                case yy::parser::token::USR:
    29792979                        if (nLhsType == NscType_Integer && nRhsType == NscType_Integer)
    29802980                        {
    29812981#ifdef NOT_ENABLED_YET
    … … YYSTYPE NscBuildBinaryOp (int nToken, YY 
    30863086                        }
    30873087                        break;
    30883088
    3089                 case LTEQ:
     3089                case yy::parser::token::LTEQ:
    30903090                        if (nLhsType == NscType_Integer && nRhsType == NscType_Integer)
    30913091                        {
    30923092                                if (g_pCtx ->GetOptExpression () &&
    … … YYSTYPE NscBuildBinaryOp (int nToken, YY 
    31283128                        }
    31293129                        break;
    31303130
    3131                 case GTEQ:
     3131                case yy::parser::token::GTEQ:
    31323132                        if (nLhsType == NscType_Integer && nRhsType == NscType_Integer)
    31333133                        {
    31343134                                if (g_pCtx ->GetOptExpression () &&
    … … YYSTYPE NscBuildBinaryOp (int nToken, YY 
    31703170                        }
    31713171                        break;
    31723172
    3173                 case EQ:
     3173                case yy::parser::token::EQ:
    31743174                        if (nLhsType == NscType_Integer && nRhsType == NscType_Integer)
    31753175                        {
    31763176                                if (g_pCtx ->GetOptExpression () &&
    … … YYSTYPE NscBuildBinaryOp (int nToken, YY 
    32603260                        }
    32613261                        break;
    32623262
    3263                 case NOTEQ:
     3263                case yy::parser::token::NOTEQ:
    32643264                        if (nLhsType == NscType_Integer && nRhsType == NscType_Integer)
    32653265                        {
    32663266                                if (g_pCtx ->GetOptExpression () &&
    … … YYSTYPE NscBuildBinaryOp (int nToken, YY 
    34403440                        }
    34413441                        break;
    34423442
    3443                 case MULEQ:
     3443                case yy::parser::token::MULEQ:
    34443444                        if (nLhsType == NscType_Vector && nRhsType == NscType_Float)
    34453445                        {
    34463446                                NscPushAssignment (pOut, NscPCode_AsnMultiply,
    … … YYSTYPE NscBuildBinaryOp (int nToken, YY 
    34683468                        }
    34693469                        break;
    34703470
    3471                 case DIVEQ:
     3471                case yy::parser::token::DIVEQ:
    34723472                        if (nLhsType == NscType_Vector && nRhsType == NscType_Float)
    34733473                        {
    34743474                                NscPushAssignment (pOut, NscPCode_AsnDivide,
    … … YYSTYPE NscBuildBinaryOp (int nToken, YY 
    34963496                        }
    34973497                        break;
    34983498
    3499                 case MODEQ:
     3499                case yy::parser::token::MODEQ:
    35003500                        if (nLhsType == NscType_Integer && nRhsType == NscType_Integer)
    35013501                        {
    35023502                                NscPushAssignment (pOut, NscPCode_AsnModulus,
    … … YYSTYPE NscBuildBinaryOp (int nToken, YY 
    35093509                        }
    35103510                        break;
    35113511
    3512                 case ADDEQ:
     3512                case yy::parser::token::ADDEQ:
    35133513                        if (nLhsType == NscType_Vector && nRhsType == NscType_Vector)
    35143514                        {
    35153515                                NscPushAssignment (pOut, NscPCode_AsnAdd,
    … … YYSTYPE NscBuildBinaryOp (int nToken, YY 
    35423542                        }
    35433543                        break;
    35443544
    3545                 case SUBEQ:
     3545                case yy::parser::token::SUBEQ:
    35463546                        if (nLhsType == NscType_Vector && nRhsType == NscType_Vector)
    35473547                        {
    35483548                                NscPushAssignment (pOut, NscPCode_AsnSubtract,
    … … YYSTYPE NscBuildBinaryOp (int nToken, YY 
    35703570                        }
    35713571                        break;
    35723572
    3573                 case SLEQ:
     3573                case yy::parser::token::SLEQ:
    35743574                        pszOp = "<<=";
    35753575                        nOp = NscPCode_AsnShiftLeft;
    35763576asn_shift_operator:;
    … … asn_shift_operator:; 
    35863586                        }
    35873587                        break;
    35883588
    3589                 case SREQ:
     3589                case yy::parser::token::SREQ:
    35903590                        pszOp = ">>=";
    35913591                        nOp = NscPCode_AsnShiftRight;
    35923592                        goto asn_shift_operator;
    35933593
    3594                 case USREQ:
     3594                case yy::parser::token::USREQ:
    35953595                        pszOp = ">>>=";
    35963596                        nOp = NscPCode_AsnUnsignedShiftRight;
    35973597                        goto asn_shift_operator;
    35983598
    3599                 case ANDEQ:
     3599                case yy::parser::token::ANDEQ:
    36003600                        pszOp = "&=";
    36013601                        nOp = NscPCode_AsnBitwiseAND;
    36023602asn_bitwise_expression:;
    … … asn_bitwise_expression:; 
    36123612                        }
    36133613                        break;
    36143614
    3615                 case XOREQ:
     3615                case yy::parser::token::XOREQ:
    36163616                        pszOp = "^=";
    36173617                        nOp = NscPCode_AsnBitwiseXOR;
    36183618                        goto asn_bitwise_expression;
    36193619
    3620                 case OREQ:
     3620                case yy::parser::token::OREQ:
    36213621                        pszOp = "|=";
    36223622                        nOp = NscPCode_AsnBitwiseOR;
    36233623                        goto asn_bitwise_expression;
    … … YYSTYPE NscBuildLogicalOp (int nToken, Y 
    36963696
    36973697                const char *pszOp;
    36983698                NscPCode nOp;
    3699                 if (nToken == ANDAND)
     3699                if (nToken == yy::parser::token::ANDAND)
    37003700                {
    37013701                        pszOp = "&&";
    37023702                        nOp = NscPCode_LogicalAND;
    37033703                }
    3704                 else if (nToken == OROR)
     3704                else if (nToken == yy::parser::token::OROR)
    37053705                {
    37063706                        pszOp = "||";
    37073707                        nOp = NscPCode_LogicalOR;
    … … YYSTYPE NscBuildLogicalOp (int nToken, Y 
    37503750                        // If the operation is known to be true or false by the lhs
    37513751                        //
    37523752
    3753                         else if (nToken == ANDAND && nLhsConstant == 0)
     3753                        else if (nToken == yy::parser::token::ANDAND && nLhsConstant == 0)
    37543754                        {
    37553755                                pOut ->PushConstantInteger (0);
    37563756                                pOut ->SetType (NscType_Integer);
    37573757                        }
    3758                         else if (nToken == OROR && nLhsConstant == 1)
     3758                        else if (nToken == yy::parser::token::OROR && nLhsConstant == 1)
    37593759                        {
    37603760                                pOut ->PushConstantInteger (1);
    37613761                                pOut ->SetType (NscType_Integer);
    … … YYSTYPE NscBuild5Block (int nToken, YYST 
    47064706        bool fCheckCond;
    47074707        switch (nToken)
    47084708        {
    4709                 case IF:
     4709                case yy::parser::token::IF:
    47104710                        nPCode = NscPCode_If;
    47114711                        nFenceType = NscFenceType_If;
    47124712                        pszToken = "if";
    … … YYSTYPE NscBuild5Block (int nToken, YYST 
    47144714                        fCheckCond = pPrev == NULL;
    47154715                        break;
    47164716
    4717                 case WHILE:
     4717                case yy::parser::token::WHILE:
    47184718                        nPCode = NscPCode_While;
    47194719                        nFenceType = NscFenceType_While;
    47204720                        pszToken = "while";
    … … YYSTYPE NscBuild5Block (int nToken, YYST 
    47224722                        fCheckCond = pPrev == NULL;
    47234723                        break;
    47244724
    4725                 case DO:
     4725                case yy::parser::token::DO:
    47264726                        nPCode = NscPCode_Do;
    47274727                        nFenceType = NscFenceType_Do;
    47284728                        pszToken = "do";
    … … YYSTYPE NscBuild5Block (int nToken, YYST 
    47304730                        fCheckCond = pPrev != NULL;
    47314731                        break;
    47324732
    4733                 case FOR:
     4733                case yy::parser::token::FOR:
    47344734                        nPCode = NscPCode_For;
    47354735                        nFenceType = NscFenceType_For;
    47364736                        pszToken = "for";
    … … YYSTYPE NscBuild5Block (int nToken, YYST 
    47384738                        fCheckCond = pPrev == NULL;
    47394739                        break;
    47404740
    4741                 case SWITCH:
     4741                case yy::parser::token::SWITCH:
    47424742                        nPCode = NscPCode_Switch;
    47434743                        nFenceType = NscFenceType_Switch;
    47444744                        pszToken = "switch";
    … … YYSTYPE NscBuild5Block (int nToken, YYST 
    47874787                // for this
    47884788                //
    47894789
    4790                 if (nToken == SWITCH)
     4790                if (nToken == yy::parser::token::SWITCH)
    47914791                {
    47924792                        NscSymbolFence *pFence = g_pCtx ->GetCurrentFence ();
    47934793                        pFence ->nPrevLocals++;
    … … YYSTYPE NscBuild5Block (int nToken, YYST 
    48064806        // then set return
    48074807        //
    48084808
    4809         if (nToken == IF && pFalse)
     4809        if (nToken == yy::parser::token::IF && pFalse)
    48104810        {
    48114811                if (fHadReturn)
    48124812                        NscSetFenceReturn (true);
    … … YYSTYPE NscBuildCase (int nToken, YYSTYP 
    49924992                // If this is a case
    49934993                //
    49944994
    4995                 if (nToken == CASE)
     4995                if (nToken == yy::parser::token::CASE)
    49964996                {
    49974997
    49984998                        //
    … … YYSTYPE NscBuildCase (int nToken, YYSTYP 
    50615061                        // Test for only one default
    50625062                        //
    50635063
    5064                         if (nToken == DEFAULT)
     5064                        if (nToken == yy::parser::token::DEFAULT)
    50655065                        {
    50665066                                if (pFence ->fHasDefault)
    50675067                                {
    … … YYSTYPE NscBuildCase (int nToken, YYSTYP 
    50865086                        //
    50875087
    50885088                        NscPCode nPCode;
    5089                         if (nToken == CASE)
     5089                        if (nToken == yy::parser::token::CASE)
    50905090                                nPCode = NscPCode_Case;
    5091                         else if (nToken == DEFAULT)
     5091                        else if (nToken == yy::parser::token::DEFAULT)
    50925092                                nPCode = NscPCode_Default;
    50935093                        else
    50945094                        {
    … … YYSTYPE NscBuildBreakContinue (int nToke 
    52625262        //
    52635263
    52645264        NscPCode nPCode;
    5265         if (nToken == BREAK)
     5265        if (nToken == yy::parser::token::BREAK)
    52665266                nPCode = NscPCode_Break;
    5267         else if (nToken == CONTINUE)
     5267        else if (nToken == yy::parser::token::CONTINUE)
    52685268                nPCode = NscPCode_Continue;
    52695269        else
    52705270        {
    … … YYSTYPE NscBuildBreakContinue (int nToke 
    52795279        NscSymbolFence *pFence = g_pCtx ->GetCurrentFence ();
    52805280        while (pFence)
    52815281        {
    5282                 if ((pFence ->nFenceType == NscFenceType_Switch && nToken == BREAK) ||
     5282                if ((pFence ->nFenceType == NscFenceType_Switch && nToken == yy::parser::token::BREAK) ||
    52835283                        pFence ->nFenceType == NscFenceType_Do ||
    52845284                        pFence ->nFenceType == NscFenceType_While ||
    52855285                        pFence ->nFenceType == NscFenceType_For)
    … … YYSTYPE NscBuildBreakContinue (int nToke 
    52885288        }
    52895289        if (pFence == NULL)
    52905290        {
    5291                 if (nToken == BREAK)
     5291                if (nToken == yy::parser::token::BREAK)
    52925292                {
    52935293            g_pCtx ->GenerateError ("\"break\" statement only allowed in "
    52945294                            "\"switch\", \"do\", \"while\", and \"for\" statements");
    52955295                }
    5296                 else if (nToken == CONTINUE)
     5296                else if (nToken == yy::parser::token::CONTINUE)
    52975297                {
    52985298            g_pCtx ->GenerateError ("\"continue\" statement only allowed in "
    52995299                            "\"do\", \"while\", and \"for\" statements");