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     ! 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.