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