![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pjw.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / ccom / common|
Return to pjw.c CVS log | Up to [Research Unix] / researchv10no / cmd / ccom / common |
1.1 ! root 1: #include "mfile2.h" ! 2: extern struct symtab { /* ripped untimely from mfile1.h */ ! 3: char *sname; ! 4: TWORD stype; /* type word */ ! 5: ! 6: char sclass; /* storage class */ ! 7: char slevel; /* scope level */ ! 8: char sflags; /* flags for set, use, hidden, mos, etc. */ ! 9: int offset; /* offset or value */ ! 10: short dimoff; /* offset into the dimension table */ ! 11: short sizoff; /* offset into the size table */ ! 12: short suse; /* line number of last use of the variable */ ! 13: struct symtab *scopelink; /* chain of symbols at same level */ ! 14: } stab[]; ! 15: ! 16: #define BINOP 1000 ! 17: #define ARG 1001 ! 18: #define UCALL 1002 ! 19: #define BINARY 1003 ! 20: #define COPY 1004 ! 21: #define ENTRY 1005 ! 22: #define LOCCTR 1006 ! 23: #define LXINFO 1008 ! 24: #define URETURN 1010 ! 25: #define USTCALL 1011 ! 26: #define STRANGE 1012 ! 27: struct init { ! 28: int op; ! 29: int type; ! 30: char *name; ! 31: } ar[] = { ! 32: {1, 0, "???"}, ! 33: {AND, BINOP, "and"}, ! 34: {ANDAND, BINOP, "andand"}, ! 35: {ASG AND, BINOP, "asgand"}, ! 36: {UNARY AND, UNOP, "unaryand"}, ! 37: {ARG, ARG, "arg"}, ! 38: {ARS, BINOP, "ars"}, ! 39: {ASSIGN, BINOP, "assign"}, ! 40: {CALL, CALL, "call"}, ! 41: {FORTCALL, CALL, "fortcall"}, ! 42: {UNARY CALL, UCALL, "unarycall"}, ! 43: {UNARY FORTCALL, UNOP, "unaryfortcall"}, ! 44: {CBRANCH, BINARY, "cbranch "}, ! 45: {CM, BINARY, "cm "}, ! 46: {CMP, BINARY, "cmp "}, ! 47: {COLON, BINOP, "colon"}, ! 48: {COMOP, BINOP, "comop"}, ! 49: {COMPL, UNOP, "compl"}, ! 50: {CONV, UNOP, "conv"}, ! 51: {COPY, COPY, "copy"}, ! 52: {DECR, BINOP, "decr"}, ! 53: {DIV, BINOP, "div"}, ! 54: {ASG DIV, BINOP, "asgdiv"}, ! 55: {ENTRY, ENTRY, "entry"}, ! 56: {EPILOG, EPILOG, "epilog"}, ! 57: {ER, BINOP, "er"}, ! 58: {ASG ER, BINOP, "asger"}, ! 59: {FCON, FCON, "fcon"}, ! 60: {FLD, FLD, "fld"}, ! 61: {FUNARG, UNOP, "funarg"}, ! 62: {FREE, FREE, "free"}, ! 63: {GENBR, GENBR, "genbr"}, ! 64: {GENLAB, GENLAB, "genlab"}, ! 65: {GENUBR, GENLAB, "genubr"}, ! 66: {GOTO, GOTO, "goto"}, ! 67: {ICON, ICON, "icon"}, ! 68: {INCR, BINOP, "incr"}, ! 69: {INIT, UNOP, "init"}, ! 70: {LABELPT, GOTO, "labelpt"}, ! 71: {LOCCTR, LOCCTR, "locctr"}, ! 72: {LS, BINOP, "ls"}, ! 73: {ASG LS, BINOP, "asgls"}, ! 74: {LXINFO, LXINFO, "lxinfo"}, ! 75: {MINUS, BINOP, "minus"}, ! 76: {ASG MINUS, BINOP, "asgminus"}, ! 77: {UNARY MINUS, UNOP, "unaryminus"}, ! 78: {MOD, BINOP, "mod"}, ! 79: {ASG MOD, BINOP, "asgmod"}, ! 80: {MUL, BINOP, "mul"}, ! 81: {ASG MUL, BINOP, "asgmul"}, ! 82: {NAME, NAME, "name"}, ! 83: {NOT, UNOP, "not"}, ! 84: {OR, BINOP, "or"}, ! 85: {ASG OR, BINOP, "asgor"}, ! 86: {OROR, BINARY, "oror "}, ! 87: {PLUS, BINOP, "plus"}, ! 88: {ASG PLUS, BINOP, "asgplus"}, ! 89: {PROLOG, PROLOG, "prolog"}, ! 90: {QUEST, BINARY, "quest"}, ! 91: {REG, REG, "reg"}, ! 92: {EQ, BINOP, "eql"}, ! 93: {NE, BINOP, "neq"}, ! 94: {GT, BINOP, "gtr"}, ! 95: {GE, BINOP, "geq"}, ! 96: {LT, BINOP, "lss"}, ! 97: {LE, BINOP, "leq"}, ! 98: {UGT, BINOP, "gtru"}, ! 99: {UGE, BINOP, "gequ"}, ! 100: {ULT, BINOP, "lssu"}, ! 101: {ULE, BINOP, "lequ"}, ! 102: {RETURN, RETURN, "return"}, ! 103: {UNARY RETURN, URETURN, "unaryreturn"}, ! 104: {RNODE, STRANGE, "rnode"}, ! 105: {QNODE, STRANGE, "qnode"}, ! 106: {SNODE, STRANGE, "snode"}, ! 107: {RS, BINOP, "rs"}, ! 108: {ASG RS, BINOP, "asgrs"}, ! 109: {STAR, UNOP, "star"}, ! 110: {UNARY MUL, UNOP, "star"}, ! 111: {STARG, STARG, "starg"}, ! 112: {STASG, STASG, "stasg"}, ! 113: {STREF, STASG, "stref"}, ! 114: {STCALL, STCALL, "stcall"}, ! 115: {UNARY STCALL, USTCALL, "unarystcall"}, ! 116: {SWBEG, SWBEG, "swbeg"}, ! 117: {SWCASE, SWCASE, "swcase"}, ! 118: {SWDEF, SWDEF, "swdef"}, ! 119: {SWEND, SWEND, "swend"}, ! 120: {TEMP, TEMP, "temp"}, ! 121: {VAUTO, VAUTO, "vauto"}, ! 122: {VPARAM, VAUTO, "vparam"}, ! 123: {0, 0, 0} ! 124: }; ! 125: int opindex[256]; ! 126: int bothdebug; ! 127: FILE *fd; ! 128: pjwreader(p) ! 129: NODE *p; ! 130: { int n; ! 131: if(bothdebug) { ! 132: printf("#tree ", p); ! 133: prtree(p); ! 134: putchar('\n'); ! 135: gencode(p); ! 136: tfree(p); ! 137: } ! 138: else { ! 139: gencode(p); ! 140: tfree(p); ! 141: } ! 142: } ! 143: prtree(p) ! 144: NODE *p; ! 145: { int i, n; ! 146: static init = 0; ! 147: if(!init++) ! 148: myinit(); ! 149: if(p == 0) { ! 150: printf("???"); ! 151: return; ! 152: } ! 153: i = opindex[p->in.op]; ! 154: if(i == 0) { ! 155: printf("(unk op %d ???) ", p->in.op); ! 156: return; ! 157: } ! 158: printf("(%s", ar[i].name); ! 159: switch(ar[i].type) { ! 160: default: ! 161: printf("%d???) ", ar[i].type); ! 162: return; ! 163: case STRANGE: ! 164: printf(") "); ! 165: return; ! 166: case BINOP: ! 167: prtype(p->in.type); ! 168: case BINARY: ! 169: prtree(p->in.left); ! 170: prtree(p->in.right); ! 171: printf(") "); ! 172: return; ! 173: case UNOP: ! 174: prtype(p->in.type); ! 175: prtree(p->in.left); ! 176: printf(") "); ! 177: return; ! 178: case ARG: ! 179: prtree(p->in.left); ! 180: printf("%d) ", p->tn.rval); ! 181: return; ! 182: case EPILOG: ! 183: printf(" %d %d) ", p->tn.lval, p->tn.rval); ! 184: return; ! 185: case FLD: ! 186: printf(" %d %d ", p->tn.rval % 64, p->tn.rval / 64); ! 187: prtree(p->in.left); ! 188: printf(") "); ! 189: return; ! 190: case CALL: ! 191: prtype(p->in.type); ! 192: printf("%d ", p->stn.argsize/32); ! 193: prtree(p->in.left); ! 194: prtree(p->in.right); ! 195: printf(") "); ! 196: return; ! 197: case UCALL: ! 198: prtype(p->in.type); ! 199: prtree(p->in.left); ! 200: printf(") "); ! 201: return; ! 202: case FCON: ! 203: prtype(p->in.type); ! 204: printf("%g) ", p->fpn.dval); ! 205: return; ! 206: case GENBR: ! 207: printf(" %s L%d ", ar[opindex[p->bn.lop]].name, p->bn.label); ! 208: prtree(p->in.left); ! 209: printf(") "); ! 210: return; ! 211: case GENLAB: ! 212: prtype(p->in.type); ! 213: printf(" L%d ", p->bn.label); ! 214: prtree(p->in.left); ! 215: printf(") "); ! 216: return; ! 217: case GOTO: ! 218: printf(" L%d ", p->bn.label); ! 219: printf(") "); ! 220: return; ! 221: case ICON: ! 222: prtype(p->in.type); ! 223: if(p->tn.name) ! 224: if(p->tn.lval) ! 225: printf("%s+%d) ", p->tn.name, p->tn.lval); ! 226: else ! 227: printf("%s) ", p->tn.name); ! 228: else ! 229: printf("%d) ", p->tn.lval); ! 230: return; ! 231: case VAUTO: ! 232: prtype(p->in.type); ! 233: printf("%d) ", p->tn.lval); ! 234: return; ! 235: case NAME: ! 236: prtype(p->in.type); ! 237: if(p->tn.lval) ! 238: printf("%s+%d) ", p->tn.name, p->tn.lval); ! 239: else if(p->tn.name) ! 240: printf("%s) ", p->tn.name); ! 241: else if(p->tn.rval >= 0) ! 242: printf("%s) ", stab[p->tn.rval].sname); ! 243: else ! 244: printf("L%d) ", -p->tn.rval); ! 245: return; ! 246: case PROLOG: ! 247: prtype(p->in.type); ! 248: printf("%s %d) ", p->tn.name, p->tn.lval); ! 249: return; ! 250: case RETURN: ! 251: printf("%s) ", p->tn.name); ! 252: return; ! 253: case URETURN: ! 254: prtype(p->in.type); ! 255: printf("%s ", p->tn.name); ! 256: prtree(p->in.left); ! 257: return; ! 258: case SWCASE: ! 259: printf(" %d L%d) ", p->tn.lval, p->tn.rval); ! 260: return; ! 261: case SWDEF: ! 262: printf(" L%d) ", p->tn.rval); ! 263: return; ! 264: case SWEND: ! 265: printf(" %d %d) ", p->tn.lval, p->tn.rval); ! 266: return; ! 267: case STARG: ! 268: printf(" %d %d ", p->tn.rval, p->stn.stsize); ! 269: prtree(p->in.left); ! 270: printf(") "); ! 271: return; ! 272: case STASG: ! 273: printf(" %d ", p->stn.stsize); ! 274: prtree(p->in.left); ! 275: prtree(p->in.right); ! 276: printf(") "); ! 277: return; ! 278: case STCALL: ! 279: printf(" %d %d ", p->stn.stsize, p->stn.argsize); ! 280: prtree(p->in.left); ! 281: prtree(p->in.right); ! 282: printf(") "); ! 283: return; ! 284: case USTCALL: ! 285: printf("%d ", p->stn.stsize); ! 286: prtree(p->in.left); ! 287: printf(") "); ! 288: return; ! 289: case REG: ! 290: prtype(p->in.type); ! 291: printf("%d) ", p->tn.rval, p->tn.lval); ! 292: return; ! 293: } ! 294: } ! 295: prtype(n) ! 296: { char *s; ! 297: switch(n) { ! 298: default: ! 299: cerror("prtype(#%x)\n", n); ! 300: case TCHAR: s = "C"; break; ! 301: case TUCHAR: s = "UC"; break; ! 302: case TSHORT: s = "S"; break; ! 303: case TUSHORT: s = "US"; break; ! 304: case TINT: s = "I"; break; ! 305: case TUNSIGNED: s = "U"; break; ! 306: case TLONG: s = "L"; break; ! 307: case TULONG: s = "UL"; break; ! 308: case TFLOAT: s = "F"; break; ! 309: case TDOUBLE: s = "D"; break; ! 310: case TSTRUCT: s = "St"; break; ! 311: case TPOINT: s = "P"; break; ! 312: } ! 313: printf("%s ", s); ! 314: } ! 315: myinit() ! 316: { int i; ! 317: for(i = 0; ar[i].name; i++) ! 318: opindex[ar[i].op] = i; ! 319: } ! 320: pjwend(p) ! 321: NODE *p; ! 322: { ! 323: if(bothdebug) ! 324: printf("#treeend\n"); ! 325: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.