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