Annotation of researchv10no/cmd/struct/lextab.l, revision 1.1

1.1     ! root        1: %{
        !             2: #include "y.tab.h"
        !             3: #include "b.h"
        !             4: #undef input
        !             5: #define input()        ninput()
        !             6: #undef unput
        !             7: #define unput(c)       nunput(c)
        !             8: extern int yylval;
        !             9: #define xxbpmax        1700
        !            10: char xxbuf[xxbpmax + 2];
        !            11: int xxbp = -1;
        !            12: #define xxunmax        200
        !            13: char xxunbuf[xxunmax + 2];
        !            14: int xxunbp = -1;
        !            15: 
        !            16: 
        !            17: int blflag;
        !            18: %}
        !            19: 
        !            20: D      [0-9]
        !            21: A      [0-9a-z]
        !            22: L      [a-z]
        !            23: SP     [^0-9a-z]
        !            24: 
        !            25: %%
        !            26: 
        !            27: %{
        !            28: char *xxtbuff;
        !            29: int xxj, xxn, xxk;
        !            30: char *xxp;
        !            31: %}
        !            32: [=/,(]{D}+[h]                  {
        !            33:                                blflag = 1;
        !            34:                                sscanf(&yytext[1],"%d",&xxn);
        !            35:                                xxtbuff = malloc(2*xxn+3);
        !            36:                                for (xxj = xxk = 1; xxj <= xxn; ++xxj)
        !            37:                                        {
        !            38:                                        xxtbuff[xxk] = ninput();
        !            39:                                        if (xxtbuff[xxk] == '"')
        !            40:                                                xxtbuff[++xxk] = '"';
        !            41:                                        ++xxk;
        !            42:                                        }
        !            43:                                xxtbuff[0] = xxtbuff[xxk++] = '"';
        !            44:                                xxtbuff[xxk] = '\0';
        !            45:                                putback(xxtbuff);
        !            46:                                free(xxtbuff);
        !            47: 
        !            48:                                backup(yytext[0]);
        !            49:                                blflag = 0;
        !            50:                                xxbp = -1;
        !            51:                                }
        !            52: IF                     {fixval(); xxbp = -1; return(xxif);}
        !            53: ELSE                   {fixval(); xxbp = -1; return(xxelse);}
        !            54: REPEAT                 {fixval(); xxbp = -1; return(xxrept); }
        !            55: WHILE                  {fixval(); xxbp = -1; return(xxwhile); }
        !            56: UNTIL                  { fixval(); xxbp = -1; return(xxuntil); }
        !            57: DO                     {fixval(); xxbp = -1; return(xxdo); }
        !            58: SWITCH                 {fixval(); xxbp = -1; return(xxswitch); }
        !            59: CASE                   {fixval(); xxbp = -1; return(xxcase); }
        !            60: DEFAULT                        {fixval(); xxbp = -1; return(xxdefault); }
        !            61: END                    {fixval(); xxbp = -1; return(xxend); }
        !            62: 
        !            63: ".true."               |
        !            64: ".false."              |
        !            65: 
        !            66: {L}{A}*                {fixval(); xxbp = -1; return(xxident); }
        !            67: ~{D}+                  {xxbuf[0] = ' '; fixval(); xxbp = -1; return(xxnum); }
        !            68: {D}+/"."(ge|gt|le|lt|eq|ne|not|or|and)"."      |
        !            69: {D}+\.?                        |
        !            70: {D}+\.?[de][+-]?{D}+           |
        !            71: {D}*\.{D}+[de][+-]?{D}+                |
        !            72: {D}*\.{D}+                     {fixval(); xxbp = -1; return(xxnum); }
        !            73: 
        !            74: ".gt."                 { putback(">"); xxbp = -1; }
        !            75: ".ge."                 { putback(">=");xxbp = -1; }
        !            76: ".lt."                 { putback("<"); xxbp = -1; }
        !            77: ".le."                 { putback("<="); xxbp = -1; }
        !            78: ".eq."                 { putback("=="); xxbp = -1; }
        !            79: ".ne."                 { putback("!="); xxbp = -1; }
        !            80: ".not."                        { putback("!"); xxbp = -1; }
        !            81: ".or."                 { putback("||"); xxbp = -1; }
        !            82: ".and."                        { putback("&&"); xxbp = -1; }
        !            83: ">="           {fixval(); xxbp = -1;  return(xxge);  }
        !            84: "<="           {fixval(); xxbp = -1;  return(xxle); }
        !            85: ==                     {fixval(); xxbp = -1; return(xxeq); }
        !            86: !=                     {fixval(); xxbp = -1; return(xxne); }
        !            87: "||"                   {fixval(); xxbp = -1; return('|'); }
        !            88: "&&"                   {fixval(); xxbp = -1;  return('&'); }
        !            89: "**"                   {fixval(); xxbp = -1; return('^'); }
        !            90: 
        !            91: #.*                    {fixval(); xxbp = -1; return(xxcom); }
        !            92: \"([^"]|\"\")*\"               {fixval(); xxbp = -1; return(xxstring); }
        !            93: '([^']|'')*'                           {
        !            94:                                        fixval();
        !            95:                                        xxp = yylval;
        !            96:                                        xxn = slength(xxp);
        !            97:                                        xxtbuff = malloc(2*xxn+1);
        !            98:                                        xxtbuff[0] = '"';
        !            99:                                        for (xxj = xxk = 1; xxj < xxn-1; ++xxj)
        !           100:                                                {
        !           101:                                                if (xxp[xxj] == '\'' && xxp[++xxj] == '\'')
        !           102:                                                        xxtbuff[xxk++] = '\'';
        !           103:                                                else if (xxp[xxj] == '"')
        !           104:                                                        {
        !           105:                                                        xxtbuff[xxk++] = '"';
        !           106:                                                        xxtbuff[xxk++] = '"';
        !           107:                                                        }
        !           108:                                                else
        !           109:                                                        xxtbuff[xxk++] = xxp[xxj];
        !           110:                                                }
        !           111:                                        xxtbuff[xxk++] = '"';
        !           112:                                        xxtbuff[xxk] = '\0';
        !           113:                                        free(xxp);
        !           114:                                        yylval = xxtbuff;
        !           115:                                        xxbp = -1;
        !           116:                                        return(xxstring);
        !           117:                                        }
        !           118: 
        !           119: ^\n            xxbp = -1;
        !           120: \n             {xxbp = -1; if (newflag) {fixval(); return('\n'); }  }
        !           121: {SP}           {fixval(); xxbp = -1; return(yytext[0]); }
        !           122: 
        !           123: %%
        !           124: 
        !           125: rdchar()
        !           126:        {
        !           127:        int c;
        !           128:        if (xxunbp >= 0)
        !           129:                return(xxunbuf[xxunbp--]);
        !           130:        c = getchar();
        !           131:        if (c == EOF) return('\0');
        !           132:        else return((char)c);
        !           133:        }
        !           134: 
        !           135: backup(c)
        !           136: char c;
        !           137:        {
        !           138:        if (++xxunbp > xxunmax)
        !           139:                {
        !           140:                xxunbuf[xxunmax + 1] = '\0';
        !           141:                error("RATFOR beautifying; input backed up too far during lex:\n",
        !           142:                        xxunbuf,"\n");
        !           143:                }
        !           144:        xxunbuf[xxunbp] = c;
        !           145:        }
        !           146: 
        !           147: nunput(c)
        !           148: char c;
        !           149:        {
        !           150:        backup(c);
        !           151:        if (xxbp < 0) return;
        !           152:        if (c != xxbuf[xxbp])
        !           153:                {
        !           154:                xxbuf[xxbp + 1] = '\0';
        !           155:                error("RATFOR beautifying; lex call of nunput with wrong char:\n",
        !           156:                        xxbuf,"\n");
        !           157:                }
        !           158:        for ( --xxbp; xxbp >= 0 && (xxbuf[xxbp] == ' ' || xxbuf[xxbp] == '\t'); --xxbp)
        !           159:                backup(xxbuf[xxbp]);
        !           160:        xxbuf[xxbp+1] = '\0';
        !           161:        }
        !           162: 
        !           163: ninput()
        !           164:        {
        !           165:        char c,d;
        !           166:        if (blflag) c = rdchar();
        !           167:        else
        !           168:                while ( (c = rdchar()) == ' ' || c == '\t')
        !           169:                addbuf(c);
        !           170:        if (c != '\n')
        !           171:                return(addbuf(c));
        !           172:        while ( (d = rdchar()) == ' ' || d == '\t');
        !           173:        if (d == '&')
        !           174:                return(ninput());
        !           175:        backup(d);
        !           176:        return(addbuf('\n'));
        !           177:        }
        !           178: 
        !           179: addbuf(c)
        !           180: char c;
        !           181:        {
        !           182:        if (++xxbp > xxbpmax)
        !           183:                {
        !           184:                xxbuf[xxbpmax +1] = '\0';
        !           185:                error("RATFOR beautifying; buffer xxbuf too small for token beginning:\n",
        !           186:                        xxbuf,"\n");
        !           187:                }
        !           188:        xxbuf[xxbp] = c;
        !           189:        xxbuf[xxbp + 1] = '\0';
        !           190:        return(c);
        !           191:        }
        !           192: 
        !           193: 
        !           194: fixval()
        !           195:        {
        !           196:        int i, j, k;
        !           197:        for (j = 0; xxbuf[j] == ' ' || xxbuf[j] == '\t'; ++j);
        !           198:        for (k = j; xxbuf[k] != '\0'; ++k);
        !           199:        for (--k; k > j && xxbuf[k] == ' ' || xxbuf[k]  == '\t'; --k);
        !           200:        xxbuf[k+1] = '\0';
        !           201:        i = slength(&xxbuf[j]) + 1;
        !           202:        yylval = malloc(i);
        !           203:        str_copy(&xxbuf[j],yylval,i);
        !           204:        }
        !           205: 
        !           206: 
        !           207: 
        !           208: putback(str)
        !           209: char *str;
        !           210:        {
        !           211:        int i;
        !           212:        for (i = 0; str[i] != '\0'; ++i);
        !           213:        for (--i; i >= 0; --i)
        !           214:                backup(str[i]);
        !           215:        }
        !           216: 

unix.superglobalmegacorp.com

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