![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to init.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / d / bin / cc / c / n0|
Return to init.c CVS log | Up to [MW Coherent from dump] / coherent / d / bin / cc / c / n0 |
1.1 ! root 1: /* ! 2: * C compiler. ! 3: * Initializers. ! 4: * (All storage classes). ! 5: */ ! 6: #ifdef vax ! 7: #include "INC$LIB:cc0.h" ! 8: #else ! 9: #include "cc0.h" ! 10: #endif ! 11: ! 12: init(sp, dp, bo, flex) ! 13: register SYM *sp; ! 14: register DIM *dp; ! 15: sizeof_t bo; ! 16: int flex; ! 17: { ! 18: register int t; ! 19: DIM *ndp; ! 20: TREE *tp; ! 21: sizeof_t width, nbe, nel, ninit; ! 22: int brace, c, adj; ! 23: ! 24: t = sp->s_type; ! 25: width = sdsize(sp, dp); ! 26: ndp = dp; ! 27: if (dp!=NULL && dp->d_type==D_ARRAY) { ! 28: if (dp->d_bound != 0) ! 29: flex = 0; ! 30: ndp = dp->d_dp; ! 31: if (width==0 && !flex) ! 32: cerror("array row has 0 length"); ! 33: } else ! 34: flex = 0; ! 35: nel = 0; ! 36: nbe = sdsize(sp, ndp); ! 37: if (nbe != 0) ! 38: nel = width/nbe; ! 39: brace = 0; ! 40: if (s==LBRACE && (dp!=NULL || !istruct(t))) { ! 41: ++brace; ! 42: lex(); ! 43: } else if (s!=LBRACE && (dp!=NULL || istruct(t))) ! 44: notbook(); ! 45: ninit = 0; ! 46: while (s != RBRACE) { ! 47: if (ndp==NULL && istruct(t)) ! 48: sinit(sp, bo); ! 49: else if (ndp!=NULL && ndp->d_type==D_ARRAY) ! 50: init(sp, ndp, bo, 0); ! 51: else { ! 52: adj = 0; ! 53: if (s==STRING && t<T_INT && ndp==NULL) { ! 54: again: while ((c = getmap('\"')) >= 0) { ! 55: newtree(sizeof(TREE)); ! 56: icollect(bicon(c), bo, sp, ndp); ! 57: ++ninit; ! 58: ++bo; ! 59: } ! 60: if (lex() == STRING) { ! 61: ++adj; ! 62: goto again; ! 63: } ! 64: if (adj) ! 65: notbook(); ! 66: if (!flex && ninit==nel) { ! 67: cwarn("string initializer not terminated by NUL"); ! 68: break; ! 69: } ! 70: newtree(sizeof(TREE)); ! 71: icollect(bicon(0), bo, sp, ndp); ! 72: ++ninit; ! 73: break; ! 74: } ! 75: newtree(sizeof(TREE)); ! 76: ++ininit; ! 77: tp = expr(); ! 78: --ininit; ! 79: icollect(tp, bo, sp, ndp); ! 80: } ! 81: ++ninit; ! 82: bo += nbe; ! 83: if (s != COMMA) ! 84: break; ! 85: if (ninit>=nel && !flex) { ! 86: if (brace) { ! 87: lex(); ! 88: if (s == RBRACE) ! 89: cwarn("trailing ',' in initialization list"); ! 90: else { ! 91: cerror("too many initializers"); ! 92: iskip(); ! 93: } ! 94: } ! 95: break; ! 96: } ! 97: itrail(); ! 98: } ! 99: if (brace) ! 100: mustbe(RBRACE); ! 101: if (ninit < nel) { ! 102: c = sp->s_class; ! 103: if (c==C_GDEF || c==C_SIN || c==C_SEX) { ! 104: bput(BLOCK); ! 105: zput(nbe*(nel-ninit)); ! 106: } ! 107: } ! 108: if (ninit > nel) { ! 109: if (!flex) ! 110: cerror("too many initializers"); ! 111: if (dp != NULL) ! 112: dp->d_bound = ninit; ! 113: } ! 114: } ! 115: ! 116: /* ! 117: * Initialize a structure. ! 118: * Create a fake variable for each member; ! 119: * this is necessary for the call to build() in iassign() ! 120: * to do the correct things. ! 121: */ ! 122: sinit(sp, bo) ! 123: SYM *sp; ! 124: sizeof_t bo; ! 125: { ! 126: register SYM *mp; ! 127: register INFO *ip; ! 128: register int n; ! 129: int brace, c, t, f; ! 130: sizeof_t mo, lo; ! 131: SYM sym; ! 132: ! 133: c = sp->s_class; ! 134: t = sp->s_type; ! 135: if (t==T_UNION || t==T_FUNION) ! 136: cerror("cannot initialize unions"); ! 137: if (t==T_FSTRUCT || t==T_FUNION) ! 138: return; ! 139: ip = sp->s_ip; ! 140: sym.s_class = c; ! 141: sym.s_value = sp->s_value; ! 142: brace = 0; ! 143: if (s == LBRACE) { ! 144: ++brace; ! 145: lex(); ! 146: } ! 147: lo = n = f = 0; ! 148: while (s != RBRACE) { ! 149: if (n >= ip->i_nsp) { ! 150: if (f == 0) { ! 151: cerror("too many structure initializers"); ! 152: ++f; ! 153: } ! 154: sym.s_type = T_INT; ! 155: sym.s_dp = sym.s_ip = NULL; ! 156: mo = 0; ! 157: } else { ! 158: mp = ip->i_sp[n++]; ! 159: sym.s_type = mp->s_type; ! 160: sym.s_dp = mp->s_dp; ! 161: sym.s_ip = mp->s_ip; ! 162: mo = mp->s_value; ! 163: if (mp->s_width != 0) ! 164: cerror("cannot initialize fields"); ! 165: if (!isauto(&sym) && lo!=mo) { ! 166: bput(BLOCK); ! 167: zput(mo-lo); ! 168: lo = mo; ! 169: } ! 170: } ! 171: init(&sym, sym.s_dp, bo+mo, 0); ! 172: lo += ssize(&sym); ! 173: if (s != COMMA || (n>=ip->i_nsp && !brace)) ! 174: break; ! 175: itrail(); ! 176: } ! 177: if (brace) ! 178: mustbe(RBRACE); ! 179: if (t==T_STRUCT && (c==C_GDEF || c==C_SIN || c==C_SEX)) { ! 180: if ((mo = ip->i_size-lo) > 0) { ! 181: bput(BLOCK); ! 182: zput(mo); ! 183: } ! 184: } ! 185: } ! 186: ! 187: /* ! 188: * Fetch the next symbol. ! 189: * The current symbol is a COMMA. ! 190: * If the new symbol is '}', the program has said ", }"; this is legal. ! 191: * If you pull the comments here, it becomes not quite so legal. ! 192: */ ! 193: static ! 194: itrail() ! 195: { ! 196: lex(); ! 197: if (s == RBRACE) ! 198: cwarn("trailing ',' in initialization list"); ! 199: } ! 200: ! 201: /* ! 202: * An initialization starting with '{' contains too many initializers. ! 203: * Skip initializers to the matching '}' or EOF. ! 204: */ ! 205: static ! 206: iskip() ! 207: { ! 208: register int braces; ! 209: ! 210: braces = 0; ! 211: for(;;) { ! 212: if (s == LBRACE) ! 213: ++braces; ! 214: else if (s == RBRACE) { ! 215: if (braces == 0) ! 216: return; ! 217: else ! 218: --braces; ! 219: } ! 220: else if (s == EOF) ! 221: return; ! 222: lex(); ! 223: } ! 224: } ! 225: ! 226: /* ! 227: * Return true if symbol "sp" is an automatic, ! 228: * in the sense that an assigment statement must be generated ! 229: * for the initialization item. ! 230: * Registers are considered auto. ! 231: */ ! 232: isauto(sp) ! 233: register SYM *sp; ! 234: { ! 235: register int c; ! 236: ! 237: c = sp->s_class; ! 238: if (c==C_AUTO || c==C_PAUTO || c==C_REG) ! 239: return (1); ! 240: return (0); ! 241: } ! 242: ! 243: /* ! 244: * This routine actually performs the initialization. ! 245: * Either an assignment node is built up and evaluated for effect, ! 246: * or an initialization tree is output. ! 247: */ ! 248: icollect(tp, bo, sp, dp) ! 249: register TREE *tp; ! 250: sizeof_t bo; ! 251: register SYM *sp; ! 252: DIM *dp; ! 253: { ! 254: register TREE *ip; ! 255: ! 256: if (isauto(sp)) { ! 257: iassign(sp, dp, bo, tp); ! 258: return; ! 259: } ! 260: ip = talloc(); ! 261: ip->t_op = INIT; ! 262: ip->t_type = sp->s_type; ! 263: ip->t_dp = dp; ! 264: ip->t_ip = sp->s_ip; ! 265: ip->t_lp = tp; ! 266: tput(IEXPR, 0, ip); ! 267: } ! 268: ! 269: /* ! 270: * Actually do the assignment for an automatic initialization thing. ! 271: */ ! 272: iassign(sp, dp, bo, tp) ! 273: register SYM *sp; ! 274: register TREE *tp; ! 275: sizeof_t bo; ! 276: DIM *dp; ! 277: { ! 278: register TREE *ip; ! 279: DIM *ssdp; ! 280: ! 281: ssdp = sp->s_dp; ! 282: sp->s_dp = dp; ! 283: ip = bid(sp); ! 284: sp->s_dp = ssdp; ! 285: if (sp->s_class != C_REG) ! 286: ip->t_offs += bo; ! 287: tp = build(ASSIGN, ip, tp); ! 288: tput(EEXPR, 0, tp); ! 289: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.