![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cfront.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / cfront / ocfront|
Return to cfront.h CVS log | Up to [Research Unix] / researchv10no / cmd / cfront / ocfront |
1.1 root 1: /*ident "@(#)ctrans:src/cfront.h 1.2.5.35" */
2: /***********************************************************************
3:
4: C++ source for cfront, the C++ compiler front-end
5: written in the computer science research center of Bell Labs
6:
7: Copyright (c) 1984 AT&T, Inc. All rigths Reserved
8: THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T, INC.
9:
10: When reading cfront code please remember that C++ was not available
11: when it was originally written. Out of necessity cfront is written
12: in a style that takes advantage of only few of C++'s features.
13:
14: cfront.h:
15:
16: Here is all the class definitions for cfront, and most of the externs
17:
18: ***********************************************************************/
19:
20: /* WARNING:
21: This program relies on non-initialized class members being ZERO.
22: This will be true as long as they are allocated using the "new" operator
23: from alloc.c
24: */
25:
26: #include "token.h"
27: #include "typedef.h"
28:
29: #ifndef GRAM
30: extern char* prog_name; // compiler name and version
31: extern int inline_restr; // inline expansion restrictions
32: #endif
33:
34: extern Pname name_free; // free lists
35: extern Pexpr expr_free;
36: extern Pstmt stmt_free;
37:
38: /* "spy" counters: */
39: //extern int Nspy;
40: //extern int Nline, Ntoken, Nname, Nfree_store, Nalloc, Nfree;
41: //extern int Nn, Nbt, Nt, Ne, Ns, Nstr, Nc, Nl;
42: //extern int NFn, NFtn, NFpv, NFbt, NFf, NFs, NFc, NFe, NFl;
43:
44: ///extern TOK lex();
45: extern TOK tlex();
46: extern Pname syn();
47:
48: extern void ext(int);
49:
50: extern char* make_name(TOK);
51: extern void make_dummy();
52: extern Pname dummy_fct;
53: extern Pname really_dominate(Pname, Pname, bit);
54: extern int exact1(Pname, Ptype);
55:
56: extern int friend_check(Pclass start,Pclass stop, Pfct f);
57:
58: struct loc // a source file location
59: {
60: short file; // index into file_name[], or zero
61: short line;
62: #ifndef GRAM
63: void put(FILE*);
64: void putline();
65: #endif
66: };
67:
68: extern Loc curloc;
69: extern int curr_file;
70: extern char* src_file_name;
71: extern loc noloc; // dummy null location
72: extern bit binary_val;
73: extern bit stmtno;
74:
75: struct ea { // fudge portable printf-like formatting for error()
76: union {
77: void* p;
78: long i;
79: };
80:
81: ea(const void* pp) { p = pp; }
82: ea(long ii) { i = ii; }
83: ea() {}
84: };
85:
86: extern ea* ea0;
87:
88: overload error;
89: int error(const char*);
90: int error(const char*, const ea&, const ea& = *ea0, const ea& = *ea0, const ea& = *ea0);
91: int error(int, const char*);
92: int error(int, const char*, const ea&, const ea& = *ea0, const ea& = *ea0, const ea& = *ea0);
93: int error(loc*, const char*, const ea& = *ea0, const ea& = *ea0, const ea& = *ea0, const ea& = *ea0);
94: int error(int, loc*, const char*, const ea& = *ea0, const ea& = *ea0, const ea& = *ea0, const ea& = *ea0);
95: extern char emode;
96:
97: extern int error_count;
98: extern int vtbl_opt;
99: extern int debug_opt;
100: extern int warning_opt;
101: extern int ansi_opt;
102: extern int strict_opt;
103: extern FILE* out_file;
104: extern FILE* in_file;
105: extern char scan_started;
106:
107: extern int bl_level;
108: extern Ptable ktbl; // keywords and typedef names
109: extern Ptable gtbl; // global names
110: extern Ptable ptbl;
111: extern Ptable lcl_tbl;
112: extern char* oper_name(TOK);
113: extern Pname def_name;
114: extern Pname pdef_name;
115: extern Pclass ccl;
116: extern Pbase defa_type;
117: extern Pbase moe_type;
118: extern Pbase mptr_type;
119:
120: #ifndef GRAM
121: extern Pstmt Cstmt; // current statement, or 0
122: extern Pname Cdcl; // name currently being declared, or 0
123:
124: extern Pbase any_type;
125: extern int largest_int;
126: #endif
127:
128: extern Pbase int_type;
129: extern Pbase char_type;
130: extern Pbase short_type;
131: extern Pbase long_type;
132: extern Pbase uint_type;
133: extern Pbase float_type;
134: extern Pbase double_type;
135: extern Pbase ldouble_type;
136: extern Pbase void_type;
137:
138: #ifndef GRAM
139: extern Pbase uchar_type;
140: extern Pbase ushort_type;
141: extern Pbase ulong_type;
142: extern Ptype Pchar_type;
143: extern Ptype Pint_type;
144: extern Ptype Pvptr_type;
145: extern Ptype Pfctvec_type;
146: extern Ptype Pvoid_type;
147: extern Pbase zero_type;
148: extern Ptype size_t_type;
149:
150: extern int byte_offset;
151: extern int bit_offset;
152: extern int max_align;
153: extern int const_save;
154: extern int const_ptr;
155: extern int cm_const_save;
156: extern bit const_problem;
157: #endif
158:
159: extern Pexpr dummy; /* the empty expression */
160: extern Pexpr zero;
161: extern Pexpr one;
162: extern Pname sta_name; /* qualifier for unary :: */
163:
164: #define DEL(p) if (p && (p->permanent==0)) p->del()
165: #define PERM(p) p->permanent=1
166: #define UNPERM(p) p->permanent=0
167:
168: struct node {
169: TOK base;
170: bit permanent;
171: #ifdef DBG
172: bit displayed; // avoid invinite recursion in display functions
173: bit allocated; // set when not on free list
174: long id;
175: #endif
176: };
177: #ifdef DBG
178: extern long node_id;
179: extern int Adebug;
180: #define DBID() { node::id = ++::node_id; node::allocated=1; displayed=0; \
181: if(Adebug>=1)fprintf(stderr,"\n*** allocated %d base %d\n",id,base); }
182: #else
183: #define DBID() /**/
184: #endif
185:
186: struct table : node {
187: /* a table is a node only to give it a "base" for debugging */
188: bit init_stat; /* ==0 if block(s) of table not simplified,
189: ==1 if simplified but had no initializers,
190: ==2 if simplified and had initializers.
191: */
192: short size;
193: short hashsize;
194: short free_slot; /* next free slot in entries */
195: Pname* entries;
196: short* hashtbl;
197: Pstmt real_block; /* the last block the user wrote,
198: not one of the ones cfront created
199: */
200: Ptable next; /* table for enclosing scope */
201: Pname t_name; /* name of the table */
202:
203: table(short, Ptable, Pname);
204:
205: Pname look(char*, TOK);
206: Pname insert(Pname, TOK);
207: #ifndef GRAM
208: void grow(int);
209: void set_name(Pname n) { t_name = n; };
210: Pname get_mem(int);
211: int max() { return free_slot-1; };
212: void dcl_print(TOK,TOK);
213: void del();
214: #endif
215: };
216:
217: #ifndef GRAM
218: extern bit Nold;
219: extern bit vec_const, fct_const;
220: #endif
221:
222: extern void restore();
223: extern void set_scope(Pname);
224: extern Plist modified_tn;
225:
226: // local class
227: extern Plist local_tn;
228: extern Plist local_blk;
229: extern Plist local_class;
230: extern void local_hide( Pname );
231: extern char *make_local_name(Pclass, int=0);
232:
233: // nested type
234: extern Plist nested_tn;
235: extern Plist nested_type;
236: extern Pname curr_scope;
237: extern Pname curr_fct;
238: extern void nested_hide(Pname);
239: extern int is_empty(Pclass,bit=0);
240:
241: extern Pbase start_cl(TOK, Pname, Pbcl);
242: extern void end_cl();
243: extern Pbase end_enum(Pname, Pname);
244:
245: /************ types : basic types, aggregates, declarators ************/
246:
247: #ifndef GRAM
248: extern bit new_type;
249: extern Pname cl_obj_vec;
250: extern Pname eobj;
251: #endif
252:
253:
254: #define DEFINED 01 /* definition fed through ?::dcl() */
255: #define SIMPLIFIED 02 /* in ?::simpl() */
256: #define DEF_SEEN 04 /* definition seen, but not processed */
257: #define REF_SEEN 010 /* reference seen (classdef) */
258: /* used for class members in norm.c */
259: #define IN_ERROR 010
260:
261: struct type : node {
262: bit defined; /* flags DEF_SEEN, DEFINED, SIMPLIFIED, IN_ERROR
263: not used systematically yet
264: */
265: bit lex_level;
266: Pclass in_class; // nested type
267: Pname in_fct; // local type
268: char *lcl;
269: char *nested_sig;
270: char *signature(char*);
271: Ptype tlist;
272: bit check(Ptype, TOK);
273: #ifndef GRAM
274: void print();
275: void dcl_print(Pname);
276: void base_print();
277: void del();
278:
279: Pname is_cl_obj(); /* sets cl_obj_vec */
280: Pptr is_ref();
281: Pptr is_ptr();
282: Pptr is_ptr_or_ref();
283: bit is_unsigned();
284: void dcl(Ptable);
285: int tsizeof(int = 0);
286: bit tconst();
287: TOK set_const(bit);
288: int align();
289: TOK kind(TOK,TOK);
290: TOK integral(TOK oo) { return kind(oo,'I'); };
291: TOK numeric(TOK oo) { return kind(oo,'N'); };
292: TOK num_ptr(TOK oo) { return kind(oo,'P'); };
293: bit vec_type();
294: Ptype deref();
295: inline Pptr addrof();
296: Pfct memptr();
297: #endif
298: };
299:
300: struct enumdef : type { /* ENUM */
301: bit e_body;
302: short no_of_enumerators;
303: unsigned char strlen; // strlen(string)
304: char* string; // name of enum
305: Pname mem;
306: Pbase e_type; // type representing the enum
307: enumdef(Pname n) { base=ENUM; mem=n; };
308: #ifndef GRAM
309: void print();
310: void dcl_print(Pname);
311: void dcl(Pname, Ptable);
312: void simpl();
313: #endif
314: };
315:
316: struct velem {
317: Pname n;
318: int offset;
319: };
320:
321: struct virt {
322: Pvirt next;
323: velem* virt_init; // vector of vtbl initializers (zero-terminated)
324: Pclass vclass; // for class vclass
325: char* string;
326: bit is_vbase; // vtable for virtual base
327: bit printed;
328: virt(Pclass cl, velem* v, char* s, bit flag) {vclass=cl; virt_init=v; string=s; is_vbase=flag; next=0; }
329: };
330:
331: enum { C_VPTR=1, C_XREF=2, C_ASS=4, C_VBASE=8 };
332:
333: struct classdef : type { /* CLASS */
334: bit c_body; /* print definition only once */
335: TOK csu; /* CLASS, STRUCT, UNION, or ANON */
336: bit obj_align;
337: bit c_xref;
338: // 1 set: has vptr(s)
339: // 2 set: X(X&) exists
340: // 4 set: operator=(X&) exists
341: // 8 set: has vbaseptr(s)
342:
343: bit virt_count; // number of virtual functions
344: // starting at max base class virt_count in
345: bit virt_merge; // set when no virtual functions, but
346: // need to merge virtual base classes
347: bit c_abstract; // abstract class: don't instansiate
348: bit has_vvtab; // set if class has vtable from virtual base
349: unsigned char strlen; // strlen(string)
350: Pbcl baselist; // list of base classes
351: char* string; /* name of class */
352: Pname mem_list;
353: Ptable memtbl;
354: int obj_size;
355: int real_size; /* obj_size - alignment waste */
356: Plist friend_list;
357: Pname pubdef;
358: Plist tn_list; // list of member names hiding type names
359: Plist nest_list; // list of nested types
360: Ptype this_type;
361: Pvirt virt_list; // vtbl initializers
362: Pname c_ctor; // constuctor:
363: // possibly overloaded, possibly inherited
364: Pname c_dtor; // destructor
365: Pname c_itor; /* constructor X(X&) */
366: Pname conv; /* operator T() chain */
367: struct toknode *c_funqf, *c_funqr; // token Q for parsing function defs after class def
368:
369: classdef(TOK);
370: TOK is_simple() { return (csu==CLASS)?0:csu; };
371: #ifndef GRAM
372: void print();
373: void dcl_print(Pname);
374: void simpl();
375:
376: void print_members();
377: void dcl(Pname, Ptable);
378:
379: // bit has_friend(Pname);
380: bit has_friend(Pclass);
381: bit has_friend(Pfct);
382:
383: bit has_base(Pclass cl);
384: bit baseof(Pname);
385: bit baseof(Pclass);
386: Pclass is_base(char*);
387:
388: Pname has_oper(TOK);
389: Pname has_ctor() { return c_ctor; }
390: Pname has_dtor() { return c_dtor; }
391: Pname has_itor() { return c_itor; }
392: Pname has_ictor();
393: Pname make_itor(int);
394: Pexpr find_name(char*, Pclass);
395: int do_virtuals(Pvirt, char*, int, bit);
396: int all_virt(Pclass, char*, int, bit);
397: void add_vtbl(velem*, char*, bit);
398: void print_all_vtbls(Pclass);
399: void print_vtbl(Pvirt);
400: void really_print(Pvirt);
401: int check_dup(Pclass, TOK);
402: int has_allocated_base(Pclass);
403: char *has_allocated_base(char*);
404: int get_offset(char*);
405: Pbcl get_base(char*);
406: Pexpr get_vptr_exp(char*);
407: Pexpr find_in_base(char*, Pclass);
408: #endif
409: };
410:
411: #ifndef GRAM
412:
413: class clist {
414: Pclass cl;
415: clist* next;
416: public:
417: clist(Pclass c, clist* n) { cl=c; next=n; }
418: int onlist(Pclass);
419: void clear();
420: };
421:
422: extern clist * vcllist;
423:
424: struct vl {
425: struct vl* next;
426: Pvirt vt;
427: classdef* cl;
428:
429: vl(classdef* c, Pvirt v, struct vl* n)
430: { cl = c; vt = v; next = n; }
431: };
432:
433: extern vl* vlist;
434:
435: extern int nin;
436: extern int Nvis;
437: extern int Noffset;
438: extern TOK Nvirt;
439: extern Pexpr Nptr;
440: extern Pbcl Nvbc_alloc;
441: extern char *Nalloc_base;
442: extern Pexpr rptr(Ptype,Pexpr,int);
443: extern Pexpr vbase_args(Pfct, Pname);
444: extern Pexpr cdvec(Pname,Pexpr,Pclass,Pname,int,Pexpr,Pexpr=0);
445:
446: extern Pexpr find(char*, Pclass, int);
447: extern Pexpr find_name(Pname, Pclass, Ptable, int, Pname);
448: extern Pname find_virtual(Pclass,Pname);
449: extern Pname vfct(Pclass, char*);
450: extern int Vcheckerror;
451: extern int vhack;
452: extern int ignore_const;
453:
454: extern int access_control;
455: extern int mex;
456: extern Pclass mec;
457: extern Pclass tcl;
458: extern Pname me;
459: extern Pfct mef;
460: #endif
461:
462: struct basetype : type
463: /* ZTYPE CHAR SHORT INT LONG FLOAT DOUBLE
464: FIELD EOBJ COBJ TYPE ANY
465: */
466: /* used for gathering all the attributes
467: for a list of declarators
468:
469: ZTYPE is the (generic) type of ZERO
470: ANY is the generic type of an undeclared name
471: */
472: {
473: bit b_unsigned;
474: bit b_signed;
475: bit b_volatile;
476: bit b_const;
477: bit b_typedef;
478: bit b_inline;
479: bit b_virtual;
480: bit b_short;
481: bit b_long;
482: bit b_bits; /* number of bits in field */
483: bit b_offset; // bit offset of field
484: TOK b_sto; /* AUTO STATIC EXTERN REGISTER 0 */
485: Pname b_name; /* name of non-basic type */
486: Ptable b_table; /* memtbl for b_name, or 0 */
487: Pname b_xname; /* extra name */
488: union {
489: Ptype b_fieldtype;
490: char* b_linkage;
491: };
492:
493: basetype(TOK, Pname);
494:
495: Pbase type_adj(TOK);
496: Pbase base_adj(Pbase);
497: Pbase name_adj(Pname);
498: Pname aggr();
499: Pbase check(Pname);
500: #ifndef GRAM
501: void dcl_print();
502: Pbase arit_conv(Pbase);
503: #endif
504: };
505:
506: enum Linkage { linkage_default, linkage_C, linkage_Cplusplus };
507: extern Linkage linkage;
508: void set_linkage(char*);
509:
510: struct fct : type // FCT
511: {
512: TOK nargs;
513: TOK nargs_known; // 0 if unknown, 1 if known, or ELLIPSIS
514: bit last_stmt;
515: bit f_vdef; // 1 if this is the first virtual definition
516: // of this function
517: bit f_inline; // 1 if inline, 2 if being expanded, else 0
518: bit f_const; // one if member function that may be called for
519: // a const object, else 0
520: bit f_static; // 1 if static member function, else 0
521: short f_virtual; // index in virtual table, or 0 meaning non-virtual
522: short f_imeasure; // some measure of the size of an inline function
523: Ptype returns;
524: Pname argtype;
525: Ptype s_returns;
526: Pname f_this;
527: Pclass memof; // member of class memof
528: Pblock body;
529: Pname f_init; // base and member initializers
530: // Pname f_baseinit; // base initializers
531: // // null name => single base class init;
532: Pexpr f_expr; // body expanded into an expression
533: Pexpr last_expanded;
534: Pname f_result; // extra second argument of type X&
535: Pname f_args; // argument list including args added by cfront
536: Linkage f_linkage;
537: char* f_signature; // character encoding of function type
538: Plist local_class; // list of local classes
539: fct(Ptype, Pname, TOK);
540: void argdcl(Pname,Pname);
541: #ifndef GRAM
542: Ptype normalize(Ptype);
543: void dcl_print();
544: void dcl(Pname);
545: Pexpr base_init(Pclass, Pexpr, Ptable, int);
546: Pexpr mem_init(Pname, Pexpr, Ptable);
547: void init_bases(Pclass, Pexpr);
548: bit declared() { return nargs_known; };
549: void simpl();
550: int ctor_simpl(Pclass, Pexpr);
551: Pstmt dtor_simpl(Pclass, Pexpr);
552: Pexpr expand(Pname,Ptable,Pexpr);
553: void sign();
554: #endif
555: };
556:
557:
558: struct name_list {
559: Pname f;
560: Plist l;
561: name_list(Pname ff, Plist ll) { f=ff; l=ll; };
562: };
563:
564: #ifndef GRAM
565: struct gen : type { // OVERLOAD
566: Plist fct_list;
567:
568: gen() { base = OVERLOAD; }
569: Pname add(Pname);
570: Pname find(Pfct, bit);
571: Pname match(Pname, Pfct, bit);
572: };
573: #endif
574:
575: struct pvtyp : type {
576: Ptype typ;
577: };
578:
579: struct vec : pvtyp // VEC
580: // typ [ dim ]
581: {
582: Pexpr dim;
583: int size;
584:
585: vec(Ptype t, Pexpr e) { base=VEC; typ=t; dim=e; DBID(); };
586: #ifndef GRAM
587: Ptype normalize(Ptype);
588: #endif
589: };
590:
591: struct ptr : pvtyp // PTR, RPTR i.e. reference
592: {
593: Pclass memof; // pointer to member of memof: memof::*
594: bit rdo; // "*const"
595:
596: ptr(TOK b, Ptype t) { base=b; typ=t; DBID(); }
597: #ifndef GRAM
598: Ptype normalize(Ptype);
599: #endif
600: };
601:
602: #ifndef GRAM
603: inline Pptr type::addrof() { return new ptr(PTR,this); }
604:
605: extern bit vrp_equiv;
606: #endif
607:
608:
609: /****************************** constants ********************************/
610:
611: /* STRING ZERO ICON FCON CCON ID */
612: /* IVAL FVAL LVAL */
613:
614: /***************************** expressions ********************************/
615:
616: #ifndef GRAM
617: extern Pexpr next_elem();
618: extern void new_list(Pexpr);
619: extern void list_check(Pname, Ptype, Pexpr, Ptable=0);
620: extern Pexpr ref_init(Pptr,Pexpr,Ptable);
621: extern Pexpr class_init(Pexpr,Ptype,Pexpr,Ptable);
622: extern Pexpr check_cond(Pexpr, TOK, Ptable);
623: extern Pexpr ptof(Pfct,Pexpr,Ptable);
624: extern void dosimpl(Pexpr, Pname);
625: extern int ref_initializer;
626: extern int ntok;
627:
628: extern void ptbl_init(int);
629: extern void ptbl_add_pair(char*,char*);
630: extern char *ptbl_lookup(char*);
631: extern char *st_name(char*);
632: #endif
633:
634: struct expr : node /* PLUS, MINUS, etc. */
635: /* IMPORTANT: all expressions are of sizeof(expr) */
636: /* DEREF => *e1 (e2==0) OR e1[e2]
637: UMINUS => -e2
638: INCR (e1==0) => ++e2
639: INCR (e2==0) => e1++
640: CM => e1 , e2
641: ILIST => LC e1 RC (an initializer list)
642: a Pexpr may denote a name
643: */
644: {
645: union {
646: Ptype tp;
647: int syn_class;
648: char *string4;
649: };
650: union {
651: Pexpr e1;
652: long i1;
653: char* string;
654: };
655: union {
656: Pexpr e2;
657: int i2;
658: char* string2;
659: Pexpr n_initializer;
660: Ptype tpdef; // local and nested typedef info
661: };
662: union { /* used by the derived classes */
663: Ptype tp2;
664: Pname fct_name;
665: Pexpr cond;
666: Pexpr mem;
667: Ptype as_type;
668: Ptable n_table;
669: Pin il;
670: char* string3;
671: };
672:
673: expr(TOK, Pexpr, Pexpr);
674: ~expr();
675: #ifndef GRAM
676: void del();
677: void print();
678: Pexpr typ(Ptable);
679: long eval();
680: unsigned long ueval(long,long);
681: int lval(TOK);
682: Ptype call_fct(Ptable);
683: Pexpr address();
684: Pexpr contents();
685: void simpl();
686: Pexpr expand();
687: bit not_simple();
688: Pexpr try_to_overload(Ptable);
689: Pexpr docast(Ptable);
690: Pexpr dovalue(Ptable);
691: Pexpr donew(Ptable);
692: void simpl_new();
693: void simpl_delete();
694: #endif
695: };
696:
697: struct texpr : expr { // CAST NEW VALUE (also ICALL)
698: #ifdef __cplusplus
699: texpr(TOK bb, Ptype tt, Pexpr ee) : expr (bb,ee,0) { this=0; tp2=tt; }
700: #else
701: texpr(TOK bb, Ptype tt, Pexpr ee) : (bb,ee,0) { this=0; tp2=tt; }
702: #endif
703:
704: };
705:
706: struct cast : expr { // CAST
707: #ifdef __cplusplus
708: cast(Ptype tt, Pexpr ee) : expr (CAST,ee,0) { this=0; tp=tp2=tt; }
709: #else
710: cast(Ptype tt, Pexpr ee) : (CAST,ee,0) { this=0; tp=tp2=tt; }
711: #endif
712: };
713:
714: struct ival : expr { // IVAL
715: #ifdef __cplusplus
716: ival(long ii) : expr (IVAL,0,0) { this=0; i1 = ii;}
717: #else
718: ival(long ii) : (IVAL,0,0) { this=0; i1 = ii;}
719: #endif
720: };
721:
722: struct call : expr { // CALL
723: #ifdef __cplusplus
724: call(Pexpr aa, Pexpr bb) : expr (CALL,aa,bb) { this=0; }
725: #else
726: call(Pexpr aa, Pexpr bb) : (CALL,aa,bb) { this=0; }
727: #endif
728: #ifndef GRAM
729: void simpl();
730: Pexpr expand(Ptable);
731: #endif
732: };
733:
734: struct qexpr : expr { // QUEST cond ? e1 : e2
735: #ifdef __cplusplus
736: qexpr(Pexpr ee, Pexpr ee1, Pexpr ee2) : expr (QUEST,ee1,ee2) { this=0; cond=ee; }
737: #else
738: qexpr(Pexpr ee, Pexpr ee1, Pexpr ee2) : (QUEST,ee1,ee2) { this=0; cond=ee; }
739: #endif
740: };
741:
742: struct ref : expr { // REF DOT e1->mem OR e1.mem
743: #ifdef __cplusplus
744: ref(TOK ba, Pexpr a, Pexpr b) : expr (ba,a,0) { this=0; mem=b; }
745: #else
746: ref(TOK ba, Pexpr a, Pexpr b) : (ba,a,0) { this=0; mem=b; }
747: #endif
748: };
749:
750: struct mdot : expr { // MDOT a.b
751: #ifdef __cplusplus
752: mdot(char* a, Pexpr b) : expr (MDOT,0,0) { this=0; string2=a; mem=b; }
753: #else
754: mdot(char* a, Pexpr b) : (MDOT,0,0) { this=0; string2=a; mem=b; }
755: #endif
756: };
757:
758: struct text_expr : expr { // TEXT (vtbl_name)
759: #ifdef __cplusplus
760: text_expr(char* a, char* b) : expr (TEXT,0,0)
761: #else
762: text_expr(char* a, char* b) : (TEXT,0,0)
763: #endif
764: { this=0; string=a; string2=b; }
765: };
766: char* vtbl_name(char*,char*);
767: /************************* names (are expressions) ****************************/
768:
769: struct basecl : node { // NAME => base class
770: // VIRTUAL => virtual base class
771: TOK ppp; // private / public / protected
772: bit allocated; // allocated virtual base
773: bit promoted; // non-explicit, promoted virtual base
774: Pclass bclass;
775: Pexpr init; // base class initializers for ctors
776: int ptr_offset; // pointer's relative position in derived class
777: int obj_offset; // object's relative position in derived class
778: Pname* virt_init; // vector of vtbl table initializers
779: basecl* next;
780:
781: basecl(Pclass cl, basecl* n) { bclass=cl; next=n; promoted=0; init=0;}
782: };
783: extern TOK ppbase;
784:
785: struct name : expr { // NAME TNAME and the keywords in the ktbl
786: TOK n_oper; // name of operator or 0
787: TOK n_sto; // EXTERN STATIC AUTO REGISTER ENUM 0
788: TOK n_stclass; // STATIC AUTO REGISTER 0
789: TOK n_scope; // EXTERN STATIC FCT ARG PUBLIC 0
790: TOK n_key; /* for names in table: class */
791: bit n_evaluated; // 0 or n_val holds the value
792: bit n_xref; // argument of type X(X&)
793: unsigned char lex_level;
794: TOK n_protect; // PROTECTED (<=>n_scope==0) or 0
795: bit n_dcl_printed; // 1: declaration printed
796: // 2: definition printed
797: // 0: declaration not printed
798: char *n_anon; // nested anonymous unions
799: short n_union; // 0, or union index
800: short n_addr_taken;
801: short n_used;
802: short n_assigned_to;
803: Loc where;
804: int n_offset; // byte offset in frame or struct
805: Pname n_list;
806: Pname n_tbl_list;
807: union {
808: Pname n_qualifier; // name of containing class
809: Ptable n_realscope; /* for labels (always entered in
810: function table) the table for the
811: actual scope in which label occurred.
812: */
813: };
814: long n_val; // the value of n_initializer
815: // also used as the argument number
816: // for inline arguments
817: name(char* =0);
818: ~name();
819:
820: Pname normalize(Pbase, Pblock, bit);
821: Pname tdef();
822: Pname tname(TOK);
823: void hide();
824: void unhide() { n_key=0; n_list=0; };
825: #ifndef GRAM
826: Pname dcl(Ptable,TOK);
827: int no_of_names();
828: void use() { n_used++; };
829: void assign();
830: void take_addr();
831: void check_oper(Pname);
832: void simpl();
833: void del();
834: void print();
835: void dcl_print(TOK);
836: void field_align();
837: Pname dofct(Ptable,TOK);
838: #endif
839: };
840:
841: extern int friend_in_class;
842: extern int in_class_dcl;
843:
844: // from parser
845: extern int in_class_decl;
846: extern int parsing_class_members;
847: extern int in_mem_fct;
848: extern int in_arg_list;
849: extern Ptype in_typedef;
850: extern int defer_check; // redefinition typedef check delay
851: extern int declTag; // !1: inline, virtual mod permitted
852: extern Pname in_tag;
853: extern Pname statStat;
854: extern int DECL_TYPE;
855:
856: /******************** statements *********************************/
857:
858: struct stmt : node { /* BREAK CONTINUE DEFAULT */
859: /* IMPORTANT: all statement nodes have sizeof(stmt) */
860: Pstmt s;
861: Pstmt s_list;
862: Loc where;
863: union {
864: Pname d;
865: Pexpr e2;
866: Pstmt has_default;
867: int case_value;
868: Ptype ret_tp;
869: };
870: union {
871: Pexpr e;
872: bit own_tbl;
873: Pstmt s2;
874: };
875: Ptable memtbl;
876: union {
877: Pstmt for_init;
878: Pstmt else_stmt;
879: Pstmt case_list;
880: // bit empty;
881: Loc where2; // location of } at end of block
882: };
883:
884: stmt(TOK, loc, Pstmt);
885: ~stmt();
886: #ifndef GRAM
887: void del();
888: void print();
889: void dcl();
890: void reached();
891: Pstmt simpl();
892: Pstmt expand();
893: Pstmt copy();
894: #endif
895: };
896:
897: #ifndef GRAM
898: extern char* Neval;
899: extern Ptable scope;
900: extern Ptable expand_tbl;
901: extern Pname expand_fn;
902: #endif
903:
904: struct estmt : stmt /* SM WHILE DO SWITCH RETURN CASE */
905: /* SM (e!=0) => e;
906: in particular assignments and function calls
907: SM (e==0) => ; (the null statement)
908: CASE => case e : s ;
909: */
910: {
911: #ifdef __cplusplus
912: estmt(TOK t, loc ll, Pexpr ee, Pstmt ss) : stmt (t,ll,ss) { this=0; e=ee; }
913: #else
914: estmt(TOK t, loc ll, Pexpr ee, Pstmt ss) : (t,ll,ss) { this=0; e=ee; }
915: #endif
916: };
917:
918: struct ifstmt : stmt /* IF */
919: // else_stme==0 => if (e) s
920: // else_stmt!=0 => if (e) s else else_stmt
921: {
922: ifstmt(loc ll, Pexpr ee, Pstmt ss1, Pstmt ss2)
923: #ifdef __cplusplus
924: : stmt (IF,ll,ss1) { this=0; e=ee; else_stmt=ss2; };
925: #else
926: : (IF,ll,ss1) { this=0; e=ee; else_stmt=ss2; };
927: #endif
928: };
929:
930: struct lstmt : stmt /* LABEL GOTO */
931: /*
932: d : s
933: goto d
934: */
935: {
936: #ifdef __cplusplus
937: lstmt(TOK bb, loc ll, Pname nn, Pstmt ss) : stmt (bb,ll,ss) { this=0; d=nn; }
938: #else
939: lstmt(TOK bb, loc ll, Pname nn, Pstmt ss) : (bb,ll,ss) { this=0; d=nn; }
940: #endif
941: };
942:
943: struct forstmt : stmt { // FOR
944: forstmt(loc ll, Pstmt fss, Pexpr ee1, Pexpr ee2, Pstmt ss)
945: #ifdef __cplusplus
946: : stmt (FOR,ll,ss) { this=0; for_init=fss; e=ee1; e2=ee2; }
947: #else
948: : (FOR,ll,ss) { this=0; for_init=fss; e=ee1; e2=ee2; }
949: #endif
950: };
951:
952: struct block : stmt { // BLOCK { d s }
953: #ifdef __cplusplus
954: block(loc ll, Pname nn, Pstmt ss, loc rr = noloc ) : stmt (BLOCK,ll,ss)
955: #else
956: block(loc ll, Pname nn, Pstmt ss, loc rr = noloc ) : (BLOCK,ll,ss)
957: #endif
958: { this=0; d=nn; where2=rr; }
959: #ifndef GRAM
960: void dcl(Ptable);
961: Pstmt simpl();
962: #endif
963: };
964:
965: #ifndef GRAM
966: struct pair : public stmt { // PAIR
967: #ifdef __cplusplus
968: pair(loc ll, Pstmt a, Pstmt b) : stmt (PAIR,ll,a) { this=0; s2 = b; }
969: #else
970: pair(loc ll, Pstmt a, Pstmt b) : (PAIR,ll,a) { this=0; s2 = b; }
971: #endif
972: };
973: #endif
974:
975: struct nlist {
976: Pname head;
977: Pname tail;
978: nlist(Pname);
979: void add(Pname n) { tail->n_list = n; tail = n; };
980: void add_list(Pname);
981: };
982:
983: extern Pname name_unlist(nlist*);
984:
985: struct slist {
986: Pstmt head;
987: Pstmt tail;
988: slist(Pstmt s) { /*Nl++;*/ head = tail = s; };
989: void add(Pstmt s) { tail->s_list = s; tail = s; };
990: };
991:
992: extern Pstmt stmt_unlist(slist*);
993:
994: struct elist {
995: Pexpr head;
996: Pexpr tail;
997: elist(Pexpr e) { /*Nl++;*/ head = tail = e; };
998: void add(Pexpr e) { tail->e2 = e; tail = e; };
999: };
1000:
1001: extern Pexpr expr_unlist(elist*);
1002:
1003: #ifndef GRAM
1004: extern class dcl_context * cc;
1005:
1006: struct dcl_context {
1007: Pname c_this; /* current fct's "this" */
1008: Ptype tot; /* type of "this" or 0 */
1009: Pname not; /* name of "this"'s class or 0 */
1010: Pclass cot; /* the definition of "this"'s class */
1011: Ptable ftbl; /* current fct's symbol table */
1012: Pname nof; /* current fct's name */
1013:
1014: void stack() { cc++; *cc = *(cc-1); };
1015: void unstack() { cc--; };
1016: };
1017:
1018: #define MAXCONT 20
1019: extern dcl_context ccvec[MAXCONT];
1020: #endif
1021:
1022: extern void yyerror(char*);
1023:
1024:
1025: #ifndef GRAM
1026: extern char* line_format;
1027:
1028: extern Plist stat_mem_list;
1029: extern Plist isf_list;
1030: extern Pstmt st_ilist;
1031: extern Pstmt st_dlist;
1032: extern Ptable sti_tbl;
1033: extern Ptable std_tbl;
1034: extern int need_sti( Pexpr e, Ptable tbl = 0, bit is_static_ok = 0 );
1035: Pexpr try_to_coerce(Ptype, Pexpr, char*, Ptable);
1036: extern bit can_coerce(Ptype, Ptype);
1037: extern Ptype np_promote(TOK, TOK, TOK, Ptype, Ptype, TOK);
1038: extern bit enum_promote;
1039: extern int suppress_error;
1040: extern void new_key(char*, TOK, TOK);
1041: extern void delete_local();
1042:
1043: extern int over_call(Pname, Pexpr);
1044: extern Pname overFound;
1045: extern Pname Nover;
1046: extern Pname Ncoerce;
1047: extern Nover_coerce;
1048: struct ia {
1049: Pname local; // local variable for argument
1050: Pexpr arg; // actual arguments for call
1051: Ptype tp; // type of formal argument
1052: };
1053:
1054: struct iline {
1055: Pname fct_name; /* fct called */
1056: Pin i_next;
1057: Ptable i_table;
1058: int i_slots; // no of arg slots pointer to by i_args
1059: ia* i_args;
1060: };
1061:
1062: extern Pexpr curr_expr;
1063: extern Pin curr_icall;
1064: #define FUDGE111 11111
1065: #define VTOK 22222
1066: #define ITOR 77
1067:
1068: extern Pstmt curr_loop;
1069: extern Pblock curr_block;
1070: extern Pstmt curr_switch;
1071: extern loc last_line; // last #line + number of '\n's output since
1072: extern int last_ll; // 0 or line of current stmt/dcl being printed
1073: extern FILE* out_file; // output file descriptor
1074: extern bit Cast;
1075: extern loc no_where;
1076:
1077: extern no_of_undcl;
1078: extern no_of_badcall;
1079: extern Pname undcl, badcall;
1080:
1081: extern long str_to_long(const char*);
1082: extern int c_strlen(const char* s);
1083: #endif
1084:
1085: #ifndef GRAM
1086: extern Pname vec_new_fct;
1087: extern Pname new_fct;
1088: extern Pname del_fct;
1089: extern Pname vec_del_fct;
1090:
1091: extern int Nstd; // standard coercion used (derived* =>base* or int=>long or ...)
1092:
1093: extern int stcount; // number of names generated using make_name()
1094:
1095: Pexpr replace_temp(Pexpr,Pexpr);
1096: void make_res(Pfct);
1097:
1098: extern int Pchecked;
1099: Pexpr ptr_init(Pptr,Pexpr,Ptable);
1100: Pexpr call_ctor(Ptable, Pexpr p, Pexpr ctor, Pexpr args, int d = REF, Pexpr vb_args = 0);
1101: Pexpr call_dtor(Pexpr p, Pexpr dtor, Pexpr arg = 0, int d = DOT, Pexpr vb_args = 0);
1102: void check_visibility(Pname, Pname, Pclass, Ptable, Pname);
1103:
1104: int make_assignment(Pname);
1105:
1106: extern Pname make_tmp(char, Ptype, Ptable);
1107: Pexpr init_tmp(Pname, Pexpr, Ptable);
1108:
1109: extern int is_unique_base(Pclass, char*, int, int = 0);
1110: extern Pexpr rptr(Ptype, Pexpr, int);
1111:
1112: extern int read_align(char*);
1113: extern void new_init();
1114:
1115: extern void Eprint(Pexpr);
1116: extern Pexpr cast_cptr(Pclass ccl, Pexpr ee, Ptable tbl, int real_cast);
1117: extern Pexpr mptr_assign(Pexpr,Pexpr);
1118: extern Pclass Mptr;
1119:
1120: #endif
1121:
1122: extern bit fake_sizeof; // suppress error message for ``int v[];''
1123:
1124: extern TOK lalex();
1125:
1126:
1127: #ifdef DBG
1128: extern void display_expr( Pexpr, char* = 0, int = 0 );
1129: extern void display_stmt( Pstmt, char* = 0, int = 0 );
1130: extern void display_type( Ptype );
1131: extern void display_namelist( Plist, char* = 0, int = 0 );
1132:
1133: extern fprintf(const FILE*, const char* ...);
1134: extern void process_debug_flags( char* );
1135: #define DB(a) a
1136: extern int Adebug; // allocation (ctor/del) debugging
1137: extern int Ddebug; // dcl debugging
1138: extern int Edebug; // expr debugging
1139: extern int Ldebug; // lex/lalex debugging
1140: extern int Mdebug; // trace function matching
1141: extern int Ndebug; // norm debugging
1142: extern int Pdebug; // print debugging
1143: extern int Rdebug; // run() debugging
1144: extern int Sdebug; // simpl debugging
1145: extern int Tdebug; // typ debugging
1146: #define Ydebug yydebug
1147: extern int Ydebug; // yacc debugging
1148:
1149: #else
1150:
1151: #define DB(a) /**/
1152:
1153: #endif
1154:
1155: /* end */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.