1 /*******************************************************************************
2 
3 	C parser
4 
5 *******************************************************************************/
6 #include <stdlib.h>
7 #include <string.h>
8 #include <stdio.h>
9 #include <unistd.h>
10 #include <assert.h>
11 
12 #include "global.h"
13 
14 exprtree CExpr;
15 lrt last_result_type;
16 
17 //***************************************************************************
18 //		Forward
19 //***************************************************************************
20 static NormPtr constant_int_expression (NormPtr, int&);
21 static NormPtr parse_expression (NormPtr);
22 static NormPtr parse_structure (NormPtr);
23 //***************************************************************************
24 //		Declarations I
25 //***************************************************************************
26 static NormPtr skip_parens (NormPtr);
27 static NormPtr skip_brackets (NormPtr);
28 static int initializer_nsize (NormPtr, int);
29 static NormPtr get_enum_consts (NormPtr);
30 
31 class declarator
32 {
33 	NormPtr p;
34 	int dp;
35 inline	void dcl ();
36 	void dirdcl ();
37 	void bitfield ();
38 	void arglist_to_specs ();
39 	NormPtr parse (NormPtr);
40 
41 #ifdef GNU_VIOLATIONS
42 	NormPtr bt_typeof (NormPtr);
43 #endif
44 	NormPtr builtin (NormPtr);
45 	NormPtr bt_enum (NormPtr);
46 	NormPtr bt_typedef (NormPtr);
47 	NormPtr bt_struct (NormPtr);
48 
49 	void complete_size ();
50 	void argument_conversions ();
51 	void semantics ();
52 	bool do_argument_conversions;
53    public:
54 	ObjPtr basetype;
55 	bool have_extern, have_static, have_typedef, have_const,
56 	     have_init, have_code, is_anonymous, is_struct_dcl;
57 
58 	declarator (bool b = false) { do_argument_conversions = b; is_struct_dcl = false; }
59 	NormPtr parse_base (NormPtr);
60 	NormPtr parse_dcl (NormPtr);
61 
62 	typeID gentype;
63 	NormPtr args;
64 	NormPtr psst, pslen;
65 	int symbol;
66 	int spec [MSPEC];
67 };
68 //***********************************************************************
69 //		definitions : declarator
70 //***********************************************************************
71 
parse(NormPtr i)72 NormPtr declarator::parse (NormPtr i)
73 {
74 	p = i; dp = 0; args = symbol = -1; have_init = have_code = false;
75 
76 	if (CODE [i] == ':' || (ISSYMBOL (CODE [i]) && CODE [i + 1] == ':'))
77 		bitfield ();
78 	else dcl ();
79 
80 	/* Ben Lau for M68K Kernel from uClinux */
81 	if (CODE [p] == RESERVED___asm__)
82 		p = skip_parens (p + 1);
83 
84 	spec [dp] = -1;
85 	have_init = CODE [p] == '=';
86 	have_code = CODE [p] == '{';
87 
88 	return p;
89 }
90 
bitfield()91 void declarator::bitfield ()
92 {
93 	if (CODE [p] != ':') symbol = CODE [p++];
94 	spec [0] = ':';
95 	p = constant_int_expression (++p, spec [1]);
96 	dp = 2;
97 }
98 
dcl()99 void declarator::dcl ()
100 {
101 	int ns = 0;
102 
103 	for (;; p++)
104 		if (CODE [p] == '*') ++ns;
105 		else if (CODE [p] != RESERVED_const
106 			&& CODE [p] != RESERVED_volatile) break;
107 	dirdcl ();
108 	while (ns--) spec [dp++] = '*';
109 }
110 
array_size_expression(NormPtr p,int & r)111 NormPtr array_size_expression (NormPtr p, int &r)
112 {
113 	NormPtr pe = constant_int_expression (p, r);
114 	if (CODE [p] != ']' && infuncs) {
115 		pe = parse_expression (p);
116 		r = 0;
117 	}
118 	return pe;
119 }
120 
dirdcl()121 void declarator::dirdcl ()
122 {
123 	if (CODE [p] == '(') {
124 		++p;
125 		dcl ();
126 		if (CODE [p++] != ')') syntax_error (p, "Missing parenthesis");
127 	} else if (ISSYMBOL (CODE [p]))
128 		symbol = CODE [p++];
129 
130 	for (;;) {
131 		switch (CODE [p]) {
132 		case '(':
133 			if (args == -1) args = p;
134 			spec [dp++] = '(';
135 			arglist_to_specs ();
136 			continue;
137 		case '[':
138 			if (CODE [++p] == ']') {
139 				spec [dp++] = '[';
140 				spec [dp++] = 0;
141 				p++; continue;
142 			}
143 			spec [dp++] = '[';
144 			p = array_size_expression (p, spec [dp++]);
145 			if (CODE [p++] != ']')
146 				syntax_error (p, "No :]");
147 			continue;
148 		}
149 		break;
150 	}
151 }
152 
complete_size()153 void declarator::complete_size ()
154 {
155 	int t = CODE [p + 1];
156 	if (ISSTRING (t)) gstr: spec [1] = strlen (C_Strings [t - STRINGBASE]) + 1;
157 	else if (t == '(' && ISSTRING (CODE [p + 2]) && CODE [p + 3] == ')') {
158 		t = CODE [p + 2];
159 		goto gstr;
160 	} else if (t == '{') {
161 		int i, a = esizeof_objptr (basetype);
162 		for (i = 2; spec [i] == '['; i += 2)
163 			a *= spec [i + 1];
164 		spec [1] = initializer_nsize (p + 1, a);
165 	} else syntax_error (p, "incomplete array initializer single");
166 }
167 
semantics()168 void declarator::semantics ()
169 {
170 	int i = 0, v, dpi = dp;
171 
172 	if (spec [0] == '(') {
173 		if (have_init) syntax_error (p, "Function != Variable");
174 	} else if (have_code) syntax_error (p, "Variable != Function");
175 
176 	if (spec [0] == ':') {
177 		if (spec [1] < 0 || spec [1] > BITFIELD_Q)
178 			syntax_error (p, "absurd");
179 		return;
180 	}
181 
182 	while (i < dpi)
183 		if (spec [i] == '[') {
184 			i += 2;
185 			if (spec [i] == '(')
186 				syntax_error (p, "array of functions");
187 		} else if (spec [i] == '(') {
188 			i += 2;
189 			v = spec [i];
190 			if (v == '(' || v == '[')
191 				syntax_error (p, "Function returning invalid");
192 		} else i++;
193 }
194 
initializer_nsize(NormPtr p,int na)195 static int initializer_nsize (NormPtr p, int na)
196 {
197 	int ec = 1;
198 	NormPtr e = skip_brackets (p++);
199 
200 	while (p < e)
201 		if (CODE [p] == ',') ec++, p++;
202 		else if (CODE [p] == '{') {
203 			ec += na;
204 			p = skip_brackets (p);
205 		} else p++;
206 
207 	return na ? ec / na : ec;
208 }
209 
skip_parens(NormPtr p)210 static NormPtr skip_parens (NormPtr p)
211 {
212 	int ns = 0;
213 
214 	for (; p < C_Ntok; p++)
215 		if (CODE [p] == '(') ++ns;
216 		else if (CODE [p] == ')')
217 			if (--ns == 0) return p + 1;
218 	return syntax_error (p, "Unclosed parenthesis:)");
219 }
220 
skip_brackets(NormPtr p)221 static NormPtr skip_brackets (NormPtr p)
222 {
223 	int ns = 0;
224 
225 	for (; p < C_Ntok; p++)
226 		if (CODE [p] == '{') ++ns;
227 		else if (CODE [p] == '}')
228 			if (--ns == 0) return p + 1;
229 	return syntax_error (p, "Unclosed brackets:}");
230 }
231 
232 //***********************************************************************
233 //		definitions : declarator
234 //***********************************************************************
235 
argument_conversions()236 void declarator::argument_conversions ()
237 {
238 	int tspec [MSPEC], *tp = tspec, *vp = spec;
239 
240 	if (basetype >= TYPEDEF_BASE && *vp == -1) {
241 		type t;
242 		opentype (basetype - TYPEDEF_BASE, t);
243 		if (t.spec [0] == '(') *tp++ = '*';
244 	}
245 
246 	if (*vp == '(') *tp++ = '*';
247 	for (;;vp++) {
248 		switch (*vp) {
249 		case '*': *tp++ = '*'; continue;
250 		case '[': *tp++ = '*'; vp++; continue;
251 		case '(': *tp++ = '('; *tp++ = *++vp; continue;
252 		}
253 		*tp = -1;
254 		break;
255 	}
256 	intcpy (spec, tspec);
257 }
258 
parse_dcl(NormPtr p)259 NormPtr declarator::parse_dcl (NormPtr p)
260 {
261 	p = parse (p);
262 	if (have_init && spec [0] == '[' && spec [1] == 0) complete_size ();
263 	semantics ();
264 	if (do_argument_conversions) argument_conversions ();
265 	gentype = gettype (basetype, spec);
266 	return p;
267 }
268 
parse_base(NormPtr p)269 NormPtr declarator::parse_base (NormPtr p)
270 {
271 	have_extern = have_static = have_typedef = have_const = is_anonymous = false;
272 
273 	while (ISDCLFLAG (CODE [p]))
274 		switch (CODE [p++]) {
275 		case RESERVED_extern:  have_extern  = true; break;
276 		case RESERVED_static:  have_static  = true; break;
277 		case RESERVED_typedef: have_typedef = true; break;
278 		case RESERVED_const:   have_const   = true; break;
279 		}
280 
281 	if ((have_extern && have_static) || (have_extern && have_typedef)
282 	|| (have_static && have_typedef)) syntax_error (p, "Decide");
283 
284 	if (ISBASETYPE (CODE [p]) || ISHBASETYPE (CODE [p]))
285 		p =  builtin (p);
286 	else if (CODE [p] == RESERVED_struct || CODE [p] == RESERVED_union)
287 		p = bt_struct (p);
288 	else if (ISSYMBOL (CODE [p]))
289 		p = bt_typedef (p);
290 	else if (CODE [p] == RESERVED_enum)
291 		p = bt_enum (p + 1);
292 #ifdef GNU_VIOLATIONS
293 	else if (CODE [p] == RESERVED___typeof__)
294 		p = bt_typeof (p + 1);
295 	else if (CODE [p] == RESERVED___label__) {
296 		while (CODE [p] != ';') p++;
297 	}
298 #endif
299 	else basetype = S_INT;
300 
301 	while (ISDCLFLAG (CODE [p]))
302 		switch (CODE [p++]) {
303 		case RESERVED_extern:  have_extern  = true; break;
304 		case RESERVED_static:  have_static  = true; break;
305 		case RESERVED_typedef: have_typedef = true; break;
306 		case RESERVED_const:   have_const   = true; break;
307 		}
308 
309 	return p;
310 }
311 
builtin(NormPtr p)312 NormPtr declarator::builtin (NormPtr p)
313 {
314 	int bt, sh, lo, si, us;
315 
316 	bt = sh = lo = si = us = 0;
317 	for (;ISBASETYPE (CODE [p]) || ISHBASETYPE (CODE [p])
318 	 || CODE [p] == RESERVED_const; p++)
319 		switch (CODE [p]) {
320 		case RESERVED_long:     lo++; break;
321 		case RESERVED_short:    sh++; break;
322 		case RESERVED_signed:   si++; break;
323 		case RESERVED_unsigned: us++; break;
324 		case RESERVED_const:	continue;
325 		default: if (bt) syntax_error (p, "Please specify");
326 			bt = CODE [p];
327 	}
328 
329 	if (bt == 0) bt = RESERVED_int;
330 	if ((lo && sh) || (si && us)) syntax_error (p, "AMBIGUOUS specifiers");
331 	switch (bt) {
332 	case RESERVED_float: basetype = FLOAT; break;
333 	case RESERVED_double: basetype = DOUBLE; break;
334 	case RESERVED_void: basetype = VOID; break;
335 	case RESERVED_char: basetype = (us) ? U_CHAR : S_CHAR; break;
336 	case RESERVED_int:
337 		if (sh) basetype = (us) ? U_SINT : S_SINT;
338 		else if (lo == 1) basetype = (us) ? U_LINT : S_LINT;
339 		else if (lo > 1) basetype = (us) ? U_LONG : S_LONG;
340 		else basetype = (us) ? U_INT : S_INT;
341 	}
342 
343 	return p;
344 }
345 
bt_enum(NormPtr p)346 NormPtr declarator::bt_enum (NormPtr p)
347 {
348 	basetype = S_INT;
349 	if (!ISSYMBOL (CODE [p]) && CODE [p] != '{')
350 		syntax_error (p, "DEAD rats after enum");
351 
352 	if (CODE [p] != '{' && CODE [p + 1] != '{') {
353 		if (!valid_enumtag (CODE [p]) &&
354 		    !introduce_enumtag (CODE [p], true))
355 			syntax_error (p, "enum tag REDEFINED");
356 		return p + 1;
357 	}
358 
359 	if (CODE [p] != '{')
360 		if (!introduce_enumtag (CODE [p++]))
361 			syntax_error (p, "enum tag REDEFINED");
362 
363 	return get_enum_consts (p);
364 }
365 
bt_typedef(NormPtr p)366 NormPtr declarator::bt_typedef (NormPtr p)
367 {
368 	if ((basetype = lookup_typedef (CODE [p])) == -1) {
369 		basetype = S_INT;
370 		return p;
371 	}
372 	++p;
373 	return ISHBASETYPE (CODE [p]) ? p + 1 : p;
374 }
375 
bt_struct(NormPtr p)376 NormPtr declarator::bt_struct (NormPtr p)
377 {
378 	bool isst = CODE [p++] == RESERVED_struct;
379 
380 	if (!ISSYMBOL (CODE [p]) && CODE [p] != '{')
381 		syntax_error (p, "DEAD RATS after struct");
382 
383 	if (CODE [p] != '{' && CODE [p + 1] != '{') {
384 		basetype = (CODE [p + 1] == ';')
385 		 	? fwd_struct_tag (CODE [p], isst)
386 			: use_struct_tag (CODE [p], isst);
387 		return p + 1;
388 	}
389 
390 	if ((is_anonymous = CODE [p] == '{'))
391 		basetype = introduce_anon_struct (isst);
392 	else if ((basetype = introduce_named_struct (CODE [p++], isst)) == -1)
393 		syntax_error (p, "Redefined structure tag");
394 
395 	is_struct_dcl = true;
396 	psst = p++ - 1;
397 	p = parse_structure (p);
398 	pslen = p - psst;
399 	return p;
400 }
401 
get_enum_consts(NormPtr p)402 static NormPtr get_enum_consts (NormPtr p)
403 {
404 	int counter = 0, s;
405 
406 	for (++p;;) {
407 		s = CODE [p++];
408 		if (s == '}') break;
409 		if (!ISSYMBOL (s))
410 			syntax_error (p, "Random NOISE INSIDE ENUM");
411 		if (CODE [p] == '=')
412 			p = constant_int_expression (++p, counter);
413 		if (!introduce_enumconst (s, counter++))
414 			syntax_error (p, "Enumeration constant exists");
415 		s = CODE [p++];
416 		if (s == '}') break;
417 		if (s != ',')
418 			syntax_error (p, "RANDOM noise inside enum");
419 	}
420 
421 	return p;
422 }
423 
424 //***************************************************************************
425 //		Forward
426 //***************************************************************************
427 static NormPtr initializer_expr (Symbol, NormPtr);
428 static NormPtr initializer_aggregate (Symbol, NormPtr);
429 static NormPtr parse_function (Symbol, NormPtr, NormPtr, NormPtr);
430 static bool is_dcl_start (int);
431 //***************************************************************************
432 //		Declarations II
433 //
434 //	Four places of declarators:
435 //	1) Declarator in code or global
436 //	2) Declarator inside structure block
437 //	3) Function argument list
438 //	4) (type cast)
439 //***************************************************************************
440 class cast_type
441 {
442    public:
443 	typeID gentype;
444 	NormPtr parse (NormPtr);
445 };
446 
447 class arglist
448 {
449 	NormPtr argument (NormPtr);
450 	NormPtr parse_newstyle (NormPtr);
451 	bool old_declaration (NormPtr);
452 	NormPtr parse_oldstyle (NormPtr, bool = false);
453    public:
454 	bool nolist;
455 	typeID types [100];
456 	int names [100], ii;
457 	void parse_declare (NormPtr);
458 	NormPtr parse (NormPtr);
459 };
460 
461 class declaration
462 {
463    protected:
464 virtual	void semantics (NormPtr);
465 	NormPtr parse_initializer (NormPtr);
466    public:
467 	declarator D;
D(b)468 	declaration (bool b = false) : D (b) { }
469 	NormPtr parse (NormPtr);
470 };
471 
472 class declaration_instruct : public declaration
473 {
474 	void semantics (NormPtr);
475 };
476 //***********************************************************************
477 //		definitions:	cast, arglist
478 //***********************************************************************
479 
parse(NormPtr p)480 NormPtr cast_type::parse (NormPtr p)
481 {
482 	declarator B;
483 	p = B.parse_dcl (B.parse_base (p));
484 
485 	if (B.have_typedef || B.have_extern || B.have_static
486 	|| B.have_code || B.have_init || B.symbol != -1
487 	|| B.spec [0] == ':') syntax_error (p, "Improper cast");
488 
489 	gentype = B.gentype;
490 
491 	return p;
492 }
493 
argument(NormPtr p)494 NormPtr arglist::argument (NormPtr p)
495 {
496 	declarator B (true);
497 	p = B.parse_dcl (B.parse_base (p));
498 
499 	if (B.have_typedef || B.have_extern || B.have_static
500 	|| B.have_code || B.have_init || B.spec [0] == ':')
501 		syntax_error (p, "Crap argument");
502 
503 	names [ii] = B.symbol;
504 	types [ii++] = B.gentype;
505 
506 	return p;
507 }
508 
old_declaration(NormPtr p)509 bool arglist::old_declaration (NormPtr p)
510 {
511 	return ISSYMBOL (CODE [p])
512 	       && (CODE [p + 1] == ',' || CODE [p + 1] == ')')
513 	       && lookup_typedef (CODE [p]) == -1;
514 }
515 
parse_newstyle(NormPtr p)516 NormPtr arglist::parse_newstyle (NormPtr p)
517 {
518 	ii = 0;
519 
520 	if (CODE [p] == ')') {
521 		nolist = true;
522 		return p + 1;
523 	}
524 
525 	if (CODE [p] == RESERVED_void && CODE [p + 1] == ')')
526 		return p + 2;
527 
528 	while (1) {
529 		if (CODE [p] == ELLIPSIS) {
530 			types [ii++] = SPECIAL_ELLIPSIS;
531 			if (CODE [p + 1] != ')')
532 				syntax_error (p, "'...' must be last");
533 			return p + 2;
534 		}
535 		switch (CODE [p = argument (p)]) {
536 		default: syntax_error (p, "Invalid argument list");
537 		case ')': return p + 1;
538 		case ',': p++;
539 		}
540 	}
541 
542 	return p + 1;
543 }
544 
parse_oldstyle(NormPtr p,bool dcl)545 NormPtr arglist::parse_oldstyle (NormPtr p, bool dcl)
546 {
547 	// few syntax/semantics tests. We suppose old program, which
548 	// is syntactically correct for the last 10 years
549 	int i = 0, j;
550 	ii = 1;
551 	types [0] = ARGLIST_OPEN;
552 	types [1] = -1;
553 
554 	if (CODE [p] != ')')
555 		do names [i++] = CODE [p++]; while (CODE [p++] == ',');
556 
557 	if (dcl) {
558 		declaration D (true);
559 		while (CODE [p] != '{') {
560 			p = D.parse (p);
561 			for (j = 0; j < i; j++)
562 				if (names [j] == D.D.symbol) {
563 					names [j] = -1;
564 					break;
565 				}
566 		}
567 		for (j = 0; j < i; j++) if (names [j] != -1)
568 			introduce_obj (names [j], SIntType, DEFAULT);
569 	} else {
570 		if (!is_dcl_start (CODE [p])) return p;
571 		while (CODE [p] != '{') p++;
572 	}
573 	return p;
574 }
575 
parse_declare(NormPtr p)576 void arglist::parse_declare (NormPtr p)
577 {
578 	if (old_declaration (p)) {
579 		parse_oldstyle (p, true);
580 		return;
581 	}
582 
583 	int i;
584 	parse_newstyle (p);
585 
586 	for (i = 0; i < ii; i++)
587 		if (types [i] != SPECIAL_ELLIPSIS) {
588 			if (names [i] == -1)
589 				syntax_error (p, "Abstract argument");
590 			introduce_obj (names [i], types [i], DEFAULT);
591 		}
592 }
593 
parse(NormPtr p)594 NormPtr arglist::parse (NormPtr p)
595 {
596 	nolist = false;
597 	return old_declaration (p) ? parse_oldstyle (p) : parse_newstyle (p);
598 }
599 
arglist_to_specs()600 void declarator::arglist_to_specs ()
601 {
602 	arglist A;
603 	p = A.parse (p + 1);
604 	if (A.nolist) A.types [A.ii++] = ARGLIST_OPEN;
605 	A.types [A.ii] = -1;
606 	spec [dp++] = make_arglist (A.types);
607 }
608 
609 //***********************************************************************
610 //		definitions:	declaration, instructure
611 //***********************************************************************
612 
parse(NormPtr p)613 NormPtr declaration::parse (NormPtr p)
614 {
615 	VARSPC vs;
616 	bool ok;
617 	typeID t;
618 	NormPtr dclstart = p;	// to report beginning of function...
619 
620 	D.is_struct_dcl = false;
621 	p = D.parse_base (p);
622 	if (CODE [p] == ';') {
623 		if (D.is_struct_dcl && usage_only && report_structs && !D.is_anonymous) {
624 			D.is_struct_dcl = false;
625 			struct_location (D.basetype, D.psst, D.pslen);
626 		} else if (D.is_struct_dcl && D.is_anonymous)
627 			spill_anonymous (D.basetype);
628 	} else while (CODE [p] != ';') {
629 		p = D.parse_dcl (p);
630 
631 		semantics (p);
632 		t = D.gentype;
633 
634 		vs = (D.have_extern)?EXTERN:(D.have_static)?STATIC:DEFAULT;
635 
636 		if (D.have_typedef) ok = introduce_tdef (D.symbol, t);
637 		else ok = introduce_obj (D.symbol, t, vs);
638 		if (!ok) syntax_error (p, "redefined: ", expand (D.symbol));
639 
640 		if (D.is_anonymous) D.is_anonymous = !rename_struct (t, D.symbol);
641 
642 		if (D.is_struct_dcl && usage_only && report_structs) {
643 			D.is_struct_dcl = false;
644 			struct_location (D.basetype, D.psst, D.pslen);
645 		}
646 
647 		if (D.have_code) return parse_function (D.symbol, D.args, p, dclstart);
648 		if (D.have_init) p = parse_initializer (p + 1);
649 
650 		if (CODE [p] == ';') break;
651 		if (CODE [p] != ',') {
652 			if (CODE [p] != RESERVED___asm__)
653 			syntax_error(p, "unaccaptable declaration, separator;",
654 					 expand (CODE [p]));
655 			p = skip_parens (p + 1);
656 			continue;
657 		}
658 		p++;
659 	}
660 
661 	return p + 1;
662 }
663 
parse_initializer(NormPtr p)664 NormPtr declaration::parse_initializer (NormPtr p)
665 {
666 	if (CODE [p] != '{')
667 		return initializer_expr (D.symbol, p);
668 
669 #ifdef PARSE_ARRAY_INITIALIZERS
670 	return initializer_aggregate (D.symbol, p);
671 #else
672 	return base_of (D.gentype) < _BTLIMIT ?
673 		 skip_brackets (p) : initializer_aggregate (D.symbol, p);
674 #endif
675 }
676 
semantics(NormPtr p)677 void declaration::semantics (NormPtr p)
678 {
679 	if (D.spec [0] == ':'
680 	|| (D.have_typedef && (D.have_init || D.have_code)))
681 		syntax_error (p, "Not the \"right thing\"");
682 	if (D.symbol == -1) syntax_error (p, "ABSENT symbol");
683 	if (D.have_code && !INGLOBAL)
684 		syntax_error (p, "Do you like nested functions?");
685 }
686 
semantics(NormPtr p)687 void declaration_instruct::semantics (NormPtr p)
688 {
689 	if (D.have_static || D.have_extern || D.have_typedef
690 	|| D.spec [0] == '(' || D.have_init || D.have_code
691 	|| (D.symbol == -1 && D.spec [0] != ':'))
692 		syntax_error (p, "Not good dcl in struct");
693 }
694 
is_typename(int token)695 static bool is_typename (int token)
696 {
697 	return token == RESERVED_struct || token == RESERVED_union
698 		|| ISBASETYPE(token) || ISHBASETYPE (token)
699 		|| token == RESERVED_enum
700 		|| (ISSYMBOL (token) && is_typedef (token));
701 }
702 
is_dcl_start(int token)703 static bool is_dcl_start (int token)
704 {
705 	return ISDCLFLAG (token) || is_typename (token)
706 #ifdef GNU_VIOLATIONS
707 		|| token == RESERVED___label__
708 		|| token == RESERVED___typeof__
709 #endif
710 				;
711 }
712 
713 //**************************************************************************
714 //		Part II
715 //
716 //	By now we are ok with the declarations (introducing new names
717 //	to the program). Whenever we see a declaration, invoke a declarator.
718 //	We can at any time lookup what's an identifier, with lookup().
719 //
720 //	Missing:
721 //		parsing expressions in initializers
722 //
723 //	But this is ok, because this is exactly what we are going to
724 //	do now.
725 //**************************************************************************
726 //			C expressions
727 //**************************************************************************
728 NormPtr ExpressionPtr;
729 
730 static int bopid;
731 
priority(int op)732 static int priority (int op)
733 {
734 	if (op > 256) switch (op) {
735 		case LSH:	bopid = SHL;	return 11;
736 		case RSH:	bopid = SHR;	return 11;
737 		case GEQCMP:	bopid = CGRE;	return 10;
738 		case LEQCMP:	bopid = CLEE;	return 10;
739 		case EQCMP:	bopid = BEQ;	return 9;
740 		case NEQCMP:	bopid = BNEQ;	return 9;
741 		case ANDAND:	bopid = IAND;	return 5;
742 		case OROR:	bopid = IOR;	return 4;
743 		default:			return 0;
744 	}
745 	switch (op) {
746 		case '*':	bopid = MUL;	return 13;
747 		case '/':	bopid = DIV;	return 13;
748 		case '%':	bopid = REM;	return 13;
749 		case '+':	bopid = ADD;	return 12;
750 		case '-':	bopid = SUB;	return 12;
751 		case '>':	bopid = CGR;	return 10;
752 		case '<':	bopid = CLE;	return 10;
753 		case '&':	bopid = BAND;	return 8;
754 	}
755 	if (op == '^') {
756 		bopid = BXOR;
757 		return 7;
758 	}
759 	if (op != '|') return 0;
760 	bopid = BOR;
761 	return 6;
762 }
763 
xlate_uop(int op)764 static int xlate_uop (int op)
765 {
766 	switch (op) {
767 		case '!':	return LNEG;
768 		case '*':	return PTRIND;
769 		case '+':	return UPLUS;
770 		case '-':	return UMINUS;
771 		case '&':	return ADDROF;
772 	}
773 	switch (op) {
774 		case PLUSPLUS:		return PPPRE;
775 		case MINUSMINUS:	return MMPRE;
776 		default:		return OCPL;
777 	}
778 }
779 
780 subexpr *&ee = CExpr.ee;
781 int &NeTop = CExpr.ne;
782 
783 class expression_parser
784 {
785 inline	void reloc ();
786 	void value_to_expression (exprID, Symbol);
787 #ifdef GNU_VIOLATIONS
788 	exprID gnu_st_expr ();
789 	exprID gnu_ctor_expr (typeID);
790 #endif
791 #ifdef LABEL_VALUES
792 	exprID gnu_label_value ();
793 #endif
794 	exprID sizeof_typename ();
795 	exprID unary_expression ();
796 	exprID argument_expression_list ();
797 	exprID primary_expression ();
798 	exprID prefix_expression ();
799 	exprID binary_expression (exprID, int);
800 	exprID logicalOR_expression ();
801 
802 	int nee, extra;
803     public:
804 	expression_parser (NormPtr, subexpr*);
805 
806 	exprID postfix_expression ();
807 	exprID assignment_expression ();
808 	exprID conditional_expression ();
809 	exprID expression ();
810 
811 	NormPtr EP;
812 	subexpr *ee;
813 	int iee;
814 	~expression_parser ();
815 };
816 
817 //***********************************************************************
818 //		definitions
819 //***********************************************************************
820 
sizeof_typename()821 exprID expression_parser::sizeof_typename ()
822 {
823 	cast_type T;
824 	EP = T.parse (EP + 2);
825 	if (CODE [EP++] != ')') syntax_error (EP, "erroneous sizeof");
826 	ee [iee].action = VALUE;
827 	exprID c = sizeof_typeID (T.gentype);
828 	ee [iee].voici.value = c;
829 	return iee++;
830 }
831 
832 #define ISUNARY(x) \
833 	((x<'~') ? (x=='!'||x=='*'||x=='&'||x=='-'||x=='+')\
834 	: (x==PLUSPLUS || x==MINUSMINUS || x=='~'))
835 
unary_expression()836 exprID expression_parser::unary_expression ()
837 {
838 	int prefix [40];
839 	typeID casts [40];
840 	int ipr = 0, t;
841 	exprID e = -1;
842 
843 	for (t = CODE [EP]; t < STRINGBASE; t = CODE [++EP])
844 		if (ISUNARY (t)) prefix [ipr++] = xlate_uop (t);
845 		else if (t == '(')
846 			if (is_dcl_start (CODE [EP + 1])) {
847 				cast_type C;
848 				EP = C.parse (EP + 1);
849 				casts [ipr] = C.gentype;
850 				prefix [ipr++] = CAST;
851 #ifdef GNU_VIOLATIONS
852 				if (CODE [EP + 1] == '{') {
853 					e = gnu_ctor_expr (C.gentype);
854 					goto have_unary;
855 				}
856 #endif
857 			} else break;
858 		else if (t == RESERVED_sizeof)
859 			if (CODE [EP+1] == '(' && is_dcl_start (CODE [EP+2])) {
860 				e = sizeof_typename ();
861 				goto have_unary;
862 			} else prefix [ipr++] = SIZEOF;
863 #ifdef LABEL_VALUES
864 		else if (t == ANDAND) {
865 			e = gnu_label_value ();
866 			goto have_unary;
867 		}
868 #endif
869 		else break;
870 
871 	if ((e = postfix_expression ()) == -1 && ipr > 0)
872 		syntax_error (EP, "prefix operator w/o operand");
873 
874 have_unary:
875 	reloc (); /* * */
876 	while (ipr--) {
877 		ee [iee].voici.e = e;
878 		if ((ee [iee].action = prefix [ipr]) == CAST)
879 			ee [iee].voila.cast = casts [ipr];
880 		e = iee++;
881 	}
882 
883 	return e;
884 }
885 
primary_expression()886 exprID expression_parser::primary_expression ()
887 {
888 	int t = CODE [EP++];
889 
890 	if (ISSYMBOL (t)) {
891 		ee [iee].action = SYMBOL;
892 		ee [iee].voici.symbol = t;
893 		return iee++;
894 	}
895 
896 	if (ISNUMBER (t) || ISSTRING (t)) {
897 		value_to_expression (iee, t);
898 		return iee++;
899 	}
900 
901 	if (t != '(') {
902 		EP--;
903 		return -1;
904 	}
905 
906 	exprID e;
907 #ifdef GNU_VIOLATIONS
908 	if (CODE [EP] == '{') e = gnu_st_expr (); else
909 #endif
910 	e = expression ();
911 	if (CODE [EP++] != ')')
912 		syntax_error (EP, "parse error");
913 	return e;
914 }
915 
postfix_expression()916 exprID expression_parser::postfix_expression ()
917 {
918 	exprID e = primary_expression (), c;
919 	if (e == -1) return -1;
920 
921 	int t;
922 	for (t = CODE [EP];; t = CODE [++EP]) {
923 		ee [iee].voici.e = e;
924 
925 		switch (t) {
926 		case PLUSPLUS:
927 			ee [e = iee++].action = PPPOST; break;
928 		case MINUSMINUS:
929 			ee [e = iee++].action = MMPOST; break;
930 		case '[':
931 			EP++;
932 			ee [e = iee++].action = ARRAY;
933 			c = expression ();
934 			ee [e].e = c;
935 			if (CODE [EP] != ']')
936 				syntax_error (EP, "missing ']'");
937 			break;
938 		case '(':
939 			EP++;
940 			ee [e = iee++].action = FCALL;
941 			c = argument_expression_list ();
942 			ee [e].e = c;
943 			if (CODE [EP] != ')')
944 				syntax_error (EP, "missing ')'");
945 			break;
946 		case POINTSAT:
947 			ee [e = iee++].action = PTRIND;
948 			ee [iee].voici.e = e;
949 		case '.':
950 			ee [e = iee++].action = MEMB;
951 			ee [e].voila.member = CODE [++EP];
952 			if (!ISSYMBOL (ee [e].voila.member))
953 				syntax_error (EP, "->members only");
954 			break;
955 		default:
956 			return e;
957 		}
958 	}
959 }
960 
binary_expression(exprID lop,int pri)961 exprID expression_parser::binary_expression (exprID lop, int pri)
962 {
963 static	int p2;
964 	int coperator = bopid;
965 	exprID e;
966 	EP++;
967 	if ((e = unary_expression ()) == -1)
968 		syntax_error (EP, "two operands expected");
969 
970 	p2 = priority (CODE [EP]);
971 	while (p2 > pri)
972 		e = binary_expression (e, p2);
973 
974 	ee [iee].voici.e = lop;
975 	ee [iee].action = coperator;
976 	ee [iee].e = e;
977 	e = iee++;
978 
979 	return (p2 < pri) ? e : binary_expression (e, pri);
980 }
981 
logicalOR_expression()982 exprID expression_parser::logicalOR_expression ()
983 {
984 	int p;
985 	exprID e = unary_expression ();
986 	if (e == -1) return -1;
987 
988 	while ((p = priority (CODE [EP])))
989 		e = binary_expression (e, p);
990 
991 	return e;
992 }
993 
conditional_expression()994 exprID expression_parser::conditional_expression ()
995 {
996 	exprID e = logicalOR_expression (), c;
997 	if (e == -1) return -1;
998 
999 	if (CODE [EP] == '?') {
1000 		ee [iee].voici.e = e;
1001 		ee [e = iee++].action = COND;
1002 		EP++;
1003 		c = expression ();
1004 		ee [e].e = c;
1005 		if (CODE [EP++] != ':')
1006 			syntax_error (EP, "(what) ? is ':' missing");
1007 		if ((c = conditional_expression ()) == -1)
1008 			syntax_error (EP, "(what) ? is : missing");
1009 		ee [e].voila.eelse = c;
1010 	}
1011 
1012 	return e;
1013 }
1014 
assignment_expression()1015 exprID expression_parser::assignment_expression ()
1016 {
1017 	exprID e = conditional_expression (), c;
1018 	if (e == -1) return -1;
1019 
1020 	if (!ISASSIGNMENT (CODE [EP])) return e;
1021 
1022 	ee [iee].voici.e = e;
1023 	ee [e = iee++].action = CODE [EP++];
1024 	if ((c = assignment_expression ()) == -1)
1025 		syntax_error (EP, " = (missing operand)");
1026 	ee [e].e = c;
1027 
1028 	return e;
1029 }
1030 
expression()1031 exprID expression_parser::expression ()
1032 {
1033 	exprID e = assignment_expression (), c;
1034 	if (e == -1) return -1;
1035 
1036 	if (CODE [EP] == ',') {
1037 		++EP;
1038 		ee [iee].voici.e = e;
1039 		ee [e = iee++].action = COMMA;
1040 		c = expression ();
1041 		ee [e].e = c;
1042 	}
1043 
1044 	return e;
1045 }
1046 
argument_expression_list()1047 exprID expression_parser::argument_expression_list ()
1048 {
1049 	exprID e = assignment_expression (), c;
1050 	if (e == -1) return -1;
1051 
1052 	if (CODE [EP] == ',') {
1053 		++EP;
1054 		ee [iee].voici.e = e;
1055 		ee [e = iee++].action = ARGCOMMA;
1056 		c = argument_expression_list ();
1057 		ee [e].e = c;
1058 	}
1059 
1060 	return e;
1061 }
1062 
expression_parser(NormPtr p,subexpr * tee)1063 expression_parser::expression_parser (NormPtr p, subexpr *tee)
1064 {
1065 #define STDNEE 138
1066 	ExpressionPtr = EP = p;
1067 	nee = STDNEE;
1068 	extra = false;
1069 	ee = tee;
1070 	iee = 0;
1071 }
1072 
reloc()1073 void expression_parser::reloc ()
1074 {
1075 #define RELOCAT 10
1076 	if (nee - iee < RELOCAT) {
1077 		subexpr *bigger = new subexpr [nee += 32];
1078 		memcpy (bigger, ee, iee * sizeof ee [0]);
1079 		if (extra) delete [] ee;
1080 		ee = bigger;
1081 		extra = true;
1082 	}
1083 }
1084 
~expression_parser()1085 expression_parser::~expression_parser ()
1086 {
1087 	if (extra) delete [] ee;
1088 }
1089 //***********************************************************************
1090 //		definitions
1091 //***********************************************************************
1092 
value_to_expression(exprID i,Symbol s)1093 void expression_parser::value_to_expression (exprID i, Symbol s)
1094 {
1095 	if (ISSTRING (s)) {
1096 		ee [i].action = SVALUE;
1097 		ee [i].voici.value = s - STRINGBASE;
1098 		return;
1099 	}
1100 
1101 	if (s >= INUMBER) {
1102 		ee [i].action = UVALUE;
1103 		ee [i].voici.uvalue = s - INUMBER;
1104 		return;
1105 	}
1106 
1107 	if (s >= FLOATBASE) {
1108 		ee [i].action = FVALUE;
1109 		ee [i].voici.fvalue = C_Floats [s - FLOATBASE];
1110 		return;
1111 	}
1112 
1113 	if (s >= UINT32BASE) {
1114 		ee [i].action = UVALUE;
1115 		ee [i].voici.uvalue = C_Unsigned [s - UINT32BASE];
1116 		return;
1117 	}
1118 
1119 	ee [i].action = VALUE;
1120 	ee [i].voici.value = getint (s);
1121 }
1122 
parse_expression(NormPtr p)1123 static NormPtr parse_expression (NormPtr p)
1124 {
1125 	subexpr tee [STDNEE];
1126 	expression_parser PP (p, tee);
1127 
1128 	CExpr.first = PP.expression ();
1129 	CExpr.ee = PP.ee;
1130 	CExpr.ne = PP.iee;
1131 	if (!usage_only) prcode (p, PP.EP - p);
1132 	ncc->cc_expression ();
1133 	return PP.EP;
1134 }
1135 
constant_int_expression(NormPtr p,int & r)1136 static NormPtr constant_int_expression (NormPtr p, int &r)
1137 {
1138 	if (ISNUMBER (CODE [p]) && CODE [p] < UINT32BASE
1139 	&& !priority (CODE [p + 1])) {
1140 		r = getint (CODE [p]);
1141 		return p + 1;
1142 	}
1143 
1144 	subexpr tee [STDNEE];
1145 	expression_parser PP (p, tee);
1146 
1147 	CExpr.first = PP.conditional_expression ();
1148 	CExpr.ee = PP.ee;
1149 	CExpr.ne = PP.iee;
1150 	r = cc_int_expression ();
1151 	return PP.EP;
1152 }
1153 
1154 //**************************************************************************
1155 //
1156 //	Some GNU Violations we don't like
1157 //
1158 //**************************************************************************
1159 #ifdef GNU_VIOLATIONS
1160 static NormPtr compound_statement (NormPtr p);
gnu_st_expr()1161 exprID expression_parser::gnu_st_expr ()
1162 {
1163 	EP = compound_statement (EP + 1);
1164 	ee [iee].action = COMPOUND_RESULT;
1165 	ee [iee].voici.using_result = last_result;
1166 	ee [iee].voila.result_type = gettype (last_result_type.base,
1167 					      last_result_type.spec);
1168 	return iee++;
1169 }
1170 
1171 static NormPtr initializer_aggregate (Symbol, NormPtr);
1172 
gnu_ctor_expr(typeID c)1173 exprID expression_parser::gnu_ctor_expr (typeID c)
1174 {
1175 	open_compound ();
1176 	introduce_obj (intern_sym, c, DEFAULT);
1177 	EP = initializer_aggregate (intern_sym, EP + 1);
1178 	//EP = skip_brackets (EP + 1);
1179 	close_region ();
1180 	ee [iee].action = VALUE;
1181 	return iee++;
1182 }
1183 
bt_typeof(NormPtr p)1184 NormPtr declarator::bt_typeof (NormPtr p)
1185 {
1186 	if (CODE [p++] != '(') syntax_error (p, "typeof '('");
1187 	if (is_dcl_start (CODE [p])) {
1188 		cast_type C;
1189 		p = C.parse (p);
1190 		basetype = C.gentype + TYPEDEF_BASE;
1191 	} else {
1192 		subexpr tee [STDNEE];
1193 		expression_parser PP (p, tee);
1194 		CExpr.first = PP.expression ();
1195 		CExpr.ee = PP.ee;
1196 		CExpr.ne = PP.iee;
1197 		basetype = typeof_expression ();
1198 		p = PP.EP;
1199 	}
1200 	if (CODE [p] != ')') syntax_error (p, "typeof ')'");
1201 	return p + 1;
1202 }
1203 #endif
1204 
1205 #ifdef LABEL_VALUES
gnu_label_value()1206 exprID expression_parser::gnu_label_value ()
1207 {
1208 	int s = CODE [++EP];
1209 	if (!ISSYMBOL (s)) syntax_error (EP, "&&identifier only, for labels");
1210 	ee [iee].action = AVALUE;
1211 	ee [iee].voici.symbol = s;
1212 	EP++;
1213 	return iee++;
1214 }
1215 #endif
1216 //**************************************************************************
1217 //		Part III
1218 //
1219 //	statements, this is really easy
1220 //**************************************************************************
1221 
1222 static int IDLEV = -1;
1223 #define PCMD(CMD) \
1224 	if (pseudo_code) {\
1225 		PRINTF ("#X: %s\n", CMD);\
1226 	}
PINDENTPINDENT1227 struct PINDENT { PINDENT () { IDLEV += 1; } ~PINDENT () { PCMD ("*"); IDLEV -= 1; } };
1228 #define PSEUDOCODE(CMD) PINDENT P; PCMD(CMD);
1229 
1230 static NormPtr while_statement (NormPtr p);
1231 static NormPtr for_statement (NormPtr p);
1232 static NormPtr do_statement (NormPtr p);
1233 static NormPtr switch_statement (NormPtr p);
1234 static NormPtr if_statement (NormPtr p);
1235 static NormPtr compound_statement (NormPtr p);
1236 static NormPtr __asm___statement (NormPtr p);
1237 
statement(NormPtr p)1238 static NormPtr statement (NormPtr p)
1239 {
1240 	int t = CODE [p++];
1241 
1242 	if (ISSYMBOL (t) && CODE [p] == ':')
1243 		return CODE [p + 1] == '}' ? p + 1 : statement (p + 1);
1244 
1245 	switch (t) {
1246 	case RESERVED_default:
1247 		if (CODE [p] != ':') syntax_error (p, "default:");
1248 		return p + 1;
1249 	case RESERVED_case:
1250 		int tmp;
1251 		p = constant_int_expression (p, tmp);
1252 		if (CODE [p] == ELLIPSIS) p = constant_int_expression (p + 1, tmp);
1253 		if (CODE [p] != ':') syntax_error (p, "case ERROR:");
1254 		return p + 1;
1255 	case RESERVED_continue:
1256 	case RESERVED_break:
1257 		if (CODE [p] != ';') syntax_error (p, "break | continue ';'");
1258 		return p + 1;
1259 	case RESERVED_goto:
1260 		if (ISSYMBOL (CODE [p]) && CODE [p + 1] == ';')
1261 			return p + 2;
1262 	case RESERVED_return:
1263 		p = parse_expression (p);
1264 		if (CODE [p] != ';') syntax_error (p, "return ... ';'");
1265 		return p + 1;
1266 	case RESERVED_while:	return while_statement (p);
1267 	case RESERVED_for:	return for_statement (p);
1268 	case RESERVED_do:	return do_statement (p);
1269 	case RESERVED_switch:	return switch_statement (p);
1270 	case RESERVED_if:	return if_statement (p);
1271 	case RESERVED___asm__:	return __asm___statement (p);
1272 	case RESERVED_else:	syntax_error (p, "else without if");
1273 	case '{':		return compound_statement (p);
1274 	default:
1275 		p = parse_expression (p - 1);
1276 		if (CODE [p++] != ';')
1277 			syntax_error (p, "expression + ';' = statement");
1278 	case ';':
1279 		return p;
1280 	}
1281 }
1282 
parenth_expression(NormPtr p)1283 static NormPtr parenth_expression (NormPtr p)
1284 {
1285 	if (CODE [p++] != '(')
1286 		syntax_error (p, "'(' expression");
1287 	p = parse_expression (p);
1288 	if (CODE [p++] != ')')
1289 		syntax_error (p, "expression ')'");
1290 	return p;
1291 }
1292 
while_statement(NormPtr p)1293 static NormPtr while_statement (NormPtr p)
1294 {
1295 	PSEUDOCODE ("REPEAT");
1296 	return statement (parenth_expression (p));
1297 }
1298 
do_statement(NormPtr p)1299 static NormPtr do_statement (NormPtr p)
1300 {
1301 	PSEUDOCODE ("REPEAT");
1302 	p = statement (p);
1303 	if (CODE [p++] != RESERVED_while)
1304 		syntax_error (p, "do w/o while");
1305 	p = parenth_expression (p);
1306 	if (CODE [p++] != ';')
1307 		syntax_error (p, "This is special, but you need a ';'");
1308 	return p;
1309 }
1310 
for_statement(NormPtr p)1311 static NormPtr for_statement (NormPtr p)
1312 {
1313 	if (CODE [p++] != '(')
1314 		syntax_error (p, "for '('...");
1315 	p = parse_expression (p);
1316 	PSEUDOCODE ("REPEAT");
1317 	if (CODE [p++] != ';')
1318 		syntax_error (p, "for (expression ';' ...");
1319 	p = parse_expression (p);
1320 	if (CODE [p++] != ';')
1321 		syntax_error (p, "for (expression; expression ';' ...");
1322 	p = parse_expression (p);
1323 	if (CODE [p++] != ')')
1324 		syntax_error (p, "for (;; ')'");
1325 	return statement (p);
1326 }
1327 
switch_statement(NormPtr p)1328 static NormPtr switch_statement (NormPtr p)
1329 {
1330 	p = parenth_expression (p);
1331 	return statement (p);
1332 }
1333 
if_statement(NormPtr p)1334 static NormPtr if_statement (NormPtr p)
1335 {
1336 	{
1337 		PSEUDOCODE ("IF");
1338 		p = statement (parenth_expression (p));
1339 	}
1340 	if (CODE [p] == RESERVED_else) {
1341 		PSEUDOCODE ("ELSE");
1342 		return statement (p + 1);
1343 	}
1344 	return p;
1345 }
1346 
parse_declaration(NormPtr p)1347 static NormPtr parse_declaration (NormPtr p)
1348 {
1349 	declaration D;
1350 	return D.parse (p);
1351 }
1352 
compound_statement(NormPtr p)1353 static NormPtr compound_statement (NormPtr p)
1354 {
1355 	open_compound ();
1356 
1357 #ifdef NCC_ISOC99
1358 	while (CODE [p] != '}')
1359 		p = (is_dcl_start (CODE [p]) && CODE [p + 1] != ':') ?
1360 		parse_declaration (p) : statement (p);
1361 #else
1362 	while (CODE [p] != '}')
1363 		if (is_dcl_start (CODE [p]))
1364 			p = parse_declaration (p);
1365 		else break;
1366 
1367 	while (CODE [p] != '}')
1368 		p = statement (p);
1369 #endif
1370 
1371 	close_region ();
1372 	return p + 1;
1373 }
1374 
__asm___statement(NormPtr p)1375 static NormPtr __asm___statement (NormPtr p)
1376 {
1377 	NormPtr ast = p + 1;
1378 	if (CODE [p] != '(') syntax_error (p, "__asm__ '('");
1379 	p = skip_parens (p);
1380 	if (CODE [p++] != ';') syntax_error (p, "asm() ';'");
1381 	ncc->inline_assembly (ast, p - ast - 1);
1382 #ifdef	GNU_VIOLATIONS
1383 	last_result_type.base = VOID;
1384 	last_result_type.spec [0] = -1;
1385 #endif
1386 	++last_result;
1387 	return p;
1388 }
1389 
1390 //***********************************************************************
1391 //
1392 //		Part IV - the rest
1393 //
1394 //***********************************************************************
1395 
1396 //***********************************************************************
1397 //
1398 //	Aggregate initializers:
1399 //	The goal is to: a) Catch functions assigned to structure
1400 //	members, and b) Catch function calls in initializers.
1401 //
1402 //***********************************************************************
1403 
join_expression(dcle & E,NormPtr p)1404 static inline NormPtr join_expression (dcle &E, NormPtr p)
1405 {
1406 #if 0
1407 	if (ISNUMBER (CODE [p]) || ISSTRING (CODE [p]))
1408 	if (CODE [p + 1] == ',' || CODE [p + 1] == '}') {
1409 		// skip these quickly (may be lots of them)
1410 		E.tofield ();
1411 		return p + 1;
1412 	}
1413 #endif
1414 	NormPtr pe, cntk;
1415 	subexpr tee [STDNEE];
1416 	expression_parser EEP (p, tee);
1417 	exprID e;
1418 	typeID t;
1419 	Symbol *se, *tmp;
1420 	// root subexpression manually constructed
1421 	tee [0].action = '=';
1422 	EEP.iee = 1;
1423 	// right part of the assignment is in CODE[]
1424 	// and is assignment expression
1425 	if ((e = EEP.assignment_expression ()) == -1)
1426 		syntax_error (p, "wrong in here");
1427 	pe = EEP.EP;
1428 	EEP.ee [0].e = e;
1429 	// check to see if the type of the assignment is
1430 	// a structure
1431 	CExpr.first = e;
1432 	CExpr.ee = EEP.ee;
1433 	CExpr.ne = EEP.iee;
1434 	t = typeof_expression () - TYPEDEF_BASE;
1435 	// ..and advance E accordingly
1436 	if (spec_of (t)[0] == -1 && base_of (t) > _BTLIMIT)
1437 		E.tostruct (base_of (t));
1438 	else E.tofield ();
1439 	// skip these quickly (calculated constant exprs)
1440 #if 0
1441 	if (EEP.ee [e].action <= FVALUE)
1442 		return pe;
1443 #endif
1444 	// left part of the assignment is made in
1445 	// E.mk_current and is a postfix expression
1446 	tmp = E.mk_current ();
1447 	if (0||!usage_only) prcode (p, EEP.EP - p, tmp);
1448 	cntk = C_Ntok;
1449 	se = CODE;
1450 	CODE = tmp;
1451 	for (C_Ntok = 0; CODE [C_Ntok] != -1; C_Ntok++);
1452 	EEP.EP = 0;
1453 	e = EEP.postfix_expression ();
1454 	EEP.ee [0].voici.e = e;
1455 	CODE = se;
1456 	C_Ntok = cntk;
1457 	// these two joined at tee[0] which is an
1458 	// assignment.  Now send to compiler
1459 	CExpr.first = 0;
1460 	CExpr.ee = EEP.ee;
1461 	CExpr.ne = EEP.iee;
1462 	ncc->cc_expression ();
1463 	return pe;
1464 }
1465 
1466 
initializer_aggregate(Symbol s,NormPtr p)1467 static NormPtr initializer_aggregate (Symbol s, NormPtr p)
1468 {
1469 	// aggregates can be very complex. if something bad happens, skip analysis
1470 	NormPtr p0 = p;
1471 	dcle E (s);
1472 	for (;;) {
1473 		for (;;)
1474 		if (CODE [p] == '{') {
1475 			p++;
1476 			if (!E.open_bracket ()) goto Bad;
1477 		} else if (ISSYMBOL (CODE [p]) && CODE [p + 1] == ':') {
1478 			Symbol d [2] = { CODE [p], -1 };
1479 			if (!E.designator (d)) goto Bad;
1480 			if (CODE [p += 2] != '{') break;
1481 		} else if (CODE [p] == '.' || CODE [p] == '[') {
1482 			Symbol d [20];
1483 			int di = 0;
1484 			while (CODE [p] == '.' || CODE [p] == '[')
1485 				if (CODE [p++] == '.')
1486 					d [di++] = CODE [p++];
1487 				else {
1488 					p = constant_int_expression (p, d [di]);
1489 					if (CODE [p++] == ELLIPSIS)
1490 						p = constant_int_expression (p, d [di]) + 1;
1491 					if (d [di] < 0) d [di] = -1;
1492 					d [di++] += INUMBER;
1493 				}
1494 			if (CODE [p] == '=') p++;
1495 			d [di] = -1;
1496 			if (!E.designator (d)) goto Bad;
1497 			if (CODE [p] != '{') break;
1498 		} else break;
1499 
1500 		if (CODE [p] != ',' && CODE [p] != '}')
1501 			p = join_expression (E, p);
1502 
1503 		for (;;)
1504 		if (CODE [p] == '}') {
1505 			p++;
1506 			if (!E.close_bracket ()) return p; //*/*/*/*/*/*/*> OUT
1507 		} else if (CODE [p] == ',') {
1508 			if (CODE [++p] == '}') continue;
1509 			if (!E.comma ()) syntax_error (p, "excess");
1510 		} else break;
1511 	}
1512 Bad:
1513 	return skip_brackets (p0);
1514 }
1515 
1516 //******** end aggregate initializers
1517 
initializer_expr(Symbol s,NormPtr p)1518 static NormPtr initializer_expr (Symbol s, NormPtr p)
1519 {
1520 //	if (ISSTRING (CODE [p])) {
1521 //		return p + 1;
1522 //	}
1523 
1524 	subexpr tee [STDNEE];
1525 	tee [0].action = '=';
1526 	tee [0].voici.e = 1;
1527 	tee [1].action = SYMBOL;
1528 	tee [1].voici.symbol = s;
1529 	expression_parser EEP (p, tee);
1530 	EEP.iee = 2;
1531 	exprID e;
1532 
1533 	if ((e = EEP.assignment_expression ()) == -1)
1534 		syntax_error (p, "erroneous initialization");
1535 	EEP.ee [0].e = e;
1536 
1537 	CExpr.first = 0;
1538 	CExpr.ee = EEP.ee;
1539 	CExpr.ne = EEP.iee;
1540 	if (!usage_only) prcode (p, EEP.EP - p, s);
1541 	ncc->cc_expression ();
1542 	return EEP.EP;
1543 }
1544 
parse_structure(NormPtr p)1545 static NormPtr parse_structure (NormPtr p)
1546 {
1547 	declaration_instruct D;
1548 	while (CODE [p] != '}' && p < C_Ntok)
1549 		p = D.parse (p);
1550 	close_region ();
1551 	return p + 1;
1552 }
1553 
parse_function(Symbol s,NormPtr a,NormPtr p,NormPtr b)1554 static NormPtr parse_function (Symbol s, NormPtr a, NormPtr p, NormPtr b)
1555 {
1556 	NormPtr e = skip_brackets (p);
1557 	if (!function_definition (s, a, p, e, b+1))
1558 		//syntax_error (p, "Function definition already defined", expand (s));
1559 		;
1560 	return e;
1561 }
1562 
do_functions()1563 void do_functions ()
1564 {
1565 	int i;
1566 	NormPtr args, body;
1567 
1568 	infuncs = true;
1569 	for (i = 0; function_no (i, &args, &body); i++) {
1570 		PSEUDOCODE("PCODE.0");
1571 		arglist A;
1572 		A.parse_declare (args + 1);
1573 		compound_statement (body + 1);
1574 		close_region ();
1575 	}
1576 }
1577 
1578 //
1579 // Well, that's it.
1580 //
parse_translation_unit()1581 void parse_translation_unit ()
1582 {
1583 	NormPtr p = 0;
1584 	declaration D;
1585 
1586 	while (p < C_Ntok)
1587 		if (CODE [p] == ';') p++;
1588 		else if (CODE [p] == RESERVED___asm__) p = skip_parens (p + 1);
1589 		else p = D.parse (p);
1590 
1591 	do_functions ();
1592 }
1593 
parse_C()1594 void parse_C ()
1595 {
1596 	parse_translation_unit ();
1597 }
1598