![[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 / b / bin / c / n0|
Return to init.c CVS log | Up to [MW Coherent from dump] / coherent / b / bin / c / n0 |
1.1 ! root 1: /* ! 2: * n0/init.c ! 3: * C compiler. ! 4: * Initializers. ! 5: * All storage classes. ! 6: */ ! 7: ! 8: #ifdef vax ! 9: #include "INC$LIB:cc0.h" ! 10: #else ! 11: #include "cc0.h" ! 12: #endif ! 13: ! 14: init(sp, dp, bo, flex) ! 15: register SYM *sp; ! 16: register DIM *dp; ! 17: sizeof_t bo; ! 18: int flex; ! 19: { ! 20: register int t; ! 21: DIM *ndp; ! 22: TREE *tp; ! 23: sizeof_t width, nbe, nel, ninit; ! 24: int brace, c, adj; ! 25: ! 26: t = sp->s_type; ! 27: width = sdsize(sp, dp); ! 28: ndp = dp; ! 29: if (dp!=NULL && dp->d_type==D_ARRAY) { ! 30: if (dp->d_bound != 0) ! 31: flex = 0; ! 32: ndp = dp->d_dp; ! 33: if (width==0 && !flex) ! 34: cerror("array row has 0 length"); ! 35: } else ! 36: flex = 0; ! 37: nel = 0; ! 38: nbe = sdsize(sp, ndp); ! 39: if (nbe != 0) ! 40: nel = width/nbe; ! 41: brace = 0; ! 42: if (s==LBRACE && (dp!=NULL || !istruct(t))) { ! 43: ++brace; ! 44: lex(); ! 45: } else if (s!=LBRACE && (dp!=NULL || istruct(t))) ! 46: notbook(); ! 47: ninit = 0; ! 48: while (s != RBRACE) { ! 49: if (ndp==NULL && istruct(t)) ! 50: sinit(sp, bo); ! 51: else if (ndp!=NULL && ndp->d_type==D_ARRAY) ! 52: init(sp, ndp, bo, 0); ! 53: else { ! 54: adj = 0; ! 55: if (s==STRING && t<T_INT && ndp==NULL) { ! 56: again: ! 57: instring = '"'; ! 58: while ((c = getmap('\"')) >= 0) { ! 59: newtree(sizeof(TREE)); ! 60: icollect(bicon((ival_t)c), bo, sp, ndp); ! 61: ++ninit; ! 62: ++bo; ! 63: } ! 64: instring = 0; ! 65: if (lex() == STRING) { ! 66: ++adj; ! 67: goto again; ! 68: } ! 69: if (adj) ! 70: notbook(); ! 71: if (!flex && ninit==nel) { ! 72: cwarn("string initializer not terminated by NUL"); ! 73: break; ! 74: } ! 75: newtree(sizeof(TREE)); ! 76: icollect(bicon((ival_t)0), bo, sp, ndp); ! 77: ++ninit; ! 78: break; ! 79: } ! 80: newtree(sizeof(TREE)); ! 81: ++ininit; ! 82: tp = expr(); ! 83: --ininit; ! 84: icollect(tp, bo, sp, ndp); ! 85: } ! 86: ++ninit; ! 87: bo += nbe; ! 88: if (s != COMMA) ! 89: break; ! 90: if (ninit>=nel && !flex) { ! 91: if (brace) { ! 92: lex(); ! 93: if (s == RBRACE) ! 94: cwarn("trailing ',' in initialization list"); ! 95: else { ! 96: cerror("too many initializers"); ! 97: iskip(); ! 98: } ! 99: } ! 100: break; ! 101: } ! 102: itrail(); ! 103: } ! 104: if (brace) ! 105: mustbe(RBRACE); ! 106: if (ninit < nel) { ! 107: c = sp->s_class; ! 108: if (c==C_GDEF || c==C_SIN || c==C_SEX) { ! 109: bput(BLOCK); ! 110: zput(nbe*(nel-ninit)); ! 111: } ! 112: } ! 113: if (ninit > nel) { ! 114: if (!flex) ! 115: cerror("too many initializers"); ! 116: if (dp != NULL) ! 117: dp->d_bound = ninit; ! 118: } ! 119: } ! 120: ! 121: /* ! 122: * Initialize a structure. ! 123: * Create a fake variable for each member; ! 124: * this is necessary for the call to build() in iassign() ! 125: * to do the correct things. ! 126: */ ! 127: sinit(sp, bo) SYM *sp; sizeof_t bo; ! 128: { ! 129: register SYM *mp; ! 130: register INFO *ip; ! 131: int n, brace, c, t, f, bfflag; ! 132: sizeof_t mo, lo; ! 133: SYM sym; ! 134: ! 135: c = sp->s_class; ! 136: t = sp->s_type; ! 137: if (t==T_UNION || t==T_FUNION) ! 138: cerror("cannot initialize unions"); ! 139: if (t==T_FSTRUCT || t==T_FUNION) ! 140: return; ! 141: ip = sp->s_ip; ! 142: sym.s_class = c; ! 143: sym.s_value = sp->s_value; ! 144: brace = 0; ! 145: if (s == LBRACE) { ! 146: ++brace; ! 147: lex(); ! 148: } ! 149: lo = n = f = 0; ! 150: while (s != RBRACE) { ! 151: bfflag = 0; ! 152: if (n >= ip->i_nsp) { ! 153: if (f == 0) { ! 154: cerror("too many structure initializers"); ! 155: ++f; ! 156: } ! 157: sym.s_type = T_INT; ! 158: sym.s_dp = sym.s_ip = NULL; ! 159: mo = 0; ! 160: } else { ! 161: mp = ip->i_sp[n++]; ! 162: sym.s_type = mp->s_type; ! 163: sym.s_dp = mp->s_dp; ! 164: sym.s_ip = mp->s_ip; ! 165: mo = mp->s_value; ! 166: if (!isauto(&sym) && lo!=mo) { ! 167: /* Output BLOCK item for padding. */ ! 168: bput(BLOCK); ! 169: zput(mo-lo); ! 170: lo = mo; ! 171: } ! 172: if (mp->s_width != 0) /* bitfield initializer */ ! 173: bfflag = bfinit(&sym, mp, ip, &n, bo+mo); ! 174: } ! 175: if (!bfflag) ! 176: init(&sym, sym.s_dp, bo+mo, 0); ! 177: lo += ssize(&sym); ! 178: if (bfflag != 2 && s != COMMA) ! 179: break; ! 180: if (n >= ip->i_nsp && !brace) ! 181: break; ! 182: if (bfflag != 2) ! 183: itrail(); /* skip COMMA, check for RBRACE */ ! 184: } ! 185: if (brace) ! 186: mustbe(RBRACE); ! 187: if (t==T_STRUCT && (c==C_GDEF || c==C_SIN || c==C_SEX)) { ! 188: if ((mo = ip->i_size-lo) > 0) { ! 189: bput(BLOCK); ! 190: zput(mo); ! 191: } ! 192: } ! 193: } ! 194: ! 195: /* ! 196: * Fetch the next symbol. ! 197: * The current symbol is a COMMA. ! 198: * If the new symbol is '}', the program has said ", }"; this is legal. ! 199: * If you pull the comments here, it becomes not quite so legal. ! 200: */ ! 201: static ! 202: itrail() ! 203: { ! 204: lex(); ! 205: if (s == RBRACE) ! 206: cwarn("trailing ',' in initialization list"); ! 207: } ! 208: ! 209: /* ! 210: * An initialization starting with '{' contains too many initializers. ! 211: * Skip initializers to the matching '}' or EOF. ! 212: */ ! 213: static ! 214: iskip() ! 215: { ! 216: register int braces; ! 217: ! 218: braces = 0; ! 219: for(;;) { ! 220: if (s == LBRACE) ! 221: ++braces; ! 222: else if (s == RBRACE) { ! 223: if (braces == 0) ! 224: return; ! 225: else ! 226: --braces; ! 227: } ! 228: else if (s == EOF) ! 229: return; ! 230: lex(); ! 231: } ! 232: } ! 233: ! 234: /* ! 235: * Return true if symbol "sp" is an automatic, ! 236: * in the sense that an assigment statement must be generated ! 237: * for the initialization item. ! 238: * Registers are considered auto. ! 239: */ ! 240: int ! 241: isauto(sp) register SYM *sp; ! 242: { ! 243: register int c; ! 244: ! 245: c = sp->s_class; ! 246: return (c==C_AUTO || c==C_PAUTO || c==C_REG); ! 247: } ! 248: ! 249: /* ! 250: * This routine actually performs the initialization. ! 251: * Either an build an assignment node and evaluate it for effect, ! 252: * or output an initialization tree. ! 253: */ ! 254: icollect(tp, bo, sp, dp) ! 255: register TREE *tp; ! 256: sizeof_t bo; ! 257: register SYM *sp; ! 258: DIM *dp; ! 259: { ! 260: register TREE *ip; ! 261: ! 262: if (isauto(sp)) { ! 263: iassign(sp, dp, bo, tp); ! 264: return; ! 265: } ! 266: ip = talloc(); ! 267: ip->t_op = INIT; ! 268: ip->t_type = sp->s_type; ! 269: ip->t_dp = dp; ! 270: ip->t_ip = sp->s_ip; ! 271: ip->t_lp = tp; ! 272: tput(IEXPR, 0, ip); ! 273: } ! 274: ! 275: /* ! 276: * Actually do the assignment for an automatic initialization thing. ! 277: */ ! 278: iassign(sp, dp, bo, tp) ! 279: register SYM *sp; ! 280: register TREE *tp; ! 281: sizeof_t bo; ! 282: DIM *dp; ! 283: { ! 284: register TREE *ip; ! 285: DIM *ssdp; ! 286: ! 287: ssdp = sp->s_dp; ! 288: sp->s_dp = dp; ! 289: ip = bid(sp); ! 290: sp->s_dp = ssdp; ! 291: if (sp->s_class != C_REG) ! 292: ip->t_offs += bo; ! 293: tp = build(ASSIGN, ip, tp); ! 294: tput(EEXPR, 0, tp); ! 295: } ! 296: ! 297: /* ! 298: * Collect one or more bitfield initializers. ! 299: * Each bitfield initializer must be an integer constant. ! 300: * Multiple bitfield initializers get output as a single initialization item: ! 301: * look for more initializers if the next ! 302: * structure member is another bitfield at the same offset (s_value). ! 303: * This may or may not need to look ahead to the next initializer, ! 304: * so it returns 1 if it has not read COMMA, 2 if it has read the COMMA. ! 305: */ ! 306: int ! 307: bfinit(sp, mp, ip, np, off) SYM *sp; register SYM *mp; INFO *ip; register int *np; sizeof_t off; ! 308: { ! 309: register unsigned long val, mval, mask; ! 310: int status; ! 311: ! 312: for (val = (unsigned long)0; ; ) { ! 313: ! 314: status = 1; /* COMMA not read yet */ ! 315: ! 316: /* Widen the initialized symbol base type if necessary. */ ! 317: if (ssize(sp) < ssize(mp)) ! 318: sp->s_type = mp->s_type; ! 319: ! 320: /* Grab the initializer value. */ ! 321: ++ininit; ! 322: mval = iconexpr(); ! 323: --ininit; ! 324: ! 325: /* Make sure the initializer is appropriate. */ ! 326: mask = (((unsigned long)1) << mp->s_width) - 1; ! 327: if ((mval & ~mask) != (unsigned long)0 && (mval & ~mask) != ~mask) ! 328: cwarn("bitfield initializer out of range"); ! 329: mval &= mask; /* mask value to bitfield width */ ! 330: ! 331: /* Build up the initializer in val. */ ! 332: val |= (mval << mp->s_offset); /* put value in the right place */ ! 333: ! 334: /* Check whether more bitfield initializers follow. */ ! 335: if (s != COMMA) /* no more initializers */ ! 336: break; ! 337: itrail(); /* skip COMMA */ ! 338: ++status; /* COMMA has been read */ ! 339: if (s == LBRACE || s == RBRACE /* { or }, no more bitfield inits */ ! 340: || *np >= ip->i_nsp /* no more members */ ! 341: || ip->i_sp[*np]->s_width==0 /* next not a bitfield */ ! 342: || ip->i_sp[*np]->s_value != mp->s_value) /* next at different value */ ! 343: break; ! 344: mp = ip->i_sp[(*np)++]; /* repeat for next bitfield */ ! 345: } ! 346: ! 347: /* ! 348: * Output the bitfield initializer built up in val. ! 349: * FIX_ME The initializer value collected in unsigned long 'val' ! 350: * is passed to icollect() as bicon((ival_t)val), ! 351: * this does not seem not quite right. ! 352: */ ! 353: icollect(bicon((ival_t)val), off, sp, NULL); ! 354: return status; ! 355: } ! 356: ! 357: /* end of n0/init.c */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.