Annotation of 43BSD/usr.bin/struct/lextab.l, revision 1.1

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

unix.superglobalmegacorp.com

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