1 /* $NetBSD: init.c,v 1.4 1995/10/02 17:21:37 jpo Exp $ */ 2 3 /* 4 * Copyright (c) 1994, 1995 Jochen Pohl 5 * All Rights Reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. All advertising materials mentioning features or use of this software 16 * must display the following acknowledgement: 17 * This product includes software developed by Jochen Pohl for 18 * The NetBSD Project. 19 * 4. The name of the author may not be used to endorse or promote products 20 * derived from this software without specific prior written permission. 21 * 22 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 23 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 24 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 25 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 26 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 27 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 31 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 32 */ 33 34 #ifndef lint 35 static char rcsid[] = "$NetBSD: init.c,v 1.4 1995/10/02 17:21:37 jpo Exp $"; 36 #endif 37 38 #include <stdlib.h> 39 40 #include "lint1.h" 41 42 /* 43 * initerr is set as soon as a fatal error occured in an initialisation. 44 * The effect is that the rest of the initialisation is ignored (parsed 45 * by yacc, expression trees built, but no initialisation takes place). 46 */ 47 int initerr; 48 49 /* Pointer to the symbol which is to be initialized. */ 50 sym_t *initsym; 51 52 /* Points to the top element of the initialisation stack. */ 53 istk_t *initstk; 54 55 56 static void popi2 __P((void)); 57 static void popinit __P((int)); 58 static void pushinit __P((void)); 59 static void testinit __P((void)); 60 static void nextinit __P((int)); 61 static int strginit __P((tnode_t *)); 62 63 64 /* 65 * Initialize the initialisation stack by putting an entry for the variable 66 * which is to be initialized on it. 67 */ 68 void 69 prepinit() 70 { 71 istk_t *istk; 72 73 if (initerr) 74 return; 75 76 /* free memory used in last initialisation */ 77 while ((istk = initstk) != NULL) { 78 initstk = istk->i_nxt; 79 free(istk); 80 } 81 82 /* 83 * If the type which is to be initialized is an incomplete type, 84 * it must be duplicated. 85 */ 86 if (initsym->s_type->t_tspec == ARRAY && incompl(initsym->s_type)) 87 initsym->s_type = duptyp(initsym->s_type); 88 89 istk = initstk = xcalloc(1, sizeof (istk_t)); 90 istk->i_subt = initsym->s_type; 91 istk->i_cnt = 1; 92 93 } 94 95 static void 96 popi2() 97 { 98 istk_t *istk; 99 sym_t *m; 100 101 initstk = (istk = initstk)->i_nxt; 102 if (initstk == NULL) 103 lerror("popi2() 1"); 104 free(istk); 105 106 istk = initstk; 107 108 istk->i_cnt--; 109 if (istk->i_cnt < 0) 110 lerror("popi2() 3"); 111 112 /* 113 * If the removed element was a structure member, we must go 114 * to the next structure member. 115 */ 116 if (istk->i_cnt > 0 && istk->i_type->t_tspec == STRUCT) { 117 do { 118 m = istk->i_mem = istk->i_mem->s_nxt; 119 if (m == NULL) 120 lerror("popi2() 2"); 121 } while (m->s_field && m->s_name == unnamed); 122 istk->i_subt = m->s_type; 123 } 124 } 125 126 static void 127 popinit(brace) 128 int brace; 129 { 130 if (brace) { 131 /* 132 * Take all entries, including the first which requires 133 * a closing brace, from the stack. 134 */ 135 do { 136 brace = initstk->i_brace; 137 popi2(); 138 } while (!brace); 139 } else { 140 /* 141 * Take all entries which cannot be used for further 142 * initializers from the stack, but do this only if 143 * they do not require a closing brace. 144 */ 145 while (!initstk->i_brace && 146 initstk->i_cnt == 0 && !initstk->i_nolimit) { 147 popi2(); 148 } 149 } 150 } 151 152 static void 153 pushinit() 154 { 155 istk_t *istk; 156 int cnt; 157 sym_t *m; 158 159 istk = initstk; 160 161 /* Extend an incomplete array type by one element */ 162 if (istk->i_cnt == 0) { 163 /* 164 * Inside of other aggregate types must not be an incomplete 165 * type. 166 */ 167 if (istk->i_nxt->i_nxt != NULL) 168 lerror("pushinit() 1"); 169 istk->i_cnt = 1; 170 if (istk->i_type->t_tspec != ARRAY) 171 lerror("pushinit() 2"); 172 istk->i_type->t_dim++; 173 /* from now its an complete type */ 174 setcompl(istk->i_type, 0); 175 } 176 177 if (istk->i_cnt <= 0) 178 lerror("pushinit() 3"); 179 if (istk->i_type != NULL && issclt(istk->i_type->t_tspec)) 180 lerror("pushinit() 4"); 181 182 initstk = xcalloc(1, sizeof (istk_t)); 183 initstk->i_nxt = istk; 184 initstk->i_type = istk->i_subt; 185 if (initstk->i_type->t_tspec == FUNC) 186 lerror("pushinit() 5"); 187 188 istk = initstk; 189 190 switch (istk->i_type->t_tspec) { 191 case ARRAY: 192 if (incompl(istk->i_type) && istk->i_nxt->i_nxt != NULL) { 193 /* initialisation of an incomplete type */ 194 error(175); 195 initerr = 1; 196 return; 197 } 198 istk->i_subt = istk->i_type->t_subt; 199 istk->i_nolimit = incompl(istk->i_type); 200 istk->i_cnt = istk->i_type->t_dim; 201 break; 202 case UNION: 203 if (tflag) 204 /* initialisation of union is illegal in trad. C */ 205 warning(238); 206 /* FALLTHROUGH */ 207 case STRUCT: 208 if (incompl(istk->i_type)) { 209 /* initialisation of an incomplete type */ 210 error(175); 211 initerr = 1; 212 return; 213 } 214 cnt = 0; 215 for (m = istk->i_type->t_str->memb; m != NULL; m = m->s_nxt) { 216 if (m->s_field && m->s_name == unnamed) 217 continue; 218 if (++cnt == 1) { 219 istk->i_mem = m; 220 istk->i_subt = m->s_type; 221 } 222 } 223 if (cnt == 0) { 224 /* cannot init. struct/union with no named member */ 225 error(179); 226 initerr = 1; 227 return; 228 } 229 istk->i_cnt = istk->i_type->t_tspec == STRUCT ? cnt : 1; 230 break; 231 default: 232 istk->i_cnt = 1; 233 break; 234 } 235 } 236 237 static void 238 testinit() 239 { 240 istk_t *istk; 241 242 istk = initstk; 243 244 /* 245 * If a closing brace is expected we have at least one initializer 246 * too much. 247 */ 248 if (istk->i_cnt == 0 && !istk->i_nolimit) { 249 switch (istk->i_type->t_tspec) { 250 case ARRAY: 251 /* too many array initializers */ 252 error(173); 253 break; 254 case STRUCT: 255 case UNION: 256 /* too many struct/union initializers */ 257 error(172); 258 break; 259 default: 260 /* too many initializers */ 261 error(174); 262 break; 263 } 264 initerr = 1; 265 } 266 } 267 268 static void 269 nextinit(brace) 270 int brace; 271 { 272 if (!brace) { 273 if (initstk->i_type == NULL && 274 !issclt(initstk->i_subt->t_tspec)) { 275 /* {}-enclosed initializer required */ 276 error(181); 277 } 278 /* 279 * Make sure an entry with a scalar type is at the top 280 * of the stack. 281 */ 282 if (!initerr) 283 testinit(); 284 while (!initerr && (initstk->i_type == NULL || 285 !issclt(initstk->i_type->t_tspec))) { 286 if (!initerr) 287 pushinit(); 288 } 289 } else { 290 if (initstk->i_type != NULL && 291 issclt(initstk->i_type->t_tspec)) { 292 /* invalid initializer */ 293 error(176); 294 initerr = 1; 295 } 296 if (!initerr) 297 testinit(); 298 if (!initerr) 299 pushinit(); 300 if (!initerr) 301 initstk->i_brace = 1; 302 } 303 } 304 305 void 306 initlbr() 307 { 308 if (initerr) 309 return; 310 311 if ((initsym->s_scl == AUTO || initsym->s_scl == REG) && 312 initstk->i_nxt == NULL) { 313 if (tflag && !issclt(initstk->i_subt->t_tspec)) 314 /* no automatic aggregate initialization in trad. C*/ 315 warning(188); 316 } 317 318 /* 319 * Remove all entries which cannot be used for further initializers 320 * and do not expect a closing brace. 321 */ 322 popinit(0); 323 324 nextinit(1); 325 } 326 327 void 328 initrbr() 329 { 330 if (initerr) 331 return; 332 333 popinit(1); 334 } 335 336 void 337 mkinit(tn) 338 tnode_t *tn; 339 { 340 ptrdiff_t offs; 341 sym_t *sym; 342 tspec_t lt, rt; 343 tnode_t *ln; 344 struct mbl *tmem; 345 scl_t sc; 346 347 if (initerr || tn == NULL) 348 goto end; 349 350 sc = initsym->s_scl; 351 352 /* 353 * Do not test for automatic aggregat initialisation. If the 354 * initalizer starts with a brace we have the warning already. 355 * If not, an error will be printed that the initializer must 356 * be enclosed by braces. 357 */ 358 359 /* 360 * Local initialisation of non-array-types with only one expression 361 * without braces is done by ASSIGN 362 */ 363 if ((sc == AUTO || sc == REG) && 364 initsym->s_type->t_tspec != ARRAY && initstk->i_nxt == NULL) { 365 ln = getnnode(initsym, 0); 366 ln->tn_type = tduptyp(ln->tn_type); 367 ln->tn_type->t_const = 0; 368 tn = build(ASSIGN, ln, tn); 369 expr(tn, 0, 0); 370 goto end; 371 } 372 373 /* 374 * Remove all entries which cannot be used for further initializers 375 * and do not require a closing brace. 376 */ 377 popinit(0); 378 379 /* Initialisations by strings are done in strginit(). */ 380 if (strginit(tn)) 381 goto end; 382 383 nextinit(0); 384 if (initerr || tn == NULL) 385 goto end; 386 387 initstk->i_cnt--; 388 389 /* Create a temporary node for the left side. */ 390 ln = tgetblk(sizeof (tnode_t)); 391 ln->tn_op = NAME; 392 ln->tn_type = tduptyp(initstk->i_type); 393 ln->tn_type->t_const = 0; 394 ln->tn_lvalue = 1; 395 ln->tn_sym = initsym; /* better than nothing */ 396 397 tn = cconv(tn); 398 399 lt = ln->tn_type->t_tspec; 400 rt = tn->tn_type->t_tspec; 401 402 if (!issclt(lt)) 403 lerror("mkinit() 1"); 404 405 if (!typeok(INIT, 0, ln, tn)) 406 goto end; 407 408 /* 409 * Store the tree memory. This is nessesary because otherwise 410 * expr() would free it. 411 */ 412 tmem = tsave(); 413 expr(tn, 1, 0); 414 trestor(tmem); 415 416 if (isityp(lt) && ln->tn_type->t_isfield && !isityp(rt)) { 417 /* 418 * Bit-fields can be initialized in trad. C only by integer 419 * constants. 420 */ 421 if (tflag) 422 /* bit-field initialisation is illegal in trad. C */ 423 warning(186); 424 } 425 426 if (lt != rt || (initstk->i_type->t_isfield && tn->tn_op == CON)) 427 tn = convert(INIT, 0, initstk->i_type, tn); 428 429 if (tn != NULL && tn->tn_op != CON) { 430 sym = NULL; 431 offs = 0; 432 if (conaddr(tn, &sym, &offs) == -1) { 433 if (sc == AUTO || sc == REG) { 434 /* non-constant initializer */ 435 (void)gnuism(177); 436 } else { 437 /* non-constant initializer */ 438 error(177); 439 } 440 } 441 } 442 443 end: 444 tfreeblk(); 445 } 446 447 448 static int 449 strginit(tn) 450 tnode_t *tn; 451 { 452 tspec_t t; 453 istk_t *istk; 454 int len; 455 strg_t *strg; 456 457 if (tn->tn_op != STRING) 458 return (0); 459 460 istk = initstk; 461 strg = tn->tn_strg; 462 463 /* 464 * Check if we have an array type which can be initialized by 465 * the string. 466 */ 467 if (istk->i_subt->t_tspec == ARRAY) { 468 t = istk->i_subt->t_subt->t_tspec; 469 if (!((strg->st_tspec == CHAR && 470 (t == CHAR || t == UCHAR || t == SCHAR)) || 471 (strg->st_tspec == WCHAR && t == WCHAR))) { 472 return (0); 473 } 474 /* Put the array at top of stack */ 475 pushinit(); 476 istk = initstk; 477 } else if (istk->i_type != NULL && istk->i_type->t_tspec == ARRAY) { 478 t = istk->i_type->t_subt->t_tspec; 479 if (!((strg->st_tspec == CHAR && 480 (t == CHAR || t == UCHAR || t == SCHAR)) || 481 (strg->st_tspec == WCHAR && t == WCHAR))) { 482 return (0); 483 } 484 /* 485 * If the array is already partly initialized, we are 486 * wrong here. 487 */ 488 if (istk->i_cnt != istk->i_type->t_dim) 489 return (0); 490 } else { 491 return (0); 492 } 493 494 /* Get length without trailing NUL character. */ 495 len = strg->st_len; 496 497 if (istk->i_nolimit) { 498 istk->i_nolimit = 0; 499 istk->i_type->t_dim = len + 1; 500 /* from now complete type */ 501 setcompl(istk->i_type, 0); 502 } else { 503 if (istk->i_type->t_dim < len) { 504 /* non-null byte ignored in string initializer */ 505 warning(187); 506 } 507 } 508 509 /* In every case the array is initialized completely. */ 510 istk->i_cnt = 0; 511 512 return (1); 513 } 514