Return to sets.lex.l CVS log

Up to [Research Unix] / researchv10dc / cmd / cyntax / sets

Annotation of researchv10dc/cmd/cyntax/sets/sets.lex.l, revision 1.1

1.1     ! root        1: %start SOURCE COMMENT STRING CHAR DEFN SETDEFN INIT C_DEFN C_SETDEFN C_INIT
        !             2: 
        !             3: %{
        !             4: #include       "sets.h"
        !             5: 
        !             6: #define        RETURN          return (int)
        !             7: %}
        !             8: 
        !             9: A      [A-Za-z_]
        !            10: AN     [A-Za-z_0-9]
        !            11: X      [0-9A-Fa-f]
        !            12: D      [0-9]
        !            13: O      [0-7]
        !            14: WS     [ \t\n\f]+
        !            15: 
        !            16: %%
        !            17: 
        !            18: <SOURCE>"/*"           {
        !            19:                                ECHO;
        !            20:                                BEGIN COMMENT;
        !            21:                        }
        !            22: 
        !            23: <SOURCE>\"             {
        !            24:                                ECHO;
        !            25:                                BEGIN STRING;
        !            26:                        }
        !            27: 
        !            28: <SOURCE>"'"            {
        !            29:                                ECHO;
        !            30:                                BEGIN CHAR;
        !            31:                        }
        !            32: 
        !            33: <SOURCE>set            {
        !            34:                                BEGIN SETDEFN;
        !            35:                                RETURN sy_set;
        !            36:                        }
        !            37: 
        !            38: <SOURCE>typedef                {
        !            39:                                ECHO;
        !            40:                                BEGIN DEFN;
        !            41:                                RETURN sy_typedef;
        !            42:                        }
        !            43: 
        !            44: <SOURCE>enum           {
        !            45:                                ECHO;
        !            46:                                BEGIN DEFN;
        !            47:                                RETURN sy_enum;
        !            48:                        }
        !            49: 
        !            50: <SOURCE>{A}{AN}*       ECHO;
        !            51: 
        !            52: <SOURCE>"[["           {
        !            53:                                BEGIN INIT;
        !            54:                                RETURN sy_on_squares;
        !            55:                        }
        !            56: 
        !            57: <SOURCE>.              putchar(*yytext);
        !            58: 
        !            59: <STRING>\\\"           ECHO;
        !            60: 
        !            61: <STRING>\"             {
        !            62:                                ECHO;
        !            63:                                BEGIN SOURCE;
        !            64:                        }
        !            65: 
        !            66: <STRING>\\\\           ECHO;
        !            67: 
        !            68: <STRING>.              ECHO;
        !            69: 
        !            70: <CHAR>\\"'"            ECHO;
        !            71: 
        !            72: <CHAR>"'"              {
        !            73:                                ECHO;
        !            74:                                BEGIN SOURCE;
        !            75:                        }
        !            76: 
        !            77: <CHAR>\\\\             ECHO;
        !            78: 
        !            79: <CHAR>.                        ECHO;
        !            80: 
        !            81: <COMMENT>"*/"          {
        !            82:                                ECHO;
        !            83:                                BEGIN SOURCE;
        !            84:                        }
        !            85: 
        !            86: <COMMENT>.             ECHO;
        !            87: 
        !            88: <DEFN>"/*"             {
        !            89:                                ECHO;
        !            90:                                BEGIN C_DEFN;
        !            91:                        }
        !            92: 
        !            93: <DEFN>{WS}             ECHO;
        !            94: 
        !            95: <DEFN>enum             {
        !            96:                                ECHO;
        !            97:                                RETURN sy_enum;
        !            98:                        }
        !            99: 
        !           100: <DEFN>set              {
        !           101:                                BEGIN SETDEFN;
        !           102:                                RETURN sy_set;
        !           103:                        }
        !           104: 
        !           105: <DEFN>{A}{AN}*         {
        !           106:                                ECHO;
        !           107:                                RETURN sy_id;
        !           108:                        }
        !           109: 
        !           110: <DEFN>"{"              {
        !           111:                                ECHO;
        !           112:                                RETURN sy_on_curly;
        !           113:                        }
        !           114: 
        !           115: <DEFN>"}"              {
        !           116:                                ECHO;
        !           117:                                RETURN sy_off_curly;
        !           118:                        }
        !           119: 
        !           120: <DEFN>","              {
        !           121:                                ECHO;
        !           122:                                RETURN sy_comma;
        !           123:                        }
        !           124: 
        !           125: <DEFN>.                        {
        !           126:                                ECHO;
        !           127:                                fprintf(stderr, "%s: line %d, ignored unknown character (%s) in definition\n", myname, yylineno, print_char());
        !           128:                        }
        !           129: 
        !           130: <C_DEFN>"*/"           {
        !           131:                                ECHO;
        !           132:                                BEGIN DEFN;
        !           133:                        }
        !           134: 
        !           135: <C_DEFN>.              ECHO;
        !           136: 
        !           137: <SETDEFN>"/*"          {
        !           138:                                ECHO;
        !           139:                                BEGIN C_SETDEFN;
        !           140:                        }
        !           141: 
        !           142: <SETDEFN>{WS}          ECHO;
        !           143: 
        !           144: <SETDEFN>char          RETURN sy_char;
        !           145: 
        !           146: <SETDEFN>{A}{AN}*      RETURN sy_id;
        !           147: 
        !           148: <SETDEFN>.             fprintf(stderr, "%s: line %d, ignored unknown character (%s) in set definition\n", myname, yylineno, print_char());
        !           149: 
        !           150: <C_SETDEFN>"*/"                {
        !           151:                                ECHO;
        !           152:                                BEGIN SETDEFN;
        !           153:                        }
        !           154: 
        !           155: <C_SETDEFN>.           ECHO;
        !           156: 
        !           157: <INIT>"/*"             {
        !           158:                                ECHO;
        !           159:                                BEGIN C_INIT;
        !           160:                        }
        !           161: 
        !           162: <INIT>{WS}             ECHO;
        !           163: 
        !           164: <INIT>"]]"             {
        !           165:                                BEGIN SOURCE;
        !           166:                                RETURN sy_off_squares;
        !           167:                        }
        !           168: 
        !           169: <INIT>","              RETURN sy_comma;
        !           170: 
        !           171: <INIT>".."             RETURN sy_dot_dot;
        !           172: 
        !           173: <INIT>{A}{AN}*         RETURN sy_id;
        !           174: 
        !           175: <INIT>0[xX]{X}+                {
        !           176:                                sscanf(yytext + 2, "%x", &yylval);
        !           177:                                RETURN sy_int;
        !           178:                        }
        !           179: 
        !           180: <INIT>0{O}+            {
        !           181:                                sscanf(yytext, "%o", &yylval);
        !           182:                                RETURN sy_int;
        !           183:                        }
        !           184: 
        !           185: <INIT>{D}+             {
        !           186:                                sscanf(yytext, "%d", &yylval);
        !           187:                                RETURN sy_int;
        !           188:                        }
        !           189: 
        !           190: <INIT>'.'              {
        !           191:                                yylval = yytext[1];
        !           192:                                RETURN sy_int;
        !           193:                        }
        !           194: 
        !           195: <INIT>'\\{O}[{O}[{O}]]'        {
        !           196:                                sscanf(yytext + 2, "%o", &yylval);
        !           197:                                RETURN sy_int;
        !           198:                        }
        !           199: 
        !           200: <INIT>'\\.'            {
        !           201:                                switch (yytext[2])
        !           202:                                {
        !           203:                                case 'n':
        !           204:                                        yylval = '\n';
        !           205:                                        break;
        !           206: 
        !           207:                                case 't':
        !           208:                                        yylval = '\t';
        !           209:                                        break;
        !           210: 
        !           211:                                case 'b':
        !           212:                                        yylval = '\b';
        !           213:                                        break;
        !           214: 
        !           215:                                case 'r':
        !           216:                                        yylval = '\r';
        !           217:                                        break;
        !           218: 
        !           219:                                case 'f':
        !           220:                                        yylval = '\f';
        !           221:                                        break;
        !           222: 
        !           223:                                default:
        !           224:                                        yylval = yytext[2];
        !           225:                                        break;
        !           226:                                }
        !           227:                                RETURN sy_int;
        !           228:                        }
        !           229: 
        !           230: <INIT>.                        fprintf(stderr, "%s: line %d, ignored unknown character (%s) in set initialisation\n", myname, yylineno, print_char());
        !           231: 
        !           232: <C_INIT>"*/"           {
        !           233:                                ECHO;
        !           234:                                BEGIN INIT;
        !           235:                        }
        !           236: 
        !           237: <C_INIT>.              ECHO;
        !           238: 
        !           239: %%
        !           240: 
        !           241: begin_source()
        !           242: {
        !           243:        BEGIN SOURCE;
        !           244: }
        !           245: 
        !           246: begin_setdefn()
        !           247: {
        !           248:        BEGIN SETDEFN;
        !           249: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.