Return to kas0.l CVS log

Up to [Research Unix] / researchv10no / cmd / kasb

Annotation of researchv10no/cmd/kasb/kas0.l, revision 1.1.1.1

1.1       root        1: /*     @(#)kas0.l      1.1     */
                      2: %%
                      3: %{
                      4:        struct symtab *op;
                      5:        static struct symtab tmplab;
                      6: %}
                      7: [ \t]  ;
                      8: "/*"   {
                      9:        char c;
                     10: 
                     11:        while(c=input()) {
                     12:                if (c=='\n')
                     13:                        lineno++;
                     14:                else if (c=='*')
                     15:                        if ((c=input())=='/')
                     16:                                break;
                     17:                        else
                     18:                                unput(c);
                     19:        }
                     20:        }
                     21: [\._a-zA-Z][0-9\._a-zA-Z]*     {
                     22:        if ((op = *lookup(1))->type&XTAG) {
                     23:                yylval.sym = op;
                     24:                return(op->type&~XTAG);
                     25:        } else {
                     26:                yylval.sym = op;
                     27:                if ((op->type&XTYPE)==XUNDEF)
                     28:                        return(UNAME);
                     29:                else    return(DNAME);
                     30:        }
                     31:        }
                     32: [0-9][bf]      {
                     33:        op = &loclab[yytext[0]-'0'];
                     34:        if (yytext[1]=='b') {
                     35:                if (op->name[0]==0)
                     36:                        yyerror("undefined numeric label");
                     37:                tmplab.value = op->type;
                     38:                tmplab.type = XTEXT;
                     39:                yylval.sym = &tmplab;
                     40:                return(DNAME);
                     41:        } else {
                     42:                yylval.sym = op;
                     43:                return(TNAME);
                     44:        }
                     45:        }
                     46: 0[0-7]*        {
                     47:        sscanf(yytext, "%o", &yylval.ival);
                     48:        return(INT);
                     49:        }
                     50: 0[xX][0-9a-fA-F]+      {
                     51:        sscanf(&yytext[2], "%x", &yylval.ival);
                     52:        return(INT);
                     53:        }
                     54: [1-9][0-9]*    {
                     55:        sscanf(yytext, "%d", &yylval.ival);
                     56:        return(INT);
                     57:        }
                     58: "\n"   return(NL);
                     59: "%"    return(POP);
                     60: "("    return(LP);
                     61: ")"    return(RP);
                     62: "*"    return(MUL);
                     63: "/"    return(DIV);
                     64: "++"   return(INC);
                     65: "+"    return(PLUS);
                     66: "-"    return(MINUS);
                     67: ","    return(CM);
                     68: ":"    return(COLON);
                     69: ";"    return(SEMI);
                     70: "|"    return(BAR);
                     71: "~"    return(NOT);
                     72: "&"    return(AND);
                     73: ">>"   return(RS);
                     74: "<<"   return(LS);
                     75: "^"    return(XOR);
                     76: ^!.*   {
                     77:        system(&yytext[1]);
                     78:        printf("!\n");
                     79:        }
                     80: ^#.*\n {
                     81:        if (sscanf(&yytext[1], "%d%*[\" ]%[^\"\n]", &lineno, infile = instr)<1)
                     82:                yyerror("illegal preprocessor line");
                     83:        }
                     84: '\\.'  {
                     85:        switch(yytext[2]) {
                     86:        case  '0':
                     87:                yylval.ival = 0;
                     88:                break;
                     89:        case 'b':
                     90:                yylval.ival = 010;
                     91:                break;
                     92:        case 't':
                     93:                yylval.ival = 011;
                     94:                break;
                     95:        case 'n':
                     96:                yylval.ival = 012;
                     97:                break;
                     98:        case 'f':
                     99:                yylval.ival = 014;
                    100:                break;
                    101:        case 'r':
                    102:                yylval.ival = 015;
                    103:                break;
                    104:        default:
                    105:                yylval.ival = yytext[2];
                    106:        }
                    107:        return(INT);
                    108:        }
                    109: '.'    {
                    110:        yylval.ival = yytext[1];
                    111:        return(INT);
                    112:        }
                    113: \"[^"\n]*\"    {
                    114:        yytext[yyleng-1] = '\0';
                    115:        strcpy(dbstr, &yytext[1]);
                    116:        yylval.str = dbstr;
                    117:        return(STR);
                    118:        }
                    119: .      {
                    120:        yyerror("Illegal character");
                    121:        return(NOCHAR);
                    122:        }
                    123: %%

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