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