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