1 /* $NetBSD: init.c,v 1.24 2009/10/02 18:17:16 christos 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 #if HAVE_NBTOOL_CONFIG_H 35 #include "nbtool_config.h" 36 #endif 37 38 #include <sys/cdefs.h> 39 #if defined(__RCSID) && !defined(lint) 40 __RCSID("$NetBSD: init.c,v 1.24 2009/10/02 18:17:16 christos Exp $"); 41 #endif 42 43 #include <stdlib.h> 44 #include <string.h> 45 #include <ctype.h> 46 47 #include "lint1.h" 48 49 /* 50 * initerr is set as soon as a fatal error occurred in an initialisation. 51 * The effect is that the rest of the initialisation is ignored (parsed 52 * by yacc, expression trees built, but no initialisation takes place). 53 */ 54 int initerr; 55 56 /* Pointer to the symbol which is to be initialized. */ 57 sym_t *initsym; 58 59 /* Points to the top element of the initialisation stack. */ 60 istk_t *initstk; 61 62 typedef struct namlist { 63 const char *n_name; 64 struct namlist *n_prev; 65 struct namlist *n_next; 66 } namlist_t; 67 68 /* Points to a c9x named member; */ 69 namlist_t *namedmem = NULL; 70 71 72 static void popi2(void); 73 static void popinit(int); 74 static void pushinit(void); 75 static void testinit(void); 76 static void nextinit(int); 77 static int strginit(tnode_t *); 78 static void memberpop(void); 79 80 #ifndef DEBUG 81 #define DPRINTF(a) 82 #else 83 #define DPRINTF(a) printf a 84 #endif 85 86 void 87 memberpush(sb) 88 sbuf_t *sb; 89 { 90 namlist_t *nam = xcalloc(1, sizeof (namlist_t)); 91 nam->n_name = sb->sb_name; 92 DPRINTF(("memberpush = %s\n", nam->n_name)); 93 if (namedmem == NULL) { 94 nam->n_prev = nam->n_next = nam; 95 namedmem = nam; 96 } else { 97 namedmem->n_prev->n_next = nam; 98 nam->n_prev = namedmem->n_prev; 99 nam->n_next = namedmem; 100 namedmem->n_prev = nam; 101 } 102 #if 0 103 nam->n_next = namedmem; 104 namedmem = nam; 105 #endif 106 } 107 108 static void 109 memberpop() 110 { 111 DPRINTF(("memberpop = %s\n", namedmem->n_name)); 112 if (namedmem->n_next == namedmem) { 113 free(namedmem); 114 namedmem = NULL; 115 } else { 116 namlist_t *nam = namedmem; 117 namedmem = namedmem->n_next; 118 free(nam); 119 } 120 #if 0 121 namedmem = namedmem->n_next; 122 free(nam); 123 #endif 124 } 125 126 127 /* 128 * Initialize the initialisation stack by putting an entry for the variable 129 * which is to be initialized on it. 130 */ 131 void 132 prepinit(void) 133 { 134 istk_t *istk; 135 136 if (initerr) 137 return; 138 139 /* free memory used in last initialisation */ 140 while ((istk = initstk) != NULL) { 141 initstk = istk->i_nxt; 142 free(istk); 143 } 144 145 /* 146 * If the type which is to be initialized is an incomplete type, 147 * it must be duplicated. 148 */ 149 if (initsym->s_type->t_tspec == ARRAY && incompl(initsym->s_type)) 150 initsym->s_type = duptyp(initsym->s_type); 151 152 istk = initstk = xcalloc(1, sizeof (istk_t)); 153 istk->i_subt = initsym->s_type; 154 istk->i_cnt = 1; 155 156 } 157 158 static void 159 popi2(void) 160 { 161 #ifdef DEBUG 162 char buf[64]; 163 #endif 164 istk_t *istk; 165 sym_t *m; 166 167 DPRINTF(("popi2(%s): brace=%d count=%d namedmem %d\n", 168 tyname(buf, sizeof(buf), 169 initstk->i_type ? initstk->i_type : initstk->i_subt), 170 initstk->i_brace, initstk->i_cnt, initstk->i_namedmem)); 171 initstk = (istk = initstk)->i_nxt; 172 if (initstk == NULL) 173 LERROR("popi2()"); 174 free(istk); 175 176 istk = initstk; 177 178 istk->i_cnt--; 179 if (istk->i_cnt < 0) 180 LERROR("popi2()"); 181 182 DPRINTF(("popi2(): %d %s\n", istk->i_cnt, 183 namedmem ? namedmem->n_name : "*null*")); 184 if (istk->i_cnt >= 0 && namedmem != NULL) { 185 DPRINTF(("popi2(): %d %s %s\n", istk->i_cnt, 186 tyname(buf, sizeof(buf), istk->i_type), namedmem->n_name)); 187 for (m = istk->i_type->t_str->memb; m != NULL; m = m->s_nxt) { 188 if (m->s_field && m->s_name == unnamed) 189 continue; 190 if (strcmp(m->s_name, namedmem->n_name) == 0) { 191 istk->i_subt = m->s_type; 192 istk->i_cnt++; 193 memberpop(); 194 return; 195 } 196 } 197 error(101, namedmem->n_name); 198 memberpop(); 199 istk->i_namedmem = 1; 200 return; 201 } 202 /* 203 * If the removed element was a structure member, we must go 204 * to the next structure member. 205 */ 206 if (istk->i_cnt > 0 && istk->i_type->t_tspec == STRUCT && 207 !istk->i_namedmem) { 208 do { 209 m = istk->i_mem = istk->i_mem->s_nxt; 210 if (m == NULL) 211 LERROR("popi2()"); 212 } while (m->s_field && m->s_name == unnamed); 213 istk->i_subt = m->s_type; 214 } 215 } 216 217 static void 218 popinit(int brace) 219 { 220 DPRINTF(("popinit(%d)\n", brace)); 221 222 if (brace) { 223 /* 224 * Take all entries, including the first which requires 225 * a closing brace, from the stack. 226 */ 227 do { 228 brace = initstk->i_brace; 229 popi2(); 230 } while (!brace); 231 } else { 232 /* 233 * Take all entries which cannot be used for further 234 * initializers from the stack, but do this only if 235 * they do not require a closing brace. 236 */ 237 while (!initstk->i_brace && 238 initstk->i_cnt == 0 && !initstk->i_nolimit) { 239 popi2(); 240 } 241 } 242 } 243 244 static void 245 pushinit(void) 246 { 247 #ifdef DEBUG 248 char buf[64]; 249 #endif 250 istk_t *istk, *inxt; 251 int cnt; 252 sym_t *m; 253 254 istk = initstk; 255 256 /* Extend an incomplete array type by one element */ 257 if (istk->i_cnt == 0) { 258 DPRINTF(("pushinit(extend) %s\n", tyname(buf, sizeof(buf), 259 istk->i_type))); 260 /* 261 * Inside of other aggregate types must not be an incomplete 262 * type. 263 */ 264 if (istk->i_nxt->i_nxt != NULL) 265 LERROR("pushinit()"); 266 istk->i_cnt = 1; 267 if (istk->i_type->t_tspec != ARRAY) 268 LERROR("pushinit()"); 269 istk->i_type->t_dim++; 270 /* from now its an complete type */ 271 setcompl(istk->i_type, 0); 272 } 273 274 if (istk->i_cnt <= 0) 275 LERROR("pushinit()"); 276 if (istk->i_type != NULL && issclt(istk->i_type->t_tspec)) 277 LERROR("pushinit()"); 278 279 initstk = xcalloc(1, sizeof (istk_t)); 280 initstk->i_nxt = istk; 281 initstk->i_type = istk->i_subt; 282 if (initstk->i_type->t_tspec == FUNC) 283 LERROR("pushinit()"); 284 285 again: 286 istk = initstk; 287 288 DPRINTF(("pushinit(%s)\n", tyname(buf, sizeof(buf), istk->i_type))); 289 switch (istk->i_type->t_tspec) { 290 case ARRAY: 291 if (namedmem) { 292 DPRINTF(("pushinit ARRAY %s brace=%d\n", 293 namedmem->n_name, istk->i_brace)); 294 goto pop; 295 } else if (istk->i_nxt->i_namedmem) { 296 DPRINTF(("pushinit ARRAY brace=%d, namedmem=%d\n", 297 istk->i_brace, istk->i_nxt->i_namedmem)); 298 istk->i_brace = 1; 299 } 300 301 if (incompl(istk->i_type) && istk->i_nxt->i_nxt != NULL) { 302 /* initialisation of an incomplete type */ 303 error(175); 304 initerr = 1; 305 return; 306 } 307 istk->i_subt = istk->i_type->t_subt; 308 istk->i_nolimit = incompl(istk->i_type); 309 istk->i_cnt = istk->i_type->t_dim; 310 DPRINTF(("elements array %s[%d] %s\n", 311 tyname(buf, sizeof(buf), istk->i_subt), istk->i_cnt, 312 namedmem ? namedmem->n_name : "*none*")); 313 break; 314 case UNION: 315 if (tflag) 316 /* initialisation of union is illegal in trad. C */ 317 warning(238); 318 /* FALLTHROUGH */ 319 case STRUCT: 320 if (incompl(istk->i_type)) { 321 /* initialisation of an incomplete type */ 322 error(175); 323 initerr = 1; 324 return; 325 } 326 cnt = 0; 327 DPRINTF(("2. member lookup %s %s\n", 328 tyname(buf, sizeof(buf), istk->i_type), 329 namedmem ? namedmem->n_name : "*none*")); 330 for (m = istk->i_type->t_str->memb; m != NULL; m = m->s_nxt) { 331 if (m->s_field && m->s_name == unnamed) 332 continue; 333 if (namedmem != NULL) { 334 DPRINTF(("pushinit():[member:%s, looking:%s]\n", 335 m->s_name, namedmem->n_name)); 336 if (strcmp(m->s_name, namedmem->n_name) == 0) { 337 cnt++; 338 break; 339 } else 340 continue; 341 } 342 if (++cnt == 1) { 343 istk->i_mem = m; 344 istk->i_subt = m->s_type; 345 } 346 } 347 if (namedmem != NULL) { 348 if (m == NULL) { 349 DPRINTF(("pushinit(): struct pop\n")); 350 goto pop; 351 } else { 352 istk->i_mem = m; 353 istk->i_subt = m->s_type; 354 } 355 istk->i_namedmem = 1; 356 istk->i_brace = 1; 357 memberpop(); 358 cnt = istk->i_type->t_tspec == STRUCT ? 2 : 1; 359 } 360 if (cnt == 0) { 361 /* cannot init. struct/union with no named member */ 362 error(179); 363 initerr = 1; 364 return; 365 } 366 istk->i_cnt = istk->i_type->t_tspec == STRUCT ? cnt : 1; 367 break; 368 default: 369 if (namedmem) { 370 DPRINTF(("pushinit(): pop\n")); 371 pop: 372 inxt = initstk->i_nxt; 373 free(istk); 374 initstk = inxt; 375 goto again; 376 } 377 istk->i_cnt = 1; 378 break; 379 } 380 } 381 382 static void 383 testinit(void) 384 { 385 istk_t *istk; 386 387 istk = initstk; 388 389 /* 390 * If a closing brace is expected we have at least one initializer 391 * too much. 392 */ 393 if (istk->i_cnt == 0 && !istk->i_nolimit && !istk->i_namedmem) { 394 switch (istk->i_type->t_tspec) { 395 case ARRAY: 396 /* too many array initializers */ 397 error(173, istk->i_type->t_dim); 398 break; 399 case STRUCT: 400 case UNION: 401 /* too many struct/union initializers */ 402 error(172); 403 break; 404 default: 405 /* too many initializers */ 406 error(174); 407 break; 408 } 409 initerr = 1; 410 } 411 } 412 413 static void 414 nextinit(int brace) 415 { 416 char buf[64]; 417 418 DPRINTF(("nextinit(%d)\n", brace)); 419 if (!brace) { 420 if (initstk->i_type == NULL && 421 !issclt(initstk->i_subt->t_tspec)) { 422 /* {}-enclosed initializer required */ 423 error(181); 424 } 425 /* 426 * Make sure an entry with a scalar type is at the top 427 * of the stack. 428 */ 429 if (!initerr) 430 testinit(); 431 while (!initerr && (initstk->i_type == NULL || 432 !issclt(initstk->i_type->t_tspec))) { 433 if (!initerr) 434 pushinit(); 435 } 436 } else { 437 if (initstk->i_type != NULL && 438 issclt(initstk->i_type->t_tspec)) { 439 /* invalid initializer */ 440 error(176, tyname(buf, sizeof(buf), initstk->i_type)); 441 initerr = 1; 442 } 443 if (!initerr) 444 testinit(); 445 if (!initerr) 446 pushinit(); 447 if (!initerr) 448 initstk->i_brace = 1; 449 } 450 } 451 452 void 453 initlbr(void) 454 { 455 DPRINTF(("initlbr\n")); 456 457 if (initerr) 458 return; 459 460 if ((initsym->s_scl == AUTO || initsym->s_scl == REG) && 461 initstk->i_nxt == NULL) { 462 if (tflag && !issclt(initstk->i_subt->t_tspec)) 463 /* no automatic aggregate initialization in trad. C*/ 464 warning(188); 465 } 466 467 /* 468 * Remove all entries which cannot be used for further initializers 469 * and do not expect a closing brace. 470 */ 471 popinit(0); 472 473 nextinit(1); 474 } 475 476 void 477 initrbr(void) 478 { 479 DPRINTF(("initrbr\n")); 480 481 if (initerr) 482 return; 483 484 popinit(1); 485 } 486 487 void 488 mkinit(tnode_t *tn) 489 { 490 ptrdiff_t offs; 491 sym_t *sym; 492 tspec_t lt, rt; 493 tnode_t *ln; 494 struct mbl *tmem; 495 scl_t sc; 496 #ifdef DEBUG 497 char buf[64], sbuf[64]; 498 #endif 499 500 DPRINTF(("mkinit(%s %s)\n", tyname(buf, sizeof(buf), tn->tn_type), 501 prtnode(sbuf, sizeof(sbuf), tn))); 502 if (initerr || tn == NULL) 503 goto end; 504 505 sc = initsym->s_scl; 506 507 /* 508 * Do not test for automatic aggregate initialisation. If the 509 * initializer starts with a brace we have the warning already. 510 * If not, an error will be printed that the initializer must 511 * be enclosed by braces. 512 */ 513 514 /* 515 * Local initialisation of non-array-types with only one expression 516 * without braces is done by ASSIGN 517 */ 518 if ((sc == AUTO || sc == REG) && 519 initsym->s_type->t_tspec != ARRAY && initstk->i_nxt == NULL) { 520 ln = getnnode(initsym, 0); 521 ln->tn_type = tduptyp(ln->tn_type); 522 ln->tn_type->t_const = 0; 523 tn = build(ASSIGN, ln, tn); 524 expr(tn, 0, 0, 1); 525 goto end; 526 } 527 528 /* 529 * Remove all entries which cannot be used for further initializers 530 * and do not require a closing brace. 531 */ 532 popinit(0); 533 534 /* Initialisations by strings are done in strginit(). */ 535 if (strginit(tn)) 536 goto end; 537 538 nextinit(0); 539 if (initerr || tn == NULL) 540 goto end; 541 542 initstk->i_cnt--; 543 DPRINTF(("mkinit() cnt=%d tn=%p\n", initstk->i_cnt, tn)); 544 /* Create a temporary node for the left side. */ 545 ln = tgetblk(sizeof (tnode_t)); 546 ln->tn_op = NAME; 547 ln->tn_type = tduptyp(initstk->i_type); 548 ln->tn_type->t_const = 0; 549 ln->tn_lvalue = 1; 550 ln->tn_sym = initsym; /* better than nothing */ 551 552 tn = cconv(tn); 553 554 lt = ln->tn_type->t_tspec; 555 rt = tn->tn_type->t_tspec; 556 557 if (!issclt(lt)) 558 LERROR("mkinit()"); 559 560 if (!typeok(INIT, 0, ln, tn)) 561 goto end; 562 563 /* 564 * Store the tree memory. This is nessesary because otherwise 565 * expr() would free it. 566 */ 567 tmem = tsave(); 568 expr(tn, 1, 0, 1); 569 trestor(tmem); 570 571 if (isityp(lt) && ln->tn_type->t_isfield && !isityp(rt)) { 572 /* 573 * Bit-fields can be initialized in trad. C only by integer 574 * constants. 575 */ 576 if (tflag) 577 /* bit-field initialisation is illegal in trad. C */ 578 warning(186); 579 } 580 581 if (lt != rt || (initstk->i_type->t_isfield && tn->tn_op == CON)) 582 tn = convert(INIT, 0, initstk->i_type, tn); 583 584 if (tn != NULL && tn->tn_op != CON) { 585 sym = NULL; 586 offs = 0; 587 if (conaddr(tn, &sym, &offs) == -1) { 588 if (sc == AUTO || sc == REG) { 589 /* non-constant initializer */ 590 (void)c99ism(177); 591 } else { 592 /* non-constant initializer */ 593 error(177); 594 } 595 } 596 } 597 598 end: 599 /* 600 * We only free the block, if we are not a compound declaration 601 * We know that the only symbols that start with a digit are the 602 * ones we allocate with mktempsym() for compound declarations 603 */ 604 if (!isdigit((unsigned char)initsym->s_name[0])) 605 tfreeblk(); 606 } 607 608 609 static int 610 strginit(tnode_t *tn) 611 { 612 tspec_t t; 613 istk_t *istk; 614 int len; 615 strg_t *strg; 616 617 if (tn->tn_op != STRING) 618 return (0); 619 620 istk = initstk; 621 strg = tn->tn_strg; 622 623 /* 624 * Check if we have an array type which can be initialized by 625 * the string. 626 */ 627 if (istk->i_subt != NULL && istk->i_subt->t_tspec == ARRAY) { 628 DPRINTF(("strginit subt array\n")); 629 t = istk->i_subt->t_subt->t_tspec; 630 if (!((strg->st_tspec == CHAR && 631 (t == CHAR || t == UCHAR || t == SCHAR)) || 632 (strg->st_tspec == WCHAR && t == WCHAR))) { 633 return (0); 634 } 635 /* Put the array at top of stack */ 636 pushinit(); 637 istk = initstk; 638 } else if (istk->i_type != NULL && istk->i_type->t_tspec == ARRAY) { 639 DPRINTF(("strginit type array\n")); 640 t = istk->i_type->t_subt->t_tspec; 641 if (!((strg->st_tspec == CHAR && 642 (t == CHAR || t == UCHAR || t == SCHAR)) || 643 (strg->st_tspec == WCHAR && t == WCHAR))) { 644 return (0); 645 } 646 /* 647 * If the array is already partly initialized, we are 648 * wrong here. 649 */ 650 if (istk->i_cnt != istk->i_type->t_dim) 651 return (0); 652 } else { 653 return (0); 654 } 655 656 /* Get length without trailing NUL character. */ 657 len = strg->st_len; 658 659 if (istk->i_nolimit) { 660 istk->i_nolimit = 0; 661 istk->i_type->t_dim = len + 1; 662 /* from now complete type */ 663 setcompl(istk->i_type, 0); 664 } else { 665 if (istk->i_type->t_dim < len) { 666 /* non-null byte ignored in string initializer */ 667 warning(187); 668 } 669 } 670 671 /* In every case the array is initialized completely. */ 672 istk->i_cnt = 0; 673 674 return (1); 675 } 676