Return to asexpr.h CVS log

Up to [CSRG BSD Unix] / 43BSD / bin / as

Annotation of 43BSD/bin/as/asexpr.h, revision 1.1

1.1     ! root        1: /*
        !             2:  * Copyright (c) 1982 Regents of the University of California.
        !             3:  * All rights reserved.  The Berkeley software License Agreement
        !             4:  * specifies the terms and conditions for redistribution.
        !             5:  *
        !             6:  *     @(#)asexpr.h    5.1 (Berkeley) 4/30/85
        !             7:  */
        !             8: 
        !             9: /*
        !            10:  *     Definitions to parse tokens
        !            11:  */
        !            12: 
        !            13: #define ERROR(string)          yyerror(string); goto errorfix
        !            14: 
        !            15: #define peekahead (*tokptr)
        !            16: 
        !            17: #define shift                  val = yylex()
        !            18: #define advance        shift
        !            19: 
        !            20: #define shiftover(token)       if (val != token) { \
        !            21:                                        shiftoerror(token); \
        !            22:                                        goto errorfix; \
        !            23:                                } \
        !            24:                                shift
        !            25: 
        !            26: #define advanceover    shiftover
        !            27: 
        !            28: /*
        !            29:  *     To speed up the expression processing, we class the input tokens
        !            30:  *     into various sets.
        !            31:  *
        !            32:  *     We don't call the recursive descent expression analyzer if we can
        !            33:  *     determine by looking at the next token after the first token in
        !            34:  *     an expression that the expression is simple (name, integer or floating
        !            35:  *     point value).  Expressions with operators are parsed using the recursive
        !            36:  *     descent method.
        !            37:  */
        !            38: 
        !            39: /*
        !            40:  *     Functional forwards for expression utility routines
        !            41:  */
        !            42: struct exp     *combine();
        !            43: struct exp     *boolterm();
        !            44: struct exp     *term();
        !            45: struct exp     *factor();
        !            46: struct exp     *yukkyexpr();
        !            47: 
        !            48: /*
        !            49:  *     The set definitions
        !            50:  */
        !            51: 
        !            52: extern char    tokensets[(LASTTOKEN) - (FIRSTTOKEN) + 1];
        !            53: 
        !            54: #define        LINSTBEGIN      01      /*SEMI, NL, NAME*/
        !            55: #define        EBEGOPS         02      /*LP, MINUS, TILDE*/
        !            56: #define        YUKKYEXPRBEG    04      /*NAME, INSTn, INST0, REG, BFINT*/
        !            57: #define        SAFEEXPRBEG     010     /*INT, FLTNUM*/
        !            58: #define        ADDOPS          020     /*PLUS, MINUS*/
        !            59: #define        BOOLOPS         040     /*IOR, XOR, AND*/
        !            60: #define        MULOPS          0100    /*LSH, RSH, MUL, DIV, TILDE*/
        !            61: 
        !            62: #define        INTOKSET(val, set)      (tokensets[(val)] & (set) )
        !            63: 
        !            64: inttoktype     exprparse();
        !            65: inttoktype     funnyreg();
        !            66: inttoktype     yylex();
        !            67: 
        !            68: #define expr(xp, val) { \
        !            69:        if ( (!INTOKSET(val, EBEGOPS)) && (!INTOKSET(peekahead, ADDOPS+BOOLOPS+MULOPS))) { \
        !            70:                if (INTOKSET(val, YUKKYEXPRBEG)) xp = yukkyexpr(val, yylval); \
        !            71:                else xp = (struct exp *) yylval; \
        !            72:                shift; \
        !            73:        } else { \
        !            74:                val = exprparse(val, ptrloc1xp); \
        !            75:                xp = loc1xp; \
        !            76:        } \
        !            77:     }
        !            78: 
        !            79: /*
        !            80:  *     Registers can be either of the form r0...pc, or
        !            81:  *     of the form % <expression>
        !            82:  *     NOTE:   Reizers documentation on the assembler says that it
        !            83:  *     can be of the form r0 + <expression>.. That's not true.
        !            84:  *
        !            85:  *     NOTE:   Reizer's yacc grammar would seem to allow an expression
        !            86:  *     to be: (This is undocumented)
        !            87:  *             a)      a register
        !            88:  *             b)      an Instruction (INSTn or INST0)
        !            89:  */
        !            90: 
        !            91: #define findreg(regno) \
        !            92:        if (val == REG) { \
        !            93:                regno = yylval; \
        !            94:                shift; \
        !            95:        } else \
        !            96:        if (val == REGOP) { \
        !            97:                shift;  /*over the REGOP*/ \
        !            98:                val = funnyreg(val, ptrregno); \
        !            99:        } \
        !           100:        else { ERROR ("register expected"); }

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