Changeset 5f2f2d7 for src/Parser


Ignore:
Timestamp:
Jun 8, 2015, 8:56:35 PM (10 years ago)
Author:
Peter A. Buhr <pabuhr@…>
Branches:
ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, ctor, deferred_resn, demangler, enum, forall-pointer-decay, gc_noraii, jacob/cs343-translation, jenkins-sandbox, master, memory, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, string, with_gc
Children:
81419b5
Parents:
cd623a4
Message:

fix constant types, remove unnecessary string copying, work on regression testing, fix several memory leaks

Location:
src/Parser
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • src/Parser/ExpressionNode.cc

    rcd623a4 r5f2f2d7  
    1010// Created On       : Sat May 16 13:17:07 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Jun  7 07:58:00 2015
    13 // Update Count     : 135
     12// Last Modified On : Mon Jun  8 17:33:40 2015
     13// Update Count     : 147
    1414//
    1515
    … …  
    9393static inline bool checkX( char c ) { return c == 'x' || c == 'X'; }
    9494
    95 // Very difficult to separate extra parts of constants during lexing because actions are not allow in the middle of
    96 // patterns:
     95// Difficult to separate extra parts of constants during lexing because actions are not allow in the middle of patterns:
    9796//
    9897//              prefix action constant action suffix
    … …  
    130129                                } // if
    131130                        } else {                                                                        // decimal constant ?
    132                                 sscanf( (char *)value.c_str(), "%lld", &v );
     131                                sscanf( (char *)value.c_str(), "%llu", &v );
    133132                                //printf( "%llu %llu\n", v, v );
    134133                        } // if
    … …  
    136135                        if ( v <= INT_MAX ) {                                           // signed int
    137136                                size = 0;
    138                         } else if ( v <= UINT_MAX ) {                           // unsigned int
     137                        } else if ( v <= UINT_MAX && ! dec ) {          // unsigned int
    139138                                size = 0;
    140                                 if ( ! dec ) Unsigned = true;                   // unsigned
     139                                Unsigned = true;                                                // unsigned
    141140                        } else if ( v <= LONG_MAX ) {                           // signed long int
    142141                                size = 1;
    143                         } else if ( v <= ULONG_MAX ) {                          // signed long int
     142                        } else if ( v <= ULONG_MAX && ( ! dec || LONG_MAX == LLONG_MAX ) ) { // signed long int
    144143                                size = 1;
    145                                 if ( ! dec ) Unsigned = true;                   // unsigned long int
     144                                Unsigned = true;                                                // unsigned long int
    146145                        } else if ( v <= LLONG_MAX ) {                          // signed long long int
    147146                                size = 2;
    148                         } else {                                                                        // signed long long int
     147                        } else {                                                                        // unsigned long long int
    149148                                size = 2;
    150                                 if ( ! dec ) Unsigned = true;                   // unsigned long long int
     149                                Unsigned = true;                                                // unsigned long long int
    151150                        } // if
    152151
    153152                        if ( checkU( value[last] ) ) {                          // suffix 'u' ?
    154153                                Unsigned = true;
    155                                 if ( checkL( value[ last - 1 ] ) ) {    // suffix 'l' ?
     154                                if ( last > 0 && checkL( value[ last - 1 ] ) ) { // suffix 'l' ?
    156155                                        size = 1;
    157                                         if ( checkL( value[ last - 1 ] ) ) { // suffix 'll' ?
     156                                        if ( last > 1 && checkL( value[ last - 2 ] ) ) { // suffix 'll' ?
    158157                                                size = 2;
    159158                                        } // if
    … …  
    161160                        } else if ( checkL( value[ last ] ) ) {         // suffix 'l' ?
    162161                                size = 1;
    163                                 if ( checkL( value[ last - 1 ] ) ) {    // suffix 'll' ?
     162                                if ( last > 0 && checkL( value[ last - 1 ] ) ) { // suffix 'll' ?
    164163                                        size = 2;
    165                                 } // if
    166                                 if ( checkU( value[ last - 1 ] ) ) {    // suffix 'u' ?
    167                                         Unsigned = true;
     164                                        if ( last > 1 && checkU( value[ last - 2 ] ) ) { // suffix 'u' ?
     165                                                Unsigned = true;
     166                                        } // if
     167                                } else {
     168                                        if ( last > 0 && checkU( value[ last - 1 ] ) ) { // suffix 'u' ?
     169                                                Unsigned = true;
     170                                        } // if
    168171                                } // if
    169172                        } // if

  • src/Parser/ParseNode.h

    rcd623a4 r5f2f2d7  
    1010// Created On       : Sat May 16 13:28:16 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Jun  7 07:42:50 2015
    13 // Update Count     : 64
     12// Last Modified On : Sun Jun  7 22:02:00 2015
     13// Update Count     : 65
    1414//
    1515
    … …  
    337337
    338338        bool get_hasEllipsis() const;
    339         std::string get_name() const { return name; }
     339        const std::string &get_name() const { return name; }
    340340        LinkageSpec::Type get_linkage() const { return linkage; }
    341341        DeclarationNode *extractAggregate() const;

  • src/Parser/lex.cc

    rcd623a4 r5f2f2d7  
    13901390 * Created On       : Sat Sep 22 08:58:10 2001
    13911391 * Last Modified By : Peter A. Buhr
    1392  * Last Modified On : Sun Jun  7 07:14:16 2015
    1393  * Update Count     : 374
    1394  */
    1395 #line 19 "lex.ll"
     1392 * Last Modified On : Mon Jun  8 20:24:15 2015
     1393 * Update Count     : 381
     1394 */
     1395#line 20 "lex.ll"
    13961396// This lexer assumes the program has been preprocessed by cpp. Hence, all user level preprocessor directive
    13971397// have been performed and removed from the source. The only exceptions are preprocessor directives passed to
    … …  
    14091409std::string *strtext;                                                                   // accumulate parts of character and string constant value
    14101410
     1411#define RETURN_LOCN(x)          yylval.tok.loc.file = yyfilename; yylval.tok.loc.line = yylineno; return(x)
     1412#define RETURN_VAL(x)           yylval.tok.str = new std::string( yytext ); RETURN_LOCN(x)
     1413#define RETURN_CHAR(x)          yylval.tok.str = NULL; RETURN_LOCN(x)
     1414#define RETURN_STR(x)           yylval.tok.str = strtext; RETURN_LOCN(x)
     1415
    14111416#define WHITE_RETURN(x)                                                                 // do nothing
    14121417#define NEWLINE_RETURN()        WHITE_RETURN('\n')
    1413 #define RETURN_VAL(x)           yylval.tok.str = new std::string( yytext ); \
    1414                                         yylval.tok.loc.file = yyfilename; \
    1415                                         yylval.tok.loc.line = yylineno; \
    1416                                         return(x)
    1417 #define RETURN_STR(x)           yylval.tok.str = strtext; \
    1418                                         yylval.tok.loc.file = yyfilename; \
    1419                                         yylval.tok.loc.line = yylineno; \
    1420                                         return(x)
    1421 
    1422 #define KEYWORD_RETURN(x)       RETURN_VAL(x)                           // keyword
     1418#define ASCIIOP_RETURN()        RETURN_CHAR((int)yytext[0])     // single character operator
     1419#define NAMEDOP_RETURN(x)       RETURN_VAL(x)                           // multichar operator, with a name
     1420#define NUMERIC_RETURN(x)       rm_underscore(); RETURN_VAL(x) // numeric constant
     1421#define KEYWORD_RETURN(x)       RETURN_CHAR(x)                          // keyword
    14231422#define IDENTIFIER_RETURN()     RETURN_VAL((typedefTable.isIdentifier(yytext) ? IDENTIFIER : typedefTable.isTypedef(yytext) ? TYPEDEFname : TYPEGENname))
    1424 //#define ATTRIBUTE_RETURN()    RETURN_VAL((typedefTable.isIdentifier(yytext) ? ATTR_IDENTIFIER : typedefTable.isTypedef(yytext) ? ATTR_TYPEDEFname : ATTR_TYPEGENname))
    14251423#define ATTRIBUTE_RETURN()      RETURN_VAL(ATTR_IDENTIFIER)
    1426 
    1427 #define ASCIIOP_RETURN()        RETURN_VAL((int)yytext[0])      // single character operator
    1428 #define NAMEDOP_RETURN(x)       RETURN_VAL(x)                           // multichar operator, with a name
    1429 
    1430 #define NUMERIC_RETURN(x)       rm_underscore(); RETURN_VAL(x) // numeric constant
    14311424
    14321425void rm_underscore() {
    … …  
    14551448
    14561449
    1457 #line 1458 "Parser/lex.cc"
     1450#line 1451 "Parser/lex.cc"
    14581451
    14591452#define INITIAL 0
    … …  
    15181511#endif
    15191512
    1520     static void yyunput (int c,char *buf_ptr  );
    1521    
    15221513#ifndef yytext_ptr
    15231514static void yy_flex_strncpy (char *,yyconst char *,int );
    … …  
    16491640        register int yy_act;
    16501641   
    1651 #line 142 "lex.ll"
     1642#line 136 "lex.ll"
    16521643
    16531644                                   /* line directives */
    1654 #line 1655 "Parser/lex.cc"
     1645#line 1646 "Parser/lex.cc"
    16551646
    16561647        if ( !(yy_init) )
    … …  
    17491740/* rule 1 can match eol */
    17501741YY_RULE_SETUP
    1751 #line 144 "lex.ll"
     1742#line 138 "lex.ll"
    17521743{
    17531744        /* " stop highlighting */
    … …  
    17761767/* rule 2 can match eol */
    17771768YY_RULE_SETUP
    1778 #line 167 "lex.ll"
     1769#line 161 "lex.ll"
    17791770;
    17801771        YY_BREAK
    … …  
    17821773case 3:
    17831774YY_RULE_SETUP
    1784 #line 170 "lex.ll"
     1775#line 164 "lex.ll"
    17851776{ BEGIN COMMENT; }
    17861777        YY_BREAK
    … …  
    17881779/* rule 4 can match eol */
    17891780YY_RULE_SETUP
    1790 #line 171 "lex.ll"
     1781#line 165 "lex.ll"
    17911782;
    17921783        YY_BREAK
    17931784case 5:
    17941785YY_RULE_SETUP
    1795 #line 172 "lex.ll"
     1786#line 166 "lex.ll"
    17961787{ BEGIN 0; }
    17971788        YY_BREAK
    … …  
    18001791/* rule 6 can match eol */
    18011792YY_RULE_SETUP
    1802 #line 175 "lex.ll"
     1793#line 169 "lex.ll"
    18031794;
    18041795        YY_BREAK
    … …  
    18061797case 7:
    18071798YY_RULE_SETUP
    1808 #line 178 "lex.ll"
     1799#line 172 "lex.ll"
    18091800{ WHITE_RETURN(' '); }
    18101801        YY_BREAK
    18111802case 8:
    18121803YY_RULE_SETUP
    1813 #line 179 "lex.ll"
     1804#line 173 "lex.ll"
    18141805{ WHITE_RETURN(' '); }
    18151806        YY_BREAK
    … …  
    18171808/* rule 9 can match eol */
    18181809YY_RULE_SETUP
    1819 #line 180 "lex.ll"
     1810#line 174 "lex.ll"
    18201811{ NEWLINE_RETURN(); }
    18211812        YY_BREAK
    … …  
    18231814case 10:
    18241815YY_RULE_SETUP
     1816#line 177 "lex.ll"
     1817{ KEYWORD_RETURN(ALIGNAS); }                    // C11
     1818        YY_BREAK
     1819case 11:
     1820YY_RULE_SETUP
     1821#line 178 "lex.ll"
     1822{ KEYWORD_RETURN(ALIGNOF); }                    // C11
     1823        YY_BREAK
     1824case 12:
     1825YY_RULE_SETUP
     1826#line 179 "lex.ll"
     1827{ KEYWORD_RETURN(ALIGNOF); }                    // GCC
     1828        YY_BREAK
     1829case 13:
     1830YY_RULE_SETUP
     1831#line 180 "lex.ll"
     1832{ KEYWORD_RETURN(ALIGNOF); }                    // GCC
     1833        YY_BREAK
     1834case 14:
     1835YY_RULE_SETUP
     1836#line 181 "lex.ll"
     1837{ KEYWORD_RETURN(ASM); }
     1838        YY_BREAK
     1839case 15:
     1840YY_RULE_SETUP
     1841#line 182 "lex.ll"
     1842{ KEYWORD_RETURN(ASM); }                                // GCC
     1843        YY_BREAK
     1844case 16:
     1845YY_RULE_SETUP
    18251846#line 183 "lex.ll"
    1826 { KEYWORD_RETURN(ALIGNAS); }                    // C11
    1827         YY_BREAK
    1828 case 11:
     1847{ KEYWORD_RETURN(ASM); }                                // GCC
     1848        YY_BREAK
     1849case 17:
    18291850YY_RULE_SETUP
    18301851#line 184 "lex.ll"
    1831 { KEYWORD_RETURN(ALIGNOF); }                    // C11
    1832         YY_BREAK
    1833 case 12:
     1852{ KEYWORD_RETURN(ATOMIC); }                             // C11
     1853        YY_BREAK
     1854case 18:
    18341855YY_RULE_SETUP
    18351856#line 185 "lex.ll"
    1836 { KEYWORD_RETURN(ALIGNOF); }                    // GCC
    1837         YY_BREAK
    1838 case 13:
     1857{ KEYWORD_RETURN(ATTRIBUTE); }                  // GCC
     1858        YY_BREAK
     1859case 19:
    18391860YY_RULE_SETUP
    18401861#line 186 "lex.ll"
    1841 { KEYWORD_RETURN(ALIGNOF); }                    // GCC
    1842         YY_BREAK
    1843 case 14:
     1862{ KEYWORD_RETURN(ATTRIBUTE); }                  // GCC
     1863        YY_BREAK
     1864case 20:
    18441865YY_RULE_SETUP
    18451866#line 187 "lex.ll"
    1846 { KEYWORD_RETURN(ASM); }
    1847         YY_BREAK
    1848 case 15:
     1867{ KEYWORD_RETURN(AUTO); }
     1868        YY_BREAK
     1869case 21:
    18491870YY_RULE_SETUP
    18501871#line 188 "lex.ll"
    1851 { KEYWORD_RETURN(ASM); }                                // GCC
    1852         YY_BREAK
    1853 case 16:
     1872{ KEYWORD_RETURN(BOOL); }                               // C99
     1873        YY_BREAK
     1874case 22:
    18541875YY_RULE_SETUP
    18551876#line 189 "lex.ll"
    1856 { KEYWORD_RETURN(ASM); }                                // GCC
    1857         YY_BREAK
    1858 case 17:
     1877{ KEYWORD_RETURN(BREAK); }
     1878        YY_BREAK
     1879case 23:
    18591880YY_RULE_SETUP
    18601881#line 190 "lex.ll"
    1861 { KEYWORD_RETURN(ATOMIC); }                             // C11
    1862         YY_BREAK
    1863 case 18:
     1882{ KEYWORD_RETURN(CASE); }
     1883        YY_BREAK
     1884case 24:
    18641885YY_RULE_SETUP
    18651886#line 191 "lex.ll"
    1866 { KEYWORD_RETURN(ATTRIBUTE); }                  // GCC
    1867         YY_BREAK
    1868 case 19:
     1887{ KEYWORD_RETURN(CATCH); }                              // CFA
     1888        YY_BREAK
     1889case 25:
    18691890YY_RULE_SETUP
    18701891#line 192 "lex.ll"
    1871 { KEYWORD_RETURN(ATTRIBUTE); }                  // GCC
    1872         YY_BREAK
    1873 case 20:
     1892{ KEYWORD_RETURN(CHAR); }
     1893        YY_BREAK
     1894case 26:
    18741895YY_RULE_SETUP
    18751896#line 193 "lex.ll"
    1876 { KEYWORD_RETURN(AUTO); }
    1877         YY_BREAK
    1878 case 21:
     1897{ KEYWORD_RETURN(CHOOSE); }                             // CFA
     1898        YY_BREAK
     1899case 27:
    18791900YY_RULE_SETUP
    18801901#line 194 "lex.ll"
    1881 { KEYWORD_RETURN(BOOL); }                               // C99
    1882         YY_BREAK
    1883 case 22:
     1902{ KEYWORD_RETURN(COMPLEX); }                    // C99
     1903        YY_BREAK
     1904case 28:
    18841905YY_RULE_SETUP
    18851906#line 195 "lex.ll"
    1886 { KEYWORD_RETURN(BREAK); }
    1887         YY_BREAK
    1888 case 23:
     1907{ KEYWORD_RETURN(COMPLEX); }                    // GCC
     1908        YY_BREAK
     1909case 29:
    18891910YY_RULE_SETUP
    18901911#line 196 "lex.ll"
    1891 { KEYWORD_RETURN(CASE); }
    1892         YY_BREAK
    1893 case 24:
     1912{ KEYWORD_RETURN(COMPLEX); }                    // GCC
     1913        YY_BREAK
     1914case 30:
    18941915YY_RULE_SETUP
    18951916#line 197 "lex.ll"
    1896 { KEYWORD_RETURN(CATCH); }                              // CFA
    1897         YY_BREAK
    1898 case 25:
     1917{ KEYWORD_RETURN(CONST); }
     1918        YY_BREAK
     1919case 31:
    18991920YY_RULE_SETUP
    19001921#line 198 "lex.ll"
    1901 { KEYWORD_RETURN(CHAR); }
    1902         YY_BREAK
    1903 case 26:
     1922{ KEYWORD_RETURN(CONST); }                              // GCC
     1923        YY_BREAK
     1924case 32:
    19041925YY_RULE_SETUP
    19051926#line 199 "lex.ll"
    1906 { KEYWORD_RETURN(CHOOSE); }                             // CFA
    1907         YY_BREAK
    1908 case 27:
     1927{ KEYWORD_RETURN(CONST); }                              // GCC
     1928        YY_BREAK
     1929case 33:
    19091930YY_RULE_SETUP
    19101931#line 200 "lex.ll"
    1911 { KEYWORD_RETURN(COMPLEX); }                    // C99
    1912         YY_BREAK
    1913 case 28:
     1932{ KEYWORD_RETURN(CONTEXT); }                    // CFA
     1933        YY_BREAK
     1934case 34:
    19141935YY_RULE_SETUP
    19151936#line 201 "lex.ll"
    1916 { KEYWORD_RETURN(COMPLEX); }                    // GCC
    1917         YY_BREAK
    1918 case 29:
     1937{ KEYWORD_RETURN(CONTINUE); }
     1938        YY_BREAK
     1939case 35:
    19191940YY_RULE_SETUP
    19201941#line 202 "lex.ll"
    1921 { KEYWORD_RETURN(COMPLEX); }                    // GCC
    1922         YY_BREAK
    1923 case 30:
     1942{ KEYWORD_RETURN(DEFAULT); }
     1943        YY_BREAK
     1944case 36:
    19241945YY_RULE_SETUP
    19251946#line 203 "lex.ll"
    1926 { KEYWORD_RETURN(CONST); }
    1927         YY_BREAK
    1928 case 31:
     1947{ KEYWORD_RETURN(DO); }
     1948        YY_BREAK
     1949case 37:
    19291950YY_RULE_SETUP
    19301951#line 204 "lex.ll"
    1931 { KEYWORD_RETURN(CONST); }                              // GCC
    1932         YY_BREAK
    1933 case 32:
     1952{ KEYWORD_RETURN(DOUBLE); }
     1953        YY_BREAK
     1954case 38:
    19341955YY_RULE_SETUP
    19351956#line 205 "lex.ll"
    1936 { KEYWORD_RETURN(CONST); }                              // GCC
    1937         YY_BREAK
    1938 case 33:
     1957{ KEYWORD_RETURN(DTYPE); }                              // CFA
     1958        YY_BREAK
     1959case 39:
    19391960YY_RULE_SETUP
    19401961#line 206 "lex.ll"
    1941 { KEYWORD_RETURN(CONTEXT); }                    // CFA
    1942         YY_BREAK
    1943 case 34:
     1962{ KEYWORD_RETURN(ELSE); }
     1963        YY_BREAK
     1964case 40:
    19441965YY_RULE_SETUP
    19451966#line 207 "lex.ll"
    1946 { KEYWORD_RETURN(CONTINUE); }
    1947         YY_BREAK
    1948 case 35:
     1967{ KEYWORD_RETURN(ENUM); }
     1968        YY_BREAK
     1969case 41:
    19491970YY_RULE_SETUP
    19501971#line 208 "lex.ll"
    1951 { KEYWORD_RETURN(DEFAULT); }
    1952         YY_BREAK
    1953 case 36:
     1972{ KEYWORD_RETURN(EXTENSION); }                  // GCC
     1973        YY_BREAK
     1974case 42:
    19541975YY_RULE_SETUP
    19551976#line 209 "lex.ll"
    1956 { KEYWORD_RETURN(DO); }
    1957         YY_BREAK
    1958 case 37:
     1977{ KEYWORD_RETURN(EXTERN); }
     1978        YY_BREAK
     1979case 43:
    19591980YY_RULE_SETUP
    19601981#line 210 "lex.ll"
    1961 { KEYWORD_RETURN(DOUBLE); }
    1962         YY_BREAK
    1963 case 38:
     1982{ KEYWORD_RETURN(FALLTHRU); }                   // CFA
     1983        YY_BREAK
     1984case 44:
    19641985YY_RULE_SETUP
    19651986#line 211 "lex.ll"
    1966 { KEYWORD_RETURN(DTYPE); }                              // CFA
    1967         YY_BREAK
    1968 case 39:
     1987{ KEYWORD_RETURN(FINALLY); }                    // CFA
     1988        YY_BREAK
     1989case 45:
    19691990YY_RULE_SETUP
    19701991#line 212 "lex.ll"
    1971 { KEYWORD_RETURN(ELSE); }
    1972         YY_BREAK
    1973 case 40:
     1992{ KEYWORD_RETURN(FLOAT); }
     1993        YY_BREAK
     1994case 46:
    19741995YY_RULE_SETUP
    19751996#line 213 "lex.ll"
    1976 { KEYWORD_RETURN(ENUM); }
    1977         YY_BREAK
    1978 case 41:
     1997{ KEYWORD_RETURN(FLOAT); }                              // GCC
     1998        YY_BREAK
     1999case 47:
    19792000YY_RULE_SETUP
    19802001#line 214 "lex.ll"
    1981 { KEYWORD_RETURN(EXTENSION); }                  // GCC
    1982         YY_BREAK
    1983 case 42:
     2002{ KEYWORD_RETURN(FOR); }
     2003        YY_BREAK
     2004case 48:
    19842005YY_RULE_SETUP
    19852006#line 215 "lex.ll"
    1986 { KEYWORD_RETURN(EXTERN); }
    1987         YY_BREAK
    1988 case 43:
     2007{ KEYWORD_RETURN(FORALL); }                             // CFA
     2008        YY_BREAK
     2009case 49:
    19892010YY_RULE_SETUP
    19902011#line 216 "lex.ll"
    1991 { KEYWORD_RETURN(FALLTHRU); }                   // CFA
    1992         YY_BREAK
    1993 case 44:
     2012{ KEYWORD_RETURN(FORTRAN); }
     2013        YY_BREAK
     2014case 50:
    19942015YY_RULE_SETUP
    19952016#line 217 "lex.ll"
    1996 { KEYWORD_RETURN(FINALLY); }                    // CFA
    1997         YY_BREAK
    1998 case 45:
     2017{ KEYWORD_RETURN(FTYPE); }                              // CFA
     2018        YY_BREAK
     2019case 51:
    19992020YY_RULE_SETUP
    20002021#line 218 "lex.ll"
    2001 { KEYWORD_RETURN(FLOAT); }
    2002         YY_BREAK
    2003 case 46:
     2022{ KEYWORD_RETURN(GENERIC); }                    // C11
     2023        YY_BREAK
     2024case 52:
    20042025YY_RULE_SETUP
    20052026#line 219 "lex.ll"
    2006 { KEYWORD_RETURN(FLOAT); }                              // GCC
    2007         YY_BREAK
    2008 case 47:
     2027{ KEYWORD_RETURN(GOTO); }
     2028        YY_BREAK
     2029case 53:
    20092030YY_RULE_SETUP
    20102031#line 220 "lex.ll"
    2011 { KEYWORD_RETURN(FOR); }
    2012         YY_BREAK
    2013 case 48:
     2032{ KEYWORD_RETURN(IF); }
     2033        YY_BREAK
     2034case 54:
    20142035YY_RULE_SETUP
    20152036#line 221 "lex.ll"
    2016 { KEYWORD_RETURN(FORALL); }                             // CFA
    2017         YY_BREAK
    2018 case 49:
     2037{ KEYWORD_RETURN(IMAGINARY); }                  // C99
     2038        YY_BREAK
     2039case 55:
    20192040YY_RULE_SETUP
    20202041#line 222 "lex.ll"
    2021 { KEYWORD_RETURN(FORTRAN); }
    2022         YY_BREAK
    2023 case 50:
     2042{ KEYWORD_RETURN(IMAGINARY); }                  // GCC
     2043        YY_BREAK
     2044case 56:
    20242045YY_RULE_SETUP
    20252046#line 223 "lex.ll"
    2026 { KEYWORD_RETURN(FTYPE); }                              // CFA
    2027         YY_BREAK
    2028 case 51:
     2047{ KEYWORD_RETURN(IMAGINARY); }                  // GCC
     2048        YY_BREAK
     2049case 57:
    20292050YY_RULE_SETUP
    20302051#line 224 "lex.ll"
    2031 { KEYWORD_RETURN(GENERIC); }                    // C11
    2032         YY_BREAK
    2033 case 52:
     2052{ KEYWORD_RETURN(INLINE); }                             // C99
     2053        YY_BREAK
     2054case 58:
    20342055YY_RULE_SETUP
    20352056#line 225 "lex.ll"
    2036 { KEYWORD_RETURN(GOTO); }
    2037         YY_BREAK
    2038 case 53:
     2057{ KEYWORD_RETURN(INLINE); }                             // GCC
     2058        YY_BREAK
     2059case 59:
    20392060YY_RULE_SETUP
    20402061#line 226 "lex.ll"
    2041 { KEYWORD_RETURN(IF); }
    2042         YY_BREAK
    2043 case 54:
     2062{ KEYWORD_RETURN(INLINE); }                             // GCC
     2063        YY_BREAK
     2064case 60:
    20442065YY_RULE_SETUP
    20452066#line 227 "lex.ll"
    2046 { KEYWORD_RETURN(IMAGINARY); }                  // C99
    2047         YY_BREAK
    2048 case 55:
     2067{ KEYWORD_RETURN(INT); }
     2068        YY_BREAK
     2069case 61:
    20492070YY_RULE_SETUP
    20502071#line 228 "lex.ll"
    2051 { KEYWORD_RETURN(IMAGINARY); }                  // GCC
    2052         YY_BREAK
    2053 case 56:
     2072{ KEYWORD_RETURN(INT); }                                // GCC
     2073        YY_BREAK
     2074case 62:
    20542075YY_RULE_SETUP
    20552076#line 229 "lex.ll"
    2056 { KEYWORD_RETURN(IMAGINARY); }                  // GCC
    2057         YY_BREAK
    2058 case 57:
     2077{ KEYWORD_RETURN(LABEL); }                              // GCC
     2078        YY_BREAK
     2079case 63:
    20592080YY_RULE_SETUP
    20602081#line 230 "lex.ll"
    2061 { KEYWORD_RETURN(INLINE); }                             // C99
    2062         YY_BREAK
    2063 case 58:
     2082{ KEYWORD_RETURN(LONG); }
     2083        YY_BREAK
     2084case 64:
    20642085YY_RULE_SETUP
    20652086#line 231 "lex.ll"
    2066 { KEYWORD_RETURN(INLINE); }                             // GCC
    2067         YY_BREAK
    2068 case 59:
     2087{ KEYWORD_RETURN(LVALUE); }                             // CFA
     2088        YY_BREAK
     2089case 65:
    20692090YY_RULE_SETUP
    20702091#line 232 "lex.ll"
    2071 { KEYWORD_RETURN(INLINE); }                             // GCC
    2072         YY_BREAK
    2073 case 60:
     2092{ KEYWORD_RETURN(NORETURN); }                   // C11
     2093        YY_BREAK
     2094case 66:
    20742095YY_RULE_SETUP
    20752096#line 233 "lex.ll"
    2076 { KEYWORD_RETURN(INT); }
    2077         YY_BREAK
    2078 case 61:
     2097{ KEYWORD_RETURN(REGISTER); }
     2098        YY_BREAK
     2099case 67:
    20792100YY_RULE_SETUP
    20802101#line 234 "lex.ll"
    2081 { KEYWORD_RETURN(INT); }                                // GCC
    2082         YY_BREAK
    2083 case 62:
     2102{ KEYWORD_RETURN(RESTRICT); }                   // C99
     2103        YY_BREAK
     2104case 68:
    20842105YY_RULE_SETUP
    20852106#line 235 "lex.ll"
    2086 { KEYWORD_RETURN(LABEL); }                              // GCC
    2087         YY_BREAK
    2088 case 63:
     2107{ KEYWORD_RETURN(RESTRICT); }                   // GCC
     2108        YY_BREAK
     2109case 69:
    20892110YY_RULE_SETUP
    20902111#line 236 "lex.ll"
    2091 { KEYWORD_RETURN(LONG); }
    2092         YY_BREAK
    2093 case 64:
     2112{ KEYWORD_RETURN(RESTRICT); }                   // GCC
     2113        YY_BREAK
     2114case 70:
    20942115YY_RULE_SETUP
    20952116#line 237 "lex.ll"
    2096 { KEYWORD_RETURN(LVALUE); }                             // CFA
    2097         YY_BREAK
    2098 case 65:
     2117{ KEYWORD_RETURN(RETURN); }
     2118        YY_BREAK
     2119case 71:
    20992120YY_RULE_SETUP
    21002121#line 238 "lex.ll"
    2101 { KEYWORD_RETURN(NORETURN); }                   // C11
    2102         YY_BREAK
    2103 case 66:
     2122{ KEYWORD_RETURN(SHORT); }
     2123        YY_BREAK
     2124case 72:
    21042125YY_RULE_SETUP
    21052126#line 239 "lex.ll"
    2106 { KEYWORD_RETURN(REGISTER); }
    2107         YY_BREAK
    2108 case 67:
     2127{ KEYWORD_RETURN(SIGNED); }
     2128        YY_BREAK
     2129case 73:
    21092130YY_RULE_SETUP
    21102131#line 240 "lex.ll"
    2111 { KEYWORD_RETURN(RESTRICT); }                   // C99
    2112         YY_BREAK
    2113 case 68:
     2132{ KEYWORD_RETURN(SIGNED); }                             // GCC
     2133        YY_BREAK
     2134case 74:
    21142135YY_RULE_SETUP
    21152136#line 241 "lex.ll"
    2116 { KEYWORD_RETURN(RESTRICT); }                   // GCC
    2117         YY_BREAK
    2118 case 69:
     2137{ KEYWORD_RETURN(SIGNED); }                             // GCC
     2138        YY_BREAK
     2139case 75:
    21192140YY_RULE_SETUP
    21202141#line 242 "lex.ll"
    2121 { KEYWORD_RETURN(RESTRICT); }                   // GCC
    2122         YY_BREAK
    2123 case 70:
     2142{ KEYWORD_RETURN(SIZEOF); }
     2143        YY_BREAK
     2144case 76:
    21242145YY_RULE_SETUP
    21252146#line 243 "lex.ll"
    2126 { KEYWORD_RETURN(RETURN); }
    2127         YY_BREAK
    2128 case 71:
     2147{ KEYWORD_RETURN(STATIC); }
     2148        YY_BREAK
     2149case 77:
    21292150YY_RULE_SETUP
    21302151#line 244 "lex.ll"
    2131 { KEYWORD_RETURN(SHORT); }
    2132         YY_BREAK
    2133 case 72:
     2152{ KEYWORD_RETURN(STATICASSERT); }               // C11
     2153        YY_BREAK
     2154case 78:
    21342155YY_RULE_SETUP
    21352156#line 245 "lex.ll"
    2136 { KEYWORD_RETURN(SIGNED); }
    2137         YY_BREAK
    2138 case 73:
     2157{ KEYWORD_RETURN(STRUCT); }
     2158        YY_BREAK
     2159case 79:
    21392160YY_RULE_SETUP
    21402161#line 246 "lex.ll"
    2141 { KEYWORD_RETURN(SIGNED); }                             // GCC
    2142         YY_BREAK
    2143 case 74:
     2162{ KEYWORD_RETURN(SWITCH); }
     2163        YY_BREAK
     2164case 80:
    21442165YY_RULE_SETUP
    21452166#line 247 "lex.ll"
    2146 { KEYWORD_RETURN(SIGNED); }                             // GCC
    2147         YY_BREAK
    2148 case 75:
     2167{ KEYWORD_RETURN(THREADLOCAL); }                // C11
     2168        YY_BREAK
     2169case 81:
    21492170YY_RULE_SETUP
    21502171#line 248 "lex.ll"
    2151 { KEYWORD_RETURN(SIZEOF); }
    2152         YY_BREAK
    2153 case 76:
     2172{ KEYWORD_RETURN(THROW); }                              // CFA
     2173        YY_BREAK
     2174case 82:
    21542175YY_RULE_SETUP
    21552176#line 249 "lex.ll"
    2156 { KEYWORD_RETURN(STATIC); }
    2157         YY_BREAK
    2158 case 77:
     2177{ KEYWORD_RETURN(TRY); }                                // CFA
     2178        YY_BREAK
     2179case 83:
    21592180YY_RULE_SETUP
    21602181#line 250 "lex.ll"
    2161 { KEYWORD_RETURN(STATICASSERT); }               // C11
    2162         YY_BREAK
    2163 case 78:
     2182{ KEYWORD_RETURN(TYPE); }                               // CFA
     2183        YY_BREAK
     2184case 84:
    21642185YY_RULE_SETUP
    21652186#line 251 "lex.ll"
    2166 { KEYWORD_RETURN(STRUCT); }
    2167         YY_BREAK
    2168 case 79:
     2187{ KEYWORD_RETURN(TYPEDEF); }
     2188        YY_BREAK
     2189case 85:
    21692190YY_RULE_SETUP
    21702191#line 252 "lex.ll"
    2171 { KEYWORD_RETURN(SWITCH); }
    2172         YY_BREAK
    2173 case 80:
     2192{ KEYWORD_RETURN(TYPEOF); }                             // GCC
     2193        YY_BREAK
     2194case 86:
    21742195YY_RULE_SETUP
    21752196#line 253 "lex.ll"
    2176 { KEYWORD_RETURN(THREADLOCAL); }                // C11
    2177         YY_BREAK
    2178 case 81:
     2197{ KEYWORD_RETURN(TYPEOF); }                             // GCC
     2198        YY_BREAK
     2199case 87:
    21792200YY_RULE_SETUP
    21802201#line 254 "lex.ll"
    2181 { KEYWORD_RETURN(THROW); }                              // CFA
    2182         YY_BREAK
    2183 case 82:
     2202{ KEYWORD_RETURN(TYPEOF); }                             // GCC
     2203        YY_BREAK
     2204case 88:
    21842205YY_RULE_SETUP
    21852206#line 255 "lex.ll"
    2186 { KEYWORD_RETURN(TRY); }                                // CFA
    2187         YY_BREAK
    2188 case 83:
     2207{ KEYWORD_RETURN(UNION); }
     2208        YY_BREAK
     2209case 89:
    21892210YY_RULE_SETUP
    21902211#line 256 "lex.ll"
    2191 { KEYWORD_RETURN(TYPE); }                               // CFA
    2192         YY_BREAK
    2193 case 84:
     2212{ KEYWORD_RETURN(UNSIGNED); }
     2213        YY_BREAK
     2214case 90:
    21942215YY_RULE_SETUP
    21952216#line 257 "lex.ll"
    2196 { KEYWORD_RETURN(TYPEDEF); }
    2197         YY_BREAK
    2198 case 85:
     2217{ KEYWORD_RETURN(VOID); }
     2218        YY_BREAK
     2219case 91:
    21992220YY_RULE_SETUP
    22002221#line 258 "lex.ll"
    2201 { KEYWORD_RETURN(TYPEOF); }                             // GCC
    2202         YY_BREAK
    2203 case 86:
     2222{ KEYWORD_RETURN(VOLATILE); }
     2223        YY_BREAK
     2224case 92:
    22042225YY_RULE_SETUP
    22052226#line 259 "lex.ll"
    2206 { KEYWORD_RETURN(TYPEOF); }                             // GCC
    2207         YY_BREAK
    2208 case 87:
     2227{ KEYWORD_RETURN(VOLATILE); }                   // GCC
     2228        YY_BREAK
     2229case 93:
    22092230YY_RULE_SETUP
    22102231#line 260 "lex.ll"
    2211 { KEYWORD_RETURN(TYPEOF); }                             // GCC
    2212         YY_BREAK
    2213 case 88:
     2232{ KEYWORD_RETURN(VOLATILE); }                   // GCC
     2233        YY_BREAK
     2234case 94:
    22142235YY_RULE_SETUP
    22152236#line 261 "lex.ll"
    2216 { KEYWORD_RETURN(UNION); }
    2217         YY_BREAK
    2218 case 89:
    2219 YY_RULE_SETUP
    2220 #line 262 "lex.ll"
    2221 { KEYWORD_RETURN(UNSIGNED); }
    2222         YY_BREAK
    2223 case 90:
    2224 YY_RULE_SETUP
    2225 #line 263 "lex.ll"
    2226 { KEYWORD_RETURN(VOID); }
    2227         YY_BREAK
    2228 case 91:
    2229 YY_RULE_SETUP
    2230 #line 264 "lex.ll"
    2231 { KEYWORD_RETURN(VOLATILE); }
    2232         YY_BREAK
    2233 case 92:
    2234 YY_RULE_SETUP
    2235 #line 265 "lex.ll"
    2236 { KEYWORD_RETURN(VOLATILE); }                   // GCC
    2237         YY_BREAK
    2238 case 93:
    2239 YY_RULE_SETUP
    2240 #line 266 "lex.ll"
    2241 { KEYWORD_RETURN(VOLATILE); }                   // GCC
    2242         YY_BREAK
    2243 case 94:
    2244 YY_RULE_SETUP
    2245 #line 267 "lex.ll"
    22462237{ KEYWORD_RETURN(WHILE); }
    22472238        YY_BREAK
    … …  
    22492240case 95:
    22502241YY_RULE_SETUP
    2251 #line 270 "lex.ll"
     2242#line 264 "lex.ll"
    22522243{ IDENTIFIER_RETURN(); }
    22532244        YY_BREAK
    22542245case 96:
    22552246YY_RULE_SETUP
    2256 #line 271 "lex.ll"
     2247#line 265 "lex.ll"
    22572248{ ATTRIBUTE_RETURN(); }
    22582249        YY_BREAK
    22592250case 97:
    22602251YY_RULE_SETUP
    2261 #line 272 "lex.ll"
     2252#line 266 "lex.ll"
    22622253{ BEGIN BKQUOTE; }
    22632254        YY_BREAK
    22642255case 98:
    22652256YY_RULE_SETUP
    2266 #line 273 "lex.ll"
     2257#line 267 "lex.ll"
    22672258{ IDENTIFIER_RETURN(); }
    22682259        YY_BREAK
    22692260case 99:
    22702261YY_RULE_SETUP
    2271 #line 274 "lex.ll"
     2262#line 268 "lex.ll"
    22722263{ BEGIN 0; }
    22732264        YY_BREAK
    … …  
    22752266case 100:
    22762267YY_RULE_SETUP
     2268#line 271 "lex.ll"
     2269{ NUMERIC_RETURN(ZERO); }                               // CFA
     2270        YY_BREAK
     2271case 101:
     2272YY_RULE_SETUP
     2273#line 272 "lex.ll"
     2274{ NUMERIC_RETURN(ONE); }                                // CFA
     2275        YY_BREAK
     2276case 102:
     2277YY_RULE_SETUP
     2278#line 273 "lex.ll"
     2279{ NUMERIC_RETURN(INTEGERconstant); }
     2280        YY_BREAK
     2281case 103:
     2282YY_RULE_SETUP
     2283#line 274 "lex.ll"
     2284{ NUMERIC_RETURN(INTEGERconstant); }
     2285        YY_BREAK
     2286case 104:
     2287YY_RULE_SETUP
     2288#line 275 "lex.ll"
     2289{ NUMERIC_RETURN(INTEGERconstant); }
     2290        YY_BREAK
     2291case 105:
     2292YY_RULE_SETUP
     2293#line 276 "lex.ll"
     2294{ NUMERIC_RETURN(FLOATINGconstant); }
     2295        YY_BREAK
     2296case 106:
     2297YY_RULE_SETUP
    22772298#line 277 "lex.ll"
    2278 { NUMERIC_RETURN(ZERO); }                               // CFA
    2279         YY_BREAK
    2280 case 101:
    2281 YY_RULE_SETUP
    2282 #line 278 "lex.ll"
    2283 { NUMERIC_RETURN(ONE); }                                // CFA
    2284         YY_BREAK
    2285 case 102:
    2286 YY_RULE_SETUP
    2287 #line 279 "lex.ll"
    2288 { NUMERIC_RETURN(INTEGERconstant); }
    2289         YY_BREAK
    2290 case 103:
    2291 YY_RULE_SETUP
    2292 #line 280 "lex.ll"
    2293 { NUMERIC_RETURN(INTEGERconstant); }
    2294         YY_BREAK
    2295 case 104:
    2296 YY_RULE_SETUP
    2297 #line 281 "lex.ll"
    2298 { NUMERIC_RETURN(INTEGERconstant); }
    2299         YY_BREAK
    2300 case 105:
    2301 YY_RULE_SETUP
    2302 #line 282 "lex.ll"
    2303 { NUMERIC_RETURN(FLOATINGconstant); }
    2304         YY_BREAK
    2305 case 106:
    2306 YY_RULE_SETUP
    2307 #line 283 "lex.ll"
    23082299{ NUMERIC_RETURN(FLOATINGconstant); }
    23092300        YY_BREAK
    … …  
    23112302case 107:
    23122303YY_RULE_SETUP
    2313 #line 286 "lex.ll"
     2304#line 280 "lex.ll"
    23142305{ BEGIN QUOTE; rm_underscore(); strtext = new std::string; *strtext += std::string( yytext ); }
    23152306        YY_BREAK
    23162307case 108:
    23172308YY_RULE_SETUP
    2318 #line 287 "lex.ll"
     2309#line 281 "lex.ll"
    23192310{ *strtext += std::string( yytext ); }
    23202311        YY_BREAK
    … …  
    23222313/* rule 109 can match eol */
    23232314YY_RULE_SETUP
    2324 #line 288 "lex.ll"
     2315#line 282 "lex.ll"
    23252316{ BEGIN 0; *strtext += std::string( yytext); RETURN_STR(CHARACTERconstant); }
    23262317        YY_BREAK
    … …  
    23292320case 110:
    23302321YY_RULE_SETUP
    2331 #line 292 "lex.ll"
     2322#line 286 "lex.ll"
    23322323{ BEGIN STRING; rm_underscore(); strtext = new std::string; *strtext += std::string( yytext ); }
    23332324        YY_BREAK
    23342325case 111:
    23352326YY_RULE_SETUP
    2336 #line 293 "lex.ll"
     2327#line 287 "lex.ll"
    23372328{ *strtext += std::string( yytext ); }
    23382329        YY_BREAK
    … …  
    23402331/* rule 112 can match eol */
    23412332YY_RULE_SETUP
    2342 #line 294 "lex.ll"
     2333#line 288 "lex.ll"
    23432334{ BEGIN 0; *strtext += std::string( yytext ); RETURN_STR(STRINGliteral); }
    23442335        YY_BREAK
    … …  
    23472338case 113:
    23482339YY_RULE_SETUP
    2349 #line 298 "lex.ll"
     2340#line 292 "lex.ll"
    23502341{ rm_underscore(); *strtext += std::string( yytext ); }
    23512342        YY_BREAK
    … …  
    23532344/* rule 114 can match eol */
    23542345YY_RULE_SETUP
    2355 #line 299 "lex.ll"
     2346#line 293 "lex.ll"
    23562347{}                                              // continuation (ALSO HANDLED BY CPP)
    23572348        YY_BREAK
    23582349case 115:
    23592350YY_RULE_SETUP
    2360 #line 300 "lex.ll"
     2351#line 294 "lex.ll"
    23612352{ *strtext += std::string( yytext ); } // unknown escape character
    23622353        YY_BREAK
    … …  
    23642355case 116:
    23652356YY_RULE_SETUP
     2357#line 297 "lex.ll"
     2358{ ASCIIOP_RETURN(); }
     2359        YY_BREAK
     2360case 117:
     2361YY_RULE_SETUP
     2362#line 298 "lex.ll"
     2363{ ASCIIOP_RETURN(); }
     2364        YY_BREAK
     2365case 118:
     2366YY_RULE_SETUP
     2367#line 299 "lex.ll"
     2368{ ASCIIOP_RETURN(); }
     2369        YY_BREAK
     2370case 119:
     2371YY_RULE_SETUP
     2372#line 300 "lex.ll"
     2373{ ASCIIOP_RETURN(); }
     2374        YY_BREAK
     2375case 120:
     2376YY_RULE_SETUP
     2377#line 301 "lex.ll"
     2378{ ASCIIOP_RETURN(); }
     2379        YY_BREAK
     2380case 121:
     2381YY_RULE_SETUP
     2382#line 302 "lex.ll"
     2383{ ASCIIOP_RETURN(); }
     2384        YY_BREAK
     2385case 122:
     2386YY_RULE_SETUP
    23662387#line 303 "lex.ll"
    2367 { ASCIIOP_RETURN(); }
    2368         YY_BREAK
    2369 case 117:
     2388{ ASCIIOP_RETURN(); }                                   // also operator
     2389        YY_BREAK
     2390case 123:
    23702391YY_RULE_SETUP
    23712392#line 304 "lex.ll"
    23722393{ ASCIIOP_RETURN(); }
    23732394        YY_BREAK
    2374 case 118:
     2395case 124:
    23752396YY_RULE_SETUP
    23762397#line 305 "lex.ll"
    23772398{ ASCIIOP_RETURN(); }
    23782399        YY_BREAK
    2379 case 119:
     2400case 125:
    23802401YY_RULE_SETUP
    23812402#line 306 "lex.ll"
    2382 { ASCIIOP_RETURN(); }
    2383         YY_BREAK
    2384 case 120:
     2403{ ASCIIOP_RETURN(); }                                   // also operator
     2404        YY_BREAK
     2405case 126:
    23852406YY_RULE_SETUP
    23862407#line 307 "lex.ll"
    2387 { ASCIIOP_RETURN(); }
    2388         YY_BREAK
    2389 case 121:
    2390 YY_RULE_SETUP
    2391 #line 308 "lex.ll"
    2392 { ASCIIOP_RETURN(); }
    2393         YY_BREAK
    2394 case 122:
    2395 YY_RULE_SETUP
    2396 #line 309 "lex.ll"
    2397 { ASCIIOP_RETURN(); }                                   // also operator
    2398         YY_BREAK
    2399 case 123:
    2400 YY_RULE_SETUP
    2401 #line 310 "lex.ll"
    2402 { ASCIIOP_RETURN(); }
    2403         YY_BREAK
    2404 case 124:
    2405 YY_RULE_SETUP
    2406 #line 311 "lex.ll"
    2407 { ASCIIOP_RETURN(); }
    2408         YY_BREAK
    2409 case 125:
    2410 YY_RULE_SETUP
    2411 #line 312 "lex.ll"
    2412 { ASCIIOP_RETURN(); }                                   // also operator
    2413         YY_BREAK
    2414 case 126:
    2415 YY_RULE_SETUP
    2416 #line 313 "lex.ll"
    24172408{ NAMEDOP_RETURN(ELLIPSIS); }
    24182409        YY_BREAK
    … …  
    24202411case 127:
    24212412YY_RULE_SETUP
    2422 #line 316 "lex.ll"
     2413#line 310 "lex.ll"
    24232414{ RETURN_VAL('['); }
    24242415        YY_BREAK
    24252416case 128:
    24262417YY_RULE_SETUP
    2427 #line 317 "lex.ll"
     2418#line 311 "lex.ll"
    24282419{ RETURN_VAL(']'); }
    24292420        YY_BREAK
    24302421case 129:
    24312422YY_RULE_SETUP
    2432 #line 318 "lex.ll"
     2423#line 312 "lex.ll"
    24332424{ RETURN_VAL('{'); }
    24342425        YY_BREAK
    24352426case 130:
    24362427YY_RULE_SETUP
    2437 #line 319 "lex.ll"
     2428#line 313 "lex.ll"
    24382429{ RETURN_VAL('}'); }
    24392430        YY_BREAK
    … …  
    24412432case 131:
    24422433YY_RULE_SETUP
     2434#line 316 "lex.ll"
     2435{ ASCIIOP_RETURN(); }
     2436        YY_BREAK
     2437case 132:
     2438YY_RULE_SETUP
     2439#line 317 "lex.ll"
     2440{ ASCIIOP_RETURN(); }
     2441        YY_BREAK
     2442case 133:
     2443YY_RULE_SETUP
     2444#line 318 "lex.ll"
     2445{ ASCIIOP_RETURN(); }
     2446        YY_BREAK
     2447case 134:
     2448YY_RULE_SETUP
     2449#line 319 "lex.ll"
     2450{ ASCIIOP_RETURN(); }
     2451        YY_BREAK
     2452case 135:
     2453YY_RULE_SETUP
     2454#line 320 "lex.ll"
     2455{ ASCIIOP_RETURN(); }
     2456        YY_BREAK
     2457case 136:
     2458YY_RULE_SETUP
     2459#line 321 "lex.ll"
     2460{ ASCIIOP_RETURN(); }
     2461        YY_BREAK
     2462case 137:
     2463YY_RULE_SETUP
    24432464#line 322 "lex.ll"
    24442465{ ASCIIOP_RETURN(); }
    24452466        YY_BREAK
    2446 case 132:
     2467case 138:
    24472468YY_RULE_SETUP
    24482469#line 323 "lex.ll"
    24492470{ ASCIIOP_RETURN(); }
    24502471        YY_BREAK
    2451 case 133:
     2472case 139:
    24522473YY_RULE_SETUP
    24532474#line 324 "lex.ll"
    24542475{ ASCIIOP_RETURN(); }
    24552476        YY_BREAK
    2456 case 134:
     2477case 140:
    24572478YY_RULE_SETUP
    24582479#line 325 "lex.ll"
    24592480{ ASCIIOP_RETURN(); }
    24602481        YY_BREAK
    2461 case 135:
     2482case 141:
    24622483YY_RULE_SETUP
    24632484#line 326 "lex.ll"
    24642485{ ASCIIOP_RETURN(); }
    24652486        YY_BREAK
    2466 case 136:
     2487case 142:
    24672488YY_RULE_SETUP
    24682489#line 327 "lex.ll"
    24692490{ ASCIIOP_RETURN(); }
    24702491        YY_BREAK
    2471 case 137:
     2492case 143:
    24722493YY_RULE_SETUP
    24732494#line 328 "lex.ll"
    24742495{ ASCIIOP_RETURN(); }
    24752496        YY_BREAK
    2476 case 138:
     2497case 144:
    24772498YY_RULE_SETUP
    24782499#line 329 "lex.ll"
    24792500{ ASCIIOP_RETURN(); }
    24802501        YY_BREAK
    2481 case 139:
    2482 YY_RULE_SETUP
    2483 #line 330 "lex.ll"
    2484 { ASCIIOP_RETURN(); }
    2485         YY_BREAK
    2486 case 140:
     2502case 145:
    24872503YY_RULE_SETUP
    24882504#line 331 "lex.ll"
    2489 { ASCIIOP_RETURN(); }
    2490         YY_BREAK
    2491 case 141:
     2505{ NAMEDOP_RETURN(ICR); }
     2506        YY_BREAK
     2507case 146:
    24922508YY_RULE_SETUP
    24932509#line 332 "lex.ll"
    2494 { ASCIIOP_RETURN(); }
    2495         YY_BREAK
    2496 case 142:
     2510{ NAMEDOP_RETURN(DECR); }
     2511        YY_BREAK
     2512case 147:
    24972513YY_RULE_SETUP
    24982514#line 333 "lex.ll"
    2499 { ASCIIOP_RETURN(); }
    2500         YY_BREAK
    2501 case 143:
     2515{ NAMEDOP_RETURN(EQ); }
     2516        YY_BREAK
     2517case 148:
    25022518YY_RULE_SETUP
    25032519#line 334 "lex.ll"
    2504 { ASCIIOP_RETURN(); }
    2505         YY_BREAK
    2506 case 144:
     2520{ NAMEDOP_RETURN(NE); }
     2521        YY_BREAK
     2522case 149:
    25072523YY_RULE_SETUP
    25082524#line 335 "lex.ll"
    2509 { ASCIIOP_RETURN(); }
    2510         YY_BREAK
    2511 case 145:
     2525{ NAMEDOP_RETURN(LS); }
     2526        YY_BREAK
     2527case 150:
     2528YY_RULE_SETUP
     2529#line 336 "lex.ll"
     2530{ NAMEDOP_RETURN(RS); }
     2531        YY_BREAK
     2532case 151:
    25122533YY_RULE_SETUP
    25132534#line 337 "lex.ll"
    2514 { NAMEDOP_RETURN(ICR); }
    2515         YY_BREAK
    2516 case 146:
     2535{ NAMEDOP_RETURN(LE); }
     2536        YY_BREAK
     2537case 152:
    25172538YY_RULE_SETUP
    25182539#line 338 "lex.ll"
    2519 { NAMEDOP_RETURN(DECR); }
    2520         YY_BREAK
    2521 case 147:
     2540{ NAMEDOP_RETURN(GE); }
     2541        YY_BREAK
     2542case 153:
    25222543YY_RULE_SETUP
    25232544#line 339 "lex.ll"
    2524 { NAMEDOP_RETURN(EQ); }
    2525         YY_BREAK
    2526 case 148:
     2545{ NAMEDOP_RETURN(ANDAND); }
     2546        YY_BREAK
     2547case 154:
    25272548YY_RULE_SETUP
    25282549#line 340 "lex.ll"
    2529 { NAMEDOP_RETURN(NE); }
    2530         YY_BREAK
    2531 case 149:
     2550{ NAMEDOP_RETURN(OROR); }
     2551        YY_BREAK
     2552case 155:
    25322553YY_RULE_SETUP
    25332554#line 341 "lex.ll"
    2534 { NAMEDOP_RETURN(LS); }
    2535         YY_BREAK
    2536 case 150:
     2555{ NAMEDOP_RETURN(ARROW); }
     2556        YY_BREAK
     2557case 156:
    25372558YY_RULE_SETUP
    25382559#line 342 "lex.ll"
    2539 { NAMEDOP_RETURN(RS); }
    2540         YY_BREAK
    2541 case 151:
     2560{ NAMEDOP_RETURN(PLUSassign); }
     2561        YY_BREAK
     2562case 157:
    25422563YY_RULE_SETUP
    25432564#line 343 "lex.ll"
    2544 { NAMEDOP_RETURN(LE); }
    2545         YY_BREAK
    2546 case 152:
     2565{ NAMEDOP_RETURN(MINUSassign); }
     2566        YY_BREAK
     2567case 158:
    25472568YY_RULE_SETUP
    25482569#line 344 "lex.ll"
    2549 { NAMEDOP_RETURN(GE); }
    2550         YY_BREAK
    2551 case 153:
     2570{ NAMEDOP_RETURN(MULTassign); }
     2571        YY_BREAK
     2572case 159:
    25522573YY_RULE_SETUP
    25532574#line 345 "lex.ll"
    2554 { NAMEDOP_RETURN(ANDAND); }
    2555         YY_BREAK
    2556 case 154:
     2575{ NAMEDOP_RETURN(DIVassign); }
     2576        YY_BREAK
     2577case 160:
    25572578YY_RULE_SETUP
    25582579#line 346 "lex.ll"
    2559 { NAMEDOP_RETURN(OROR); }
    2560         YY_BREAK
    2561 case 155:
     2580{ NAMEDOP_RETURN(MODassign); }
     2581        YY_BREAK
     2582case 161:
    25622583YY_RULE_SETUP
    25632584#line 347 "lex.ll"
    2564 { NAMEDOP_RETURN(ARROW); }
    2565         YY_BREAK
    2566 case 156:
     2585{ NAMEDOP_RETURN(ANDassign); }
     2586        YY_BREAK
     2587case 162:
    25672588YY_RULE_SETUP
    25682589#line 348 "lex.ll"
    2569 { NAMEDOP_RETURN(PLUSassign); }
    2570         YY_BREAK
    2571 case 157:
     2590{ NAMEDOP_RETURN(ORassign); }
     2591        YY_BREAK
     2592case 163:
    25722593YY_RULE_SETUP
    25732594#line 349 "lex.ll"
    2574 { NAMEDOP_RETURN(MINUSassign); }
    2575         YY_BREAK
    2576 case 158:
     2595{ NAMEDOP_RETURN(ERassign); }
     2596        YY_BREAK
     2597case 164:
    25772598YY_RULE_SETUP
    25782599#line 350 "lex.ll"
    2579 { NAMEDOP_RETURN(MULTassign); }
    2580         YY_BREAK
    2581 case 159:
     2600{ NAMEDOP_RETURN(LSassign); }
     2601        YY_BREAK
     2602case 165:
    25822603YY_RULE_SETUP
    25832604#line 351 "lex.ll"
    2584 { NAMEDOP_RETURN(DIVassign); }
    2585         YY_BREAK
    2586 case 160:
    2587 YY_RULE_SETUP
    2588 #line 352 "lex.ll"
    2589 { NAMEDOP_RETURN(MODassign); }
    2590         YY_BREAK
    2591 case 161:
    2592 YY_RULE_SETUP
    2593 #line 353 "lex.ll"
    2594 { NAMEDOP_RETURN(ANDassign); }
    2595         YY_BREAK
    2596 case 162:
    2597 YY_RULE_SETUP
    2598 #line 354 "lex.ll"
    2599 { NAMEDOP_RETURN(ORassign); }
    2600         YY_BREAK
    2601 case 163:
    2602 YY_RULE_SETUP
    2603 #line 355 "lex.ll"
    2604 { NAMEDOP_RETURN(ERassign); }
    2605         YY_BREAK
    2606 case 164:
    2607 YY_RULE_SETUP
    2608 #line 356 "lex.ll"
    2609 { NAMEDOP_RETURN(LSassign); }
    2610         YY_BREAK
    2611 case 165:
    2612 YY_RULE_SETUP
    2613 #line 357 "lex.ll"
    26142605{ NAMEDOP_RETURN(RSassign); }
    26152606        YY_BREAK
    … …  
    26172608case 166:
    26182609YY_RULE_SETUP
    2619 #line 360 "lex.ll"
     2610#line 354 "lex.ll"
    26202611{ IDENTIFIER_RETURN(); }                                // unary
    26212612        YY_BREAK
    26222613case 167:
    26232614YY_RULE_SETUP
    2624 #line 361 "lex.ll"
     2615#line 355 "lex.ll"
    26252616{ IDENTIFIER_RETURN(); }
    26262617        YY_BREAK
    26272618case 168:
    26282619YY_RULE_SETUP
    2629 #line 362 "lex.ll"
     2620#line 356 "lex.ll"
    26302621{ IDENTIFIER_RETURN(); }                // binary
    26312622        YY_BREAK
    … …  
    26582649case 169:
    26592650YY_RULE_SETUP
    2660 #line 389 "lex.ll"
     2651#line 383 "lex.ll"
    26612652{
    26622653        // 1 or 2 character unary operator ?
    … …  
    26732664case 170:
    26742665YY_RULE_SETUP
    2675 #line 401 "lex.ll"
     2666#line 395 "lex.ll"
    26762667{ printf("unknown character(s):\"%s\" on line %d\n", yytext, yylineno); }
    26772668        YY_BREAK
    26782669case 171:
    26792670YY_RULE_SETUP
    2680 #line 403 "lex.ll"
     2671#line 397 "lex.ll"
    26812672ECHO;
    26822673        YY_BREAK
    2683 #line 2684 "Parser/lex.cc"
     2674#line 2675 "Parser/lex.cc"
    26842675case YY_STATE_EOF(INITIAL):
    26852676case YY_STATE_EOF(COMMENT):
    … …  
    30133004
    30143005        return yy_is_jam ? 0 : yy_current_state;
    3015 }
    3016 
    3017     static void yyunput (int c, register char * yy_bp )
    3018 {
    3019         register char *yy_cp;
    3020    
    3021     yy_cp = (yy_c_buf_p);
    3022 
    3023         /* undo effects of setting up yytext */
    3024         *yy_cp = (yy_hold_char);
    3025 
    3026         if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
    3027                 { /* need to shift things up to make room */
    3028                 /* +2 for EOB chars. */
    3029                 register int number_to_move = (yy_n_chars) + 2;
    3030                 register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
    3031                                         YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
    3032                 register char *source =
    3033                                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
    3034 
    3035                 while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
    3036                         *--dest = *--source;
    3037 
    3038                 yy_cp += (int) (dest - source);
    3039                 yy_bp += (int) (dest - source);
    3040                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
    3041                         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
    3042 
    3043                 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
    3044                         YY_FATAL_ERROR( "flex scanner push-back overflow" );
    3045                 }
    3046 
    3047         *--yy_cp = (char) c;
    3048 
    3049     if ( c == '\n' ){
    3050         --yylineno;
    3051     }
    3052 
    3053         (yytext_ptr) = yy_bp;
    3054         (yy_hold_char) = *yy_cp;
    3055         (yy_c_buf_p) = yy_cp;
    30563006}
    30573007
    … …  
    36973647#define YYTABLES_NAME "yytables"
    36983648
    3699 #line 403 "lex.ll"
     3649#line 397 "lex.ll"
    37003650
    37013651

  • src/Parser/lex.h

    rcd623a4 r5f2f2d7  
    1010// Created On       : Sat Sep 22 08:58:10 2001
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Jun  6 07:44:39 2015
    13 // Update Count     : 338
     12// Last Modified On : Mon Jun  8 20:28:48 2015
     13// Update Count     : 341
    1414//
    1515
    … …  
    1818
    1919int yylex();
    20 void yyerror(char *);
     20void yyerror( const char * );
    2121
    2222// External declarations for information sharing between lexer and scanner
    … …  
    3535class Token {
    3636  public:
    37     std::string *str;
     37    std::string *str;                                                                   // must be pointer as used in union
    3838    Location loc;
    3939
    … …  
    4444
    4545// Local Variables: //
    46 // fill-column: 110 //
    4746// tab-width: 4 //
    4847// mode: c++ //

  • src/Parser/lex.ll

    rcd623a4 r5f2f2d7  
    1010 * Created On       : Sat Sep 22 08:58:10 2001
    1111 * Last Modified By : Peter A. Buhr
    12  * Last Modified On : Sun Jun  7 07:14:16 2015
    13  * Update Count     : 374
     12 * Last Modified On : Mon Jun  8 20:24:15 2015
     13 * Update Count     : 381
    1414 */
    1515
    1616%option yylineno
     17%option nounput
    1718
    1819%{
    … …  
    3233std::string *strtext;                                                                   // accumulate parts of character and string constant value
    3334
     35#define RETURN_LOCN(x)          yylval.tok.loc.file = yyfilename; yylval.tok.loc.line = yylineno; return(x)
     36#define RETURN_VAL(x)           yylval.tok.str = new std::string( yytext ); RETURN_LOCN(x)
     37#define RETURN_CHAR(x)          yylval.tok.str = NULL; RETURN_LOCN(x)
     38#define RETURN_STR(x)           yylval.tok.str = strtext; RETURN_LOCN(x)
     39
    3440#define WHITE_RETURN(x)                                                                 // do nothing
    3541#define NEWLINE_RETURN()        WHITE_RETURN('\n')
    36 #define RETURN_VAL(x)           yylval.tok.str = new std::string( yytext ); \
    37                                         yylval.tok.loc.file = yyfilename; \
    38                                         yylval.tok.loc.line = yylineno; \
    39                                         return(x)
    40 #define RETURN_STR(x)           yylval.tok.str = strtext; \
    41                                         yylval.tok.loc.file = yyfilename; \
    42                                         yylval.tok.loc.line = yylineno; \
    43                                         return(x)
    44 
    45 #define KEYWORD_RETURN(x)       RETURN_VAL(x)                           // keyword
     42#define ASCIIOP_RETURN()        RETURN_CHAR((int)yytext[0])     // single character operator
     43#define NAMEDOP_RETURN(x)       RETURN_VAL(x)                           // multichar operator, with a name
     44#define NUMERIC_RETURN(x)       rm_underscore(); RETURN_VAL(x) // numeric constant
     45#define KEYWORD_RETURN(x)       RETURN_CHAR(x)                          // keyword
    4646#define IDENTIFIER_RETURN()     RETURN_VAL((typedefTable.isIdentifier(yytext) ? IDENTIFIER : typedefTable.isTypedef(yytext) ? TYPEDEFname : TYPEGENname))
    47 //#define ATTRIBUTE_RETURN()    RETURN_VAL((typedefTable.isIdentifier(yytext) ? ATTR_IDENTIFIER : typedefTable.isTypedef(yytext) ? ATTR_TYPEDEFname : ATTR_TYPEGENname))
    4847#define ATTRIBUTE_RETURN()      RETURN_VAL(ATTR_IDENTIFIER)
    49 
    50 #define ASCIIOP_RETURN()        RETURN_VAL((int)yytext[0])      // single character operator
    51 #define NAMEDOP_RETURN(x)       RETURN_VAL(x)                           // multichar operator, with a name
    52 
    53 #define NUMERIC_RETURN(x)       rm_underscore(); RETURN_VAL(x) // numeric constant
    5448
    5549void rm_underscore() {

  • src/Parser/module.mk

    rcd623a4 r5f2f2d7  
    1111## Created On       : Sat May 16 15:29:09 2015
    1212## Last Modified By : Peter A. Buhr
    13 ## Last Modified On : Thu Jun  4 09:39:00 2015
    14 ## Update Count     : 86
     13## Last Modified On : Mon Jun  8 20:23:47 2015
     14## Update Count     : 87
    1515###############################################################################
    1616

  • src/Parser/parser.cc

    rcd623a4 r5f2f2d7  
    92669266// ----end of grammar----
    92679267
    9268 void yyerror( char *string ) {
    9269         using std::cout;
    9270         using std::endl;
    9271         cout << "Error ";
     9268void yyerror( const char * ) {
     9269        std::cout << "Error ";
    92729270        if ( yyfilename ) {
    9273                 cout << "in file " << yyfilename << " ";
    9274         }
    9275         cout << "at line " << yylineno << " reading token \"" << *(yylval.tok.str) << "\"" << endl;
     9271            std::cout << "in file " << yyfilename << " ";
     9272        } // if
     9273        std::cout << "at line " << yylineno << " reading token \"" << *(yylval.tok.str) << "\"" << std::endl;
    92769274}
    92779275
    92789276// Local Variables: //
    9279 // fill-column: 110 //
    92809277// tab-width: 4 //
    92819278// mode: c++ //

  • src/Parser/parser.yy

    rcd623a4 r5f2f2d7  
    1010// Created On       : Sat Sep  1 20:22:55 2001
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Jun  6 20:18:36 2015
    13 // Update Count     : 1026
     12// Last Modified On : Mon Jun  8 20:31:07 2015
     13// Update Count     : 1030
    1414//
    1515
    … …  
    27172717// ----end of grammar----
    27182718
    2719 void yyerror( char *string ) {
    2720         using std::cout;
    2721         using std::endl;
    2722         cout << "Error ";
     2719void yyerror( const char * ) {
     2720        std::cout << "Error ";
    27232721        if ( yyfilename ) {
    2724                 cout << "in file " << yyfilename << " ";
    2725         }
    2726         cout << "at line " << yylineno << " reading token \"" << *(yylval.tok.str) << "\"" << endl;
     2722            std::cout << "in file " << yyfilename << " ";
     2723        } // if
     2724        std::cout << "at line " << yylineno << " reading token \"" << *(yylval.tok.str) << "\"" << std::endl;
    27272725}
    27282726
    27292727// Local Variables: //
    2730 // fill-column: 110 //
    27312728// tab-width: 4 //
    27322729// mode: c++ //
Note: See TracChangeset for help on using the changeset viewer.