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