![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to stat.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / b / bin / c / n0|
Return to stat.c CVS log | Up to [MW Coherent from dump] / coherent / b / bin / c / n0 |
1.1 ! root 1: /* ! 2: * n0/stat.c ! 3: * C compiler. ! 4: * Statement compilation. ! 5: * The routines in this file compile C statements. ! 6: * This file also contains a number of small routines that are ! 7: * only used by the statement compilation code. ! 8: * This is the new VAX/VMS base version. ! 9: */ ! 10: ! 11: #ifdef vax ! 12: #include "INC$LIB:cc0.h" ! 13: #else ! 14: #include "cc0.h" ! 15: #endif ! 16: ! 17: /* ! 18: * Compile one statement. ! 19: * On entry, 's' contains the first symbol of the new statement. ! 20: * On exit, 's' contains the first token beyond the end of the statement. ! 21: */ ! 22: statement() ! 23: { ! 24: register TREE *tp; ! 25: register int lab1, lab2; ! 26: TREE *lp, *rp; ! 27: TREE *itree, *ctree, *stree; ! 28: SBLOCK *ssbp; ! 29: int i, sclab, sblab, tt; ! 30: ival_t v; ! 31: ! 32: loop: ! 33: dbstat(s, line); ! 34: switch (s) { ! 35: ! 36: case EOF: ! 37: cerror("unexpected end of file"); ! 38: break; ! 39: ! 40: case SEMI: ! 41: lex(); ! 42: break; ! 43: ! 44: case LBRACE: ! 45: lex(); ! 46: savelocals(); ! 47: ++llex; ! 48: locals(); ! 49: putautos(); ! 50: while (s!=EOF && s!=RBRACE) ! 51: statement(); ! 52: mustbe(RBRACE); ! 53: --llex; ! 54: downlex(); ! 55: dbstat(RBRACE, line); ! 56: restlocals(); ! 57: break; ! 58: ! 59: case BREAK: ! 60: lex(); ! 61: if (cblab == 0) ! 62: cerror("break not in a loop"); ! 63: jump(cblab); ! 64: mustbe(SEMI); ! 65: break; ! 66: ! 67: case CONTINUE: ! 68: lex(); ! 69: if (cclab == 0) ! 70: cerror("continue not in a loop"); ! 71: jump(cclab); ! 72: mustbe(SEMI); ! 73: break; ! 74: ! 75: case CASE: ! 76: lex(); ! 77: newtree(sizeof(TREE)); ! 78: ++incase; ! 79: v = iconexpr(); ! 80: --incase; ! 81: mustbe(COLON); ! 82: if (sbp == NULL) ! 83: cerror("case not in a switch"); ! 84: else ! 85: newcase(v); ! 86: goto loop; ! 87: ! 88: case DEFAULT: ! 89: lex(); ! 90: mustbe(COLON); ! 91: if (sbp == NULL) ! 92: cerror("default label not in a switch"); ! 93: else { ! 94: if (sbp->sb_dlab != 0) ! 95: cerror("only one default label allowed"); ! 96: sbp->sb_dlab = here(); ! 97: } ! 98: goto loop; ! 99: ! 100: case GOTO: ! 101: lex(); ! 102: if (s != ID) { ! 103: cerror("missing label name in goto"); ! 104: skip(); ! 105: } else { ! 106: dogoto(); ! 107: lex(); ! 108: mustbe(SEMI); ! 109: } ! 110: break; ! 111: ! 112: case IF: ! 113: lex(); ! 114: tp = pexpr(); ! 115: truth(tp); ! 116: tput(FEXPR, lab1=newlab(), tp); ! 117: statement(); ! 118: if (s == ELSE) { ! 119: lab2 = newlab(); ! 120: jump(lab2); ! 121: label(lab1); ! 122: lex(); ! 123: statement(); ! 124: label(lab2); ! 125: break; ! 126: } ! 127: label(lab1); ! 128: break; ! 129: ! 130: case DO: ! 131: sblab = cblab; ! 132: sclab = cclab; ! 133: cblab = newlab(); ! 134: cclab = newlab(); ! 135: lab1 = here(); ! 136: lex(); ! 137: statement(); ! 138: label(cclab); ! 139: dbstat(s, line); ! 140: mustbe(WHILE); ! 141: tp = pexpr(); ! 142: truth(tp); ! 143: tput(TEXPR, lab1, tp); ! 144: label(cblab); ! 145: mustbe(SEMI); ! 146: cclab = sclab; ! 147: cblab = sblab; ! 148: break; ! 149: ! 150: case WHILE: ! 151: sblab = cblab; ! 152: sclab = cclab; ! 153: cblab = newlab(); ! 154: cclab = here(); ! 155: lex(); ! 156: tp = pexpr(); ! 157: truth(tp); ! 158: tput(FEXPR, cblab, tp); ! 159: statement(); ! 160: jump(cclab); ! 161: label(cblab); ! 162: cclab = sclab; ! 163: cblab = sblab; ! 164: break; ! 165: ! 166: case SWITCH: ! 167: lex(); ! 168: tp = pexpr(); ! 169: tt = tltype(tp); ! 170: if ((tt == T_LONG && mytypes[T_INT] == mytypes[T_LONG]) ! 171: || (tt == T_ULONG && mytypes[T_UINT] == mytypes[T_ULONG])) { ! 172: if (isvariant(VSBOOK)) ! 173: cstrict("switch expression is long"); ! 174: } else if (tt > T_UINT) ! 175: cerror("switch of non integer"); ! 176: if (tt != T_INT) { ! 177: rp = NULL; ! 178: if (tt == T_PTR) ! 179: rp = bzcon(psize(tp)); ! 180: tp = bconvert(tp, T_INT, NULL, NULL, rp); ! 181: } ! 182: tput(SEXPR, 0, tp); ! 183: ssbp = sbp; ! 184: sbp = (SBLOCK *) new(sizeof(SBLOCK)); ! 185: sbp->sb_dlab = 0; ! 186: sbp->sb_ncase = 0; ! 187: sblab = cblab; ! 188: cblab = newlab(); ! 189: statement(); ! 190: jump(cblab); ! 191: if (sbp->sb_dlab==0 && sbp->sb_ncase==0) ! 192: cwarn("empty switch"); ! 193: if (sbp->sb_dlab == 0) ! 194: sbp->sb_dlab = cblab; ! 195: bput(SBODY); ! 196: iput((ival_t) sbp->sb_dlab); ! 197: iput((ival_t) sbp->sb_ncase); ! 198: for (i=0; i<sbp->sb_ncase; ++i) { ! 199: iput((ival_t) sbp->sb_case[i].sc_val); ! 200: iput((ival_t) sbp->sb_case[i].sc_lab); ! 201: } ! 202: label(cblab); ! 203: cblab = sblab; ! 204: free((char *) sbp); ! 205: sbp = ssbp; ! 206: break; ! 207: ! 208: case FOR: ! 209: lex(); ! 210: mustbe(LPAREN); ! 211: newtree(sizeof(TREE)); ! 212: itree = NULL; ! 213: if (s != SEMI) ! 214: itree = expr(); ! 215: mustbe(SEMI); ! 216: ctree = NULL; ! 217: if (s != SEMI) { ! 218: ctree = expr(); ! 219: truth(ctree); ! 220: } ! 221: mustbe(SEMI); ! 222: stree = NULL; ! 223: if (s != RPAREN) ! 224: stree = expr(); ! 225: mustbe(RPAREN); ! 226: sblab = cblab; ! 227: sclab = cclab; ! 228: cblab = newlab(); ! 229: cclab = newlab(); ! 230: if (itree != NULL) { ! 231: tput(EEXPR, 0, itree); ! 232: } ! 233: if (stree != NULL) ! 234: jump(lab1 = newlab()); ! 235: label(cclab); ! 236: if (stree != NULL) { ! 237: tput(EEXPR, 0, stree); ! 238: label(lab1); ! 239: } ! 240: if (ctree != NULL) { ! 241: tput(FEXPR, cblab, ctree); ! 242: } ! 243: statement(); ! 244: jump(cclab); ! 245: label(cblab); ! 246: cclab = sclab; ! 247: cblab = sblab; ! 248: break; ! 249: ! 250: case RETURN: ! 251: lex(); ! 252: if (s != SEMI) { ! 253: newtree(sizeof(TREE)); ! 254: tp = expr(); ! 255: if (cfsym==NULL) { ! 256: cerror("return(e) not inside valid function"); ! 257: mustbe(SEMI); ! 258: break; ! 259: } ! 260: lp = talloc(); ! 261: lp->t_op = CONVERT; ! 262: lp->t_type = cfsym->s_type; ! 263: lp->t_dp = cfsym->s_dp->d_dp; /* Skip D_FUNC */ ! 264: lp->t_ip = cfsym->s_ip; ! 265: if (lp->t_dp==NULL && lp->t_type==T_VOID) { ! 266: cerror("return(e) illegal in void function"); ! 267: mustbe(SEMI); ! 268: break; ! 269: } ! 270: if ((tltype(lp)==T_STRUCT || tltype(tp)==T_STRUCT) ! 271: && (lp->t_type!=tp->t_type||lp->t_dp!=tp->t_dp||lp->t_ip!=tp->t_ip)) { ! 272: cerror("return type/function type mismatch"); ! 273: mustbe(SEMI); ! 274: break; ! 275: } ! 276: if (bitcompat(tltype(lp), tltype(tp))) ! 277: adjust(tp, lp->t_type, lp->t_dp, lp->t_ip); ! 278: else { ! 279: lp->t_lp = tp; ! 280: tp = lp; ! 281: } ! 282: tput(REXPR, 0, tp); ! 283: } ! 284: jump(cflab); ! 285: mustbe(SEMI); ! 286: break; ! 287: ! 288: case ID: ! 289: if (spnextis(':')) { ! 290: dolabel(); ! 291: lex(); ! 292: lex(); ! 293: goto loop; ! 294: } ! 295: ! 296: default: ! 297: newtree(sizeof(TREE)); ! 298: tp = expr(); ! 299: tput(EEXPR, 0, tp); ! 300: mustbe(SEMI); ! 301: } ! 302: } ! 303: ! 304: /* ! 305: * Check if the given tree can be used in a truth value context. ! 306: * Put out the appropriate diagnostics. ! 307: * What does this have to do with stat()? ! 308: */ ! 309: truth(tp) ! 310: TREE *tp; ! 311: { ! 312: register int tt, op; ! 313: ! 314: tt = tltype(tp); ! 315: op = tp->t_op; ! 316: if (tt>=T_STRUCT && tt<=T_FUNION) ! 317: cerror("structure or union used in truth context"); ! 318: if (incpp) ! 319: return; ! 320: if (isvariant(VSRTVC)) { ! 321: if ((tt>=T_PTR && tt<=T_DOUBLE) ! 322: || (op==EQ && tp->t_lp->t_type==T_DOUBLE)) ! 323: cstrict("risky type in truth context"); ! 324: } ! 325: if (isvariant(VSCCON)) { ! 326: /* Catch typing error "if (i = 1) ..." for "if (i == 1)...". */ ! 327: while (op == ASSIGN) { ! 328: tp = tp->t_rp; ! 329: op = tp->t_op; ! 330: } ! 331: if (op==ICON || op==LCON || op==DCON) ! 332: cstrict("constant used in truth context"); ! 333: } ! 334: } ! 335: ! 336: /* ! 337: * Read an expression enclosed in parentheses. ! 338: * Used to read the control expressions in 'if', 'do', 'while' and 'switch'. ! 339: */ ! 340: TREE * ! 341: pexpr() ! 342: { ! 343: register TREE *tp; ! 344: ! 345: mustbe(LPAREN); ! 346: newtree(sizeof(TREE)); ! 347: tp = expr(); ! 348: mustbe(RPAREN); ! 349: return (tp); ! 350: } ! 351: ! 352: /* ! 353: * Labels. ! 354: */ ! 355: dolabel() ! 356: { ! 357: register SYM *sp; ! 358: register int c; ! 359: ! 360: sp = deflookup(SL_LAB, 2); ! 361: c = sp->s_class; ! 362: if (c==C_NONE || c==C_FREF) { ! 363: if (c == C_NONE) ! 364: sp->s_value = newlab(); ! 365: sp->s_class = C_LAB; ! 366: sp->s_dline = line; ! 367: label(sp->s_value); ! 368: dblabel(sp); ! 369: } else ! 370: cerror("illegal label \"%s\"", sp->s_id); ! 371: } ! 372: ! 373: /* ! 374: * The dreaded 'goto' statement. ! 375: */ ! 376: dogoto() ! 377: { ! 378: register SYM *sp; ! 379: register int c; ! 380: ! 381: sp = deflookup(SL_LAB, 2); ! 382: c = sp->s_class; ! 383: if (c == C_NONE) { ! 384: sp->s_class = C_FREF; ! 385: sp->s_value = newlab(); ! 386: } else if (c!=C_LAB && c!=C_FREF) ! 387: cerror("identifier \"%s\" is not a label", sp->s_id); ! 388: jump(sp->s_value); ! 389: sp->s_flag |= S_USED; ! 390: } ! 391: ! 392: /* ! 393: * Append a new case to the current switch, ! 394: * adjusting the size of the switch block if necessary and possible. ! 395: */ ! 396: newcase(v) ! 397: ival_t v; ! 398: { ! 399: SBLOCK *ssbp; ! 400: register SCASE *scp, *ocp; ! 401: register int i; ! 402: ! 403: i = sbp->sb_ncase; ! 404: scp = sbp->sb_case; ! 405: while (--i >= 0) { ! 406: if (scp->sc_val == v) { ! 407: cerror("duplicated case constant"); ! 408: return; ! 409: } else ! 410: scp += 1; ! 411: } ! 412: i = sbp->sb_ncase; ! 413: scp = &sbp->sb_case[i]; ! 414: if ((i % 32) == 0) { ! 415: ssbp = sbp; ! 416: sbp = new(sizeof(SBLOCK) + (i+32) * sizeof(SCASE)); ! 417: sbp->sb_ncase = ssbp->sb_ncase; ! 418: sbp->sb_dlab = ssbp->sb_dlab; ! 419: scp = sbp->sb_case; ! 420: ocp = ssbp->sb_case; ! 421: while (--i >= 0) { ! 422: scp->sc_val = ocp->sc_val; ! 423: scp->sc_lab = ocp->sc_lab; ! 424: scp += 1; ! 425: ocp += 1; ! 426: } ! 427: free((char *) ssbp); ! 428: scp = &sbp->sb_case[sbp->sb_ncase]; ! 429: } ! 430: scp->sc_val = v; ! 431: scp->sc_lab = here(); ! 432: sbp->sb_ncase += 1; ! 433: } ! 434: ! 435: /* end of n0/stat.c */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.