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