Return to pcctokens CVS log

Up to [CSRG BSD Unix] / 43BSDTahoe / lib / old_compiler / pcc / pcc.tahoe

Annotation of 43BSDTahoe/lib/old_compiler/pcc/pcc.tahoe/pcctokens, revision 1.1.1.1

1.1       root        1: %term  TOKENS  0
                      2: %term  ERROR   1       /* an error node */
                      3: %term  FREE    2       /* an unused node */
                      4: %term  STRING  3       /* a string constant */
                      5: %term  ICON    4       /* an integer constant */
                      6: %term  FCON    5       /* a floating point constant */
                      7: %term  DCON    6       /* a double precision f.p. constant */
                      8: %term  NAME    7       /* an identifier */
                      9: %term  REG             8       /* a register */
                     10: %term  OREG    9       /* register and offset */
                     11: %term  CCODES  10      /* condition codes */
                     12: %term  FLD             11      /* a bit field */
                     13: %term  PLUS    12      /* + */
                     14: %term  PLUSEQ  13      /* += */
                     15: %term  UPLUS   14      /* unary + (for completeness) */
                     16: %term  MINUS   15      /* - */
                     17: %term  MINUSEQ 16      /* -= */
                     18: %term  UMINUS  17      /* unary - */
                     19: %term  MUL             18      /* * */
                     20: %term  MULEQ   19      /* *= */
                     21: %term  DIV             21      /* / */
                     22: %term  DIVEQ   22      /* /= */
                     23: %term  MOD             23      /* % */
                     24: %term  MODEQ   24      /* %= */
                     25: %term  INCR    25      /* ++ */
                     26: %term  DECR    26      /* -- */
                     27: %term  ASSIGN  27      /* = (these last 3 are stretching it) */
                     28: %term  AND             28      /* & */
                     29: %term  ANDEQ   29      /* &= */
                     30: %term  OR              31      /* | */
                     31: %term  OREQ    32      /* |= */
                     32: %term  ER              33      /* ^ */
                     33: %term  EREQ    34      /* ^= */
                     34: %term  LS              35      /* << */
                     35: %term  LSEQ    36      /* <<= */
                     36: %term  RS              37      /* >> */
                     37: %term  RSEQ    38      /* >>= */
                     38: %term  COMPL   39      /* ~ */
                     39: %term  EQ              40      /* == */
                     40: %term  NE              41      /* != */
                     41: %term  LE              42      /* <= */
                     42: %term  LT              43      /* < */
                     43: %term  GE              44      /* >= */
                     44: %term  GT              45      /* > */
                     45: %term  ULE             46      /* unsigned <= */
                     46: %term  ULT             47      /* unsigned < */
                     47: %term  UGE             48      /* unsigned >= */
                     48: %term  UGT             49      /* unsigned > */
                     49: %term  QUEST   50      /* ? (for conditional expressions) */
                     50: %term  COLON   51      /* : (for conditional expressions) */
                     51: %term  ANDAND  52      /* && */
                     52: %term  OROR    53      /* || */
                     53: %term  NOT             54      /* ! */
                     54: %term  CALL    55      /* call by value */
                     55: %term  UCALL   57      /* call with no arguments */
                     56: %term  FORTCALL        58      /* call by reference? */
                     57: %term  UFORTCALL       60      /* ??? */
                     58: %term  INLINE  61      /* inline function */
                     59: %term  UINLINE 63      /* inline with no arguments */
                     60: %term  DEREF   20      /* * */
                     61: %term  ADDROF  30      /* & */
                     62: %term  DOT             64      /* . */
                     63: %term  STREF   65      /* -> */
                     64: %term  STASG   66      /* structure assignment */
                     65: %term  STARG   67      /* an argument of type structure */
                     66: %term  STCALL  68      /* a function of type structure */
                     67: %term  USTCALL 70      /* unary structure function */
                     68: %term  SCONV   71      /* scalar conversion */
                     69: %term  PCONV   72      /* pointer conversion */
                     70: %term  PMCONV  73      /* pointer multiply conversion */
                     71: %term  PVCONV  74      /* pointer divide conversion */
                     72: %term  CAST    75      /* redundant? */
                     73: %term  LB              76      /* [ */
                     74: %term  RB              77      /* ] */
                     75: %term  COMOP   78      /* , (in expressions) */
                     76: %term  CM              79      /* , (in argument lists) */
                     77: %term  FORCE   80      /* result of last expression goes in r0 */
                     78: %term  GOTO    81      /* unconditional goto */
                     79: %term  CBRANCH 82      /* goto label if !test */
                     80: %term  RETURN  83      /* return from function */
                     81: %term  INIT    84      /* initialized data */
                     82: %term  TYPE    85      /* a type */
                     83: %term  CLASS   86      /* a storage class */
                     84: %term  MAXOP   86      /* highest numbered PCC op */
                     85: %term  LOCALTOKENS     100
                     86: %term  ASOP    100     /* assignment ops */
                     87: %term  RELOP   101     /* <=, <, >=, > */
                     88: %term  EQUOP   102     /* ==, != */
                     89: %term  DIVOP   103     /* /, % */
                     90: %term  SHIFTOP 104     /* <<, >> */
                     91: %term  INCOP   105     /* ++, -- */
                     92: %term  UNOP    106     /* !, ~ */
                     93: %term  STROP   107     /* ., -> */
                     94: %term  LP              108     /* ( */
                     95: %term  RP              109     /* ) */
                     96: %term  LC              110     /* { */
                     97: %term  RC              111     /* } */
                     98: %term  STRUCT  112
                     99: %term  IF              113
                    100: %term  ELSE    114
                    101: %term  SWITCH  115
                    102: %term  BREAK   116
                    103: %term  CONTINUE        117
                    104: %term  WHILE   118
                    105: %term  DO              119
                    106: %term  FOR             120
                    107: %term  DEFAULT 121
                    108: %term  CASE    122
                    109: %term  SIZEOF  123
                    110: %term  ENUM    124
                    111: %term  SM              125

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