Return to cfront.cpio CVS log

Up to [Research Unix] / researchv10no / cmd / cfront / xptcfront

Annotation of researchv10no/cmd/cfront/xptcfront/cfront.cpio, revision 1.1

1.1     ! root        1: 0707071010112043441004440001630000160000010075200466055374000001000000013411alloc.c/*ident    "@(#)ctrans:src/alloc.c 1.4" */
        !             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: alloc.c:
        !            11: 
        !            12: *****************************************************************************/
        !            13: #include "cfront.h"
        !            14: #include "size.h"
        !            15: #include "sysent.h"
        !            16: 
        !            17: const int NBITE = (CHUNK-8)/sizeof(name)-1;
        !            18: const int EBITE = (CHUNK-8)/sizeof(expr)-1;
        !            19: const int SBITE = (CHUNK-8)/sizeof(stmt)-1;
        !            20: const int TBITE = (CHUNK-8)/sizeof(table)-1;
        !            21: const int VBITE = (CHUNK-8)/sizeof(vec)-1;
        !            22: const int FBITE = (CHUNK-8)/sizeof(fct)-1;
        !            23: const int PBITE = (CHUNK-8)/sizeof(ptr)-1;
        !            24: 
        !            25: #define  mzero(p,l)  memset(p,0,l)
        !            26: 
        !            27: void* chunk(int i)     // get memory that is not to be freed
        !            28: {
        !            29:        register char* cp = malloc(i*CHUNK-8);
        !            30:        if (cp == 0) {                  // no space
        !            31:                free((char*)gtbl);      // get space for error message
        !            32:                error('i',"free store exhausted");
        !            33:        }
        !            34:        return cp;
        !            35: }
        !            36: 
        !            37: #ifdef __HAVE_SIZE_T
        !            38: #include <new.h>
        !            39: #define NEW_SIZE size_t
        !            40: #else
        !            41: #define NEW_SIZE long
        !            42: #endif
        !            43: 
        !            44: void* operator new(NEW_SIZE sz)        // get memory that might be freed
        !            45: {
        !            46:        char* p = calloc((unsigned)sz,1);
        !            47: 
        !            48: //fprintf(stderr,"alloc(%d)->%d\n",sz,p);
        !            49: 
        !            50:        if (p == 0) {                   // no space
        !            51:                free((char*)gtbl);      // get space for error message
        !            52:                error('i',"free store exhausted");
        !            53:        }
        !            54:        return p;
        !            55: }
        !            56: 
        !            57: void operator delete (void* p)
        !            58: {
        !            59:        if (p == 0) return;
        !            60: 
        !            61: //fprintf(stderr,"free(%d) %d\n",p,((int*)p)[-1]-(int)p-1+sizeof(int*));
        !            62: 
        !            63:        free((char*)p);
        !            64: }
        !            65: 
        !            66: // class new and delete operators
        !            67: 
        !            68: void*
        !            69: expr::operator new(size_t sz)
        !            70: {
        !            71:        register Pexpr p;
        !            72: 
        !            73:         if ( (p=expr_free) == 0 ) {
        !            74:                 register Pexpr q = (Pexpr) chunk(1);
        !            75:                 for (p=expr_free=&q[EBITE-1]; q<p; p--) {
        !            76:                         p->e1 = p-1;
        !            77:                         DB(p->node::allocated=0);
        !            78:                }
        !            79:                (p+1)->e1 = 0;
        !            80:                DB(p->node::allocated=0);
        !            81:        }
        !            82:        else
        !            83:                expr_free = p->e1;
        !            84: 
        !            85:        mzero(p,sz);
        !            86:        return p;
        !            87: }
        !            88: 
        !            89: void
        !            90: expr::operator delete(void* vp, size_t)
        !            91: {
        !            92:        Pexpr p = (Pexpr)vp;
        !            93: 
        !            94:        DB( if(!p->node::allocated) error('i',"deleting unallocated expr:%k! -- id==%d",p->base,p->node::id);
        !            95:            p->node::allocated = 0;
        !            96:        );
        !            97:        p->e1 = expr_free;
        !            98:        expr_free = p;
        !            99:        vp = 0;
        !           100: }
        !           101: 
        !           102: void*
        !           103: stmt::operator new(size_t sz)
        !           104: {
        !           105:        register Pstmt p;
        !           106:        if ( (p=stmt_free) == 0 ) {
        !           107:                register Pstmt q = (Pstmt) chunk(1);
        !           108:                for (p=stmt_free=&q[SBITE-1]; q<p; p--) {
        !           109:                        p->s_list = p-1;
        !           110:                        DB(p->node::allocated=0);
        !           111:                }
        !           112:                (p+1)->s_list = 0;
        !           113:                DB(p->node::allocated=0);
        !           114:        }
        !           115:        else
        !           116:                stmt_free = p->s_list;
        !           117: 
        !           118:        mzero(p,sz);
        !           119:        return p;
        !           120: }
        !           121: 
        !           122: void
        !           123: stmt::operator delete(void* vp,size_t)
        !           124: {
        !           125:        Pstmt p = (Pstmt)vp;
        !           126:        DB( if(!p->node::allocated) error('i',"deleting unallocated stmt:%k! -- id==%d",p->base,p->node::id);
        !           127:            p->node::allocated = 0;
        !           128:        );
        !           129:        p->s_list = stmt_free;
        !           130:        stmt_free = p;
        !           131:        vp = 0;
        !           132: }
        !           133: 
        !           134: void*
        !           135: name::operator new(size_t sz)
        !           136: {
        !           137:        register Pname p;
        !           138: 
        !           139:        if ( (p=name_free) == 0 ) {
        !           140:                register Pname q = (Pname) chunk(1);
        !           141:                for (p=name_free=&q[NBITE-1]; q<p; p--) {
        !           142:                        p->n_tbl_list = p-1;
        !           143:                        DB(p->node::allocated=0);
        !           144:                }
        !           145:                (p+1)->n_tbl_list = 0;
        !           146:                DB(p->node::allocated=0);
        !           147:        }
        !           148:        else
        !           149:                name_free = p->n_tbl_list;
        !           150: 
        !           151:        mzero(p,sz);
        !           152:        return p;
        !           153: }
        !           154: 
        !           155: void
        !           156: name::operator delete(void* vp,size_t)
        !           157: {
        !           158:        Pname p = (Pname)vp;
        !           159:        DB( if(!p->node::allocated) error('i',"deleting unallocated name %s! -- id==%d",p->string?p->string:"???",p->node::id);
        !           160:            p->node::allocated = 0;
        !           161:        );
        !           162:        p->n_tbl_list = name_free;
        !           163:        name_free = p;
        !           164:        vp = 0;
        !           165: }
        !           166: 
        !           167: void*
        !           168: table::operator new(size_t sz)
        !           169: {
        !           170:        register Ptable p;
        !           171: 
        !           172:        if ( (p=table_free) == 0 ) {
        !           173:                register Ptable q = (Ptable) chunk(1);
        !           174:                for (p=table_free=&q[TBITE-1]; q<p; p--) {
        !           175:                        p->next = p-1;
        !           176:                        DB(p->node::allocated=0);
        !           177:                }
        !           178:                (p+1)->next = 0;
        !           179:                DB(p->node::allocated=0);
        !           180:        }
        !           181:        else
        !           182:                table_free = p->next;
        !           183: 
        !           184:        mzero(p, sz);
        !           185:        return p;
        !           186: }
        !           187: 
        !           188: void
        !           189: table::operator delete(void* vp,size_t)
        !           190: {
        !           191:        Ptable p = (Ptable)vp;
        !           192:        DB( if(!p->node::allocated) error('i',"deleting unallocated table %d! -- id==%d",p->base,p->node::id);
        !           193:            p->node::allocated = 0;
        !           194:        );
        !           195:        p->next = table_free;
        !           196:        table_free = p;
        !           197:        vp = 0;
        !           198: }
        !           199: 
        !           200: void*
        !           201: vec::operator new(size_t sz)
        !           202: {
        !           203:        register Pvec p;
        !           204: 
        !           205:        if ( (p=vec_free) == 0 ) {
        !           206:                register Pvec q = (Pvec) chunk(1);
        !           207:                for (p=vec_free=&q[VBITE-1]; q<p; p--) {
        !           208:                        p->tlist = p-1;
        !           209:                        DB(p->node::allocated=0);
        !           210:                }
        !           211:                (p+1)->tlist = 0;
        !           212:                DB(p->node::allocated=0);
        !           213:        }
        !           214:        else
        !           215:                vec_free = (Pvec) p->tlist;
        !           216: 
        !           217:        mzero(p, sz);
        !           218:        return p;
        !           219: }
        !           220: 
        !           221: void
        !           222: vec::operator delete(void* vp,size_t)
        !           223: {
        !           224:        Pvec p = (Pvec)vp;
        !           225:        DB( if(!p->node::allocated) error('i',"deleting unallocated vec %d! -- id==%d",p->base,p->node::id);
        !           226:            p->node::allocated = 0;
        !           227:        );
        !           228:        p->tlist = vec_free;
        !           229:        vec_free = p;
        !           230:        vp = 0;
        !           231: }
        !           232: 
        !           233: void*
        !           234: fct::operator new(size_t sz)
        !           235: {
        !           236:        register Pfct p;
        !           237: 
        !           238:        if ( (p=fct_free) == 0 ) {
        !           239:                register Pfct q = (Pfct) chunk(1);
        !           240:                for (p=fct_free=&q[FBITE-1]; q<p; p--) {
        !           241:                        p->tlist = p-1;
        !           242:                        DB(p->node::allocated=0);
        !           243:                }
        !           244:                (p+1)->tlist = 0;
        !           245:                DB(p->node::allocated=0);
        !           246:        }
        !           247:        else
        !           248:                fct_free = (Pfct) p->tlist;
        !           249: 
        !           250:        mzero(p, sz);
        !           251:        return p;
        !           252: }
        !           253: 
        !           254: void
        !           255: fct::operator delete(void* vp,size_t)
        !           256: {
        !           257:        Pfct p = (Pfct)vp;
        !           258:        DB( if(!p->node::allocated) error('i',"deleting unallocated fct %d! -- id==%d",p->base,p->node::id);
        !           259:            p->node::allocated = 0;
        !           260:        );
        !           261:        p->tlist = fct_free;
        !           262:        fct_free = p;
        !           263:        vp = 0;
        !           264: }
        !           265: 
        !           266: void*
        !           267: ptr::operator new(size_t sz)
        !           268: {
        !           269:        register Pptr p;
        !           270: 
        !           271: //error('d',"ptr new");
        !           272:        if ( (p=ptr_free) == 0 ) {
        !           273:                register Pptr q = (Pptr) chunk(1);
        !           274:                for (p=ptr_free=&q[PBITE-1]; q<p; p--) {
        !           275:                        p->tlist = p-1;
        !           276:                        DB(p->node::allocated=0);
        !           277:                }
        !           278:                (p+1)->tlist = 0;
        !           279:                DB(p->node::allocated=0);
        !           280:        }
        !           281:        else 
        !           282:                ptr_free = (Pptr) p->tlist;
        !           283: 
        !           284:        mzero(p, sz);
        !           285:        return p;
        !           286: }
        !           287: 
        !           288: void
        !           289: ptr::operator delete(void* vp,size_t)
        !           290: {
        !           291:        Pptr p = (Pptr)vp;
        !           292:        DB( if(!p->node::allocated) error('i',"deleting unallocated ptr %d! -- id==%d",p->base,p->node::id);
        !           293:            p->node::allocated = 0;
        !           294:        );
        !           295:        p->tlist = ptr_free;
        !           296:        ptr_free = p;
        !           297:        vp = 0;
        !           298: }
        !           299: 0707071010112043451004440001630000160000010070500466055374500001100000070343cfront.h/*ident   "@(#)ctrans:src/cfront.h        1.12" */
        !           300: /***********************************************************************
        !           301: 
        !           302:        C++ source for cfront, the C++ compiler front-end
        !           303:        written in the computer science research center of Bell Labs
        !           304: 
        !           305:        Copyright (c) 1984 AT&T, Inc. All Rights Reserved
        !           306:        THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T, INC.
        !           307: 
        !           308:        When reading cfront code please remember that C++ was not available
        !           309:        when it was originally written. Out of necessity cfront is written
        !           310:        in a style that takes advantage of only few of C++'s features.
        !           311: 
        !           312:        WARNING: This program relies on non-initialized class members being ZERO.
        !           313:        This will be true as long as they are allocated using the "new" operator
        !           314:        from alloc.c
        !           315: 
        !           316: cfront.h:
        !           317: 
        !           318:        Here is all the class definitions for cfront, and most of the externs
        !           319: 
        !           320: ***********************************************************************/
        !           321: 
        !           322: #ifndef _CFRONT_H
        !           323: #define _CFRONT_H
        !           324: 
        !           325: #include "token.h"
        !           326: #include "typedef.h"
        !           327: 
        !           328: #ifndef GRAM
        !           329: extern char* prog_name;                // compiler name and version
        !           330: extern int inline_restr;       // inline expansion restrictions 
        !           331: #endif
        !           332: 
        !           333: extern TOK     tlex();
        !           334: extern Pname   syn();
        !           335: 
        !           336: extern void    ext(int);
        !           337: 
        !           338: extern char*   make_name(TOK);
        !           339: extern void    make_dummy();
        !           340: extern Pname   dummy_fct;
        !           341: extern Pname    really_dominate(Pname, Pname, bit);
        !           342: extern int      exact1(Pname, Ptype);
        !           343: 
        !           344: extern int friend_check(Pclass start,Pclass stop, Pfct f);
        !           345: 
        !           346: struct loc             // a source file location
        !           347: {
        !           348:        short   file;   // index into file_name[], or zero
        !           349:        short   line;
        !           350: #ifndef GRAM
        !           351:        void    put(FILE*);
        !           352:        void    putline();
        !           353: #endif
        !           354: };
        !           355: 
        !           356: extern Loc curloc;
        !           357: extern int curr_file;
        !           358: extern char* src_file_name;
        !           359: extern loc noloc; // dummy null location
        !           360: extern bit binary_val;
        !           361: extern bit stmtno;
        !           362: 
        !           363: struct ea {    // fudge portable printf-like formatting for error()
        !           364:        union {
        !           365:                void* p;
        !           366:                long i;
        !           367:        };
        !           368: 
        !           369:        ea(const void* pp) { p = pp; }
        !           370:        ea(long ii)   { i = ii; }
        !           371:        ea() {}
        !           372: };
        !           373: 
        !           374: extern ea* ea0;
        !           375: 
        !           376: overload error;
        !           377: int error(const char*);
        !           378: int error(const char*, const ea&, const ea& = *ea0, const ea& = *ea0, const ea& = *ea0);
        !           379: int error(int, const char*);
        !           380: int error(int, const char*, const ea&, const ea& = *ea0, const ea& = *ea0, const ea& = *ea0);
        !           381: int error(loc*, const char*, const ea& = *ea0, const ea& = *ea0, const ea& = *ea0, const ea& = *ea0);
        !           382: int error(int, loc*, const char*, const ea& = *ea0, const ea& = *ea0, const ea& = *ea0, const ea& = *ea0);
        !           383: extern char emode;
        !           384: 
        !           385: extern int error_count;
        !           386: extern int vtbl_opt;
        !           387: extern int debug_opt;
        !           388: extern int warning_opt;
        !           389: extern int ansi_opt;
        !           390: extern int strict_opt;
        !           391: extern FILE* out_file;
        !           392: extern FILE* in_file;
        !           393: extern char scan_started;
        !           394: 
        !           395: extern int bl_level;
        !           396: extern Ptable ktbl;            // keywords and typedef names
        !           397: extern Ptable gtbl;            // global names
        !           398: extern Ptable ptbl;            
        !           399: extern Ptable lcl_tbl;
        !           400: extern char* oper_name(TOK);
        !           401: extern Pname def_name;
        !           402: extern Pname pdef_name;
        !           403: extern Pclass ccl;
        !           404: extern Pbase defa_type;
        !           405: extern Pbase moe_type;
        !           406: extern Pbase mptr_type;
        !           407: 
        !           408: #ifndef GRAM
        !           409: extern Pstmt Cstmt;            // current statement, or 0
        !           410: extern Pname Cdcl;             // name currently being declared, or 0
        !           411: 
        !           412: extern Pbase any_type;
        !           413: extern int largest_int;
        !           414: #endif
        !           415: 
        !           416: extern Pbase int_type;
        !           417: extern Pbase char_type;
        !           418: extern Pbase short_type;
        !           419: extern Pbase long_type;
        !           420: extern Pbase uint_type;
        !           421: extern Pbase float_type;
        !           422: extern Pbase double_type;
        !           423: extern Pbase ldouble_type;
        !           424: extern Pbase void_type;
        !           425: 
        !           426: #ifndef GRAM
        !           427: extern Pbase uchar_type;
        !           428: extern Pbase ushort_type;
        !           429: extern Pbase ulong_type;
        !           430: extern Ptype Pchar_type;
        !           431: extern Ptype Pint_type;
        !           432: extern Ptype Pvptr_type;
        !           433: extern Ptype Pfctvec_type;
        !           434: extern Ptype Pvoid_type;
        !           435: extern Pbase zero_type;
        !           436: extern Ptype size_t_type;
        !           437: 
        !           438: extern int byte_offset;
        !           439: extern int bit_offset;
        !           440: extern int max_align;
        !           441: extern int const_save;
        !           442: extern int const_ptr;
        !           443: extern int cm_const_save;
        !           444: extern bit const_problem;
        !           445: #endif
        !           446: 
        !           447: extern Pexpr dummy;    /* the empty expression */
        !           448: extern Pexpr zero;
        !           449: extern Pexpr one;
        !           450: extern Pname sta_name; /* qualifier for unary :: */
        !           451: 
        !           452: #define DEL(p) if (p && (p->permanent==0)) p->del()
        !           453: #define PERM(p) p->permanent=1
        !           454: #define UNPERM(p) p->permanent=0
        !           455: 
        !           456: struct node {
        !           457:        TOK     base;
        !           458:        bit     permanent;
        !           459:         bit     baseclass; // base classes have NAME in their base ...
        !           460: #ifdef DBG
        !           461:        bit     displayed;      // avoid infinite recursion in display functions
        !           462:        bit     allocated;      // set when not on free list
        !           463:        long    id;
        !           464: #endif
        !           465: };
        !           466: #ifdef DBG
        !           467: extern long node_id;
        !           468: extern int Adebug;
        !           469: #define DBID() { node::id = ++::node_id; node::allocated=1; displayed=0; \
        !           470:        if(Adebug>=1)fprintf(stderr,"\n*** allocated %d base %d\n",id,base); }
        !           471: #else
        !           472: #define DBID() /**/
        !           473: #endif
        !           474: 
        !           475: struct table : node {
        !           476: /*     a table is a node only to give it a "base" for debugging */
        !           477:        bit     init_stat;      /* ==0 if block(s) of table not simplified,
        !           478:                                   ==1 if simplified but had no initializers,
        !           479:                                   ==2 if simplified and had initializers.
        !           480:                                */
        !           481:        short   size;
        !           482:        short   hashsize;
        !           483:        short   free_slot;      /* next free slot in entries */
        !           484:        Pname*  entries;
        !           485:        short*  hashtbl;
        !           486:        Pstmt   real_block;     /* the last block the user wrote,
        !           487:                                   not one of the ones cfront created
        !           488:                                */
        !           489:        Ptable  next;           /* table for enclosing scope */
        !           490:        Pname   t_name;         /* name of the table */
        !           491: 
        !           492:        static Ptable table_free;
        !           493:        void* operator new(size_t);
        !           494:        void operator delete(void*,size_t);
        !           495: 
        !           496:        table(short, Ptable, Pname);
        !           497:        ~table();
        !           498: 
        !           499:        Pname   look(char*, TOK);
        !           500:        Pname   insert(Pname, TOK);
        !           501: #ifndef GRAM
        !           502:        void    grow(int);
        !           503:        void    set_name(Pname n)       { t_name = n; };
        !           504:        Pname   get_mem(int);
        !           505:        int     max()                   { return free_slot-1; };
        !           506:        void    dcl_print(TOK,TOK);
        !           507: #endif
        !           508:        void    del();
        !           509: };
        !           510: 
        !           511: #ifndef GRAM
        !           512: extern bit Nold;
        !           513: extern bit vec_const, fct_const;
        !           514: #endif
        !           515: 
        !           516: extern void restore();
        !           517: extern void set_scope(Pname);
        !           518: extern Plist modified_tn;
        !           519: 
        !           520: // local class
        !           521: extern Plist local_tn;
        !           522: extern Plist local_blk;
        !           523: extern Plist local_class;
        !           524: extern void local_hide( Pname ); 
        !           525: extern char *make_local_name(Pclass, int=0);
        !           526: 
        !           527: // nested type
        !           528: extern Plist nested_tn;
        !           529: extern Plist nested_type;
        !           530: extern Pname curr_scope; 
        !           531: extern Pname curr_fct; 
        !           532: extern void nested_hide(Pname); 
        !           533: extern int is_empty(Pclass,bit=0);
        !           534: 
        !           535: extern Pbase start_cl(TOK, Pname, Pbcl);
        !           536: extern void end_cl();
        !           537: extern Pbase end_enum(Pname, nlist*);
        !           538: 
        !           539: /************ types : basic types, aggregates, declarators ************/
        !           540: 
        !           541: #ifndef GRAM
        !           542: extern bit new_type;
        !           543: extern Pname cl_obj_vec;
        !           544: extern Pname eobj;
        !           545: #endif
        !           546: 
        !           547: 
        !           548: #define DEFINED 01     /* definition fed through ?::dcl() */
        !           549: #define SIMPLIFIED 02  /* in ?::simpl() */
        !           550: #define DEF_SEEN 04    /* definition seen, but not processed */
        !           551: #define REF_SEEN 010   /* reference seen (classdef) */
        !           552:                        /*   used for class members in norm.c */
        !           553: #define IN_ERROR 010
        !           554: 
        !           555: struct type : node {
        !           556:        bit     defined;        /* flags DEF_SEEN, DEFINED, SIMPLIFIED, IN_ERROR
        !           557:                                        not used systematically yet
        !           558:                                */
        !           559:        bit     lex_level;
        !           560:        Pclass  in_class;       // nested type
        !           561:        Pname   in_fct;         // local type
        !           562:        char    *lcl;
        !           563:        char    *nested_sig;
        !           564:        char    *signature(char*);
        !           565:        Ptype   tlist;
        !           566:        bit     check(Ptype, TOK);
        !           567: #ifndef GRAM
        !           568:        void    print();
        !           569:        void    dcl_print(Pname);
        !           570:        void    base_print();
        !           571: 
        !           572:        Pname   is_cl_obj();    /* sets cl_obj_vec */
        !           573:        Pptr    is_ref();
        !           574:        Pptr    is_ptr();
        !           575:        Pptr    is_ptr_or_ref();
        !           576:        bit     is_unsigned();
        !           577:        void    dcl(Ptable);
        !           578:        int     tsizeof(int = 0);
        !           579:        bit     tconst();
        !           580:        TOK     set_const(bit);
        !           581:        int     align();
        !           582:        TOK     kind(TOK,TOK);
        !           583:        TOK     integral(TOK oo)        { return kind(oo,'I'); };
        !           584:        TOK     numeric(TOK oo)         { return kind(oo,'N'); };
        !           585:        TOK     num_ptr(TOK oo)         { return kind(oo,'P'); };
        !           586:        bit     vec_type();
        !           587:        Ptype   deref();
        !           588:        inline Pptr     addrof();
        !           589:        Pfct    memptr();
        !           590: #endif
        !           591:        void    del();
        !           592: };
        !           593: 
        !           594: struct enumdef : type {        /* ENUM */
        !           595:        bit     e_body;
        !           596:        short   no_of_enumerators;
        !           597:        unsigned char strlen;   // strlen(string)
        !           598:        char*   string;         // name of enum
        !           599:        Pname   mem;
        !           600:        Pbase   e_type;         // type representing the enum
        !           601:                enumdef(Pname n)        { base=ENUM; mem=n; };
        !           602: #ifndef GRAM
        !           603:        void    print();
        !           604:        void    dcl_print(Pname);
        !           605:        void    dcl(Pname, Ptable);
        !           606:        void    simpl();
        !           607: #endif
        !           608: };
        !           609: 
        !           610: struct velem {
        !           611:        Pname   n;
        !           612:        int     offset;
        !           613: };
        !           614: 
        !           615: struct virt : node {
        !           616:        Pvirt   next;
        !           617:        int     n_init;
        !           618:        velem*  virt_init;      // vector of vtbl initializers (zero-terminated)
        !           619:        Pclass  vclass;         // for class vclass
        !           620:        char*   string;
        !           621:        bit     is_vbase;       // vtable for virtual base
        !           622:        bit     printed;
        !           623:        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;}
        !           624: };
        !           625: 
        !           626: enum { C_VPTR=1, C_XREF=2, C_ASS=4, C_VBASE=8 };
        !           627: 
        !           628: // An enumeration of the types of classes for Objectstore
        !           629: enum class_type_enum { vanilla_class,   // A regular class
        !           630:                        template_class,
        !           631:                        instantiated_template_class,
        !           632:                        uninstantiated_template_class,
        !           633:                        relationship_class,
        !           634:                        defining_class 
        !           635: };
        !           636: class type_extension;
        !           637: 
        !           638: struct classdef : type {       /* CLASS */
        !           639:         class_type_enum  class_base; // An extension of "base" to further define
        !           640:                                 // the real subtype of the class
        !           641:        bit     c_body;         /* print definition only once */
        !           642:        TOK     csu;            /* CLASS, STRUCT, UNION, or ANON */
        !           643:        bit     obj_align;
        !           644:        bit     c_xref;
        !           645:                // 1 set:       has vptr(s) 
        !           646:                // 2 set:       X(X&) exists
        !           647:                // 4 set:       operator=(X&) exists
        !           648:                // 8 set:       has vbaseptr(s)
        !           649:                
        !           650:        bit     virt_count;     // number of virtual functions
        !           651:                                // starting at max base class virt_count in
        !           652:        bit     virt_merge;     // set when no virtual functions, but
        !           653:                                // need to merge virtual base classes
        !           654:        bit     c_abstract;     // abstract class: don't instantiate
        !           655:        bit     has_vvtab;      // set if class has vtable from virtual base
        !           656:        unsigned char strlen;   // strlen(string)
        !           657:        Pbcl    baselist;       // list of base classes
        !           658:        char*   string;         /* name of class */
        !           659:        Pname   mem_list;
        !           660:        Ptable  memtbl;
        !           661:        int     obj_size;
        !           662:        int     real_size;      /* obj_size - alignment waste */
        !           663:        Plist   friend_list;
        !           664:        Pname   pubdef;
        !           665:        Plist   tn_list;        // list of member names hiding type names
        !           666:        Plist   nest_list;      // list of nested types
        !           667:        Ptype   this_type;
        !           668:        Pvirt   virt_list;      // vtbl initializers
        !           669:        Pname   c_ctor;         // constuctor:
        !           670:                                // possibly overloaded, possibly inherited
        !           671:        Pname   c_dtor;         // destructor
        !           672:        Pname   c_itor;         /* constructor X(X&) */
        !           673:        Pname   conv;           /* operator T() chain */
        !           674:        struct toknode *c_funqf, *c_funqr; // token Q for parsing function defs after class def
        !           675: 
        !           676:        classdef(TOK);
        !           677:        ~classdef();
        !           678:        TOK     is_simple()     { return (csu==CLASS)?0:csu; };
        !           679: #ifndef GRAM
        !           680:        void    print();
        !           681:        void    dcl_print(Pname);
        !           682:        void    simpl();
        !           683: 
        !           684:        void    print_members();
        !           685:        void    dcl(Pname, Ptable);
        !           686: 
        !           687: //     bit     has_friend(Pname);
        !           688:        bit     has_friend(Pclass);
        !           689:        bit     has_friend(Pfct);
        !           690: 
        !           691:        bit     has_base(Pclass cl);
        !           692:        bit     baseof(Pname);
        !           693:        bit     baseof(Pclass);
        !           694:        Pclass  is_base(char*);
        !           695: 
        !           696:        Pname   has_oper(TOK);
        !           697:        Pname   has_ctor()      { return c_ctor; }
        !           698:        Pname   has_dtor()      { return c_dtor; }
        !           699:        Pname   has_itor()      { return c_itor; }
        !           700:        Pname   has_ictor();
        !           701:        Pname   make_itor(int);
        !           702:        Pexpr   find_name(char*, Pclass, int=0);
        !           703:        int     do_virtuals(Pvirt, char*, int, bit);
        !           704:        int     all_virt(Pclass, char*, int, bit);
        !           705:        void    add_vtbl(velem*, char*, bit, int);
        !           706:        void    print_all_vtbls(Pclass);
        !           707:        void    print_vtbl(Pvirt);
        !           708:        void    really_print(Pvirt);
        !           709:        int     check_dup(Pclass, TOK);
        !           710:        int     has_allocated_base(Pclass);
        !           711:        char    *has_allocated_base(char*);
        !           712:        int     get_offset(char*);
        !           713:        Pbcl    get_base(char*);
        !           714:        Pexpr   get_vptr_exp(char*);
        !           715:        Pexpr   find_in_base(char*, Pclass);
        !           716:         void    modify_inst_names(char *s); // Adjust ctor names for instantiation
        !           717:         bit     parametrized_class();
        !           718:         bit    same_class(Pclass p);
        !           719: #endif
        !           720: };
        !           721: 
        !           722: #ifndef GRAM
        !           723: 
        !           724: class clist {
        !           725:        Pclass cl;
        !           726:        clist* next;
        !           727: public:
        !           728:        clist(Pclass c, clist* n) { cl=c; next=n; }
        !           729:        int onlist(Pclass);
        !           730:        void clear();
        !           731: };
        !           732:        
        !           733: extern clist * vcllist;
        !           734: 
        !           735: struct vl {
        !           736:        struct vl* next;
        !           737:        Pvirt vt;
        !           738:        classdef* cl;
        !           739: 
        !           740:        vl(classdef* c, Pvirt v, struct vl* n)
        !           741:                { cl = c; vt = v; next = n; }
        !           742: };
        !           743: 
        !           744: extern vl* vlist;
        !           745: 
        !           746: extern int nin;
        !           747: extern int Nvis;
        !           748: extern int Noffset;
        !           749: extern TOK Nvirt;
        !           750: extern Pexpr Nptr;
        !           751: extern Pbcl Nvbc_alloc;
        !           752: extern char *Nalloc_base;
        !           753: extern Pexpr rptr(Ptype,Pexpr,int);
        !           754: extern Pexpr vbase_args(Pfct, Pname);
        !           755: extern Pexpr cdvec(Pname,Pexpr,Pclass,Pname,int,Pexpr,Pexpr=0);
        !           756: 
        !           757: extern Pexpr find(char*, Pclass, int);
        !           758: extern Pexpr find_name(Pname, Pclass, Ptable, int, Pname);
        !           759: extern Pname find_virtual(Pclass,Pname);
        !           760: extern Pname vfct(Pclass, char*);
        !           761: extern int Vcheckerror;
        !           762: extern int ignore_const;       
        !           763: 
        !           764: extern int mex;
        !           765: extern Pclass mec;
        !           766: extern Pclass tcl;
        !           767: #endif
        !           768: 
        !           769: struct basetype : type
        !           770:        /*      ZTYPE CHAR SHORT INT LONG FLOAT DOUBLE
        !           771:                FIELD EOBJ COBJ TYPE ANY
        !           772:        */
        !           773:        /*      used for gathering all the attributes
        !           774:                for a list of declarators
        !           775: 
        !           776:                ZTYPE is the (generic) type of ZERO
        !           777:                ANY is the generic type of an undeclared name
        !           778:        */
        !           779: {
        !           780:        bit     b_unsigned;
        !           781:        bit     b_signed;
        !           782:        bit     b_volatile;
        !           783:        bit     b_const;
        !           784:        bit     b_typedef;
        !           785:        bit     b_inline;
        !           786:        bit     b_virtual;
        !           787:        bit     b_short;
        !           788:        bit     b_long;
        !           789:        bit     b_bits;         /* number of bits in field */
        !           790:        bit     b_offset;       // bit offset of field
        !           791:        TOK     b_sto;          /* AUTO STATIC EXTERN REGISTER 0 */
        !           792:        Pname   b_name;         /* name of non-basic type */
        !           793:        Ptable  b_table;        /* memtbl for b_name, or 0 */
        !           794:        Pname   b_xname;        /* extra name */
        !           795:        union {
        !           796:        Ptype   b_fieldtype;
        !           797:        char*   b_linkage;
        !           798:        };
        !           799: 
        !           800:        basetype(TOK, Pname);
        !           801: 
        !           802:        Pbase   type_adj(TOK);
        !           803:        Pbase   base_adj(Pbase);
        !           804:        Pbase   name_adj(Pname);
        !           805:        Pname   aggr();
        !           806:        Pbase   check(Pname);
        !           807: #ifndef GRAM
        !           808:        void    dcl_print();
        !           809:        Pbase   arit_conv(Pbase);
        !           810:         bit     parametrized_class();
        !           811: #endif
        !           812:        int     discriminator(int); // union discriminator fcn 
        !           813: };
        !           814: 
        !           815: enum Linkage { linkage_default, linkage_C, linkage_Cplusplus };
        !           816: extern Linkage linkage;
        !           817: void set_linkage(char*);
        !           818: 
        !           819: struct fct : type              // FCT
        !           820: {
        !           821:        TOK     nargs;
        !           822:        TOK     nargs_known;    // 0 if unknown, 1 if known, or ELLIPSIS
        !           823:        bit     last_stmt;
        !           824:        bit     f_vdef;         // 1 if this is the first virtual definition
        !           825:                                // of this function
        !           826:        bit     f_inline;       // 1 if inline, 2 if being expanded, else 0
        !           827:        bit     f_const;        // one if member function that may be called for
        !           828:                                // a const object, else 0
        !           829:        bit     f_static;       // 1 if static member function, else 0
        !           830:        short   f_virtual;      // index in virtual table, or 0 meaning non-virtual
        !           831:        short   f_imeasure;     // some measure of the size of an inline function
        !           832:        Ptype   returns;
        !           833:        Pname   argtype;
        !           834:        Ptype   s_returns;
        !           835:        Pname   f_this;
        !           836:        Pclass  memof;          // member of class memof
        !           837:        Pblock  body;
        !           838:        Pname   f_init;         // base and member initializers
        !           839:        Pexpr   f_expr;         // body expanded into an expression
        !           840:        Pexpr   last_expanded;
        !           841:        Pname   f_result;       // extra second argument of type X&
        !           842:        Pname   f_args;         // argument list including args added by cfront
        !           843:        Linkage f_linkage;
        !           844:        char*   f_signature;    // character encoding of function type
        !           845:        Plist local_class;      // list of local classes
        !           846:        static Pfct fct_free;
        !           847:        void*   operator new(size_t);
        !           848:        void    operator delete(void*,size_t);
        !           849: 
        !           850:        fct(Ptype, Pname, TOK);
        !           851:        void    argdcl(Pname,Pname);
        !           852: #ifndef GRAM
        !           853:        Ptype   normalize(Ptype);
        !           854:        void    dcl_print();
        !           855:        void    dcl(Pname);
        !           856:        Pexpr   base_init(Pclass, Pexpr, Ptable, int);
        !           857:        Pexpr   mem_init(Pname, Pexpr, Ptable);
        !           858:        void    init_bases(Pclass, Pexpr);
        !           859:        bit     declared() { return nargs_known; };
        !           860:        void    simpl();
        !           861:        int     ctor_simpl(Pclass, Pexpr);
        !           862:        Pstmt   dtor_simpl(Pclass, Pexpr);
        !           863:        Pexpr   expand(Pname,Ptable,Pexpr);
        !           864:        void    sign();
        !           865: #endif
        !           866:        int     discriminator(int); // union discriminator fcn 
        !           867: };
        !           868: 
        !           869: struct name_list : node {
        !           870:        Pname   f;
        !           871:        Plist   l;
        !           872:         name_list(Pname ff, Plist ll) { base = XNLIST; f=ff; l=ll; };
        !           873: };
        !           874: 
        !           875: #ifndef GRAM
        !           876: struct gen : type {            // OVERLOAD
        !           877:        Plist   fct_list;
        !           878: 
        !           879:        gen() { base = OVERLOAD; }
        !           880:        Pname   add(Pname);
        !           881:        Pname   find(Pfct, bit);
        !           882:        Pname   match(Pname, Pfct, bit);
        !           883: };
        !           884: #endif
        !           885: 
        !           886: struct pvtyp : type {
        !           887:        Ptype typ;
        !           888: };
        !           889: 
        !           890: struct vec : pvtyp             // VEC
        !           891:                                // typ [ dim ]
        !           892: {
        !           893:        Pexpr   dim;
        !           894:        int     size;   
        !           895: 
        !           896:        static Pvec vec_free;
        !           897:        void*   operator new(size_t);
        !           898:        void    operator delete(void*,size_t);
        !           899: 
        !           900:        vec(Ptype t, Pexpr e) { base=VEC; typ=t; dim=e; DBID(); }
        !           901: #ifndef GRAM
        !           902:        Ptype   normalize(Ptype);
        !           903: #endif
        !           904: };
        !           905: 
        !           906: struct ptr : pvtyp             // PTR, RPTR i.e. reference
        !           907: {
        !           908:        Pclass  memof;          // pointer to member of memof: memof::*
        !           909:        bit     rdo;            // "*const"
        !           910: 
        !           911:        static Pptr ptr_free;
        !           912:        void*   operator new(size_t);
        !           913:        void    operator delete(void*,size_t);
        !           914: 
        !           915:        ptr(TOK b, Ptype t) { base=b; typ=t; DBID(); }
        !           916: #ifndef GRAM
        !           917:        Ptype   normalize(Ptype);
        !           918: #endif
        !           919: };
        !           920: 
        !           921: #ifndef GRAM
        !           922: inline Pptr type::addrof() { return new ptr(PTR,this); }
        !           923: 
        !           924: extern bit vrp_equiv;
        !           925: #endif
        !           926: 
        !           927: 
        !           928: /****************************** constants ********************************/
        !           929: 
        !           930:                /* STRING ZERO ICON FCON CCON ID */
        !           931:                /* IVAL FVAL LVAL */
        !           932: 
        !           933: /***************************** expressions ********************************/
        !           934: 
        !           935: #ifndef GRAM
        !           936: extern Pexpr next_elem();
        !           937: extern void new_list(Pexpr);
        !           938: extern void list_check(Pname, Ptype, Pexpr, Ptable=0);
        !           939: extern Pexpr ref_init(Pptr,Pexpr,Ptable);
        !           940: extern Pexpr class_init(Pexpr,Ptype,Pexpr,Ptable);
        !           941: extern Pexpr check_cond(Pexpr, TOK, Ptable);
        !           942: extern Pexpr ptof(Pfct,Pexpr,Ptable);
        !           943: extern void dosimpl(Pexpr, Pname);
        !           944: extern int ref_initializer;
        !           945: extern int ntok;
        !           946: 
        !           947: extern void ptbl_init(int);
        !           948: extern void ptbl_add_pair(char*,char*);
        !           949: extern char *ptbl_lookup(char*);
        !           950: extern char *st_name(char*);
        !           951: #endif
        !           952: 
        !           953: struct expr : node     /* PLUS, MINUS, etc. */
        !           954:        /* IMPORTANT:   all expressions are of sizeof(expr) */
        !           955:        /*      DEREF           =>      *e1 (e2==0) OR e1[e2]
        !           956:                UMINUS          =>      -e2
        !           957:                INCR (e1==0)    =>      ++e2
        !           958:                INCR (e2==0)    =>      e1++
        !           959:                CM              =>      e1 , e2
        !           960:                ILIST           =>      LC e1 RC   (an initializer list)
        !           961:                a Pexpr may denote a name
        !           962:        */
        !           963: {
        !           964:        union {
        !           965:                Ptype   tp;
        !           966:                char    *string4;
        !           967:        };
        !           968:        union {
        !           969:                Pexpr   e1;
        !           970:                long    i1;
        !           971:                char*   string;
        !           972:        };
        !           973:        union {
        !           974:                Pexpr   e2;
        !           975:                int     i2;
        !           976:                char*   string2;
        !           977:                Pexpr   n_initializer;
        !           978:                Ptype   tpdef;  // local and nested typedef info
        !           979:        };
        !           980:        union {                 /* used by the derived classes */
        !           981:                Ptype   tp2;    
        !           982:                Pname   fct_name;
        !           983:                Pexpr   cond;
        !           984:                Pexpr   mem;
        !           985:                Ptype   as_type;
        !           986:                Ptable  n_table;
        !           987:                Pin     il;
        !           988:                Pname   query_this; 
        !           989:        };
        !           990: 
        !           991:        static Pexpr expr_free;
        !           992:        void* operator new(size_t);
        !           993:        void operator delete(void*,size_t);
        !           994:        expr(TOK, Pexpr, Pexpr);
        !           995:        void    del();
        !           996: #ifndef GRAM
        !           997:        void    print();
        !           998:         Pexpr   typ0(Ptable);
        !           999:        Pexpr   typ(Ptable);
        !          1000:        long    eval();
        !          1001:        unsigned long ueval(long,long);
        !          1002:        int     lval(TOK);
        !          1003:        Ptype   call_fct(Ptable);
        !          1004:        Pexpr   address();
        !          1005:        Pexpr   contents();
        !          1006:        void    simpl();
        !          1007:        Pexpr   expand();
        !          1008:        bit     not_simple();
        !          1009:        Pexpr   try_to_overload(Ptable);
        !          1010:        Pexpr   docast(Ptable);
        !          1011:        Pexpr   dovalue(Ptable);
        !          1012:        Pexpr   donew(Ptable);
        !          1013:        void    simpl_new();
        !          1014:        void    simpl_delete();
        !          1015: #endif
        !          1016:        int     discriminator(int); // union discriminator fcn 
        !          1017: };
        !          1018: 
        !          1019: struct texpr : expr {          // CAST NEW VALUE (also ICALL)
        !          1020:        texpr(TOK bb, Ptype tt, Pexpr ee) : expr (bb,ee,0) { tp2=tt; }
        !          1021: };
        !          1022: 
        !          1023: struct cast : expr {           // CAST
        !          1024:        cast(Ptype tt, Pexpr ee) : expr (CAST,ee,0) { tp=tp2=tt; }
        !          1025: };
        !          1026: 
        !          1027: struct ival : expr {           // IVAL
        !          1028:        ival(long ii) : expr (IVAL,0,0) { i1 = ii;}
        !          1029: };
        !          1030: 
        !          1031: struct call : expr {           // CALL
        !          1032:        call(Pexpr aa, Pexpr bb) : expr (CALL,aa,bb) { }
        !          1033: #ifndef GRAM
        !          1034:        void    simpl();
        !          1035:        Pexpr   expand(Ptable);
        !          1036: #endif
        !          1037: };
        !          1038: 
        !          1039: struct qexpr : expr {          // QUEST        cond ? e1 : e2
        !          1040:        qexpr(Pexpr ee, Pexpr ee1, Pexpr ee2) : expr (QUEST,ee1,ee2) { cond=ee; }
        !          1041: };
        !          1042: 
        !          1043: struct ref : expr {            // REF DOT      e1->mem OR e1.mem
        !          1044:        ref(TOK ba, Pexpr a, Pexpr b) : expr (ba,a,0) { mem=b; }
        !          1045: };
        !          1046: 
        !          1047: struct mdot : expr {           // MDOT         a.b
        !          1048:        mdot(char* a, Pexpr b) : expr (MDOT,0,0) { string2=a; mem=b; }
        !          1049: };
        !          1050: 
        !          1051: struct text_expr : expr        {       // TEXT (vtbl_name)
        !          1052:        text_expr(char* a, char* b) : expr (TEXT,0,0)
        !          1053:        { string=a; string2=b; }
        !          1054: };
        !          1055: char* vtbl_name(char*,char*);
        !          1056: /************************* names (are expressions) ****************************/
        !          1057: 
        !          1058: struct basecl : node { // NAME         => base class
        !          1059:                        // VIRTUAL      => virtual base class
        !          1060:        TOK     ppp;            // private / public / protected
        !          1061:        bit     allocated;      // allocated virtual base
        !          1062:         bit     promoted;       // non-explicit, promoted virtual base
        !          1063:        Pclass  bclass;
        !          1064:        Pexpr   init;           // base class initializers for ctors
        !          1065:        int     ptr_offset;     // pointer's relative position in derived class
        !          1066:        int     obj_offset;     // object's relative position in derived class
        !          1067:        Pname*  virt_init;      // vector of vtbl table initializers
        !          1068:        basecl* next;
        !          1069: 
        !          1070:         basecl(Pclass cl, basecl* n) { baseclass=1; bclass=cl; next=n; promoted=0; init=0;}
        !          1071: };
        !          1072: 
        !          1073: enum template_formal_types { 
        !          1074:        template_type_formal =1 , template_expr_formal,
        !          1075:         template_stmt_tree_formal, template_expr_tree_formal,
        !          1076:         template_actual_arg_dummy // used during the parse
        !          1077: };
        !          1078: extern TOK ppbase;
        !          1079: 
        !          1080: struct name : expr {   // NAME TNAME and the keywords in the ktbl
        !          1081:        TOK     n_oper;         // name of operator or 0
        !          1082:        TOK     n_sto;          // EXTERN STATIC AUTO REGISTER ENUM 0
        !          1083:        TOK     n_stclass;      // STATIC AUTO REGISTER 0
        !          1084:        TOK     n_scope;        // EXTERN STATIC FCT ARG PUBLIC 0 
        !          1085:        TOK     n_key;  /* for names in table: class */
        !          1086:        bit     n_evaluated;    // 0 or n_val holds the value
        !          1087:        bit     n_xref;         // argument of type X(X&)
        !          1088:        unsigned char   lex_level;
        !          1089:        TOK     n_protect;      // PROTECTED (<=>n_scope==0) or 0
        !          1090:        bit     n_dcl_printed;  // 1: declaration printed
        !          1091:                                // 2: definition printed
        !          1092:                                // 0: declaration not printed
        !          1093: 
        !          1094:         // if this is set it implies that n_template_arg == template_type_formal
        !          1095:        char    n_template_arg; // One of template_formal_types for template arguments
        !          1096:         bit     n_template_formal_must_be_class ;
        !          1097:         bit     n_redefined ;   // set only for PT function names where an explict
        !          1098:                                 // definition was provided.
        !          1099:         char    *n_anon;       // nested anonymous unions
        !          1100:        short   n_union;        // 0, or union index
        !          1101:        short   n_addr_taken;
        !          1102:        short   n_used;
        !          1103:        short   n_assigned_to;
        !          1104:        Loc     where;
        !          1105:        int     n_offset;       // byte offset in frame or struct
        !          1106:        Pname   n_list;
        !          1107:        Pname   n_tbl_list;
        !          1108:        char    *n_gen_fct_name; // used to be punned with n_tbl_list.
        !          1109:         char    *n_template_arg_string ; // the mangled string name
        !          1110:        union {
        !          1111:        /* 
        !          1112:         * n_qualifier: name of containing class
        !          1113:         * n_realscope: for labels (always entered in function table) 
        !          1114:          *             the table for the actual scope in which label occurred.
        !          1115:         * syn_class: lex table only
        !          1116:         */
        !          1117:                Pname   n_qualifier;    
        !          1118:                 Ptable  n_realscope;    
        !          1119:                int     syn_class; 
        !          1120:         };
        !          1121: 
        !          1122:        /* n_val: the value of n_initializer; also the argument 
        !          1123:         * number for inline arguments (when base == ANAME) */
        !          1124:        long    n_val;          
        !          1125:        static Pname name_free;
        !          1126:        void* operator new(size_t);
        !          1127:        void operator delete(void*,size_t);
        !          1128:        name(char* =0);
        !          1129: 
        !          1130: 
        !          1131:        Pname   normalize(Pbase, Pblock, bit);
        !          1132:        Pname   tdef();
        !          1133:        Pname   tname(TOK);
        !          1134:        void    hide();
        !          1135:        void    unhide()        { n_key=0; n_list=0; };
        !          1136: #ifndef GRAM
        !          1137:        Pname   dcl(Ptable,TOK);
        !          1138:        int     no_of_names();
        !          1139:        void    use()           { n_used++; };
        !          1140:        void    assign();
        !          1141:        void    take_addr();
        !          1142:        void    check_oper(Pname);
        !          1143:        void    simpl();
        !          1144:        void    print();
        !          1145:        void    dcl_print(TOK);
        !          1146:        void    field_align();
        !          1147:        Pname   dofct(Ptable,TOK);
        !          1148: #endif
        !          1149:        void    del();
        !          1150:        int     discriminator(int); // union discriminator fcn 
        !          1151: };
        !          1152: 
        !          1153: extern int friend_in_class;
        !          1154: extern int in_class_dcl;
        !          1155: 
        !          1156: // from parser
        !          1157: extern int in_class_decl;
        !          1158: extern int parsing_class_members;
        !          1159: extern int in_mem_fct;
        !          1160: extern int in_arg_list;
        !          1161: extern Ptype in_typedef;
        !          1162: extern int     defer_check;     // redefinition typedef check delay
        !          1163: extern int     declTag;         // !1: inline, virtual mod permitted
        !          1164: extern Pname in_tag;
        !          1165: extern Pname statStat;
        !          1166: extern int DECL_TYPE;
        !          1167: 
        !          1168: /******************** statements *********************************/
        !          1169: 
        !          1170: struct stmt : node {   /* BREAK CONTINUE DEFAULT */
        !          1171: /*     IMPORTANT: all statement nodes have sizeof(stmt) */
        !          1172:        Pstmt   s;
        !          1173:        Pstmt   s_list;
        !          1174:        Loc     where;
        !          1175:        union {
        !          1176:                Pname   d; // goto/block -- destination
        !          1177:                Pexpr   e2; // for iteration
        !          1178:                Pstmt   has_default; // switch statement default
        !          1179:                int     case_value; 
        !          1180:                Ptype   ret_tp; // pair
        !          1181:        };
        !          1182:        union {
        !          1183:                Pexpr   e;
        !          1184:                bit     own_tbl;
        !          1185:                Pstmt   s2;
        !          1186:        };
        !          1187:        Ptable  memtbl;
        !          1188:        union {
        !          1189:                Pstmt   for_init;
        !          1190:                Pstmt   else_stmt;
        !          1191:                Pstmt   case_list;
        !          1192:                Loc     where2; // location of } at end of block
        !          1193:        };
        !          1194: 
        !          1195:        static Pstmt stmt_free;
        !          1196:        void* operator new(size_t);
        !          1197:        void operator delete(void*,size_t);
        !          1198:        stmt(TOK, loc, Pstmt);
        !          1199:        void    del();
        !          1200: #ifndef GRAM
        !          1201:        void    print();
        !          1202:        void    dcl();
        !          1203:         void    dcl1(Pstmt&);
        !          1204:        void    reached();
        !          1205:        Pstmt   simpl();
        !          1206:        Pstmt   expand();
        !          1207:        Pstmt   copy();
        !          1208: #endif
        !          1209:        int     discriminator(int); // union discriminator fcn 
        !          1210: };
        !          1211: 
        !          1212: #ifndef GRAM
        !          1213: extern char* Neval;
        !          1214: extern Ptable scope;
        !          1215: extern Ptable expand_tbl;
        !          1216: extern Pname expand_fn;
        !          1217: #endif
        !          1218: 
        !          1219: struct estmt : stmt    /* SM WHILE DO SWITCH RETURN CASE */
        !          1220:        /*      SM (e!=0)       =>      e;
        !          1221:                in particular assignments and function calls
        !          1222:                SM (e==0)       =>      ;       (the null statement)
        !          1223:                CASE            =>      case e : s ;
        !          1224:                SM_PARAM        => e is the template_statement_tree_formal name
        !          1225:        */
        !          1226: {
        !          1227:        estmt(TOK t, loc ll, Pexpr ee, Pstmt ss) : stmt (t,ll,ss) { e=ee; }
        !          1228: };
        !          1229: 
        !          1230: struct ifstmt : stmt   /* IF */
        !          1231:        // else_stme==0 =>      if (e) s
        !          1232:        // else_stmt!=0 =>      if (e) s else else_stmt
        !          1233: {
        !          1234:        ifstmt(loc ll, Pexpr ee, Pstmt ss1, Pstmt ss2)
        !          1235:                : stmt (IF,ll,ss1) { e=ee; else_stmt=ss2; };
        !          1236: };
        !          1237: 
        !          1238: struct lstmt : stmt    /* LABEL GOTO */
        !          1239:        /*
        !          1240:                d : s
        !          1241:                goto d
        !          1242:        */
        !          1243: {
        !          1244:        lstmt(TOK bb, loc ll, Pname nn, Pstmt ss) : stmt (bb,ll,ss) { d=nn; }
        !          1245: };
        !          1246: 
        !          1247: struct forstmt : stmt {        // FOR
        !          1248:        forstmt(loc ll, Pstmt fss, Pexpr ee1, Pexpr ee2, Pstmt ss)
        !          1249:                : stmt (FOR,ll,ss) { for_init=fss; e=ee1; e2=ee2; }
        !          1250: };
        !          1251: 
        !          1252: struct block : stmt {  // BLOCK        { d s }
        !          1253:        block(loc ll, Pname nn, Pstmt ss, loc rr = noloc ) : stmt (BLOCK,ll,ss)
        !          1254:                { d=nn; where2=rr; }
        !          1255: #ifndef GRAM
        !          1256:        void    dcl(Ptable);
        !          1257:        Pstmt   simpl();
        !          1258: #endif
        !          1259: };
        !          1260: 
        !          1261: #ifndef GRAM
        !          1262: struct pair : public stmt {    // PAIR
        !          1263:        pair(loc ll, Pstmt a, Pstmt b) : stmt (PAIR,ll,a) { s2 = b; }
        !          1264: };
        !          1265: #endif
        !          1266: 
        !          1267: struct nlist {
        !          1268:        Pname   head;
        !          1269:        Pname   tail;
        !          1270:                nlist(Pname);
        !          1271:        void    add(Pname n)    { tail->n_list = n; tail = n; };
        !          1272:        void    add_list(Pname);
        !          1273: };
        !          1274: 
        !          1275: extern Pname name_unlist(nlist*);
        !          1276: 
        !          1277: struct slist {
        !          1278:        Pstmt   head;
        !          1279:        Pstmt   tail;
        !          1280:                slist(Pstmt s)  { /*Nl++;*/ head = tail = s; };
        !          1281:        void    add(Pstmt s)    { tail->s_list = s; tail = s; };
        !          1282: };
        !          1283: 
        !          1284: extern Pstmt stmt_unlist(slist*);
        !          1285: 
        !          1286: struct elist {
        !          1287:        Pexpr   head;
        !          1288:        Pexpr   tail;
        !          1289:                elist(Pexpr e)  { /*Nl++;*/ head = tail = e; };
        !          1290:        void    add(Pexpr e)    { tail->e2 = e; tail = e; };
        !          1291: };
        !          1292: 
        !          1293: extern Pexpr expr_unlist(elist*);
        !          1294: 
        !          1295: #ifndef GRAM 
        !          1296: extern class dcl_context * cc;
        !          1297: 
        !          1298: struct dcl_context {
        !          1299:        Pname   c_this; /* current fct's "this" */
        !          1300:        Ptype   tot;    /* type of "this" or 0 */
        !          1301:        Pname   not;    /* name of "this"'s class or 0 */
        !          1302:        Pclass  cot;    /* the definition of "this"'s class */
        !          1303:        Ptable  ftbl;   /* current fct's symbol table */
        !          1304:        Pname   nof;    /* current fct's name */
        !          1305: 
        !          1306:        void    stack()         { cc++; *cc = *(cc-1); };
        !          1307:        void    unstack()       { cc--; };
        !          1308: };
        !          1309: 
        !          1310: #define MAXCONT        20
        !          1311: extern dcl_context ccvec[MAXCONT];
        !          1312: #endif 
        !          1313: 
        !          1314: extern void yyerror(char*);
        !          1315: 
        !          1316: 
        !          1317: #ifndef GRAM
        !          1318: extern char* line_format;
        !          1319: 
        !          1320: extern Plist stat_mem_list;
        !          1321: extern Plist isf_list;
        !          1322: extern Pstmt st_ilist;
        !          1323: extern Pstmt st_dlist;
        !          1324: extern Ptable sti_tbl;
        !          1325: extern Ptable std_tbl;
        !          1326: extern int need_sti( Pexpr e, Ptable tbl = 0, bit is_static_ok = 0 ); 
        !          1327: Pexpr try_to_coerce(Ptype, Pexpr, char*, Ptable);
        !          1328: extern bit can_coerce(Ptype, Ptype);
        !          1329: extern Ptype np_promote(TOK, TOK, TOK, Ptype, Ptype, TOK);
        !          1330: extern bit enum_promote;
        !          1331: extern int suppress_error;
        !          1332: extern void delete_local();
        !          1333: 
        !          1334: extern int over_call(Pname, Pexpr);
        !          1335: extern Pname overFound;
        !          1336: extern Pname Nover;
        !          1337: extern Pname Ncoerce;
        !          1338: extern Nover_coerce;
        !          1339: struct ia : node {
        !          1340:        Pname   local;  // local variable for argument
        !          1341:        Pexpr   arg;    // actual arguments for call
        !          1342:        Ptype   tp;     // type of formal argument
        !          1343:         ia() { base = XIA; };
        !          1344: };
        !          1345: 
        !          1346: struct iline : node {
        !          1347:        Pname   fct_name;       /* fct called */
        !          1348:        Pin     i_next;
        !          1349:        Ptable  i_table;
        !          1350:        int     i_slots;        // no of arg slots pointer to by i_args
        !          1351:        ia*     i_args;
        !          1352:         iline() { base = XILINE; };
        !          1353: };
        !          1354: 
        !          1355: extern Pexpr curr_expr;
        !          1356: extern Pin curr_icall;
        !          1357: #define FUDGE111 11111
        !          1358: #define VTOK 22222
        !          1359: #define ITOR 77
        !          1360: 
        !          1361: extern Pstmt curr_loop;
        !          1362: extern Pblock curr_block;
        !          1363: extern Pstmt curr_switch;
        !          1364: extern loc last_line;  // last #line + number of '\n's output since
        !          1365: extern int last_ll;    // 0 or line of current stmt/dcl being printed
        !          1366: extern FILE* out_file; // output file descriptor
        !          1367: extern bit Cast;
        !          1368: extern loc no_where;
        !          1369: 
        !          1370: extern no_of_undcl;
        !          1371: extern no_of_badcall;
        !          1372: extern Pname undcl, badcall;
        !          1373: 
        !          1374: extern long str_to_long(const char*);
        !          1375: extern int c_strlen(const char* s);
        !          1376: #endif
        !          1377: 
        !          1378: #ifndef GRAM
        !          1379: extern Pname vec_new_fct;
        !          1380: extern Pname new_fct;
        !          1381: extern Pname del_fct;
        !          1382: extern Pname vec_del_fct;
        !          1383: 
        !          1384: extern int Nstd; // standard coercion used (derived* =>base* or int=>long or ...)
        !          1385: 
        !          1386: extern int stcount;    // number of names generated using make_name()
        !          1387: 
        !          1388: Pexpr replace_temp(Pexpr,Pexpr);
        !          1389: void make_res(Pfct);
        !          1390: 
        !          1391: extern int Pchecked;
        !          1392: Pexpr ptr_init(Pptr,Pexpr,Ptable);
        !          1393: Pexpr call_ctor(Ptable, Pexpr p, Pexpr ctor, Pexpr args, int d = REF, Pexpr vb_args = 0);
        !          1394: Pexpr call_dtor(Pexpr p, Pexpr dtor, Pexpr arg = 0, int d = DOT, Pexpr vb_args = 0);
        !          1395: void check_visibility(Pname, Pname, Pclass, Ptable, Pname);
        !          1396: 
        !          1397: int make_assignment(Pname);
        !          1398: 
        !          1399: extern Pname make_tmp(char, Ptype, Ptable);
        !          1400: Pexpr init_tmp(Pname, Pexpr, Ptable);
        !          1401: 
        !          1402: extern int is_unique_base(Pclass, char*, int, int = 0);
        !          1403: extern Pexpr rptr(Ptype, Pexpr, int);
        !          1404: 
        !          1405: extern int read_align(char*);
        !          1406: extern void new_init();
        !          1407: 
        !          1408: extern void Eprint(Pexpr);
        !          1409: extern Pexpr cast_cptr(Pclass ccl, Pexpr ee, Ptable tbl, int real_cast);
        !          1410: extern Pexpr mptr_assign(Pexpr,Pexpr);
        !          1411: extern Pclass Mptr;
        !          1412: 
        !          1413: #endif
        !          1414: 
        !          1415: extern bit fake_sizeof;        // suppress error message for ``int v[];''
        !          1416: 
        !          1417: extern TOK lalex();
        !          1418: 
        !          1419: 
        !          1420: #ifdef DBG
        !          1421: extern void display_expr( Pexpr, char* = 0, int = 0 );
        !          1422: extern void display_stmt( Pstmt, char* = 0, int = 0 );
        !          1423: extern void display_type( Ptype );
        !          1424: extern void display_namelist( Plist, char* = 0, int = 0 );
        !          1425: 
        !          1426: extern fprintf(const FILE*, const char* ...);
        !          1427: extern void process_debug_flags( char* );
        !          1428: #define DB(a) if(scan_started){a;}
        !          1429: extern int Adebug; // allocation (ctor/del) debugging
        !          1430: extern int Ddebug; // dcl debugging
        !          1431: extern int Edebug; // expr debugging
        !          1432: extern int Ldebug; // lex/lalex debugging
        !          1433: extern int Mdebug; // trace function matching
        !          1434: extern int Ndebug; // norm debugging
        !          1435: extern int Pdebug; // print debugging
        !          1436: extern int Rdebug; // run() debugging
        !          1437: extern int Sdebug; // simpl debugging
        !          1438: extern int Tdebug; // typ debugging
        !          1439: #define Ydebug yydebug
        !          1440: extern int Ydebug; // yacc debugging
        !          1441: 
        !          1442: #else
        !          1443: 
        !          1444: #define DB(a) /**/
        !          1445: 
        !          1446: #endif
        !          1447: 
        !          1448: #endif
        !          1449: /* end */
        !          1450: 0707071010112043661004440001630000160000010071100466055375100000600000112027dcl.c/*ident      "@(#)ctrans:src/dcl.c   1.5" */
        !          1451: /**************************************************************************
        !          1452: 
        !          1453:        C++ source for cfront, the C++ compiler front-end
        !          1454:        written in the computer science research center of Bell Labs
        !          1455: 
        !          1456:        Copyright (c) 1984 AT&T, Inc. All rights Reserved
        !          1457:        THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T, INC.
        !          1458: 
        !          1459: dcl.c:
        !          1460: 
        !          1461:        ``declare'' all names, that is insert them in the appropriate symbol tables.
        !          1462: 
        !          1463:        Calculate the size for all objects (incl. stack frames),
        !          1464:        and find store the offsets for all members (incl. auto variables).
        !          1465:        "size.h" holds the constants needed for calculating sizes.
        !          1466: 
        !          1467:        Note that (due to errors) functions may nest
        !          1468: 
        !          1469: *****************************************************************************/
        !          1470: 
        !          1471: 
        !          1472: #include "cfront.h"
        !          1473: #include "size.h"
        !          1474: 
        !          1475: class dcl_context ccvec[MAXCONT], * cc = ccvec;
        !          1476: int byte_offset;
        !          1477: int bit_offset;
        !          1478: int max_align;
        !          1479: int friend_in_class;
        !          1480: static Pstmt itail;
        !          1481: 
        !          1482: Pname dclass(Pname, Ptable);
        !          1483: Pname denum(Pname, Ptable);
        !          1484: void merge_init(Pname, Pfct, Pfct);
        !          1485: 
        !          1486: void dosimpl(Pexpr e, Pname n)
        !          1487: {
        !          1488: //error('d',"dosimpl %k %n",e?e->base:0,n);
        !          1489:        if (n==0) {
        !          1490:                if (dummy_fct == 0) make_dummy();
        !          1491:                n = dummy_fct;
        !          1492:        }
        !          1493:        Pname cf = curr_fct;
        !          1494:        curr_fct = n;
        !          1495:        e->simpl();
        !          1496:        curr_fct = cf;
        !          1497: }
        !          1498: 
        !          1499: static Pexpr co_array_init(Pname n, Ptable tbl)
        !          1500: /*
        !          1501:        handle simple arrays only. To be done well list_check() must
        !          1502:        be rewritten to handle dynamic initialization.
        !          1503: */
        !          1504: {
        !          1505: // error('d',"Ir forCO%n\[\]",n);
        !          1506:        Pexpr init = n->n_initializer;
        !          1507: 
        !          1508:        if (init->base != ILIST) {
        !          1509:                error("badIr for array ofCOs %n",n);
        !          1510:                return 0;
        !          1511:        }
        !          1512: 
        !          1513:        Pexpr el = 0;
        !          1514:        Pvec v = Pvec(n->tp);
        !          1515:        while (v->base==TYPE) v = Pvec(Pbase(v)->b_name->tp);
        !          1516:        Pname cn = v->typ->is_cl_obj();
        !          1517:        Pclass cl = cn ? Pclass(cn->tp) : 0;
        !          1518: //error('d',"v %t cl %d %t",v,cl,cl);
        !          1519:        int i = v->size;
        !          1520: 
        !          1521:        int count = 0;
        !          1522:        Pexpr il2;
        !          1523:        for (Pexpr il = init->e1; il; il = il2) {
        !          1524:                        // generate     n[0].cl(initializer),
        !          1525:                        //              ...
        !          1526:                        //              n[max].cl(initializer),
        !          1527:                Pexpr e = il->e1;
        !          1528:                il2 = il->e2;
        !          1529:                il->e2 = 0;
        !          1530:                if  (e == dummy) break;
        !          1531: //error('d',"il %k e %k",il->base,e?e->base:0);
        !          1532:                if (e->base == VALUE) {
        !          1533:                        switch (e->tp2->base) {
        !          1534:                        case CLASS:
        !          1535:                                if (Pclass(e->tp2)!=cl) e = new texpr(VALUE,cl,il);
        !          1536:                                break;
        !          1537:                        default:
        !          1538:                                Pname n2 = e->tp2->is_cl_obj();
        !          1539:                                if (n2==0 || Pclass(n2->tp)!=cl) e = new texpr(VALUE,cl,il);
        !          1540:                        }
        !          1541:                }
        !          1542:                else
        !          1543:                        e = new texpr(VALUE,cl,il);
        !          1544:                e->e2 = new expr(DEREF,n,new ival(count++));
        !          1545:                e = e->typ(tbl);
        !          1546:                dosimpl(e,cc->nof);
        !          1547:        //      e->simpl();
        !          1548:                if (sti_tbl == tbl) {
        !          1549:                        Pstmt ist = new estmt(SM,no_where,e,0);
        !          1550:                        if (st_ilist == 0)
        !          1551:                                st_ilist = ist;
        !          1552:                        else
        !          1553:                                itail->s_list = ist;
        !          1554:                        itail = ist;
        !          1555:                }
        !          1556:                else {
        !          1557:                        el = el ? new expr(G_CM,el,e) : e;
        !          1558:                }
        !          1559:        }
        !          1560: 
        !          1561:        if (i==0)
        !          1562:                v->size = count;
        !          1563:        else if (i==count)
        !          1564:                ;
        !          1565:        else if (i<count) {
        !          1566:                 error("too manyIrs for%n (%d)",n, count);
        !          1567:                return 0;
        !          1568:        }       
        !          1569:        else {
        !          1570: //              error('d',"too fewIrs for%n (%d)",n, count);
        !          1571:                if (cl->has_ictor())
        !          1572:                        error('s',"too fewIrs for%n",n);
        !          1573:                else error( "too fewIrs for%n (C %srequires a defaultK)", n, cl->string );
        !          1574:                return 0;
        !          1575:        }
        !          1576:        return el;
        !          1577: }
        !          1578: 
        !          1579: int need_sti(Pexpr e, Ptable tbl, bit accept_name)
        !          1580: /*
        !          1581:        check if non-static variables or operations are used
        !          1582:        INCOMPLETE 
        !          1583: */
        !          1584: {
        !          1585:        if (e == 0) return 0;
        !          1586: // error('d',"need_sti: %d - %d %k %t",tbl?1:0,accept_name,e->base,e->tp);
        !          1587: 
        !          1588:        switch (e->base) {
        !          1589:        case QUEST:
        !          1590:                if (need_sti(e->cond,tbl,0) && tbl==0) return 1;
        !          1591:        case PLUS:
        !          1592:        case MINUS:
        !          1593:        case MUL:
        !          1594:        case DIV:
        !          1595:        case MOD:
        !          1596:        case ER:
        !          1597:        case OR:
        !          1598:        case ANDAND:
        !          1599:        case OROR:
        !          1600:        case LS:
        !          1601:        case RS:
        !          1602:        case EQ:
        !          1603:        case NE:
        !          1604:        case LT:
        !          1605:        case LE:
        !          1606:        case GT:
        !          1607:        case GE:
        !          1608:        case INCR:
        !          1609:        case DECR:
        !          1610:        case ASSIGN:
        !          1611:                if (need_sti(e->e1,tbl,accept_name) && tbl==0) return 1;
        !          1612:                // no break;
        !          1613: 
        !          1614:        case UMINUS:
        !          1615:        case UPLUS:
        !          1616:        case NOT:
        !          1617:        case COMPL:
        !          1618:                if (need_sti(e->e2,tbl,accept_name) && tbl==0) return 1;
        !          1619:                // no break
        !          1620: 
        !          1621:        case SIZEOF:
        !          1622:        default:
        !          1623: 
        !          1624:                return 0;
        !          1625: 
        !          1626:        case CAST:
        !          1627: 
        !          1628:                return need_sti(e->e1,tbl,accept_name);
        !          1629: 
        !          1630:        case ADDROF:
        !          1631:        {
        !          1632:                int i = need_sti(e->e2,tbl,1);
        !          1633:                return i;
        !          1634:        }
        !          1635: 
        !          1636:        case NAME:
        !          1637:                if (accept_name && Pname(e)->n_stclass==STATIC) return 0;
        !          1638: 
        !          1639: //             if ((Pname(e)->n_stclass==AUTO || Pname(e)->n_stclass==REGISTER)
        !          1640: //             &&   strncmp(Pname(e)->string,"__Q",3) != 0 ) {
        !          1641: //                     error("localN%n inIr for static",e);
        !          1642: //                     return 0;
        !          1643: //             }
        !          1644: 
        !          1645:                if (e->tp->tconst()) {
        !          1646:                        if (vec_const || fct_const) return 0;
        !          1647:                        Neval = 0;
        !          1648:                        e->eval();
        !          1649:                        if (Neval == 0) return 0;
        !          1650:                }
        !          1651:                return 1;
        !          1652: 
        !          1653:        case DEREF:
        !          1654:        case REF:
        !          1655:        case DOT:
        !          1656:                if (accept_name||(e->tp && e->tp->base==VEC)) {
        !          1657:                        int x1 = need_sti(e->e1,tbl,e->base == DOT);
        !          1658:                        int x2 = need_sti(e->e2,tbl,0);
        !          1659:                        return x1 || x2;
        !          1660:                }
        !          1661:                // no break
        !          1662: 
        !          1663:        case ELIST:
        !          1664: //     case ILIST:
        !          1665:        case G_CM:
        !          1666:        case CM:
        !          1667:                if (e->base==CM) {
        !          1668:                        if (need_sti(e->e1,tbl,0) || need_sti(e->e2,tbl,0))
        !          1669:                                return 1;
        !          1670:                        else
        !          1671:                                return 0;
        !          1672:                }
        !          1673:        case CALL:
        !          1674:        case G_CALL:
        !          1675:        case NEW:
        !          1676:        case GNEW:
        !          1677:        case 0:                 // hack for `new type (expr)'
        !          1678:                if (tbl) {
        !          1679:                        need_sti(e->e1,tbl,accept_name);
        !          1680:                        need_sti(e->e2,tbl,accept_name);
        !          1681:                        if ( e->tp && e->tp->base == VEC &&
        !          1682:                                e->base == NEW || e->base == GNEW )
        !          1683:                                // preserve ICON,STRING,CCON,FCON
        !          1684:                                need_sti(Pvec(e->tp)->dim,tbl);
        !          1685:                }
        !          1686:                 else if (e->base == 0)
        !          1687:                       return 0;
        !          1688:                // no break
        !          1689:        case ICALL:
        !          1690:                return 1;
        !          1691:        case ICON:
        !          1692:        case STRING:
        !          1693:        case CCON:
        !          1694:        case FCON:
        !          1695: //error('d',"save %k tbl %d",e->base,tbl);
        !          1696:                if (tbl) {
        !          1697:                        char* p = new char[strlen(e->string)+1];
        !          1698:                        strcpy(p,e->string);
        !          1699:                        e->string = p;
        !          1700:                }
        !          1701:                return 0;
        !          1702:        }
        !          1703: }
        !          1704: 
        !          1705: static void check_def_name( Pname nn, int scope ) 
        !          1706: {
        !          1707: // error('d', "check_def_name: nn: %n n_sto: %k scope: %k", nn,nn->n_sto,scope );
        !          1708:        if ( def_name==0 && pdef_name==0 && friend_in_class == 0 &&
        !          1709:                scope == EXTERN && nn->n_scope != STATIC &&  
        !          1710:                nn->n_oper != NEW && nn->n_oper != DELETE ) { 
        !          1711:                        Pfct f = Pfct(nn->tp);
        !          1712:                        if (f->body && 
        !          1713:                                f->f_inline == 0 && 
        !          1714:                                f->f_imeasure == 0) {
        !          1715: // error('d', "check_def_name: do it: %n", nn );
        !          1716:                                        pdef_name = def_name = nn;
        !          1717:                                        ptbl_init(0);
        !          1718:                                        def_name = 0;
        !          1719:                        }
        !          1720:        }
        !          1721: }
        !          1722: 
        !          1723: int stat_init = 0; // in an expression initializing a local static
        !          1724: Pname name::dcl(Ptable tbl, TOK scope)
        !          1725: /*
        !          1726:        enter a copy of this name into symbol table "tbl";
        !          1727:                - create local symbol tables as needed
        !          1728:        
        !          1729:        "scope" gives the scope in which the declaration was found
        !          1730:                - EXTERN, FCT, ARG, PUBLIC, or 0
        !          1731:        Compare "scope" with the specified storage class "n_sto"
        !          1732:                - AUTO, STATIC, REGISTER, EXTERN, OVERLOAD, FRIEND, or 0
        !          1733: 
        !          1734:        After name::dcl()
        !          1735:        n_stclass ==    0               class or enum member
        !          1736:                        REGISTER        auto variables declared register
        !          1737:                        AUTO            auto variables not registers
        !          1738:                        STATIC          statically allocated object
        !          1739:        n_scope ==      0               private class member
        !          1740:                        PUBLIC          public class member
        !          1741:                        EXTERN          name valid in this and other files
        !          1742:                        STATIC          name valid for this file only
        !          1743:                        FCT             name local to a function
        !          1744:                        ARG             name of a function argument
        !          1745:                        ARGT            name of a type defined in an
        !          1746:                                        argument list
        !          1747:                         ARGS            temporary class object with dtor in
        !          1748:                                         initialization of a local static
        !          1749: 
        !          1750: 
        !          1751:        typecheck function bodies;
        !          1752:        typecheck initializers;
        !          1753: 
        !          1754:        note that functions (error recovery) and classes (legal) nest
        !          1755: 
        !          1756:        The return value is used to chain symbol table entries, but cannot
        !          1757:        be used for printout because it denotes the sum of all type information
        !          1758:        for the name
        !          1759: 
        !          1760:        names of typenames are marked with n_oper==TNAME
        !          1761: 
        !          1762:        WARNING: The handling of scope and storage class is cursed!
        !          1763: */
        !          1764: {
        !          1765:        Pname nn;
        !          1766:        Ptype nnt = 0;
        !          1767:        Pname odcl = Cdcl;
        !          1768:        int sti_vb = 0; // set if initialize with virtual base class
        !          1769: 
        !          1770: //     if (this == 0) error('i',"0->N::dcl()");
        !          1771: //     if (tbl == 0) error('i',"%n->N::dcl(tbl=0,%k)",this,scope);
        !          1772: //     if (tbl->base != TABLE) error('i',"%n->N::dcl(tbl=%d,%k)",this,tbl->base,scope);
        !          1773: //     if (tp == 0) error('i',"N::dcl(%n,%k)T missing",this,scope);
        !          1774: 
        !          1775:        Cdcl = this;
        !          1776:        Ptype tx = tp;
        !          1777: 
        !          1778:        DB( if(Ddebug>=1) error('d',"dcl %n %t",this,tx); );
        !          1779: // error('d',"dcl %n %t cc->cot: %d",this,tx,cc?cc->cot:0); 
        !          1780:        while (tx->base == TYPE) tx = Pbase(tx)->b_name->tp;
        !          1781: 
        !          1782:        switch (base) {
        !          1783:        case TNAME:
        !          1784:                nn = tbl->look(string,0);
        !          1785:                tp->dcl(tbl);
        !          1786:                 if (nn && nn->lex_level == lex_level) {
        !          1787: //error('d', "dcl: cot: %s ccl: %s", cc->cot?cc->cot->string:"notset", ccl?ccl->string:"notset");
        !          1788: 
        !          1789:                         if ( tp->check(nn->tp,0) )
        !          1790:                                 error("%n declared as %t and %t",nn,nn->tp,tp);
        !          1791:                         else if ( nn->base == NAME && cc->cot == 0 &&
        !          1792:                        (tp->base != COBJ || tp->base != EOBJ))
        !          1793:                                 error("%n declared as identifier and typedef", nn );
        !          1794:                         Cdcl = odcl;
        !          1795:                         return 0;
        !          1796: 
        !          1797:                 }
        !          1798:                PERM(tp);
        !          1799:                nn = new name(string);
        !          1800:                nn->base = TNAME;
        !          1801:                nn->tp = tp;
        !          1802:                Pname tn = tbl->insert(nn,0);
        !          1803:                if (n_key == NESTED) {
        !          1804:                        tn->n_key = NESTED;
        !          1805:                        tn->tpdef = tpdef;
        !          1806:                }
        !          1807:                delete nn;
        !          1808:                Cdcl = odcl;
        !          1809:                return this;
        !          1810:        
        !          1811:        case NAME:
        !          1812:                switch (n_oper) {
        !          1813:                case COMPL:
        !          1814:                        if (tp->base != FCT) {
        !          1815:                                error("~%s notF",string);
        !          1816:                                n_oper = 0;
        !          1817:                        }
        !          1818:                        break;
        !          1819:                case TNAME:
        !          1820:                        if (tp->base != FCT) n_oper = 0;
        !          1821:                        break;
        !          1822:                }
        !          1823:                break;
        !          1824:        default:
        !          1825:                error('i',"NX in N::dcl()");
        !          1826:        }
        !          1827: 
        !          1828:        if (n_qualifier) {      
        !          1829:                                // c::f()
        !          1830:                                // class function,
        !          1831:                                // friend declaration, or 
        !          1832:                                // static member initializer
        !          1833:                Pname cn = n_qualifier;
        !          1834: 
        !          1835:                switch (cn->base) {
        !          1836:                case TNAME:
        !          1837:                        break;
        !          1838:                case NAME:
        !          1839:                        cn = gtbl->look(cn->string,0);
        !          1840:                        if (cn && cn->base==TNAME) break;
        !          1841:                default:
        !          1842:                        error("badQr%n for%n",n_qualifier,this);
        !          1843:                        Cdcl = odcl;
        !          1844:                        return 0;
        !          1845:                }
        !          1846: 
        !          1847:                while (cn->tp->base == TYPE) cn->tp = Pbase(cn->tp)->b_name->tp;
        !          1848: // error('d',"actualQr%n %t",cn,cn->tp);
        !          1849:                if (cn->tp->base != COBJ) {
        !          1850:                        error(&where,"Qr%nnot aCN",n_qualifier);
        !          1851:                        Cdcl = odcl;
        !          1852:                        return 0;
        !          1853:                }
        !          1854: 
        !          1855:                cn = Pbase(cn->tp)->b_name;
        !          1856:                if (n_oper) check_oper(cn);
        !          1857: 
        !          1858:                Pclass cl = Pclass(cn->tp);
        !          1859:                if (cl == cc->cot) {
        !          1860:                        n_qualifier = 0;
        !          1861:                        goto xdr;
        !          1862:                }
        !          1863:                else if ((cl->defined&(DEFINED|SIMPLIFIED)) == 0) {
        !          1864:                        error("C%nU",cn);
        !          1865:                        Cdcl = odcl;
        !          1866:                        return 0;
        !          1867:                }
        !          1868:                else if (cl->c_body==1) //III
        !          1869:                        cl->dcl_print(0);
        !          1870: 
        !          1871:                Ptable etbl = cl->memtbl;
        !          1872:                Pname x = etbl->look(string,0);
        !          1873:                if (x==0 || x->n_table!=etbl) {
        !          1874:                        error("%n is not aM of%n",this,cn);
        !          1875:                        Cdcl = odcl;
        !          1876:                        return 0;
        !          1877:                }
        !          1878: 
        !          1879:                if (tp->base == FCT) {  //III
        !          1880:                //      if (friend_in_class==0 && Pfct(tp)->body==0) {  // c::f(); needed for friend
        !          1881:                        if (friend_in_class==0
        !          1882:                        && n_sto!=FRIEND
        !          1883:                        && Pfct(tp)->body==0) { // c::f(); needed for friend
        !          1884:                                error("QdN%n inFD",x);
        !          1885:                                Cdcl = odcl;
        !          1886:                                return 0;
        !          1887:                        }
        !          1888: 
        !          1889:                        if (Pfct(tp)->body==0) {
        !          1890:                                Pfct(tp)->memof = cl;
        !          1891:                                int xx;
        !          1892:                                if (x->tp->base==OVERLOAD)
        !          1893:                                        xx = Pgen(x->tp)->find(Pfct(tp),0)==0;
        !          1894:                                else
        !          1895:                                        xx = x->tp->check(tp,0);
        !          1896: 
        !          1897:                                if (xx) {
        !          1898:                                        error("%n is not aM of%n",this,cn);
        !          1899:                                        Cdcl = odcl;
        !          1900:                                        return 0;
        !          1901:                                }
        !          1902:                        }
        !          1903:                }
        !          1904:                else {
        !          1905:                        if (x->n_stclass != STATIC) {   // e.g. int c::i = 7
        !          1906:                                error("D of non staticCM %n",this);
        !          1907:                                Cdcl = odcl;
        !          1908:                                return 0;
        !          1909:                        }
        !          1910:                        if (n_sto) error("staticCM declared%k",n_sto);
        !          1911:                        tbl = etbl;
        !          1912:                }
        !          1913:        }
        !          1914: xdr:
        !          1915:        if (n_oper
        !          1916:        && tp->base!=FCT
        !          1917:        && n_sto!=OVERLOAD) error("operator%k not aF",n_oper);
        !          1918: 
        !          1919: 
        !          1920:        /*      if a storage class was specified
        !          1921:                        check that it is legal in the scope 
        !          1922:                else
        !          1923:                        provide default storage class
        !          1924:                some details must be left until the type of the object is known
        !          1925:        */
        !          1926: 
        !          1927:        n_stclass = n_sto;
        !          1928:        n_scope = scope;        /* default scope & storage class */
        !          1929: 
        !          1930:        switch (n_sto) {
        !          1931:        default:
        !          1932:                error('i',"unX %k",n_sto);
        !          1933:        case FRIEND:
        !          1934:        {
        !          1935:                Pclass cl = cc->cot;
        !          1936: 
        !          1937:                switch (scope) {
        !          1938:                case 0:
        !          1939:                case PUBLIC:
        !          1940:                        break;
        !          1941:                default:
        !          1942:                        error("friend%n not inCD(%k)",this,scope);
        !          1943:                        base = 0;
        !          1944:                        Cdcl = odcl;
        !          1945:                        return 0;
        !          1946:                }
        !          1947: 
        !          1948:                switch (n_oper) {
        !          1949:                case 0:
        !          1950:                case NEW:
        !          1951:                case DELETE:
        !          1952:                case CTOR:
        !          1953:                case DTOR:
        !          1954:                case TYPE:
        !          1955:                        n_sto = 0;
        !          1956:                        break;
        !          1957:                default:
        !          1958:                        n_sto = OVERLOAD;
        !          1959:                }
        !          1960: 
        !          1961:                switch (tx->base) {
        !          1962:                case COBJ:
        !          1963:                        nn = Pbase(tx)->b_name;
        !          1964:                        break;
        !          1965:                case CLASS:
        !          1966:                        nn = this;
        !          1967:                        break;
        !          1968:                case FCT:
        !          1969:                        cc->stack();
        !          1970:                        cc->not = 0;
        !          1971:                        cc->tot = 0;
        !          1972:                        cc->cot = 0;
        !          1973:                        friend_in_class++;
        !          1974:                //      n_sto = EXTERN;
        !          1975:                        n_sto = 0;
        !          1976:                        nn = dcl(gtbl,EXTERN);
        !          1977:                        if (nn == 0) {
        !          1978:                                Cdcl = odcl;
        !          1979:                                return 0;
        !          1980:                        }
        !          1981:                        friend_in_class--;
        !          1982:                        cc->unstack();
        !          1983:                        if (nn->tp->base == OVERLOAD) nn = Pgen(nn->tp)->find(Pfct(tx),1);
        !          1984:                        break;
        !          1985:                default:
        !          1986:                        error("badT%tof friend%n",tp,this);
        !          1987:                        Cdcl = odcl;
        !          1988:                        return 0;
        !          1989:                }
        !          1990:                PERM(nn);
        !          1991:                cl->friend_list = new name_list(nn,cl->friend_list);
        !          1992:                Cdcl = odcl;
        !          1993:                return nn;
        !          1994:        }
        !          1995:        case OVERLOAD:
        !          1996:                if (strict_opt||warning_opt)
        !          1997:                        error(strict_opt?0:'w',"`overload' used (anachronism)");
        !          1998:                n_sto = 0;
        !          1999:                // ignore overload!
        !          2000:                switch (tp->base) {
        !          2001:                case FCT:
        !          2002:                        break;
        !          2003:                default:
        !          2004:                        base = 0;
        !          2005:                        Cdcl = odcl;
        !          2006:                        return this;
        !          2007:                }
        !          2008:                break;
        !          2009:        case REGISTER:
        !          2010:                if (tp->base == FCT) {
        !          2011:                        error('w',"%n: register (ignored)",this);
        !          2012:                        goto ddd;
        !          2013:                }
        !          2014:        case AUTO:
        !          2015:                switch (scope) {
        !          2016:                case 0:
        !          2017:                case PUBLIC:
        !          2018:                case EXTERN:
        !          2019:                        error("%k not inF",n_sto);
        !          2020:                        goto ddd;
        !          2021:                }
        !          2022:                if (n_sto==AUTO) n_sto = 0;     // always redundant
        !          2023:                break;
        !          2024:        case EXTERN:
        !          2025:                switch (scope) {
        !          2026:                case ARG:
        !          2027:                        //error("externA");
        !          2028:                        goto ddd;
        !          2029:                case 0:
        !          2030:                case PUBLIC:
        !          2031:                        /* extern is provided as a default for functions without body */
        !          2032:                        if (tp->base != FCT) error("externM%n",this);
        !          2033:                        goto ddd;
        !          2034:                case FCT:
        !          2035:                        {
        !          2036:                        Pname nn = gtbl->look( string, 0 );
        !          2037:                        tp->dcl(tbl);
        !          2038:                        if ( nn && tp->base != FCT &&
        !          2039:                                tp->check(nn->tp,0)) 
        !          2040:                                {
        !          2041:                                error("twoDs of%n;Ts:%t and%t",this,nn->tp,tp);
        !          2042:                                Cdcl = odcl;
        !          2043:                                return 0;
        !          2044:                                }
        !          2045:                        }
        !          2046:                }
        !          2047:                n_stclass = STATIC;
        !          2048:                n_scope = EXTERN;       /* avoid FCT scoped externs to allow better checking */
        !          2049:                break;
        !          2050:        case STATIC:
        !          2051:                switch (scope) {
        !          2052:                case ARG:
        !          2053:                        //error("static used forA%n",this);
        !          2054:                        goto ddd;
        !          2055:                case 0:
        !          2056:                case PUBLIC:
        !          2057:                        n_stclass = STATIC;
        !          2058:                        n_scope = scope;
        !          2059:                        break;
        !          2060:                default:
        !          2061:                        n_scope = STATIC;
        !          2062:                }
        !          2063:                break;
        !          2064:        case 0:
        !          2065:        ddd:
        !          2066:                switch (scope) {        /* default storage classes */
        !          2067:                case EXTERN:
        !          2068:                        n_scope = EXTERN;
        !          2069:                        n_stclass = STATIC;
        !          2070:                        break;
        !          2071:                case FCT:
        !          2072:                        if (tp->base == FCT) {
        !          2073:                                n_stclass = STATIC;
        !          2074:                                n_scope = EXTERN;
        !          2075:                        }
        !          2076:                        else
        !          2077:                                n_stclass = AUTO;
        !          2078:                        break;
        !          2079:                case ARG:
        !          2080:                        n_stclass = AUTO;
        !          2081:                        break;
        !          2082:                case 0:
        !          2083:                case PUBLIC:
        !          2084:                        n_stclass = 0;
        !          2085:                        break;
        !          2086:                }
        !          2087:        }
        !          2088: 
        !          2089:        
        !          2090:        /*
        !          2091:                now insert the name into the appropriate symbol table,
        !          2092:                and compare types with previous declarations of that name
        !          2093: 
        !          2094:                do type dependent adjustments of the scope
        !          2095:        */
        !          2096: //error('d',"sw %d",tx->base);
        !          2097:        static int warn_ldouble=0;
        !          2098: 
        !          2099:        switch (tx->base) {
        !          2100:        case ASM:
        !          2101:        {       Pbase b = Pbase(tp);
        !          2102:                Pname n = tbl->insert(this,0);
        !          2103:                n->assign();
        !          2104:                n->use();
        !          2105:                char* s = (char*) b->b_name;    // save asm string. Shoddy
        !          2106:                int ll = strlen(s);
        !          2107:                char* s2 = new char[ll+1];
        !          2108:                strcpy(s2,s);
        !          2109:                b->b_name = Pname(s2);
        !          2110:                Cdcl = odcl;
        !          2111:                return this;
        !          2112:        }
        !          2113: 
        !          2114:        case CLASS:
        !          2115:                tp = tx;
        !          2116:                nn = dclass(this,tbl);
        !          2117:                Cdcl = odcl;
        !          2118:                return nn;
        !          2119: 
        !          2120:        case ENUM:
        !          2121:                tp = tx;
        !          2122:                nn = denum(this,tbl);
        !          2123:                Cdcl = odcl;
        !          2124:                return nn;
        !          2125:        
        !          2126:        case FCT:
        !          2127:                tp = tx;
        !          2128:                nn = dofct(tbl,scope);
        !          2129:                if (nn == 0) {
        !          2130:                        Cdcl = odcl;
        !          2131:                        return 0;
        !          2132:                }
        !          2133: 
        !          2134: // error('d', "%s n_oper: %k, scope: %k", string, n_oper, scope );
        !          2135:                if (pdef_name == 0) check_def_name(nn, scope);
        !          2136:                break;
        !          2137: 
        !          2138:        case FIELD:
        !          2139:                switch (n_stclass) {
        !          2140:                case 0:
        !          2141:                case PUBLIC:
        !          2142:                        break;
        !          2143:                default:
        !          2144:                        error("%k field",n_stclass);
        !          2145:                        n_stclass = 0;
        !          2146:                }
        !          2147: 
        !          2148:                if (cc->not==0 || cc->cot->csu==UNION || cc->cot->csu==ANON) {
        !          2149:                        error(cc->not?"field in union":"field not inC");
        !          2150:                        PERM(tp);
        !          2151:                        Cdcl = odcl;
        !          2152:                        return this;
        !          2153:                }
        !          2154: 
        !          2155:                if (string) {
        !          2156:                        nn = tbl->insert(this,0);
        !          2157:                        n_table = nn->n_table;
        !          2158:                        if (Nold) error("twoDs of field%n",this);
        !          2159:                }
        !          2160: 
        !          2161:                tp->dcl(tbl);
        !          2162:                field_align();
        !          2163:                break;
        !          2164:        
        !          2165:        case COBJ:
        !          2166:        {       Pclass cl = Pclass(Pbase(tx)->b_name->tp);
        !          2167: //error('d',&where,"dcl %n; tx->base == cobj",this);
        !          2168:                if (cl->lex_level > lex_level) 
        !          2169:                        error("C%t is not visible in this scope",cl);
        !          2170: 
        !          2171:                if (cl->csu == ANON) {  // export member names to enclosing scope
        !          2172:                         if (tbl==gtbl && n_sto!=STATIC) error("extern anonymous union (declare as static)");
        !          2173:                        char* p = cl->string;
        !          2174:                        while (*p++ != 'C');    /* sneaky */
        !          2175:                        int uindex = (int)str_to_long(p);
        !          2176: 
        !          2177: // error('d', "%n->dcl() n_scope: %k n_protect: %k", this, n_scope, n_protect );
        !          2178:                // cannot cope with use counts for ANONs:
        !          2179:                        Pbase(tp)->b_name->n_used = 1;
        !          2180:                        Pbase(tp)->b_name->n_assigned_to = 1;
        !          2181: 
        !          2182:                        Ptable mtbl = cl->memtbl;
        !          2183:                         int i, err_msg = 0;
        !          2184:                        for (Pname nn=mtbl->get_mem(i=1); nn; nn=mtbl->get_mem(++i)) {
        !          2185:                                if (nn->tp->base == FCT) {
        !          2186:                                        error("FM%n for anonymous union",nn);
        !          2187:                                        break;
        !          2188:                                }
        !          2189:                                Ptable tb = nn->n_table;
        !          2190:                                nn->n_table = 0;
        !          2191:                                nn->n_scope = n_protect?n_protect:n_scope; 
        !          2192:                                Pname n = tbl->insert(nn,0);
        !          2193:                                if (Nold) {
        !          2194:                                        error("twoDs of%n (one in anonymous union)",nn);
        !          2195:                                        break;
        !          2196:                                }
        !          2197: 
        !          2198:                                Pclass tc;
        !          2199:                                if (tc = cl->in_class) 
        !          2200:                                        --n->lex_level;
        !          2201:                                if ( tc && tc->csu == ANON) {
        !          2202: //error('d', "tc->csu anon %k %s", tc->csu, string );
        !          2203:                                        if ( n->n_anon ) {
        !          2204:                                                if ( !err_msg ) 
        !          2205:                                                        error('s', "anonymous unions nested deeper than 2 levels" );
        !          2206:                                                err_msg = 1;
        !          2207:                                        }
        !          2208:                                        n->n_anon = string;
        !          2209:                                }
        !          2210: 
        !          2211:                                n->n_union = uindex;
        !          2212:                                nn->n_table = tb;
        !          2213:                        }
        !          2214:                }
        !          2215:                if (cl->c_abstract) error("D ofO of abstractC%t",cl);
        !          2216:                goto cde;
        !          2217:        }
        !          2218: 
        !          2219:        case VOID:
        !          2220:                if (n_scope != ARG) {
        !          2221:                        error("badBT:%k%n",tx->base,this);
        !          2222:                        Cdcl = odcl;
        !          2223:                        return 0;
        !          2224:                }
        !          2225:                break;
        !          2226: 
        !          2227:        case LDOUBLE:
        !          2228:                 if (warn_ldouble==0 && ansi_opt==0) {
        !          2229:                         ++warn_ldouble;
        !          2230:                         error('w',"long double supported under ``+a1'' option only, generating ``double%n''", this);
        !          2231:                 }
        !          2232:                goto cde;
        !          2233: 
        !          2234:        case PTR:
        !          2235:        case VEC:
        !          2236:        case RPTR:
        !          2237:                tp->dcl(tbl);
        !          2238: 
        !          2239:        default:
        !          2240:        cde:
        !          2241: //error('d',"cde: %n %t",this,tp);
        !          2242:                nn = tbl->insert(this,0);
        !          2243:                n_table = nn->n_table;
        !          2244: 
        !          2245:                if (Nold) {
        !          2246: 
        !          2247:                        if ( nn->base == PUBLIC ) { // X::i
        !          2248:                                error("twoDs ofCM%n", nn);
        !          2249:                                Cdcl = odcl;
        !          2250:                                return 0;
        !          2251:                        }
        !          2252: 
        !          2253:                        if (nn->tp->base == ANY) goto zzz;
        !          2254: 
        !          2255:                        if (tp->check(nn->tp,0)) {
        !          2256:                                error("twoDs of%n;Ts:%t and%t",this,nn->tp,tp);
        !          2257:                                Cdcl = odcl;
        !          2258:                                return 0;
        !          2259:                        }
        !          2260: //error('d',"%n: %k %k scope %k",this,n_sto,nn->n_sto,nn->n_scope);
        !          2261:                        if (n_sto && n_sto!=nn->n_scope) {
        !          2262:                                if (n_sto==EXTERN && nn->n_scope==STATIC) {
        !          2263:                                        error('w',"%n declared extern after being declared static",this);
        !          2264:                                        goto ext_fudge;
        !          2265:                                }
        !          2266:                                else
        !          2267:                                        error("%n declared as both%k and%k",this,n_sto,(nn->n_sto)?nn->n_sto:(scope==FCT?AUTO:EXTERN));
        !          2268:                        }
        !          2269:                        else if (nn->n_scope==STATIC && n_scope==EXTERN) {
        !          2270:                                error('w',"static%n followed by definition",this);
        !          2271:                        ext_fudge:
        !          2272:                                if (n_initializer) {
        !          2273: //                                     error('d',"static%n redefined (WIr)",this);
        !          2274:                                        n_initializer = 0;
        !          2275:                                }
        !          2276:                                n_sto = EXTERN;
        !          2277:                        }
        !          2278:                        else if (nn->n_sto==STATIC && n_sto==STATIC ) 
        !          2279:                                error("static%n declared twice",this);
        !          2280:                        else {
        !          2281:                                if (n_sto==0
        !          2282:                                && nn->n_sto==EXTERN
        !          2283:                                && n_initializer
        !          2284:                                && tp->tconst())
        !          2285:                                        n_sto = EXTERN;
        !          2286:                                n_scope = nn->n_scope;
        !          2287: 
        !          2288:                                switch (scope) {
        !          2289:                                case FCT:
        !          2290:                                        if (n_sto != EXTERN) {
        !          2291:                                                error("twoDs of%n",this);
        !          2292:                                                Cdcl = odcl;
        !          2293:                                                return 0;
        !          2294:                                        }
        !          2295:                                        break;
        !          2296:                                case ARG:
        !          2297:                                        error("twoAs%n",this);
        !          2298:                                        Cdcl = odcl;
        !          2299:                                        return 0;
        !          2300:                                case 0:
        !          2301:                                case PUBLIC:
        !          2302:                                        error("twoDs ofM%n",this);
        !          2303:                                        Cdcl = odcl;
        !          2304:                                        return 0;
        !          2305:                                case EXTERN:
        !          2306:                                        if (n_sto==0) {
        !          2307:                                                switch(nn->n_sto) {
        !          2308:                                                case 0:
        !          2309:                                                        error("two definitions of%n",this);
        !          2310:                                                        Cdcl = odcl;
        !          2311:                                                        return 0;
        !          2312:                                                case EXTERN:
        !          2313:                                                        if(nn->n_initializer) {
        !          2314:                                                                error("two definitions of%n",this);
        !          2315:                                                                Cdcl = odcl;
        !          2316:                                                        }
        !          2317:                                                        else
        !          2318:                                                                nn->n_sto=0;
        !          2319:                                                        break;
        !          2320:                                                }
        !          2321:                                        }
        !          2322:                                        else if(n_sto==EXTERN && n_initializer) {
        !          2323:                                                switch(nn->n_sto) {
        !          2324:                                                case 0:
        !          2325:                                                        error("two definitions of%n",this);
        !          2326:                                                        Cdcl = odcl;
        !          2327:                                                        return 0;
        !          2328:                                                case EXTERN:
        !          2329:                                                        nn->n_sto=0;
        !          2330:                                                        break;
        !          2331:                                                }
        !          2332:                                        }
        !          2333:                                        break;
        !          2334:                                }
        !          2335:                        }
        !          2336:                        n_scope = nn->n_scope;
        !          2337: /* n_val */
        !          2338:                        if (n_initializer) {
        !          2339:                                if (nn->n_initializer || nn->n_val) error("twoIrs for%n",this);
        !          2340:                                nn->n_initializer = n_initializer;
        !          2341:                        }
        !          2342:                        if (tp->base == VEC) {
        !          2343:                        //      handle:  extern v[]; v[200];
        !          2344:                        //      and     extern u[10]; u[11];
        !          2345: 
        !          2346:                                Ptype ntp = nn->tp;
        !          2347:                                while (ntp->base == TYPE) ntp = Pbase(ntp)->b_name->tp;
        !          2348:                                if (Pvec(ntp)->dim == 0) Pvec(ntp)->dim = Pvec(tp)->dim;
        !          2349:                                if (Pvec(ntp)->size) {
        !          2350:                                        if (Pvec(tp)->size
        !          2351:                                        && Pvec(ntp)->size!=Pvec(tp)->size)
        !          2352:                                                error("bad array size for%n: %d %dX",this,Pvec(tp)->size,Pvec(ntp)->size);
        !          2353:                                }
        !          2354:                                else
        !          2355:                                        Pvec(ntp)->size = Pvec(tp)->size;
        !          2356:                        }
        !          2357:                }
        !          2358:                else {
        !          2359: //error('d',"%n %t scope %d sto %k",this,tp,scope,n_sto);              
        !          2360:                        if (scope!=ARG
        !          2361:                        && n_sto!=EXTERN
        !          2362:                        && (!((scope==0 || scope==PUBLIC) && n_sto==STATIC)) // static member
        !          2363:                        && n_initializer==0
        !          2364:                        && tp->base==VEC
        !          2365:                        && Pvec(tp)->size==0)
        !          2366:                                error(&where,"dimension missing for array%n",this);
        !          2367: 
        !          2368:                        if (scope==EXTERN
        !          2369:                        && n_sto==0
        !          2370:                        && tp->tconst()
        !          2371:                        && vec_const==0
        !          2372:                        && fct_const==0)
        !          2373:                                nn->n_sto = n_sto = STATIC;
        !          2374:                }
        !          2375:        
        !          2376:        zzz:
        !          2377:                if (base != TNAME) {
        !          2378:                        Ptype t = nn->tp;
        !          2379: 
        !          2380:                        if (t->base == TYPE) {
        !          2381:                                Ptype tt = Pbase(t)->b_name->tp;
        !          2382:                                if (tt->base == FCT) nn->tp = t = tt;
        !          2383:                        }
        !          2384: 
        !          2385:                        switch (t->base) {
        !          2386:                        case FCT:
        !          2387:                        case OVERLOAD:
        !          2388:                                break;
        !          2389:                        default:
        !          2390:                                fake_sizeof = 1;
        !          2391:                                switch (nn->n_stclass) {
        !          2392:                                default:
        !          2393:                                        if (nn->n_scope != ARG) {
        !          2394:                                                int x = t->align();
        !          2395:                                                int y = t->tsizeof();
        !          2396: 
        !          2397:                                                if (max_align < x) max_align = x;
        !          2398: 
        !          2399:                                                while (0 < bit_offset) {
        !          2400:                                                        byte_offset++;
        !          2401:                                                        bit_offset -= BI_IN_BYTE;
        !          2402:                                                }
        !          2403:                                                bit_offset = 0;
        !          2404: 
        !          2405:                                                if (byte_offset && 1<x) byte_offset = ((byte_offset-1)/x)*x+x;
        !          2406:                                                nn->n_offset = byte_offset;
        !          2407:                                                byte_offset += y;
        !          2408:                                        }
        !          2409:                                        break;
        !          2410:                                case STATIC:
        !          2411:                                        if (n_sto != EXTERN
        !          2412:                                        && nn->n_scope
        !          2413:                                        && nn->n_scope!=PUBLIC)
        !          2414:                                        t->tsizeof();   // check that size is known
        !          2415:                                }
        !          2416:                                fake_sizeof = 0;
        !          2417:                        }
        !          2418:                }
        !          2419: 
        !          2420:        {       Ptype t = nn->tp;
        !          2421:                int const_old = const_save;
        !          2422:                bit vec_seen = 0;
        !          2423:                Pexpr init = n_initializer;
        !          2424: 
        !          2425:        lll:
        !          2426: // error('d',"lll %n %t init %d %k",this,t,init,init?init->base:0);
        !          2427:                switch (t->base) {
        !          2428:                case COBJ:
        !          2429:                {       Pname cn = Pbase(t)->b_name;
        !          2430:                        Pclass cl = (Pclass)cn->tp;
        !          2431:                        Pname ctor = cl->has_ctor();
        !          2432:                        Pname dtor = cl->has_dtor();
        !          2433:                        int stct = 0;
        !          2434: //error('d',"obj %n; class '%s'; ctor '%s'; dtor '%s'",nn,cn->string,ctor?ctor->string:"???",dtor?dtor->string:"???");
        !          2435:                        if (dtor) {
        !          2436:                                Pstmt dls;
        !          2437: 
        !          2438:                                // if dtor is not public check scope of class object
        !          2439: 
        !          2440: //error('d',"dcl %n has dtor",nn);
        !          2441:                                if (dtor->n_scope != PUBLIC)  {
        !          2442: //error('d',"dcl %n->n_scope: %d fct %n",nn,nn->n_scope,cc->nof);
        !          2443:                                        switch (nn->n_scope) {
        !          2444:                                        case ARG:
        !          2445:                                        case 0:
        !          2446:                                        case PUBLIC:
        !          2447:                                                break;
        !          2448:                                        default: 
        !          2449:                                                check_visibility( dtor, 0, cl, tbl, cc->nof );
        !          2450:                                        }
        !          2451:                        //              if (nn->n_scope == FCT) 
        !          2452:                        //                      check_visibility( dtor, 0, cl, tbl, cc->nof );
        !          2453:                        //              else if ( nn->n_sto != EXTERN )
        !          2454:                        //                      error("%k%n cannot access%n: %sM",nn->n_scope,nn,dtor,dtor->n_protect?"protected":"private");
        !          2455:                                }
        !          2456: 
        !          2457:                                switch ( nn->n_scope ) {
        !          2458:                                case 0:
        !          2459:                                case PUBLIC:
        !          2460:                                        if (n_stclass==STATIC) { //III
        !          2461:                                                Pclass cl = Pclass(nn->n_table->t_name->tp);
        !          2462:                                                if (cl->defined&DEFINED) goto dtdt;
        !          2463:                                        }
        !          2464:                                        break;
        !          2465:                                case EXTERN:
        !          2466:                                        if (n_sto==EXTERN) break;
        !          2467: 
        !          2468:                                case STATIC:
        !          2469:                                {       Pexpr c;
        !          2470:                                dtdt:
        !          2471: // local static class objects have destructors set up in simpl2.c
        !          2472: // special case: temporary class object generated in init expression
        !          2473:                                        if (stat_init && scope == ARGS ) {
        !          2474:                                                nn->n_scope = ARGS;
        !          2475:                                                goto ggg;
        !          2476:                                        }
        !          2477: 
        !          2478:                                        if ( nn->lex_level
        !          2479:                                        &&   nn->n_sto == STATIC ) {
        !          2480:                                                if (ctor==0) 
        !          2481:                                                    error('s',"local static%n has%n but noK(add%n::%n())", nn, dtor, cn, cn );
        !          2482:                                                goto static_init;
        !          2483:                                        }
        !          2484: 
        !          2485:                                        Ptable otbl = tbl;
        !          2486:                                            // to collect temporaries generated
        !          2487:                                            // in static destructors where we
        !          2488:                                            // can find them again (in std_tbl)
        !          2489:                                        if (std_tbl == 0) std_tbl = new table(8,gtbl,0);
        !          2490:                                        tbl = std_tbl;
        !          2491:                                        if (vec_seen) {
        !          2492:                                                c = cdvec(vec_del_fct,nn,cl,dtor,0,zero);
        !          2493:                                        } else {        // nn->cl::~cl(0);
        !          2494:                                                c = call_dtor(nn,dtor,0,DOT,one);
        !          2495:                                        }
        !          2496:                                        c->tp = any_type; // avoid another check
        !          2497:                                        dls = new estmt(SM,nn->where,c,0);
        !          2498:                                        
        !          2499:                                        // destructors for statics are executed in reverse order
        !          2500:                                        if (st_dlist) dls->s_list = st_dlist;
        !          2501:                                        st_dlist = dls;
        !          2502:                                        tbl = otbl;
        !          2503:                                } // case STATIC
        !          2504:                                } // switch nn->n_scope
        !          2505:                        } // if dtor
        !          2506: 
        !          2507: // local static class objects must defer setting up static dtor
        !          2508: static_init:
        !          2509:                        if (ctor) {
        !          2510: // error('d',"ctor %n scope %k",ctor,nn->n_scope);
        !          2511:                                Pexpr oo = nn;
        !          2512:                                for (int vi=vec_seen; vi; vi--) oo = oo->contents();
        !          2513:                                int sti = 0;
        !          2514:                                switch (nn->n_scope) {
        !          2515:                                case EXTERN:
        !          2516:                                        if (init==0 && n_sto==EXTERN) goto ggg;
        !          2517:                                case STATIC:
        !          2518:                                        if (tbl == gtbl)
        !          2519:                                                sti = 1;
        !          2520:                                        else
        !          2521:                                                stct = 1;
        !          2522:                                default:
        !          2523:                                        if (vec_seen && init) {
        !          2524:                                                if (1<vec_seen) {
        !          2525: /* ?????
        !          2526:                                                        if (init->base != ILIST)
        !          2527:                                                                error("badIr forO ofC %t withK%n",cl,this);
        !          2528:                                                        else
        !          2529: */
        !          2530:                                                                error('s',"Ir for multi-dimensional array%n ofOsofC %t withK",this,cl);
        !          2531:                                                        }
        !          2532:                                                else {
        !          2533:                                                        if (sti) {
        !          2534:                                                                if (sti_tbl==0) sti_tbl = new table(8,gtbl,0);
        !          2535:                                                                const_save = 1;
        !          2536:                                                                (void) co_array_init(nn,sti_tbl);
        !          2537:                                                                const_save = 0;
        !          2538:                                                                n_initializer = init = 0;
        !          2539:                                                        }
        !          2540:                                                        else {
        !          2541:                                                                n_initializer = init = co_array_init(nn,tbl);
        !          2542:                                                                if (stct)  
        !          2543:                                                                        nn->n_initializer = n_initializer = init = new expr( STAT_INIT, init, 0 );
        !          2544:                                                        }
        !          2545:                                                }
        !          2546:                                                goto ggg;
        !          2547:                                        }
        !          2548:                                        break;
        !          2549:                                case PUBLIC:
        !          2550:                                case 0:
        !          2551:                                        if (n_stclass==STATIC) { //III
        !          2552:                                                Pclass cl = Pclass(nn->n_table->t_name->tp);
        !          2553:                                                if (cl->defined&DEFINED) {
        !          2554:                                                        sti = 1;
        !          2555:                                                        break;
        !          2556:                                                }
        !          2557:                                        }
        !          2558:                                        {
        !          2559:                                                Pname c;
        !          2560:                                                if (vec_seen) {
        !          2561:                                                        c = cl->has_ictor();
        !          2562:                                                        if (c == 0)
        !          2563:                                                                error("array ofC%n that does not have aK taking noAs",cn);
        !          2564:                                                        else if (Pfct(c->tp)->nargs)
        !          2565:                                                                error("defaultAs forK for array ofC%n",cn);
        !          2566:                                                }
        !          2567:                                        }
        !          2568:                                        // no break
        !          2569:                                case ARG:
        !          2570:                                        goto ggg;
        !          2571:                                }
        !          2572: 
        !          2573:                                const_save = 1;
        !          2574:                                nn->assign();
        !          2575:                                Ptable otbl = tbl;
        !          2576:                                if (sti) {      // to collect temporaries generated
        !          2577:                                                // in static initializers where we
        !          2578:                                                // can find them again (in sti_tbl)
        !          2579:                                        if (sti_tbl == 0) sti_tbl = new table(8,gtbl,0);
        !          2580:                                        tbl = sti_tbl;
        !          2581:                                        if (n_sto == EXTERN) nn->n_sto = n_sto = 0;
        !          2582:                                }
        !          2583: 
        !          2584:                                if (init) {
        !          2585: // error('d',"init %k",init->base);
        !          2586:                                        if (init->base==VALUE) {
        !          2587:                                                switch (init->tp2->base) {
        !          2588:                                                case CLASS:
        !          2589: // error('d',"class %t %t",Pclass(init->tp2),cl);
        !          2590:                                                        if (Pclass(init->tp2)!=cl) goto inin;
        !          2591:                                                        break;
        !          2592:                                                default:
        !          2593:                                                        Pname  n2 = init->tp2->is_cl_obj();
        !          2594: // error('d',"default %t %t",n2->tp,cl);
        !          2595:                                                        if (n2==0 || Pclass(n2->tp)!=cl) goto inin;
        !          2596:                                                }
        !          2597: 
        !          2598:                                                Pexpr ee = init->e1;
        !          2599: // error('d',"init->e1 %k",ee->base);
        !          2600:                                                if (ee && vec_seen==0)
        !          2601:                                                switch (ee->base) {
        !          2602:                                                case CALL:      // T a = f();
        !          2603:                                                        init = ee;
        !          2604:                                                        goto inin;
        !          2605:                                                case ELIST:     // T a(f());
        !          2606:                                                        if (ee->e1->base==CALL
        !          2607:                                                        && ee->e2 == 0) {
        !          2608:                                                                init = ee->e1;
        !          2609:                                                                goto inin;
        !          2610:                                                        }
        !          2611:                                                } // end switch
        !          2612: 
        !          2613:                                                init->e2 = oo;
        !          2614:                                                init = init->typ(tbl);
        !          2615: 
        !          2616:                                                if (init->base == G_CM) // beware of type conversion operators
        !          2617:                                                switch (init->tp2->base) {
        !          2618:                                                case CLASS:
        !          2619:                                                        if (Pclass(init->tp2)!=cl) goto inin;
        !          2620:                                                        break;
        !          2621:                                                default:
        !          2622:                                                        Pname  n2 = init->tp2->is_cl_obj();
        !          2623:                                                        if (n2==0 || Pclass(n2->tp)!=cl) goto inin;
        !          2624:                                                }
        !          2625:                                        }
        !          2626:                                        else {
        !          2627:                                        inin:
        !          2628: // error('d',"inin %k",init->base);
        !          2629:                                                init = init->typ(tbl);
        !          2630: //error('d', "inin: init->typ: %d %k n->tp %t init->tp %t",init->base,init->base,nn->tp,init->tp);
        !          2631:                                                if (init->base==G_CM
        !          2632:                                                && nn->tp->check(init->tp,0)==0)
        !          2633:                                                        (void) replace_temp(init,nn->address());
        !          2634:                                                else
        !          2635:                                                        init = class_init(nn,nn->tp,init,tbl);
        !          2636:                                        }
        !          2637:                                }
        !          2638:                                else if (vec_seen == 0) {
        !          2639: //error('d',"make value");
        !          2640:                                        init = new texpr(VALUE,cl,0);
        !          2641:                                        init->e2 = oo;
        !          2642:                                        init = init->typ(tbl);
        !          2643:                                }
        !          2644: 
        !          2645:                                Pname c;
        !          2646:                                if (vec_seen) {
        !          2647:                                        c = cl->has_ictor();
        !          2648:                                        if (c == 0)
        !          2649:                                                error("array ofC%n that does not have aK taking noAs",cn);
        !          2650:                                        else if (Pfct(c->tp)->nargs)
        !          2651:                                                error("defaultAs forK for array ofC%n",cn);
        !          2652:                                }
        !          2653: 
        !          2654: // error( 'd', "stct: %d init: %d", stct, init );
        !          2655:                                if (stct) {
        !          2656:                                        if (tbl!=gtbl && nn->n_sto==EXTERN) {
        !          2657:                                                error(&where,"Id local extern%n",this);
        !          2658:                                                init = 0;
        !          2659:                                        }
        !          2660:                                        else if (init) 
        !          2661:                                                init->base = STAT_INIT;
        !          2662:                                        else {
        !          2663:                                                if (tp->base == VEC && Pvec(tp)->size ) {
        !          2664:                                                        Pexpr ilist = 0;
        !          2665:                                                        for (int i=Pvec(tp)->size; i>0; i--) {
        !          2666:                                                                Pexpr e = new texpr(VALUE,cl,0);
        !          2667:                                                                ilist = new expr(ELIST, e, ilist);
        !          2668:                                                        }
        !          2669:                                                        nn->n_initializer=new expr(ILIST,ilist,0);
        !          2670:                                                        init = co_array_init(nn,tbl);
        !          2671:                                                        nn->n_initializer = n_initializer = init = new expr( STAT_INIT, init, 0 );
        !          2672:                                                }
        !          2673:                                                else
        !          2674:                                                error('s',"local staticC%n (%t)",this, tp);
        !          2675:                                        }
        !          2676:                                }
        !          2677: 
        !          2678: // error('d', "%n->sti: %d vec_seen: %d n_stclass: %k", this, sti, vec_seen, n_stclass );
        !          2679:        if (sti) {
        !          2680:                if (vec_seen) { // _vec_new(vec,noe,sz,ctor);
        !          2681: // error('d', "%n->dcl: n_stclass: %k ", this, n_stclass );
        !          2682:                        if ( n_stclass == STATIC && n_initializer ) {
        !          2683:                                const_save = 1;
        !          2684:                                (void) co_array_init(nn,sti_tbl);
        !          2685:                                const_save = 0;
        !          2686:                                n_initializer = init = 0;
        !          2687:                                goto ggg;
        !          2688:                        }
        !          2689: 
        !          2690:                        init = cdvec(vec_new_fct,nn,cl,c,-1,0);
        !          2691:                        init->tp = any_type;
        !          2692:                }
        !          2693:                else {
        !          2694:                        switch (init->base) {
        !          2695:                        case DEREF:             // *constructor?
        !          2696:                                if (init->e1->base == G_CALL) { 
        !          2697:                                        Pname fn = init->e1->fct_name;
        !          2698:                                        if (fn==0 || fn->n_oper!=CTOR) goto as;
        !          2699:                                        init = init->e1;
        !          2700:                                        break;
        !          2701:                                }
        !          2702:                                goto as;
        !          2703:                        case G_CM:
        !          2704:                                init = init->e1;
        !          2705:                                        // suppress further type checking
        !          2706:                                if (init->tp == 0) init->tp= any_type; 
        !          2707:                                break;
        !          2708:                        case ASSIGN:
        !          2709:                                if (init->e1 == nn) break;      // simple assignment
        !          2710:                        as:     
        !          2711:                        default:        
        !          2712:                                init = new expr(ASSIGN,nn,init);
        !          2713:                        }
        !          2714:                }
        !          2715:                Pstmt ist = new estmt(SM,nn->where,init,0);
        !          2716:                // constructors for statics are executed in order
        !          2717:                if (st_ilist == 0)
        !          2718:                        st_ilist = ist;
        !          2719:                else
        !          2720:                        itail->s_list = ist;
        !          2721:                itail = ist;
        !          2722:                init = 0;       // suppress further processing
        !          2723:        } // if (sti)
        !          2724:                                nn->n_initializer = n_initializer = init;
        !          2725:                                const_save = const_old;
        !          2726:                                tbl = otbl;
        !          2727:                        }
        !          2728:                        else if (init == 0)             // no initializer
        !          2729:                                goto str;
        !          2730:                        else if (cl->is_simple()
        !          2731:                        //      && cl->csu!=UNION       // accept ANSIism
        !          2732:                                && cl->csu!=ANON
        !          2733:                                ) {     // struct
        !          2734:                                init = init->typ(tbl);
        !          2735:                                if (nn->tp->check(init->tp,0)==0
        !          2736:                                && init->base==G_CM) 
        !          2737:                                        (void) replace_temp(init,nn->address());
        !          2738:                                else {
        !          2739:                                        if (ansi_opt==0
        !          2740:                                        && init->base==ILIST
        !          2741:                                        && cl->csu==UNION)
        !          2742:                                                error('s',"initialization of union withIL");
        !          2743:                                        goto str;
        !          2744:                                }
        !          2745:                        }
        !          2746:                        else if (init->base == ILIST) { // class or union
        !          2747:                                error("cannotI%nWIrL",nn);
        !          2748:                        }
        !          2749:                        else {                  // bitwise copy ok?
        !          2750:                                                // possible to get here?
        !          2751:                                init = init->typ(tbl);
        !          2752: //error('d',"init22 %t %t",nn->tp,init->tp);
        !          2753:                                if (nn->tp->check(init->tp,0)==0) {
        !          2754:                                        if (init->base==G_CM) 
        !          2755:                                                (void) replace_temp(init,nn->address());
        !          2756:                                        else
        !          2757:                                                goto str;
        !          2758:                                }
        !          2759:                                goto str;
        !          2760:                        //      else
        !          2761:                        //              error("cannotI%n:%k %s has noK",nn,cl->csu,cl->string);
        !          2762:                        }
        !          2763:                        break;
        !          2764:                }
        !          2765:                case VEC:       
        !          2766:                        t = Pvec(t)->typ;
        !          2767:                        vec_seen++;
        !          2768:                        goto lll;
        !          2769:                case TYPE:
        !          2770:                        if (init==0 && Pbase(t)->b_const) {
        !          2771:                                switch (n_scope) {
        !          2772:                                case ARG:
        !          2773:                                        break;
        !          2774:                                case 0:
        !          2775:                                case PUBLIC:
        !          2776:                                        if ( cc->cot ) break;
        !          2777:                                default: {
        !          2778:                                        Pname n = t->is_cl_obj();
        !          2779:                                        Pclass cl;
        !          2780:                                        if ( n ) cl = Pclass( n->tp );
        !          2781: 
        !          2782:                                        if (n_sto!=EXTERN && 
        !          2783:                                           (n==0 || (cl->has_ctor()==0 && is_empty(cl,1)==0))) 
        !          2784:                                                error("uninitialized const%n",this);
        !          2785:                                        }
        !          2786:                                }
        !          2787:                        }
        !          2788:                        t = Pbase(t)->b_name->tp;
        !          2789:                        goto lll;
        !          2790:                case RPTR:
        !          2791:                        if (init) {
        !          2792:                                if (nn->n_scope == ARG) break;
        !          2793:                                if (Pptr(nn->tp)->memof) error("R toCM%n ofT%t illegal",nn,nn->tp);
        !          2794:                                ref_initializer++;
        !          2795:                                init = init->typ(tbl);
        !          2796:                                ref_initializer--;
        !          2797:                                Nvirt = 0; // set within ref_init() call
        !          2798:                                const_ptr = Pbase(Pptr(t)->typ)->tconst(); 
        !          2799: 
        !          2800:                                if (n_sto==STATIC
        !          2801:                                && init->lval(0)==0
        !          2802:                                && fct_const==0)
        !          2803:                                        error("Ir for staticR%n not an lvalue",this);
        !          2804:                                else
        !          2805:                                        nn->n_initializer = n_initializer = init = ref_init(Pptr(t),init,tbl);
        !          2806: 
        !          2807:                                const_ptr = 0;
        !          2808:                                if (Nvirt == VIRTUAL) sti_vb = 1;
        !          2809:                                nn->assign();
        !          2810: 
        !          2811:                                if (init->base==ILIST && init->e2==0) {
        !          2812:                                        new_list(init);
        !          2813:                                        list_check(nn,nn->tp,0,tbl);
        !          2814:                                        if (next_elem()) error(&where,"IrL too long");
        !          2815:                                }
        !          2816: 
        !          2817:                        }
        !          2818:                        else {
        !          2819:                                switch (nn->n_scope) {
        !          2820:                                default:
        !          2821:                                        if (n_sto == EXTERN) break;
        !          2822:                                        error("uninitializedR%n",this);
        !          2823:                                case ARG:
        !          2824:                                        break;
        !          2825:                                case PUBLIC:
        !          2826:                                case 0:
        !          2827:                        //III           if (n_sto == STATIC) error("a staticM%n cannot be aR",this);
        !          2828: // error('d', "%n->dcl cot: %s", this, cc->cot?cc->cot->string:"notset");
        !          2829:                                        if ( cc->cot == 0 )
        !          2830:                                                error("uninitializedR%n",this);
        !          2831:                                        break;
        !          2832:                                }
        !          2833:                        }
        !          2834:                        goto stgg;
        !          2835:                default:
        !          2836:                str:
        !          2837: // error('d',"str %n %t %k %t",this,tp,init?init->base:0,init?init->tp:0);
        !          2838:                        if (init == 0) {
        !          2839:                                switch (n_scope) {
        !          2840:                                case ARG:
        !          2841:                                        break;
        !          2842:                                case 0:
        !          2843:                                case PUBLIC:
        !          2844:                                        if ( cc->cot ) break;
        !          2845:                                default:
        !          2846:                                        if (n_sto!=EXTERN && t->tconst()) error("uninitialized const%n",this);
        !          2847:                                }
        !          2848: 
        !          2849:                                break;
        !          2850:                        }
        !          2851: 
        !          2852:                        const_save =       const_save
        !          2853:                                        || n_scope==ARG
        !          2854:                                        || (t->tconst() && vec_const==0);
        !          2855: 
        !          2856:                        if ( tp->base == PTR ) {
        !          2857:                                if ( cc && cc->nof 
        !          2858:                                        && Pfct(cc->nof->tp)->f_const ) 
        !          2859:                                                cm_const_save = Pbase(Pptr(tp)->typ)->b_const; 
        !          2860:                                const_ptr = Pbase(Pptr(tp)->typ)->b_const; 
        !          2861:                        }
        !          2862: 
        !          2863:                        if (n_sto==STATIC) stat_init++;
        !          2864:                         nn->n_initializer = n_initializer = init = init->typ(tbl);
        !          2865:                        if (n_sto==STATIC) stat_init--;
        !          2866: 
        !          2867:                        cm_const_save = 0;
        !          2868:                        const_ptr = 0;
        !          2869: 
        !          2870:                        if (const_save) PERM(init);
        !          2871:                        nn->assign();
        !          2872:                        const_save = const_old;
        !          2873: //error('d',"init2 %k %t",init->base,init->tp);
        !          2874:                        switch (init->base) {
        !          2875:                        case ILIST:
        !          2876:                                if (init->e2) goto dfdf;//break; // pointer to member
        !          2877:                                new_list(init);
        !          2878:                                list_check(nn,nn->tp,0,tbl);
        !          2879:                                if (next_elem()) error(&where,"IrL too long");
        !          2880:                                break;
        !          2881:                        case STRING:
        !          2882:                        {       Ptype v = nn->tp;
        !          2883:                                while (v->base == TYPE) v = Pbase(v)->b_name->tp;
        !          2884:                                if (v->base==VEC) {
        !          2885:                                        Ptype vv = Pvec(v)->typ;
        !          2886:                                        while(vv->base==TYPE) vv = Pbase(vv)->b_name->tp;
        !          2887:                                        if(vv->base==CHAR) {
        !          2888:                                                int sz = Pvec(v)->size;
        !          2889:                                                int isz = Pvec(init->tp)->size;
        !          2890:                                                if (sz == 0)
        !          2891:                                                        Pvec(v)->size = isz;
        !          2892:                                                else if (sz < isz)
        !          2893:                                                        error(&where,"Ir too long (%d characters) for%n[%d]",isz,nn,sz);
        !          2894:                                                break;
        !          2895:                                        }
        !          2896:                                }
        !          2897:                                // no break
        !          2898:                        }
        !          2899:                        default:
        !          2900:                        dfdf:
        !          2901:                        {       Ptype nt = nn->tp;
        !          2902:                                int ntc = Pbase(nt)->b_const;
        !          2903: 
        !          2904:                                if (vec_seen) {
        !          2905:                                        error("badIr for array%n",nn);
        !          2906:                                        break;
        !          2907:                                }
        !          2908:                        tlx:
        !          2909:                                switch (nt->base) {
        !          2910:                                case TYPE:
        !          2911:                                        nt = Pbase(nt)->b_name->tp;
        !          2912:                                        ntc |= Pbase(nt)->b_const;
        !          2913:                                        goto tlx;
        !          2914:                                case INT:
        !          2915:                                case CHAR:
        !          2916:                                case SHORT:
        !          2917:                                case EOBJ:
        !          2918:                                //      if (init->base==ICON && init->tp==long_type)
        !          2919:                                //              error('w',"longIr constant for%k%n",nn->tp->base,nn);
        !          2920:                                {       Ptype t = init->tp;
        !          2921:                                csi:
        !          2922:                                        switch (t->base) {
        !          2923:                                        case TYPE:
        !          2924:                                                t = Pbase(t)->b_name->tp; goto csi;
        !          2925:                                        case LONG:
        !          2926:                                        case FLOAT:
        !          2927:                                        case DOUBLE:
        !          2928:                                        case LDOUBLE:
        !          2929:                                                error('w',"%tIdW %t",nt,init->tp);
        !          2930:                                        }
        !          2931:                                }
        !          2932:                                        // no break
        !          2933:                                case LONG:
        !          2934:                                        if (Pbase(nt)->b_unsigned
        !          2935:                                        && init->base==UMINUS
        !          2936:                                        && init->e2->base==ICON)
        !          2937:                                                error('w',"negativeIr for unsigned%n",nn);
        !          2938:                                        if (ntc && scope!=ARG) {
        !          2939:                                                long i;
        !          2940:                                                Neval = 0;
        !          2941:                                                i = init->eval();
        !          2942:                                                if (Neval == 0) {
        !          2943:                                                        DEL(init);
        !          2944:                                                        nn->n_evaluated = n_evaluated = 1;
        !          2945:                                                        nn->n_val = n_val = i;
        !          2946:                                                        DEL(init);
        !          2947:                                                        nn->n_initializer = n_initializer = 0;
        !          2948:                                                }
        !          2949:                                        }
        !          2950:                                        break;
        !          2951:                                case PTR:
        !          2952:                                        Nvirt = 0;
        !          2953:                                        nn->n_initializer = n_initializer = init = ptr_init(Pptr(nt),init,tbl);
        !          2954: //display_expr(init,string);
        !          2955:                                        if (Nvirt == VIRTUAL) sti_vb = 1;
        !          2956:                                        if (Pchecked) goto stgg;
        !          2957:                                } 
        !          2958: 
        !          2959:                        {       Pexpr x = try_to_coerce(nt,init,"initializer",tbl);
        !          2960:                                if (x) {
        !          2961:                                        nn->n_initializer = n_initializer = init = x;
        !          2962:                                        goto stgg;
        !          2963:                                }
        !          2964:                        }
        !          2965: //error('d',"check %t %t %k",nt,init->tp,init->base);
        !          2966:                //      if (nt->check(init->tp,ASSIGN)) {
        !          2967:                                Pname c1 = nt->is_cl_obj();
        !          2968:                                Pname c2 = init->tp->is_cl_obj();
        !          2969:                                if (c1
        !          2970:                                && c2
        !          2971:                                && Pclass(c2->tp)->has_base(Pclass(c1->tp))) {
        !          2972:                                        init = new texpr(CAST,new ptr(PTR,nt),init->address());
        !          2973:                                        init = init->typ(tbl);
        !          2974:                                        nn->n_initializer = n_initializer = init = init->contents();
        !          2975:                                        goto stgg;
        !          2976:                                }
        !          2977: 
        !          2978:                                if (nt->check(init->tp,ASSIGN)) {
        !          2979:                                        error("badIrT%t for%n (%tX)",init->tp,this,nn->tp);
        !          2980:                                        break;
        !          2981:                                }
        !          2982:                }
        !          2983: 
        !          2984:                stgg:
        !          2985: // error('d',"stgg %n init %k %t Nvirt: %k",this,init?init->base:0,init?init->tp:0, Nvirt);
        !          2986:                        if (init && n_stclass==STATIC && (sti_vb || need_sti(init))) {
        !          2987:                                /* check if non-static variables are used */
        !          2988:                                int local = (0<lex_level);
        !          2989: // error('d',"init %n %t local %d",nn,init->tp,local);
        !          2990:                                if (local==0) need_sti(init,tbl);       // save consts
        !          2991: 
        !          2992:                                Pptr r = nn->tp->is_ref();      //III
        !          2993: 
        !          2994:                                if (r) init = init->address();
        !          2995:                                init = new expr(ASSIGN,nn,init);
        !          2996: // error('d',"init r %t: nn %n %t init %t",r,nn,nn->tp,init->tp);
        !          2997:                                if (r)
        !          2998:                                        init->tp = nn->tp;
        !          2999:                                else if (nn->tp!=init->tp) { // static member refs
        !          3000:                                        TOK t = nn->tp->set_const(0);   //JJJ
        !          3001:                                        init = init->typ(tbl);
        !          3002:                                        nn->tp->set_const(t);           //JJJ
        !          3003:                                }
        !          3004: 
        !          3005:                                if (local) {
        !          3006:                                        if (init->base != ASSIGN) error('s',"Ir for local static too complicated");
        !          3007:                                        if (nn->n_sto == EXTERN) {
        !          3008:                                                error(&where,"Id local extern%n",this);
        !          3009:                                                        init = 0;
        !          3010:                                        }
        !          3011:                                        else init->base = STAT_INIT;
        !          3012:                                        nn->n_initializer = n_initializer = init;
        !          3013:                                        
        !          3014:                                }
        !          3015:                                else {
        !          3016:                                        Pstmt ist = new estmt(SM,nn->where,init,0);
        !          3017:                                        // constructors for statics are executed in order
        !          3018:                
        !          3019:                                        if (st_ilist == 0)
        !          3020:                                                st_ilist = ist;
        !          3021:                                        else
        !          3022:                                                itail->s_list = ist;
        !          3023:                                        itail = ist;
        !          3024:                                        nn->n_initializer = n_initializer = init = 0;   // suppress further processing
        !          3025:                                        nn->n_val = n_val = 1;
        !          3026:                                }
        !          3027:                        }
        !          3028:                        
        !          3029:                
        !          3030:                } /* switch */
        !          3031:        } /* block */
        !          3032:        } /* default */
        !          3033: 
        !          3034:        } /* switch */
        !          3035: ggg:
        !          3036: //error('d',"ggg");
        !          3037:        PERM(nn);
        !          3038:        switch (n_scope) {
        !          3039:        case FCT:
        !          3040:                nn->n_initializer = n_initializer;
        !          3041:                break;
        !          3042:        default:
        !          3043:        {       Ptype t = nn->tp;
        !          3044:        px:
        !          3045:                PERM(t);
        !          3046:                switch (t->base) {
        !          3047:                case PTR:
        !          3048:                case RPTR:
        !          3049:                case VEC:       t = Pptr(t)->typ; goto px;
        !          3050:                case TYPE:      t = Pbase(t)->b_name->tp; goto px;
        !          3051:                case FCT:       t = Pfct(t)->returns; goto px; /* args? */
        !          3052:                } 
        !          3053:        }
        !          3054:        }
        !          3055:        
        !          3056:        Cdcl = odcl;
        !          3057:        return nn;
        !          3058: }
        !          3059: 0707071010112043671004440001630000160000010172100466055375400000700000067044dcl2.c/*ident     "@(#)ctrans:src/dcl2.c  1.2" */
        !          3060: /**************************************************************************
        !          3061: 
        !          3062:        C++ source for cfront, the C++ compiler front-end
        !          3063:        written in the computer science research center of Bell Labs
        !          3064: 
        !          3065:        Copyright (c) 1984 AT&T, Inc. All Rights Reserved
        !          3066:        THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T, INC.
        !          3067: 
        !          3068: dcl2.c:
        !          3069: 
        !          3070: *************************************************************************/
        !          3071: 
        !          3072: #include "cfront.h"
        !          3073: #include "size.h"
        !          3074: 
        !          3075: Pname conv_dominates(Pname on1, Pname on2)
        !          3076: /*
        !          3077:        compare for duplicates and dominance:
        !          3078: 
        !          3079:        on1 and on2 are two conversion operator functions
        !          3080:        return the the one that dominates the other (according to the
        !          3081:        class hierarchy) otherwise 0 (0 thus indicats ambiguous conversion)
        !          3082: */
        !          3083: { 
        !          3084:        Ptype r1 = on1->tp->base==FCT ? Pfct(on1->tp)->returns 
        !          3085:                        : Pfct(Pgen(on1->tp)->fct_list->f->tp)->returns;
        !          3086:        Ptype r2 = on2->tp->base==FCT ? Pfct(on2->tp)->returns 
        !          3087:                        : Pfct(Pgen(on2->tp)->fct_list->f->tp)->returns;
        !          3088: //error('d',"conv_dominates(%n,%n)",on1,on2);
        !          3089:        if (r1==r2 || r1->check(r2,0)==0) return on1;
        !          3090:        Pptr p1 = r1->is_ptr_or_ref();
        !          3091:        Pptr p2 = r2->is_ptr_or_ref();
        !          3092:        if (p1 && p2) {
        !          3093:                Pname cn1 = p1->typ->is_cl_obj();
        !          3094:                Pname cn2 = p2->typ->is_cl_obj();
        !          3095:                if (cn1 && cn2) {
        !          3096: // is_cl_obj() returns b_name
        !          3097: //                     Pclass c1 = Pclass(Pbase(cn1->tp)->b_name->tp);
        !          3098: //                     Pclass c2 = Pclass(Pbase(cn2->tp)->b_name->tp);
        !          3099:                        Pclass c1 = Pclass(cn1->tp);
        !          3100:                        Pclass c2 = Pclass(cn2->tp);
        !          3101:                        if (c1 && c2) {
        !          3102:                                //if (c1==c2 || c1->has_base(c2)) 
        !          3103:                                if (c1->has_base(c2)) 
        !          3104:                                        return on1;
        !          3105:                                else if (c2->has_base(c1)) 
        !          3106:                                        return on2;
        !          3107:                        }
        !          3108:                }
        !          3109:        }
        !          3110:        return 0;
        !          3111: }
        !          3112: 
        !          3113: 
        !          3114: Pstmt curr_loop;
        !          3115: Pstmt curr_switch;
        !          3116: Pblock curr_block;
        !          3117: 
        !          3118: void stmt::reached()
        !          3119: {
        !          3120:        register Pstmt ss = s_list;
        !          3121: 
        !          3122:        if (ss == 0) return;
        !          3123: 
        !          3124:        switch (ss->base) {
        !          3125:        case LABEL:
        !          3126:        case CASE:
        !          3127:        case DEFAULT:
        !          3128:                break;
        !          3129:        default:
        !          3130:                error('w',&ss->where,"S after%k not reached",base);
        !          3131:                for (; ss; ss=ss->s_list) {     // delete unreacheable code
        !          3132:                        switch (ss->base) {
        !          3133:                        case LABEL:
        !          3134:                        case CASE:
        !          3135:                        case DEFAULT:           // reachable
        !          3136:                                s_list = ss;
        !          3137:                                return;
        !          3138:                        case DCL:               // the dcl may be used later
        !          3139:                                                // keep to avoid cascading errors
        !          3140:                        case IF:
        !          3141:                        case DO:
        !          3142:                        case WHILE:
        !          3143:                        case SWITCH:
        !          3144:                        case FOR:
        !          3145:                        case BLOCK:             // may hide a label
        !          3146:                                s_list = ss;
        !          3147:                                return;
        !          3148:                        }
        !          3149:                }
        !          3150:                s_list = 0;
        !          3151:        }
        !          3152: }
        !          3153: 
        !          3154: Pexpr check_cond(Pexpr e, TOK b, Ptable tbl)
        !          3155: {
        !          3156: //error('d',"check_cond(%k %k) tbl %d",e->base,b,tbl);
        !          3157:        Pname cn;
        !          3158:        if (e == dummy) error("empty condition for %k",b);
        !          3159: 
        !          3160:        int const_obj = 0;
        !          3161:        const_obj = e->tp->tconst();
        !          3162:        Pexpr ee = e;
        !          3163:         while (ee && (ee->base==DOT || ee->base==REF)) {
        !          3164:                        Pexpr m = ee->mem;
        !          3165:                        if ( ee->base==REF && m->tp &&  m->tp->is_ptr())
        !          3166:                                break;
        !          3167:                        ee = ee->e1;
        !          3168:         }
        !          3169:         if (ee) {
        !          3170:                        Ptype ttt = ee->tp;
        !          3171:                        switch (e->base) {
        !          3172:                        case REF:
        !          3173:                                Pptr p = ttt?ttt->is_ptr():0;
        !          3174:                                if (p && p->typ->tconst())
        !          3175:                                        const_obj = 1;
        !          3176:                                break;
        !          3177:                        case DOT:
        !          3178:                                if (ttt && ttt->tconst())
        !          3179:                                        const_obj = 1;
        !          3180:                        }
        !          3181:         }
        !          3182: 
        !          3183:        if (cn = e->tp->is_cl_obj()) {  
        !          3184:                Pclass cl = Pclass(cn->tp);
        !          3185:                int i = 0;
        !          3186:                Pname found = 0;
        !          3187:                for (Pname on = cl->conv; on; on=on->n_list) {
        !          3188:                        Pfct f = on->tp->base == FCT ? Pfct(on->tp)
        !          3189:                                 : Pfct(Pgen(on->tp)->fct_list->f->tp);
        !          3190:                        Ptype t = f->returns;
        !          3191:                xx:
        !          3192:                        switch (t->base) {
        !          3193:                        case TYPE:
        !          3194:                                t = Pbase(t)->b_name->tp;
        !          3195:                                goto xx;
        !          3196:                        case FLOAT:
        !          3197:                        case DOUBLE:
        !          3198:                        case LDOUBLE:
        !          3199:                        case PTR:
        !          3200:                                if (b == DEREF) break;
        !          3201:                        case CHAR:
        !          3202:                        case SHORT:
        !          3203:                        case INT:
        !          3204:                        case LONG:
        !          3205:                        case EOBJ:
        !          3206: //                              if (found==0 || found->tp->check(on->tp,0)) {
        !          3207: //error('d',"found %n on %n",found,on);
        !          3208:                        {       Pname xx = found;
        !          3209:                                 if (found == 0) {
        !          3210:                                         i = 1;
        !          3211:                                         found = on;
        !          3212:                                 }
        !          3213:                                 else if ((found = really_dominate(found,on,const_obj)) == 0) {
        !          3214:                                         i = 2;
        !          3215:                                         found = on;
        !          3216:                                         error("two conversions for%nO in%kE: %n and %n",cn,b,xx,on);
        !          3217:                                        return e;
        !          3218:                                }
        !          3219:                        }
        !          3220:                        }
        !          3221:                }
        !          3222: //error('d',"i %d",i);
        !          3223:                switch (i) {
        !          3224:                case 0:
        !          3225:                        error("%nO in%kE",cn,b);
        !          3226:                        return e;
        !          3227: /*
        !          3228:                case 1:
        !          3229:                {       Pname xx = new name(found->string);
        !          3230:                        Pref r = new ref(DOT,e,xx);
        !          3231:                        Pexpr rr = r->typ(tbl);
        !          3232:                        Pexpr c = new expr(G_CALL,rr,0);
        !          3233: 
        !          3234:                        if (e->lval(0)) {
        !          3235:                        //      Pref r = new ref(DOT,e,found);
        !          3236:                        //      r->tp = found->tp;
        !          3237:                        //      Pexpr c = new expr(G_CALL,r,0);
        !          3238:                        //      c->fct_name = found;
        !          3239:                                return c->typ(tbl);
        !          3240:                        }
        !          3241:                        else {  // (temp=init,temp.coerce())
        !          3242:                                Pname tmp = make_tmp('U',e->tp,tbl); 
        !          3243:                                Pexpr ass = init_tmp(tmp,e,tbl);
        !          3244:                        //      Pref r = new ref(DOT,tmp,found);
        !          3245:                        //      Pexpr rr = r->typ(tbl);
        !          3246:                        //      Pexpr c = new expr(G_CALL,rr,0);
        !          3247:                        //      c->fct_name = found;
        !          3248:                                ass = new expr(CM,ass,c);
        !          3249:                                return ass->typ(tbl);
        !          3250:                        }
        !          3251:                }
        !          3252: */
        !          3253:                case 1:
        !          3254:                {       Pname xx = new name(found->string);
        !          3255:                        Pexpr c;
        !          3256: 
        !          3257:                        if (e->lval(0)) {
        !          3258:                                Pref r = new ref(DOT,e,xx);
        !          3259:                                Pexpr rr = r->typ(tbl);
        !          3260:                                c = new expr(G_CALL,rr,0);
        !          3261:                        }
        !          3262:                        else {  // (temp=init,temp.coerce())
        !          3263:                                Pname tmp = make_tmp('U',e->tp,tbl); 
        !          3264:                                Pexpr ass = init_tmp(tmp,e,tbl);
        !          3265:                                Pref r = new ref(DOT,tmp,xx);
        !          3266:                                Pexpr rr = r->typ(tbl);
        !          3267:                                c = new expr(G_CALL,rr,0);
        !          3268:                                c = new expr(CM,ass,c);
        !          3269:                        }
        !          3270:                        return c->typ(tbl);
        !          3271:                }
        !          3272:        //      default:
        !          3273:        //              error("%d possible conversions for%nO in%kE",i,cn,b);
        !          3274:        //              return e;
        !          3275:                }
        !          3276:                
        !          3277:        }
        !          3278:        if (e->tp->memptr()) {
        !          3279:                e = new mdot("i",e);
        !          3280:                e->i1 = 9;
        !          3281:                e = new expr(NE,e,zero);
        !          3282:        }
        !          3283:        else if (e->tp->num_ptr(b) == FCT)
        !          3284:                error("%k(F)",b);
        !          3285:        return e;
        !          3286: }
        !          3287: 
        !          3288: void stmt::dcl()
        !          3289: /*
        !          3290:        typecheck statement "this" in scope "curr_block->tbl"
        !          3291: */
        !          3292: {
        !          3293:        Pstmt ss;
        !          3294:        Pname n;
        !          3295:        Pname nn;
        !          3296:        Pstmt ostmt = Cstmt;
        !          3297:        DB( if(Ddebug>=1) error('d',&where,"'%k'->stmt::dcl()",base); );
        !          3298:        for (ss=this; ss; ss=ss->s_list) {
        !          3299:                Pstmt old_loop, old_switch;
        !          3300:                Cstmt = ss;
        !          3301:                enum_promote = 0;
        !          3302:                Ptable tbl = curr_block->memtbl;
        !          3303: //error('d',"stmt::dcl %k",ss->base);
        !          3304:                switch (ss->base) {
        !          3305:                case BREAK:
        !          3306:                        inline_restr |= 16;
        !          3307:                        if (curr_loop==0 && curr_switch==0)
        !          3308:                                error("break not in loop or switch");
        !          3309:                        ss->reached();
        !          3310:                        break;
        !          3311: 
        !          3312:                case CONTINUE:
        !          3313:                        inline_restr |= 32;
        !          3314:                        if (curr_loop == 0) error("continue not in loop");
        !          3315:                        ss->reached();
        !          3316:                        break;
        !          3317: 
        !          3318:                case DEFAULT:
        !          3319:                        if (curr_switch == 0) {
        !          3320:                                error("default not in switch");
        !          3321:                                break;
        !          3322:                        }
        !          3323:                        if (curr_switch->has_default) error("two defaults in switch");
        !          3324:                        curr_switch->has_default = ss;
        !          3325:                        ss->s->s_list = ss->s_list;
        !          3326:                        ss->s_list = 0;
        !          3327:                        ss->s->dcl();
        !          3328:                        break;
        !          3329: 
        !          3330:                case SM:
        !          3331:                {       if (ss->e ==0) break;
        !          3332:                        TOK b = ss->e->base;
        !          3333:                        switch (b) {
        !          3334:                        case DUMMY:
        !          3335:                                ss->e = 0;
        !          3336:                                break;
        !          3337:                                        // check for unused results
        !          3338:                                        // don't check operators that are likely
        !          3339:                                        // to be overloaded to represent "actions":
        !          3340:                                        // ! ~ < <= > >= << >>
        !          3341:                        case EQ:
        !          3342:                        case NE:
        !          3343:                        case PLUS:
        !          3344:                        case MINUS:
        !          3345:                        case REF:
        !          3346:                        case DOT:
        !          3347:                        case MUL:
        !          3348:                        case DIV:
        !          3349:                        case ADDROF:
        !          3350:                        case AND:
        !          3351:                        case OR:
        !          3352:                        case ER:
        !          3353:                        case DEREF:
        !          3354:                        case ANDAND:
        !          3355:                        case OROR:
        !          3356:                        case NAME:
        !          3357:                        case VALUE:
        !          3358:                                if (ss->e->tp) break;   // avoid looking at generated code
        !          3359:                                ss->e = ss->e->typ(tbl);
        !          3360:                                if (ss->e->base == CALL) break;
        !          3361:                                if (ss->e->tp->base != VOID) {
        !          3362:                                        if ( ss->e->base == DEREF )
        !          3363:                                           error('w',"result of %sE not used",ss->e->e2?"[]":"*");
        !          3364:                                        else 
        !          3365:                                           error('w',"result of%kE not used",b);
        !          3366:                                        if (ss->e->not_simple()==0) ss->e = dummy;
        !          3367:                                }
        !          3368:                                break;
        !          3369:                        default:
        !          3370:                                ss->e = ss->e->typ(tbl);
        !          3371:                        }
        !          3372:                        break;
        !          3373:                }
        !          3374:                case RETURN:
        !          3375:                {       Pname fn = cc->nof;
        !          3376:                        Pfct f = Pfct(fn->tp);
        !          3377:                        Ptype rt = f->returns;
        !          3378:                        Pexpr v = ss->e;
        !          3379: //error('d',"rt %t",rt);
        !          3380:                        while (rt->base == TYPE) rt = Pbase(rt)->b_name->tp;
        !          3381:                        if (v != dummy) {
        !          3382:                                if (rt->base == RPTR || rt->base == PTR) {
        !          3383:                                        const_ptr = Pbase(Pptr(rt)->typ)->tconst();
        !          3384:                                }
        !          3385:                                if (rt->base == RPTR) {
        !          3386:                                        ref_initializer++;
        !          3387:                                        v = v->typ(tbl);
        !          3388:                                        ref_initializer--;
        !          3389:                                } else
        !          3390:                                        v = v->typ(tbl);
        !          3391:                                const_ptr = 0;
        !          3392: 
        !          3393:                                if (fn->n_oper==CTOR
        !          3394:                                || fn->n_oper==DTOR
        !          3395:                                || (rt->base==VOID && v->tp!=void_type)) {
        !          3396:                                        error("unexpected return value");
        !          3397:                                        // refuse to return the value:
        !          3398:                                        ss->e = dummy;
        !          3399:                                }
        !          3400:                                else {
        !          3401:                                        switch (rt->base) {
        !          3402:                                        // case TYPE: laready done above
        !          3403:                                        case RPTR:
        !          3404:                                                switch (v->base) {
        !          3405:                                                case NAME:
        !          3406:                                                        if (Pname(v)->n_scope==FCT
        !          3407:                                                        || Pname(v)->n_scope==ARG)
        !          3408:                                                                error('w',"R to localV returned");
        !          3409:                                                        break;
        !          3410:                                                case ICON:
        !          3411:                                                case CCON:
        !          3412:                                                case FCON:
        !          3413:                                                case STRING:
        !          3414:                                                        if (Pptr(rt)->typ->tconst()==0)
        !          3415:                                                                error('w',"R to literal returned");
        !          3416:                                                }
        !          3417:                                                v = ref_init(Pptr(rt),v,tbl);
        !          3418:                                                if (v->base==G_CM
        !          3419:                                                && v->e2->base==G_ADDROF
        !          3420:                                                && v->e2->e2->base==NAME)
        !          3421:                                                        error('w',"R to temporary returned (return value is not lvalue or of wrongT)");
        !          3422:                                        case ANY:
        !          3423:                                                break;
        !          3424:                                        case COBJ:
        !          3425: if (v->base == DEREF) {
        !          3426:        Pexpr v1 = v->e1;
        !          3427:        if (v1->base==CAST) {
        !          3428:                Pexpr v2 = v1->e1;
        !          3429:                if (v2->base == G_CM) { // *(T)(e1,e2) => (e1,*(T)e2)
        !          3430:                        Pexpr v3 = v2->e2;
        !          3431:                        v2->e2 = v;
        !          3432:                        v2->tp = v->tp;
        !          3433:                        v = v2;
        !          3434:                        v1->e1 = v3;
        !          3435:                }
        !          3436:        }
        !          3437: }
        !          3438:        if (f->f_result) {
        !          3439:                if (v->base==G_CM && rt->check(v->tp,0/*ASSIGN*/)==0)
        !          3440:                        v = replace_temp(v,f->f_result);
        !          3441:                else {
        !          3442:                        v = class_init(f->f_result->contents(),rt,v,tbl);
        !          3443:                        Pname rcn = rt->is_cl_obj();
        !          3444:                        if (Pclass(rcn->tp)->has_itor()==0) {
        !          3445:                                // can happen for virtuals and for user defined conversions
        !          3446:                                v->tp = rt;
        !          3447:                                v = new expr(ASSIGN,f->f_result->contents(),v);
        !          3448:                                v->tp = rt;
        !          3449:                        }
        !          3450:                }
        !          3451:        }
        !          3452:        else
        !          3453:                v = class_init(0,rt,v,tbl);
        !          3454:                                                break;
        !          3455:                                        case PTR:
        !          3456:                                        {       Pexpr x = v;
        !          3457:                                                v = ptr_init(Pptr(rt),v,tbl);
        !          3458:                                                if (v->base == ADDROF
        !          3459:                                                && v->e2->base == NAME
        !          3460:                                                && Pname(v->e2)->n_stclass == AUTO)
        !          3461:                                                        error('w',"P to local variable%n returned",Pname(v->e2));
        !          3462:                                        //      if (v==x ||v->e2==x) goto def;
        !          3463:                                                if (Pchecked == 0) goto def;
        !          3464:                                                goto ret_save;
        !          3465:                                        //      break;
        !          3466:                                        }
        !          3467:                                        case INT:
        !          3468:                                        case CHAR:
        !          3469:                                        case LONG:
        !          3470:                                        case SHORT:
        !          3471:                                                if (Pbase(rt)->b_unsigned
        !          3472:                                                && v->base==UMINUS
        !          3473:                                                && v->e2->base==ICON)
        !          3474:                                                        error('w',"negative returned fromF returning unsigned");
        !          3475:                                        default:
        !          3476:                                        def:
        !          3477:                                        {
        !          3478:                                                Pexpr x = try_to_coerce(rt,v,"return value",tbl);
        !          3479:                                                if (x)
        !          3480:                                                        v = x;
        !          3481:                                                else if (rt->check(v->tp,ASSIGN))
        !          3482:                                                        error("bad return valueT for%n:%t (%tX)",fn,v->tp,rt);
        !          3483:                                        }
        !          3484: 
        !          3485:                                        }
        !          3486:                                ret_save:
        !          3487:                                        ss->ret_tp = rt;
        !          3488:                                        ss->e = v;
        !          3489:                                }
        !          3490:                        }
        !          3491:                        else {
        !          3492:                                if (rt->base != VOID) error("return valueX");
        !          3493:                        }
        !          3494:                        ss->reached();
        !          3495:                        break;
        !          3496:                }
        !          3497: 
        !          3498:                case DO:        // in DO the stmt is before the test
        !          3499:                        inline_restr |= 8;
        !          3500:                        old_loop = curr_loop;
        !          3501:                        curr_loop = ss;
        !          3502:                        { Pstmt st = ss->s;
        !          3503:                          while(st && st->base == FOR) st = st->for_init;
        !          3504:                          if (st && st->base == DCL)
        !          3505:                                if (st==ss->s) error("D as onlyS in do-loop");
        !          3506:                        }
        !          3507:                        ss->s->dcl();
        !          3508:                        ss->e = ss->e->typ(tbl);
        !          3509:                        ss->e = check_cond(ss->e,DO,tbl);
        !          3510:                        curr_loop = old_loop;
        !          3511:                        break;
        !          3512: 
        !          3513:                case WHILE:
        !          3514:                        inline_restr |= 8;
        !          3515:                        old_loop = curr_loop;
        !          3516:                        curr_loop = ss;
        !          3517:                        ss->e = ss->e->typ(tbl);
        !          3518:                        ss->e = check_cond(ss->e,WHILE,tbl);
        !          3519:                        { Pstmt st = ss->s;
        !          3520:                          while(st && st->base == FOR) st = st->for_init;
        !          3521:                          if (st && st->base == DCL)
        !          3522:                                if(st==ss->s) error("D as onlyS in while-loop");
        !          3523:                        }
        !          3524:                        ss->s->dcl();
        !          3525:                        curr_loop = old_loop;
        !          3526:                        break;
        !          3527: 
        !          3528:                case SWITCH:
        !          3529:                {       int ne = 0;
        !          3530:                        inline_restr |= 4;
        !          3531:                        old_switch = curr_switch;
        !          3532:                        curr_switch = ss;
        !          3533:                        ss->e = ss->e->typ(tbl);
        !          3534:                        ss->e = check_cond(ss->e,SWITCH,tbl);
        !          3535:                        { Pstmt st = ss->s;
        !          3536:                          while(st && st->base == FOR) st = st->for_init;
        !          3537:                          if (st && st->base == DCL)
        !          3538:                                if(st==ss->s) error("D as onlyS in switchS");
        !          3539:                        }
        !          3540:                        {       Ptype tt = ss->e->tp;
        !          3541:                        sii:
        !          3542:                                switch (tt->base) {
        !          3543:                                case TYPE:
        !          3544:                                        tt = Pbase(tt)->b_name->tp; goto sii;
        !          3545:                                case EOBJ:
        !          3546:                                        ne = Penum(Pbase(tt)->b_name->tp)->no_of_enumerators;
        !          3547:                                case ZTYPE:
        !          3548:                                case ANY:
        !          3549:                                case CHAR:
        !          3550:                                case SHORT:
        !          3551:                                case INT:
        !          3552:                                case LONG:
        !          3553:                                case FIELD:
        !          3554:                                        break;
        !          3555:                                default:
        !          3556:                                        error("%t switchE",ss->e->tp);
        !          3557:                                }
        !          3558:                        }
        !          3559:                        ss->s->dcl();
        !          3560:                        if (ne) {       /* see if the number of cases is "close to"
        !          3561:                                           but not equal to the number of enumerators
        !          3562:                                        */
        !          3563:                                int i = 0;
        !          3564:                                Pstmt cs;
        !          3565:                                for (cs=ss->case_list; cs; cs=cs->case_list) i++;
        !          3566:                                if (i && i!=ne) {
        !          3567:                                        if (ne < i) {
        !          3568:                                ee:             error('w',"switch (%t)W %d cases (%d enumerators)",ss->e->tp,i,ne);
        !          3569:                                        }
        !          3570:                                        else {
        !          3571:                                                switch (ne-i) {
        !          3572:                                                case 1: if (3<ne) goto ee;
        !          3573:                                                case 2: if (7<ne) goto ee;
        !          3574:                                                case 3: if (23<ne) goto ee;
        !          3575:                                                case 4: if (60<ne) goto ee;
        !          3576:                                                case 5: if (99<ne) goto ee;
        !          3577:                                                }
        !          3578:                                        }
        !          3579:                                }
        !          3580:                        }
        !          3581:                        curr_switch = old_switch;
        !          3582:                        break;
        !          3583:                }
        !          3584:                case CASE:
        !          3585:                        if (curr_switch == 0) {
        !          3586:                                error("case not in switch");
        !          3587:                                break;
        !          3588:                        }
        !          3589:                        ss->e = ss->e->typ(tbl);
        !          3590:                        ss->e->tp->num_ptr(CASE);
        !          3591:                        {       Ptype tt = ss->e->tp;
        !          3592:                        iii:
        !          3593:                                switch (tt->base) {
        !          3594:                                case TYPE:
        !          3595:                                        tt = Pbase(tt)->b_name->tp; goto iii;
        !          3596:                                case ZTYPE:
        !          3597:                                case ANY:
        !          3598:                                case CHAR:
        !          3599:                                case SHORT:
        !          3600:                                case INT:
        !          3601:                                case LONG:
        !          3602:                                case EOBJ:
        !          3603:                                        Neval = 0;
        !          3604:                                        long i = ss->e->eval();
        !          3605:                                        if (Neval == 0) {
        !          3606:                                                Pstmt cs;
        !          3607:                                                if (largest_int<i) error("long case value");
        !          3608:                                                for (cs=curr_switch->case_list; cs; cs=cs->case_list) {
        !          3609:                                                        if (cs->case_value == i) error("case %d used twice in switch",i);
        !          3610:                                                }
        !          3611:                                                ss->case_value = int(i);
        !          3612:                                                ss->case_list = curr_switch->case_list;
        !          3613:                                                curr_switch->case_list = ss;
        !          3614:                                        }
        !          3615:                                        else
        !          3616:                                                error("bad case label: %s",Neval);
        !          3617:                                        break;
        !          3618:                                default:
        !          3619:                                        error("%t caseE",ss->e->tp);
        !          3620:                                }
        !          3621:                        }
        !          3622:                //      if (1) {
        !          3623:                //              Neval = 0;
        !          3624:                //              long i = ss->e->eval();
        !          3625:                //              if (Neval == 0) {
        !          3626:                //                      Pstmt cs;
        !          3627:                //                      if (largest_int<i) error("long case value");
        !          3628:                //                      for (cs=curr_switch->case_list; cs; cs=cs->case_list) {
        !          3629:                //                              if (cs->case_value == i) error("case %d used twice in switch",i);
        !          3630:                //                      }
        !          3631:                //                      ss->case_value = int(i);
        !          3632:                //                      ss->case_list = curr_switch->case_list;
        !          3633:                //                      curr_switch->case_list = ss;
        !          3634:                //              }
        !          3635:                //              else
        !          3636:                //                      error("bad case label: %s",Neval);
        !          3637:                //      }
        !          3638:                        if (ss->s->s_list) error('i',"case%k",ss->s->s_list->base);
        !          3639:                        ss->s->s_list = ss->s_list;
        !          3640:                        ss->s_list = 0;
        !          3641:                        ss->s->dcl();
        !          3642:                        break;
        !          3643: 
        !          3644:                case GOTO:
        !          3645:                        inline_restr |= 2;
        !          3646:                        ss->reached();
        !          3647:                case LABEL:
        !          3648:                        /* Insert label in function mem table;
        !          3649:                           labels have function scope.
        !          3650:                        */
        !          3651:                        n = ss->d;
        !          3652:                        nn = cc->ftbl->insert(n,LABEL);
        !          3653: 
        !          3654:                        /* Set a ptr to the mem table corresponding to the scope
        !          3655:                           in which the label actually occurred.  This allows the
        !          3656:                           processing of goto's in the presence of ctors and dtors
        !          3657:                        */
        !          3658:                        if (ss->base == LABEL) {
        !          3659:                                nn->n_realscope = curr_block->memtbl;
        !          3660:                                inline_restr |= 1;
        !          3661:                        }
        !          3662: 
        !          3663:                        if (Nold) {
        !          3664:                                if (ss->base == LABEL) {
        !          3665:                                        if (nn->n_initializer) error("twoDs of label%n",n);
        !          3666:                                        nn->n_initializer = (Pexpr)1;
        !          3667:                                }
        !          3668:                                if (n != nn) ss->d = nn;
        !          3669:                        }
        !          3670:                        else {
        !          3671:                                if (ss->base == LABEL) nn->n_initializer = (Pexpr)1;
        !          3672:                                nn->where = ss->where;
        !          3673:                        }
        !          3674:                        if (ss->base == GOTO)
        !          3675:                                nn->use();
        !          3676:                        else {
        !          3677:                                if (ss->s->s_list) error('i',"label%k",ss->s->s_list->base);
        !          3678:                                ss->s->s_list = ss->s_list;
        !          3679:                                ss->s_list = 0;
        !          3680:                                nn->assign();
        !          3681:                        }
        !          3682:                        if (ss->s) ss->s->dcl();
        !          3683:                        break;
        !          3684: 
        !          3685:                case IF:
        !          3686:                {       
        !          3687:                        Pexpr ee = ss->e->typ(tbl);
        !          3688:                        if (ee->base == ASSIGN) {
        !          3689:                                Neval = 0;
        !          3690:                                (void)ee->e2->eval();
        !          3691:                                if (Neval == 0)
        !          3692:                                        error('w',"constant assignment in condition");
        !          3693:                        }
        !          3694:                        ss->e = ee = check_cond(ee,IF,tbl);
        !          3695: 
        !          3696:                        if (ss->s->base == DCL) error("D as onlyS after `if'");
        !          3697: 
        !          3698:                        // pointer to member returns with a tp set to 0
        !          3699:                        if ( ee->tp ) switch (ee->tp->base) {
        !          3700:                        case INT:
        !          3701:                        case EOBJ:
        !          3702:                        case ZTYPE:
        !          3703:                        {       long i;
        !          3704:                                Neval = 0;
        !          3705:                                i = ee->eval();
        !          3706: 
        !          3707:                                if (Neval == 0) {
        !          3708:                                        Pstmt sl = ss->s_list;
        !          3709:                                        if (i) {
        !          3710:                                                DEL(ss->else_stmt);
        !          3711:                                                ss->s->dcl();
        !          3712:                                                *ss = *ss->s;
        !          3713:                                        }
        !          3714:                                        else {
        !          3715:                                                DEL(ss->s);
        !          3716:                                                if (ss->else_stmt) {
        !          3717:                                                        ss->else_stmt->dcl();
        !          3718:                                                        *ss = *ss->else_stmt;
        !          3719:                                                }
        !          3720:                                                else {
        !          3721:                                                        ss->base = SM;
        !          3722:                                                        ss->e = dummy;
        !          3723:                                                        ss->s = 0;
        !          3724:                                                }
        !          3725:                                        }
        !          3726:                                        ss->s_list = sl;
        !          3727:                                        continue;
        !          3728:                                }
        !          3729:                        }
        !          3730:                        }
        !          3731:                        ss->s->dcl();
        !          3732:                        if (ss->else_stmt) {
        !          3733:                                if (ss->else_stmt->base == DCL) error("D as onlyS after `else'");
        !          3734:                                ss->else_stmt->dcl();
        !          3735:                        }
        !          3736:                        break;
        !          3737:                }
        !          3738:                case FOR:
        !          3739:                        inline_restr |= 8;
        !          3740:                        old_loop = curr_loop;
        !          3741:                        curr_loop = ss;
        !          3742:                        if (ss->for_init) {
        !          3743:                                Pstmt fi = ss->for_init;
        !          3744:                                switch (fi->base) {
        !          3745:                                case SM:
        !          3746:                                        if (fi->e == dummy) {
        !          3747:                                                ss->for_init = 0;
        !          3748:                                                break;
        !          3749:                                        }
        !          3750:                                        fi->dcl();
        !          3751:                                        break;
        !          3752:                                default:
        !          3753:                                        // for (stmt; e1; e2) stmt1 stmt2
        !          3754:                                        // => {stmt; for(; e1; e2) stmt1 stmt2}
        !          3755:                                        //    if stmt != declaration
        !          3756:                                        // if stmt == declaration, temporarily
        !          3757:                                        //    rewrite to avoid symbol table
        !          3758:                                        //    problems in some contexts.
        !          3759:                                        //    Then put decl back to avoid
        !          3760:                                        //    extraneous {}.
        !          3761:                                        // Note: to maintain pointers, ss
        !          3762:                                        //       must not change
        !          3763:                                {       Pstmt tmp = new stmt (SM,curloc,0);
        !          3764:                                        *tmp = *ss;     // tmp = original for
        !          3765:                                        tmp->for_init = 0;
        !          3766:                                        fi->s_list = tmp;
        !          3767:                                        *ss = *fi;
        !          3768:                                        curr_loop = old_loop;
        !          3769:                                        ss->dcl();
        !          3770:                                        tmp = ss->s_list;
        !          3771:                                        if ( ss->base == DCL
        !          3772:                                        &&   tmp->base == FOR   // sanity check
        !          3773:                                        &&   tmp->for_init == 0 // sanity check
        !          3774:                                        ) {
        !          3775:                                                // put DCL back in for init
        !          3776:                                                *fi = *ss;
        !          3777:                                                *ss = *tmp;
        !          3778:                                                ss->for_init = fi;
        !          3779:                                                fi->s_list = 0;
        !          3780:                                        } else {
        !          3781:                                                // non-decl stmt in for init
        !          3782:                                                // put stmts in block in case
        !          3783:                                                //    they follow a condition...
        !          3784:                                                // allocate tmp to be sure
        !          3785:                                                //    fields are initialized
        !          3786:                                                *fi = *ss;
        !          3787:                                                tmp = new block(ss->where,0,fi);
        !          3788:                                                tmp->own_tbl = 0;
        !          3789:                                                tmp->memtbl = curr_block->memtbl;
        !          3790:                                                tmp->permanent = ss->permanent;
        !          3791:                                                *ss = *tmp;
        !          3792:                                                tmp->permanent = 0; delete tmp;
        !          3793:                                        }
        !          3794:                                        // don't repeat stmt::dcl() for
        !          3795:                                        //    remaining stmts
        !          3796:                                        goto done;
        !          3797:                                }
        !          3798:                                }
        !          3799:                        }
        !          3800:                        if (ss->e == dummy)
        !          3801:                                ss->e = 0;
        !          3802:                        else {
        !          3803:                                ss->e = ss->e->typ(tbl);
        !          3804:                                ss->e = check_cond(ss->e,FOR,tbl);
        !          3805:                        }
        !          3806:                        { Pstmt st = ss->s;
        !          3807:                          while(st && st->base == FOR) st = st->for_init;
        !          3808:                          if (st && st->base == DCL)
        !          3809:                                if(st==ss->s) error("D as onlyS in for-loop");
        !          3810:                        }
        !          3811:                        ss->s->dcl();
        !          3812:                        ss->e2 = (ss->e2 == dummy) ? 0 : ss->e2->typ(tbl);
        !          3813:                        curr_loop = old_loop;
        !          3814:                        break;
        !          3815: 
        !          3816:                case DCL:       /* declaration after statement */
        !          3817:                {
        !          3818:                        /*      collect all the contiguous DCL nodes from the
        !          3819:                                head of the s_list. find the next statement
        !          3820:                        */
        !          3821:                        int non_trivial = 0;
        !          3822:                        int count = 0;
        !          3823:                        Pname tail = ss->d;
        !          3824:                        for (Pname nn=tail; nn; nn=nn->n_list) {
        !          3825:                                //      find tail;
        !          3826:                                //      detect non-trivial declarations
        !          3827:                                count++;
        !          3828: 
        !          3829:                                if (nn->n_list) tail = nn->n_list;
        !          3830:                                Pname n = tbl->look(nn->string,0);
        !          3831: 
        !          3832:                                if (n && n->n_table==tbl) non_trivial = 2;
        !          3833:                                if (non_trivial == 2) continue;
        !          3834:                                if ((nn->n_sto==STATIC && nn->tp->base!=FCT)
        !          3835:                                || nn->tp->is_ref()
        !          3836:                                || (nn->tp->tconst() && fct_const==0)) {
        !          3837:                                        non_trivial = 2;
        !          3838:                                        continue;
        !          3839:                                }
        !          3840: 
        !          3841:                                Pexpr in = nn->n_initializer;
        !          3842:                                if (in)
        !          3843:                                        switch (in->base) {
        !          3844:                                        case ILIST:
        !          3845:                                        case STRING:
        !          3846:                                                non_trivial = 2;
        !          3847:                                                continue;
        !          3848:                                        }
        !          3849:                                non_trivial = 1;
        !          3850:                                Pname cln = nn->tp->is_cl_obj();
        !          3851:                                if (cln == 0) cln = cl_obj_vec;
        !          3852:                                if (cln == 0) continue;
        !          3853:                                if (Pclass(cln->tp)->has_ctor()) {
        !          3854:                                        non_trivial = 2;
        !          3855:                                        continue;
        !          3856:                                }
        !          3857:                                if (Pclass(cln->tp)->has_dtor()) non_trivial = 2;
        !          3858:                        }
        !          3859: 
        !          3860:                        while( ss->s_list && ss->s_list->base==DCL ) {
        !          3861:                                Pstmt sx = ss->s_list;
        !          3862:                                tail = tail->n_list = sx->d;    // add to tail
        !          3863:                                for (nn=sx->d; nn; nn=nn->n_list) {
        !          3864:                                        //      find tail;
        !          3865:                                        //      detect non-trivial declarations
        !          3866:                                        count++;
        !          3867:                                        if (nn->n_list) tail = nn->n_list;
        !          3868:                                        Pname n = tbl->look(nn->string,0);
        !          3869:                                        if (n && n->n_table==tbl) non_trivial = 2;
        !          3870:                                        if (non_trivial == 2) continue;
        !          3871:                                        if ((nn->n_sto==STATIC && nn->tp->base!=FCT)
        !          3872:                                        || nn->tp->is_ref()
        !          3873:                                        || (nn->tp->tconst() && fct_const==0)) {
        !          3874:                                                non_trivial = 2;
        !          3875:                                                continue;
        !          3876:                                        }
        !          3877:                                        Pexpr in = nn->n_initializer;
        !          3878:                                        if (in)
        !          3879:                                                switch (in->base) {
        !          3880:                                                case ILIST:
        !          3881:                                                case STRING:
        !          3882:                                                        non_trivial = 2;
        !          3883:                                                        continue;
        !          3884:                                                }
        !          3885:                                        non_trivial = 1;
        !          3886:                                        Pname cln = nn->tp->is_cl_obj();
        !          3887:                                        if (cln == 0) cln = cl_obj_vec;
        !          3888:                                        if (cln == 0) continue;
        !          3889:                                        if (Pclass(cln->tp)->has_ctor()) {
        !          3890:                                                non_trivial = 2;
        !          3891:                                                continue;
        !          3892:                                        }
        !          3893:                                        if (Pclass(cln->tp)->has_dtor()) non_trivial = 2;
        !          3894:                                }
        !          3895:                                ss->s_list = sx->s_list;
        !          3896:                        /*      delete sx;      */
        !          3897:                        }
        !          3898: 
        !          3899:                        Pstmt next_st = ss->s_list;
        !          3900: //error('d',"dcl stmt : d %n  non_trivial %d  curr own_tbl %d  inline_restr 0%o",ss->d,non_trivial,curr_block->own_tbl,inline_restr);
        !          3901:                        if (non_trivial==2      // must
        !          3902:                        || (non_trivial==1      // might
        !          3903:                                && ( curr_block->own_tbl==0     // why not?
        !          3904:                                || inline_restr&3       /* label seen */)
        !          3905:                                )
        !          3906:                        ) {
        !          3907:                                if (curr_switch && non_trivial==2) {
        !          3908:                                        Pstmt cs = curr_switch->case_list;
        !          3909:                                        Pstmt ds = curr_switch->has_default;
        !          3910:                                        Pstmt bl;
        !          3911:                                        if (cs == 0)
        !          3912:                                                bl = ds;
        !          3913:                                        else if (ds == 0)
        !          3914:                                                bl = cs;
        !          3915:                                        else if (cs->where.line<ds->where.line)
        !          3916:                                                bl = ds;
        !          3917:                                        else
        !          3918:                                                bl = cs;
        !          3919: 
        !          3920:                                        if ((bl==0 || bl->s->base!=BLOCK) && curr_switch->s->memtbl==tbl)
        !          3921:                                                error('s',"non trivialD in switchS (try enclosing it in a block)");
        !          3922:                                }
        !          3923: 
        !          3924:                                /*      Create a new block,
        !          3925:                                        put all the declarations at the head,
        !          3926:                                        and the remainder of the slist as the
        !          3927:                                        statement list of the block.
        !          3928:                                */
        !          3929:                                //ss->base = BLOCK; //DCL 
        !          3930: 
        !          3931:                                /*      check that there are no redefinitions
        !          3932:                                        since the last "real" (user-written,
        !          3933:                                        non-generated) block
        !          3934:                                */
        !          3935:                                { Pname lastnn = 0;
        !          3936:                                  for( nn=ss->d; nn; nn=nn->n_list ) {
        !          3937:                                        Pname n;
        !          3938: //n=curr_block->memtbl->look(nn->string,0);
        !          3939: //error('d',"checking %n  lex_level: %d  n: %n  n->lex_level: %d",nn,nn->lex_level,n,n?n->lex_level:0);
        !          3940: //error('d',"   own_tbl: %d  curr_block: %d  n->n_table: %d",curr_block->own_tbl,curr_block,n->n_table);
        !          3941: //error('d',"   real_block: %d  n's real_block: %d",curr_block->memtbl->real_block,n->n_table->real_block);
        !          3942:                                        //if( curr_block->own_tbl
        !          3943:                                        if ( (n=curr_block->memtbl->look(nn->string,0))
        !          3944:                                        && n->n_table->real_block==curr_block->memtbl->real_block
        !          3945:                                        && n->tp->base!=FCT
        !          3946:                                        && n->tp->base!=OVERLOAD
        !          3947:                                        && nn->lex_level == n->lex_level ) {
        !          3948:                                                error("twoDs of%n",n);
        !          3949:                                                if (lastnn==0) ss->d=nn->n_list;
        !          3950:                                                else lastnn->n_list=nn->n_list;
        !          3951:                                        } else lastnn = nn;
        !          3952:                                  } // for nn
        !          3953:                                }
        !          3954: 
        !          3955:                                /*      attach the remainder of the s_list
        !          3956:                                        as the statement part of the block.
        !          3957:                                */
        !          3958:                                ss->s = next_st;
        !          3959:                                ss->s_list = 0;
        !          3960: 
        !          3961:                                /*      create the table in advance,
        !          3962:                                        in order to set the real_block
        !          3963:                                        ptr to that of the enclosing table
        !          3964:                                */
        !          3965:                                ss->memtbl = new table(count+4,tbl,0);
        !          3966:                                ss->memtbl->real_block = curr_block->memtbl->real_block;
        !          3967:                                Pblock(ss)->dcl(ss->memtbl);
        !          3968:                        }
        !          3969:                        else {  /*      to reduce the number of symbol tables,
        !          3970:                                        do not make a new block,
        !          3971:                                        instead insert names in enclosing block,
        !          3972:                                        and make the initializers into expression
        !          3973:                                        statements.
        !          3974:                                */
        !          3975:                                Pstmt sss = ss;
        !          3976:                                { Pname lastnn = 0;
        !          3977:                                  for( nn=ss->d; nn; nn=nn->n_list ) {
        !          3978:                                        Pname n;
        !          3979: //error('d',"nn %n",nn);
        !          3980:                                        //if( curr_block->own_tbl
        !          3981:                                        if ( (n=curr_block->memtbl->look(nn->string,0))
        !          3982:                                        && n->n_table->real_block==curr_block->memtbl->real_block
        !          3983:                                        && n->tp->base!=FCT && n->tp->base!=OVERLOAD
        !          3984:                                        && nn->lex_level == n->lex_level ) {
        !          3985:                                                error("twoDs of%n",n);
        !          3986:                                                n = 0;
        !          3987:                                                if (lastnn==0) ss->d=nn->n_list;
        !          3988:                                                else lastnn->n_list=nn->n_list;
        !          3989:                                        } else {
        !          3990:                                                n = nn->dcl(tbl,FCT);
        !          3991:                                                lastnn=nn;
        !          3992:                                        }
        !          3993: 
        !          3994:                                        if (n == 0) {
        !          3995:                                                if (ss) {
        !          3996:                                                        ss->base = SM;
        !          3997:                                                        ss->e = 0;
        !          3998:                                                }
        !          3999:                                                continue;
        !          4000:                                        }
        !          4001: //error('d',"hoisted %n to outer blk",n);
        !          4002: 
        !          4003:                                        Pexpr in = n->n_initializer;
        !          4004:                                        n->n_initializer = 0;
        !          4005: 
        !          4006:                                        if (ss) {
        !          4007:                                                sss->base = SM;
        !          4008:                                                ss = 0;
        !          4009:                                        }
        !          4010:                                        else
        !          4011:                                                sss = sss->s_list = new estmt(SM,sss->where,0,0);
        !          4012:                                        if (in) {
        !          4013:                                                switch (in->base) {
        !          4014:                                                case G_CALL:    /* constructor? */
        !          4015:                                                {
        !          4016:                                                        Pname fn = in->fct_name;
        !          4017:                                                        if (fn && fn->n_oper==CTOR) break;
        !          4018:                                                }
        !          4019:                                                default:
        !          4020:                                                        in = new expr(ASSIGN,n,in);
        !          4021:                                                        in->tp = n->tp;
        !          4022:                                                }
        !          4023:                                        //      sss->e = in->typ(tbl);
        !          4024:                                                sss->e = in;
        !          4025:                                        }
        !          4026:                                        else
        !          4027:                                                sss->e = dummy;
        !          4028:                                  } // for nn
        !          4029:                                }
        !          4030: 
        !          4031:                                ss = sss;
        !          4032:                                ss->s_list = next_st;
        !          4033:                        }
        !          4034:                        break;
        !          4035:                }
        !          4036: 
        !          4037:                case BLOCK:
        !          4038:                        Pblock(ss)->dcl(tbl);
        !          4039:                        break;
        !          4040: 
        !          4041:                case ASM:
        !          4042:                        /* save string */
        !          4043:                {
        !          4044:                        char* s = (char*)ss->e;
        !          4045:                        int ll = strlen(s);
        !          4046:                        char* s2 = new char[ll+1];
        !          4047:                        strcpy(s2,s);
        !          4048:                        ss->e = Pexpr(s2);
        !          4049:                        break;
        !          4050:                }
        !          4051:                default:
        !          4052:                        error('i',"badS(%p %d)",ss,ss->base);
        !          4053:                }
        !          4054:        }
        !          4055: done:
        !          4056:        Cstmt = ostmt;
        !          4057: }
        !          4058: 
        !          4059: void block::dcl(Ptable tbl)
        !          4060: /*
        !          4061:        Note: for a block without declarations memtbl denotes the table
        !          4062:        for the enclosing scope.
        !          4063:        A function body has its memtbl created by fct::dcl().
        !          4064: */
        !          4065: {
        !          4066:        int bit_old = bit_offset;
        !          4067:        int byte_old = byte_offset;
        !          4068:        int max_old = max_align;
        !          4069:        Pblock block_old = curr_block;
        !          4070: 
        !          4071:        if (base != BLOCK && base != DCL) error('i',"block::dcl(%d)",base);
        !          4072: 
        !          4073:        curr_block = this;
        !          4074: //error('d',"%d->block::dcl(%d) base %k",this,tbl,base);
        !          4075: //error('d',"    memtbl %d  own_tbl %d  d %n  s %k",memtbl,own_tbl,d,s?s->base:0);
        !          4076:        if (d) {
        !          4077:                own_tbl = 1;
        !          4078:                base = BLOCK;
        !          4079:                if (memtbl == 0) {
        !          4080:                        int nmem = d->no_of_names()+4;
        !          4081:                        memtbl = new table(nmem,tbl,0);
        !          4082:                        memtbl->real_block = this;
        !          4083:                        /*      this is a "real" block from the
        !          4084:                                source text, and not one created by DCL's
        !          4085:                                inside a block. */
        !          4086:                }
        !          4087:                else
        !          4088:                        if (memtbl != tbl) error('i',"block::dcl(?)");
        !          4089: 
        !          4090:                Pname nx;
        !          4091:                for (Pname n=d; n; n=nx) {
        !          4092:                        nx = n->n_list;
        !          4093:                        n->dcl(memtbl,FCT);
        !          4094:                        switch (n->tp->base) {
        !          4095:                        case CLASS:
        !          4096:                        case ANON:
        !          4097:                        case ENUM:
        !          4098:                                break;
        !          4099:                        default:
        !          4100:                                delete n;
        !          4101:                        }
        !          4102:                }
        !          4103:        }
        !          4104:        else if ( base == BLOCK ) {
        !          4105:                own_tbl = 1;
        !          4106:                if (memtbl == 0) {
        !          4107:                        int nmem = 4;
        !          4108:                        memtbl = new table(nmem,tbl,0);
        !          4109:                        memtbl->real_block = this;
        !          4110:                        /*      this is a "real" block from the
        !          4111:                                source text, and not one created by DCL's
        !          4112:                                inside a block. */
        !          4113:                } else
        !          4114:                        if (memtbl != tbl) error('i',"block::dcl(?)");
        !          4115:        } else {
        !          4116:                base = BLOCK;
        !          4117:                memtbl = tbl;
        !          4118:        }
        !          4119: 
        !          4120:        Pname odcl = Cdcl;
        !          4121:        if (s) s->dcl();
        !          4122:        if (own_tbl) {
        !          4123:                Pname m;
        !          4124:                int i;
        !          4125:                for (m=memtbl->get_mem(i=1); m; m=memtbl->get_mem(++i)) {
        !          4126:                        Ptype t = m->tp;
        !          4127: 
        !          4128: if (in_class_dcl) m->lex_level -= 1;
        !          4129: 
        !          4130:                        if (t == 0) {
        !          4131:                                if (m->n_assigned_to == 0)
        !          4132:                                   error("label %sU",m->string);
        !          4133:                                if (m->n_used == 0)
        !          4134:                                   error('w',"label %s not used", m->string);
        !          4135:                                continue;
        !          4136:                        }
        !          4137:                ll:
        !          4138:                        switch (t->base) {
        !          4139:                        case TYPE:      t = Pbase(t)->b_name->tp; goto ll;
        !          4140:                        case CLASS:
        !          4141:                        case ANON:
        !          4142:                        case ENUM:
        !          4143:                        case FCT:
        !          4144:                        //case VEC:
        !          4145:                                continue;
        !          4146:                        }
        !          4147: 
        !          4148:                        if (m->n_addr_taken == 0) {
        !          4149:                                if (m->n_used) {
        !          4150:                                        if (m->n_assigned_to) {
        !          4151:                                        }
        !          4152:                                        else if ( t->base != VEC ) {
        !          4153:                                                switch (m->n_scope) {
        !          4154:                                                case FCT:
        !          4155:                                                        Cdcl = m;
        !          4156:                                                        if (m->string[0] != '_' && m->string[1] != '_' )
        !          4157:                                                                error('w',&m->where,"%n used but not set",m);
        !          4158:                                                }
        !          4159:                                        }
        !          4160:                                }
        !          4161:                                else {
        !          4162:                                        if (m->n_assigned_to) {
        !          4163:                                        }
        !          4164:                                        else if (m->string[0]!='_' || m->string[1]!='_') {
        !          4165:                                                switch (m->n_scope) {
        !          4166:                                                case ARG:
        !          4167:                                                case FCT:
        !          4168:                                                        Cdcl = m;
        !          4169:                                                        error('w',&m->where,"%n not used",m);
        !          4170:                                                }
        !          4171:                                        }
        !          4172:                                }
        !          4173:                        }
        !          4174:                }
        !          4175:        }
        !          4176:        Cdcl = odcl;
        !          4177: 
        !          4178:        d = 0;
        !          4179: 
        !          4180:        if (bit_offset) byte_offset += SZ_WORD;
        !          4181:        bit_offset = bit_old;
        !          4182:        byte_offset = byte_old;
        !          4183:        curr_block = block_old;
        !          4184: }
        !          4185: 
        !          4186: void name::field_align()
        !          4187: /*
        !          4188:         adjust alignment
        !          4189: */
        !          4190: {
        !          4191:        Pbase fld = (Pbase)tp;
        !          4192:        int nbits = fld->b_bits;
        !          4193: 
        !          4194:        int a = (F_SENSITIVE) ? fld->b_fieldtype->align() : SZ_WORD;
        !          4195:        if (max_align < a) max_align = a;
        !          4196: 
        !          4197:        if (nbits == 0) {               // force word alignment
        !          4198:                int b;
        !          4199:                if (bit_offset)
        !          4200:                        nbits = BI_IN_WORD - bit_offset;
        !          4201:                else if (b = byte_offset%SZ_WORD)
        !          4202:                        nbits = b * BI_IN_BYTE;
        !          4203:        //      else
        !          4204:        //              nbits = BI_IN_WORD;
        !          4205:                if (max_align < SZ_WORD) max_align = SZ_WORD;
        !          4206:        }
        !          4207:        else if (bit_offset == 0) {     // take care of part of word
        !          4208:                int b = byte_offset%SZ_WORD;
        !          4209:                if (b) {
        !          4210:                        byte_offset -= b;
        !          4211:                        bit_offset = b*BI_IN_BYTE;
        !          4212:                }
        !          4213:        }
        !          4214: //error('d',"byteoff %d bitoff %d bits %d",byte_offset,bit_offset,nbits);
        !          4215:        int x = (bit_offset += nbits);
        !          4216:        if (BI_IN_WORD < x) {
        !          4217:                fld->b_offset = 0;
        !          4218:                byte_offset += SZ_WORD;
        !          4219:                bit_offset = nbits;
        !          4220:        }
        !          4221:        else {
        !          4222:                fld->b_offset = bit_offset;
        !          4223:                if (BI_IN_WORD == x) {
        !          4224:                        bit_offset = 0;
        !          4225:                        byte_offset += SZ_WORD;
        !          4226:                }
        !          4227:                else
        !          4228:                        bit_offset = x;
        !          4229:        }
        !          4230:        n_offset = byte_offset;
        !          4231: }
        !          4232: 0707071010112043701004440001630000160000010172500466055376100000700000171674dcl3.c/*ident     "@(#)ctrans:src/dcl3.c  1.7" */
        !          4233: /**************************************************************************
        !          4234: 
        !          4235:        C++ source for cfront, the C++ compiler front-end
        !          4236:        written in the computer science research center of Bell Labs
        !          4237: 
        !          4238:        Copyright (c) 1984 AT&T, Inc. All Rights Reserved
        !          4239:        THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T, INC.
        !          4240: 
        !          4241: dcl3.c:
        !          4242:        Routines used by ::dcl fucntions: fct::dcl() etc.
        !          4243: 
        !          4244: *****************************************************************************/
        !          4245: 
        !          4246: #include "cfront.h"
        !          4247: #include "size.h"
        !          4248: #include "template.h"
        !          4249: 
        !          4250: static void vbase_pointers(Pname fn, Pclass cl)
        !          4251: /*
        !          4252:        insert argument for virtual base pointers (if any)
        !          4253:        after f_this and before f_argtype
        !          4254: */
        !          4255: {
        !          4256: //error('d',"vbase_pointers(%n,%t) %d %k",fn,cl,fn->tp,fn->n_oper);
        !          4257:        Pfct f = Pfct(fn->tp);
        !          4258:        if (fn->n_oper == CTOR) {
        !          4259:                Pname d = 0;
        !          4260:                for (Pbcl b = cl->baselist; b; b=b->next) {
        !          4261:                        if (b->base != VIRTUAL) continue;
        !          4262:                        Pname a = new name(b->bclass->string);
        !          4263:                        a->tp = b->bclass->this_type;
        !          4264:                        a->n_list = d;
        !          4265:                        a->n_table = f->body ? f->body->memtbl : 0;
        !          4266:                        a->where = fn->where;
        !          4267:                        d = a;
        !          4268:                }       
        !          4269:                                
        !          4270:                if (d) {
        !          4271:                        for (Pname dd =d;;) {
        !          4272:                                if (d->n_list == 0) {
        !          4273:                                        d->n_list = f->f_args->n_list;
        !          4274:                                        break;
        !          4275:                                }
        !          4276:                                d = d->n_list;
        !          4277:                        }
        !          4278:                        f->f_args->n_list = dd;
        !          4279:                }
        !          4280:        }
        !          4281:        if (fn->n_oper == DTOR) {       // add __free argument
        !          4282: //error('d',"add __free to %n",fn);
        !          4283:                Pname fa = new name;
        !          4284:                fa->tp = int_type;
        !          4285:                fa->n_scope = ARG;
        !          4286:                fa->where = fn->where;
        !          4287: 
        !          4288:                Pname a = f->f_args;
        !          4289:                if (a == 0)
        !          4290:                        f->f_args = fa;
        !          4291:                else {
        !          4292:                        for(;;a = a->n_list) {
        !          4293: // error('d',"a %d %t",a,a->tp);
        !          4294:                                if (a->n_list == 0) {
        !          4295:                                        a->n_list = fa;
        !          4296:                                        break;
        !          4297:                                }
        !          4298:                        }
        !          4299:                }
        !          4300:        }
        !          4301: }
        !          4302: 
        !          4303: void make_res(Pfct f)
        !          4304: /*
        !          4305:        returns X where X(X&) has been declared
        !          4306:        add "_result" argument of type X*
        !          4307: */
        !          4308: {
        !          4309:        Pname cl = f->returns->is_cl_obj();
        !          4310:        if (cl==0 || Pclass(cl->tp)->has_itor()==0) return;
        !          4311: 
        !          4312:        Pname rv = new name("_result");
        !          4313:        rv->tp  = f->returns->addrof();
        !          4314:        rv->n_scope = FCT;      // not a ``real'' argument
        !          4315:        rv->n_used = 1;
        !          4316:        rv->n_list = f->argtype;
        !          4317:        if (f->f_this)
        !          4318:                f->f_this->n_list = rv;
        !          4319:        else
        !          4320:                f->f_args = rv;
        !          4321:        f->f_result = rv;
        !          4322:        f->s_returns = void_type;
        !          4323: }
        !          4324: 
        !          4325: void name::check_oper(Pname cn)
        !          4326: /*
        !          4327:        check declarations of operators, ctors, dtors
        !          4328: */
        !          4329: {
        !          4330: // error('d', "%n->check_oper( %n ): n_oper: %k", this, cn, n_oper );
        !          4331:        switch (n_oper) {
        !          4332:        case CALL:
        !          4333:        case DEREF:
        !          4334:        case REF:
        !          4335:                if (cn == 0) error("operator%s must be aM",keys[n_oper]);
        !          4336:                break;
        !          4337:        case ASPLUS:
        !          4338:        case ASMINUS:
        !          4339:        case ASMUL:
        !          4340:        case ASDIV:
        !          4341:        case ASMOD:
        !          4342:        case ASAND:
        !          4343:        case ASOR:
        !          4344:        case ASER:
        !          4345:        case ASLS:
        !          4346:        case ASRS:
        !          4347:                if ( warning_opt ) {
        !          4348:                        if ( cn == 0 || Pfct(tp)->f_static )
        !          4349:                                error('w', "operator%s should be a non-staticMF",keys[n_oper]);
        !          4350:                }
        !          4351:                break;
        !          4352:        case ASSIGN:
        !          4353:                if (cn == 0) 
        !          4354:                        error(strict_opt?0:'w',"non-member operator%k() (anachronism)",n_oper);
        !          4355:                break;
        !          4356:        case NOT:       /* unary operators only */
        !          4357:        case COMPL:
        !          4358:        // case INCR:
        !          4359:        // case DECR:
        !          4360:                Pfct f = Pfct(tp);
        !          4361:                if (cn && f->argtype) 
        !          4362:                        error("%n::%n takes noA",cn, this);
        !          4363:                else if (f->nargs == 2)
        !          4364:                        error("%n takes 1A only",this);
        !          4365:                break;
        !          4366:        case INCR:
        !          4367:        case DECR:
        !          4368:                // check for postscript instance
        !          4369:                f = Pfct(tp);
        !          4370:                if (cn) { // member
        !          4371:                        if ( f->argtype && f->nargs == 1 ) {
        !          4372:                                Pname n = f->argtype;
        !          4373:                                if ( n->tp->base != INT )
        !          4374:                                        error("%n must takeA ofT int, not %t",this,n->tp);
        !          4375:                        }
        !          4376:                }
        !          4377:                else 
        !          4378:                if (f->nargs == 2) { // non-member
        !          4379:                        Pname n = f->argtype->n_list;
        !          4380:                        if ( n->tp->base != INT )
        !          4381:                                error("%n must takeA ofT int, not %t",this,n->tp);
        !          4382:                }
        !          4383:                break;
        !          4384: 
        !          4385:        case 0:
        !          4386:        case TNAME:     /* may be a constructor */
        !          4387:                if (cn && ((strcmp(cn->string,string)==0) ||
        !          4388:                        ((Pclass(cn->tp)->class_base == 
        !          4389:                                instantiated_template_class) &&
        !          4390:                        (strcmp(string, 
        !          4391:                                Ptclass(cn->tp)->unparametrized_tname()->string) == 0)))) 
        !          4392:                {
        !          4393:                        if (tp->base == FCT) {
        !          4394:                                Pfct f = Pfct(tp);
        !          4395:                                if (f->returns!=defa_type)
        !          4396:                                        error("%s::%s()W returnT",string,string);
        !          4397:                                f->returns = void_type;
        !          4398:                                string = "__ct";
        !          4399:                                n_oper = CTOR;
        !          4400:                        }
        !          4401:                        else
        !          4402:                                error('s',"struct%nM%n",cn,cn);
        !          4403:                }
        !          4404:                else
        !          4405:                        n_oper = 0;
        !          4406:                break;
        !          4407:        case DTOR:      /* must be a destructor */
        !          4408: //error('d',"dtor %s",string);
        !          4409:                if (cn == 0) {
        !          4410:                        n_oper = 0;
        !          4411:                        error("destructor ~%s() not inC",string);
        !          4412:                }
        !          4413:                 else 
        !          4414:                if ((strcmp(cn->string,string) == 0) ||
        !          4415:                        ((Pclass(cn->tp)->class_base ==
        !          4416:                                instantiated_template_class) &&
        !          4417:                          (strcmp(string,
        !          4418:                                Ptclass(cn->tp)->unparametrized_tname()->string)==0)))
        !          4419:                {
        !          4420:                dto:
        !          4421:                        Pfct f = (Pfct)tp;
        !          4422:                        string = "__dt";
        !          4423:                        if (tp->base != FCT) {
        !          4424:                                error("%s::~%s notF",cn->string,cn->string);
        !          4425:                                tp = new fct(void_type,0,1);
        !          4426:                        }
        !          4427:                        else if (f->returns!=defa_type/* && f->returns!=void_type*/) {
        !          4428:                                if ( f->returns != void_type ||
        !          4429:                                        f->body != 0 || friend_in_class == 0 ) 
        !          4430:                                                error("%s::~%s()W returnT",cn->string,cn->string);
        !          4431:                        }
        !          4432: 
        !          4433:                        if (f->argtype) {
        !          4434:                                error("%s::~%s()WAs",cn->string,cn->string);
        !          4435:                                f->nargs = 0;
        !          4436:                                f->nargs_known = 1;
        !          4437:                                f->argtype = 0;
        !          4438:                        }
        !          4439:                        f->returns = void_type;
        !          4440:                }
        !          4441:                else {
        !          4442:                        if (strcmp(string,"__dt") == 0) goto dto;
        !          4443:                        error("~%s in %s",string,cn->string);
        !          4444:                        n_oper = 0;
        !          4445:                }
        !          4446:                break;
        !          4447:        case TYPE:
        !          4448: // cond stores the type of the operator function
        !          4449: // error('d',"type %t",cond);
        !          4450:                if (cn == 0) {
        !          4451:                        // error("operator%t() not aM",Ptype(n_initializer));
        !          4452:                        error("operator%t() not aM",Ptype(cond));
        !          4453:                        n_oper = 0;
        !          4454:                        // n_initializer = 0;
        !          4455:                        cond = 0;
        !          4456:                }
        !          4457:                else {
        !          4458:                        Pfct f = Pfct(tp);
        !          4459:                        // n_initializer = 0;
        !          4460:                        Ptype tx = Ptype(cond);
        !          4461:                        cond = 0;
        !          4462:                        if (f->base != FCT) error("badT for%n::operator%t()",cn,tx);
        !          4463:                        if (f->returns != defa_type) {
        !          4464:                        //      if (f->returns->check(tx,0)) error("bad resultT for%n::operator%t()",cn,tx);
        !          4465:                                error("resultT for%n::operator%t()",cn,tx);
        !          4466:                                DEL(f->returns);
        !          4467:                        }
        !          4468:                        if (f->argtype) {
        !          4469:                                error("%n::operator%t()WAs",cn,tx);
        !          4470:                                f->argtype = 0;
        !          4471:                        }
        !          4472:                        f->returns = tx;
        !          4473:                        Pname nx = tx->is_cl_obj();
        !          4474:                        if (nx && can_coerce(tx,cn->tp)) error("both %n::%n(%n) and %n::operator%t()",cn,cn,nx,tx);
        !          4475:                        char buf[1024];
        !          4476:                        char* bb = tx->signature(buf);
        !          4477:                        int l2 = bb-buf;
        !          4478:                        if (1023<l2) error('i',"N::check_oper():N buffer overflow");
        !          4479:                        char* p = new char[l2+5];
        !          4480:                        p[0] = '_';
        !          4481:                        p[1] = '_';
        !          4482:                        p[2] = 'o';
        !          4483:                        p[3] = 'p';
        !          4484:                        strcpy(p+4,buf);
        !          4485:                        string = p;
        !          4486:                }
        !          4487:                break;
        !          4488:        }
        !          4489: }
        !          4490: 
        !          4491: Pexpr vbase_args(Pfct a, Pname bn)
        !          4492: /*
        !          4493:        constructor a calls the constructor bn for a base class
        !          4494:        generate argument list needed for virtual base arguments
        !          4495: */
        !          4496: {
        !          4497:        Pfct b = Pfct(bn->tp);
        !          4498: //error('d',"vbase_args%n: %t %k",bn,b,b->base);
        !          4499:        Pexpr args = 0;
        !          4500:        Pexpr tail = 0;
        !          4501:        if (b->base == OVERLOAD) b = Pfct(Pgen(b)->fct_list->f->tp);    // doesn't matter which
        !          4502:        for (Pname d = b->f_args->n_list; d!=b->argtype; d=d->n_list) {
        !          4503:                for (Pname dd = a->f_args->n_list; dd; dd=dd->n_list)
        !          4504:                        // using strcmp is a trick
        !          4505:                        if (strcmp(dd->string,d->string)==0) break;
        !          4506: 
        !          4507:                Pexpr aa = new expr(ELIST,dd,0);
        !          4508:                if (args == 0)
        !          4509:                        args = aa;
        !          4510:                else
        !          4511:                        tail->e2 = aa;
        !          4512:                tail = aa;
        !          4513:        }
        !          4514:        return args;
        !          4515: }
        !          4516: 
        !          4517: void fct::init_bases(Pclass cl, Pexpr)
        !          4518: /*
        !          4519:        in "cl"'s constructor "this" generate code to initialize base classes
        !          4520:        and members using the initializers "f->f_init"
        !          4521:        
        !          4522:        this->f_init == list of names of classes to be initialized
        !          4523:                COLON(b)        => base class b
        !          4524:                                => constructor call in f_init->n_initializer
        !          4525:                COLON()         => unnamed base class
        !          4526:                                => constructor call in f_init->n_initializer
        !          4527:                NAME(m)         => member m
        !          4528:                                => constructor call in m->n_initializer
        !          4529: */
        !          4530: {
        !          4531:        Ptable ftbl = body->memtbl;
        !          4532:        DB( if(Ddebug>=1) error('d',"init_bases %t init %d",cl,f_init); );
        !          4533: 
        !          4534:        // explicit initializers
        !          4535:        if ( cl && cl->csu == UNION && f_init && f_init->n_list )
        !          4536:                error(&f_init->where,"multipleIrs in unionK %s:: %s",cl->string,cl->string);
        !          4537:        for (Pname nx, nn=f_init; nn; delete nn,(nn=nx) ) {
        !          4538:                Pexpr i = nn->n_initializer;
        !          4539:                nn->n_initializer = 0;
        !          4540:                nx = nn->n_list;
        !          4541: 
        !          4542: // error('d',"init_base %s %d",nn->string,i);
        !          4543:                if (nn->string) {
        !          4544:                        // lookup in case type name hides a "real" member
        !          4545:                        { Pname mmm = cl->memtbl->look(nn->string,0);
        !          4546:                          if ( mmm ) nn->base = mmm->base;
        !          4547:                        }
        !          4548:                        if (nn->base == TNAME) {        // base class
        !          4549:                                char *bn;
        !          4550:                                while ( nn->tp && nn->tp->base == TYPE )
        !          4551:                                        nn->tp = Pbase(nn->tp)->b_name->tp;
        !          4552:                                if ( nn->tp && nn->tp->base == COBJ )
        !          4553:                                    bn = Pbase(nn->tp)->b_name->string;
        !          4554:                                else
        !          4555:                                    bn = nn->string;
        !          4556:                                for (Pbcl l = cl->baselist; l; l=l->next) {
        !          4557:                                        Pclass bcl = l->bclass;
        !          4558:                                        if ((strcmp(bcl->string,bn) == 0) ||
        !          4559:                                                ((bcl->class_base ==
        !          4560:                                                        instantiated_template_class) &&
        !          4561:                                                ((strcmp(nn->string,
        !          4562:                                                        Ptclass(bcl)->unparametrized_tname()->string)) == 0)))
        !          4563:                                        {
        !          4564: 
        !          4565:                                                // l->init is zeroed out in ctor_simpl
        !          4566:                                                // if error_count, simpl() not invoked
        !          4567:                                                if (l->init && error_count == 0) 
        !          4568:                                                        error("twoIrs for%t",bcl);
        !          4569:                                                else
        !          4570:                                                        l->init = base_init(bcl,i,ftbl,l->obj_offset);
        !          4571:                                                goto con;
        !          4572:                                        }
        !          4573:                                }
        !          4574:                                error(&nn->where,"unexpectedAL: noBC%n",nn);
        !          4575:                        con:
        !          4576:                                continue;
        !          4577:                        }
        !          4578:                        else {  // member initializer
        !          4579:                                Pname m = cl->memtbl->look(nn->string,0);
        !          4580:                                if (m && m->n_table==cl->memtbl)
        !          4581:                                        m->n_initializer = mem_init(m,i,ftbl);
        !          4582:                                else
        !          4583:                                        error(&nn->where,"%n not inC %s",nn,cl->string);
        !          4584:                        }
        !          4585:                }
        !          4586:                else {                  // unnamed base class
        !          4587:                        Pbcl l = cl->baselist;
        !          4588:                        if (l == 0) {
        !          4589:                                error("unexpectedAL: noBC called");
        !          4590:                                continue;
        !          4591:                        }
        !          4592: 
        !          4593:                        if (l->next) {
        !          4594:                                bit cnt = 0, rvb = 0; // remote virtual base classes
        !          4595:                                for (Pbcl ll = l; ll; ll = ll->next, ++cnt ) 
        !          4596:                                        if (ll->base==VIRTUAL && ll->promoted) ++rvb;
        !          4597:                                if ( rvb ) 
        !          4598:                                        error("unnamedBCIr: %dBCes(%d non-explicit virtualBC%s)",cnt,rvb,rvb==1?"":"es");
        !          4599:                                else error("unnamedBCIr: %dBCes",cnt);
        !          4600:                                continue;
        !          4601:                        }
        !          4602:                        
        !          4603:                        if (l->init)
        !          4604:                                error("twoIrs for%t",l->bclass);
        !          4605:                        else {
        !          4606:                                error(strict_opt?0:'w',&nn->where,"N ofBC%t missing from BCIr (anachronism)",l->bclass);
        !          4607:                                l->init = base_init(l->bclass,i,ftbl,l->obj_offset);
        !          4608:                        }
        !          4609:                }
        !          4610:        } // for
        !          4611: 
        !          4612:        for (Pbcl l = cl->baselist; l; l=l->next) {
        !          4613:                // default initialization of base classes
        !          4614:                Pname ctor;
        !          4615:                Pclass bcl = l->bclass;
        !          4616:                if (l->init==0 && (ctor=bcl->has_ctor()))
        !          4617:                        l->init = base_init(bcl,0,ftbl,l->obj_offset);
        !          4618:        }
        !          4619: }
        !          4620: 
        !          4621: int inline_restr;      /* report use of constructs that the inline expanded
        !          4622:                           cannot handle here */
        !          4623: 
        !          4624: void fct::dcl(Pname n)
        !          4625: {
        !          4626:        int nmem = TBLSIZE;
        !          4627:        Pname a;
        !          4628:        Pname ll;
        !          4629:        Ptable ftbl;
        !          4630: 
        !          4631:        Pptr cct = 0;
        !          4632:        int const_old = const_save;
        !          4633: 
        !          4634:        int bit_old = bit_offset;
        !          4635:        int byte_old = byte_offset;
        !          4636:        int max_old = max_align;
        !          4637: 
        !          4638:        if (base != FCT) error('i',"F::dcl(%d)",base);
        !          4639:        if (body == 0) error('i',"F::dcl(body=%d)",body);
        !          4640:        if (n==0 || n->base!=NAME) error('i',"F::dcl(N=%d %d)",n,(n)?n->base:0);
        !          4641:        DB( if(Ddebug>=1) error('d',"fct::dcl(%n) %k %d %t",n,n->n_scope,body->own_tbl,this); );
        !          4642:        if (body->own_tbl) return;      // done already
        !          4643: 
        !          4644: //     if (f_inline==0 ) n->n_dcl_printed = 1; // beware of recursive calls, no decl needed
        !          4645: //     if (f_inline && debug_opt) n->n_dcl_printed = 2;
        !          4646:        if (body->memtbl == 0) body->memtbl = new table(nmem+3,gtbl,0);
        !          4647:        body->own_tbl = 1;
        !          4648:        ftbl = body->memtbl;
        !          4649:        ftbl->real_block = body;
        !          4650: 
        !          4651:        max_align = 0;//AL_FRAME;
        !          4652:        bit_offset = 0;
        !          4653: 
        !          4654:        cc->stack();
        !          4655:        cc->nof = n;
        !          4656:        cc->ftbl = ftbl;
        !          4657: 
        !          4658:        switch (n->n_scope) {
        !          4659:        case 0:
        !          4660:        case PUBLIC:
        !          4661:        {       cc->not = n->n_table->t_name;
        !          4662:                cc->cot = Pclass(cc->not->tp);
        !          4663:                cc->tot = cc->cot->this_type;
        !          4664:        //      if (f_this==0 || cc->tot==0) error('i',"F::dcl(%n): f_this=%d cc->tot=%d",n,f_this,cc->tot);
        !          4665:                if (f_this) f_this->n_table = ftbl;     // fake for inline printout
        !          4666:                cc->c_this = f_this;
        !          4667: 
        !          4668: 
        !          4669:                Pclass cl = Pclass(cc->not->tp);
        !          4670: 
        !          4671:                if (cl->c_body!=3
        !          4672:                || n->n_initializer
        !          4673:                || n->n_sto==STATIC
        !          4674:                || f_inline
        !          4675:                || f_imeasure
        !          4676:                || f_virtual==0)
        !          4677:                        ;
        !          4678:                else {          // could be the function where we need to
        !          4679:                                // output the vtbl
        !          4680:                        int i;
        !          4681:                        for (Pname nn=cl->memtbl->get_mem(i=1); nn; nn=cl->memtbl->get_mem(++i) ) {
        !          4682:                        Ptype t = nn->tp;
        !          4683:                        if (t)
        !          4684:                        switch (t->base) {
        !          4685:                        case FCT:
        !          4686:                                if (nn == n) goto prnt;
        !          4687:                                if (nn->n_initializer
        !          4688:                                || nn->n_sto==STATIC
        !          4689:                                || Pfct(nn->tp)->f_inline
        !          4690:                                || Pfct(nn->tp)->f_imeasure
        !          4691:                                || Pfct(nn->tp)->f_virtual==0) break;
        !          4692:                                goto zaq;
        !          4693: 
        !          4694:                        case OVERLOAD:
        !          4695:                        {       for (Plist gl=Pgen(t)->fct_list; gl; gl=gl->l) {
        !          4696:                                        Pname nn = gl->f;
        !          4697:                                        if (nn == n) goto prnt;
        !          4698:                                        if (nn->n_initializer
        !          4699:                                        || nn->n_sto==STATIC
        !          4700:                                        || Pfct(nn->tp)->f_inline
        !          4701:                                        || Pfct(nn->tp)->f_imeasure
        !          4702:                                        || Pfct(nn->tp)->f_virtual==0) continue;
        !          4703:                                        goto zaq;
        !          4704:                                }
        !          4705:                        }
        !          4706:                        }
        !          4707:                }
        !          4708:                        goto zaq;
        !          4709:                prnt:
        !          4710:                        cl->print_all_vtbls(cl);
        !          4711:                        goto zaq;
        !          4712:                }
        !          4713:        }
        !          4714:        }
        !          4715: zaq:
        !          4716:                // protect against: class x; x f(); class x { x(x&); ....
        !          4717:        if (f_result == 0) make_res(this);
        !          4718:        if (f_result) f_result->n_table = ftbl;         // fake for inline printout
        !          4719: 
        !          4720:        returns->tsizeof();     // make sure size is known
        !          4721: 
        !          4722:        Pname ax;
        !          4723:        for (a=argtype, ll=0; a; a=ax) {
        !          4724:                ax = a->n_list;
        !          4725:                Pname nn = a->dcl(ftbl,ARG);
        !          4726:                Pname cn = nn->tp->is_cl_obj();
        !          4727:                if (cn == 0) cn = cl_obj_vec;
        !          4728:                if (cn) (void)cn->tp->tsizeof();        // make sure it is printed
        !          4729:                nn->n_assigned_to = nn->n_used = nn->n_addr_taken = 0;
        !          4730:                nn->n_list = 0;
        !          4731: 
        !          4732:                switch (nn->tp->base) {
        !          4733:                case CLASS:
        !          4734:                case ENUM:      /* unlink types declared in arg list */
        !          4735:                        nn->dcl_print(0);
        !          4736:                        break;
        !          4737:                default:
        !          4738:                        if (ll)
        !          4739:                                ll->n_list = nn;
        !          4740:                        else
        !          4741:                                f_args = argtype = nn;
        !          4742:                        ll = nn;
        !          4743:                }
        !          4744:                delete a;
        !          4745:        }
        !          4746: 
        !          4747:        if (f_result) {         // link in f_result
        !          4748:                f_args = f_result;
        !          4749:                f_result->n_list = argtype;
        !          4750:        }
        !          4751: 
        !          4752:        if (f_this) {           // link in f_this
        !          4753:                f_args = f_this;
        !          4754:                f_this->n_list = f_result ? f_result : argtype;
        !          4755:        }
        !          4756: 
        !          4757:        if (n->n_oper==CTOR || n->n_oper==DTOR) vbase_pointers(n,cc->cot);
        !          4758: 
        !          4759:        if (n->n_oper == CTOR) {
        !          4760:                const_save = 1;
        !          4761:                init_bases(cc->cot,f_init);
        !          4762:        }
        !          4763:        else if (f_init)
        !          4764:                error(0,"unexpectedAL: not aK");
        !          4765: 
        !          4766:        PERM(returns);
        !          4767:        const_save = f_inline&&debug_opt==0;
        !          4768:        inline_restr = 0;
        !          4769:        body->dcl(ftbl);
        !          4770:        
        !          4771:        defined |= DEFINED;
        !          4772:        if (f_inline && inline_restr && returns->base!=VOID) {
        !          4773:                f_inline = 0;
        !          4774:                char* s = (inline_restr & 32) ? "continue"
        !          4775:                        : (inline_restr & 16) ? "break"
        !          4776:                        : (inline_restr & 8) ? "loop"
        !          4777:                        : (inline_restr & 4) ? "switch"
        !          4778:                        : (inline_restr & 2) ? "goto"
        !          4779:                        : (inline_restr & 1) ? "label"
        !          4780:                        : "" ;
        !          4781:                if (warning_opt) {
        !          4782:                        error('w', "\"inline\" ignored, %n contains %s",n,s);
        !          4783:                        error('w', "out-of-line copy of %n created",n);
        !          4784:                }
        !          4785:        //      if (cc->cot)
        !          4786:                n->simpl();     //BS6
        !          4787:                n->dcl_print(0);
        !          4788:        }
        !          4789:        const_save = const_old;
        !          4790: 
        !          4791:        if (f_inline && debug_opt==0) isf_list = new name_list(n,isf_list);
        !          4792: 
        !          4793:        bit_offset = bit_old;
        !          4794:        byte_offset = byte_old;
        !          4795:        max_align = max_old;
        !          4796:        cc->unstack();
        !          4797: 
        !          4798: //error('d',"fct-> returns %t",returns);
        !          4799: }
        !          4800: 
        !          4801: Pexpr fct::base_init(Pclass bcl, Pexpr i, Ptable ftbl, int offset)
        !          4802: /*
        !          4803:        have base class bcl and expr list i
        !          4804:        return "( *(base*)this ) . ctor( i )"
        !          4805:        ctor call generated in expr.typ()
        !          4806: */
        !          4807: {
        !          4808:        Ptype ty = bcl->this_type;
        !          4809:        Pexpr th = rptr(ty,f_this,offset);              // base*
        !          4810:        Pname ctor = bcl->has_ctor();
        !          4811: 
        !          4812: //error('d',"fct::B_init(C %t, i %d, %d) ctor %n",bcl,i,i?i->tp:0,ctor);
        !          4813: 
        !          4814:        Pexpr ii = (i && i->base==ELIST)?i->e1:i;
        !          4815: 
        !          4816:        if (ii
        !          4817:        && ii->base==DEREF
        !          4818:        && ii->e1->base==CAST
        !          4819:        && th->base==CAST) th->i2 = ii->e1->i2;
        !          4820: 
        !          4821:        if (ctor == 0) {
        !          4822:                if (i && i->base!=ELIST) i = new expr(ELIST,i,0);
        !          4823: 
        !          4824:                Pexpr v = new texpr(VALUE,bcl,i);       // ?.base(i)
        !          4825:                v->e2 = new expr(DEREF,th,0);           // (*(base*)this).base(i)
        !          4826:                v = v->typ(ftbl);                       // *base(&*(base*)this,i)
        !          4827: //error('d',"v %k",v->base);
        !          4828:                switch (v->base) {
        !          4829:                case DEREF:
        !          4830:                        return v->e1;                   // base(&*(base*)this,i)
        !          4831:                case ASSIGN:            // degenerate base(base&): *(base*)this=i
        !          4832:                        th = new texpr(CAST,ty,f_this);
        !          4833:                        v = new expr(CM,v,th);          // (*(base*)this=i,(base*)this);
        !          4834:                        return v->typ(ftbl);
        !          4835:                default:
        !          4836:                        return 0;
        !          4837:                }
        !          4838:        }
        !          4839: 
        !          4840: 
        !          4841:        Pname icn;
        !          4842:        if (i) {
        !          4843:                ii = ii->typ(ftbl);
        !          4844:                if (bcl->has_itor()==0
        !          4845:                && (icn=ii->tp->is_cl_obj())
        !          4846:                && (Pclass(icn->tp)==bcl || Pclass(icn->tp)->has_base(bcl))) {
        !          4847:                        // degenerate base(base&): *(base*)this=i
        !          4848:                        // memberwise copy
        !          4849: //error('d',"copy %t",ty);
        !          4850:                //      th = new cast(ty,f_this);
        !          4851:                //      th = th->contents();
        !          4852:                        th = new texpr(CAST,ty,f_this);
        !          4853:                        th = th->contents();
        !          4854:                        th = th->typ(ftbl);
        !          4855:                        if (Pclass(icn->tp)!=bcl) {     // cast needed
        !          4856:                                Pptr r = new ptr(RPTR,Pptr(ty)->typ);
        !          4857:                                ii = new texpr(CAST,r,ii);
        !          4858:                                ii = ii->typ(ftbl);
        !          4859:                        }
        !          4860:                        ii = new expr(ASSIGN,th,ii);
        !          4861:                        ii->tp = th->tp;
        !          4862:                                        // simulate `return this':
        !          4863:                                        // *(base*)this=i,(base*)this
        !          4864:                        ii = new expr(CM,ii,new cast(ty,f_this));
        !          4865:                        ii->tp = th->tp;
        !          4866:                        return ii;
        !          4867:                //      return ii->typ(ftbl);   // don't find cl::operator=()
        !          4868:                }
        !          4869:                if (i->base == ELIST) i->e1 = ii;
        !          4870:        }
        !          4871: //Pexpr x = call_ctor(ftbl,th,ctor,i,REF,vbase_args(this,ctor));
        !          4872: //error('d',"call %n %t -> %d %k",ctor,ctor->tp,x,x->base);
        !          4873: //     return x;
        !          4874:        return call_ctor(ftbl,th,ctor,i,REF,vbase_args(this,ctor));
        !          4875: }
        !          4876: 
        !          4877: 
        !          4878: Pexpr fct::mem_init(Pname mn, Pexpr i, Ptable ftbl)
        !          4879: /*
        !          4880:        return "member_ctor( m, i )"
        !          4881: */
        !          4882: {
        !          4883: // a new entry for B::B_pub, in general, has no tp and no
        !          4884: // real info: all the tp-> only work on our systems because
        !          4885: // 0 pointer dereference isn't system memory.  it core dumps
        !          4886: // in set_const since no test is made on this == 0.
        !          4887: //error('d',"mem_init %n",mn);
        !          4888: 
        !          4889: //     if (mn->n_stclass == STATIC) error('s',"MIr for static%n",mn);
        !          4890:         switch (mn->n_stclass) {
        !          4891:         case STATIC:
        !          4892:                 error("MIr for static%n",mn);
        !          4893:                 break;
        !          4894:         case ENUM:
        !          4895:                 error("MIr for enumeration constant%n", mn);     
        !          4896:                 break;
        !          4897:         }
        !          4898: 
        !          4899:        Pname member = (mn->base==PUBLIC && mn->n_qualifier) ? mn->n_qualifier : mn;
        !          4900: 
        !          4901:        if (i) i = i->typ(ftbl);
        !          4902:        Pname cn = member->tp->is_cl_obj();     // first find the class name
        !          4903: 
        !          4904: //     if (member->n_stclass == STATIC) error('s',"MIr for static%n",member);
        !          4905: //     if (i) i = i->typ(ftbl);
        !          4906: //     Pname cn = member->tp->is_cl_obj();     // first find the class name
        !          4907:        Pref tn = new ref(REF,f_this,member);
        !          4908:        tn->tp = member->tp;
        !          4909: //error('d',"MI for %n %t = %t",member,member->tp,i?i->tp:0);
        !          4910: //error('d',"fthis %d %t member %n tp %t",f_this,f_this->tp,member,tn->tp);
        !          4911:        if (cn) {
        !          4912:                Pclass mcl = Pclass(cn->tp);    // then find the classdef
        !          4913:                Pname ctor = mcl->has_ctor();
        !          4914:                Pname icn;
        !          4915: 
        !          4916:                if (i
        !          4917:                && mcl->has_itor()==0
        !          4918:                && (icn=i->tp->is_cl_obj())
        !          4919:                && Pclass(icn->tp)==mcl) {      // bitwise copy
        !          4920:                        Pexpr init = new expr(ASSIGN,tn,i);
        !          4921:                        init->tp = tn->tp;
        !          4922:                //      return init->typ(ftbl); // don't look for mcl.operator=()
        !          4923:                        member->assign();
        !          4924:                        return init;
        !          4925:                }
        !          4926:                
        !          4927:                if (ctor) return call_ctor(ftbl,tn,ctor,i,DOT);
        !          4928: 
        !          4929:                error("Ir forM%nW noK",member);
        !          4930:                return 0;
        !          4931:        }
        !          4932: 
        !          4933:        if (cl_obj_vec) {
        !          4934:                if (i && i->base == ELIST)
        !          4935:                        error("illegalIrL for %t%nWinM initializationL",mn->tp,mn);
        !          4936:                else error('s',"Ir forCM %t%nWK",mn->tp,mn);
        !          4937:                return 0;
        !          4938:        }
        !          4939: 
        !          4940:        if (i && i->base == ELIST) {
        !          4941:                if (i->e2) error("Ir for%n not a simpleE",member);
        !          4942:                i = i->e1;
        !          4943:        }
        !          4944: 
        !          4945:        if (member->tp->is_ref() && (i == 0)) {
        !          4946:                error("empty Ir for reference %n", member);
        !          4947:                return 0 ;
        !          4948:        }
        !          4949: 
        !          4950: // error( 'd', "fct_mem_init: %n %k", member, member->tp->base );
        !          4951:        switch (member->tp->base) {
        !          4952:        // case RPTR:
        !          4953:        //      if ( i == 0 ) {
        !          4954:        //              error( "empty Ir for reference %n", member );
        !          4955:        //              return 0;
        !          4956:        //      }
        !          4957:        //      break;
        !          4958:        case VEC:
        !          4959:        case FCT:
        !          4960:        case OVERLOAD:
        !          4961:                error("Ir for%n ofT %t",member,member->tp);
        !          4962:                return 0;
        !          4963:        }
        !          4964: 
        !          4965: //error('d',"tp %t",member->tp);
        !          4966:        if (member->tp->tconst()) {
        !          4967:                 int save_ignore_const = ignore_const;
        !          4968:                 ignore_const = 1;
        !          4969:                 i = new expr(ASSIGN,tn,i);
        !          4970:                 i = i->typ(ftbl);
        !          4971:                 ignore_const = save_ignore_const;
        !          4972:                 return i;
        !          4973:        }
        !          4974: 
        !          4975:        Pptr pt;
        !          4976:        if (pt = member->tp->is_ref()) {
        !          4977:                switch (pt->typ->base) {
        !          4978:                case FCT:
        !          4979:                case OVERLOAD:
        !          4980:                        i = ptr_init(pt,i,ftbl);
        !          4981:                        break;
        !          4982:                default:
        !          4983:                        i = ref_init(pt,i,ftbl);
        !          4984:                }
        !          4985:                i = new expr(ASSIGN,tn,i);
        !          4986:                i->tp = tn->tp;
        !          4987:                member->assign();       // cannot call typ: would cause dereference
        !          4988:                return i;
        !          4989:        }
        !          4990: 
        !          4991:        i = new expr(ASSIGN,tn,i);
        !          4992:        return i->typ(ftbl);    // typ performs the type check on the assignment
        !          4993: }
        !          4994: 
        !          4995: Pexpr replace_temp(Pexpr e, Pexpr n)
        !          4996: /*
        !          4997:        e is on the form
        !          4998:                                f(&temp,arg) , temp
        !          4999:                        or
        !          5000:                                &temp->ctor(arg) , temp
        !          5001:                        or
        !          5002:                                x->f(&temp,arg) , temp
        !          5003:        change it to
        !          5004:                                f(n,arg)
        !          5005:                        or
        !          5006:                                n->ctor(arg)
        !          5007: */
        !          5008: {
        !          5009:        Pexpr c = e->e1;        // f(&temp,arg) or &temp->ctor(args)
        !          5010:        Pexpr ff = c->e1;
        !          5011:        Pexpr a = c->e2;        // maybe ELIST(&temp,arg)
        !          5012:        Pexpr tmp = e->e2;
        !          5013: 
        !          5014: //error('d',"suppress(%d %k) %n",tmp->base,tmp->base,tmp->base==NAME?tmp:0);
        !          5015:        if (tmp->base==DEREF) tmp = tmp->e1;
        !          5016:        if (tmp->base==CAST) tmp = tmp->e1;
        !          5017:        if (tmp->base==ADDROF || tmp->base==G_ADDROF) tmp = tmp->e2;
        !          5018:         if (tmp->base != NAME) return e; //error('i',"replace %k",tmp->base);
        !          5019:        tmp->tp = any_type;     // temporary not used: suppress it
        !          5020: 
        !          5021: //error('d',"replace_temp(%k %k) c %k ff %k",e->base,n->base,c->base,ff->base);
        !          5022:        switch (ff->base) {
        !          5023:        case REF:
        !          5024:                if (ff->e1->base==G_ADDROF && ff->e1->e2==tmp)
        !          5025:                        a = ff;                         // &tmp -> f()
        !          5026:                break;
        !          5027:        case DOT:
        !          5028:                if (ff->e1->base==NAME && ff->e1==tmp) {
        !          5029:                        a = ff;                         // tmp . f()
        !          5030:                        a->base = REF;
        !          5031:                }
        !          5032:                break;
        !          5033:        }
        !          5034:        a->e1 = n;
        !          5035:        return c;
        !          5036: }
        !          5037: 
        !          5038: Pname classdef::has_ictor()
        !          5039: /*
        !          5040:        does this class have a constructor taking no arguments?
        !          5041: */
        !          5042: {
        !          5043:        Pname c = has_ctor();
        !          5044:        if (c == 0) return 0;
        !          5045:        
        !          5046:        Pfct f = Pfct(c->tp);
        !          5047: 
        !          5048:        switch (f->base) {
        !          5049:        default:
        !          5050:                error('i',"%s: badK (%k)",string,c->tp->base);
        !          5051:        
        !          5052:        case FCT:
        !          5053:                switch (f->nargs) {
        !          5054:                case 0:         return c;
        !          5055:                default:        if (f->argtype->n_initializer) return c;
        !          5056:                }
        !          5057:                return 0;
        !          5058: 
        !          5059:        case OVERLOAD:
        !          5060:        {       for (Plist l=Pgen(f)->fct_list; l; l=l->l) {
        !          5061:                        Pname n = l->f;
        !          5062:                        f = (Pfct)n->tp;
        !          5063:                        switch (f->nargs) {
        !          5064:                        case 0:         return n;
        !          5065:                        default:        if (f->argtype->n_initializer) return n;
        !          5066:                        }
        !          5067:                }
        !          5068:                return 0;
        !          5069:        }
        !          5070:        }
        !          5071: }
        !          5072: 
        !          5073: int add_first; // fudge, use ctor arg instead
        !          5074: Pname gen::add(Pname n)
        !          5075: /*
        !          5076:        add "n" to the tail of "fct_list"
        !          5077:        (overloaded names are searched in declaration order)
        !          5078: 
        !          5079:        detect:         multiple identical declarations
        !          5080:                        declaration after use
        !          5081:                        multiple definitions
        !          5082: */
        !          5083: {
        !          5084:        Pfct f = Pfct(n->tp);
        !          5085:        Pname nx;
        !          5086: //error('d',"add(%n) %d",n,add_first);
        !          5087:        if (f->base != FCT) error("%n: overloaded nonF",n);
        !          5088: 
        !          5089:        if ( fct_list && (nx=find(f,1)) ) {
        !          5090: //error('d',"found %n %t",nx,nx->tp);
        !          5091:                Linkage l1 = Pfct(nx->tp)->f_linkage;
        !          5092:                Linkage l2 = f->f_linkage;
        !          5093:                if ( l2 != linkage_default && l1 != l2 )
        !          5094:                        error("inconsistent linkage specifications for%n",n);
        !          5095:                Nold = 1;
        !          5096:        }
        !          5097:        else {
        !          5098:                if (add_first==0 && f->f_signature==0) f->sign();
        !          5099: //error('d',"signature: %d \"%s\" fct_list %d",f->f_signature,f->f_signature,fct_list);
        !          5100:                nx = new name;
        !          5101:                *nx = *n;
        !          5102:                // nx->n_tbl_list = Pname(n->string);
        !          5103:                 nx->n_gen_fct_name = n->string;
        !          5104:                PERM(nx);
        !          5105:                Nold = 0;
        !          5106:                if (fct_list) {
        !          5107:                        int clink = (f->f_linkage==linkage_C);
        !          5108:                        Plist gl=fct_list;
        !          5109:                        for(;;) {
        !          5110:                                if (clink
        !          5111:                                && Pfct(gl->f->tp)->f_linkage == linkage_C ) {
        !          5112:                                        error("two%ns with c linkage",n);
        !          5113:                                        if(f->f_signature==0) f->sign();
        !          5114:                                }
        !          5115:                                if (gl->l)
        !          5116:                                        gl = gl->l;
        !          5117:                                else
        !          5118:                                        break;
        !          5119:                        }
        !          5120:                        gl->l = new name_list(nx,0); 
        !          5121:                }
        !          5122:                else
        !          5123:                        fct_list = new name_list(nx,0);
        !          5124:                nx->n_list = 0;
        !          5125:        }
        !          5126:        return nx;
        !          5127: }
        !          5128: 
        !          5129: void fct::sign()
        !          5130: {
        !          5131:        switch ( f_linkage ) {
        !          5132:        case linkage_C:
        !          5133:                f_signature = "";
        !          5134:                return;
        !          5135:        case linkage_Cplusplus:
        !          5136:        case linkage_default:
        !          5137:                break;
        !          5138:        }
        !          5139:        char buf[1024];
        !          5140:        char* bb = signature(buf);
        !          5141:        int ll = bb-buf;
        !          5142:        if (1023 < ll) error('i',"gen::add():N buffer overflow");
        !          5143:        char* p = new char[ll+1];
        !          5144:        strcpy(p,buf);
        !          5145:        f_signature = p;
        !          5146: //error('d',"fct::sign %s",p);
        !          5147: }
        !          5148: 
        !          5149: Pname gen::find(Pfct f, bit warn)
        !          5150: {      
        !          5151:        for (Plist gl=fct_list; gl; gl=gl->l) {
        !          5152:                Pname n = match(gl->f,f,warn);
        !          5153:                if (n) return n;
        !          5154:        }
        !          5155:        return 0;
        !          5156: }
        !          5157: 
        !          5158: Pname gen::match(Pname nx, Pfct f, bit warn)
        !          5159: {
        !          5160:        Pfct fx = Pfct(nx->tp);
        !          5161:        Pname a, ax;
        !          5162:        int op = 0;     // overloading problem: const, ref, vec/ptr, or basetype
        !          5163: //error('d',"fx %d %d f %d %d",fx->nargs_known,fx->nargs,f->nargs_known,f->nargs);
        !          5164: 
        !          5165:        if (f->nargs_known != fx->nargs_known) return 0; // the bets are off
        !          5166:                                                         // must rely on checks at
        !          5167:                                                         // call points
        !          5168:        if (f->f_const != fx->f_const) return 0;
        !          5169: 
        !          5170:        if (fx->nargs != f->nargs
        !          5171:        && fx->nargs_known==1
        !          5172:        && f->nargs_known==1) return 0; // no warning for potential
        !          5173:                                        // problems due to default args
        !          5174:        
        !          5175:        for (ax=fx->argtype, a=f->argtype; a&&ax; ax=ax->n_list, a=a->n_list) {
        !          5176:                Ptype at = ax->tp;
        !          5177:                Ptype atp = a->tp;
        !          5178: //error('d',"at %t atp %t",at,atp);
        !          5179:                if (at->check(atp,OVERLOAD) == 0) {
        !          5180: //error('d',"at %t atp %t cp %d vrp %d",at,atp,const_problem,vrp_equiv);
        !          5181:                        continue;
        !          5182:                }
        !          5183: //error('d',"warn %d",warn);
        !          5184:                if (warn == 0) goto xx;
        !          5185: 
        !          5186:                /*
        !          5187:                        warn against:
        !          5188:                                overload f(X&), f(X);           error
        !          5189:                                overload f(int), f(const);      error
        !          5190:                                overload f(int*), f(int[10]);   warn
        !          5191:                        etc.
        !          5192:                */
        !          5193: 
        !          5194: //error('d',"vrp_equiv %d const_problem %d",vrp_equiv,const_problem);
        !          5195:                if (const_problem) {    // differ only in X vs const X
        !          5196:                        if (at->is_ptr_or_ref()) return 0;
        !          5197:                        op++;
        !          5198:                        continue;
        !          5199:                }
        !          5200: 
        !          5201:        aaa:
        !          5202:                switch (atp->base) {
        !          5203:                case TYPE:
        !          5204:                        atp = Pbase(atp)->b_name->tp;
        !          5205:                        goto aaa;
        !          5206:        //      case EOBJ:
        !          5207:        //              atp = Penum(Pbase(atp)->b_name->tp)->e_type;
        !          5208:        //              goto aaa;
        !          5209:                case RPTR:      // differ only by X vs X& ?
        !          5210:                        if (Pptr(atp)->typ->check(at,0)==0) {
        !          5211:                                op++;
        !          5212:                                continue;
        !          5213:                        }
        !          5214:                }
        !          5215: 
        !          5216:        atl:
        !          5217:                switch (at->base) {
        !          5218:                case TYPE:
        !          5219:                        at = Pbase(at)->b_name->tp;
        !          5220:                        goto atl;
        !          5221:        //      case EOBJ:
        !          5222:        //              at = Penum(Pbase(at)->b_name->tp)->e_type;
        !          5223:        //              goto atl;
        !          5224:                case RPTR:      // differ only by X& vs X ?
        !          5225:                        if (Pptr(at)->typ->check(atp,0)==0) {
        !          5226:                                op++;
        !          5227:                                continue;
        !          5228:                        }
        !          5229:                        break;
        !          5230:        //      case CHAR:      // differ only by int vs char ?
        !          5231:        //      case SHORT:
        !          5232:        //      case INT:
        !          5233:                //      if (atp->base!=at->base && atp->base==EOBJ) {
        !          5234:                //              op++;
        !          5235:                //              continue;
        !          5236:                //      }
        !          5237:        //              break;
        !          5238:                }
        !          5239: //error('d',"return 0");
        !          5240:                //goto xx;
        !          5241:                // some argument is really different
        !          5242:                // e.g. f(int), f(char*);
        !          5243:                return 0;
        !          5244:        }
        !          5245: 
        !          5246:        // arguments checked. Now look at leftover args, return type,etc.
        !          5247: 
        !          5248: //     if (warn && a && fx->nargs_known==ELLIPSIS) error('w',"... in%n'sAT hidesATs from the overloading mechanism",nx);
        !          5249: 
        !          5250:        if (a || ax) return 0;
        !          5251: 
        !          5252:        if (op == 0) {
        !          5253:                if (warn && fx->returns->check(f->returns,0))
        !          5254:                        error("two different return valueTs for%n: %t and %t",nx,fx->returns,f->returns);
        !          5255: 
        !          5256:                return nx;
        !          5257:        }
        !          5258: xx:
        !          5259:        if (warn && op)
        !          5260:                error("the overloading mechanism cannot tell a%t from a%t",fx,f);
        !          5261: 
        !          5262:        return 0;
        !          5263: }
        !          5264: 
        !          5265: int name::no_of_names()
        !          5266: {
        !          5267:        register int i = 0;
        !          5268:        register Pname n;
        !          5269:        for (n=this; n; n=n->n_list) i++;
        !          5270:        return i;
        !          5271: }
        !          5272: 
        !          5273: static Pexpr lvec[20], *lll, *curr_e;
        !          5274: static Pexpr last_il = 0;
        !          5275: static Pexpr list_back = 0;
        !          5276: static Pexpr last_el = 0, *last_lll;
        !          5277: 
        !          5278: void new_list(Pexpr lx)
        !          5279: {
        !          5280:        if (lx->base != ILIST) error('i',"IrLX");
        !          5281: 
        !          5282:        lll = last_lll = lvec;
        !          5283:        lll++;
        !          5284:        *lll = last_el = lx->e1;
        !          5285: }
        !          5286: 
        !          5287: Pexpr next_elem()
        !          5288: {
        !          5289:        Pexpr e;
        !          5290:        Pexpr lx;
        !          5291: 
        !          5292:        if (lll == lvec) return 0;
        !          5293: 
        !          5294:        lx = *lll;
        !          5295: 
        !          5296:        if (list_back) {
        !          5297:                e = list_back;
        !          5298:                list_back = 0;
        !          5299:                return e;
        !          5300:        }
        !          5301: 
        !          5302:        if (lx == 0) {                          /* end of list */
        !          5303:                lll--;
        !          5304:                return 0;
        !          5305:        }
        !          5306: 
        !          5307:        switch (lx->base) {
        !          5308:        case ELIST:
        !          5309:                e = lx->e1;
        !          5310:                curr_e = &lx->e1;
        !          5311:                last_el = lx;
        !          5312:                last_lll = lll;
        !          5313:                *lll = lx->e2;
        !          5314:                switch (e->base) {
        !          5315:                case ILIST:
        !          5316:                        lll++;
        !          5317:                        *lll = e->e1;
        !          5318:                        last_il = e;
        !          5319:                        return Pexpr(1);        // start of new ILIST
        !          5320:                case ELIST:
        !          5321:                        error("nestedEL");
        !          5322:                        return 0;
        !          5323:                default:
        !          5324:                {
        !          5325:                        if (need_sti(e)) error('s',"generalIr inIrL");
        !          5326:                        return e;
        !          5327:                }
        !          5328:                }
        !          5329:        case IVAL:
        !          5330:        case ZERO:
        !          5331:                lll--;
        !          5332:                return 0;
        !          5333:        default:
        !          5334:                error('i',"IrL %k",lx->base);
        !          5335:        }
        !          5336: }
        !          5337: 
        !          5338: static Pexpr insert_init(Pexpr newval) {
        !          5339: // splice an initializer in front of the next element in the
        !          5340: // initializer list.  Provides initializers for unnamed bitfields.
        !          5341:        Pexpr t = new expr(ELIST,last_el->e1,last_el->e2);
        !          5342: 
        !          5343:        last_el->e1=newval;
        !          5344:        last_el->e2=t;
        !          5345:        lll = last_lll;
        !          5346:        *lll = last_el;
        !          5347:        return next_elem();
        !          5348: }
        !          5349: 
        !          5350: void skip_ilist()
        !          5351: // skip ilist use to represent pointer to member function literal
        !          5352: {
        !          5353:        Pexpr e = next_elem();
        !          5354:        e = next_elem();
        !          5355: }
        !          5356: 
        !          5357: void list_check(Pname nn, Ptype t, Pexpr il, Ptable tbl)
        !          5358: /*
        !          5359:        see if the list "lll" can be assigned to something of type "t"
        !          5360:        "nn" is the name of the variable for which the assignment is taking place.
        !          5361:        "il" is the last list element returned by next_elem()
        !          5362: */
        !          5363: {
        !          5364:        Pexpr e;
        !          5365:        bit lst = 0;
        !          5366:        int i;
        !          5367:        Pclass cl;
        !          5368:        int tdef = 0;
        !          5369: 
        !          5370: //error('d',"list_check%n: %t (%d)",nn,t,il);
        !          5371:        if (il == Pexpr(1)) {
        !          5372:                lst = 1;
        !          5373:                e = il;
        !          5374:        }
        !          5375:        else if (il)
        !          5376:                list_back = il;
        !          5377: 
        !          5378: zzz:
        !          5379:        switch (t->base) {
        !          5380:        case TYPE:
        !          5381:                t = Pbase(t)->b_name->tp;
        !          5382:                tdef = 1;
        !          5383: 
        !          5384:                // did it used to be a VEC before arg_fudge was applied?
        !          5385:                 if (t->base==PTR && Pvec(t)->size)
        !          5386:                         t->base=VEC;
        !          5387:                 goto zzz;
        !          5388: 
        !          5389:        case VEC:
        !          5390:        {       Pvec v = Pvec(t);
        !          5391:                Ptype vt = v->typ;
        !          5392: 
        !          5393:                if (v->size) {  /* get at most v->size initializers */
        !          5394:                        if (v->typ->base == CHAR) {
        !          5395:                                e = next_elem();
        !          5396:                                if (e->base == STRING) {        // v[size] = "..."
        !          5397:                                        int isz = Pvec(e->tp)->size;
        !          5398:                                        if (v->size < isz) error("Ir too long (%d characters) for%n[%d]",isz,nn,v->size);
        !          5399:                                        break;
        !          5400:                                }
        !          5401:                                else
        !          5402:                                        list_back = e;
        !          5403:                        }
        !          5404:                        for (i=0; i<v->size; i++) { // check next list element type
        !          5405:                                Pfct MP = 0;
        !          5406:                        ee:
        !          5407:                                e = next_elem();
        !          5408:                                if (e == 0) goto xsw; // too few initializers are ok
        !          5409:                        vtz:
        !          5410: //error('d',"vtz: %d",vt->base);
        !          5411:                                switch (vt->base) {
        !          5412:                                case TYPE:
        !          5413:                                        vt = Pbase(vt)->b_name->tp;
        !          5414:                                        goto vtz;
        !          5415:                                case VEC:
        !          5416:                                case COBJ:
        !          5417:                                        list_check(nn,vt,e);
        !          5418:                                        break;
        !          5419:                                case PTR:
        !          5420:                                        if ((MP = vt->memptr()) &&
        !          5421:                                            e==Pexpr(1)) {
        !          5422:                                                if (vt->check(last_il->tp,ASSIGN))
        !          5423:                                                        error("badIrT for%n:%t (%tX)",v,last_il->tp,vt);
        !          5424:                                                skip_ilist();
        !          5425:                                                break;
        !          5426:                                        }
        !          5427:                                        if (MP && e && e->base==ZERO) {
        !          5428:                                                *curr_e = new expr(ELIST,zero,zero);
        !          5429:                                                *curr_e = new expr(ILIST,*curr_e,zero);
        !          5430:                                                (*curr_e)->tp = zero_type;
        !          5431:                                                break;
        !          5432:                                        }
        !          5433:                                        if (MP && e && e->tp->base==OVERLOAD) {
        !          5434:                                                Pexpr op = ptof(Pfct(Pptr(vt)->typ),e,tbl);
        !          5435:                                                if(op) {
        !          5436:                                                        *curr_e = op;
        !          5437:                                                        break;
        !          5438:                                                }
        !          5439:                                        }
        !          5440:                                        // no break
        !          5441:                                default:
        !          5442:                                {
        !          5443:                                        if (e == (Pexpr)1) {
        !          5444:                                                error("unexpectedIrL");
        !          5445:                                                goto ee;
        !          5446:                                        }
        !          5447: 
        !          5448:                                        if (vt->check(e->tp,ASSIGN))
        !          5449:                                                error("badIrT for%n:%t (%tX)",nn,e->tp,vt);
        !          5450: 
        !          5451:                                        Pptr p;
        !          5452:                                        if (vt->check(e->tp,0)
        !          5453:                                        && (p=vt->is_ptr())
        !          5454:                                        && Ptype(p)!=zero_type
        !          5455:                                        && p->typ!=char_type) {
        !          5456:                                                Pexpr te = e;
        !          5457:                                                Ptype t = p->typ;
        !          5458:                                                while ( t->base == TYPE ) t = Pbase(t)->b_name->tp;
        !          5459:                                                if ( t->base == COBJ )
        !          5460:                                                        te = ptr_init( p, e, tbl );
        !          5461:                                                if ( te == e )
        !          5462:                                                        *curr_e = new cast(vt,e);
        !          5463:                                                else *curr_e = te;
        !          5464:                                        }
        !          5465:                                }
        !          5466:                                }
        !          5467:                        }
        !          5468:                        if ( lst && (e=next_elem()) ) error("end ofIrLX after array");
        !          5469:                xsw:;
        !          5470:                }
        !          5471:                else {          /* determine v->size */
        !          5472:                        i = 0;
        !          5473:                        (void) v->typ->tsizeof();
        !          5474:                xx:
        !          5475:                        while ( e=next_elem() ) {       // get another initializer
        !          5476:                                Pfct MP = 0;
        !          5477:                                i++;
        !          5478:                        vtzz:
        !          5479: //error('d',"vtzz");
        !          5480:                                switch (vt->base) {
        !          5481:                                case TYPE:
        !          5482:                                        vt = Pbase(vt)->b_name->tp;
        !          5483:                                        goto vtzz;
        !          5484:                                case VEC:
        !          5485:                                case COBJ:
        !          5486:                                        list_check(nn,vt,e);
        !          5487:                                        break;
        !          5488:                                case PTR:
        !          5489:                                        if((MP = vt->memptr()) &&
        !          5490:                                            e==Pexpr(1)) {
        !          5491:                                                if (vt->check(last_il->tp,ASSIGN))
        !          5492:                                                        error("badIrT for%n:%t (%tX)",v,last_il->tp,vt);
        !          5493:                                                skip_ilist();
        !          5494:                                                break;
        !          5495:                                        }
        !          5496:                                        if (MP && e && e->base==ZERO) {
        !          5497:                                                *curr_e = new expr(ELIST,zero,zero);
        !          5498:                                                *curr_e = new expr(ILIST,*curr_e,zero);
        !          5499:                                                (*curr_e)->tp = zero_type;
        !          5500:                                                break;
        !          5501:                                        }
        !          5502:                                        if (MP && e && e->tp->base==OVERLOAD) {
        !          5503:                                                Pexpr op = ptof(Pfct(Pptr(vt)->typ),e,tbl);
        !          5504:                                                if(op) {
        !          5505:                                                        *curr_e = op;
        !          5506:                                                        break;
        !          5507:                                                }
        !          5508:                                        }
        !          5509:                                        // no break
        !          5510:                                default:
        !          5511:                                {       if (e == Pexpr(1)) {
        !          5512:                                                error("unexpectedIrL");
        !          5513:                                                goto xx;
        !          5514:                                        }
        !          5515: 
        !          5516:                                        if (vt->check(e->tp,ASSIGN))
        !          5517:                                                error("badIrT for%n:%t (%tX)",nn,e->tp,vt);
        !          5518: 
        !          5519:                                        Pptr p;
        !          5520:                                        if (vt->check(e->tp,0)
        !          5521:                                        && (p=vt->is_ptr())
        !          5522:                                        && Ptype(p)!=zero_type
        !          5523:                                        && p->typ!=char_type) {
        !          5524:                                                Pexpr te = e;
        !          5525:                                                Ptype t = p->typ;
        !          5526:                                                while ( t->base == TYPE ) t = Pbase(t)->b_name->tp;
        !          5527:                                                if ( t->base == COBJ )
        !          5528:                                                        te = ptr_init( p, e, tbl );
        !          5529:                                                if ( te == e )
        !          5530:                                                        *curr_e = new cast(vt,e);
        !          5531:                                                else *curr_e = te;
        !          5532:                                        }
        !          5533:                                }
        !          5534:                                }
        !          5535:                        }
        !          5536:                        if (tdef==0) v->size = i;
        !          5537:                }
        !          5538:                break;
        !          5539:        }
        !          5540: 
        !          5541:        case CLASS:
        !          5542:                cl = Pclass(t);
        !          5543:                goto ccc;
        !          5544: 
        !          5545:        case COBJ:      /* initialize members */
        !          5546:                cl = Pclass(Pbase(t)->b_name->tp);
        !          5547:        ccc:
        !          5548:                if (cl->defined == 0) {
        !          5549:                        lll = lvec;     // we are lost: ignore rest of list
        !          5550:                        return;
        !          5551:                }
        !          5552: 
        !          5553:                if (cl->c_body == 1) cl->dcl_print(0);
        !          5554: 
        !          5555:        {       Ptable tbl = cl->memtbl;
        !          5556:                Pname m;
        !          5557: 
        !          5558:                if (cl->baselist) {
        !          5559:                        if (cl->baselist->next) error("IrL forO ofC with multipleBCs");
        !          5560:                        list_check(nn,cl->baselist->bclass,0);
        !          5561:                }
        !          5562: 
        !          5563:                for (m=tbl->get_mem(i=1); m; m=tbl->get_mem(++i)) {
        !          5564:                        Ptype mt = m->tp;
        !          5565:                        Pfct MP = 0;
        !          5566:                        switch (mt->base) {
        !          5567:                        case FCT:
        !          5568:                        case OVERLOAD:
        !          5569:                        case CLASS:
        !          5570:                        case ENUM:
        !          5571:                                continue;
        !          5572:                        }
        !          5573:                        if (m->n_stclass == STATIC ||
        !          5574:                                m->n_stclass == ENUM ) continue;
        !          5575:                        /* check assignment to next member */
        !          5576:                dd:
        !          5577:                        while (mt->base == TYPE)
        !          5578:                                mt = Pbase(mt)->b_name->tp;
        !          5579: 
        !          5580:                        if ((MP = mt->memptr()) &&
        !          5581:                            e==Pexpr(1) &&
        !          5582:                                last_il->tp->base == PTR) {
        !          5583:                                if(i==1) lst=0;
        !          5584:                        }
        !          5585:                        else e = next_elem();
        !          5586: 
        !          5587:                        if (e == 0) return; //break;
        !          5588: 
        !          5589:                        if(
        !          5590:                                mt->base == FIELD
        !          5591:                                        &&
        !          5592:                                m->string[0]=='_'
        !          5593:                                        &&
        !          5594:                                m->string[1]=='_'
        !          5595:                                        &&
        !          5596:                                m->string[2]=='F'       // unnamed bitfield
        !          5597:                        ) {
        !          5598:                                e = insert_init(zero);
        !          5599:                        }
        !          5600: 
        !          5601: //error('d',"mtz%n: %d",m,mt->base);
        !          5602:                        switch (mt->base) {
        !          5603:                        case CLASS:
        !          5604:                        case ENUM:
        !          5605:                                break;
        !          5606:                        case VEC:
        !          5607:                        case COBJ:
        !          5608:                                list_check(nn,m->tp,e);
        !          5609:                                break;
        !          5610:                        case PTR:
        !          5611:                                if (MP && e==Pexpr(1)) {
        !          5612:                                        if (mt->check(last_il->tp,ASSIGN))
        !          5613:                                                error("badIrT for%n:%t (%tX)",m,last_il->tp,mt);
        !          5614:                                        skip_ilist();
        !          5615:                                        break;
        !          5616:                                }
        !          5617:                                if (MP && e && e->base==ZERO) {
        !          5618:                                        *curr_e = new expr(ELIST,zero,zero);
        !          5619:                                        *curr_e = new expr(ILIST,*curr_e,zero);
        !          5620:                                        (*curr_e)->tp = zero_type;
        !          5621:                                        break;
        !          5622:                                }
        !          5623:                                if (MP && e && e->tp->base==OVERLOAD) {
        !          5624:                                        Pexpr op = ptof(Pfct(Pptr(mt)->typ),e,tbl);
        !          5625:                                        if(op) {
        !          5626:                                                *curr_e = op;
        !          5627:                                                break;
        !          5628:                                        }
        !          5629:                                }
        !          5630:                                // no break
        !          5631:                        default:
        !          5632:                        {       if (e == Pexpr(1)) {
        !          5633:                                        error("unexpectedIrL");
        !          5634:                                        goto dd;
        !          5635:                                }
        !          5636: 
        !          5637:                                if (mt->check(e->tp,ASSIGN))
        !          5638:                                        error("badIrT for%n:%t (%tX)",m,e->tp,m->tp);
        !          5639: 
        !          5640:                                if(MP && e && e->base==CAST)
        !          5641:                                        *curr_e = e->e1;
        !          5642: 
        !          5643:                                Pptr p;
        !          5644:                                if (mt->check(e->tp,0)
        !          5645:                                && (p=mt->is_ptr())
        !          5646:                                && Ptype(p)!=zero_type
        !          5647:                                && p->typ!=char_type)
        !          5648:                                        *curr_e = new cast(mt,e);
        !          5649:                        }
        !          5650:                        }
        !          5651:                }
        !          5652:                if (lst && (e=next_elem()) ) error("end ofIrLX afterCO");
        !          5653:                break;
        !          5654:        }
        !          5655:        default:
        !          5656:                e = next_elem();
        !          5657: 
        !          5658:                if (e == 0) {
        !          5659:                        error("noIr forO");
        !          5660:                        break;
        !          5661:                }
        !          5662:                
        !          5663:                if (e == Pexpr(1)) {
        !          5664:                        error("unexpectedIrL");
        !          5665:                        break;
        !          5666:                }
        !          5667: //error('d',"t %t e->tp %t",t,e->tp);
        !          5668:                if (t->check(e->tp,ASSIGN)) error("badIrT for%n:%t (%tX)",nn,e->tp,t);
        !          5669:                Pptr p;
        !          5670:                if (t->check(e->tp,0)
        !          5671:                && (p=t->is_ptr())
        !          5672:                && Ptype(p)!=zero_type
        !          5673:                && p->typ!=char_type)
        !          5674:                        *curr_e = new cast(t,e);
        !          5675:                if (lst && (e=next_elem()) ) error("end ofIrLX afterO");
        !          5676:                break;
        !          5677:        }
        !          5678: }
        !          5679: 
        !          5680: int
        !          5681: is_anon(char* string) {
        !          5682: // error('d',"is_anon: %s", string );
        !          5683:        if ( string == 0 )
        !          5684:                return 0;
        !          5685: 
        !          5686:        if ( string[0]=='_' && string[1]=='_' &&
        !          5687:                (string[2]=='C' || string[2]=='E')) 
        !          5688:                        return 1;
        !          5689:        return 0;
        !          5690: }
        !          5691: 
        !          5692: Pname dclass(Pname n, Ptable tbl)
        !          5693: {      
        !          5694:        Pclass cl;
        !          5695:        Pbase bt;
        !          5696:        Pname bn;
        !          5697:        Pname ntbl = tbl->t_name;
        !          5698:        Ptype ntp = 0; 
        !          5699:        TOK tscope;
        !          5700: 
        !          5701:        Pname nx = ktbl->look(n->string,0);             // TNAME
        !          5702:        if (ntbl && ntbl->tp) ntp = ntbl->tp;
        !          5703: 
        !          5704:        tscope = ntp&&ntp->base==CLASS?NESTED:(n->lex_level?LOCAL:HIDDEN);
        !          5705: 
        !          5706:        DB( if(Ddebug>=1) error( 'd', &n->where, "dclass n %n %d nx %d", n,n->lex_level, nx); );
        !          5707: // error( 'd', &n->where, "dclass n %n ll %d nx %d tbl: %n", n,n->lex_level, nx, tbl->t_name); 
        !          5708:        if (nx == 0 || n->lex_level || 
        !          5709:                ntp && is_anon(n->string) == 0 && ntp->base == CLASS 
        !          5710:                && (ktbl->look(n->string,tscope))) 
        !          5711:        {
        !          5712:                if ( nx && ntp && ntp->base == CLASS ) { 
        !          5713:                        bt = (Pbase)nx->tp;
        !          5714:                        bn = bt->b_name;
        !          5715:                        cl = bn ? (Pclass)bn->tp : 0;
        !          5716:                        if (cl && cl->lcl && 
        !          5717:                                strcmp(cl->lcl,"FUDGE007")==0)
        !          5718:                                        goto bbb;
        !          5719:                        else { bt=0; bn=0; cl=0; }
        !          5720:                }
        !          5721: 
        !          5722:                int tn = 0;
        !          5723:                for (nx=ktbl->look(n->string,tscope); nx; nx=nx->n_tbl_list) 
        !          5724:                {
        !          5725:                        if (nx->n_key != tscope) continue;
        !          5726:                        if (tscope==LOCAL && 
        !          5727:                                nx->lex_level != n->lex_level ) continue;
        !          5728: 
        !          5729:                        if (nx->tp->base != COBJ) {
        !          5730:                                tn = 1;
        !          5731:                                continue;
        !          5732:                        }
        !          5733: 
        !          5734:                        bt = (Pbase)nx->tp;
        !          5735:                        bn = bt->b_name;
        !          5736:                        cl = (Pclass)bn->tp;
        !          5737: 
        !          5738:                        if (cl == 0) continue;
        !          5739: 
        !          5740:                        // is this class nested within class table?
        !          5741:                        if (tscope==NESTED && 
        !          5742:                                strcmp(ntbl->string,cl->in_class->string))
        !          5743:                                        continue;
        !          5744:                        else
        !          5745:                        if ( tscope==LOCAL && 
        !          5746:                                (cl->lcl==0 || strcmp(cl->lcl,Pclass(n->tp)->lcl))) 
        !          5747:                                        continue;
        !          5748: 
        !          5749:                        goto bbb;
        !          5750:                }
        !          5751: 
        !          5752:                if (tn)
        !          5753:                        error("%n redefined using Tdef",n);
        !          5754:                else
        !          5755:                        error('i',"%n is not aCN",n);
        !          5756:        }
        !          5757:        else {
        !          5758:                bt = Pbase(nx->tp);                     // COBJ
        !          5759:                 if ( bt->base != COBJ ) {
        !          5760:                         error("%n redefined using typedef",n);
        !          5761:                         Pname tn = ktbl->look(n->string,HIDDEN); 
        !          5762:                         if ( tn->tp->base == COBJ )  
        !          5763:                                 bt = Pbase(tn->tp);
        !          5764:                         else error('i',"%n is not a CN", n );
        !          5765:                 }
        !          5766:                bn = bt->b_name;
        !          5767:        }
        !          5768: bbb:
        !          5769:        bn->where = nx->where;
        !          5770:        Pname bnn = tbl->insert(bn,CLASS);              // copy for member lookup
        !          5771:        cl = Pclass(bn->tp);
        !          5772: 
        !          5773:        if (cl->class_base == template_class)
        !          5774:                error("C%n defined previously asYC", bn);
        !          5775:                                                        
        !          5776:        if (cl->defined&(DEFINED|SIMPLIFIED))
        !          5777:                error("C%n defined twice",n);
        !          5778:        else {
        !          5779:                if (bn->n_scope == ARG) bn->n_scope = ARGT;
        !          5780:                cl->dcl(bn,tbl);
        !          5781:        }
        !          5782:        n->tp = cl;
        !          5783:        return bnn;
        !          5784: }
        !          5785: 
        !          5786: Pname denum(Pname n, Ptable tbl)
        !          5787: {
        !          5788:        Penum en;
        !          5789:        Pbase bt;
        !          5790:        Pname bn;
        !          5791:        Pname ntbl = tbl->t_name;
        !          5792:        Ptype ntp = 0; 
        !          5793:        TOK tscope;
        !          5794: 
        !          5795:        Pname nx = ktbl->look(n->string,0);             // TNAME
        !          5796:        if (ntbl && ntbl->tp) ntp = ntbl->tp;
        !          5797: 
        !          5798: // note: ***** add for local enumeration declaration
        !          5799: // error( 'd', &n->where, "denum n %n ll %d nx %d tbl: %n", n,n->lex_level, nx, tbl->t_name); 
        !          5800:        if (nx == 0 || /* n->lex_level ||*/ 
        !          5801:                ntp && is_anon(n->string)==0 && ntp->base == CLASS ) 
        !          5802:        {
        !          5803:                int tn = 0;
        !          5804:                tscope = ntp&&ntp->base==CLASS?NESTED:(/*n->lex_level?LOCAL:*/HIDDEN);
        !          5805:                for (nx=ktbl->look(n->string,tscope); nx; nx=nx->n_tbl_list) 
        !          5806:                {
        !          5807:                        if (nx->n_key != tscope) continue;
        !          5808: //                     if (tscope==LOCAL && 
        !          5809: //                             nx->lex_level != n->lex_level ) continue;
        !          5810: 
        !          5811:                        bt = (Pbase)nx->tp;
        !          5812:                        bn = bt->b_name;
        !          5813:                        en = (Penum)bn->tp;
        !          5814: 
        !          5815:                        // is this class nested within class table?
        !          5816:                        if (tscope==NESTED && en->in_class &&
        !          5817:                                strcmp(ntbl->string,en->in_class->string))
        !          5818:                                        continue;
        !          5819:                }
        !          5820:        }
        !          5821:        else {
        !          5822:                        bt = (Pbase)nx->tp;
        !          5823:                        bn = bt->b_name;
        !          5824:                        en = (Penum)bn->tp;
        !          5825:        }
        !          5826: 
        !          5827:        Pname bnn = tbl->insert(bn,CLASS);
        !          5828:        if (en->defined&(DEFINED|SIMPLIFIED))
        !          5829:                error("enum%n defined twice",n);
        !          5830:        else {
        !          5831:                if (bn->n_scope == ARG) bn->n_scope = ARGT;
        !          5832:                en->dcl(bn,tbl);
        !          5833:        }
        !          5834:        n->tp = en;
        !          5835:        return bnn;
        !          5836: }
        !          5837: 
        !          5838: static int
        !          5839: is_probably_temp( char *str ) 
        !          5840: {
        !          5841: // error( 'd', "is_probably_temp( %s )", str );
        !          5842: 
        !          5843:        if ( str[0] != '_' || str[1] != '_' )
        !          5844:                return 0;
        !          5845: 
        !          5846:        switch (str[2]) {
        !          5847:                default:
        !          5848:                        return 0;
        !          5849:                case 'A': case 'C': case 'D': case 'E': case 'F': 
        !          5850:                case 'I': case 'K': case 'L': case 'M': case 'N': 
        !          5851:                case 'Q': case 'R': case 'S': case 'T': case 'U': 
        !          5852:                case 'V': case 'W': case 'X':
        !          5853:                        return 1;
        !          5854:        }
        !          5855: 
        !          5856: }
        !          5857: 
        !          5858: static void
        !          5859: check_for_local( Pexpr ee )
        !          5860: {
        !          5861:        static Pname n[2] = {0,0}; // try not to flag multiple errors 
        !          5862:        static index = 0;
        !          5863: 
        !          5864:        if ( ee==0 ) return; 
        !          5865: 
        !          5866: // error('d', "check_for_local( %k ) e1: %d e2: %d", ee->base, ee->e1, ee->e2);
        !          5867: 
        !          5868:        switch ( ee->base ) {
        !          5869:                case NAME:  
        !          5870:                {
        !          5871:                        Pname nn = Pname(ee);
        !          5872:                        if ((nn->n_scope==FCT || nn->n_scope==ARG) 
        !          5873:                            && is_probably_temp(nn->string) == 0  
        !          5874:                            && n[0]!=nn && n[1]!=nn) 
        !          5875:                        {
        !          5876:                                error("local%n used as defaultA", nn );
        !          5877:                                n[index] = nn;
        !          5878:                                index = index==0?1:0;
        !          5879:                        }       
        !          5880:                        // no break;
        !          5881:                }
        !          5882:                case TNAME: case STRING: case IVAL:
        !          5883:                case ICON: case CCON: case FCON:
        !          5884:                case ZERO: case DUMMY: case SIZEOF:
        !          5885:                        return;
        !          5886:                case QUEST:
        !          5887:                        check_for_local( ee->cond );
        !          5888:                        break;
        !          5889:                case MDOT:
        !          5890:                        check_for_local( ee->mem );
        !          5891:                        return;
        !          5892:        }
        !          5893: 
        !          5894:        check_for_local( ee->e1 );
        !          5895:        check_for_local( ee->e2 );
        !          5896: }
        !          5897: 
        !          5898: void dargs(Pname, Pfct f, Ptable tbl)
        !          5899: {
        !          5900:        int argnamesize = 0; // if +a1, make sure arg names can be printed
        !          5901:        int oo = const_save;
        !          5902:        const_save = 1;
        !          5903:        if ( ansi_opt ) {
        !          5904:            Pname th = f->f_this;
        !          5905:            if ( th && th->string ) argnamesize += strlen(th->string) + 1;
        !          5906:            th = f->f_result;
        !          5907:            if ( th && th->string ) argnamesize += strlen(th->string) + 1;
        !          5908:        }
        !          5909: 
        !          5910:        for (Pname a=f->argtype; a; a=a->n_list) {
        !          5911:                Pexpr init;
        !          5912: 
        !          5913:                if (a->tp == 0) {
        !          5914:                        error( "A has noT" );
        !          5915:                        a->tp = any_type;
        !          5916:                        continue;
        !          5917:                }
        !          5918:                if (ansi_opt && a->string) argnamesize += strlen(a->string) + 1;
        !          5919: 
        !          5920:                Pname cln = a->tp->is_cl_obj();
        !          5921: //error('d',"dargs %t",a->tp);
        !          5922:                if (cln && Pclass(cln->tp)->has_itor()) // mark X(X&) arguments
        !          5923:                        a->n_xref = 1;
        !          5924:                else {
        !          5925:                        Ptype t = a->tp;
        !          5926:                        while (t->base == TYPE) t = Pbase(t)->b_name->tp;
        !          5927:                        if (t->base == FCT) a->tp = new ptr(PTR,a->tp);
        !          5928:                }
        !          5929: 
        !          5930: //             if (init = a->n_initializer) {  // default argument
        !          5931:                 if ( a->n_key != NESTED &&
        !          5932:                     (init = a->n_initializer)) { // default argument
        !          5933:                        Pptr pt;
        !          5934:                        if (init == dummy) {
        !          5935:                                error("emptyIr");
        !          5936:                                a->n_initializer = 0;
        !          5937:                                continue;
        !          5938:                        }
        !          5939:                        if (cln) {
        !          5940:                                if (init->base==VALUE) {
        !          5941:                                        switch (init->tp2->base) {
        !          5942:                                        case CLASS:
        !          5943:                                                if (Pclass(init->tp2)!=Pclass(cln->tp)) goto inin2;
        !          5944:                                                break;
        !          5945:                                        default:
        !          5946:                                                Pname n2 = init->tp2->is_cl_obj();
        !          5947:                                                if (n2==0 || Pclass(n2->tp)!=Pclass(cln->tp)) goto inin2;
        !          5948:                                        }
        !          5949: 
        !          5950:                                        a->n_initializer = init = 0;
        !          5951:                                        error('s',"K as defaultA");
        !          5952:                                }
        !          5953:                                else {
        !          5954:                                inin2:
        !          5955:                                        if (init->base == ILIST) error("list as AIr");
        !          5956:                                        Pexpr i = init->typ(tbl);
        !          5957:                                        init = class_init(a,a->tp,i,tbl);
        !          5958:                                        if (i!=init && init->base==DEREF) {
        !          5959:                                                error('s',"K needed forAIr");
        !          5960:                                                init = 0;
        !          5961:                                        }
        !          5962:                                        else {
        !          5963:                                                dosimpl(init,cc->nof);
        !          5964:                                        //      init->simpl();
        !          5965:                                                init->permanent = 2;
        !          5966:                                        }
        !          5967:                                        a->n_initializer = init;
        !          5968:                                }
        !          5969:                        }
        !          5970:                        else if (pt = a->tp->is_ref()) {
        !          5971:                                ref_initializer++;
        !          5972:                                init = init->typ(tbl);
        !          5973:                                ref_initializer--;
        !          5974:                                int tcount = stcount;
        !          5975:                                init = ref_init(pt,init,tbl);
        !          5976:                                if (tcount != stcount) {
        !          5977:                                        error('s',"needs temporaryV to evaluateAIr");
        !          5978:                                        init = 0;
        !          5979:                                }
        !          5980:                                else {
        !          5981:                                        dosimpl(init,cc->nof);
        !          5982:                                //      init->simpl();
        !          5983:                                        init->permanent = 2;
        !          5984:                                }
        !          5985:                                a->n_initializer = init;
        !          5986:                        }
        !          5987:                        else {
        !          5988:                                Pptr p = a->tp->is_ptr();
        !          5989:                                init = init->typ(tbl);
        !          5990:                                if (p) init = ptr_init(p,init,tbl);
        !          5991: 
        !          5992:                                if (a->tp->check(init->tp,ARG)) {
        !          5993:                                        int i = can_coerce(a->tp,init->tp);
        !          5994: 
        !          5995:                                        switch (i) {
        !          5996:                                        case 1:
        !          5997:                                                if (Ncoerce) {
        !          5998:                                                        Pname cn = init->tp->is_cl_obj();
        !          5999:                                                        Pname xx = new name(Ncoerce->string);
        !          6000:                                                        Pref r = new ref(DOT,init,xx);
        !          6001:                                                        init = new expr(G_CALL,r,0);
        !          6002:                                                        init = init->typ(tbl);
        !          6003:                                                }
        !          6004:                                                break;
        !          6005:                                        default:
        !          6006:                                                error("%d possible conversions for defaultA",i);
        !          6007:                                        case 0:
        !          6008:                                                error("badIrT%t forA%n (%tX)",init->tp,a,a->tp);
        !          6009:                                                DEL(init);
        !          6010:                                                a->n_initializer = init = 0;
        !          6011:                                        }
        !          6012:                                }
        !          6013:                                
        !          6014:                                if (init) {
        !          6015:                                        dosimpl(init,cc->nof);
        !          6016:                                //      init->simpl();
        !          6017:                                        init->permanent = 2;
        !          6018:                                        a->n_initializer = init;
        !          6019:                                        Neval = 0;
        !          6020:                                        long i = init->eval();
        !          6021:                                        if (Neval == 0) {
        !          6022:                                                a->n_evaluated = 1;
        !          6023:                                                a->n_val = i;
        !          6024:                                        }
        !          6025:                                }
        !          6026:                        }
        !          6027:                        if ( a->n_initializer ) 
        !          6028:                                check_for_local(a->n_initializer);
        !          6029:                }
        !          6030:        }
        !          6031:        if ( ansi_opt && argnamesize ) {
        !          6032:                char* ps = new char[ argnamesize ];
        !          6033:                Pname a = f->f_this;
        !          6034:                if ( a && a->string ) {
        !          6035:                        int i = strlen(a->string) + 1;
        !          6036:                        if ( (argnamesize -= i) < 0 ) goto bad;
        !          6037:                        strcpy(ps,a->string);
        !          6038:                        a->string = ps;
        !          6039:                        ps += i;
        !          6040:                }
        !          6041:                a = f->f_result;
        !          6042:                if ( a && a->string ) {
        !          6043:                        int i = strlen(a->string) + 1;
        !          6044:                        if ( (argnamesize -= i) < 0 ) goto bad;
        !          6045:                        strcpy(ps,a->string);
        !          6046:                        a->string = ps;
        !          6047:                        ps += i;
        !          6048:                }
        !          6049:                for ( a = f->argtype;  a;  a = a->n_list ) {
        !          6050:                        if ( a->string == 0 ) continue;
        !          6051:                        int i = strlen(a->string) + 1;
        !          6052:                        if ( (argnamesize -= i) < 0 ) goto bad;
        !          6053:                        strcpy(ps,a->string);
        !          6054:                        a->string = ps;
        !          6055:                        ps += i;
        !          6056:                }
        !          6057:                if ( argnamesize ) bad:error('i',"bad argN size for%t",f);
        !          6058:        }
        !          6059:        const_save = oo;
        !          6060: }
        !          6061: 
        !          6062: void merge_init(Pname nn, Pfct f, Pfct nf)
        !          6063: {
        !          6064: //     Pname a1 = f->f_args; if (a1==0) a1 = f->argtype;
        !          6065: //     Pname a2 = nf->f_args;//nf->argtype; 
        !          6066:        Pname a1 = f->argtype;
        !          6067:        Pname a2 = nf->argtype; 
        !          6068: 
        !          6069:        for (; a1; a1=a1->n_list, a2=a2->n_list) {
        !          6070:                int i1 = a1->n_initializer || a1->n_evaluated;
        !          6071:                int i2 = a2->n_initializer || a2->n_evaluated;
        !          6072: 
        !          6073:                if (i1 && i2) error(&a1->where,"twoIrs for%nA%n",nn,a1);
        !          6074: 
        !          6075:                if (i1) {
        !          6076:                        a2->n_initializer = a1->n_initializer;
        !          6077:                        a2->n_evaluated = a1->n_evaluated;
        !          6078:                        a2->n_val = a1->n_val;
        !          6079:                }
        !          6080:                if (i2) {
        !          6081:                        a1->n_initializer = a2->n_initializer;
        !          6082:                        a1->n_evaluated = a2->n_evaluated;
        !          6083:                        a1->n_val = a2->n_val;
        !          6084:                }
        !          6085: 
        !          6086:        }
        !          6087: }
        !          6088: 
        !          6089: Pexpr try_to_coerce(Ptype rt, Pexpr e, char* s, Ptable tbl)
        !          6090: /*
        !          6091:        ``e'' is of class ``cn'' coerce it to type ``rt''
        !          6092: */
        !          6093: {
        !          6094:        int i;
        !          6095:        Pname cn;
        !          6096: //error('d',"try_to_coerce(%t, %t, %s, %d)",rt,e->tp,s,tbl);
        !          6097: 
        !          6098:        if ((cn=e->tp->is_cl_obj()) && (i=can_coerce(rt,e->tp)) && Ncoerce) {
        !          6099:                if (1 < i) error("%d possible conversions for %s",i,s);
        !          6100: //error('d',"coerce %n",Ncoerce);
        !          6101:                Pclass cl = Pclass(cn->tp);
        !          6102:        //      Pref r = new ref(DOT,e,Ncoerce);
        !          6103:        //      Pexpr rr = r->typ(tbl);
        !          6104:        //      Pexpr c = new expr(G_CALL,rr,0);
        !          6105:        //      c->fct_name = Ncoerce;
        !          6106:                Pname xx = new name(Ncoerce->string);
        !          6107:                Pref r = new ref(DOT,e,xx);
        !          6108:                Pexpr c = new expr(G_CALL,r,0);
        !          6109:        //      return c->typ(tbl);
        !          6110:                c = c->typ(tbl);
        !          6111: //error('d',"coerce -> %k %t",c->base,c->tp);
        !          6112:                return c;
        !          6113:        }
        !          6114: //error('d',"coerce ->0");
        !          6115:        return 0;
        !          6116: }
        !          6117: 
        !          6118: int in_class_dcl;
        !          6119: 
        !          6120: Pname name::dofct(Ptable tbl, TOK scope)
        !          6121: {      
        !          6122:        Pfct f = Pfct(tp);
        !          6123:        Pname class_name;
        !          6124:        Ptable etbl;
        !          6125:        in_class_dcl = cc->not!=0;
        !          6126:        int just_made = 0;
        !          6127: //     int fvirt = 0;  //BSopt
        !          6128:        DB( if(Ddebug>=1) error('d',"dofct %n %d %t %s",this,tp,tp,tbl==gtbl?"global":""); );
        !          6129: // error( 'd', "%n->dofct(): n_initializer: %d f->f_virtual: %d", this, n_initializer, f->f_virtual);
        !          6130: 
        !          6131:        if (f->f_inline) n_sto = STATIC;
        !          6132: 
        !          6133:        if (n_stclass)
        !          6134:                switch (n_stclass) {
        !          6135:                case EXTERN:
        !          6136:                case STATIC:
        !          6137:                case OVERLOAD:
        !          6138:                        break;
        !          6139:                default:
        !          6140:                        error("%n declared%k",this,n_stclass);
        !          6141:                        n_stclass = EXTERN;
        !          6142:                }
        !          6143: 
        !          6144:        tp->dcl(tbl);           // must be done before the type check
        !          6145: 
        !          6146:        if (n_qualifier) {      // qualified name: c::f() checked above
        !          6147:                class_name = Pbase(n_qualifier->tp)->b_name;
        !          6148:                etbl = Pclass(class_name->tp)->memtbl;
        !          6149: 
        !          6150:                if (f->f_virtual) {
        !          6151:                          error("virtual specifier illegal outsideCD(%n::%s())",class_name,this->string);
        !          6152:                         f->f_virtual = 0;
        !          6153:                }
        !          6154: 
        !          6155: 
        !          6156:                if (n_sto
        !          6157:                && n_sto!=FRIEND        // friend X::f();
        !          6158:                && f->f_inline==0) {    // inline causes n_sto==STATIC
        !          6159:                        error("%k specified for QdN%n",n_sto,this);
        !          6160:                        n_sto = 0;
        !          6161:                }
        !          6162:        }
        !          6163:        else {
        !          6164:                class_name = cc->not;
        !          6165: 
        !          6166:                // beware of local function declarations in member functions
        !          6167:                if (class_name && tbl!=cc->cot->memtbl) {
        !          6168:                        class_name = 0;
        !          6169:                        in_class_dcl = 0;
        !          6170:                }
        !          6171: 
        !          6172:                if (f->f_static && f->f_virtual) {
        !          6173:                         error("virtual staticM");
        !          6174:                         f->f_virtual = 0;
        !          6175:                }
        !          6176: 
        !          6177:                if (n_oper) check_oper(class_name);
        !          6178:                etbl = tbl;
        !          6179:        }
        !          6180: 
        !          6181: //     Pfct(tp)->memof = class_name ? Pclass(class_name->tp) : 0;
        !          6182: 
        !          6183:        if (class_name) {
        !          6184:                Pclass cl;
        !          6185:                f->memof = cl = Pclass(class_name->tp);
        !          6186:                if (f->f_virtual==0 && find_virtual(f->memof,this))
        !          6187:                        f->f_virtual = VTOK;
        !          6188: //error('d',"class_name: %s fct: %s virtual: %d", class_name->string, string, f->f_virtual );
        !          6189: 
        !          6190:                if (f->f_static && f->f_virtual) {
        !          6191:                         error("virtual staticM");
        !          6192:                         f->f_virtual = 0;
        !          6193:                }
        !          6194: 
        !          6195:                if ( cl->csu == UNION && f->f_virtual ) // don't worry about ANON
        !          6196:                        error( "%n: cannot declare a virtualFWin union", this ); 
        !          6197:         }
        !          6198: 
        !          6199:        if(f->f_const && f->memof==0) {
        !          6200:                error("onlyMFs can be constant");
        !          6201:        }
        !          6202: 
        !          6203:        if (etbl==0 || etbl->base!=TABLE) error('i',"N::dcl: etbl=%d",etbl);
        !          6204: 
        !          6205:        switch (n_oper) {
        !          6206:        case CTOR:
        !          6207:                if (f->f_virtual) {
        !          6208:                        error("virtualK");
        !          6209:                        f->f_virtual = 0;
        !          6210:                }
        !          6211: 
        !          6212: //     case DTOR:
        !          6213: //             f->f_const = 1;
        !          6214:                break;
        !          6215: 
        !          6216:        case REF:
        !          6217:                if (f->argtype) 
        !          6218:                        error("%n takes no argument",this);
        !          6219:                else if (f->returns->is_ptr() == 0) {
        !          6220:                        Pname cn = f->returns->is_cl_obj();
        !          6221:                        if (cn==0 && f->returns->base==RPTR) cn = Pptr(f->returns)->typ->is_cl_obj();
        !          6222:                        if (cn==0 || Pclass(cn->tp)->has_oper(REF)==0) {
        !          6223:                                if ( cn && class_name &&  // B B::operator->();
        !          6224:                                        strcmp(cn->string, class_name->string)==0 )
        !          6225:                                                error("%s::%n cannot return aR orCO ofC%n",cn->string,this,cn);
        !          6226:                                else error("%n must return aP toCO, aR toCO, or aCO",this);
        !          6227:                                tp = any_type; // suppress further checking
        !          6228:                        }
        !          6229:                }
        !          6230:                break;
        !          6231: 
        !          6232:        case NEW:       // void* operator new(long)
        !          6233:                if (f->f_virtual)
        !          6234:                        error("virtual%n (operator new() is static)",this);
        !          6235:                if (class_name) f->f_static = 1;        // if member: static by default
        !          6236:                if (f->nargs_known != 1)
        !          6237:                        error("ATs must be fully specified for%n",this);
        !          6238:                else if (f->nargs<1)
        !          6239:                        error("%n requires a firstA ofT size_t",this);
        !          6240:                else if (f->argtype->tp->check(size_t_type,0)) {
        !          6241:                                if (strict_opt==0
        !          6242:                                && ( f->argtype->tp->check(long_type,0)==0 ||
        !          6243:                                     f->argtype->tp->check(ulong_type,0)==0)) {
        !          6244:                                        error('w',"%n firstA should be size_t (anachronism)",this);
        !          6245:                                        f->argtype->tp = size_t_type;
        !          6246:                                        if (f->f_signature) f->sign();
        !          6247:                                }
        !          6248:                                else
        !          6249:                                        error("%n requires a firstA ofT size_t",this);
        !          6250:                }
        !          6251:                else {
        !          6252:                        Ptype t = f->s_returns  ? f->s_returns : f->returns;
        !          6253:                        if (t->check(Pvoid_type,0)) error("bad returnT for %n",this);
        !          6254:                }
        !          6255:                break;
        !          6256: 
        !          6257:                case DELETE:    // void operator delete(void*) or
        !          6258:                                // void operator delete(void*, long)
        !          6259:                        if (f->f_virtual)
        !          6260:                                error("virtual%n (operator delete() is static)",this);
        !          6261:                        if (class_name) f->f_static = 1;        // if member: static by default
        !          6262:                        if (f->nargs_known != 1)
        !          6263:                                        error("ATs must be fully specified for%n",this);
        !          6264:                        else {
        !          6265:                                Ptype t = f->s_returns ? f->s_returns : f->returns;
        !          6266:                                if (t->base != VOID)
        !          6267:                                        error("bad returnT for %n", this);
        !          6268:                                else {
        !          6269:                                        switch (f->nargs) {
        !          6270:                                        default:
        !          6271:                                                error("%n takes 1 or 2As",this);
        !          6272:                                                break;
        !          6273:                                        case 1:
        !          6274:                                        case 2:
        !          6275:                                        {       Pname a = f->argtype;
        !          6276:                                                if (a->tp->check(Pvoid_type,0))
        !          6277:                                                                error("%n's 1stA must be a void*",this);
        !          6278:                                                else if (a = a->n_list) {
        !          6279:                                                        if (class_name == 0)
        !          6280:                                                                error("%n takes only oneA",this);
        !          6281:                                                        else if (a->tp->check(size_t_type,0)) {
        !          6282:                                                                if (strict_opt==0
        !          6283:                                                                && a->tp->check(long_type,0)==0) {
        !          6284:                                                                        error('w',"%n's 2ndA should be a size_t (anachronism)",this);
        !          6285:                                                                        a->tp = size_t_type;
        !          6286:                                                                        if (f->f_signature) f->sign();
        !          6287:                                                                }
        !          6288:                                                                else
        !          6289:                                                                        error("%n's 2ndA must be a size_t",this);
        !          6290:                                                        }
        !          6291:                                                }
        !          6292:                                        }
        !          6293:                                        }
        !          6294:                                }
        !          6295:                                }
        !          6296:                break;
        !          6297: 
        !          6298:        case ASSIGN:
        !          6299:                if (class_name && f->nargs==1) {
        !          6300:                        Ptype t = f->argtype->tp;
        !          6301:                        Pname an = t->is_cl_obj();  // X::operator=(X) ?
        !          6302:                        if (an==0 && (t=t->is_ref())) { // X::operator=(X&) ?
        !          6303:                                t = Pptr(t)->typ;
        !          6304:                        rx1:
        !          6305:                                switch (t->base) {
        !          6306:                                case TYPE:      t = Pbase(t)->b_name->tp; goto rx1;
        !          6307:                                case COBJ:      an = Pbase(t)->b_name;
        !          6308:                                }
        !          6309:                        }
        !          6310:                        if (an && an==class_name) Pclass(an->tp)->c_xref |= C_ASS;
        !          6311:                }
        !          6312:                else if (f->nargs == 2) {
        !          6313:                        Ptype t = f->argtype->tp;
        !          6314:                        Pname an1;
        !          6315:                        if (t=t->is_ref()) { // operator=(X&,?) ?
        !          6316:                                t = Pptr(t)->typ;
        !          6317:                        rx2:
        !          6318:                                switch (t->base) {
        !          6319:                                case TYPE:      t = Pbase(t)->b_name->tp; goto rx2;
        !          6320:                                case COBJ:      an1 = Pbase(t)->b_name;
        !          6321:                                }
        !          6322:                        }
        !          6323:                        t = f->argtype->n_list->tp;
        !          6324:                        Pname an2 = t->is_cl_obj(); // operator=(X&,X) ?
        !          6325:                        if (an2==0 && (t=t->is_ref())) { // operator=(X&,X&) ?
        !          6326:                                t = Pptr(t)->typ;
        !          6327:                        rx3:
        !          6328:                                switch (t->base) {
        !          6329:                                case TYPE:      t = Pbase(t)->b_name->tp; goto rx3;
        !          6330:                                case COBJ:      an2 = Pbase(t)->b_name;
        !          6331:                                }
        !          6332:                        }
        !          6333:                        if (an1 && an1==an2) Pclass(an1->tp)->c_xref |= C_ASS;
        !          6334:                }
        !          6335:        }
        !          6336: 
        !          6337:        switch (scope) {
        !          6338:        case FCT:
        !          6339:        case ARG:
        !          6340:                if (n_sto == STATIC) error("D of staticF in aF");
        !          6341:                else { // detect local re-definition
        !          6342:                        Pname nx = gtbl->look(string,0);
        !          6343:                        if (nx) {
        !          6344:                                switch (nx->tp->base) {
        !          6345:                                case FCT:
        !          6346:                                        if (tp->check(nx->tp,0))
        !          6347:                                                error('w',"%n has been locally re-declared as%t",this,tp);
        !          6348:                                        else {
        !          6349:                                                if(Pfct(nx->tp)->f_signature==0)
        !          6350:                                                        Pfct(nx->tp)->sign();
        !          6351:                                                if (Pfct(tp)->f_signature == 0)
        !          6352:                                                        Pfct(tp)->sign();
        !          6353:                                                if ( strcmp(Pfct(nx->tp)->f_signature,Pfct(tp)->f_signature))
        !          6354:                                                        error('w',"%n of type %t has been locally re-declared with different linkage",this,tp);
        !          6355:                                        }
        !          6356:                                        break;
        !          6357:                                case OVERLOAD:
        !          6358:                                {       Pname ny = Pgen(nx->tp)->find(f,0);
        !          6359:                                        if (ny == 0)
        !          6360:                                                error('w',"overloadedF%n has been locally declared as%t",this,tp);
        !          6361:                                        else {
        !          6362:                                                if(Pfct(ny->tp)->f_signature==0)
        !          6363:                                                        Pfct(ny->tp)->sign();
        !          6364:                                                if (Pfct(tp)->f_signature == 0)
        !          6365:                                                        Pfct(tp)->sign();
        !          6366:                                                if (strcmp(Pfct(ny->tp)->f_signature,Pfct(tp)->f_signature))
        !          6367:                                                        error('w',"overloadedF%n of type %t has been locally re-declared with different linkage",this,tp);
        !          6368:                                        }
        !          6369:                                }
        !          6370:                                        break;
        !          6371:                                } // switch nx->base
        !          6372:                        } // if nx
        !          6373:                } // else
        !          6374:        } // switch scope
        !          6375: 
        !          6376:        Pname nn = etbl->insert(this,0);
        !          6377:        if ( f->body ) nn->where = where;
        !          6378:        nn->assign();
        !          6379:        n_table = etbl;
        !          6380: //error('d',"%n->dofct(): n_initializer:%d f->f_virtual:%d",this,n_initializer,f->f_virtual);
        !          6381:        if (n_initializer) {
        !          6382:                if (f->f_virtual == 0) error("Ir for non-virtualF%n",this);
        !          6383:                if (n_initializer != zero) error("virtualFIr must be 0");
        !          6384:        }
        !          6385:                        
        !          6386:        if (Nold) {
        !          6387:                Pfct nf = Pfct(nn->tp);
        !          6388: // error('d',"old %n: %t and %t",nn,nf,tp);
        !          6389:                int flag = 0;
        !          6390:                Pname af=0,anf=0;
        !          6391:                if (nf->base==ANY || f->base==ANY)
        !          6392:                        ; // wild card -- do nothing
        !          6393:                else 
        !          6394:                if (nf->base == OVERLOAD) {
        !          6395:                        string = nn->string;
        !          6396:                        nn = Pgen(nf)->add(this);
        !          6397: 
        !          6398:                        if (Nold == 0) {
        !          6399:                                if (f->body && n_qualifier) {
        !          6400:                                        error("badAL for%n",this);
        !          6401:                                        return 0;
        !          6402:                                }
        !          6403:                                goto thth;
        !          6404:                        }
        !          6405:                //      else {
        !          6406:                //              if (f->body==0 && friend_in_class==0) error('w',"%n redeclared",nn);
        !          6407:                //      }
        !          6408:                        nf = Pfct(nn->tp);
        !          6409:                        if (f->body && nf->body) {
        !          6410:                                // Preserve the original definition 
        !          6411:                                // in the case of a PT class; i.e, 
        !          6412:                                // the one supplied by the user
        !          6413:                                if (!(class_name &&
        !          6414:                                        (Pclass(class_name->tp)->class_base ==
        !          6415:                                                instantiated_template_class) && 
        !          6416:                                        nn->n_redefined))
        !          6417:                                        {
        !          6418:                                        error("two definitions of%n",nn);
        !          6419:                                        f->body = 0;
        !          6420:                                }
        !          6421:                                return 0;
        !          6422:                        }
        !          6423:                        if (f->body) goto bdbd;
        !          6424:                        goto stst;
        !          6425:                }
        !          6426:                else if (nf->base != FCT) {
        !          6427:                        error("%n declared both as%t and asF",this,nf);
        !          6428:                        f->body = 0;
        !          6429:                }
        !          6430:                else  {
        !          6431: // error('d',"%t->check(%t) -> %d %d",nf,f,nf->check(f,OVERLOAD));
        !          6432:                        if (nf->check(f,OVERLOAD) || const_problem) {
        !          6433:                                if (f->body && n_qualifier) {
        !          6434:                                        error("%nT mismatch: %t and %t",nn,nf,f);
        !          6435:                                        return 0;
        !          6436:                                }
        !          6437:                                Pgen g = new gen;
        !          6438:                                add_first = 1;
        !          6439:                                Pname n1 = g->add(nn);
        !          6440:                                add_first = 0;
        !          6441:                                string = nn->string;
        !          6442:                                Pname n2 = g->add(this);
        !          6443:                                nn->tp = g;
        !          6444:                                nn = n2;
        !          6445:                                goto thth;
        !          6446:                        }
        !          6447: 
        !          6448:                         af = f->argtype;
        !          6449:                         anf = nf->argtype;
        !          6450:                        for (; af && anf; af=af->n_list,anf=anf->n_list) {
        !          6451:                                Ptype at = af->tp;
        !          6452:                                Ptype atp = anf->tp;
        !          6453:                                if(!exact1(af,atp)) break;
        !          6454:                                if(at->base!=PTR || 
        !          6455:                                   Pptr(at)->rdo == Pptr(atp)->rdo) continue;
        !          6456:                                int k = Pptr(at)->typ->tconst();
        !          6457:                                int l = Pptr(atp)->typ->tconst();
        !          6458:                                if(k==l) flag=1;
        !          6459:                        }
        !          6460:                        if ( flag && !af && !anf) {
        !          6461:                                error("the overloading mechanism cannot tell a%t from a%t",nf,f);
        !          6462:                        }
        !          6463:                                
        !          6464:                        if (in_class_dcl) {
        !          6465:                        //      error("twoDs of%n",this);
        !          6466:                        //      f->body = 0;
        !          6467:                        //      return 0;
        !          6468:                        }
        !          6469:                        else if (nf->f_static && f->f_inline==0 && n_sto==STATIC) {
        !          6470:                                //error('d',"MF%n declared static outsideF",this);
        !          6471:                                n_sto = 0;
        !          6472:                        }
        !          6473:                        else if (n_sto && n_sto!=nn->n_scope) {
        !          6474:                                if (n_sto==EXTERN && nn->n_scope==STATIC)
        !          6475:                                        error('w',"%n declared extern after being declared static",this);
        !          6476:                                else if (nf->f_inline==0 && f->f_inline==0) {
        !          6477:                                        if (nn->tp==new_fct->tp || nn->tp==del_fct->tp)
        !          6478:                                                nn->n_sto = n_sto;
        !          6479:                                        else
        !          6480:                                                error("%n declared as both%k and%k",this,n_sto,(nn->n_sto)?nn->n_sto:EXTERN);
        !          6481:                                }
        !          6482:                        }
        !          6483: 
        !          6484: //error('d',"fct %n: %k %k scope %k",this,n_sto,nn->n_sto,nn->n_scope);        
        !          6485: //error('d',"link %d lcount %d sig %s",linkage,lcount,nf->f_signature);
        !          6486: 
        !          6487:                        { 
        !          6488:                                Linkage l1 = nf->f_linkage;
        !          6489:                                Linkage l2 = f->f_linkage;
        !          6490:                                if ( l2!=linkage_default && l1!=l2)
        !          6491:                                        error("inconsistent linkage specifications for%n",this);
        !          6492:                        }
        !          6493:                        if (nf->body && f->body) {
        !          6494:                                // Preserve the original definition 
        !          6495:                                // in the case of a PT class; i.e, 
        !          6496:                                // the one supplied by the user
        !          6497:                                if (!(class_name &&
        !          6498:                                        (Pclass(class_name->tp)->class_base ==
        !          6499:                                                instantiated_template_class) && 
        !          6500:                                        nn->n_redefined))
        !          6501:                                        {
        !          6502:                                error("two definitions of%n",this);
        !          6503:                                f->body = 0;
        !          6504:                                }
        !          6505:                                return 0;
        !          6506:                        }
        !          6507:                                
        !          6508:                        if (f->body) goto bdbd;
        !          6509: 
        !          6510:                        goto stst;
        !          6511:        
        !          6512:                bdbd: 
        !          6513: // error('d',"nn %n init: %d f_virt: %d f->body: %d", nn,nn->n_initializer,nf->f_virtual,f->body);
        !          6514:                        if (f->nargs_known && nf->nargs_known) merge_init(nn,f,nf);
        !          6515:                        f->f_virtual = nf->f_virtual;
        !          6516:                        f->f_this = nf->f_this;
        !          6517:                        f->f_result = nf->f_result;
        !          6518:                        f->s_returns = nf->s_returns;
        !          6519:                        f->f_args = nf->f_args;
        !          6520:                //      f->argtype = nf->argtype;
        !          6521:                        f->f_signature = nf->f_signature;
        !          6522:                        f->f_const = nf->f_const;
        !          6523:                        f->f_static = nf->f_static;
        !          6524:                        nn->tp = f;
        !          6525:                        if (f->f_inline) {
        !          6526:                                if (nf->f_inline==0) {
        !          6527:                                           if (nn->n_used && nn->n_sto!=STATIC)
        !          6528:                                                error("%n declared with external linkage and called before defined as inline",nn);
        !          6529:                                //      else if (nf->memof)
        !          6530:                                //              error('w',"%n declared as non-inline but defined as inline",nn);
        !          6531:                                        else if (nn->n_used) {
        !          6532:                                                nn->take_addr(); // force printout
        !          6533:                                                if (warning_opt) error('w',"%n called before defined as inline",nn);
        !          6534:                                }
        !          6535:                                }
        !          6536:                                nf->f_inline = 1;
        !          6537:                                nn->n_sto = STATIC;
        !          6538:                        }
        !          6539:                        else if (nf->f_inline) {
        !          6540:                //              error('w',"%n defined as inline but not declared as inline",this);
        !          6541:                                f->f_inline = 1;
        !          6542:                        }
        !          6543:                        goto stst2;
        !          6544: 
        !          6545:                stst:
        !          6546: //error('d',"stst");
        !          6547:                        if (f->nargs_known && nf->nargs_known) merge_init(nn,f,nf);
        !          6548:                        f->f_args = nf->f_args;
        !          6549:                //      f->argtype = nf->argtype;
        !          6550:                stst2:
        !          6551: //error('d',"stst2 %n printed %d",nn,nn->n_dcl_printed);
        !          6552:                        if (f->f_inline) n_sto = STATIC;
        !          6553: 
        !          6554: /* superceded above (line 1978 and following)
        !          6555:                        if (n_sto
        !          6556:                        && nn->n_scope!=n_sto
        !          6557:                        && friend_in_class==0
        !          6558:                        && f->f_inline==0){ // allow re-def to "static"
        !          6559:                                if (n_sto == STATIC)
        !          6560:                                        nn->n_sto = STATIC;
        !          6561:                                else {
        !          6562:                                        error("%n both%k and%k",this,n_sto,nn->n_scope);
        !          6563:                                }
        !          6564:                        }
        !          6565: */
        !          6566: 
        !          6567: //// addition for 2.1
        !          6568: 
        !          6569:                        if(n_sto == STATIC && nn->n_sto == EXTERN &&
        !          6570:                            (!strcmp(string,"__nw") || !strcmp(string,"__dl")))
        !          6571:                                nn->n_sto = STATIC;
        !          6572: 
        !          6573: //// end of addition
        !          6574: 
        !          6575:                        n_scope = nn->n_scope; // first specifier wins
        !          6576:                        n_sto = nn->n_sto;
        !          6577:                }
        !          6578:        }
        !          6579:        else {  // new function: make f_this for member functions
        !          6580:        thth:
        !          6581:                just_made = 1;
        !          6582:                if (f->f_inline)
        !          6583:                        nn->n_sto = STATIC;
        !          6584:                else if (class_name==0 && n_sto==0 && f->body==0)
        !          6585:                        nn->n_sto = EXTERN;
        !          6586: //error('d',"thth %n %t static %d sto %k",nn,f,f->f_static,nn->n_sto);
        !          6587:                if (f->f_static)
        !          6588:                        switch (n_oper) {       // what about + ??
        !          6589:                        case CTOR:
        !          6590:                        case DTOR:
        !          6591:                        case TYPE:
        !          6592:                        case CALL:
        !          6593:                        case DEREF:
        !          6594:                        case REF:
        !          6595:                        case ASSIGN:
        !          6596:                                error("%n cannot be a staticMF",nn);
        !          6597:                                f->f_static = 0;
        !          6598:                        }
        !          6599: 
        !          6600:                if (class_name
        !          6601:                && f->f_static==0       // no ``this'' in static members
        !          6602:                && n_oper!=NEW          // X::operator new() static by default
        !          6603:                && n_oper!=DELETE       // X::operator delete() static by default
        !          6604:                && etbl!=gtbl) {        // beware of implicit declaration 
        !          6605:                        Pname cn = nn->n_table->t_name;
        !          6606:                        Pname tt = new name("this");
        !          6607:                        tt->n_scope = ARG;
        !          6608:                        tt->where = no_where;
        !          6609:                //      tt->n_sto = ARG;
        !          6610:                        tt->tp = Pclass(class_name->tp)->this_type;
        !          6611:                        PERM(tt);
        !          6612:                        Pfct(nn->tp)->f_this = f->f_this = Pfct(nn->tp)->f_args = f->f_args = tt;
        !          6613:                        tt->n_list = f->argtype;
        !          6614: //error('d',"nn %n tp %t const %d",nn,nn->tp,f->f_const);
        !          6615:                        if (f->f_const /*&& n_oper!=CTOR && n_oper!=DTOR*/) {
        !          6616:                                Pbase x = Pbase(Pptr(tt->tp)->typ);
        !          6617:                                Pbase y = new basetype(COBJ,0);
        !          6618:                                *y = *x;
        !          6619:                                y->b_const = 1;
        !          6620:                                tt->tp = new ptr(PTR,y);
        !          6621:                                Pptr(tt->tp)->rdo = 1;
        !          6622:                                PERM(tt->tp);
        !          6623:                        }
        !          6624:                }
        !          6625:                else {
        !          6626:                        Pfct(nn->tp)->f_args = f->f_args = f->f_result?f->f_result:f->argtype;
        !          6627:                        Pfct(nn->tp)->f_signature = f->f_signature;
        !          6628:                        Pfct(nn->tp)->f_const = f->f_const;
        !          6629:                        Pfct(nn->tp)->f_static = f->f_static;
        !          6630:                }
        !          6631: 
        !          6632:                // if C++ linkage encode type in function name
        !          6633:                if (Pfct(nn->tp)->f_signature==0) Pfct(nn->tp)->sign();
        !          6634: 
        !          6635:                if (f->f_result == 0) {
        !          6636: //error('d',"re1 %n %t %d",this,f,f);
        !          6637:                        make_res(f);
        !          6638:                }
        !          6639:                else if (f->f_this)
        !          6640:                        f->f_this->n_list = f->f_result;
        !          6641: 
        !          6642:                if (nn->n_oper==CTOR || nn->n_oper==DTOR) vbase_pointers(nn,Pclass(class_name->tp));
        !          6643: 
        !          6644:                if (f->f_virtual) {
        !          6645:                        switch (nn->n_scope) {
        !          6646:                        default:
        !          6647:                                error("nonC virtual%n",this);
        !          6648:                                break;
        !          6649:                        case 0:
        !          6650:                        case PUBLIC:
        !          6651:                                //      if (fvirt)      //BSopt
        !          6652:                                cc->cot->virt_count = 1;
        !          6653:                                Pfct(nn->tp)->f_virtual = f->f_virtual;
        !          6654:                                break;
        !          6655:                        }
        !          6656:                }
        !          6657:        }
        !          6658: 
        !          6659:                /*      an operator must take at least one class object or
        !          6660:                        reference to class object argument
        !          6661:                */
        !          6662: 
        !          6663:        if (just_made)
        !          6664:        switch (n_oper) {
        !          6665:        case CTOR:
        !          6666:                switch (f->nargs) {     // check for X(X) and X(X&)
        !          6667:                case 0:
        !          6668:                        break;
        !          6669:                default:                // handle X(X&, int i = 0)
        !          6670:                {       Pname n2 = f->argtype->n_list;
        !          6671:                        if (n2->n_initializer==0 && n2->n_evaluated==0) break;
        !          6672:                }
        !          6673:                case 1:
        !          6674:                {
        !          6675:                        Ptype t = f->argtype->tp;
        !          6676:                clll:
        !          6677:                        switch (t->base) {
        !          6678:                        case TYPE:
        !          6679:                                t = Pbase(t)->b_name->tp;
        !          6680:                                goto clll;
        !          6681:                        case RPTR:                      /* X(X&) ? */
        !          6682:                                t = Pptr(t)->typ;
        !          6683:                        cxll:
        !          6684:                                switch (t->base) {
        !          6685:                                case TYPE:
        !          6686:                                        t = Pbase(t)->b_name->tp;
        !          6687:                                        goto cxll;
        !          6688:                                case COBJ:
        !          6689:                                        if (class_name == Pbase(t)->b_name)
        !          6690:                                                Pclass(class_name->tp)->c_itor = nn;
        !          6691:                                }
        !          6692:                                break;
        !          6693:                        case COBJ:                      /* X(X) ? */
        !          6694:                                if (class_name == Pbase(t)->b_name) {
        !          6695:                                        error("badK %s(%s) use %s(%s&)",class_name->string,class_name->string,class_name->string,class_name->string);
        !          6696:                                        f->argtype->tp = any_type;
        !          6697:                                }
        !          6698:                        }
        !          6699:                }
        !          6700:                }
        !          6701:                if (Pclass(class_name->tp)->c_ctor == 0) Pclass(class_name->tp)->c_ctor = nn;
        !          6702:                break;
        !          6703: 
        !          6704:        case TYPE:
        !          6705:                // somewhat simple minded solution to the inheritance of
        !          6706:                // conversion operator problem
        !          6707:                nn->n_list = Pclass(class_name->tp)->conv;
        !          6708:                Pclass(class_name->tp)->conv = nn;
        !          6709:                break;
        !          6710: 
        !          6711:        case DTOR:
        !          6712:                Pclass(class_name->tp)->c_dtor = nn;
        !          6713:                break;
        !          6714: 
        !          6715:        case NEW:       
        !          6716:        case DELETE:
        !          6717:        case CALL:
        !          6718:        case 0:
        !          6719:                break;
        !          6720: 
        !          6721:        default:
        !          6722:                for (Pname a=f->argtype; a; a=a->n_list) {
        !          6723:                        if ( a->n_initializer )
        !          6724:                                error( "%n: operatorFs cannot take defaultA", this );
        !          6725:                }
        !          6726: 
        !          6727:                if (f->nargs_known != 1) {
        !          6728:                        error("ATs must be fully specified for%n",nn);
        !          6729:                }
        !          6730:                // this doesn't catch unary operator off by one errors
        !          6731:                // for simplicity, placed that check in check_oper(), above
        !          6732:                else if (class_name == 0) {
        !          6733:                        switch (f->nargs) {
        !          6734:                        case 1:
        !          6735:                        case 2:
        !          6736:                                for (a=f->argtype; a; a=a->n_list) {
        !          6737:                                        Ptype tx = a->tp;
        !          6738:                                        while (tx->base == TYPE) tx = Pbase(tx)->b_name->tp;
        !          6739:                                        if (tx->is_ref()) tx = Pptr(tx)->typ;
        !          6740:                                        if (tx->is_cl_obj()) goto cok;
        !          6741:                                }
        !          6742:                                error("%n must take at least oneCTA",nn);
        !          6743:                                break;
        !          6744:                        default:
        !          6745:                                error("%n must take 1 or 2As",nn);
        !          6746:                        }
        !          6747:                }
        !          6748:                else {
        !          6749:                        switch (f->nargs) {
        !          6750:                        case 0:
        !          6751:                        case 1:
        !          6752:                                break;
        !          6753:                        default:
        !          6754:                                error("%n must take 0 or 1As",nn);
        !          6755:                        }
        !          6756:                }
        !          6757:        cok:;
        !          6758:        }
        !          6759: 
        !          6760:        int i = 0;      // check that every argument after an argument with
        !          6761:                        // initializer have an initializer
        !          6762:        for (Pname a = f->f_args/*f->argtype*/; a; a=a->n_list) {
        !          6763:                if (a->n_initializer)
        !          6764:                        i = 1;
        !          6765:                else if (i)
        !          6766:                        error("trailingA%n withoutIr",a);
        !          6767:        }
        !          6768: 
        !          6769:        /*
        !          6770:                the body cannot be checked until the name
        !          6771:                has been checked and entered into its table
        !          6772:        */
        !          6773:        if (f->body) f->dcl(nn);
        !          6774:        return nn;
        !          6775: }
        !          6776: 
        !          6777: 0707071010112043711004440001630000160000010174600466055376600000700000154273dcl4.c/*ident     "@(#)ctrans:src/dcl4.c  1.4" */
        !          6778: /**************************************************************************
        !          6779: 
        !          6780:        C++ source for cfront, the C++ compiler front-end
        !          6781:        written in the computer science research center of Bell Labs
        !          6782: 
        !          6783:        Copyright (c) 1984 AT&T, Inc. All Rights Reserved
        !          6784:        THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T, INC.
        !          6785: 
        !          6786: dcl4.c:
        !          6787:        Declaration of class and enum
        !          6788: 
        !          6789: *************************************************************************/
        !          6790: 
        !          6791: #include "cfront.h"
        !          6792: #include "size.h"
        !          6793: #include "template.h"
        !          6794: 
        !          6795: Pname find_vptr(Pclass);
        !          6796: void fix_args(Pfct f, Pclass cl)
        !          6797: /*
        !          6798:        This function is used to cope with the case where cl::cl(cl&) is
        !          6799:        declared AFTER f has been declared
        !          6800:        set n_xref bit for f
        !          6801: */
        !          6802: {
        !          6803:        for (Pname a = f->argtype; a; a = a->n_list) {
        !          6804:                Pname n = a->tp->is_cl_obj();
        !          6805:                if (n && Pclass(n->tp)==cl) a->n_xref = 1;
        !          6806:        }
        !          6807: }
        !          6808: 
        !          6809: Pname merge_conv(Pname c1, Pname c2)
        !          6810: {
        !          6811:        if (c1 == 0) return c2;
        !          6812:        if (c2 == 0) return c1;
        !          6813:        if (c1 == c2) return c1;
        !          6814:        error('s',"cannot merge lists of conversion functions");
        !          6815:        return c1;
        !          6816: }
        !          6817: 
        !          6818: static Eppp;
        !          6819: 
        !          6820: char* get_classname(char* s)
        !          6821: /*
        !          6822:        retrieve the outermost class name in a vtable name
        !          6823: */
        !          6824: {
        !          6825: //error('d',"get_classname(%s)",s);
        !          6826:        char* s1 = 0;
        !          6827: 
        !          6828:        while (*s) {
        !          6829:                s1 = s;
        !          6830:                for ( ; s[0] && (s[0] != '_' || s[1] && s[1] != '_'); s++);
        !          6831:                if (*s) s += 2; // bypass "__"
        !          6832:        }
        !          6833: 
        !          6834:        return s1;
        !          6835: }
        !          6836: 
        !          6837: char* drop_classname(char* s)
        !          6838: /*
        !          6839:        retrieve all but the outermost class name in a vtable name
        !          6840: */
        !          6841: {
        !          6842: //error('d',"drop_classname(%s)",s);
        !          6843:        char* r = new char[strlen(s)+1];
        !          6844:        sprintf(r,s);
        !          6845:        s = r;
        !          6846: 
        !          6847:        char* s1 = s;
        !          6848:        while (*s) {
        !          6849:                for ( ; s[0] && (s[0] != '_' || s[1] && s[1] != '_'); s++);
        !          6850:                if (*s) {
        !          6851:                        s1 = s;
        !          6852:                        s += 2; // bypass "__"
        !          6853:                }
        !          6854:        }
        !          6855: 
        !          6856:        *s1 = '\0';
        !          6857: 
        !          6858:        return (*r) ? r : 0;
        !          6859: }
        !          6860:                
        !          6861: Pbcl classdef::get_base( char *s )
        !          6862: /*
        !          6863:        Find the base class whose name matches the argument
        !          6864: */
        !          6865: {
        !          6866: //error('d',"%t::get_base(%s)",this,s);
        !          6867:        for (Pbcl b = baselist; b; b = b->next) {
        !          6868:                for ( char *s1 = s, *s2 = b->bclass->string;
        !          6869:                     *s1 && *s2 && *s1 == *s2;
        !          6870:                     s1++, s2++);
        !          6871:                
        !          6872:                if (!(*s1 || *s2))
        !          6873:                        break;
        !          6874:        }
        !          6875: 
        !          6876:        return b;
        !          6877: }
        !          6878: 
        !          6879: int classdef::get_offset(char* s)
        !          6880: /*
        !          6881:        Get offset represented by string as viewed from "this"
        !          6882: */
        !          6883: {
        !          6884: //error('d',"%t::get_offset(%s)",this,s);
        !          6885:        if (!s) return 0;
        !          6886: 
        !          6887:        Pbcl b = get_base(get_classname(s));
        !          6888: 
        !          6889:        return b->obj_offset + b->bclass->get_offset(drop_classname(s));
        !          6890: }
        !          6891: 
        !          6892: char* vtbl_str(char* s1, char* s2)
        !          6893: /*
        !          6894:        combine two pieces of a vtbl name
        !          6895: */
        !          6896: {
        !          6897: //error('d',"vtbl_str(%s,%s)",s1,s2);
        !          6898:        char* s3;
        !          6899:        if (s1)
        !          6900:                if (s2) {
        !          6901:                        s3 = new char[strlen(s1)+strlen(s2)+3];
        !          6902:                        sprintf(s3,"%s__%s",s1,s2);
        !          6903:                        return s3;
        !          6904:                }
        !          6905:                else
        !          6906:                        return s1;
        !          6907:        else
        !          6908:                return s2;
        !          6909: }
        !          6910: 
        !          6911: void classdef::add_vtbl(velem* v, char* s, bit virt_flag, int n_init)
        !          6912: /*
        !          6913:        add vtbl to virt_list
        !          6914: */
        !          6915: {
        !          6916: // error('d',"%t->add_vtbl(%d,%s)",this,v,s);
        !          6917:        Pvirt vtab = new virt(this, v, s, virt_flag, n_init);
        !          6918: 
        !          6919:        if (virt_flag) has_vvtab = 1;
        !          6920: 
        !          6921:        if (!virt_list) {
        !          6922:                virt_list = vtab;
        !          6923:                return;
        !          6924:        }
        !          6925: 
        !          6926:        // If conficting vtable entries are made because of
        !          6927:        // a virtual base class, must be considered an error.
        !          6928:        for (Pvirt vt = virt_list; vt; vt = vt->next )
        !          6929: //             if (strcmp(vt->string,s)==0) {
        !          6930:                 if (vt->string && strcmp(vt->string,s)==0) {
        !          6931:                        velem* ivec = vt->virt_init;
        !          6932:                        Pname on = ivec[0].n;
        !          6933:                        Pname nn = v[0].n;
        !          6934:                        Pclass ocl,ncl;
        !          6935:                        for (int i=0; on && nn; i++,on=ivec[i].n,nn=v[i].n) {
        !          6936:                                ocl = Pfct(on->tp)->memof;
        !          6937:                                ncl = Pfct(nn->tp)->memof;
        !          6938:                                if (on != nn)
        !          6939:                                        if (!ocl->has_base(ncl))
        !          6940:                                                if (!ncl->has_base(ocl))
        !          6941:                                                        break;
        !          6942:                                                else {
        !          6943:                                                        ivec[i].n = nn;
        !          6944:                                                        ivec[i].offset = v[i].offset;
        !          6945:                                                }
        !          6946:                        }
        !          6947:                        if (on || nn)
        !          6948:                                error("virtualB: ambiguous%n and%n", on, nn);
        !          6949:                        return;
        !          6950:                }
        !          6951: 
        !          6952:        vtab->next = virt_list->next;
        !          6953:        virt_list->next = vtab;
        !          6954: }
        !          6955: 
        !          6956: static int Voffset;    // cope with offsets of virtuals in deep nests
        !          6957: int vcounter;
        !          6958: static vmax;
        !          6959: const vpChunk = 32;
        !          6960: 
        !          6961: int classdef::do_virtuals(Pvirt vtab, char* str, int leftmost, bit virt_flag)
        !          6962: /*
        !          6963:        make vtbl for b in "this"
        !          6964:        match up virtuals and assign virtual indices for the base or delegate "bcl"
        !          6965:        first base class shares ``this'' and vtbl with this class
        !          6966: */
        !          6967: {
        !          6968:        if (vmax<vcounter) vmax = vcounter;
        !          6969:         int vpsz = (vmax+vcounter)/vpChunk+1;   // fragmentation prevention
        !          6970:         vpsz *= vpChunk;
        !          6971:        Pname* vp = new Pname[vpsz];
        !          6972:        velem* ivec = vtab ? vtab->virt_init : 0;
        !          6973:        int vo = Voffset;
        !          6974:        int vc = 0;
        !          6975:        int changed = 0;
        !          6976: 
        !          6977: // error('d',"%t->do_virtuals(%d,%s) voffset %d",this,vtab,str,Voffset);
        !          6978: // error('d',"virt_count %d vpsz %d vcounter %d",virt_count,vpsz,vcounter);
        !          6979: 
        !          6980: if (ivec) {    // vtbl replacement for ivec
        !          6981: 
        !          6982:        if (vtab->is_vbase) {
        !          6983:                str = 0;
        !          6984:                Voffset = get_offset(vtab->string);
        !          6985:        }
        !          6986:        else
        !          6987:                Voffset = Voffset + vtab->vclass->get_offset(vtab->string);
        !          6988:        Pname vn;
        !          6989:        for (int i=0; vn=ivec[i].n; i++) {
        !          6990: 
        !          6991:        /*      go through virtual table's list of virtuals:
        !          6992:                first see if the function is simply inherited
        !          6993:                if not, check for a match
        !          6994:                if not, then add as new
        !          6995:        */
        !          6996:        //      Pname vn = ivec[i];
        !          6997:                 if ( i >= vpsz ) { // resize vp vector
        !          6998:                         int tvpsz = vpsz + vpChunk;
        !          6999:                         Pname *tvp = new Pname[ tvpsz ];
        !          7000:                         for ( int j = 0; j < i; ++j )
        !          7001:                                 tvp[ j ] = vp[ j ];
        !          7002:                         delete [vpsz] vp;
        !          7003:                         vp = tvp;
        !          7004: //error( 'd',"resizing: i: %d vpsz: %d tvpsz: %d", i, vpsz, tvpsz );
        !          7005:                         vpsz = tvpsz;
        !          7006:                 }
        !          7007: 
        !          7008:                // char* s = Pchar(vn->n_tbl_list);
        !          7009:                 char* s = vn->n_gen_fct_name;
        !          7010:                Pname n = memtbl->look(s?s:vn->string, 0);
        !          7011: 
        !          7012: // error('d',"vn %n %s n %n %d",vn,s,n,Voffset);
        !          7013: // error('d',"n %n %k", n, n?n->base:0 );
        !          7014:                if (n == 0 ||                           // FCT + FCT
        !          7015:                        n->base == PUBLIC ) {           // base::FCT
        !          7016:                inher:                  // inherit
        !          7017: //                     if (vn->n_initializer) error("cannot inherit pure virtualF%n",vn);
        !          7018:                         if (vn->n_initializer) c_abstract = 1;
        !          7019:                        vp[i] = vn;
        !          7020:                         if ( ivec[i].offset && vtab->is_vbase )
        !          7021:                                 vp[i]->n_offset = Voffset - vo;
        !          7022:                         else
        !          7023:                                 vp[i]->n_offset = ivec[i].offset;
        !          7024:                        continue;
        !          7025:                }
        !          7026: 
        !          7027:                Pfct f = Pfct(n->tp);
        !          7028: // error ('d', "f %d", f );
        !          7029:                if (f == 0 ) continue;
        !          7030: // error('d',"f %t %d",f,f->f_virtual);
        !          7031: 
        !          7032:                if (s && f->base==OVERLOAD) {   // OVERLOAD + OVERLOAD
        !          7033:                        // vn is overloaded and s is its name
        !          7034:                        for (Plist gl=Pgen(f)->fct_list; gl; gl=gl->l)
        !          7035:                                if (gl->f == vn)  goto inher;
        !          7036:                }
        !          7037: 
        !          7038:                Pfct vnf = Pfct(vn->tp);
        !          7039:                                                // re-define?
        !          7040:                switch (f->base) {
        !          7041:                default:
        !          7042:                        error('w',&n->where,"%n hides virtual%n",n,vn);
        !          7043:                        vp[i] = vn;     // not a new overloaded: inherit 
        !          7044:                        if ( ivec[i].offset && vtab->is_vbase )
        !          7045:                                        vp[i]->n_offset = Voffset - vo;
        !          7046:                        else
        !          7047:                                        vp[i]->n_offset = ivec[i].offset;
        !          7048:                        break;
        !          7049:                case FCT:                       // derived::FCT
        !          7050:                {
        !          7051:                        if (vnf->check(f,VIRTUAL) == 0) { // derived::FCT match base::FCT
        !          7052: // error('d',"vnf1 %t f %t vcheck %d",vnf,f,Vcheckerror);
        !          7053:                                // VTOK: virtual, but no index assigned
        !          7054:                                // you can only inherit an index from your first base
        !          7055:                                if (Vcheckerror) error("bad virtualT match for %n",vn);
        !          7056:                                if (f->f_virtual==VTOK) f->f_virtual = i+1;
        !          7057:                                vp[i] = n;
        !          7058:                                vp[i]->n_offset = Voffset;
        !          7059:                                changed = 1;
        !          7060:                        }
        !          7061:                        else {
        !          7062: // error('d',"vnf2 %t f %t vcheck %d",vnf,f,Vcheckerror);
        !          7063:                                if (Vcheckerror)
        !          7064:                                        error("bad virtualT match for %n",vn);
        !          7065:                                else
        !          7066:                                        switch (f->f_virtual) {
        !          7067:                                                case 0:
        !          7068:                                                case VTOK:
        !          7069:                                                        error('w',&n->where,"%n hides virtual%n",n,vn);
        !          7070:                                        }
        !          7071:                                vp[i] = vn;     // not a new overloaded: inherit
        !          7072:                                 if ( ivec[i].offset && vtab->is_vbase )
        !          7073:                                         vp[i]->n_offset = Voffset - vo;
        !          7074:                                 else
        !          7075:                                         vp[i]->n_offset = ivec[i].offset;
        !          7076:                        }
        !          7077:                        break;
        !          7078:                }
        !          7079:                case OVERLOAD:                  // derived::OVERLOAD
        !          7080:                {                               
        !          7081:                        int hit = 0;
        !          7082:                        for (Plist gl=Pgen(f)->fct_list; gl; gl=gl->l) {
        !          7083:                                // try each fct from derived class
        !          7084:                                Pname fn = gl->f;
        !          7085:                                Pfct f = Pfct(fn->tp);
        !          7086:                        
        !          7087:                                if (f->check(vnf,VIRTUAL) == 0) {       // derived::FCT
        !          7088:                                        if (Vcheckerror) error("bad virtualT match for %n",vn);
        !          7089:                                        if  (f->f_virtual==VTOK) f->f_virtual = i+1;
        !          7090:                                        vp[i] = fn;
        !          7091:                                        vp[i]->n_offset = Voffset;
        !          7092:                                        changed = 1;
        !          7093:                                        goto found;
        !          7094:                                }
        !          7095:                                else {
        !          7096:                                        if (Vcheckerror) error("bad virtualT match for %n",vn);
        !          7097:                                }
        !          7098:                                if (Vcheckerror == 0)
        !          7099:                                        switch (f->f_virtual) {
        !          7100:                                                case 0:
        !          7101:                                                case VTOK:
        !          7102:                                                        hit = 1;
        !          7103:                                }
        !          7104:        
        !          7105:                        }
        !          7106: 
        !          7107:                        if (hit) 
        !          7108:                                error('w',&n->where,"%n hides virtual%n ofT %t",n,vn,vn->tp);
        !          7109: 
        !          7110:                        vp[i] = vn;     // not a new overloaded: inherit
        !          7111:                         if ( ivec[i].offset && vtab->is_vbase )
        !          7112:                                 vp[i]->n_offset = Voffset - vo;
        !          7113:                         else
        !          7114:                                 vp[i]->n_offset = ivec[i].offset;
        !          7115:                found:
        !          7116:                        break;
        !          7117:                }
        !          7118:                }
        !          7119:        }
        !          7120: 
        !          7121:        Voffset = vo;
        !          7122:        vc = i;
        !          7123: }
        !          7124: 
        !          7125: // error( 'd', "do_virtuals: out of loop: vc: %d vpsz: %d changed: %d", vc, vpsz,changed );
        !          7126: 
        !          7127:        if (leftmost) {
        !          7128:                /*
        !          7129:                        add new virtuals:
        !          7130:                        `VTOK' marks ``new virtual, no index assigned''.
        !          7131:                        You can only be new once (no base or first base).
        !          7132:                */
        !          7133:                int i;
        !          7134:                for (Pname nn=memtbl->get_mem(i=1); nn; nn=memtbl->get_mem(++i) ) {
        !          7135:                        Pfct f = Pfct(nn->tp);
        !          7136: 
        !          7137:                        if ( vc >= vpsz ) { // resize vp vector
        !          7138:                                int tvpsz = vpsz + vpChunk;
        !          7139:                                Pname *tvp = new Pname[ tvpsz ];
        !          7140:                                for ( int j = 0; j < vc; ++j )
        !          7141:                                        tvp[ j ] = vp[ j ];
        !          7142:                                delete [vpsz] vp;
        !          7143:                                vp = tvp;
        !          7144:                                vpsz = tvpsz;
        !          7145:                        }
        !          7146: 
        !          7147: // error('d',"f %n %t",nn,f);
        !          7148:                         if (f)
        !          7149:                         switch (f->base) {
        !          7150:                        case FCT:
        !          7151: //error('d',"fv %d",f->f_virtual);
        !          7152:                                if (f->f_virtual == VTOK) {
        !          7153:                                        // declared virtual, or
        !          7154:                                        // virtual in some base
        !          7155:                                        f->f_virtual = ++vc;
        !          7156:                                        vp[f->f_virtual-1] = nn;
        !          7157:                                         vp[f->f_virtual-1]->n_offset = 0;
        !          7158:                                        f->f_vdef = 1;
        !          7159:                                        changed = 2;
        !          7160:                                }
        !          7161:                                break;
        !          7162:                        case OVERLOAD:
        !          7163:                        {       for (Plist gl=Pgen(f)->fct_list; gl; gl=gl->l) {
        !          7164:                                        Pname fn = gl->f;
        !          7165:                                        Pfct f = Pfct(fn->tp);
        !          7166: 
        !          7167:  
        !          7168:                                if ( vc >= vpsz ) { // resize vp vector
        !          7169:                                        int tvpsz = vpsz + vpChunk;
        !          7170:                                        Pname *tvp = new Pname[ tvpsz ];
        !          7171:                                        for ( int j = 0; j < vc; ++j ) {
        !          7172:                                                tvp[ j ] = vp[ j ];
        !          7173:                                        }
        !          7174:                                        delete [vpsz] vp;
        !          7175:                                        vp = tvp;
        !          7176:                                        vpsz = tvpsz;
        !          7177:                                }
        !          7178:  
        !          7179: 
        !          7180:                                        if (f->f_virtual == VTOK) {
        !          7181:                                                f->f_virtual = ++vc;
        !          7182:                                                vp[f->f_virtual-1] = fn;
        !          7183:                                                vp[f->f_virtual-1]->n_offset = 0;
        !          7184:                                                f->f_vdef = 1;
        !          7185:                                                changed = 2;
        !          7186:                                        }
        !          7187:                                }
        !          7188:                                break;
        !          7189:                        }
        !          7190:                        }
        !          7191:                }
        !          7192: // error('d',"%s changed %d has_vvtab %d",string,changed,has_vvtab);
        !          7193: // error('d',"vc %d vpsz %d",vc,vpsz);
        !          7194:                virt_count = 0;
        !          7195:                if (changed)
        !          7196:                        virt_count = vc;
        !          7197:                else if (has_vvtab) {
        !          7198:                        virt_merge = 1;
        !          7199:                        if (vc && vtab->is_vbase)
        !          7200:                                leftmost = 0;
        !          7201:                }
        !          7202:        }
        !          7203: 
        !          7204: // error('d',"vc %d ch %d vp[%d] virt_count %d",vc,changed,vpsz,virt_count);
        !          7205:        if (changed || !leftmost) {
        !          7206:                // vc==0 if all explicit virtuals in fact were declared in base
        !          7207:                velem* v = new velem[vc+1];
        !          7208: 
        !          7209:                for (int i=0; i<vc; i++) {
        !          7210:                        v[i].n = vp[i];
        !          7211:                        v[i].offset = vp[i]->n_offset;
        !          7212:                }
        !          7213:                v[vc].n = 0;
        !          7214: 
        !          7215:                if (leftmost)
        !          7216:                        add_vtbl(v,0,0,0);
        !          7217:                else
        !          7218:                        add_vtbl(v,vtbl_str(vtab->string,str),virt_flag||vtab->is_vbase,vc+1);
        !          7219:                delete vp;
        !          7220:                vcounter = 0;
        !          7221:                return 1;
        !          7222:        }
        !          7223: 
        !          7224:        delete vp;
        !          7225:        vcounter = 0;
        !          7226:        return 0;
        !          7227: }
        !          7228: 
        !          7229: int classdef::all_virt(Pclass bcl, char* s, int leftmost, bit virt_flag)
        !          7230: {
        !          7231:        int i = 0;
        !          7232:        if (bcl->virt_count) {
        !          7233:                for (Pvirt blist = bcl->virt_list; blist; blist = blist->next) {
        !          7234:                        // if (has_base(blist->vclass))
        !          7235:                        //      if (blist->vclass==bcl
        !          7236:                        //              // bcl is virtual in both
        !          7237:                        //      || ((Nvirt=0,blist->vclass->has_base(bcl)) && Nvirt==VIRTUAL
        !          7238:                        //              && (Nvirt=0,has_base(bcl)) && Nvirt==VIRTUAL
        !          7239:                        //         )
        !          7240:                        //      )
        !          7241:                        if (virt_merge && !(virt_flag || blist->is_vbase))
        !          7242:                                continue;
        !          7243: 
        !          7244:                        i += do_virtuals(blist, s, leftmost, virt_flag);
        !          7245:                        if (!i && leftmost && !virt_merge)
        !          7246:                                return 0;
        !          7247: 
        !          7248:                        leftmost = 0;
        !          7249:                }
        !          7250:        }
        !          7251: 
        !          7252:        // finding virt_list stops recursive step
        !          7253:        // if vtables found and updated, return number
        !          7254:        if (i) return i;
        !          7255: 
        !          7256:        for (Pbcl b = bcl->baselist; b; b = b->next) {
        !          7257:        //      if (b->base==PTR) continue;
        !          7258:                if (b->promoted) continue;
        !          7259: // error('d',"b %t vl %d bl %d",b->bclass,b->bclass->virt_list,b->bclass->baselist);
        !          7260:                if (leftmost && b->base == VIRTUAL) {
        !          7261:                        i += do_virtuals(0, 0, 1, 0);
        !          7262:                        if (!i && !virt_merge)
        !          7263:                                return 0;
        !          7264:                        leftmost = 0;
        !          7265:                }
        !          7266:                int vo = Voffset;
        !          7267:                Voffset += b->obj_offset;
        !          7268: // error('d',"offset %t %d",b->bclass,Voffset);
        !          7269: 
        !          7270:                if (b->base==VIRTUAL)
        !          7271:                        i += all_virt(b->bclass, b->bclass->string, leftmost, 1);
        !          7272:                else
        !          7273:                        i += all_virt(b->bclass, vtbl_str(b->bclass->string,s), leftmost, virt_flag);
        !          7274:                if (!i && leftmost && !virt_merge)
        !          7275:                        return 0;
        !          7276: 
        !          7277:                Voffset = vo;
        !          7278:                leftmost = 0;
        !          7279:        }
        !          7280: 
        !          7281:        // if recursion updated vtables, return number
        !          7282:        if (i) return i;
        !          7283: 
        !          7284:        // no vtables updated in recursion
        !          7285:        // look for new virtuals
        !          7286:        if (leftmost)
        !          7287:                return do_virtuals(0, 0, 1, 0);
        !          7288:        else
        !          7289:                return 0;
        !          7290: }
        !          7291: 
        !          7292: Pexpr copy_obj(Pexpr l, Pexpr r, int sz)
        !          7293: /*
        !          7294:        generate:
        !          7295:        struct _s { char[sz]; };
        !          7296:        *(struct _s*)this->m = *(struct _s*)arg.mem;
        !          7297: */
        !          7298: {
        !          7299:        if ( !sz ) sz = 1;
        !          7300: //error('d',"copy(%d)",sz);
        !          7301:        char* s = make_name('S');
        !          7302:        fprintf(out_file,"struct %s { char v[%d]; };\n",s,sz);
        !          7303:        Pname n = new name(s);
        !          7304:        Ptype t = new basetype(COBJ,n);
        !          7305:        t = new ptr(PTR,t);
        !          7306: 
        !          7307:        l = new texpr(CAST,t,l);//new cast(t,l);
        !          7308:        l = l->contents();
        !          7309: 
        !          7310:        r = new texpr(CAST,t,r);//new cast(t,r);
        !          7311:        r = r->contents();
        !          7312: 
        !          7313:        return new expr(ASSIGN,l,r);
        !          7314: }
        !          7315: 
        !          7316: /*
        !          7317: Pname make_default_ctor(Pclass cl)
        !          7318: {
        !          7319: //error('d',"make_ctor %t",cl);
        !          7320:        Pname cn = ktbl->look(cl->string,0);
        !          7321:        if (cn) cn = Pbase(cn->tp)->b_name;
        !          7322:        cc->stack();
        !          7323:        cc->not = cn;
        !          7324:        cc->cot = cl;
        !          7325:        Pname fn = new name(cl->string);
        !          7326:        Pfct f = new fct(defa_type,0,1);
        !          7327:        fn->tp = f;
        !          7328:        fn->n_oper = TNAME;
        !          7329: //     fn->n_sto = STATIC;
        !          7330: 
        !          7331:        Pfct(f)->f_inline = 1;
        !          7332:        f->body = new block(curloc,0,0);
        !          7333: 
        !          7334:        Pname nn = fn->dcl(cl->memtbl,PUBLIC);
        !          7335:        delete fn;
        !          7336: 
        !          7337:        cc->unstack();
        !          7338:        nn->simpl();
        !          7339:        if (debug_opt) nn->dcl_print(0);
        !          7340: //error('d',"make_ctor->");
        !          7341:        return nn;
        !          7342: }
        !          7343: 
        !          7344: Pname make_default_dtor(Pclass cl)
        !          7345: {
        !          7346: //error('d',"make_dtor %t",cl);
        !          7347:        Pname cn = ktbl->look(cl->string,0);
        !          7348:        if (cn) cn = Pbase(cn->tp)->b_name;
        !          7349:        cc->stack();
        !          7350:        cc->not = cn;
        !          7351:        cc->cot = cl;
        !          7352:        Pname fn = new name(cl->string);
        !          7353:        Pfct f = new fct(defa_type,0,1);
        !          7354:        fn->tp = f;
        !          7355:        fn->n_oper = DTOR;
        !          7356: //     fn->n_sto = STATIC;
        !          7357: 
        !          7358:        Pfct(f)->f_inline = 1;
        !          7359:        f->body = new block(curloc,0,0);
        !          7360: 
        !          7361:        Pname nn = fn->dcl(cl->memtbl,PUBLIC);
        !          7362:        delete fn;
        !          7363: 
        !          7364:        cc->unstack();
        !          7365:        nn->simpl();
        !          7366:        if (debug_opt) nn->dcl_print(0);
        !          7367: //error('d',"make_dtor->");
        !          7368:        return nn;
        !          7369: }
        !          7370: */
        !          7371: 
        !          7372: Ptype find_arg_type(Pclass cl)
        !          7373: // first determine argument type
        !          7374: {
        !          7375:        int i;
        !          7376:        int mod = 0;
        !          7377:        for (Pbcl b = cl->baselist; b; b = b->next) {
        !          7378:                Pclass bcl = b->bclass;
        !          7379:                switch (b->base) {
        !          7380:                case VIRTUAL:
        !          7381:                case NAME:      //      generate :b(*(b*)&arg)
        !          7382:                {
        !          7383:                        Pname itor = bcl->has_itor();
        !          7384:                        if (itor && itor->tp->base==FCT) {
        !          7385:                                Pname a = Pfct(itor->tp)->argtype;
        !          7386:                                Pptr p = a->tp->is_ref();
        !          7387:                                if (p && p->typ->tconst()==0) {
        !          7388:                                        mod = 1;
        !          7389:                                        goto ll1;
        !          7390:                                }
        !          7391:                        }
        !          7392:                }
        !          7393:                }
        !          7394:        }
        !          7395: ll1:
        !          7396:     if (mod == 0) {
        !          7397:        for (Pname m=cl->memtbl->get_mem(i=1); m; m=cl->memtbl->get_mem(++i) ) {
        !          7398:                Pname cln;
        !          7399:                // ignore static members
        !          7400:                if (m->n_evaluated || m->n_stclass==STATIC) continue;
        !          7401: 
        !          7402:                if (cln = m->tp->is_cl_obj()) {
        !          7403:                        Pname itor = Pclass(cln->tp)->has_itor();
        !          7404:                        if (itor && itor->tp->base==FCT) {
        !          7405:                                Pname a = Pfct(itor->tp)->argtype;
        !          7406:                                Pptr p = a->tp->is_ref();
        !          7407:                                if (p && p->typ->tconst()==0) {
        !          7408:                                        mod = 1;
        !          7409:                                        goto ll2;
        !          7410:                                }
        !          7411:                        }
        !          7412:                }
        !          7413:        }
        !          7414:     }
        !          7415: ll2:
        !          7416: //error('d',"mod %d",mod);
        !          7417:                Pbase bp = new basetype(INT,0);
        !          7418:                *bp = *Pbase(Pptr(cl->this_type)->typ);
        !          7419:                if (mod == 0) bp->b_const = 1;
        !          7420:                return new ptr(RPTR,bp);
        !          7421: }
        !          7422: 
        !          7423: Pname classdef::make_itor(int def)
        !          7424: /*
        !          7425:        make cn::cn(const cn&) :bases_and_members_of_cn {}
        !          7426: */
        !          7427: {
        !          7428: //error('d',"%t->make_itor(%d) %d",this,def,obj_size);
        !          7429:        Pstmt s;
        !          7430:        Pname e;
        !          7431:        int i;
        !          7432:        Pname arg = new name(make_name('A'));
        !          7433:        arg->tp = find_arg_type(this);
        !          7434: 
        !          7435: //     c_xref = 2;  // now it has X(X&)
        !          7436:        c_xref |= C_XREF;  // now it has X(X&)
        !          7437: 
        !          7438:     if (def) {
        !          7439:        // define itor
        !          7440:        int slow = 0;   // slow==0 => copy using vector copy
        !          7441:        int first = 1;
        !          7442:        Pexpr es = 0;
        !          7443:        s = new estmt(SM,no_where,0,0);
        !          7444:        e = 0;
        !          7445: 
        !          7446: 
        !          7447:        if (warning_opt && 128<obj_size)
        !          7448:                error('w',"copying a %d byte object (ofC %s)",obj_size,string);
        !          7449: 
        !          7450:        if (baselist) slow = 1;
        !          7451:                
        !          7452:        //for (Pbcl v = baselist; v; v = v->next)
        !          7453:        //      if (v->base == VIRTUAL) {
        !          7454:        //              slow = 1;
        !          7455:        //              break;
        !          7456:        //      }
        !          7457: 
        !          7458:        // initialize bases:
        !          7459:     if (slow) {
        !          7460:        for (Pbcl b = baselist; b; b = b->next) {
        !          7461:                Pclass bcl = b->bclass;
        !          7462:                Ptype pt = bcl->this_type;
        !          7463: //error('d',"base %t %k offset %d ptroffset %d",bcl,b->base,b->obj_offset,b->ptr_offset);
        !          7464:                switch (b->base) {
        !          7465:                case VIRTUAL:
        !          7466:                case NAME:      //      generate :b(*(b*)&arg)
        !          7467:                {
        !          7468:                        Pexpr b2 = new name(arg->string);
        !          7469:                        b2 = b2->address();
        !          7470:                        b2 = new texpr(CAST,pt,b2);//new cast(pt,b2);
        !          7471:                        b2->i2 = 1;
        !          7472:                        b2 = b2->contents();
        !          7473: 
        !          7474:                        Pname ee = new name(bcl->string);
        !          7475:                        ee->base = TNAME;
        !          7476:                        ee->n_initializer = b2;
        !          7477:                        if (e) ee->n_list = e;
        !          7478:                        e = ee;
        !          7479:                        break;
        !          7480:                }
        !          7481:                }
        !          7482:        }
        !          7483:     }
        !          7484: 
        !          7485:        // initialize members
        !          7486:        for (Pname m=memtbl->get_mem(i=1); m; m=memtbl->get_mem(++i) ) {
        !          7487:                // ignore static members
        !          7488:                if (m->n_evaluated || m->n_stclass==STATIC) continue;
        !          7489: 
        !          7490:                if (strcmp(m->string,"__vptr")==0) {
        !          7491: // error('d',"%t vptr: %d",this,first);
        !          7492:                        if (first==0 && m->n_offset) {
        !          7493:                                Pexpr th = new expr(THIS,0,0);
        !          7494:                                Pexpr a = new name(arg->string);
        !          7495:                                a = a->address();
        !          7496:                                Pexpr ee = copy_obj(th,a,m->n_offset);
        !          7497:                                es = es ? new expr(CM,es,ee) : ee;
        !          7498:                        }
        !          7499:                        slow = 1;
        !          7500:                        first = 0;
        !          7501:                        continue;
        !          7502:                }
        !          7503:                Ptype mt = m->tp;
        !          7504:        tx:
        !          7505:                switch (mt->base) {
        !          7506:                case TYPE:
        !          7507:                        mt = Pbase(mt)->b_name->tp;
        !          7508:                        goto tx;
        !          7509:                case VEC:
        !          7510:                {       Pname cn = Pvec(mt)->typ->is_cl_obj();
        !          7511: //error('d',"vec %n %t xref %d",m,mt,cn?Pclass(cn->tp)->c_xref:0);
        !          7512:                        if (cn && Pclass(cn->tp)->c_xref&(C_XREF|C_VBASE)) {
        !          7513:                                error('s',"copy of %n[], no memberwise copy for%n",cn,cn);
        !          7514:                                slow = 1;       // make sure an assignment operator
        !          7515:                                                // is generated so that there will
        !          7516:                                                // be no more error messages
        !          7517:                        }
        !          7518: 
        !          7519:                        if (slow && mt->tsizeof()) {
        !          7520:                        /*
        !          7521:                                generate:
        !          7522:                                struct _s { char[sizeof(m)]; };
        !          7523:                                *(struct _s*)this->m = *(struct _s*)arg.mem;
        !          7524:                        */
        !          7525:                                Pexpr l = new name(m->string);
        !          7526:                                Pexpr r = new name(m->string);
        !          7527:                                r = new ref(DOT,new name(arg->string),r);
        !          7528:                                Pexpr ee = copy_obj(l,r,mt->tsizeof());
        !          7529:                                es = es ? new expr(CM,es,ee) : ee;
        !          7530:                                break;
        !          7531:                        }
        !          7532:                }
        !          7533:                case FCT:
        !          7534:                case OVERLOAD:
        !          7535:                case CLASS:
        !          7536:                case ENUM:
        !          7537:                        break;
        !          7538:                case COBJ:
        !          7539:                {       Pclass mcl = Pclass(Pbase(mt)->b_name->tp);
        !          7540:                        if (slow==0     // if slow, previous members have
        !          7541:                                        // already been copied
        !          7542:                        && mcl->c_xref&(C_VBASE|C_XREF)) {
        !          7543:                                slow = 1;
        !          7544:                                if (first==0 && m->n_offset) {
        !          7545:                                                //AAA copy up to here
        !          7546:                                        Pexpr th = new expr(THIS,0,0);
        !          7547:                                        Pexpr a = new name(arg->string);
        !          7548:                                        a = a->address();
        !          7549:                                        Pexpr ee = copy_obj(th,a,m->n_offset);
        !          7550:                                        es = es ? new expr(CM,es,ee) : ee;
        !          7551:                                }
        !          7552:                        }
        !          7553:                        // no break
        !          7554:                }
        !          7555: 
        !          7556:                default:
        !          7557:                        if (slow) {
        !          7558: //error('d',"slow %s %s",m->string,arg->string);
        !          7559:                                Pname ee = new name(m->string);
        !          7560:                                ee->n_initializer = new ref(DOT,new name(arg->string),new name(m->string));
        !          7561:                                if (e) ee->n_list = e;
        !          7562:                                e = ee;
        !          7563:                        }
        !          7564:                }
        !          7565:                first = 0;
        !          7566:        }
        !          7567:        
        !          7568:        if (slow == 0) {
        !          7569:        /*      really simple just copy:
        !          7570:                the only problem was a vptr which can be
        !          7571:                ignored since X(X&) is going to reset it anyway
        !          7572:                don't use assignment of this struct to avoid operator=
        !          7573:        */
        !          7574:                Pexpr th = new expr(THIS,0,0);
        !          7575:                Pexpr a = new name(arg->string);
        !          7576:                a = a->address();
        !          7577:                Pexpr ee = copy_obj(th,a,obj_size);
        !          7578:                es = es ? new expr(CM,es,ee) : ee;
        !          7579:        }
        !          7580: 
        !          7581:        s->e = es;
        !          7582:        Pname cn = ktbl->look(string,0);
        !          7583:        if (cn) cn = Pbase(cn->tp)->b_name;
        !          7584:        cc->stack();
        !          7585:        cc->not = cn;
        !          7586:        cc->cot = this;
        !          7587: }
        !          7588:        Pname fn = new name(string);
        !          7589:        Pfct f = new fct(defa_type,arg,1);
        !          7590:        fn->tp = f;
        !          7591:        fn->n_oper = TNAME;
        !          7592: //     fn->n_sto = STATIC;
        !          7593: 
        !          7594:        Pfct(f)->f_inline = def?1:ITOR; // ITOR means ``define itor() if used''
        !          7595:        if (def) {
        !          7596:                f->body = new block(curloc,0,s);
        !          7597:                f->f_init = e;
        !          7598:        }
        !          7599: 
        !          7600:        Pname nn = fn->dcl(memtbl,PUBLIC);
        !          7601:        delete fn;
        !          7602: 
        !          7603:        if (def) {
        !          7604:                cc->unstack();
        !          7605:                nn->simpl();
        !          7606:                if (debug_opt) nn->dcl_print(0);
        !          7607:        }
        !          7608: //error('d',"make_itor->");
        !          7609:        return nn;
        !          7610: }
        !          7611: 
        !          7612: int make_assignment(Pname cn)
        !          7613: /*
        !          7614:        write the function:
        !          7615: 
        !          7616:        X& X::operator=(const X&) { assign all bases and members }
        !          7617: 
        !          7618:        return 1 is a function is really synthesized
        !          7619: */
        !          7620: {
        !          7621:        Pclass cl = Pclass(cn->tp);
        !          7622:        Pstmt s = new estmt(SM,no_where,0,0);
        !          7623:        Pexpr e = 0;
        !          7624:        Pname arg = new name(make_name('A'));
        !          7625:        basetype* bp = new basetype(INT,0);
        !          7626:        *bp = *Pbase(Pptr(cl->this_type)->typ);
        !          7627:        bp->b_const = 1;
        !          7628: //     arg->tp = new ptr(RPTR,bp);
        !          7629:        arg->tp = find_arg_type(cl);
        !          7630: //error('d',"make_assignment %t %d",cl,cl->obj_size);
        !          7631: //     cl->c_xref |= 4;  // now it has X::operator=(const X&)
        !          7632: 
        !          7633:        if (warning_opt && 128<cl->obj_size)
        !          7634:                error('w',"copying a %d byte object (ofC %s)",
        !          7635:                        cl->obj_size,cl->string);
        !          7636: {
        !          7637:        int slow = 0;   // slow==0 => copy using vector copy
        !          7638:        int first = 1;  // first==1 => first member of (derived) class
        !          7639: 
        !          7640:        if (cl->baselist) slow = 1;     // be dumb and safe
        !          7641: //     for (Pbcl v = cl->baselist; v; v = v->next)
        !          7642: //             if (v->base==VIRTUAL || v->c_xref&(C_VBASE|C_ASS)) {
        !          7643: //                     slow = 1;
        !          7644: //                     break;
        !          7645: //             }
        !          7646: 
        !          7647:     if (slow) {
        !          7648:        for (Pbcl b = cl->baselist; b; b = b->next) {
        !          7649:                Pclass bcl = b->bclass;
        !          7650:                Ptype pt = bcl->this_type;
        !          7651:                switch (b->base) {
        !          7652:                case NAME:
        !          7653:                {       // generate: *(bcl*)this = *(bcl*)&arg;
        !          7654: //error('d',"base %t",bcl);
        !          7655:                        Pexpr b1 = new expr(THIS,0,0);
        !          7656:                        b1 = new texpr(CAST,pt,b1);
        !          7657:                        b1 = b1->contents();
        !          7658: 
        !          7659:                        Pexpr b2 = new name(arg->string);
        !          7660:                        b2 = b2->address();
        !          7661:                        b2 = new texpr(CAST,pt,b2);
        !          7662:                        b2->i2 = 1;
        !          7663:                        b2 = b2->contents();
        !          7664: 
        !          7665:                        Pexpr ee = new expr(ASSIGN,b1,b2);
        !          7666:                        e = e ? new expr(CM,e,ee) : ee;
        !          7667:                        break;
        !          7668:                }
        !          7669:                case VIRTUAL:
        !          7670:                        if (warning_opt)
        !          7671:                                error('w',"copying an object ofC%n with a virtualBC",cn);
        !          7672:                        if (b->ptr_offset) {
        !          7673:                                // copy object, but not pointer
        !          7674:                                // generate: *(bcl*)this->Pw = *(bcl*)arg->Pw;
        !          7675: 
        !          7676:                                // I don't know how to avoid copying the object
        !          7677:                                // once for each pointer
        !          7678: 
        !          7679:                                Pexpr b1 = new expr(THIS,0,0);
        !          7680:                                b1 = new mdot(bcl->string,b1);
        !          7681:                                b1->i1 = 3;
        !          7682:                                b1->tp = pt;
        !          7683:                                b1 = new expr(DEREF,b1,0);//b1->contents();
        !          7684: 
        !          7685:                                Pexpr b2 = new name(arg->string);
        !          7686:                                b2 = b2->address();
        !          7687:                                b2 = new mdot(bcl->string,b2);
        !          7688:                                b2->i1 = 3;
        !          7689:                                b2->tp = pt;
        !          7690:                                b2 = new expr(DEREF,b2,0);//b2->contents();
        !          7691: 
        !          7692:                                Pexpr ee = new expr(ASSIGN,b1,b2);
        !          7693:                                e = e ? new expr(CM,e,ee) : ee;
        !          7694:                        }
        !          7695:                        break;
        !          7696:                }
        !          7697:        }
        !          7698:     }
        !          7699: 
        !          7700:        int i;
        !          7701:        for (Pname m=cl->memtbl->get_mem(i=1); m; m=cl->memtbl->get_mem(++i) ) {
        !          7702:                // ignore static members
        !          7703:                if (m->n_evaluated || m->n_stclass==STATIC) continue;
        !          7704: 
        !          7705:                if (strcmp(m->string,"__vptr")==0) {    // don't copy vptrs
        !          7706:                                                        // we may be copying
        !          7707:                                                        // into a base class object
        !          7708:                if (first==0 && m->n_offset) {
        !          7709:                                        // copy up to (but not including) vptr
        !          7710:                                        // don't copy if first member
        !          7711:                                Pexpr th = new expr(THIS,0,0);
        !          7712:                                Pexpr a = new name(arg->string);
        !          7713:                                a = a->address();
        !          7714:                                Pexpr ee = copy_obj(th,a,m->n_offset);
        !          7715:                                e = e ? new expr(CM,e,ee) : ee;
        !          7716:                        }
        !          7717:                        slow = 1;
        !          7718:                        first = 0;
        !          7719:                        continue;
        !          7720:                }
        !          7721:                Ptype mt = m->tp;
        !          7722:        tx:
        !          7723:                switch (mt->base) {
        !          7724:                case TYPE:
        !          7725:                        mt = Pbase(mt)->b_name->tp;
        !          7726:                        goto tx;
        !          7727:                case VEC:
        !          7728:                {       Pname cn = Pvec(mt)->typ->is_cl_obj();
        !          7729:                        if (cn && Pclass(cn->tp)->c_xref&(C_ASS|C_VBASE)) {
        !          7730:                                error('s',"copy of %n[], no memberwise copy for%n",cn,cn);
        !          7731:                                slow = 1;       // make sure an assignment operator
        !          7732:                                                // is generated so that there will
        !          7733:                                                // be no more error messages
        !          7734:                        }
        !          7735: 
        !          7736:                        if (slow && mt->tsizeof()) {
        !          7737:                                // protect against sizeof(mt)==0: char[]
        !          7738:                        /*
        !          7739:                                generate:
        !          7740:                                        struct _s { char[sizeof(m)]; };
        !          7741:                                        *(struct _s*)this->m = *(struct _s*)arg.mem;
        !          7742:                        */      
        !          7743:                                Pexpr l = new name(m->string);
        !          7744:                                Pexpr r = new name(m->string);
        !          7745:                                r = new ref(DOT,new name(arg->string),r);
        !          7746:                                Pexpr ee = copy_obj(l,r,mt->tsizeof());
        !          7747:                                e = e ? new expr(CM,e,ee) : ee;
        !          7748:                                break;
        !          7749:                        }
        !          7750:                }
        !          7751:                case FCT:
        !          7752:                case OVERLOAD:
        !          7753:                case CLASS:
        !          7754:                case ENUM:
        !          7755:                        break;
        !          7756:                case RPTR:
        !          7757:                        error("cannot assignC%t:RM%n",cl,m);
        !          7758:                        break;
        !          7759:                case COBJ:
        !          7760: //error('d',"cobj %n %d %d",m,slow,Pclass(Pbase(mt)->b_name->tp)->c_xref);
        !          7761:                        if (slow==0
        !          7762:                        && Pclass(Pbase(mt)->b_name->tp)->c_xref&(C_VBASE|C_ASS)) {
        !          7763:                                // must use its assignment operation
        !          7764:                                if (first==0 && m->n_offset) {
        !          7765:                                                // copy up to this member 
        !          7766:                                        Pexpr th = new expr(THIS,0,0);
        !          7767:                                        Pexpr a = new name(arg->string);
        !          7768:                                        a = a->address();
        !          7769:                                        e = copy_obj(th,a,m->n_offset);
        !          7770:                                }
        !          7771:                                slow = 1;
        !          7772:                        }
        !          7773:                        // no break: copy cobj itself
        !          7774:                default:
        !          7775:  //error('d',"defa %n %d",m,slow);
        !          7776:                        if (slow) {
        !          7777:                                if (m->tp->tconst()) error("cannot assignC%t: const M%n",cl,m);
        !          7778:                                Pname ms = new name(m->string);
        !          7779:                                Pname as = new name(arg->string);
        !          7780:                                Pexpr ee = new ref(DOT,as,new name(m->string));
        !          7781:                                ee = new expr(ASSIGN,ms,ee);
        !          7782:                                e = e ? new expr(CM,e,ee) : ee;
        !          7783:                        }
        !          7784:                }
        !          7785:                first = 0;
        !          7786:        }
        !          7787: 
        !          7788:         if (slow == 0) {
        !          7789:         /*      really simple just copy:
        !          7790:         */
        !          7791: //error('d',"slow");
        !          7792: /*
        !          7793:                 Pexpr th = new expr(THIS,0,0);
        !          7794:                 Pexpr a = new name(arg->string);
        !          7795:                 a = a->address();
        !          7796:                 Pexpr ee = copy_obj(th,a,cl->tsize());
        !          7797:                 e = e ? new expr(CM,e,ee) : e;
        !          7798: */
        !          7799: //error('d',"%n simple assignment",cn);
        !          7800:        //      cl->c_xref ^= C_ASS; // Didn't mean it: No X::operator=(X&)
        !          7801:                return 0;
        !          7802:         }
        !          7803: 
        !          7804: }
        !          7805: 
        !          7806:        Pexpr rv = new expr(THIS,0,0);
        !          7807:        rv = new expr(DEREF,rv,0);//b1->contents();
        !          7808:        
        !          7809:        s->e = e ? new expr(CM,e,rv) : e;
        !          7810:        s->s_list = new estmt(RETURN,no_where,rv,0);
        !          7811: 
        !          7812:        cc->stack();
        !          7813:        cc->not = cn;
        !          7814:        cc->cot = cl;
        !          7815: 
        !          7816:        cl->c_xref |= C_ASS;  // now it has X::operator=(const X&)
        !          7817: 
        !          7818:        Pname fn = new name(oper_name(ASSIGN));
        !          7819:        Pfct f = new fct(new ptr(RPTR,Pptr(cl->this_type)->typ),arg,1);
        !          7820:        f->f_inline = 1;
        !          7821:        fn->tp = f;
        !          7822:        fn->n_oper = ASSIGN;
        !          7823:        fn->n_sto = STATIC;
        !          7824:        Pname nn = fn->dcl(cl->memtbl,PUBLIC);
        !          7825:        delete fn;
        !          7826:        Pfct(nn->tp)->body = new block(curloc,0,s);
        !          7827:        Pfct(nn->tp)->dcl(nn);
        !          7828: 
        !          7829:        cc->unstack();
        !          7830:        nn->simpl();
        !          7831: //error('d',"make_assign->");
        !          7832:        return 1;
        !          7833: }
        !          7834: 
        !          7835: void classdef::dcl(Pname cname, Ptable tbl)
        !          7836: {
        !          7837:        int bvirt = 0;
        !          7838:        int dvirt = 0;
        !          7839:        int scope = PUBLIC;
        !          7840:        int protect = 0;
        !          7841:        int st = 1;             // nothing private or protected seen: a struct
        !          7842:        // int nstd = (in_class && nested_sig)?2:(in_class?1:0); // nested class
        !          7843: 
        !          7844:        int byte_old = byte_offset;
        !          7845:        int bit_old = bit_offset;
        !          7846:        int max_old = max_align;
        !          7847:        int boff = 0;
        !          7848: 
        !          7849:        int in_union = 0;
        !          7850:        int usz;
        !          7851:        int make_ctor = 0;
        !          7852:        int make_dtor = 0;
        !          7853: 
        !          7854:        /* this is the place for paranoia */
        !          7855:        if (this == 0) error('i',"0->Cdef::dcl(%p)",tbl);
        !          7856:        if (base != CLASS) error('i',"Cdef::dcl(%d)",base);
        !          7857:        if (cname == 0) error('i',"unNdC");
        !          7858:        if (cname->tp != this) error('i',"badCdef");
        !          7859:        if (tbl == 0) error('i',"Cdef::dcl(%n,0)",cname);
        !          7860:        if (tbl->base != TABLE) error('i',"Cdef::dcl(%n,tbl=%d)",cname,tbl->base);
        !          7861:        DB( if(Ddebug>=1) error('d',&cname->where,"classdef::dcl %s tbl %d gtbl %d",string,tbl,gtbl); );
        !          7862: // error('d',&cname->where,"classdef::dcl %s tbl %d gtbl %d",string,tbl,gtbl); 
        !          7863: 
        !          7864:        switch (csu) {
        !          7865:        case UNION:
        !          7866:                in_union = UNION;
        !          7867:                break;
        !          7868:        case ANON:
        !          7869:                in_union = ANON;
        !          7870:                break;
        !          7871:        case CLASS:
        !          7872:                scope = 0;
        !          7873:        }
        !          7874: 
        !          7875:        max_align = AL_STRUCT;
        !          7876: 
        !          7877:        if (lex_level) {
        !          7878: // error('d',&cname->where,"%t::dcl in_class: %t lex_level %d ",this,in_class, lex_level); 
        !          7879:                if ( in_class )
        !          7880:                        lex_level = 0;
        !          7881:                else {
        !          7882:                        in_fct = cc->nof;
        !          7883:                        if ( lcl == 0 ) lcl = make_name( 'L' );
        !          7884:                }
        !          7885:        }
        !          7886: 
        !          7887:        if (strlen == 0) strlen = ::strlen(string);
        !          7888:        if (baselist) {
        !          7889:                /*
        !          7890:                        check base classes.
        !          7891:                        duplicates were removed in start_cl() in norm.c.
        !          7892:                        remove bad classes.
        !          7893:                        add virtual bases from bases to the list.
        !          7894: 
        !          7895:                        check against
        !          7896:                                class b : a {}
        !          7897:                                class c : a, b {}       // first a inaccessible
        !          7898:                */
        !          7899:                
        !          7900:                Pbcl ll = 0;
        !          7901:                Pbcl lll = 0;
        !          7902:                Pbcl vlist = 0;
        !          7903:                for (Pbcl lx, l=baselist; l; l=lx) {    // remove bad bases
        !          7904:                        Pclass cl = l->bclass;
        !          7905:                        /* restriction lifted: nested and local classes
        !          7906:                        int b_nstd = (cl->in_class && cl->nested_sig) 
        !          7907:                                        ?2:(cl->in_class?1:0); 
        !          7908: 
        !          7909:                        if (b_nstd) 
        !          7910:                                error((b_nstd==2)?0:'w',"%s derived from nestedC %s", string, cl->string);
        !          7911:                        if (cl->lex_level) 
        !          7912:                                error('w',"%s derived from localC  %s", string, cl->string);
        !          7913:                        */
        !          7914: 
        !          7915:                        lx = l->next;
        !          7916: 
        !          7917: //error('d',"base1 %t %k init %d",cl,l->ppp,l->init);
        !          7918:                        // ``class'' => private base ``struct'' => public base
        !          7919:                        if (l->ppp == 0) {
        !          7920:                                l->ppp = csu==CLASS ? PRIVATE : PUBLIC;
        !          7921: #ifndef OLD
        !          7922:                                if (l->ppp == PRIVATE) error('w',"B%t private by default: please be explicit ``: private%t",cl,cl);
        !          7923: #endif
        !          7924:                        }
        !          7925:                        // if you have a ``class'' as base you cannot remain a
        !          7926:                        // ``mere struct''
        !          7927:                        if (cl && cl->csu == CLASS) st = 0;
        !          7928: 
        !          7929:                        if ((cl->defined&(DEFINED|SIMPLIFIED)) == 0) {
        !          7930:                                error("BC %sU",cl->string);
        !          7931:                                continue;
        !          7932:                        }
        !          7933:                        else
        !          7934:                                (void)cl->tsizeof();    // ensure printout
        !          7935: 
        !          7936:                        if (cl->csu==UNION || cl->csu==ANON) {
        !          7937:                                error("C derived from union");
        !          7938:                                continue;
        !          7939:                        }
        !          7940: 
        !          7941:                        if (in_union) {
        !          7942:                                error("derived union");
        !          7943:                                continue;
        !          7944:                        }
        !          7945: 
        !          7946:                        if (l->base==VIRTUAL) {
        !          7947:                        // constraint removed ...
        !          7948:                        //      if (cl->has_ictor()==0 && cl->has_ctor()) {
        !          7949:                        //              error("virtualB%t has no defaultIr",cl);
        !          7950:                        //              continue;
        !          7951:                        //      }
        !          7952:                                // order of virtual classes doesn't matter
        !          7953:                                l->next = vlist;
        !          7954:                                vlist = l;
        !          7955:                        }
        !          7956:                        else {  // keep ordinary base classes in order
        !          7957:                                if (ll == 0) {
        !          7958:                                        lll = l;
        !          7959:                                        l->next = 0;
        !          7960:                                }
        !          7961:                                else
        !          7962:                                        ll->next = l;
        !          7963:                                ll = l;
        !          7964:                        }
        !          7965:                }
        !          7966:                if (ll) {
        !          7967:                        ll->next = vlist;       // put virtual bases at end
        !          7968:                        baselist = lll;
        !          7969:                }
        !          7970:                else
        !          7971:                        baselist = vlist;
        !          7972: 
        !          7973:                lll = 0;
        !          7974:                for (l=baselist; l; l=l->next) {        // detect unmanageable duplicates
        !          7975:                        Pclass b = l->bclass;
        !          7976:                        for (ll=baselist; ll; ll=ll->next)
        !          7977:                                if (b!=ll->bclass && ll->bclass->check_dup(b,l->base)) {
        !          7978:                                        if (lll)
        !          7979:                                                lll->next = l->next;
        !          7980:                                        else
        !          7981:                                                baselist = l->next;
        !          7982:                                        goto mmm;
        !          7983:                                }
        !          7984:                                                
        !          7985:                        lll = l;
        !          7986:                        mmm:;
        !          7987:                }
        !          7988: 
        !          7989:                for (l=baselist; l; l=l->next) {        // promote virtual bases
        !          7990:                        Pclass b = l->bclass;
        !          7991:                        for (ll=b->baselist; ll; ll=ll->next) {
        !          7992:                                if (ll->base == VIRTUAL) {
        !          7993:                                        Pclass v = ll->bclass;
        !          7994:                                        for (Pbcl lll=baselist; lll; lll=lll->next)
        !          7995:                                                if (lll->bclass == v) goto nnn;
        !          7996:                //                      error('w',"%t is virtualB of%t",v,this);
        !          7997:                                        baselist = new basecl(v,baselist);
        !          7998:                                        baselist->base = VIRTUAL;
        !          7999:                                        baselist->promoted = 1;
        !          8000: // needs a more complete check of visibility rules
        !          8001: //error('d',"promote %t %k",v,ll->ppp);
        !          8002:                                        baselist->ppp = ll->ppp;
        !          8003:                                }
        !          8004:                                nnn:;
        !          8005:                        }
        !          8006:                }
        !          8007: 
        !          8008:                ll = 0;
        !          8009:                lll = 0;
        !          8010:                l=baselist;
        !          8011:                baselist = 0;
        !          8012:                vlist = 0;
        !          8013:                for (; l; l=lx) {
        !          8014:                        // sort virtual bases so that no virtual base
        !          8015:                        // is ahead of its own virtual base
        !          8016:                        lx = l->next;
        !          8017:                        if (l->base == VIRTUAL) { // add to sorted vlist
        !          8018:                                                  // each class before its bases
        !          8019:                                if (vlist == 0) {
        !          8020:                                        vlist = l;
        !          8021:                                        l->next = 0;
        !          8022:                                }
        !          8023:                                else {
        !          8024:                                        Pclass lb = l->bclass;
        !          8025:                                        Pbcl v_prev = 0;
        !          8026:                                        for (Pbcl vx, v = vlist; v; v=vx) {
        !          8027:                                                Pclass vb = v->bclass;
        !          8028:                                                vx = v->next;
        !          8029: 
        !          8030:                                                if (lb->has_base(vb)) {
        !          8031:                                                        // put l ahead of v
        !          8032:                                                        l->next = v;
        !          8033:                                                        if (v_prev)
        !          8034:                                                                v_prev->next = l;
        !          8035:                                                        else
        !          8036:                                                                vlist = l;
        !          8037:                                                        break;
        !          8038:                                                }
        !          8039:                                                if (vx == 0) {
        !          8040:                                                        // stick l at end
        !          8041:                                                        v->next = l;
        !          8042:                                                        l->next = 0;
        !          8043:                                                        break;
        !          8044:                                                }       
        !          8045:                                                v_prev = v;
        !          8046:                                        }
        !          8047:                                }
        !          8048:                        }
        !          8049:                        else {  // keep in order
        !          8050:                                if (ll == 0) {
        !          8051:                                        lll = l;
        !          8052:                                        l->next = 0;
        !          8053:                                }
        !          8054:                                else
        !          8055:                                        ll->next = l;
        !          8056:                                ll = l;
        !          8057:                        }
        !          8058:                }
        !          8059: 
        !          8060:                if (ll) {
        !          8061:                        ll->next = vlist;       // put virtual bases at end
        !          8062:                        baselist = lll;
        !          8063:                }
        !          8064:                else
        !          8065:                        baselist = vlist;
        !          8066: 
        !          8067:                for (l=baselist; l; l=l->next) { // allocate base class objects
        !          8068:                        Pclass cl = l->bclass;
        !          8069: //error('d',"base %t %k init %d",cl,l->ppp,l->init);
        !          8070:                        if (l->base == VIRTUAL) {       // : virtual bclass
        !          8071:                                // pointer and object for virtual base MAY
        !          8072:                                // be allocated at the end - but not here
        !          8073:                                c_xref |= C_VBASE;
        !          8074:                                dvirt += cl->virt_count;
        !          8075:                        }
        !          8076:                        else {                          // : bclass =>allocate
        !          8077:                                int ba = cl->align();
        !          8078:                                if (max_align<ba) max_align = ba;
        !          8079: 
        !          8080:                                if (cl == baselist->bclass) {
        !          8081:                                        // pad to ensure alignment:
        !          8082:                                        boff = cl->real_size;
        !          8083:                                        // not obj_size-real_size, we can
        !          8084:                                        // optimize vbase object away
        !          8085:                                        int xtra = boff%ba;
        !          8086:                                        // align
        !          8087:                                        if (xtra) boff += ba-xtra;
        !          8088:                                }
        !          8089:                                else {  // let C handle the padding:
        !          8090:                                        int xtra = boff%ba;
        !          8091:                                        if (xtra) boff += ba-xtra;      // align
        !          8092:                                        l->obj_offset = boff;
        !          8093:                                        // don't use waste
        !          8094:                                        boff += cl->obj_size;
        !          8095:                                }
        !          8096:                                bvirt += cl->virt_count;
        !          8097:                        }
        !          8098: 
        !          8099:                         if (cl->has_vvtab) has_vvtab = 1;
        !          8100:                        c_xref |= cl->c_xref;
        !          8101: 
        !          8102: //error('d',"%t: base %t conv %d base conv %d",this,cl,conv,cl->conv);
        !          8103:                        conv = merge_conv(conv,cl->conv);
        !          8104:                }
        !          8105:        }
        !          8106: 
        !          8107:        memtbl->set_name(cname);
        !          8108: 
        !          8109: //     int nmem = mem_list->no_of_names();
        !          8110:        int nmem = 0;
        !          8111:        int fct_mem = 0;
        !          8112:        {       for (Pname m = mem_list; m; m=m->n_list) {
        !          8113:                        nmem++;
        !          8114:                        if (m->tp && m->tp->base==FCT) fct_mem++;
        !          8115:                }
        !          8116:        }
        !          8117:        if (nmem) memtbl->grow((nmem<=2)?3:nmem);
        !          8118: 
        !          8119:        cc->stack();
        !          8120:        cc->not = cname;
        !          8121:        cc->cot = this;
        !          8122: 
        !          8123:        byte_offset = usz = boff;
        !          8124:        bit_offset = 0;
        !          8125:        
        !          8126:        int real_virts = 0;
        !          8127:        Pbase bt = new basetype(COBJ,cname);
        !          8128:        bt->b_table = memtbl;
        !          8129:        Ptype cct = bt->addrof();
        !          8130:        // for strict opt type of `this': X *const
        !          8131:        // '2' distinguishes this case from a real constant object
        !          8132:        if (strict_opt) Pptr(cct)->rdo = 2;
        !          8133:        this_type = cc->tot = cct;
        !          8134:        PERM(cct);
        !          8135:        PERM(bt);
        !          8136: 
        !          8137:        for (Pname px, p=mem_list; p; p=px) {
        !          8138:        /*
        !          8139:                look at each member;
        !          8140:                declare it and determine its visibility
        !          8141:                calculate offsets and sizes
        !          8142:        */
        !          8143:                px = p->n_list;
        !          8144: // error( 'd', "p: %n %k n_scope: %d", p, p->base, p->n_scope );
        !          8145: 
        !          8146:                switch (p->base) {
        !          8147:                case PUBLIC:
        !          8148:                        scope = PUBLIC;
        !          8149:                        protect = 0;
        !          8150:                        goto prpr;
        !          8151: 
        !          8152:                case PRIVATE:
        !          8153:                        scope = 0;
        !          8154:                        protect = 0;
        !          8155:                        goto prpr;
        !          8156: 
        !          8157:                case PROTECTED:
        !          8158:                        scope = 0;
        !          8159:                        protect = PROTECTED;
        !          8160:                prpr:
        !          8161:                        if (in_union == ANON) error(&p->where,"%k in anonymous unionD",p->base);
        !          8162:                        continue;
        !          8163: 
        !          8164:                case PR:        // visibility control:  C::M
        !          8165:                {
        !          8166:                        char* qs = p->n_qualifier->string;
        !          8167:                        char* ms = p->string;
        !          8168:                        TOK ppp = scope?PUBLIC:(protect?PROTECTED:PRIVATE);
        !          8169: 
        !          8170:                        p->base = NAME;
        !          8171:                        p->n_scope = scope;
        !          8172:                        p->n_protect = protect;
        !          8173: 
        !          8174:                        if (strcmp(ms,qs) == 0) ms = "__ct";
        !          8175: 
        !          8176:                        ppbase = PUBLIC;
        !          8177: 
        !          8178:                        if (is_base(qs) == 0) {
        !          8179:                                error("%kQr %s not aBC of %s",ppp,qs,string);
        !          8180:                                continue;
        !          8181:                        }
        !          8182: 
        !          8183:                        mex = 1;
        !          8184:                        tcl = mec = this;
        !          8185:                        c_body = 0; // this search must not be interpreted as a use
        !          8186:                        Pname os = Cdcl;
        !          8187:                        Cdcl = p;
        !          8188:                        Pexpr ee = find_name(ms,0,1);
        !          8189:                        Cdcl = os;
        !          8190:                        c_body = 1;
        !          8191: 
        !          8192: // error('d', "ee: %k ", ee->base );
        !          8193: 
        !          8194: //                     while (ee->base == MDOT || ee->base == REF) 
        !          8195:                         while (ee && (ee->base == MDOT || ee->base == REF))
        !          8196:                                ee = ee->mem;
        !          8197:                        Pname mx = Pname(ee);
        !          8198: 
        !          8199: // error('d', "ee: %k mx: %n", ee->base, mx );
        !          8200: 
        !          8201:                        if (mx == 0) {
        !          8202:                                error("C %s does not have aM %s",qs,ms);
        !          8203:                                continue;
        !          8204:                        }
        !          8205: 
        !          8206:                        if (mx->tp->base == OVERLOAD) {
        !          8207:                                error('s',"%k specification of overloaded%n",ppp,mx);
        !          8208:                                continue;
        !          8209:                        }
        !          8210: 
        !          8211:                        TOK pp = mx->n_scope?PUBLIC:mx->n_protect?PROTECTED:PRIVATE;
        !          8212:                        
        !          8213: // error('d',"mx %n pp %k ppp %k",mx,pp,ppp);
        !          8214:                        if (ppp != pp) {
        !          8215:                                error(&p->where,"%kM%n specified%k",pp,mx,ppp);
        !          8216:                                continue;
        !          8217:                        }       
        !          8218:                        
        !          8219:                
        !          8220:                        p->n_qualifier = mx;
        !          8221:                        Pname m = memtbl->insert(p,0);
        !          8222:                        m->base = PUBLIC;
        !          8223:                        if (Nold) error("twoDs ofCM%n",p);
        !          8224:                        continue;
        !          8225:                }
        !          8226:                }
        !          8227: 
        !          8228: // error('d',"mem%n tp %d %k scope %d",p,p->tp->base,p->tp->base,scope);
        !          8229: 
        !          8230:                if (scope==0) { 
        !          8231:                        if (p->n_sto != STATIC) st = 0;
        !          8232:                }
        !          8233:                else 
        !          8234:                if ( p->tp->base == TYPE ) {
        !          8235:                        Pname nn = p->tp->is_cl_obj();
        !          8236:                        if (nn) { 
        !          8237: // error( 'd', "nn: %n %k tp %t %k", nn, nn->base, nn->tp, nn->tp->base );
        !          8238:                                 if ((Pclass(nn->tp)->csu == CLASS) && (strcmp(this->string,nn->string))) st = 0;
        !          8239:                        }
        !          8240:                }
        !          8241: 
        !          8242:                if (p->tp->base == FCT) {
        !          8243:                        int ff = 0;
        !          8244:                        Pfct f = Pfct(p->tp);
        !          8245:                        Pblock b = f->body;
        !          8246:                        f->body = 0;
        !          8247:                        if (b) 
        !          8248:                                f->f_inline = 1;
        !          8249:                        /* restriction lifted: nested classes
        !          8250:                        else
        !          8251:                        if (nstd) 
        !          8252:                                error((nstd==2)?0:'w',&p->where,"non-inlineMF%n in nestedC %s",p,string);
        !          8253:                        */
        !          8254:                        else
        !          8255:                        if (lex_level) 
        !          8256:                                error('w',&p->where,"non-inlineMF%n in localC %s",p,string);
        !          8257: 
        !          8258:                        switch (p->n_sto) {
        !          8259:                        case FRIEND:
        !          8260:                                ff = 1;
        !          8261:                                break;
        !          8262:                        case STATIC:    // accept static member functions
        !          8263: //error('d',"inline %d",f->f_inline);
        !          8264:                        //      if (f->f_inline==0)
        !          8265:                                /* restriction lifted: nested classes
        !          8266:                                if (nstd) 
        !          8267:                                        error((nstd==2)?0:'w',"staticMF%n in nestedC %s",p,string);
        !          8268:                                else
        !          8269:                                */
        !          8270:                                if (lex_level) 
        !          8271:                                        error('w',"staticMF%n in localC %s",p,string);
        !          8272:                                f->f_static = 1;
        !          8273:                                p->n_sto = 0;
        !          8274:                                break;
        !          8275:                        case AUTO:
        !          8276:                //      case STATIC:
        !          8277:                        case REGISTER:
        !          8278:                        case EXTERN:
        !          8279:                                error(&p->where,"M%n cannot be%k",p,p->n_sto);
        !          8280:                                p->n_sto = 0;
        !          8281:                        }
        !          8282: 
        !          8283:                        if (f->f_virtual) real_virts++;
        !          8284: 
        !          8285:                        Pname m = p->dcl(memtbl,scope);
        !          8286:                        if (m == 0 || m->tp->base != FCT) continue;
        !          8287:                         if (m->n_initializer) {
        !          8288:                                 c_abstract = 1;
        !          8289:                                 if (m->n_oper == DTOR)
        !          8290:                                        error('w',"please provide an out-of-line definition: %n {}; which is needed by derived classes",m);
        !          8291:                         }
        !          8292:                        if (ff == 0) m->n_protect = protect;
        !          8293:                        if (b) {
        !          8294:                                if (m->tp->defined&DEFINED || Pfct(m->tp)->body )
        !          8295:                                        error(&p->where,"two definitions of%n",m);
        !          8296:                                else
        !          8297:                                        Pfct(m->tp)->body = b;
        !          8298:                        //      Pfct(m->tp)->f_inline = 1;
        !          8299:                        }
        !          8300:                        if (ff==0 && p->where.line!=m->where.line)
        !          8301:                                error(&p->where,"%n cannot be redeclared inCD",p);
        !          8302:                }
        !          8303:                else {
        !          8304:                        Eppp = scope?scope:protect?protect:0;
        !          8305: 
        !          8306:                        if (p->base == TNAME) {
        !          8307:                                // typedef names are exported to
        !          8308:                                // surrounding non-class scope
        !          8309:                                // NOTE: name should actually be declared in
        !          8310:                                //       the innermost block of the current
        !          8311:                                //       function, but this info isn't available
        !          8312:                                if ( cc->nof ) {
        !          8313:                                        if (p->tp && 
        !          8314:                                                Pbase(p->tp)->base != COBJ && 
        !          8315:                                                Pbase(p->tp)->base != EOBJ) {
        !          8316:                                                        Pname n = cc->ftbl->look(p->string,0);
        !          8317:                                                        if (n && n->base != TNAME && 
        !          8318:                                                                  n->lex_level &&
        !          8319:                                                                n->tp != p->tp ) {
        !          8320:                                                                        error('s',"transitional model of nestedTs within%n (%s asTdef and%t)",cc->nof,p->string,n->tp); 
        !          8321:                                                                        error('i', "cannot recover from previous errors" );
        !          8322:                                                        }
        !          8323:                                        }
        !          8324:                                        else p->dcl(cc->ftbl,scope);
        !          8325:                                }
        !          8326:                                else
        !          8327:                                        p->dcl(gtbl,scope);
        !          8328: 
        !          8329:                                // typedefs need to be generated outside class
        !          8330:                                 if ( p->tp && Pbase(p->tp)->base != COBJ ) {
        !          8331:                                         Pname n = gtbl->look(p->string,0);
        !          8332:                                        if ( n && lex_level == 0 && n->base != TNAME )
        !          8333:                                                 error(&p->where,"%nredefined: identifier and typedef",p); 
        !          8334:                                        p->dcl_print(0);
        !          8335:                                 }
        !          8336:                                 continue;
        !          8337:                         };
        !          8338: 
        !          8339:                        if (p->n_initializer) {
        !          8340:                                error(&p->where,"Ir forM%n",p);
        !          8341:                                p->n_initializer = 0;
        !          8342:                        }
        !          8343: 
        !          8344:                        if (p->tp->base==OVERLOAD) {
        !          8345:                                for (Plist gl=Pgen(p->tp)->fct_list; gl; gl=gl->l) { 
        !          8346:                                        Pname nn = gl->f;
        !          8347:                                        Pfct ff = Pfct(nn->tp);
        !          8348:                                        if ( ff->f_virtual ) real_virts++;
        !          8349:                                }
        !          8350:                        }
        !          8351: 
        !          8352: // error('d',"lex_level %d p %n lex %d nested_scope: %k",lex_level,p,p->lex_level, nested_scope);
        !          8353: 
        !          8354:                        TOK is_friend = p->n_sto;
        !          8355:                        if ( lex_level && p->tp->base == VEC ) lcl_tbl = tbl;
        !          8356:                        if ( protect && p->tp->base == COBJ && 
        !          8357:                                Pclass(Pbase(p->tp)->b_name->tp)->csu == ANON ) 
        !          8358:                                        p->n_protect = protect;
        !          8359:                        Pname m = p->dcl(memtbl,scope);
        !          8360:                        lcl_tbl = 0;
        !          8361:                        Eppp = 0;
        !          8362:                        if (m == 0) continue;
        !          8363: 
        !          8364:                        m->n_protect = protect;
        !          8365: 
        !          8366:                        if (m->n_stclass==STATIC) {
        !          8367:                                if (in_union) error("staticM%n in union",m);
        !          8368:                                if ( is_friend != FRIEND ) {
        !          8369:                                        /* restriction lifted: nested classes
        !          8370:                                        if (nstd)
        !          8371:                                                error((nstd==2)?0:'w',"staticM%n in nestedC %s",m,string);
        !          8372:                                        else
        !          8373:                                        */
        !          8374:                                        if (lex_level)
        !          8375:                                                error(strict_opt?0:'w',"staticM%n in localC %s (anachronism)",m,string);
        !          8376:                                }
        !          8377:                        //      Ptype t = m->tp;
        !          8378:                        //      Pname cn = t->is_cl_obj();
        !          8379:                        //      if ((cn && Pclass(cn->tp)->has_ctor())
        !          8380:                        //      || t->is_ref()
        !          8381:                        //      || (t->tconst() && vec_const == 0))
        !          8382:                                m->n_sto = EXTERN;
        !          8383:                                if (tbl == gtbl) stat_mem_list = new name_list(m,stat_mem_list);
        !          8384:                                if (m->n_initializer) error('s',"staticM%nWIr",m);
        !          8385:                        }
        !          8386: 
        !          8387:                        if (in_union) {
        !          8388:                                if (usz < byte_offset) usz = byte_offset;
        !          8389:                                byte_offset = 0;
        !          8390:                                if(in_union==ANON) m->n_offset+=byte_old;
        !          8391:                        }
        !          8392:                }
        !          8393:        }
        !          8394: 
        !          8395:        /* restriction lifted: nested and local classes
        !          8396:        if (real_virts) {
        !          8397:                if (nstd)
        !          8398:                        error((nstd==2)?0:'w',"nestedC%s contains%d virtualF",string,real_virts);
        !          8399:                else
        !          8400:                if (lex_level)
        !          8401:                        error('w',"localC%s contains%d virtualF",string,real_virts);
        !          8402:        }
        !          8403:        */
        !          8404: 
        !          8405:        if (st && csu==CLASS) csu = STRUCT;     // nothing private => STRUCT
        !          8406:        if (st==0 && csu==STRUCT) csu = CLASS;  // all is not public => CLASS
        !          8407: 
        !          8408:        if (in_union) byte_offset = usz;
        !          8409: 
        !          8410:        // now look look at the members
        !          8411: 
        !          8412:        Pname ct = has_ctor();
        !          8413:        Pname dt = has_dtor();
        !          8414: 
        !          8415:        int i;
        !          8416: 
        !          8417:        int omex = mex; mex = 0;
        !          8418:        Pname on = has_oper(NEW);
        !          8419:        Pname od = has_oper(DELETE);
        !          8420:        mex = omex;
        !          8421: 
        !          8422:        if (dt && ct==0 && Pfct(dt->tp)->f_virtual == 0 ) error('w',"%s has%n but noK",string,dt);
        !          8423:        if (on && od==0) error('w',"%s has%n but no operator delete()",string,on);
        !          8424:        if (od && on==0) error('w',"%s has%n but no operator new()",string,od);
        !          8425: 
        !          8426:        if (dt==0 && od && od && od->n_table==memtbl) make_dtor = 1;
        !          8427: 
        !          8428:        for (Pname m=memtbl->get_mem(i=1); m; m=memtbl->get_mem(++i) ) {
        !          8429:        /*
        !          8430:                The members have been declared.
        !          8431:                now look at each to see if it needs defining
        !          8432:        */
        !          8433:                Ptype t = m->tp;
        !          8434: 
        !          8435:                if (t == 0) continue;   // public declarations
        !          8436: // error('d', "m %n %d", m, m->n_scope );
        !          8437: 
        !          8438:                switch (t->base) {
        !          8439:                default:
        !          8440:                        if (ct==0
        !          8441:                        && m->n_stclass!=ENUM
        !          8442:                        && m->n_stclass!=STATIC) {
        !          8443:                                if (t->is_ref()) error("R%n inC %sWoutK",m,string);
        !          8444:                                if (t->tconst()
        !          8445:                                && vec_const==0
        !          8446:                                && m->n_evaluated==0)
        !          8447:                                        error("const%n inC %sWoutK",m,string);
        !          8448:                        }
        !          8449:                case VEC:
        !          8450:                        break;
        !          8451:                case FCT:
        !          8452:                case OVERLOAD:
        !          8453:                case CLASS:
        !          8454:                case ENUM:
        !          8455:                        continue;
        !          8456:                }
        !          8457: 
        !          8458:                Pname cn = t->is_cl_obj();
        !          8459:                if (cn == 0) cn = cl_obj_vec;
        !          8460:                if (cn == 0) continue;
        !          8461: 
        !          8462:                Pclass cl = Pclass(cn->tp);
        !          8463:                 c_xref |= cl->c_xref;
        !          8464: //error('d',"m %n %t %d",m,cl,cl->c_xref);
        !          8465:                if (cl->has_ctor()) {
        !          8466:                        if (m->n_stclass == STATIC)
        !          8467:                                ; // error('s',"staticM%n ofC%nWK",m,cn);
        !          8468:                        else if (in_union) {
        !          8469:                                if (strncmp("__C",string,3) == 0)
        !          8470:                                    error("M %s ofC%nWK in union",m->string,cn); // tagless union
        !          8471:                                else error("M%n ofC%nWK in union",m,cn);
        !          8472:                        }
        !          8473:                        else if (ct == 0) {
        !          8474:                                // does mctor have a default constructor?
        !          8475:                                if (make_ctor==0 && cl->has_ictor()==0)
        !          8476:                                        error("%t needs aK; it has aMWK requiringAs",this);
        !          8477:                                make_ctor = 1;
        !          8478:                        }
        !          8479:                }
        !          8480: 
        !          8481:                if (cl->has_dtor()) {
        !          8482:                        if (m->n_stclass==STATIC)
        !          8483:                                ; // error('s',"staticM%n ofC%nW destructor",m,cn);
        !          8484:                        else if (in_union) {
        !          8485:                                if (strncmp("__C",string,3) == 0) // tagless union
        !          8486:                                    error("M %s ofC%nW destructor in union",m->string,cn);
        !          8487:                                else error("M%n ofC%nW destructor in union",m,cn);
        !          8488:                        }
        !          8489:                        else if (dt==0)
        !          8490:                                make_dtor = 1;
        !          8491:                }
        !          8492:        }
        !          8493: 
        !          8494:        if (has_dtor()==0 && make_dtor==0) {
        !          8495:                // can dtor be inherited (from single base class)?
        !          8496:                Pclass bcl = 0;
        !          8497:                for (Pbcl b = baselist; b; b = b->next) {
        !          8498:                        switch (b->base) {
        !          8499:                        case NAME:
        !          8500:                                if (bcl == 0) {
        !          8501:                                        Pname d = b->bclass->has_dtor();
        !          8502:                                        if (d==0) break;
        !          8503:                                        if (strict_opt == 0) {
        !          8504:                                                if (d->n_scope==PUBLIC
        !          8505:                                                && Pfct(d->tp)->f_virtual==0) {
        !          8506:                                                        bcl = b->bclass;
        !          8507:                                                        break;
        !          8508:                                                }
        !          8509:                                        }
        !          8510:                                }
        !          8511:                                // two dtors or non-public dtors force creation
        !          8512:                                 make_dtor = 1;
        !          8513:                                 goto zbzb;
        !          8514:                         case VIRTUAL:
        !          8515:                                 if (b->bclass->has_dtor()) make_dtor = 1;
        !          8516:                                 goto zbzb;
        !          8517:                        }
        !          8518:                }
        !          8519:                if (bcl) c_dtor = bcl->has_dtor();
        !          8520:        zbzb:;
        !          8521:        }
        !          8522: 
        !          8523:        if (make_dtor && dt==0) {       // make x::~x() {}
        !          8524: 
        !          8525:                // must be done before vtbls are made in case dtor is virtual
        !          8526: //error('d',"%t: make_dtor",this);
        !          8527:                Pname n = new name(string);
        !          8528:                Pfct f = new fct(defa_type,0,1);
        !          8529:                f->f_inline = /*IDTOR; */ 1;
        !          8530:                n->tp = f;
        !          8531:                n->n_oper = DTOR;
        !          8532:                dt = n->dcl(memtbl,PUBLIC);
        !          8533:                delete n;
        !          8534:                Pfct(dt->tp)->body  = /*0; */ new block(curloc,0,0);
        !          8535:                dt = has_dtor();
        !          8536:        }
        !          8537: 
        !          8538:        if (virt_count && find_vptr(this)==0) {
        !          8539:                // we only need a vptr if this class has virtual
        !          8540:                // functions and none of its first bases have vptrs
        !          8541: //error('d',"%s virt_count %d",string,virt_count);
        !          8542:                Pname vp = new name("__vptr");
        !          8543:                vp->tp = Pvptr_type;
        !          8544:                (void) vp->dcl(memtbl,0);
        !          8545:                delete vp;
        !          8546:                c_xref |= C_VPTR;
        !          8547:        }
        !          8548:        else {
        !          8549: //error("byte_offset %d bit_offset %d bitsinbyte %d",byte_offset,bit_offset,BI_IN_BYTE);
        !          8550: //error("   div %d mod %d",bit_offset/BI_IN_BYTE,bit_offset%BI_IN_BYTE);
        !          8551:            // no more bit fields. absorb bit_offset
        !          8552:            if (bit_offset) {
        !          8553:                byte_offset += (bit_offset/BI_IN_BYTE + (bit_offset%BI_IN_BYTE?1:0));
        !          8554:                bit_offset = 0;
        !          8555:            }
        !          8556:        }
        !          8557: //error("byte_offset %d bit_offset %d",byte_offset,bit_offset);
        !          8558: 
        !          8559:        for (Pbcl b = baselist; b; b = b->next) { // allocate virtual base pointers
        !          8560:                if (b->base != VIRTUAL) continue;
        !          8561:                Pclass bcl = b->bclass;
        !          8562: 
        !          8563:                // search non-virtual bases for this virtual base
        !          8564:                for (Pbcl bb = baselist; bb; bb = bb->next)
        !          8565:                        if (bb->base == NAME) {
        !          8566:                                for (Pbcl l = bb->bclass->baselist; l; l=l->next)
        !          8567:                                        if (l->base==VIRTUAL && l->bclass==bcl) goto eee;
        !          8568:                        }
        !          8569:                {
        !          8570:                if (obj_align<AL_WPTR) obj_align = AL_WPTR;
        !          8571:                if (max_align<AL_WPTR) max_align = AL_WPTR;
        !          8572:                int waste = byte_offset%AL_WPTR;
        !          8573:                if (waste) byte_offset += AL_WPTR-waste;        // align
        !          8574:                b->ptr_offset = byte_offset+1;                  // ensure != 0
        !          8575:                byte_offset += sizeof(int*);
        !          8576:                }
        !          8577:        eee:;
        !          8578:        }
        !          8579: 
        !          8580:        real_size = byte_offset;        // the rest may be optimized away
        !          8581: 
        !          8582:        for (b = baselist; b; b = b->next) {    // allocate virtual class objects
        !          8583:                if (b->base != VIRTUAL) continue;
        !          8584:                Pclass bcl = b->bclass;
        !          8585: 
        !          8586:                // if necessary
        !          8587:                if (b->obj_offset = has_allocated_base(bcl)) continue;
        !          8588: 
        !          8589:                int ba = bcl->align();
        !          8590:                if (obj_align<ba) obj_align = ba;
        !          8591:                if (max_align<ba) max_align = ba;
        !          8592:                int waste = byte_offset%ba;
        !          8593:                if (waste) byte_offset += ba-waste;     // align
        !          8594:                b->obj_offset = byte_offset;            // offset in this
        !          8595:                b->allocated = 1;
        !          8596: //error('d',"virtual %t in %t at %d",bcl,this,b->obj_offset);
        !          8597:                byte_offset += bcl->tsizeof();
        !          8598:        }
        !          8599: 
        !          8600:        // no more data members.
        !          8601:        // pad object (so that copying into a base object
        !          8602:        // doesn't destroy derevid class members):
        !          8603:        if (byte_offset==0) {   // empty struct: waste a member
        !          8604:                Pname c = new name (make_name('W'));
        !          8605:                c->tp = char_type;
        !          8606:                (void) c->dcl(memtbl,0);
        !          8607:                real_size = byte_offset = 1;
        !          8608:        }
        !          8609:        if (byte_offset < SZ_STRUCT) byte_offset = SZ_STRUCT;
        !          8610:        int waste = byte_offset%max_align;
        !          8611: //error('d',"max_align %d waste %d byte_offset %d",max_align,waste,byte_offset);
        !          8612:        if (waste) byte_offset += max_align-waste;
        !          8613:        obj_size = byte_offset;
        !          8614:        obj_align = max_align;
        !          8615: 
        !          8616:        // make vtbls
        !          8617:        // this cannot be done until the bases
        !          8618:        // have been allocated in this class
        !          8619:        // so that the offsets (deltas) are known
        !          8620:        if (all_virt(this,0,1,0)) {
        !          8621:                if (has_ctor()==0) make_ctor = 1;
        !          8622:        }
        !          8623:        else if (has_vvtab)
        !          8624:                error("virtualB: conflicting vtable initialization");
        !          8625: 
        !          8626: // error('d',"%t->classdef: virt_count: %d virt_merge: %d",this,virt_count,virt_merge);
        !          8627: 
        !          8628:        Pname hito = has_itor();
        !          8629: 
        !          8630:        if (hito) c_xref |= C_XREF;     // has user defined X(X&)
        !          8631: //error('d',"%t hito %d ctor %d",this,hito,make_ctor);
        !          8632:        if (hito==0 && c_xref&(C_VPTR|C_VBASE|C_XREF)) {
        !          8633:                // X(X&) needed if bitwise copy is illegal
        !          8634:                // or if any constructor is defined
        !          8635:                
        !          8636:                hito = make_itor(0);
        !          8637:                        // if the base has B::B(void)
        !          8638:                        // the derived should have D::D(void)
        !          8639:                if (baselist) {
        !          8640:                        int mc = 1;     // can make and ictor
        !          8641:                        for (Pbcl b = baselist; b; b = b->next) {
        !          8642:                                if (b->bclass->has_ctor()
        !          8643:                                && b->bclass->has_ictor()==0)
        !          8644:                                                mc = 0;
        !          8645:                        }
        !          8646:                        make_ctor = mc;
        !          8647: /*
        !          8648:                        int mc = 1;     // can make an ictor
        !          8649:                        for (Pbcl b = baselist; b; b = b->next) {
        !          8650:                                if (b->bclass->has_ctor()) {
        !          8651:                                        Pname c = b->bclass->has_ictor();
        !          8652:                                                // no copy constructor?
        !          8653:                                                // non-public copy constructor?
        !          8654:                                        if (c==0 || c->n_scope==0) mc = 0;
        !          8655:                                }
        !          8656:                        }
        !          8657:                        make_ctor = mc;
        !          8658: */
        !          8659:                }
        !          8660:                else
        !          8661:                        make_ctor =  1;
        !          8662:        }
        !          8663: 
        !          8664:        if (c_ctor==0 && make_ctor==0) {        // can ctor be inherited (from single base class)?
        !          8665: /*
        !          8666:                int bb = 0;
        !          8667:                for (Pbcl b = baselist; b; b = b->next) {
        !          8668:                        switch (b->base) {
        !          8669:                        case NAME:
        !          8670:                        {       Pname c = b->bclass->has_ctor();
        !          8671:                        //      if (b->bclass->has_ctor() == 0) break;
        !          8672:                                if (c == 0) break;
        !          8673:                                if (c->n_scope==PUBLIC && bb++==0) break;
        !          8674:                        }
        !          8675:                                // no break: two bases: needs ctor
        !          8676:                        case VIRTUAL:
        !          8677:                                make_ctor = 1;  // virtual base: need ctor
        !          8678:                                goto zaza;
        !          8679:                        }
        !          8680:                }
        !          8681: */
        !          8682:                Pname btor = 0;
        !          8683:                Pclass bc = 0;
        !          8684:                for (Pbcl b = baselist; b; b = b->next) {
        !          8685:                        switch (b->base) {
        !          8686:                        case NAME:
        !          8687:                        {       Pname c = b->bclass->has_ctor();
        !          8688:                                if (c == 0) break;
        !          8689:                                if (c->n_scope==PUBLIC && b==baselist) {
        !          8690:                                        bc = b->bclass;
        !          8691:                                        btor = bc->has_ictor();
        !          8692:                                        break;
        !          8693:                                }
        !          8694:                        }
        !          8695:                                // no break: two bases: needs ctor
        !          8696:                        case VIRTUAL:
        !          8697:                                make_ctor = 1;  // virtual base: need ctor
        !          8698:                                goto zaza;
        !          8699:                        }
        !          8700:                }
        !          8701:        //      c_ctor = btor;
        !          8702: //error('d',"btor %n",btor);
        !          8703:                if (bc) {
        !          8704:                        if (btor)
        !          8705:                                make_ctor = 1;
        !          8706:                        else
        !          8707:                                error("K needed for %s, BC%t hasK",string,bc);
        !          8708:                }
        !          8709:        zaza:;
        !          8710:        }
        !          8711: 
        !          8712:        if (make_ctor && ct==0) {       // make x::x() {}
        !          8713: //error('d',"%t: make_ctor",this);
        !          8714:                Pname n = new name(string);
        !          8715:                Pfct f = new fct(defa_type,0,1);
        !          8716:                f->f_inline = 1; // ICTOR; // ICTOR means ``define ctor() if used''
        !          8717:                n->tp = f;
        !          8718:                n->n_oper = TNAME;
        !          8719:                ct = n->dcl(memtbl,PUBLIC);
        !          8720:                delete n;
        !          8721:                Pfct(ct->tp)->body = /* 0; */ new block(curloc,0,0);
        !          8722:        }
        !          8723: 
        !          8724:        defined |= DEFINED;
        !          8725: 
        !          8726:        if (ansi_opt) {
        !          8727:                char* s = csu==UNION || csu==ANON ? "union" : "struct";
        !          8728:                fprintf(out_file,"%s %s;",s,string);
        !          8729:        }
        !          8730: //error('d',"defined %s",string);
        !          8731: 
        !          8732:        // fix argument lists for inlines
        !          8733:        for (p=memtbl->get_mem(i=1); p; p=memtbl->get_mem(++i)) {
        !          8734:                Pfct f = Pfct(p->tp);
        !          8735:                if (f==0) continue;     // public declarations
        !          8736: 
        !          8737:                switch (f->base) {
        !          8738:                case FCT:
        !          8739:                        /* prohibit something like the following:
        !          8740:                                typedef int t1;
        !          8741:                                class x {
        !          8742:                                        typedef int t1;
        !          8743:                                        t1 foo();
        !          8744:                                };
        !          8745:                        */
        !          8746:                        if (f->returns->base == TYPE) {
        !          8747:                                Pname nn = Pbase(f->returns)->b_name;
        !          8748:                                while ( nn->tp->base == TYPE ) 
        !          8749:                                        nn = Pbase(nn->tp)->b_name;
        !          8750:                                if (nn->n_key == NESTED) {
        !          8751:                                        Ptype tt;
        !          8752:                                        if ( nn->tp->base != EOBJ && 
        !          8753:                                                nn->tp->base != COBJ )
        !          8754:                                                        tt = nn->tpdef;
        !          8755:                                        else  tt = Pbase(nn->tp)->b_name->tp; 
        !          8756:                                        if ( tt && tt->nested_sig )
        !          8757:                                                error('w',"nested %s as returnT for non-inlineMF, use %t::%s %n{} in definition (anachronism)",nn->string,tt->in_class,nn->string,p);
        !          8758:                                }
        !          8759:                        }
        !          8760: 
        !          8761:                        if (hito && f->argtype) fix_args(f,this);
        !          8762:                        if (p->n_oper == CTOR) f->s_returns = this_type;
        !          8763:                        if (f->body) p->n_sto = STATIC;
        !          8764:                        break;
        !          8765:                case OVERLOAD:
        !          8766:                {       Pgen g = Pgen(f);
        !          8767:                        for (Plist gl=g->fct_list; gl; gl=gl->l) {
        !          8768:                                Pname n = gl->f;
        !          8769:                                Pfct f = Pfct(n->tp);
        !          8770: 
        !          8771:                                if (hito && f->argtype) fix_args(f,this);
        !          8772:                                if (n->n_oper == CTOR) f->s_returns = this_type;
        !          8773:                                if (f->body) n->n_sto = STATIC;
        !          8774:                        }
        !          8775:                }
        !          8776:                }
        !          8777:        }
        !          8778: 
        !          8779:        // define members defined inline
        !          8780:        for (p=memtbl->get_mem(i=1); p; p=memtbl->get_mem(++i)) {
        !          8781:                Pfct f = Pfct(p->tp);
        !          8782:                if (f==0) continue;     // public declarations
        !          8783: 
        !          8784:                switch (f->base) {
        !          8785:                case FCT:
        !          8786:                        if (f->body) {
        !          8787:                                f->dcl(p);
        !          8788:                                p->simpl();
        !          8789:                        }
        !          8790:                        break;
        !          8791:                case OVERLOAD:
        !          8792:                {       Pgen g = Pgen(f);
        !          8793:                        for (Plist gl=g->fct_list; gl; gl=gl->l) {
        !          8794:                                Pname n = gl->f;
        !          8795:                                Pfct f = Pfct(n->tp);
        !          8796: 
        !          8797:                                if (f->body) {
        !          8798:                                        f->dcl(n);
        !          8799:                                        n->simpl();
        !          8800:                                }
        !          8801:                        }
        !          8802:                }
        !          8803:                }
        !          8804:        }
        !          8805: 
        !          8806:        byte_offset = byte_old;
        !          8807:        bit_offset = bit_old;
        !          8808:        max_align = max_old;
        !          8809: 
        !          8810:        cc->unstack();  // friends are not in class scope
        !          8811: 
        !          8812:        // fix arguments lists for friends defined inline 
        !          8813:        for (Plist fl=friend_list; fl; fl=fl->l) {
        !          8814:                Pname p = fl->f;
        !          8815:                Pfct f = Pfct(p->tp);
        !          8816: 
        !          8817:                switch (f->base) {
        !          8818:                case FCT:
        !          8819:                        if (hito && f->argtype) fix_args(f,this);
        !          8820:                        if (f->body &&
        !          8821:                           (f->defined&(DEFINED|SIMPLIFIED)) == 0) 
        !          8822:                                p->n_sto = STATIC;
        !          8823:                        else 
        !          8824:                        if (p->n_scope == STATIC)
        !          8825:                                error(strict_opt?0:'w',"static%n declared friend toC%t",p,this);
        !          8826:                        break;
        !          8827:                case OVERLOAD:
        !          8828:                {       Pgen g = Pgen(f);
        !          8829:                        for (Plist gl=g->fct_list; gl; gl=gl->l) {
        !          8830:                                Pname n = gl->f;
        !          8831:                                Pfct f = Pfct(n->tp);
        !          8832: 
        !          8833:                                if (hito && f->argtype) fix_args(f,this);
        !          8834:                                if (f->body &&
        !          8835:                                   (f->defined&(DEFINED|SIMPLIFIED)) == 0) 
        !          8836:                                        n->n_sto = STATIC;
        !          8837:                                else 
        !          8838:                                if (p->n_scope == STATIC)
        !          8839:                                        error(strict_opt?0:'w',"static%n declared friend toC%t",p,this);
        !          8840:                        }
        !          8841:                }
        !          8842:                }
        !          8843:        }
        !          8844: 
        !          8845:        // define friends defined inline and modify return types if necessary
        !          8846:        for (fl=friend_list; fl; fl=fl->l) {
        !          8847:                Pname p = fl->f;
        !          8848:                Pfct f = Pfct(p->tp);
        !          8849: 
        !          8850:                switch (f->base) {
        !          8851:                case FCT:
        !          8852:                        if (f->body &&
        !          8853:                           (f->defined&(DEFINED|SIMPLIFIED)) == 0) {
        !          8854:                                f->dcl(p);
        !          8855:                                p->simpl();
        !          8856:                        }
        !          8857:                        break;
        !          8858:                case OVERLOAD:
        !          8859:                {       Pgen g = Pgen(f);
        !          8860:                        for (Plist gl=g->fct_list; gl; gl=gl->l) {
        !          8861:                                Pname n = gl->f;
        !          8862:                                Pfct f = Pfct(n->tp);
        !          8863: 
        !          8864:                                if (f->body &&
        !          8865:                                   (f->defined&(DEFINED|SIMPLIFIED)) == 0) {
        !          8866:                                        f->dcl(n);
        !          8867:                                        n->simpl();
        !          8868:                                }
        !          8869:                        }
        !          8870:                }
        !          8871:                }
        !          8872:        }
        !          8873: 
        !          8874:        if (tbl != gtbl) this->simpl();
        !          8875: 
        !          8876:         if ( statStat && strcmp(statStat->string,string)==0) {
        !          8877: //error('d', "classdef::dcl: statstat: %n this %s", statStat, string);
        !          8878:                 statStat->hide();
        !          8879:                 statStat = 0;
        !          8880:         }
        !          8881: // error('d',"classdef::dcl defined: %d",defined);
        !          8882:        // catch refs to this class in body of nested class function
        !          8883:        // (i.e., ref to member of this class...)
        !          8884:        if ( (defined&REF_SEEN) != 0 ) dcl_print(0);
        !          8885: 
        !          8886:      if ( debug_opt ) {
        !          8887:        for (p=memtbl->get_mem(i=1); p; p=memtbl->get_mem(++i)) {
        !          8888:                Pfct f = Pfct(p->tp);
        !          8889:                if (f==0) continue;     // public declarations
        !          8890: 
        !          8891:                switch (f->base) {
        !          8892:                        case FCT:
        !          8893:                                if (f->body) {
        !          8894:                                        if ( c_body == 1 ) dcl_print(0);
        !          8895:                                        p->dcl_print(0);
        !          8896:                                }
        !          8897:                                break;
        !          8898:                        case OVERLOAD: 
        !          8899:                        {       
        !          8900:                                Pgen g = Pgen(f);
        !          8901:                                for (Plist gl=g->fct_list; gl; gl=gl->l) {
        !          8902:                                        Pname n = gl->f;
        !          8903:                                        Pfct f = Pfct(n->tp);
        !          8904:                                        if (f->body) {
        !          8905:                                                if ( c_body == 1 ) dcl_print(0);
        !          8906:                                                p->dcl_print(0);
        !          8907:                                        }
        !          8908:                                }
        !          8909:                        }
        !          8910:                }
        !          8911:        }
        !          8912: 
        !          8913:        for (fl=friend_list; fl; fl=fl->l) {
        !          8914:                Pname p = fl->f;
        !          8915:                Pfct f = Pfct(p->tp);
        !          8916: 
        !          8917:                switch (f->base) {
        !          8918:                        case FCT:
        !          8919:                                if (f->body &&
        !          8920:                                   (f->defined&(DEFINED|SIMPLIFIED)) == 0) 
        !          8921:                                        p->dcl_print(0);
        !          8922:                                break;
        !          8923:                        case OVERLOAD:
        !          8924:                        {       
        !          8925:                                Pgen g = Pgen(f);
        !          8926:                                for (Plist gl=g->fct_list; gl; gl=gl->l) {
        !          8927:                                        Pname n = gl->f;
        !          8928:                                        Pfct f = Pfct(n->tp);
        !          8929: 
        !          8930:                                        if (f->body &&
        !          8931:                                           (f->defined&(DEFINED|SIMPLIFIED)) == 0) 
        !          8932:                                                p->dcl_print(0);
        !          8933:                                }
        !          8934:                        }
        !          8935:                }
        !          8936:        }
        !          8937:     } // end, if (debug_opt)
        !          8938: }
        !          8939: 
        !          8940: void enumdef::dcl(Pname n, Ptable tbl)
        !          8941: {
        !          8942: //     if (this == 0) error('i',"0->enumdef::dcl(%p)",tbl);
        !          8943:        Pname px;
        !          8944:        Pname p = mem;
        !          8945:        DB( if(Ddebug>=1) error('d',&n->where,"enumdef(%n,%d)",n,tbl); );
        !          8946:        Pbase b = new basetype(EOBJ,n);
        !          8947:        b->b_const = 1;
        !          8948: 
        !          8949: #define FIRST_ENUM 0
        !          8950:        int enum_count = FIRST_ENUM;
        !          8951:        no_of_enumerators = mem->no_of_names();
        !          8952:        int largest = 0;
        !          8953: 
        !          8954:        if (p == 0) mem = new name(make_name('e'));
        !          8955: 
        !          8956:        for (; p; p=px) {
        !          8957:                px = p->n_list;
        !          8958: // error( 'd', "p %n", p );
        !          8959:                if (p->n_initializer) {
        !          8960:                        Pexpr i = p->n_initializer->typ(tbl);
        !          8961:                        Neval = 0;
        !          8962:                        long ii = i->eval();
        !          8963:                        if (largest_int<ii) error("long enumerator");
        !          8964:                        enum_count = int(ii);
        !          8965:                        if (Neval) error("%s",Neval);
        !          8966:                        DEL(i);
        !          8967:                        p->n_initializer = 0;
        !          8968:                }
        !          8969:                p->n_evaluated = 1;
        !          8970:                largest |= enum_count;
        !          8971:                p->n_val = enum_count++;
        !          8972:                p->tp = b;
        !          8973: 
        !          8974:                Pname nn = tbl->insert(p,0);
        !          8975:                if (Nold) {
        !          8976:                        if (nn->n_stclass == ENUM) {
        !          8977:                        //      error( (p->n_val!=nn->n_val)?0:'w',"enumerator%n declared twice",nn);
        !          8978:                //      if (p->n_val!=nn->n_val)
        !          8979:                        error("enumerator%n declared twice",nn);
        !          8980:                        
        !          8981:                        }
        !          8982:                        else
        !          8983:                                error("incompatibleDs of%n",nn);
        !          8984:                }
        !          8985:                else {
        !          8986:                        nn->n_stclass = ENUM; // no store will be allocated
        !          8987:                        if (Eppp == PROTECTED)
        !          8988:                                nn->n_protect = PROTECTED;
        !          8989:                        else if (Eppp == PUBLIC)
        !          8990:                                nn->n_scope = PUBLIC;
        !          8991:                }
        !          8992:                p->string = nn->string;
        !          8993: //             delete p;
        !          8994:        }
        !          8995: 
        !          8996: //     mem = 0;
        !          8997: 
        !          8998: //     chose a shorter representation for the enum?
        !          8999: //     if (largest&0133 == largest)
        !          9000: //             e_type = char_type;
        !          9001: //     else if largest&077777 == largest)
        !          9002: //             e_type = short_type;
        !          9003: //     else
        !          9004:                e_type = int_type;
        !          9005: 
        !          9006:        defined |= DEFINED;
        !          9007: }
        !          9008: 
        !          9009: 
        !          9010: 0707071010112044131004440001630000160000010175600466055377200000600000013077del.c/*ident      "@(#)ctrans:src/del.c   1.3" */
        !          9011: /************************************************************
        !          9012: 
        !          9013:        C++ source for cfront, the C++ compiler front-end
        !          9014:        written in the computer science research center of Bell Labs
        !          9015: 
        !          9016:        Copyright (c) 1984 AT&T, Inc. All rights Reserved
        !          9017:        THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T, INC.
        !          9018: 
        !          9019: del.c:
        !          9020: 
        !          9021:        walk the trees to reclaim storage
        !          9022: 
        !          9023: **************************************************************/
        !          9024: 
        !          9025: #include "cfront.h"
        !          9026: 
        !          9027: void name::del()
        !          9028: {
        !          9029:        DB( if(Adebug>=1) {
        !          9030:                fprintf(stderr,"\n*** '%s'->del()",string?string:"???");
        !          9031:                display_type(tp); putc(' ',stderr);
        !          9032:                where.put(stderr); putc('\n',stderr);
        !          9033:            }
        !          9034:            if ( base!=NAME && base!=TNAME ) error('i',"name::del() of%k -- id==%ld",base,node::id);
        !          9035:        );
        !          9036:        Pexpr i = n_initializer;
        !          9037: 
        !          9038: // error('d', "\nname::del: %d %s", this, string?string:"no name" );
        !          9039: //     NFn++;
        !          9040:        DEL(tp);
        !          9041:        if(i && i!=(Pexpr)1) DEL(i);
        !          9042:        delete this;
        !          9043: }
        !          9044: 
        !          9045: void type::del()
        !          9046: {
        !          9047:        DB( if(Adebug>=1) {
        !          9048:                fprintf(stderr,"\n*** '");
        !          9049:                display_type(this);
        !          9050:                fprintf(stderr," '->del()\n");
        !          9051:            }
        !          9052:        );
        !          9053: //fprintf(stderr,"DEL(type=%d %d)\n",this,base);
        !          9054:        permanent = 3;  /* do not delete twice */
        !          9055:        switch (base) {
        !          9056:        case TNAME:
        !          9057:        case NAME:
        !          9058:                error('i',"%d->T::del():N %s %d",this,Pname(this)->string,base);
        !          9059:        case FCT:
        !          9060:        {       Pfct f = (Pfct) this;
        !          9061:                DEL(f->returns);
        !          9062:                delete f;
        !          9063:                break;
        !          9064:        }
        !          9065:        case VEC:
        !          9066:        {       Pvec v = (Pvec) this;
        !          9067:                DEL(v->dim);
        !          9068:                DEL(v->typ);
        !          9069:                delete v;
        !          9070:                break;
        !          9071:        }
        !          9072:        case PTR:
        !          9073:        case RPTR:
        !          9074:        {       Pptr p = (Pptr) this;
        !          9075:                DEL(p->typ);
        !          9076:                delete p;
        !          9077:                break;
        !          9078:        }
        !          9079:        }
        !          9080: }
        !          9081: 
        !          9082: void expr::del()
        !          9083: {
        !          9084:        DB( if(Adebug>=1) {
        !          9085:                fprintf(stderr,"\n*** expr::del():  ");
        !          9086:                display_expr(this,0,1);
        !          9087:                if(Adebug>=2) display_expr(this);
        !          9088:        });
        !          9089: //fprintf(stderr,"DEL(expr=%d: %d %d %d)\n",this,base,e1,e2); fflush(stderr);
        !          9090:        permanent = 3;
        !          9091:        switch (base) {
        !          9092:        case IVAL:
        !          9093:                if (this == one) return;
        !          9094:        //case FVAL:
        !          9095:        case THIS:
        !          9096:        case ICON:
        !          9097:        case FCON:
        !          9098:        case CCON:
        !          9099:        case STRING:
        !          9100:        case TEXT:
        !          9101:                goto dd;
        !          9102:        case DUMMY:
        !          9103:        case ZERO:
        !          9104:        case NAME:
        !          9105:                return;
        !          9106:        case CAST:
        !          9107:        case SIZEOF:
        !          9108:        case NEW:
        !          9109:        case GNEW:
        !          9110:        case VALUE:
        !          9111:                DEL(tp2);
        !          9112:                break;
        !          9113:        case REF:
        !          9114:        case DOT:
        !          9115:                DEL(e1);
        !          9116:                if (e2) DEL(e2);
        !          9117:        case MDOT:
        !          9118:                if (mem && mem->base!=NAME) DEL(mem);
        !          9119:                if ( i1 == 5 ) delete string4;
        !          9120:                goto dd;
        !          9121:        case QUEST:
        !          9122:                DEL(cond);
        !          9123:                break;
        !          9124:        case ICALL:
        !          9125:                delete il->i_args;
        !          9126:                delete il;
        !          9127:                goto dd;
        !          9128:        case ELIST: { // limit recursion
        !          9129:                Pexpr tp = e2;
        !          9130:                while ( tp && tp->e2 && tp->e2->base == ELIST ) {
        !          9131:                        Pexpr x = tp;
        !          9132:                        if ( x->permanent ) break;
        !          9133:                        x->permanent = 3;
        !          9134:                        tp = tp->e2;
        !          9135:                        if ( x->e1 ) DEL(x->e1);
        !          9136:                        delete x;
        !          9137:                }
        !          9138:                e2 = tp;
        !          9139:                break;
        !          9140:                }
        !          9141:        }
        !          9142: 
        !          9143:        DEL(e1);
        !          9144:        DEL(e2);
        !          9145: dd:
        !          9146:        delete this;
        !          9147: }
        !          9148: 
        !          9149: void stmt::del()
        !          9150: {
        !          9151:        DB( if(Adebug>=1) {
        !          9152:                fprintf(stderr,"\n*** stmt::del():  ");
        !          9153:                display_stmt(this,0,1);
        !          9154:                if(Adebug>=2) display_stmt(this);
        !          9155:        });
        !          9156: //fprintf(stderr,"DEL(stmt %d %s)\n",this,keys[base]); fflush(stderr);
        !          9157:        permanent = 3;
        !          9158:        switch (base) {
        !          9159:        case SM:
        !          9160:        case WHILE:
        !          9161:        case DO:
        !          9162:        case RETURN:
        !          9163:        case CASE:
        !          9164:        case SWITCH:
        !          9165:                DEL(e);
        !          9166:                break;
        !          9167:        case PAIR:
        !          9168:                DEL(s2);
        !          9169:                break;
        !          9170:        case BLOCK:
        !          9171:                DEL(d);
        !          9172:                DEL(s);
        !          9173:                if (own_tbl) DEL(memtbl);
        !          9174:                DEL(s_list);
        !          9175:                goto dd;
        !          9176:        case FOR:
        !          9177:                DEL(e);
        !          9178:                DEL(e2);
        !          9179:                DEL(for_init);
        !          9180:                break;
        !          9181:        case IF:
        !          9182:                DEL(e);
        !          9183:                DEL(else_stmt);
        !          9184:                break;
        !          9185:        }
        !          9186: 
        !          9187:        DEL(s);
        !          9188:        DEL(s_list);
        !          9189: dd:
        !          9190:        delete this;
        !          9191: }
        !          9192: 
        !          9193: void table::del()
        !          9194: {
        !          9195: // error('d',"\n*** %d::del() -- '%s'\n",this, t_name?t_name->string:"???");
        !          9196: 
        !          9197:        for (register i=1; i<free_slot; i++) {
        !          9198:                Pname n = entries[i];
        !          9199:                if (n==0) error('i',"table.del(0)");
        !          9200:                DB( if(Adebug>=2) { fprintf(stderr,"  name: '%s'",n->string);
        !          9201:                        display_type(n->tp); putc('\n',stderr);
        !          9202:                });
        !          9203: 
        !          9204: // error( 'd',"\ntable::del: %s n_scope: %d, n_stclass: %d", n->string, n->n_scope, n->n_stclass );
        !          9205: 
        !          9206:                if (n->n_stclass == STATIC) continue;
        !          9207:                switch (n->n_scope) {
        !          9208:                case ARG:
        !          9209:                case ARGT:
        !          9210:                        break;
        !          9211:                default:
        !          9212:                {       char* s = n->string;
        !          9213:                        if (s && (s[0]!='_' || s[1]!='_' || s[2]!='X')) delete s;
        !          9214:                        /* delete n; */
        !          9215:                        n->del();
        !          9216:                }
        !          9217:                }
        !          9218:        }
        !          9219:        //delete entries;
        !          9220:        //delete hashtbl;
        !          9221:        delete this;
        !          9222: }
        !          9223: 
        !          9224: // local class
        !          9225: void delete_local() 
        !          9226: {
        !          9227:        DB( if(Adebug>=1) {
        !          9228:                fprintf( stderr, "delete_local: vlist: %d", vlist );
        !          9229:        });
        !          9230: // error( 'd', "delete_local: vlist: %d", vlist );
        !          9231:     do {
        !          9232:        for (vl* v = vlist; v; v = v->next) v->cl->really_print(v->vt);
        !          9233:        vlist = 0;
        !          9234: 
        !          9235:        for (Plist l=isf_list; l; l=l->l) {
        !          9236:                Pname n = l->f;
        !          9237:                Pfct f = Pfct(n->tp);
        !          9238: // error('d',"isf %n f %d",n,f);
        !          9239:                if ( f == 0 ) { error('d', "delete_local: f == 0" );break;} 
        !          9240:                if (f->base == OVERLOAD) {
        !          9241:                        n = Pgen(f)->fct_list->f;       // first fct
        !          9242:                        f = Pfct(n->tp);
        !          9243:                }
        !          9244: 
        !          9245:                if (debug_opt==0 && n->n_addr_taken) {
        !          9246:                        f->f_inline = 0;
        !          9247:                        if (n->n_dcl_printed<2) {
        !          9248:                                if (warning_opt)
        !          9249:                                        error('w',"out-of-line copy of %n created",n);
        !          9250:                                n->dcl_print(0);
        !          9251:                        }
        !          9252:                }
        !          9253:        }
        !          9254:        //isf_list = 0;
        !          9255:     } while (vlist);
        !          9256: 
        !          9257:     for ( Plist l = local_class; l; l = l->l )
        !          9258:     {
        !          9259:           Pname n = l->f;
        !          9260: // error( 'd' , "delete_local() %d %n %t", n, n, n->tp );
        !          9261:     Pname nn = Pbase(n->tp)->b_name;
        !          9262:     Pclass cl = Pclass(nn->tp);
        !          9263:        for (Pname px, p=cl->mem_list; p; p=px) {
        !          9264:                px = p->n_list;
        !          9265:                if (p->tp)
        !          9266:                switch (p->tp->base) {
        !          9267:                        case FCT:
        !          9268:                        {       Pfct f = (Pfct)p->tp;
        !          9269:                                if (f->body) {
        !          9270:                                    if (f->f_inline==0
        !          9271:                                    && f->f_imeasure==0) {
        !          9272: 
        !          9273:                                        if (ansi_opt && f->f_this) {
        !          9274:                                                f->f_this->n_table = 0;
        !          9275:                                                for (Pname n=f->f_this->n_list; n; n=n->n_list) 
        !          9276:                                                        n->n_table = 0; 
        !          9277:                                        }
        !          9278: 
        !          9279:                                        DEL(f->body);
        !          9280:                                        f->body = 0;
        !          9281:                                        }
        !          9282:                                }
        !          9283:                        }
        !          9284:                        case COBJ:
        !          9285:                        case EOBJ:
        !          9286:                                DEL(p);
        !          9287:                                break;
        !          9288:                        case CLASS:
        !          9289:                        case ENUM:
        !          9290:                                break;
        !          9291:                        default:
        !          9292:                                delete p;
        !          9293:                        } // end switch
        !          9294:                else delete p;
        !          9295:        } // end for mem
        !          9296:         DEL(cl->memtbl);
        !          9297:        cl->mem_list = 0;
        !          9298:        cl->permanent = 3;
        !          9299:         nn->permanent = 0;
        !          9300:        DEL(nn);
        !          9301:        n->permanent = 0;
        !          9302:        extern void table_delete( char*, TOK, int );
        !          9303:        table_delete( n->string, LOCAL, n->lex_level );
        !          9304:        DEL(n);
        !          9305:     }
        !          9306: }
        !          9307: 0707071010112045761004440001630000160000010210600466055414200001200000013534discrim.c/* ident "@(#)ctrans:src/discrim.c       1.2" */
        !          9308: /************ add copyright **********************
        !          9309:  * union discriminator functions for nodes in cfront. 
        !          9310:  * all return 0 for none,
        !          9311:  *   -1 for bad union index, -2 for inconsistent
        !          9312:  *  or otherwise messed up nodes 
        !          9313:  */
        !          9314: #include "cfront.h"
        !          9315: #define DEFINE_TOKEN_CLASS_TABLE
        !          9316: #include "node_classes.h"
        !          9317: 
        !          9318: int basetype::discriminator(int which_union)
        !          9319: {
        !          9320:     switch(which_union)
        !          9321:     {
        !          9322:       case 0:
        !          9323:        switch(base) {
        !          9324:          case FIELD: return 1;
        !          9325:          case FCT: return 2;
        !          9326:          default: return discrim_none_valid;
        !          9327:        }
        !          9328:       default:
        !          9329:        return discrim_bad_index;
        !          9330:     }
        !          9331: }
        !          9332: 
        !          9333: int fct::discriminator(int)
        !          9334: {
        !          9335:     return discrim_bad_index;
        !          9336: }
        !          9337: 
        !          9338: int expr::discriminator(int which_union)
        !          9339: {
        !          9340:     switch(which_union) {
        !          9341:       case 0:
        !          9342:        return 1;               /* tp, never syn_class */
        !          9343:       case 1:                  /* e1, i1, string */
        !          9344:        switch(base) {
        !          9345:          case DEREF:
        !          9346:          case ICALL:
        !          9347:          case REF:
        !          9348:          case DOT:
        !          9349:          case VALUE:
        !          9350:          case SIZEOF:
        !          9351:          case NEW:
        !          9352:          case GNEW:
        !          9353:          case DELETE:
        !          9354:          case CAST:
        !          9355:          case CALL:
        !          9356:          case G_CALL:
        !          9357:          case ASSIGN:
        !          9358:          case EQ:
        !          9359:          case NE:
        !          9360:          case GT:
        !          9361:          case GE:
        !          9362:          case LE:
        !          9363:          case LT:
        !          9364:          case ELIST:
        !          9365:          case ILIST:
        !          9366:          case QUEST:
        !          9367:          case CM:
        !          9368:          case G_CM:
        !          9369:          case PLUS:
        !          9370:          case MINUS:
        !          9371:          case MUL:
        !          9372:          case DIV:
        !          9373:          case MOD:
        !          9374:          case LS:
        !          9375:          case RS:
        !          9376:          case AND:
        !          9377:          case OR:
        !          9378:          case ER:
        !          9379:          case ANDAND:
        !          9380:          case OROR:
        !          9381:          case ASOR: 
        !          9382:          case ASER: 
        !          9383:          case ASAND:
        !          9384:          case ASPLUS:
        !          9385:          case ASMINUS:
        !          9386:          case ASMUL:
        !          9387:          case ASMOD:
        !          9388:          case ASDIV:
        !          9389:          case ASLS:
        !          9390:          case ASRS:
        !          9391:          case DECR:
        !          9392:          case INCR:
        !          9393:            return 1;
        !          9394:          case MDOT:
        !          9395:          case IVAL:
        !          9396:            return 2;
        !          9397:          case TNAME:
        !          9398:          case NAME:
        !          9399:          case ICON:
        !          9400:          case FCON:
        !          9401:          case CCON:
        !          9402:          case ID:
        !          9403:          case STRING:
        !          9404:          case TEXT:
        !          9405:            return 3;
        !          9406:          default: return discrim_none_valid;
        !          9407:        }
        !          9408:       case 2:                  /* e2, i2, string2, n_initializer */
        !          9409:        /* i2 is a complete mystery. It is set to 1,
        !          9410:           and never referenced. But I'm not sure that
        !          9411:           someone somewhere doesn't test one of the other
        !          9412:           union elements for equal to 1, so therefore this test. */
        !          9413:        if(i2 == 1)return 2;
        !          9414:        switch(base) {
        !          9415:          case DELETE:
        !          9416:          case VALUE:
        !          9417:          case ICALL:
        !          9418:          case CALL:
        !          9419:          case G_CALL:
        !          9420:          case ASSIGN:
        !          9421:          case EQ:
        !          9422:          case NE:
        !          9423:          case GT:
        !          9424:          case GE:
        !          9425:          case LE:
        !          9426:          case LT:
        !          9427:          case DEREF:
        !          9428:          case ELIST:
        !          9429:          case QUEST:
        !          9430:          case CM:
        !          9431:          case G_CM:
        !          9432:          case UMINUS:
        !          9433:          case NOT:
        !          9434:          case COMPL:
        !          9435:          case ADDROF:
        !          9436:          case G_ADDROF:
        !          9437:          case PLUS:
        !          9438:          case MINUS:
        !          9439:          case MUL:
        !          9440:          case DIV:
        !          9441:          case MOD:
        !          9442:          case LS:
        !          9443:          case RS:
        !          9444:          case AND:
        !          9445:          case OR:
        !          9446:          case ER:
        !          9447:          case ANDAND:
        !          9448:          case OROR:
        !          9449:          case ASOR: 
        !          9450:          case ASER: 
        !          9451:          case ASAND:
        !          9452:          case ASPLUS:
        !          9453:          case ASMINUS:
        !          9454:          case ASMUL:
        !          9455:          case ASMOD:
        !          9456:          case ASDIV:
        !          9457:          case ASLS:
        !          9458:          case ASRS:
        !          9459:          case DECR:
        !          9460:          case INCR:
        !          9461:          case NEW:     /*- the placement expression list hangs off e2 -*/
        !          9462:            return 1;
        !          9463:          case TEXT:
        !          9464:            return 3;
        !          9465:          case NAME:
        !          9466:          case TNAME:
        !          9467:            /* The n_initializer field is used for TNAMEs when describing base */
        !          9468:            /* class initializations. The TNAME refers to the base class, and */
        !          9469:            /* the actuals arguments are hung off the n_initializer list */
        !          9470:            return 4;
        !          9471:          default: return discrim_none_valid;
        !          9472:        }
        !          9473:       case 3:                  /* tp2, fct_name, cond, mem, as_type, n_table, il, query_this */
        !          9474:        switch(base) {
        !          9475:          case VALUE:
        !          9476:          case SIZEOF:
        !          9477:          case NEW:
        !          9478:          case GNEW:    
        !          9479:          case CAST:
        !          9480:            return 1;
        !          9481:          case CALL:
        !          9482:          case G_CALL:
        !          9483:            return 2;
        !          9484:          case QUEST:
        !          9485:            return 3;
        !          9486:          case REF:
        !          9487:          case DOT:
        !          9488:          case MDOT: 
        !          9489:            return 4;
        !          9490:          case ASOR: 
        !          9491:          case ASER: 
        !          9492:          case ASAND:
        !          9493:          case ASPLUS:
        !          9494:          case ASMINUS:
        !          9495:          case ASMUL:
        !          9496:          case ASMOD:
        !          9497:          case ASDIV:
        !          9498:          case ASLS:
        !          9499:          case ASRS:
        !          9500:          case DECR:
        !          9501:          case INCR:
        !          9502:          case ASSIGN:
        !          9503:            return 5;
        !          9504: 
        !          9505:          case NAME:
        !          9506:          case TNAME:
        !          9507: if (Pname(this)->n_oper==TYPE &&
        !          9508: (strcmp(Pname(this)->string, "_type")==0)) {
        !          9509: // error('d',"string %s n_oper: %k", string, Pname(this)->n_oper);
        !          9510: return 3;
        !          9511: }
        !          9512:            return 6;
        !          9513: 
        !          9514:          case ICALL:
        !          9515:          case ANAME: 
        !          9516:            return 7;
        !          9517: 
        !          9518:          default: return discrim_none_valid;
        !          9519:        }
        !          9520:            
        !          9521:       default:
        !          9522:        return discrim_bad_index;
        !          9523:     }
        !          9524: }
        !          9525: 
        !          9526: int name::discriminator (int which_union)
        !          9527: {
        !          9528:     switch(which_union) {
        !          9529:       case 0:                  /* n_qualifier, n_realscope */
        !          9530:        if(base == LABEL) return 2;
        !          9531:        else return 1;
        !          9532:       default:
        !          9533:        return discrim_bad_index;
        !          9534:     }
        !          9535: }
        !          9536: 
        !          9537: int stmt::discriminator (int which_union)
        !          9538: {
        !          9539:     switch(which_union) {
        !          9540:       case 0:                  /* d, e2, has_default, case_value, ret_tp */
        !          9541:        switch(base) {
        !          9542:          case BLOCK:
        !          9543:          case GOTO:
        !          9544:          case LABEL:
        !          9545:          case DCL:
        !          9546:            return 1;
        !          9547:          case FOR:
        !          9548:            return 2;
        !          9549:          case SWITCH:
        !          9550:            return 3;
        !          9551:          case PAIR:
        !          9552:          case RETURN:
        !          9553:            return 4;
        !          9554:          default: return discrim_none_valid;
        !          9555:        }
        !          9556:       case 1:                  /* e, own_tbl, s2 */
        !          9557:        switch(base) {
        !          9558:          case FOR:
        !          9559:          case IF:
        !          9560:          case WHILE:
        !          9561:          case DO:
        !          9562:          case RETURN:
        !          9563:          case SWITCH:
        !          9564:          case SM:
        !          9565:          case SM_PARAM:
        !          9566:          case CASE:
        !          9567:            return 1;
        !          9568:          case BLOCK:
        !          9569:            return 2;
        !          9570:          case PAIR:
        !          9571:            return 3;
        !          9572:          default:
        !          9573:            return discrim_none_valid;
        !          9574:        }
        !          9575:       case 2:                  /* for_init, else_stmt, case_list */
        !          9576:        switch(base) {
        !          9577:          case FOR:
        !          9578:            return 1;
        !          9579:          case IF:
        !          9580:            return 2;
        !          9581:          case SWITCH:
        !          9582:          case CASE:
        !          9583:            return 3;
        !          9584:          default:
        !          9585:            return discrim_none_valid;
        !          9586:        }
        !          9587:       default:
        !          9588:        return discrim_bad_index;
        !          9589:     }
        !          9590: }
        !          9591: 
        !          9592: static node_class token_to_class_map[DUMMY_LAST_NODE];
        !          9593: static char map_initialized;
        !          9594: 
        !          9595: node_class classify_node (Pnode node, int& error)
        !          9596: {
        !          9597:     int ncx;
        !          9598:     node_class nclass;
        !          9599: 
        !          9600:     error = 0;
        !          9601: 
        !          9602:     if (! map_initialized) {
        !          9603:        map_initialized = 1 ;
        !          9604:        for(ncx = 0; ncx < sizeof (token_classes) / sizeof (token_class);
        !          9605:            ncx ++)
        !          9606:            token_to_class_map[token_classes[ncx].token]
        !          9607:                = token_classes[ncx].nclass;
        !          9608:     }
        !          9609: 
        !          9610:     if (!((node->base > 0) && (node->base < DUMMY_LAST_NODE))) {
        !          9611:        error = 1;
        !          9612:        return nc_unused;
        !          9613:     }
        !          9614: 
        !          9615:     nclass = token_to_class_map[node->base];
        !          9616: 
        !          9617:     switch(nclass) {
        !          9618:       case nc_fct:
        !          9619:       case nc_name:
        !          9620:        if(node->baseclass) nclass = nc_baseclass;
        !          9621:     }
        !          9622: 
        !          9623:     return nclass;
        !          9624: }
        !          9625: 
        !          9626: node_class classify_node (Pnode node)
        !          9627: {
        !          9628:     int err;
        !          9629:     node_class nclass = classify_node (node, err);
        !          9630:     if(err) error ('i', "failed to classify node.");
        !          9631:     return nclass;
        !          9632: }
        !          9633: 0707071010112045771004440001630000160000010210700466055414600001200000041601doprint.c/* ident "@(#)ctrans:src/doprint.c       1.2" */
        !          9634: /*
        !          9635:  ************* obviously, have to do something here!!!
        !          9636: 
        !          9637:  * Copyright (c) 1988 Regents of the University of California.
        !          9638:  * All rights reserved.
        !          9639:  *
        !          9640:  * Redistribution and use in source and binary forms are permitted
        !          9641:  * provided that the above copyright notice and this paragraph are
        !          9642:  * duplicated in all such forms and that any documentation,
        !          9643:  * advertising materials, and other materials related to such
        !          9644:  * distribution and use acknowledge that the software was developed
        !          9645:  * by the University of California, Berkeley.  The name of the
        !          9646:  * University may not be used to endorse or promote products derived
        !          9647:  * from this software without specific prior written permission.
        !          9648:  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
        !          9649:  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
        !          9650:  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
        !          9651:  */
        !          9652: 
        !          9653: /*
        !          9654:     $Header: /usr2/odi/lib.src/RCS/doprint.C,v 1.3 89/09/19 12:00:34 benson Exp $
        !          9655: 
        !          9656:     Copyright (c) 1989 by Object Design, Inc., Burlington, Mass.
        !          9657:     All rights reserved.
        !          9658: 
        !          9659: */
        !          9660: 
        !          9661: #include <sys/types.h>
        !          9662: #include <stdarg.h>
        !          9663: #include <ctype.h>
        !          9664: #include <iostream.h>
        !          9665: #include <strstream.h>
        !          9666: #include <memory.h>
        !          9667: #include <math.h>
        !          9668: #include <string.h>
        !          9669: #include "print_self.h"
        !          9670: 
        !          9671: /* 11-bit exponent (VAX G floating point) is 308 decimal digits */
        !          9672: #define        MAXEXP          308
        !          9673: /* 128 bit fraction takes up 39 decimal digits; max reasonable precision */
        !          9674: #define        MAXFRACT        39
        !          9675: 
        !          9676: #define        DEFPREC         6
        !          9677: 
        !          9678: #define        BUF             (MAXEXP+MAXFRACT+1)     /* + decimal point */
        !          9679: 
        !          9680: #define        PUTC(ch)        (void) fp.put(ch)
        !          9681: 
        !          9682: #define        ARG() \
        !          9683:        _ulong = flags&LONGINT ? va_arg(argp, long) : \
        !          9684:            flags&SHORTINT ? va_arg(argp, short) : va_arg(argp, int);
        !          9685: 
        !          9686: #define        todigit(c)      ((c) - '0')
        !          9687: #define        tochar(n)       ((n) + '0')
        !          9688: 
        !          9689: #define        LONGINT         0x01            /* long integer */
        !          9690: #define        LONGDBL         0x02            /* long double; unimplemented */
        !          9691: #define        SHORTINT        0x04            /* short integer */
        !          9692: #define        ALT             0x08            /* alternate form */
        !          9693: #define        LADJUST         0x10            /* left adjustment */
        !          9694: #define        ZEROPAD         0x20            /* zero (as opposed to blank) pad */
        !          9695: #define        HEXPREFIX       0x40            /* add 0x or 0X prefix */
        !          9696: 
        !          9697: 
        !          9698: static char * exponent(char * p, int exp, u_char fmtch);
        !          9699: static char * round(double fract,
        !          9700:                    int * exp,
        !          9701:                    char * start,
        !          9702:                    char * end,
        !          9703:                    char ch,
        !          9704:                    char * signp);
        !          9705: 
        !          9706: 
        !          9707: 
        !          9708: static
        !          9709: cvt(double number,
        !          9710:     register int prec,
        !          9711:     int flags,
        !          9712:     char * signp,
        !          9713:     u_char fmtch,
        !          9714:     char * startp,
        !          9715:     char * endp)
        !          9716: {
        !          9717:     register char *p, *t;
        !          9718:     register double fract;
        !          9719:     int dotrim, expcnt, gformat;
        !          9720:     double integer, tmp;
        !          9721: 
        !          9722:     dotrim = expcnt = gformat = 0;
        !          9723:     fract = modf(number, &integer);
        !          9724: 
        !          9725:     /* get an extra slot for rounding. */
        !          9726:     t = ++startp;
        !          9727: 
        !          9728:     /*
        !          9729:        * get integer portion of number; put into the end of the buffer; the
        !          9730:            * .01 is added for modf(356.0 / 10, &integer) returning .59999999...
        !          9731:                */
        !          9732:     for (p = endp - 1; integer; ++expcnt) {
        !          9733:        tmp = modf(integer / 10, &integer);
        !          9734:        *p-- = tochar((int)((tmp + .01) * 10));
        !          9735:     }
        !          9736:     switch(fmtch) {
        !          9737:     case 'f':
        !          9738:        /* reverse integer into beginning of buffer */
        !          9739:        if (expcnt)
        !          9740:            for (; ++p < endp; *t++ = *p);
        !          9741:        else
        !          9742:            *t++ = '0';
        !          9743:        /*
        !          9744:            * if precision required or alternate flag set, add in a
        !          9745:                * decimal point.
        !          9746:                    */
        !          9747:        if (prec || flags&ALT)
        !          9748:            *t++ = '.';
        !          9749:        /* if requires more precision and some fraction left */
        !          9750:        if (fract) {
        !          9751:            if (prec)
        !          9752:                do {
        !          9753:                    fract = modf(fract * 10, &tmp);
        !          9754:                    *t++ = tochar((int)tmp);
        !          9755:                } while (--prec && fract);
        !          9756:            if (fract)
        !          9757:                startp = round(fract, (int *)NULL, startp,
        !          9758:                               t - 1, (char)0, signp);
        !          9759:        }
        !          9760:        for (; prec--; *t++ = '0');
        !          9761:        break;
        !          9762:     case 'e':
        !          9763:     case 'E':
        !          9764:       eformat: if (expcnt) {
        !          9765:          *t++ = *++p;
        !          9766:          if (prec || flags&ALT)
        !          9767:              *t++ = '.';
        !          9768:          /* if requires more precision and some integer left */
        !          9769:          for (; prec && ++p < endp; --prec)
        !          9770:              *t++ = *p;
        !          9771:          /*
        !          9772:              * if done precision and more of the integer component,
        !          9773:          * round using it; adjust fract so we don't re-round
        !          9774:              * later.
        !          9775:                  */
        !          9776:          if (!prec && ++p < endp) {
        !          9777:              fract = 0;
        !          9778:              startp = round((double)0, &expcnt, startp,
        !          9779:                             t - 1, *p, signp);
        !          9780:          }
        !          9781:          /* adjust expcnt for digit in front of decimal */
        !          9782:          --expcnt;
        !          9783:       }
        !          9784:        /* until first fractional digit, decrement exponent */
        !          9785:       else if (fract) {
        !          9786:          /* adjust expcnt for digit in front of decimal */
        !          9787:          for (expcnt = -1;; --expcnt) {
        !          9788:              fract = modf(fract * 10, &tmp);
        !          9789:              if (tmp)
        !          9790:                  break;
        !          9791:          }
        !          9792:          *t++ = tochar((int)tmp);
        !          9793:          if (prec || flags&ALT)
        !          9794:              *t++ = '.';
        !          9795:       }
        !          9796:       else {
        !          9797:          *t++ = '0';
        !          9798:          if (prec || flags&ALT)
        !          9799:              *t++ = '.';
        !          9800:       }
        !          9801:        /* if requires more precision and some fraction left */
        !          9802:        if (fract) {
        !          9803:            if (prec)
        !          9804:                do {
        !          9805:                    fract = modf(fract * 10, &tmp);
        !          9806:                    *t++ = tochar((int)tmp);
        !          9807:                } while (--prec && fract);
        !          9808:            if (fract)
        !          9809:                startp = round(fract, &expcnt, startp,
        !          9810:                               t - 1, (char)0, signp);
        !          9811:        }
        !          9812:        /* if requires more precision */
        !          9813:        for (; prec--; *t++ = '0');
        !          9814: 
        !          9815:        /* unless alternate flag, trim any g/G format trailing 0's */
        !          9816:        if (gformat && !(flags&ALT)) {
        !          9817:            while (t > startp && *--t == '0');
        !          9818:            if (*t == '.')
        !          9819:                --t;
        !          9820:            ++t;
        !          9821:        }
        !          9822:        t = exponent(t, expcnt, fmtch);
        !          9823:        break;
        !          9824:     case 'g':
        !          9825:     case 'G':
        !          9826:        /* a precision of 0 is treated as a precision of 1. */
        !          9827:        if (!prec)
        !          9828:            ++prec;
        !          9829:        /*
        !          9830:            * ``The style used depends on the value converted; style e
        !          9831:                * will be used only if the exponent resulting from the
        !          9832:                    * conversion is less than -4 or greater than the precision.''
        !          9833:                        *       -- ANSI X3J11
        !          9834:                            */
        !          9835:        if (expcnt > prec || !expcnt && fract && fract < .0001) {
        !          9836:            /*
        !          9837:                * g/G format counts "significant digits, not digits of
        !          9838:                         * precision; for the e/E format, this just causes an
        !          9839:                         * off-by-one problem, i.e. g/G considers the digit
        !          9840:                         * before the decimal point significant and e/E doesn't
        !          9841:                         * count it as precision."
        !          9842:                             */
        !          9843:            --prec;
        !          9844:            fmtch -= 2;         /* G->E, g->e */
        !          9845:            gformat = 1;
        !          9846:            goto eformat;
        !          9847:        }
        !          9848:        /*
        !          9849:            * reverse integer into beginning of buffer,
        !          9850:        * note, decrement precision
        !          9851:            */
        !          9852:        if (expcnt)
        !          9853:            for (; ++p < endp; *t++ = *p, --prec);
        !          9854:        else
        !          9855:            *t++ = '0';
        !          9856:        /*
        !          9857:            * if precision required or alternate flag set, add in a
        !          9858:                * decimal point.  If no digits yet, add in leading 0.
        !          9859:                    */
        !          9860:        if (prec || flags&ALT) {
        !          9861:            dotrim = 1;
        !          9862:            *t++ = '.';
        !          9863:        }
        !          9864:        else
        !          9865:            dotrim = 0;
        !          9866:        /* if requires more precision and some fraction left */
        !          9867:        if (fract) {
        !          9868:            if (prec) {
        !          9869:                do {
        !          9870:                    fract = modf(fract * 10, &tmp);
        !          9871:                    *t++ = tochar((int)tmp);
        !          9872:                } while(!tmp);
        !          9873:                while (--prec && fract) {
        !          9874:                    fract = modf(fract * 10, &tmp);
        !          9875:                    *t++ = tochar((int)tmp);
        !          9876:                }
        !          9877:            }
        !          9878:            if (fract)
        !          9879:                startp = round(fract, (int *)NULL, startp,
        !          9880:                               t - 1, (char)0, signp);
        !          9881:        }
        !          9882:        /* alternate format, adds 0's for precision, else trim 0's */
        !          9883:        if (flags&ALT)
        !          9884:            for (; prec--; *t++ = '0');
        !          9885:        else if (dotrim) {
        !          9886:            while (t > startp && *--t == '0');
        !          9887:            if (*t != '.')
        !          9888:                ++t;
        !          9889:        }
        !          9890:     }
        !          9891:     return(t - startp);
        !          9892: }
        !          9893: 
        !          9894: static char * round(double fract,
        !          9895:                    int * exp,
        !          9896:                    char * start,
        !          9897:                    char * end,
        !          9898:                    char ch,
        !          9899:                    char * signp)
        !          9900: {
        !          9901:     double tmp;
        !          9902: 
        !          9903:     if (fract)
        !          9904:        (void)modf(fract * 10, &tmp);
        !          9905:     else
        !          9906:        tmp = todigit(ch);
        !          9907:     if (tmp > 4)
        !          9908:        for (;; --end) {
        !          9909:            if (*end == '.')
        !          9910:                --end;
        !          9911:            if (++*end <= '9')
        !          9912:                break;
        !          9913:            *end = '0';
        !          9914:            if (end == start) {
        !          9915:                if (exp) {      /* e/E; increment exponent */
        !          9916:                    *end = '1';
        !          9917:                    ++*exp;
        !          9918:                }
        !          9919:                else {          /* f; add extra digit */
        !          9920:                    *--end = '1';
        !          9921:                    --start;
        !          9922:                }
        !          9923:                break;
        !          9924:            }
        !          9925:        }
        !          9926:     /* ``"%.3f", (double)-0.0004'' gives you a negative 0. */
        !          9927:     else if (*signp == '-')
        !          9928:        for (;; --end) {
        !          9929:            if (*end == '.')
        !          9930:                --end;
        !          9931:            if (*end != '0')
        !          9932:                break;
        !          9933:            if (end == start)
        !          9934:                *signp = 0;
        !          9935:        }
        !          9936:     return(start);
        !          9937: }
        !          9938: 
        !          9939: static char * exponent(char * p, int exp, u_char fmtch)
        !          9940: {
        !          9941:     register char *t;
        !          9942:     char expbuf[MAXEXP];
        !          9943: 
        !          9944:     *p++ = fmtch;
        !          9945:     if (exp < 0) {
        !          9946:        exp = -exp;
        !          9947:        *p++ = '-';
        !          9948:     }
        !          9949:     else
        !          9950:        *p++ = '+';
        !          9951:     t = expbuf + MAXEXP;
        !          9952:     if (exp > 9) {
        !          9953:        do {
        !          9954:            *--t = tochar(exp % 10);
        !          9955:        } while ((exp /= 10) > 9);
        !          9956:        *--t = tochar(exp);
        !          9957:        for (; t < expbuf + MAXEXP; *p++ = *t++);
        !          9958:     }
        !          9959:     else {
        !          9960:        *p++ = '0';
        !          9961:        *p++ = tochar(exp);
        !          9962:     }
        !          9963:     return(p);
        !          9964: }
        !          9965: 
        !          9966: int vostream_printf(const char *fmt0, va_list argp, ostream& fp)
        !          9967: {
        !          9968:     register const u_char *fmt;        /* format string */
        !          9969:     register int ch;           /* character from fmt */
        !          9970:     register int cnt;          /* return value accumulator */
        !          9971:     register int n;            /* random handy integer */
        !          9972:     register char *t;          /* buffer pointer */
        !          9973:     double _double;            /* double precision arguments %[eEfgG] */
        !          9974:     u_long _ulong;             /* integer arguments %[diouxX] */
        !          9975:     int base;                  /* base for [diouxX] conversion */
        !          9976:     int dprec;                 /* decimal precision in [diouxX] */
        !          9977:     int fieldsz;               /* field size expanded by sign, etc */
        !          9978:     int flags;                 /* flags as above */
        !          9979:     int fpprec;                        /* `extra' floating precision in [eEfgG] */
        !          9980:     int prec;                  /* precision from format (%.3d), or -1 */
        !          9981:     int realsz;                        /* field size expanded by decimal precision */
        !          9982:     int size;                  /* size of converted field or string */
        !          9983:     int width;                 /* width from format (%8d), or 0 */
        !          9984:     char sign;                 /* sign prefix (' ', '+', '-', or \0) */
        !          9985:     char softsign;             /* temporary negative sign for floats */
        !          9986:     char *digs;                        /* digits for [diouxX] conversion */
        !          9987:     char buf[BUF];             /* space for %c, %[diouxX], %[eEfgG] */
        !          9988: 
        !          9989:     fmt = (const u_char *)fmt0;
        !          9990:     digs = "0123456789abcdef";
        !          9991:     for (cnt = 0;; ++fmt) {
        !          9992:        for (;(ch = *fmt) && ch != '%'; ++cnt, ++fmt)
        !          9993:            PUTC(ch);
        !          9994:        if (!ch)return (cnt);
        !          9995: 
        !          9996:        flags = 0; dprec = 0; fpprec = 0; width = 0;
        !          9997:        prec = -1;
        !          9998:        sign = '\0';
        !          9999: 
        !          10000:       rflag:           switch (*++fmt) {
        !          10001:        case ' ':
        !          10002:          /*
        !          10003:           * ``If the space and + flags both appear, the space
        !          10004:           * flag will be ignored.''
        !          10005:           *    -- ANSI X3J11
        !          10006:           */
        !          10007:          if (!sign)
        !          10008:              sign = ' ';
        !          10009:          goto rflag;
        !          10010:        case '#':
        !          10011:          flags |= ALT;
        !          10012:          goto rflag;
        !          10013:        case '*':
        !          10014:          /*
        !          10015:           * ``A negative field width argument is taken as a
        !          10016:           * - flag followed by a  positive field width.''
        !          10017:           *    -- ANSI X3J11
        !          10018:           * They don't exclude field widths read from args.
        !          10019:           */
        !          10020:          if ((width = va_arg(argp, int)) >= 0)
        !          10021:              goto rflag;
        !          10022:          width = -width;
        !          10023:          /* FALLTHROUGH */
        !          10024:        case '-':
        !          10025:          flags |= LADJUST;
        !          10026:          goto rflag;
        !          10027:        case '+':
        !          10028:          sign = '+';
        !          10029:          goto rflag;
        !          10030:        case '.':
        !          10031:          if (*++fmt == '*')
        !          10032:              n = va_arg(argp, int);
        !          10033:          else {
        !          10034:              n = 0;
        !          10035:              while (isascii(*fmt) && isdigit(*fmt))
        !          10036:                  n = 10 * n + todigit(*fmt++);
        !          10037:              --fmt;
        !          10038:          }
        !          10039:          prec = n < 0 ? -1 : n;
        !          10040:          goto rflag;
        !          10041:        case '0':
        !          10042:          /*
        !          10043:           * ``Note that 0 is taken as a flag, not as the
        !          10044:           * beginning of a field width.''
        !          10045:           *    -- ANSI X3J11
        !          10046:           */
        !          10047:          flags |= ZEROPAD;
        !          10048:          goto rflag;
        !          10049:        case '1': case '2': case '3': case '4':
        !          10050:        case '5': case '6': case '7': case '8': case '9':
        !          10051:          n = 0;
        !          10052:          do {
        !          10053:              n = 10 * n + todigit(*fmt);
        !          10054:          } while (isascii(*++fmt) && isdigit(*fmt));
        !          10055:          width = n;
        !          10056:          --fmt;
        !          10057:          goto rflag;
        !          10058:        case 'L':
        !          10059:          flags |= LONGDBL;
        !          10060:          goto rflag;
        !          10061:        case 'h':
        !          10062:          flags |= SHORTINT;
        !          10063:          goto rflag;
        !          10064:        case 'l':
        !          10065:          flags |= LONGINT;
        !          10066:          goto rflag;
        !          10067:        case 'c':
        !          10068:          *(t = buf) = va_arg(argp, int);
        !          10069:          size = 1;
        !          10070:          sign = '\0';
        !          10071:          goto pforw;
        !          10072:        case 'D':
        !          10073:          flags |= LONGINT;
        !          10074:          /*FALLTHROUGH*/
        !          10075:        case 'd':
        !          10076:        case 'i':
        !          10077:          ARG();
        !          10078:          if ((long)_ulong < 0) {
        !          10079:              _ulong = -_ulong;
        !          10080:              sign = '-';
        !          10081:          }
        !          10082:          base = 10;
        !          10083:          goto number;
        !          10084:        case 'e':
        !          10085:        case 'E':
        !          10086:        case 'f':
        !          10087:        case 'g':
        !          10088:        case 'G':
        !          10089:          _double = va_arg(argp, double);
        !          10090:          /*
        !          10091:           * don't do unrealistic precision; just pad it with
        !          10092:           * zeroes later, so buffer size stays rational.
        !          10093:           */
        !          10094:          if (prec > MAXFRACT) {
        !          10095:              if (*fmt != 'g' && *fmt != 'G' || (flags&ALT))
        !          10096:                  fpprec = prec - MAXFRACT;
        !          10097:              prec = MAXFRACT;
        !          10098:          }
        !          10099:          else if (prec == -1)
        !          10100:              prec = DEFPREC;
        !          10101:          /*
        !          10102:           * softsign avoids negative 0 if _double is < 0 and
        !          10103:           * no significant digits will be shown
        !          10104:           */
        !          10105:          if (_double < 0) {
        !          10106:              softsign = '-';
        !          10107:              _double = -_double;
        !          10108:          }
        !          10109:          else
        !          10110:              softsign = 0;
        !          10111:          /*
        !          10112:           * cvt may have to round up past the "start" of the
        !          10113:           * buffer, i.e. ``intf("%.2f", (double)9.999);'';
        !          10114:           * if the first char isn't NULL, it did.
        !          10115:           */
        !          10116:          *buf = NULL;
        !          10117:          size = cvt(_double, prec, flags, &softsign, *fmt, buf,
        !          10118:                     buf + sizeof(buf));
        !          10119:          if (softsign)
        !          10120:              sign = '-';
        !          10121:          t = *buf ? buf : buf + 1;
        !          10122:          goto pforw;
        !          10123:        case 'n':
        !          10124:          if (flags & LONGINT)
        !          10125:              *va_arg(argp, long *) = cnt;
        !          10126:          else if (flags & SHORTINT)
        !          10127:              *va_arg(argp, short *) = cnt;
        !          10128:          else
        !          10129:              *va_arg(argp, int *) = cnt;
        !          10130:          break;
        !          10131:        case 'O':
        !          10132:          flags |= LONGINT;
        !          10133:          /*FALLTHROUGH*/
        !          10134:        case 'o':
        !          10135:          ARG();
        !          10136:          base = 8;
        !          10137:          goto nosign;
        !          10138:        case 'T':               // Type
        !          10139:          {
        !          10140:              streampos cur_pos;
        !          10141:              streampos new_pos;
        !          10142: 
        !          10143:              cur_pos = fp.tellp();
        !          10144: 
        !          10145:              _Print_self * obj = va_arg (argp, _Print_self *);
        !          10146:              obj->print_self (fp);
        !          10147: 
        !          10148:              new_pos = fp.tellp();
        !          10149:                
        !          10150:              cnt += int (new_pos - cur_pos);
        !          10151:          }
        !          10152:          break;
        !          10153: 
        !          10154:        case 'p':
        !          10155:          /*
        !          10156:           * ``The argument shall be a pointer to void.  The
        !          10157:           * value of the pointer is converted to a sequence
        !          10158:           * of printable characters, in an implementation-
        !          10159:           * defined manner.''
        !          10160:           *    -- ANSI X3J11
        !          10161:           */
        !          10162:          /* NOSTRICT */
        !          10163:          _ulong = (u_long)va_arg(argp, void *);
        !          10164:          base = 16;
        !          10165:          goto nosign;
        !          10166:        case 's':
        !          10167:          if (!(t = va_arg(argp, char *)))
        !          10168:              t = "(null)";
        !          10169:          if (prec >= 0) {
        !          10170:              /*
        !          10171:               * can't use strlen; can only look for the
        !          10172:               * NUL in the first `prec' characters, and
        !          10173:               * strlen() will go further.
        !          10174:               */
        !          10175:              char *p;
        !          10176: 
        !          10177:              if (p = (char *) memchr(t, 0, prec)) {
        !          10178:                  size = p - t;
        !          10179:                  if (size > prec)
        !          10180:                      size = prec;
        !          10181:              } else
        !          10182:                  size = prec;
        !          10183:          } else
        !          10184:              size = strlen(t);
        !          10185:          sign = '\0';
        !          10186:          goto pforw;
        !          10187:        case 'U':
        !          10188:          flags |= LONGINT;
        !          10189:          /*FALLTHROUGH*/
        !          10190:        case 'u':
        !          10191:          ARG();
        !          10192:          base = 10;
        !          10193:          goto nosign;
        !          10194:        case 'X':
        !          10195:          digs = "0123456789ABCDEF";
        !          10196:          /* FALLTHROUGH */
        !          10197:        case 'x':
        !          10198:          ARG();
        !          10199:          base = 16;
        !          10200:          /* leading 0x/X only if non-zero */
        !          10201:          if (flags & ALT && _ulong != 0)
        !          10202:              flags |= HEXPREFIX;
        !          10203: 
        !          10204:          /* unsigned conversions */
        !          10205:        nosign:                 sign = '\0';
        !          10206:          /*
        !          10207:           * ``... diouXx conversions ... if a precision is
        !          10208:           * specified, the 0 flag will be ignored.''
        !          10209:           *    -- ANSI X3J11
        !          10210:           */
        !          10211:        number:                 if ((dprec = prec) >= 0)
        !          10212:            flags &= ~ZEROPAD;
        !          10213: 
        !          10214:          /*
        !          10215:           * ``The result of converting a zero value with an
        !          10216:           * explicit precision of zero is no characters.''
        !          10217:           *    -- ANSI X3J11
        !          10218:           */
        !          10219:          t = buf + BUF;
        !          10220:          if (_ulong != 0 || prec != 0) {
        !          10221:              do {
        !          10222:                  *--t = digs[_ulong % base];
        !          10223:                  _ulong /= base;
        !          10224:              } while (_ulong);
        !          10225:              digs = "0123456789abcdef";
        !          10226:              if (flags & ALT && base == 8 && *t != '0')
        !          10227:                  *--t = '0';   /* octal leading 0 */
        !          10228:          }
        !          10229:          size = buf + BUF - t;
        !          10230: 
        !          10231:        pforw:
        !          10232:          /*
        !          10233:           * All reasonable formats wind up here.  At this point,
        !          10234:           * `t' points to a string which (if not flags&LADJUST)
        !          10235:           * should be padded out to `width' places.  If
        !          10236:           * flags&ZEROPAD, it should first be prefixed by any
        !          10237:           * sign or other prefix; otherwise, it should be blank
        !          10238:           * padded before the prefix is emitted.  After any
        !          10239:           * left-hand padding and prefixing, emit zeroes
        !          10240:           * required by a decimal [diouxX] precision, then print
        !          10241:           * the string proper, then emit zeroes required by any
        !          10242:           * leftover floating precision; finally, if LADJUST,
        !          10243:           * pad with blanks.
        !          10244:           */
        !          10245: 
        !          10246:          /*
        !          10247:           * compute actual size, so we know how much to pad
        !          10248:           * fieldsz excludes decimal prec; realsz includes it
        !          10249:           */
        !          10250:          fieldsz = size + fpprec;
        !          10251:          if (sign)
        !          10252:              fieldsz++;
        !          10253:          if (flags & HEXPREFIX)
        !          10254:              fieldsz += 2;
        !          10255:          realsz = dprec > fieldsz ? dprec : fieldsz;
        !          10256: 
        !          10257:          /* right-adjusting blank padding */
        !          10258:          if ((flags & (LADJUST|ZEROPAD)) == 0 && width)
        !          10259:              for (n = realsz; n < width; n++)
        !          10260:                  PUTC(' ');
        !          10261:          /* prefix */
        !          10262:          if (sign)
        !          10263:              PUTC(sign);
        !          10264:          if (flags & HEXPREFIX) {
        !          10265:              PUTC('0');
        !          10266:              PUTC((char)*fmt);
        !          10267:          }
        !          10268:          /* right-adjusting zero padding */
        !          10269:          if ((flags & (LADJUST|ZEROPAD)) == ZEROPAD)
        !          10270:              for (n = realsz; n < width; n++)
        !          10271:                  PUTC('0');
        !          10272:          /* leading zeroes from decimal precision */
        !          10273:          for (n = fieldsz; n < dprec; n++)
        !          10274:              PUTC('0');
        !          10275: 
        !          10276:          /* the string or number proper */
        !          10277: 
        !          10278:          fp.write(t, size);
        !          10279: 
        !          10280:          /* trailing f.p. zeroes */
        !          10281:          while (--fpprec >= 0)
        !          10282:              PUTC('0');
        !          10283:          /* left-adjusting padding (always blank) */
        !          10284:          if (flags & LADJUST)
        !          10285:              for (n = realsz; n < width; n++)
        !          10286:                  PUTC(' ');
        !          10287:          /* finally, adjust cnt */
        !          10288:          cnt += width > realsz ? width : realsz;
        !          10289:          break;
        !          10290:        case '\0':              /* "%?" prints ?, unless ? is NULL */
        !          10291:          return (cnt);
        !          10292:        default:
        !          10293:          PUTC(*fmt);
        !          10294:          cnt++;
        !          10295:       }
        !          10296:     }
        !          10297:     /* NOTREACHED */
        !          10298: }
        !          10299: 
        !          10300: int ostream_printf(ostream& stream, const char * format ...)
        !          10301: {
        !          10302:     int ret;
        !          10303: 
        !          10304:     va_list args;
        !          10305:     va_start(args, format);
        !          10306:     ret = vostream_printf(format, args, stream);
        !          10307:     va_end(args);
        !          10308:     return ret;
        !          10309: }
        !          10310: 
        !          10311: // There are intended to be more convienient that stirring up
        !          10312: // an strstream by hand.
        !          10313: 
        !          10314: int printf_to_string (char * string, int length, const char * format ...)
        !          10315: {
        !          10316:     ostrstream& stream = ostrstream (string, length, (ios::open_mode)ios::app);
        !          10317: 
        !          10318:     va_list args;
        !          10319:     va_start(args, format);
        !          10320: 
        !          10321:     vostream_printf (format, args, stream);
        !          10322: 
        !          10323:     va_end(args);
        !          10324:     stream.str();
        !          10325:     return stream.pcount();
        !          10326: }
        !          10327: 
        !          10328: // caller of this must free() the string that comes back. 
        !          10329: 
        !          10330: char * printf_to_alloc_string (const char * format ...)
        !          10331: {
        !          10332:     ostrstream& stream = ostrstream ();
        !          10333: 
        !          10334:     va_list args;
        !          10335:     va_start(args, format);
        !          10336: 
        !          10337:     vostream_printf (format, args, stream);
        !          10338: 
        !          10339:     va_end(args);
        !          10340:     return stream.str();
        !          10341: }
        !          10342: 0707071010112044141004440001630000160000010176000466055377500001000000031505error.c/*ident    "@(#)ctrans:src/error.c 1.4" */
        !          10343: /**************************************************************************
        !          10344: 
        !          10345:        C++ source for cfront, the C++ compiler front-end
        !          10346:        written in the computer science research center of Bell Labs
        !          10347: 
        !          10348:        Copyright (c) 1984 AT&T, Inc. All Rights Reserved
        !          10349:        THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T, INC.
        !          10350: 
        !          10351:  error.c :
        !          10352: 
        !          10353:        write error messages
        !          10354: 
        !          10355:        Until scan_started != 0 no context can be assumed
        !          10356: 
        !          10357: ***************************************************************************/
        !          10358: 
        !          10359: #ifdef __cplusplus
        !          10360: #include <stdlib.h>
        !          10361: #endif
        !          10362: 
        !          10363: #include "cfront.h"
        !          10364: #include "size.h"
        !          10365: #include "template.h"
        !          10366: 
        !          10367: int error_count;
        !          10368: static int no_of_warnings;
        !          10369: char scan_started;
        !          10370: 
        !          10371: #define ERRTRACE    20
        !          10372: 
        !          10373: static char* abbrev_tbl[] = {
        !          10374:        " argument",
        !          10375:        " base",
        !          10376:        " class",
        !          10377:        " declaration",
        !          10378:        " expression",
        !          10379:        " function",
        !          10380:        " global",
        !          10381:        "H",
        !          10382:        " initialize",
        !          10383:        "J",
        !          10384:        " constructor", // 'K' !
        !          10385:        " list",
        !          10386:        " member",
        !          10387:        " name",
        !          10388:        " object",
        !          10389:        " pointer",
        !          10390:        " qualifie",
        !          10391:        " reference",
        !          10392:        " statement",
        !          10393:        " type",
        !          10394:        " undefined",
        !          10395:        " variable",
        !          10396:        " with",
        !          10397:        " expected", // 'X'
        !          10398:        " template", // 'Y'???
        !          10399:        " parameter", // 'Z'???
        !          10400: };
        !          10401: 
        !          10402: ea* ea0;
        !          10403: 
        !          10404: void error_init()
        !          10405: {
        !          10406:        static char errbuf[BUFSIZ];
        !          10407:        setbuf(stderr,errbuf);
        !          10408:        ea0 = new ea;
        !          10409: }
        !          10410: 
        !          10411: #define INTERNAL 127
        !          10412: 
        !          10413: void ext(int n)
        !          10414: {
        !          10415:        int useit=n; // to avoid n not used warning during build
        !          10416: // for testing only
        !          10417: //     if (n == INTERNAL)
        !          10418: //     abort();
        !          10419:        exit(error_count?error_count:1);
        !          10420: }
        !          10421: 
        !          10422: /* static */ 
        !          10423: void print_loc()
        !          10424: {
        !          10425:        loc* sl = (Cstmt) ? &Cstmt->where : 0;
        !          10426:        loc* dl = (Cdcl && (Cdcl->base==NAME || Cdcl->base==TNAME)) ? &Cdcl->where : 0;
        !          10427:        if (sl && dl && sl->file==dl->file) {   // Cstmt and Cdcl in same file
        !          10428:                if (sl->line<=dl->line) {
        !          10429:                        if (curloc.file==dl->file && curloc.line<dl->line)
        !          10430:                                // hack to compensate for YACC's
        !          10431:                                // bad manners in the use of line numbers
        !          10432:                                sl->put(out_file);
        !          10433:                        else
        !          10434:                                dl->put(out_file);
        !          10435:                }
        !          10436:                else
        !          10437:                        sl->put(out_file);
        !          10438:        }
        !          10439:        else if (sl && sl->file==curr_file)     // Cstmt in current file
        !          10440:                sl->put(out_file);
        !          10441:        else if (dl && dl->file==curr_file)     // Cdcl in current file
        !          10442:                dl->put(out_file);
        !          10443:        else
        !          10444:                curloc.put(out_file);
        !          10445: }
        !          10446: 
        !          10447: static void print_context()
        !          10448: {
        !          10449:        putc('\n',out_file);
        !          10450: }
        !          10451: 
        !          10452: static char in_error = 0;
        !          10453: static loc dummy_loc;
        !          10454: 
        !          10455: void yyerror(char* s)
        !          10456: {
        !          10457:        error(s);
        !          10458: }
        !          10459: 
        !          10460: int error(const char* s)
        !          10461: {
        !          10462:        return error(0,s);
        !          10463: }
        !          10464: 
        !          10465: int error(int t, const char* s)
        !          10466: {
        !          10467:        return error(t,&dummy_loc,s,*ea0,*ea0,*ea0,*ea0);
        !          10468: }
        !          10469: 
        !          10470: int error(const char* s, const ea& a0, const ea& a1, const ea& a2, const ea& a3)
        !          10471: {
        !          10472:        return error(0,&dummy_loc,s,a0,a1,a2,a3);
        !          10473: }
        !          10474: 
        !          10475: int error(loc* lc, const char* s, const ea& a0, const ea& a1, const ea& a2, const ea& a3)
        !          10476: {
        !          10477:        return error(0,lc,s,a0,a1,a2,a3);
        !          10478: }
        !          10479: 
        !          10480: int error(int t, const char* s, const ea& a0, const ea& a1, const ea& a2, const ea& a3)
        !          10481: {
        !          10482:        return error(t,&dummy_loc,s,a0,a1,a2,a3);
        !          10483: }
        !          10484: 
        !          10485: int suppress_error;
        !          10486: 
        !          10487: int error(int t, loc* lc, const char* s, const ea& a0, const ea& a1, const ea& a2, const ea& a3)
        !          10488: /*
        !          10489:        "int" not "void" because of "pch" in lex.c
        !          10490: 
        !          10491:        legal error types are:
        !          10492:                'w'             warning  (not counted in error count)
        !          10493:                'd'             debug
        !          10494:                'D'             debug -- no prefix
        !          10495:                's'             "not implemented" message
        !          10496:                'l'             "compiler limit exceeded" message
        !          10497:                0               error 
        !          10498:                'i'             internal error (causes abort)
        !          10499:                't'             error while printing error message
        !          10500: */
        !          10501: {
        !          10502:        if (suppress_error) return 0;
        !          10503: 
        !          10504:        if (in_error++)
        !          10505:                if (t == 't')
        !          10506:                        t = 'i';
        !          10507:                else if (4 < in_error) {
        !          10508:                        fprintf(stderr,"\nOops!, error while handling error\n");
        !          10509:                        ext(13);
        !          10510:                }
        !          10511: 
        !          10512:        FILE * of = out_file;
        !          10513:        out_file = stderr;
        !          10514: 
        !          10515:        if (!scan_started || t=='t')
        !          10516:                putch('\n');
        !          10517:        else if (lc != &dummy_loc) {
        !          10518:                if(t != 'D') lc->put(out_file);
        !          10519:        } else {
        !          10520:                if(t != 'D') print_loc();
        !          10521:        }
        !          10522: 
        !          10523:        switch (t) {
        !          10524:        case 0:
        !          10525:                putstring("error: ");
        !          10526:                break;
        !          10527:         case 'd':
        !          10528:                putstring("DEBUG: ");
        !          10529:         case 'D':
        !          10530:                break;
        !          10531:         case 'w':
        !          10532:                no_of_warnings++;
        !          10533:                putstring("warning: ");
        !          10534:                break;
        !          10535:         case 'l':
        !          10536:                putstring("compiler limit exceeded: ");
        !          10537:                break;
        !          10538:         case 's':
        !          10539:                putstring("sorry, not implemented: ");
        !          10540:                break;
        !          10541:         case 'i':
        !          10542:                if (error_count++) {
        !          10543:                        fprintf(out_file,"sorry, %s cannot recover from earlier errors\n",prog_name);
        !          10544:                        ext(INTERNAL);
        !          10545:                }
        !          10546:                else
        !          10547:                        fprintf(out_file,"internal %s error: ",prog_name);
        !          10548:         }
        !          10549: 
        !          10550:        ea argv[4];
        !          10551:        ea* a = argv;
        !          10552:        argv[0] = a0;
        !          10553:        argv[1] = a1;
        !          10554:        argv[2] = a2;
        !          10555:        argv[3] = a3;
        !          10556: 
        !          10557:        int c;
        !          10558: 
        !          10559:        while (c = *s++) {
        !          10560:                if ('A'<=c && c<='Z')
        !          10561:                        putstring(abbrev_tbl[c-'A']);
        !          10562:                else if (c == '%') {
        !          10563:                        switch (c = *s++) {
        !          10564:                        case 'k':       // TOK assumed passed as an int
        !          10565:                        {       TOK x = TOK(a->i);
        !          10566:                                if (0<x && x<=MAXTOK && keys[x])
        !          10567:                                        fprintf(out_file," %s",keys[x]);
        !          10568:                                else
        !          10569:                                        fprintf(out_file," token(%d)",x);
        !          10570:                                break;
        !          10571:                        }
        !          10572:                        case 't':       // Ptype 
        !          10573:                        {       Ptype tt = Ptype(a->p);
        !          10574:                                if (tt == 0) break;
        !          10575: 
        !          10576:                                putch(' ');
        !          10577:                        
        !          10578:                                int nt = ntok;
        !          10579:                                emode = 1;
        !          10580:                                tt->dcl_print(0);
        !          10581:                                emode = 0;
        !          10582:                                ntok = nt;
        !          10583:                                break;
        !          10584:                        }
        !          10585:                        case 'n':       // Pname
        !          10586:                        {       Pname nn = Pname(a->p);
        !          10587:                                if (nn && nn->string) {
        !          10588:                                        // suppress generated class names:
        !          10589:                                        if (nn->string[0]=='_'
        !          10590:                                        && nn->string[1]=='_'
        !          10591:                                        && nn->string[2]=='C') break;
        !          10592:                                        emode = 1;
        !          10593:                                        putch(' ');
        !          10594:                                        nn->print();
        !          10595:                                        emode = 0;
        !          10596:                                }
        !          10597:                                else
        !          10598:                                        putstring(" ?");
        !          10599:                                break;
        !          10600:                        }
        !          10601:                        case 'p':       // pointer
        !          10602:                        {       char* f = sizeof(char*)==sizeof(int)?" %d":" %ld";
        !          10603:                                fprintf(out_file,f,a->p);
        !          10604:                                break;
        !          10605:                        }
        !          10606:                        case 'c':       // char assumed passed as an int
        !          10607:                                putch(a->i);
        !          10608:                                break;
        !          10609: 
        !          10610:                        case 'd':       // int
        !          10611:                                fprintf(out_file," %d",a->i);
        !          10612:                                break;
        !          10613: 
        !          10614:                        case 'o':       // int
        !          10615:                                fprintf(out_file," %o",a->i);
        !          10616:                                break;
        !          10617: 
        !          10618:                        case 's':       // char*
        !          10619:                                char *s = ((char *)a->p);
        !          10620:                                if ( s ) putst((char*)a->p);
        !          10621:                                break;
        !          10622:                        }
        !          10623:                        a++;
        !          10624:                }
        !          10625:                else
        !          10626:                        putch(c);
        !          10627:        }
        !          10628: 
        !          10629: /*
        !          10630:        switch (t) {
        !          10631:        case 'd':
        !          10632:        case 't':
        !          10633:        case 'w':
        !          10634:                putch('\n');
        !          10635:                break;
        !          10636:        default:
        !          10637: */
        !          10638:                print_context();
        !          10639: /*
        !          10640:        }
        !          10641: */
        !          10642: 
        !          10643:         templ_inst::head->print_error_loc();
        !          10644:        fflush(stderr);
        !          10645:        if (!scan_started && t!='d' && t!='w') ext(4);
        !          10646: 
        !          10647:         // now we may want to carry on 
        !          10648:        out_file = of;
        !          10649:        switch (t) {
        !          10650:        case 't':
        !          10651:                if (--in_error) return 0;
        !          10652:        case 'i': 
        !          10653:                ext(INTERNAL);
        !          10654:        case 0:
        !          10655:        case 'l':
        !          10656:        case 's':
        !          10657:                if (MAXERR<++error_count) {
        !          10658:                        fprintf(stderr,"Sorry, too many errors\n");
        !          10659:                        ext(7);
        !          10660:                }
        !          10661:        }
        !          10662: 
        !          10663:        in_error = 0;
        !          10664:        return 0;
        !          10665: }
        !          10666: 
        !          10667: 
        !          10668: 
        !          10669: #ifdef DBG
        !          10670: #define OPEREP(v) ((v)>MAXTOK || (v)<=0 ? 0 : keys[v])
        !          10671: void
        !          10672: display_type( Ptype t )
        !          10673: {
        !          10674:        if ( t ) { putc(' ',stderr);
        !          10675:                FILE * of = out_file;
        !          10676:                out_file = stderr;
        !          10677:                extern int ntok; int nt = ntok;
        !          10678:                emode=1; (t)->dcl_print(0); emode=0;
        !          10679:                //fprintf(stderr," <node %d",t->node::id);
        !          10680:                if(!t->allocated)fprintf(stderr," UNALLOCATED!");
        !          10681:                //putc('>',stderr);
        !          10682:                ntok = nt;
        !          10683:                out_file = of;
        !          10684:        } else fprintf(stderr," <null type>");
        !          10685: }
        !          10686: #define INDENT(in) { for ( int i = in;  i > 0;  --i ) fprintf(stderr,"  "); }
        !          10687: static indent = 0;
        !          10688: 
        !          10689: void
        !          10690: display_expr( Pexpr ptr, char* label, int oneline )
        !          10691: {
        !          10692:        INDENT(indent);
        !          10693:        if ( label ) fprintf(stderr, "%s:", label);
        !          10694:        if ( ptr == 0 ) {
        !          10695:                fprintf(stderr, "NULL EXPR\n" );
        !          10696:                return;
        !          10697:        }
        !          10698:        fprintf(stderr,"%d",ptr->node::id);
        !          10699:        if(!ptr->allocated)fprintf(stderr," UNALLOCATED!");
        !          10700:        putc(':',stderr);
        !          10701:        char* s = OPEREP(ptr->base);
        !          10702:        if ( s == 0 )
        !          10703:                fprintf(stderr, "token(%d)", ptr->base );
        !          10704:        else
        !          10705:                fprintf(stderr,"%s",s);
        !          10706:        if ( ptr->displayed ) { // recursion!!!
        !          10707:                if ( ptr->base == NAME )
        !          10708:                        fprintf(stderr," '%s'",Pname(ptr)->string);
        !          10709:                fprintf(stderr,"   RECURSION!!!\n");
        !          10710:                ptr->displayed = 0;
        !          10711:                return;
        !          10712:        }
        !          10713:        ptr->displayed = 1;
        !          10714:        switch ( ptr->base ) {
        !          10715:        case QUEST:
        !          10716:                display_type(ptr->tp);
        !          10717:                putc('\n',stderr);
        !          10718:                if ( !oneline ) {
        !          10719:                        ++indent;
        !          10720:                        display_expr( ptr->cond, "cond" ); 
        !          10721:                        display_expr( ptr->e1, "e1" ); 
        !          10722:                        display_expr( ptr->e2, "e2" ); 
        !          10723:                        --indent;
        !          10724:                }
        !          10725:                break;
        !          10726:        case REF: case DOT:
        !          10727:                display_type(ptr->tp);
        !          10728:                putc('\n',stderr);
        !          10729:                if ( !oneline ) {
        !          10730:                        ++indent;
        !          10731:                        display_expr( ptr->e1, "e1" );
        !          10732:                        display_expr( ptr->mem, "mem" );
        !          10733:                        --indent;
        !          10734:                }
        !          10735:                break;
        !          10736:        case MDOT:
        !          10737:                display_type(ptr->tp);
        !          10738:                fprintf(stderr," string2:'%s'\n",ptr->string2?ptr->string2:"");
        !          10739:                if ( !oneline ) {
        !          10740:                        ++indent;
        !          10741:                        display_expr( ptr->mem, "mem" );
        !          10742:                        --indent;
        !          10743:                }
        !          10744:                break;
        !          10745:        case ICALL:
        !          10746:                fprintf(stderr," fn=='%s'",ptr->il->fct_name->string);
        !          10747:                display_type(ptr->tp);
        !          10748:                putc('\n',stderr);
        !          10749:                if ( !oneline ) {
        !          10750:                        ++indent;
        !          10751:                        for ( int i = 0;  i < ptr->il->i_slots;  ++i ) {
        !          10752:                                ia *aa = &ptr->il->i_args[i];
        !          10753:                                INDENT(indent);
        !          10754:                                fprintf(stderr,"arg:'%s'",aa->local&&aa->local->string?aa->local->string:"");
        !          10755:                                display_type(aa->tp);
        !          10756:                                putc('\n',stderr);
        !          10757:                                ++indent;
        !          10758:                                display_expr( aa->arg, "actual" );
        !          10759:                                --indent;
        !          10760:                        }
        !          10761:                        display_expr( ptr->e1, "e1" );
        !          10762:                        display_expr( ptr->e2, "e2" );
        !          10763:                        --indent;
        !          10764:                }
        !          10765:                break;
        !          10766:        case SIZEOF:
        !          10767:                if ( ptr->tp2 ) {
        !          10768:                        putc('(',stderr);
        !          10769:                        display_type(ptr->tp2);
        !          10770:                        putc(')',stderr);
        !          10771:                }
        !          10772:                display_type(ptr->tp);
        !          10773:                putc('\n',stderr);
        !          10774:                if ( !oneline ) {
        !          10775:                    if ( ptr->e1 ) {
        !          10776:                        ++indent;
        !          10777:                        display_expr(ptr->e1,"e1");
        !          10778:                        --indent;
        !          10779:                    }
        !          10780:                    if ( ptr->e2 ) {
        !          10781:                        ++indent;
        !          10782:                        display_expr(ptr->e2,"e2");
        !          10783:                        --indent;
        !          10784:                    }
        !          10785:                }
        !          10786:                break;
        !          10787:        case ZERO:
        !          10788:                display_type(ptr->tp);
        !          10789:                putc('\n',stderr);
        !          10790:                break;
        !          10791:        case NAME: case TNAME: case STRING:
        !          10792:        case ICON: case ID:
        !          10793:        case FCON: case CCON:
        !          10794:        case IVAL:
        !          10795:                fprintf(stderr," '%s'",(ptr->string)?ptr->string:"<0>");
        !          10796:                display_type(ptr->tp);
        !          10797:                if(ptr->string2)fprintf(stderr," string2=='%s'",ptr->string2);
        !          10798:                if ( ptr->permanent ) fprintf(stderr, " (permanent)");
        !          10799:                if ( ptr->base == IVAL ) fprintf(stderr, " i1==%d", ptr->i1);
        !          10800:                putc('\n',stderr);
        !          10801:                if ( !oneline && (ptr->base == NAME || ptr->base == TNAME) ) {
        !          10802:                        Pname n = Pname(ptr);
        !          10803:                        ++indent;
        !          10804:                        INDENT(indent);
        !          10805:                        fprintf(stderr, "n_sto==%d", n->n_sto );
        !          10806:                        fprintf(stderr, " n_stclass==%d",n->n_stclass);
        !          10807:                        fprintf(stderr, " n_scope==%d",n->n_scope);
        !          10808:                        fprintf(stderr, " n_protected==%d\n", n->n_protect );
        !          10809:                        INDENT(indent);
        !          10810:                        fprintf(stderr, "n_oper=='%s'", (s=OPEREP(n->base))?s:"0");
        !          10811:                        fprintf(stderr, " n_val==%d", n->n_val );
        !          10812:                        fprintf(stderr, " n_xref==%d",n->n_xref);
        !          10813:                        fprintf(stderr, " lex_level==%d\n", n->lex_level );
        !          10814:                        INDENT(indent);
        !          10815:                        fprintf(stderr, "n_used==%d",n->n_used);
        !          10816:                        fprintf(stderr, " n_assigned_to==%d",n->n_assigned_to);
        !          10817:                        fprintf(stderr, " n_addr_taken==%d\n",n->n_addr_taken );
        !          10818:                        INDENT(indent);
        !          10819:                        fprintf(stderr, "n_union==%d", n->n_union);
        !          10820:                        fprintf(stderr, " n_list=='%s'", n->n_list?n->n_list->string:"<0>" );
        !          10821:                        fprintf(stderr, " n_qualifier=='%s'", n->n_qualifier?n->n_qualifier->string:"<0>" ); 
        !          10822:                        if ( n->n_initializer ) {
        !          10823:                                fprintf(stderr, " n_initializer:\n" );
        !          10824:                                ++indent;
        !          10825:                                display_expr( n->n_initializer );
        !          10826:                                --indent;
        !          10827:                        } else fprintf(stderr, " n_initializer==<0>\n");
        !          10828:                        --indent;
        !          10829:                }
        !          10830:                break;
        !          10831:        case BLOCK:
        !          10832:                ((Pstmt)ptr)->where.put(stderr); putc(' ',stderr);
        !          10833:                putc('\n',stderr);
        !          10834:                break;
        !          10835:        default:
        !          10836:                display_type(ptr->tp);
        !          10837:                putc('\n',stderr);
        !          10838:                if ( !oneline && ptr->base > 0
        !          10839:                &&   (ptr->base<165 || ptr->base==MEMPTR) ) {
        !          10840:                        ++indent;
        !          10841:                        display_expr( ptr->e1, "e1" ); 
        !          10842:                        display_expr( ptr->e2, "e2" );
        !          10843:                        --indent;
        !          10844:                }
        !          10845:                break;
        !          10846:        }
        !          10847:        ptr->displayed = 0;
        !          10848:        return;
        !          10849: }
        !          10850: void
        !          10851: display_stmt( Pstmt ptr, char* label, int oneline )
        !          10852: {
        !          10853:        INDENT(indent);
        !          10854:        if ( label ) fprintf(stderr, "%s:", label);
        !          10855:        if ( ptr == 0 ) {
        !          10856:                fprintf(stderr, "NULL STMT\n" );
        !          10857:                return;
        !          10858:        }
        !          10859:        fprintf(stderr,"%d",ptr->node::id);
        !          10860:        if(!ptr->allocated)fprintf(stderr," UNALLOCATED!");
        !          10861:        putc(':',stderr);
        !          10862:        char* s = OPEREP(ptr->base);
        !          10863:        if ( s == 0 )
        !          10864:                fprintf(stderr, "token(%d)", ptr->base );
        !          10865:        else
        !          10866:                fprintf(stderr,"%s",s);
        !          10867:        if ( ptr->displayed ) { // recursion!!!
        !          10868:                if ( ptr->base == NAME )
        !          10869:                        fprintf(stderr," '%s'",Pname(ptr)->string);
        !          10870:                fprintf(stderr,"   RECURSION!!!\n");
        !          10871:                ptr->displayed = 0;
        !          10872:                return;
        !          10873:        }
        !          10874:        putc(' ',stderr);
        !          10875:        ptr->where.put(stderr);
        !          10876:        if ( oneline ) { putc('\n',stderr); return; }
        !          10877:        ptr->displayed = 1;
        !          10878:        switch ( ptr->base ) {
        !          10879:        case BLOCK:
        !          10880:                fprintf(stderr," .. ");
        !          10881:                ptr->where2.put(stderr);
        !          10882:                putc('\n',stderr);
        !          10883:                ++indent;
        !          10884:                { for( Pstmt st = ptr->s;  st;  st = st->s_list )
        !          10885:                        display_stmt( ptr->s, "s" ); 
        !          10886:                }
        !          10887:                --indent;
        !          10888:                break;
        !          10889:        case IF:
        !          10890:                putc('\n',stderr);
        !          10891:                ++indent;
        !          10892:                display_expr(ptr->e,"cond");
        !          10893:                display_stmt(ptr->s,"if-clause");
        !          10894:                --indent;
        !          10895:                if ( ptr->else_stmt ) {
        !          10896:                        INDENT(indent);
        !          10897:                        fprintf(stderr,"else\n");
        !          10898:                        ++indent;
        !          10899:                        display_stmt(ptr->else_stmt,"else-clause");
        !          10900:                        --indent;
        !          10901:                }
        !          10902:                break;
        !          10903:        case DO:
        !          10904:                putc('\n',stderr);
        !          10905:                ++indent;
        !          10906:                display_stmt(ptr->s,"do-stmt");
        !          10907:                display_expr(ptr->e,"cond");
        !          10908:                --indent;
        !          10909:                break;
        !          10910:        case WHILE:
        !          10911:                putc('\n',stderr);
        !          10912:                ++indent;
        !          10913:                display_expr(ptr->e,"cond");
        !          10914:                display_stmt(ptr->s,"while-stmt");
        !          10915:                --indent;
        !          10916:                break;
        !          10917:        case FOR:
        !          10918:                putc('\n',stderr);
        !          10919:                ++indent;
        !          10920:                display_stmt(ptr->for_init,"init");
        !          10921:                display_expr(ptr->e,"cond");
        !          10922:                display_expr(ptr->e2,"incr");
        !          10923:                display_stmt(ptr->s,"stmt");
        !          10924:                --indent;
        !          10925:                break;
        !          10926:        case RETURN:
        !          10927:                putc('\n',stderr);
        !          10928:                ++indent;
        !          10929:                display_expr(ptr->e,"e");
        !          10930:                --indent;
        !          10931:                break;
        !          10932:        case SM:
        !          10933:                putc('\n',stderr);
        !          10934:                ++indent;
        !          10935:                display_expr(ptr->e,"e");
        !          10936:                --indent;
        !          10937:                break;
        !          10938:        default:
        !          10939:                putc('\n',stderr);
        !          10940:                break;
        !          10941:        }
        !          10942:        ptr->displayed = 0;
        !          10943:        return;
        !          10944: }
        !          10945: 
        !          10946: void
        !          10947: display_namelist( Plist nl, char* s, int verbose )
        !          10948: {
        !          10949:        error('d',"namelist:    %s",s?s:"");
        !          10950:        ++indent;
        !          10951:        for ( Plist l = nl;  l;  l = l->l ) {
        !          10952:                Pname n = l->f;
        !          10953:                INDENT(indent);
        !          10954:                fprintf(stderr,"        %d",n);
        !          10955:                error('D'," %n %k n_key %d",n,n?n->tp->base:0,n?n->n_key:0);
        !          10956:                if ( verbose ) {
        !          10957:                        ++indent;
        !          10958:                        display_expr(n);
        !          10959:                        --indent;
        !          10960:                }
        !          10961:        }
        !          10962:        --indent;
        !          10963: }
        !          10964: #endif
        !          10965: 0707071010112044151004440001630000160000010176300466055400100001100000053752expand.c/*ident   "@(#)ctrans:src/expand.c        1.3" */
        !          10966: /*****************************************************************
        !          10967: 
        !          10968:        C++ source for cfront, the C++ compiler front-end
        !          10969:        written in the computer science research center of Bell Labs
        !          10970: 
        !          10971:        Copyright (c) 1984 AT&T, Inc. All rights Reserved
        !          10972:        THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T, INC.
        !          10973: 
        !          10974: expand.c:
        !          10975: 
        !          10976:        expand inline functions
        !          10977: 
        !          10978: ******************************************************************/
        !          10979: 
        !          10980: #include "cfront.h"
        !          10981: static Ptable Scope;
        !          10982: // extern void display_expr(Pexpr);
        !          10983: 
        !          10984: static char* temp(char* vn, Pname fn)
        !          10985: //
        !          10986: //     make the name of the temporary: __Xvn00xxxxxx
        !          10987: //     xxxxxx is a representation of fn's address -
        !          10988: //     anything unique will do.  we use radix 32 here
        !          10989: //     add two bytes to make the name sensitive to the scope
        !          10990: //     to avoid re-using temps when an inline is expanded in
        !          10991: //     more than one other inline that is then called in the
        !          10992: //     same expression
        !          10993: //
        !          10994: {
        !          10995:        if (vn[0]!='_' || vn[1]!='_' || vn[2]!='X') {
        !          10996:                unsigned long a = (unsigned long) fn->tp;
        !          10997: 
        !          10998:                // al = the number of radix-32 chars in a
        !          10999:                unsigned long aa = a;
        !          11000:                int al = 0;
        !          11001:                while (aa) {
        !          11002:                        al++;
        !          11003:                        aa >>= 5;
        !          11004:                }
        !          11005: 
        !          11006:                // allocate memory for the result
        !          11007:                int ll = strlen(vn);
        !          11008:                char* s = new char[ll+al+8];
        !          11009:                register char* p = s;
        !          11010: 
        !          11011:                // append _ _ X vn
        !          11012:                *p++ = '_';
        !          11013:                *p++ = '_';
        !          11014:                *p++ = 'X';
        !          11015:                strcpy(p,vn);
        !          11016:                p += ll;
        !          11017:                *p++ = '0';
        !          11018:                *p++ = '0';
        !          11019: 
        !          11020:                // append representation of `a'
        !          11021:                while (a) {
        !          11022:                        *p++ = "abcdefghijklmnopqrstuvwxyz012345"[a&037];
        !          11023:                        a >>= 5;
        !          11024:                }
        !          11025: 
        !          11026:                // append scope representation and trailing null
        !          11027:                *p++ = 'a' + ((int(Scope)>>4)&15);
        !          11028:                *p++ = 'a' + ((int(Scope)>>8)&15);
        !          11029:                *p = '\0';
        !          11030: //tmp error('d',"temp(%s,%n) -- scope %d -- returning %s",vn,fn,scope,s);
        !          11031:                return s;
        !          11032:        }
        !          11033:        else {
        !          11034: //tmp error('d',"temp(%s,%n) -- scope %d -- returning %s",vn,fn,scope,vn);
        !          11035:                return vn;
        !          11036:        }
        !          11037: 
        !          11038: }
        !          11039: 
        !          11040: Pname dcl_local(Ptable scope, Pname an, Pname fn)
        !          11041: {
        !          11042:        if (scope == 0 || scope->base == 0) {
        !          11043:                if (sti_tbl == 0) sti_tbl = new table(8,gtbl,0);
        !          11044:                scope = sti_tbl;
        !          11045:        //      error('s',"cannot expand inlineF needing temporaryV in nonF context");
        !          11046:        //      return an;
        !          11047:        }
        !          11048: 
        !          11049:        if (an->n_stclass == STATIC) {
        !          11050:                if (an->tp->base!=FCT) error('s',&fn->where,"cannot expand inlineF with static%n",an);
        !          11051:                return an;
        !          11052:        }
        !          11053: 
        !          11054:        Pname cn = fn->n_table->t_name;
        !          11055:        char* s = temp(an->string,fn);
        !          11056:        Pname nx = new name(s);
        !          11057:        Ptype atp = an->tp;
        !          11058: //error('d',"dcl_local(%d,%n,%n) -> %s",scope,an,fn,s);
        !          11059:        while (atp->base == TYPE) atp = Pbase(atp)->b_name->tp;
        !          11060:        if (atp->base == VEC) {
        !          11061:                if (an->n_scope == ARG) {
        !          11062:                        Pptr t = new ptr(PTR,Pvec(atp)->typ);
        !          11063:                        nx->tp = t;
        !          11064:                }
        !          11065:                else {
        !          11066:                        error('s',&fn->where,"cannot expand inlineF needing temporaryV of vectorT");
        !          11067:                        return an;
        !          11068:                }
        !          11069:        }
        !          11070:        else
        !          11071:                nx->tp = atp;
        !          11072:        PERM(nx->tp);
        !          11073: 
        !          11074:        nx->n_used = an->n_used;
        !          11075:        nx->n_assigned_to = an->n_assigned_to;
        !          11076:        nx->n_addr_taken = an->n_addr_taken;
        !          11077:        nx->n_xref = an->n_xref;
        !          11078: //error('d',"nx %n %t,",nx,nx->tp);
        !          11079:        Pname r = scope->look(nx->string,0);
        !          11080:        if (r) {
        !          11081: //error('d',"ll %n %t",ll,ll->tp);
        !          11082:                if (r->tp->check(nx->tp,0))
        !          11083:                        error('s',&fn->where,"cannot expand inlineF %n with two local variables with the sameN (%s)",fn,an->string);
        !          11084:                else
        !          11085:                        r = 0;
        !          11086:        }
        !          11087:        if (r==0) {
        !          11088:                r = scope->insert(nx,0);
        !          11089: //error('d',"%d %d %d %d",r->n_stclass,an->n_stclass,r->lex_level,an->lex_level);
        !          11090:                r->n_stclass = an->n_stclass;
        !          11091:                r->lex_level = an->lex_level;
        !          11092:                delete nx;
        !          11093:                r->where.line = 0;
        !          11094:        }
        !          11095:        return r;
        !          11096: }
        !          11097: 
        !          11098: int ck_cast(Ptype t1, Ptype t2)
        !          11099: /*
        !          11100:        return a value of type t2 from a function returning a t1
        !          11101:        return 1 if cast is needed
        !          11102: */
        !          11103: {
        !          11104: st:
        !          11105:        while (t1->base == TYPE) t1 = Pbase(t1)->b_name->tp;
        !          11106:        while (t2->base == TYPE) t2 = Pbase(t2)->b_name->tp;
        !          11107: 
        !          11108:        if (t1 == t2) return 0;
        !          11109: 
        !          11110:        if (t1->base != t2->base) return 1;
        !          11111: 
        !          11112:        switch (t1->base) {
        !          11113:        case RPTR:
        !          11114:        case PTR:
        !          11115:        {       t1 = Pptr(t1)->typ;
        !          11116:                if (t1->base == VOID) return 1;
        !          11117:                t2 = Pptr(t2)->typ;
        !          11118:                goto st;
        !          11119:        }
        !          11120:        case CHAR:
        !          11121:        case SHORT:
        !          11122:        case INT:
        !          11123:        case LONG:
        !          11124:                if (Pbase(t1)->b_unsigned != Pbase(t2)->b_unsigned) return 1;
        !          11125:                break;
        !          11126:        case COBJ:
        !          11127:        {
        !          11128:                Pname nn = Pbase(t1)->b_name;
        !          11129: 
        !          11130:                if (Pclass(nn->tp)->csu==UNION ) return 0; 
        !          11131: 
        !          11132:                if (t2->base==COBJ && nn->tp==Pbase(t2)->b_name->tp) return 0;
        !          11133: 
        !          11134:                return 1;
        !          11135:        }
        !          11136:        }
        !          11137: 
        !          11138:        return 0;
        !          11139: }
        !          11140: 
        !          11141: int makeCM( Ptype t )
        !          11142: /* return 1 if the type is not a primitive type
        !          11143:  * this will cause the generation of (t,0) 
        !          11144:  * note: ``t'' is guaranteed not to be 0
        !          11145:  */
        !          11146: {
        !          11147:     while ( t->base == TYPE )
        !          11148:        t = Pbase(t)->b_name->tp;
        !          11149: 
        !          11150:     switch (t->base) {
        !          11151:        case FLOAT:
        !          11152:        case DOUBLE:
        !          11153:        case LDOUBLE:
        !          11154:        case CHAR:
        !          11155:        case SHORT:
        !          11156:        case INT:
        !          11157:        case LONG:
        !          11158:        case EOBJ:
        !          11159:                return 0;
        !          11160:        default: 
        !          11161:                return 1;
        !          11162:        }
        !          11163: }
        !          11164: 
        !          11165: static ret_seen = 0;
        !          11166: 
        !          11167: Pstmt stmt::expand()
        !          11168: /*
        !          11169:        copy the statements with the formal arguments replaced by ANAMES 
        !          11170: 
        !          11171:        called once only per inline function
        !          11172:        expand_tbl!=0 if the function should be transformed into an expression
        !          11173:        and expand_tbl is the table for local variables
        !          11174: */
        !          11175: {
        !          11176:        if (this == 0) error('i',"0->S::expand() for%n",expand_fn);
        !          11177:        Pstmt ostmt = Cstmt;
        !          11178:        if ( where.line ) Cstmt = this;
        !          11179: 
        !          11180:        if (memtbl) {   /* check for static variables */
        !          11181:                register Ptable t = memtbl;
        !          11182:                register int i;
        !          11183:                for (register Pname n = t->get_mem(i=1); n; n=t->get_mem(++i)) {
        !          11184:                        if (n->n_stclass == STATIC) {
        !          11185:                                if (n->tp->base == FCT) continue;
        !          11186:                                error('s',"cannot expand inlineF with static%n",n);
        !          11187:                                n->n_stclass = AUTO;
        !          11188:                        }
        !          11189:                        n->where.line = 0;
        !          11190:                }
        !          11191:        }
        !          11192: 
        !          11193:        if (expand_tbl) {       /* make expression */
        !          11194:                Pexpr ee;
        !          11195: 
        !          11196:                if (memtbl) { // temporaries
        !          11197:                        int i;
        !          11198:                        for (Pname n=memtbl->get_mem(i=1); n; n=memtbl->get_mem(++i)) {
        !          11199: //error('d',"block %n %k %d %d",n,base,memtbl->real_block == this,n->lex_level);
        !          11200:                                if (n->base!=NAME || n->tp==any_type) continue;
        !          11201: 
        !          11202:                                if (base==BLOCK 
        !          11203:                                && memtbl->real_block == this 
        !          11204:                                && n->lex_level < 2
        !          11205:                                && (n->string[0]!='_'   // promoted from called
        !          11206:                                                        // inlines
        !          11207:                                        || n->string[1]!='_'
        !          11208:                                        || (  n->string[2]!='X'
        !          11209:                                           && n->string[2]!='K'))
        !          11210:                                ) {
        !          11211: //error('d',"not promoting%n",n);
        !          11212:                                        continue;
        !          11213:                                }
        !          11214: 
        !          11215:                                if (memtbl != scope)
        !          11216:                                {
        !          11217:                                        Pname nn = dcl_local(scope,n,expand_fn);
        !          11218:                                        nn->base = NAME;
        !          11219:                                        n->string = nn->string;
        !          11220:                                }
        !          11221:                                else if (n->tp->base!=FCT && n->tp->base!=OVERLOAD){
        !          11222:                                        n->string = temp(n->string, expand_fn);
        !          11223:                                        n->where.line = 0;
        !          11224:                                }
        !          11225:                        }
        !          11226:                }
        !          11227: 
        !          11228:                switch (base) {
        !          11229:                default:
        !          11230:                        error('s',"cannot expand inlineF%n with %kS in inline",expand_fn,base);
        !          11231:                        Cstmt = ostmt;
        !          11232:                        return Pstmt(dummy);
        !          11233: 
        !          11234:                case BLOCK:
        !          11235: DB(if(Edebug>=2){error('d',"stmt::expand() -- block");display_stmt(this);});
        !          11236:                        if (s_list) {
        !          11237:                                ee = Pexpr(s_list->expand());
        !          11238:                                if (s) {
        !          11239:                                        ee = new expr(CM, Pexpr(s->expand()), ee);
        !          11240:                                        ee->tp = ee->e2->tp;
        !          11241:                                        PERM(ee);
        !          11242:                                }
        !          11243:                                Cstmt = ostmt;
        !          11244:                                return Pstmt(ee);
        !          11245:                        }
        !          11246: 
        !          11247:                        if (s) {
        !          11248:                                Pstmt st = s->expand();
        !          11249:                                Cstmt = ostmt;
        !          11250:                                return st;
        !          11251:                        }
        !          11252: 
        !          11253:                        Cstmt = ostmt;
        !          11254:                        return Pstmt(zero);
        !          11255: 
        !          11256:                case PAIR:
        !          11257:                        ee = s2 ? Pexpr(s2->expand()) : 0;
        !          11258:                        ee = new expr(CM, s?Pexpr(s->expand()):0, ee);
        !          11259:                        ee->tp = ee->e2->tp;
        !          11260:                        if (s_list) {
        !          11261:                                ee = new expr(CM, ee, Pexpr(s_list->expand()));
        !          11262:                                ee->tp = ee->e2->tp;
        !          11263:                        }
        !          11264:                        PERM(ee);
        !          11265:                        Cstmt = ostmt;
        !          11266:                        return Pstmt(ee);
        !          11267: 
        !          11268:                case RETURN:
        !          11269:                        ret_seen = 1;
        !          11270:                        s_list = 0;
        !          11271: 
        !          11272:                        if (e == 0) 
        !          11273:                                ee = zero;
        !          11274:                        else {
        !          11275:                                ee = e->expand();
        !          11276:                                Ptype tt = Pfct(expand_fn->tp)->returns;
        !          11277:                                if (tt == 0) tt = Pfct(expand_fn->tp)->returns;
        !          11278: //error('d',"return::expand() -- ee==%k  tt==%t",ee?ee->base:0,tt);
        !          11279: //display_expr(ee);
        !          11280:                                if (tt!=ee->tp && ck_cast(tt,ee->tp)) ee = new cast(tt,ee);
        !          11281:                        }
        !          11282:        
        !          11283:                        Cstmt = ostmt;
        !          11284:                        return Pstmt(ee);
        !          11285: 
        !          11286:                case SM:
        !          11287:                        if (e== 0 || e==dummy)
        !          11288:                                ee = zero;
        !          11289:                        else {
        !          11290:                                if (e->base == DEREF) e = e->e1;
        !          11291:                                ee = e->expand();
        !          11292:                        }
        !          11293:                        // no break;
        !          11294: 
        !          11295:                case ASM:
        !          11296:                        if (s_list) {
        !          11297:                                ee = new expr(CM, ee, (Pexpr)s_list->expand());
        !          11298:                                ee->tp = ee->e2->tp;
        !          11299:                                PERM(ee);
        !          11300:                        }
        !          11301:                        Cstmt = ostmt;
        !          11302:                        return (Pstmt)ee;
        !          11303: 
        !          11304:                case IF:
        !          11305:                {
        !          11306:                        int ors = ret_seen;
        !          11307:                        ret_seen = 0;
        !          11308:                        ee = Pexpr(s->expand());
        !          11309:                        if(ee->base==ASSIGN && ee->e1->tp &&
        !          11310:                            ee->e1->tp->base != PTR)
        !          11311:                                ee = new expr(G_CM,ee,zero);
        !          11312:                        Pexpr qq = new expr(QUEST,ee,zero);
        !          11313:                        int ret1 = ret_seen;
        !          11314:                        ret_seen = 0;
        !          11315: 
        !          11316:                        qq->cond = e->expand();
        !          11317:                        qq->e2 = else_stmt ? Pexpr(else_stmt->expand()) : zero;
        !          11318:                        int ret2 = ret_seen; 
        !          11319:                        if (ret1+ret2 && s_list) {
        !          11320:                                error('s',"cannot expand inlineF%n with S after \"return\"",expand_fn);
        !          11321:                                ret_seen = 0;
        !          11322:                        }
        !          11323:                        ret_seen += ret1;
        !          11324:                        ret_seen += ret2;
        !          11325:                        ret_seen += ors;
        !          11326: 
        !          11327:                        // handle ``if (x) class_object_valued_expression;''
        !          11328: 
        !          11329:                        Ptype t1 = qq->e1->tp;
        !          11330:                        Ptype t2 = qq->e2->tp;
        !          11331: 
        !          11332:        if (t1 && t1->base==FCT)
        !          11333:                t1 = Pfct(t1)->s_returns ? Pfct(t1)->s_returns : Pfct(t1)->returns;
        !          11334: 
        !          11335:        if (t2 && t2->base==FCT)
        !          11336:                t2 = Pfct(t2)->s_returns ? Pfct(t2)->s_returns : Pfct(t2)->returns;
        !          11337: 
        !          11338:                        Pname c1 = t1?t1->is_cl_obj():0;
        !          11339:                        Pname c2 = t2?t2->is_cl_obj():0;
        !          11340: 
        !          11341:                        int z1 = c1 && c1!=c2;
        !          11342:                        int z2 = c2 && c1!=c2;
        !          11343: 
        !          11344: //error('d',"if()%k%t else%k%t",qq->e1->base,t1,qq->e2->base,t2);
        !          11345: //error('d',"c1%n c2%n %d %d",c1,c2,z1,z2);
        !          11346: //display_expr(qq);
        !          11347:                        if (c1==0
        !          11348:                        && c2==0
        !          11349:                        && t1
        !          11350:                        && t2
        !          11351:                        && t2->check(t1,ASSIGN)
        !          11352:                        && t1->check(t2,ASSIGN)) {
        !          11353:                                z1 = makeCM( t1 );
        !          11354:                                z2 = makeCM( t2 );
        !          11355:                                if ((z1 && ret1) || (z2 && ret2))
        !          11356:                                        error('s',"cannot expand inlineF with return in ifS");
        !          11357:                        }
        !          11358: 
        !          11359: //error('d',"if()%k%t else%k%t",qq->e1->base,t1,qq->e2->base,t2);
        !          11360: //error('d',"c1%n c2%n %d %d",c1,c2,z1,z2);
        !          11361: //display_expr(qq);
        !          11362:                        if (t1 && z1==0) {
        !          11363:                                // since zero is acceptable to all pointer types
        !          11364:                                // we need only ``fix'' z1 and z2 will take care
        !          11365:                                // of itself
        !          11366:                                z1 = t1->is_ptr_or_ref()
        !          11367:                                        && t2
        !          11368:                                        && t2->is_ptr_or_ref()
        !          11369:                                        && t1->check(t2,0)
        !          11370:                                        && !const_problem;
        !          11371:                        }
        !          11372: 
        !          11373: //error('d',"if()%k%t else%k%t",qq->e1->base,t1,qq->e2->base,t2);
        !          11374: //error('d',"c1%n c2%n %d %d",c1,c2,z1,z2);
        !          11375: //display_expr(qq);
        !          11376:                        if (z1) {
        !          11377:                                Pexpr v = (z2==0 && (t2->is_ptr_or_ref())) ? new cast(t2,zero) : zero;
        !          11378:                                qq->e1 = new expr(CM,qq->e1,v);
        !          11379:                                qq->e1->tp = qq->e1->e1->tp;
        !          11380:                        }
        !          11381: 
        !          11382: //error('d',"if()%k%t else%k%t",qq->e1->base,t1,qq->e2->base,t2);
        !          11383: //error('d',"c1%n c2%n %d %d",c1,c2,z1,z2);
        !          11384: //display_expr(qq);
        !          11385:                        if (z2) {
        !          11386:                                Pexpr v = (z1==0 && (t1->is_ptr_or_ref())) ? new cast(t1,zero) : zero;
        !          11387:                                qq->e2 = new expr(CM,qq->e2,v);
        !          11388:                                qq->e2->tp = qq->e2->e1->tp;
        !          11389:                        }
        !          11390: 
        !          11391: //error('d',"if()%k%t else%k%t",qq->e1->base,t1,qq->e2->base,t2);
        !          11392: //error('d',"c1%n c2%n %d %d",c1,c2,z1,z2);
        !          11393: //display_expr(qq);
        !          11394:                        if (s_list) {
        !          11395:                                qq = new expr(CM,qq,Pexpr(s_list->expand()));
        !          11396:                                qq->tp = qq->e2->tp;
        !          11397:                        }
        !          11398:                        else
        !          11399:                                qq->tp = qq->e1->tp;
        !          11400:                        PERM(qq);
        !          11401:                        Cstmt = ostmt;
        !          11402:                        return Pstmt(qq);
        !          11403:                }
        !          11404:                }
        !          11405:        }
        !          11406: 
        !          11407:        where.line = 0;
        !          11408: 
        !          11409:        switch (base) {
        !          11410:        default:
        !          11411:                if (e) e = e->expand();
        !          11412:                break;
        !          11413:        case PAIR:
        !          11414:                if (s2) s2 = s2->expand();
        !          11415:                break;
        !          11416:        case BLOCK:
        !          11417:                break;
        !          11418:        case FOR:
        !          11419:                if (for_init) for_init = for_init->expand();
        !          11420:                if (e2) e2 = e2->expand();
        !          11421:        case ASM:
        !          11422:                break;
        !          11423: //     case LABEL:
        !          11424: //     case GOTO:
        !          11425:        case RETURN:
        !          11426: //     case BREAK:
        !          11427: //     case CONTINUE:
        !          11428:                error('s',"cannot expand inlineF%n with %kS",expand_fn,base);
        !          11429:        }
        !          11430: 
        !          11431:        if (s) s = s->expand();
        !          11432:        if (s_list) s_list = s_list->expand();
        !          11433:        PERM(this);
        !          11434:        Cstmt = ostmt;
        !          11435:        return this;
        !          11436: }
        !          11437: 
        !          11438: Pexpr expr::expand()
        !          11439: {
        !          11440:        if (this == 0) error('i',"E::expand(0)");
        !          11441: 
        !          11442:        switch (base) {
        !          11443:        case NAME:
        !          11444:                if (expand_tbl && Pname(this)->n_scope==FCT) {
        !          11445:                        Pname n = Pname(this);
        !          11446:                        char* s = n->string;
        !          11447:                        if (s[0]=='_' && s[1]=='_' && s[2]=='X') break;
        !          11448:                        Pname cn = expand_fn->n_table->t_name;
        !          11449:                //      n->string = temp(s,expand_fn->string,(cn)?cn->string:0);
        !          11450:                        n->string = temp(s,expand_fn);
        !          11451:                }
        !          11452:        case DUMMY:
        !          11453:        case ICON:
        !          11454:        case FCON:
        !          11455:        case CCON:
        !          11456:        case IVAL:
        !          11457:        //case FVAL:
        !          11458:        //case LVAL:
        !          11459:        case STRING:
        !          11460:        case ZERO:
        !          11461:        case TEXT:
        !          11462:        case ANAME:
        !          11463:        case MDOT:
        !          11464:                break;
        !          11465:        case ICALL:
        !          11466:                if (expand_tbl && e1==0) {
        !          11467:                        int ors = ret_seen;
        !          11468:                        ret_seen = 0;
        !          11469:                        Pname fn = il->fct_name;
        !          11470:                        Pfct f = Pfct(fn->tp);
        !          11471:                        if (f->f_expr==0
        !          11472:                // f->returns==void_type
        !          11473:                //      && f->s_returns!=int_type
        !          11474:                //      && fn->n_oper!=CTOR
        !          11475:                        )
        !          11476:                                error('s',&fn->where,"cannot expand value-returning inline%n with call of non-value-returning inline%n",expand_fn,fn);
        !          11477:                //      else
        !          11478:                //              error("inline%n called before defined",fn);
        !          11479: ret_seen = ors;
        !          11480:                }
        !          11481:                break;
        !          11482:        case SIZEOF:
        !          11483:        case CAST:
        !          11484:                if (tp2) PERM(tp2);
        !          11485:                goto rrr;
        !          11486:        case QUEST:
        !          11487:                cond = cond->expand();
        !          11488:        default:
        !          11489:                if (e2) e2 = e2->expand();
        !          11490:        case REF:
        !          11491:        case DOT:
        !          11492:        rrr:
        !          11493:                if (e1) e1 = e1->expand();
        !          11494:                break;
        !          11495:        }
        !          11496: 
        !          11497:        switch (base) {
        !          11498:        case CM:
        !          11499:        case G_CM:
        !          11500:                if (tp==0) tp=e2->tp;
        !          11501:        }
        !          11502: 
        !          11503:        PERM(this);
        !          11504:        return this;
        !          11505: }
        !          11506: 
        !          11507: int nin;
        !          11508: 
        !          11509: static int watch_out;
        !          11510: bit expr::not_simple()
        !          11511: /*
        !          11512:        is a temporary variable needed to hold the value of this expression
        !          11513:        as an argument for an inline expansion?
        !          11514:        return 1; if side effect
        !          11515:        return 2; if modifies expression
        !          11516: */
        !          11517: {
        !          11518:        int s;
        !          11519: //error('d',"not_simple%k",base);
        !          11520:        switch (base) {
        !          11521:        default:
        !          11522:                return 2;
        !          11523:        case NAME:
        !          11524:                if (nin==0 && Pname(this)->n_table==gtbl) return 2;     // unsafe: aliasing
        !          11525:        case ZERO:
        !          11526:        case IVAL:
        !          11527:        //case FVAL:
        !          11528:        case ICON:
        !          11529:        case CCON:
        !          11530:        case FCON:
        !          11531:                return 0;
        !          11532:        case STRING:
        !          11533:                ::watch_out = 1;
        !          11534:                return 0;
        !          11535:        case MDOT:
        !          11536:                return mem->not_simple();
        !          11537:        case SIZEOF:
        !          11538:                return (e1==0 || e1==dummy) ? 0 : e1->not_simple();
        !          11539:        case G_ADDROF:
        !          11540:        case ADDROF:
        !          11541:                return e2->not_simple();
        !          11542:        case CAST:
        !          11543:                return e1->not_simple();
        !          11544:        case DOT:
        !          11545:                ::watch_out = 1;
        !          11546:                return e1->not_simple();
        !          11547:        case REF:
        !          11548:                ::watch_out = 1;
        !          11549:                return e1->not_simple();
        !          11550:        case UMINUS:
        !          11551:        case NOT:
        !          11552:        case COMPL:
        !          11553:                return e2->not_simple();
        !          11554:        case DEREF:
        !          11555:                s = e1->not_simple();
        !          11556:                if (1<s) return 2;
        !          11557:                if (e2==0) return s;
        !          11558:                return s |= e2->not_simple();
        !          11559:        case MUL:
        !          11560:        case DIV:
        !          11561:        case MOD:
        !          11562:        case PLUS:
        !          11563:        case MINUS:
        !          11564:        case LS:
        !          11565:        case RS:
        !          11566:        case AND:
        !          11567:        case OR:
        !          11568:        case ER:
        !          11569:        case LT:
        !          11570:        case LE:
        !          11571:        case GT:
        !          11572:        case GE:
        !          11573:        case EQ:
        !          11574:        case NE:
        !          11575:        case ANDAND:
        !          11576:        case OROR:
        !          11577:        case CM:
        !          11578:                s = e1->not_simple();
        !          11579:                if (1<s) return 2;
        !          11580:                return s |= e2->not_simple();
        !          11581:        case QUEST:
        !          11582:                s = cond->not_simple();
        !          11583:                if (1<s) return 2;
        !          11584:                s |= e1->not_simple();
        !          11585:                if (1<s) return 2;
        !          11586:                return s |= e2->not_simple();
        !          11587:        case ANAME:
        !          11588:                if (curr_icall) {
        !          11589:                        Pname n = (Pname)this;
        !          11590:                        int argno = int(n->n_val);
        !          11591:                        for (Pin il=curr_icall; il; il=il->i_next)
        !          11592:                                if (n->n_table == il->i_table) goto aok;
        !          11593:                        goto bok;
        !          11594:                aok:
        !          11595:                        return (il->i_args[argno].local) ? 0 : il->i_args[argno].arg->not_simple();
        !          11596:                }
        !          11597:        bok:    error('i',"expand aname%n",this);
        !          11598:        case G_CM:
        !          11599:        case VALUE:
        !          11600:        case NEW:
        !          11601:        case GNEW:
        !          11602:        case CALL:
        !          11603:        case G_CALL:
        !          11604:        case ICALL:
        !          11605:        case ASSIGN:
        !          11606:        case INCR:
        !          11607:        case DECR:
        !          11608:        case ASPLUS:
        !          11609:        case ASMINUS:
        !          11610:        case ASMUL:
        !          11611:        case ASDIV:
        !          11612:        case ASMOD:
        !          11613:        case ASAND:
        !          11614:        case ASOR:
        !          11615:        case ASER:
        !          11616:        case ASLS:
        !          11617:        case ASRS:
        !          11618:                return 2;
        !          11619:        }
        !          11620: }
        !          11621: 
        !          11622: extern void uninline(Pname fn);
        !          11623: //extern Pname new_fct;        
        !          11624: //extern Pname del_fct;
        !          11625: extern Pstmt del_list;
        !          11626: extern Pstmt break_del_list;
        !          11627: extern Pstmt continue_del_list;
        !          11628: extern Pname curr_fct;
        !          11629: extern Pexpr init_list;
        !          11630: 
        !          11631: extern Pname make_default_ctor(Pclass cl);
        !          11632: void expand_itor(Pclass cl)
        !          11633: {
        !          11634: //error('d',"expand_itor(%t)",cl);
        !          11635:        Pexpr s2 = curr_expr;
        !          11636:        Pstmt s5 = del_list;
        !          11637:        Pstmt s6 = break_del_list;
        !          11638:        Pstmt s7 = continue_del_list;
        !          11639:        Pname s8 = curr_fct;
        !          11640:        Pexpr s9 = init_list;
        !          11641:        (void) cl->make_itor(1);
        !          11642:        curr_expr = s2;
        !          11643:        del_list = s5;
        !          11644:        break_del_list = s6;
        !          11645:        continue_del_list = s7;
        !          11646:        curr_fct = s8;
        !          11647:        init_list = s9;
        !          11648: }
        !          11649: /*
        !          11650: extern Pname make_default_dtor(Pclass cl);
        !          11651: void expand_dtor(Pclass cl)
        !          11652: {
        !          11653: //error('d',"expand_itor(%t)",cl);
        !          11654:        Pexpr s2 = curr_expr;
        !          11655:        Pstmt s5 = del_list;
        !          11656:        Pstmt s6 = break_del_list;
        !          11657:        Pstmt s7 = continue_del_list;
        !          11658:        Pname s8 = curr_fct;
        !          11659:        Pexpr s9 = init_list;
        !          11660:        (void) make_default_dtor(cl);
        !          11661:        curr_expr = s2;
        !          11662:        del_list = s5;
        !          11663:        break_del_list = s6;
        !          11664:        continue_del_list = s7;
        !          11665:        curr_fct = s8;
        !          11666:        init_list = s9;
        !          11667: }
        !          11668: 
        !          11669: 
        !          11670: void expand_ictor(Pclass cl)
        !          11671: {
        !          11672: //error('d',"expand_itor(%t)",cl);
        !          11673:        Pexpr s2 = curr_expr;
        !          11674:        Pstmt s5 = del_list;
        !          11675:        Pstmt s6 = break_del_list;
        !          11676:        Pstmt s7 = continue_del_list;
        !          11677:        Pname s8 = curr_fct;
        !          11678:        Pexpr s9 = init_list;
        !          11679:        (void) make_default_ctor(cl);
        !          11680:        curr_expr = s2;
        !          11681:        del_list = s5;
        !          11682:        break_del_list = s6;
        !          11683:        continue_del_list = s7;
        !          11684:        curr_fct = s8;
        !          11685:        init_list = s9;
        !          11686: }
        !          11687: */
        !          11688: Pexpr fct::expand(Pname fn, Ptable scope, Pexpr ll)
        !          11689: /*
        !          11690:        expand call to (previously defined) inline function in "scope"
        !          11691:        with the argument list "ll"
        !          11692:        (1) declare variables in "scope"
        !          11693:        (2) initialize argument variables
        !          11694:        (3) link to body
        !          11695: */
        !          11696: {
        !          11697:        Scope = scope;
        !          11698: //error('d',"expand%s() body %d f_expr %d inline %d",fn->string,body,f_expr,f_inline);
        !          11699:        if (f_inline == ITOR) {
        !          11700:                Pexpr s1 = last_expanded;
        !          11701:                expand_itor(memof);
        !          11702:                last_expanded = s1;
        !          11703:                last_stmt = stmtno;
        !          11704:                this = Pfct(fn->tp);
        !          11705:                if (f_inline==0 && f_imeasure) {
        !          11706:                        uninline(fn);
        !          11707:                        return 0;
        !          11708:                }
        !          11709:        }
        !          11710: 
        !          11711: //error('d',"expand %n body %d f_expr %d defined %d",fn,body,f_expr,defined);
        !          11712: //error('d',"inline %d memtbl %d scope %d",f_inline,Pfct(fn->tp)->body->memtbl,scope);
        !          11713: //display_stmt(body);
        !          11714:        if ((body==0 && f_expr==0)                      // before defined
        !          11715:        ||  ((defined&SIMPLIFIED)==0)                   // before simplified
        !          11716:        ||  (Pfct(fn->tp)->body->memtbl==scope)         // while defining
        !          11717:        ||  (f_inline>1)                                // recursive call
        !          11718:        ) {                                             // so don't expand
        !          11719:                if (warning_opt) error('w',"cannot inline%n in thisE",fn);
        !          11720:                if (fn->n_addr_taken++==0) fn->dcl_print(0);
        !          11721:                return 0;
        !          11722:        }
        !          11723: 
        !          11724:        if (fn->n_oper==CTOR) {
        !          11725:                Pclass cl = Pclass(fn->n_table->t_name->tp);
        !          11726:                if (cl->c_body == 3) cl->print_all_vtbls(cl);
        !          11727:        }
        !          11728: 
        !          11729:        Pin il = new iline;
        !          11730:        Pexpr ic = new texpr(ICALL,0,0);
        !          11731:        int ns = 0;
        !          11732:        for (Pname an = f_args; an; an=an->n_list) ns++;
        !          11733:        il->fct_name = fn;
        !          11734:        il->i_args = new ia[il->i_slots = ns];
        !          11735:        ic->il = il;
        !          11736:        ic->tp = s_returns ? s_returns : returns;
        !          11737: //     Pname at = (f_this) ? f_this : (f_result) ? f_result : argtype;
        !          11738:        Pname at = f_args;
        !          11739: 
        !          11740:        f_inline++;
        !          11741: 
        !          11742:        if (at) il->i_table = at->n_table;
        !          11743:        int i = 0;
        !          11744:        int not_simple = 0;     /* is a temporary argument needed? */
        !          11745: 
        !          11746:        for (Pname n=at; n; n=n->n_list, i++) {
        !          11747:                /*      check formal/actual argument pairs
        !          11748:                        and generate temporaries as necessary
        !          11749:                */
        !          11750: 
        !          11751:                if (ll == 0) error('i',"F::expand(%n):AX",fn);
        !          11752:                Pexpr ee;
        !          11753: 
        !          11754:                if (ll->base == ELIST) {
        !          11755:                        ee = ll->e1;
        !          11756:                        ll = ll->e2;
        !          11757:                }
        !          11758:                else {
        !          11759:                        ee = ll;
        !          11760:                        ll = 0;
        !          11761:                }
        !          11762: 
        !          11763:                /* could be avoided when expanding into a block */
        !          11764:                il->i_args[i].local = 0;
        !          11765:                int s ;
        !          11766: 
        !          11767:        // try to protect agains aliasing through pointers and references
        !          11768:        for (Pname m=at; m; m=m->n_list) {
        !          11769:                Pptr p;
        !          11770:                if (n!=m) {
        !          11771:                //      if ((p=m->tp->is_ptr()) || (p=m->tp->is_ref()))
        !          11772:                        if (p=m->tp->is_ptr_or_ref())
        !          11773:                                if (p->check(n->tp,0)==0 || p->typ->check(n->tp,0)==0) goto zxc;
        !          11774: 
        !          11775:                }
        !          11776:        }
        !          11777: 
        !          11778:                ::watch_out = 0;
        !          11779:                int notsimple; notsimple = ee->not_simple();
        !          11780:                if ( notsimple==0 && ::watch_out && n->n_used > 1 ) goto zxc;
        !          11781:                if (n->n_assigned_to==FUDGE111
        !          11782:                && ee!=zero
        !          11783:                && notsimple==0) {
        !          11784:                        if (ee && ee->e1 && (ee->e1->base == NAME) &&
        !          11785:                               (! strcmp (ee->e1->string,"this"))) goto zxc;
        !          11786:                }
        !          11787:                else if (n->n_addr_taken || n->n_assigned_to) 
        !          11788:                        goto zxc;
        !          11789:                else if (s=notsimple) {
        !          11790:                        if (/*n->n_used==0      // n_used not set for ``this''
        !          11791:                        || */1<s
        !          11792:                        || 1<n->n_used ) {      // not safe
        !          11793:                zxc:
        !          11794:                        if (last_expanded && last_expanded==curr_expr && last_stmt==stmtno) {
        !          11795:                                if (warning_opt)
        !          11796:                                        error('w',"%n not inlined, called twice in an expression",fn);
        !          11797:                                f_inline--;
        !          11798:                                delete il->i_args;
        !          11799:                                delete il;
        !          11800:                                if (fn->n_addr_taken++==0) fn->dcl_print(0);
        !          11801:                                return 0;
        !          11802:                        }
        !          11803: //error('d',"zxc %n %t ee %d %t",n,n->tp,ee->base,ee->tp);
        !          11804:                        if (ee && ee->tp && (ee->tp->base==EOBJ) && ansi_opt) 
        !          11805:                                ; // do nothing
        !          11806:                        else {
        !          11807:                                Pname nn = dcl_local(scope,n,fn);
        !          11808:                                nn->base = NAME;
        !          11809:                                il->i_args[i].local = nn;
        !          11810:                                ++not_simple;
        !          11811:                        //      if (nn->tp->is_ref()
        !          11812:                        //      && ee->tp
        !          11813:                        //      && ee->tp->is_ptr_or_ref()==0) ee = ee->address();
        !          11814:                        }
        !          11815:                        }
        !          11816:                }
        !          11817: 
        !          11818:                il->i_args[i].arg = ee;
        !          11819:                il->i_args[i].tp = n->tp;
        !          11820:        }
        !          11821:        
        !          11822:        Ptable tbl = body->memtbl;
        !          11823:        if (f_expr) {           // generate comma expression
        !          11824:                
        !          11825:                char loc_var = 0;
        !          11826: 
        !          11827:                /* look for local variables needing declaration: */
        !          11828:                for (n=tbl->get_mem(i=1); n; n=tbl->get_mem(++i) ) {
        !          11829: //error('d',"n %n %d",n,n->base);
        !          11830: //error('d',"loc %n %d %d %d",n,n->n_used,n->n_assigned_to,n->n_addr_taken);
        !          11831:                        if (n->base==NAME       // don't re-declare the args
        !          11832:                        && (n->tp->base!=FCT && n->tp->base!=OVERLOAD)
        !          11833:                        && (n->n_used || n->n_assigned_to || n->n_addr_taken)) {
        !          11834: if (last_expanded && last_expanded==curr_expr && last_stmt == stmtno) {
        !          11835:        if (warning_opt) error('w',"cannot inline%n in thisE",fn);
        !          11836:        f_inline--;
        !          11837:        delete il->i_args;
        !          11838:        delete il;
        !          11839:        if (fn->n_addr_taken++==0) fn->dcl_print(0);
        !          11840:        return 0;
        !          11841: }
        !          11842:                                Pname nn = dcl_local(scope,n,fn);
        !          11843:                                nn->base = NAME;
        !          11844:                                n->string = nn->string;
        !          11845: 
        !          11846:                                loc_var++;
        !          11847:                        }
        !          11848:                }
        !          11849: 
        !          11850:                if (i /*not_simple*/ || loc_var) {
        !          11851:                        if(!curr_expr) curr_expr = dummy;
        !          11852:                        last_expanded = curr_expr;
        !          11853:                        last_stmt = stmtno;
        !          11854:                }
        !          11855: 
        !          11856:                Pexpr ex;
        !          11857:                if (not_simple) {
        !          11858:                        Pexpr etail = ex = new expr(CM,0,0);
        !          11859:                        for (i=0; i<il->i_slots; i++) {
        !          11860:                                Pname n = il->i_args[i].local;
        !          11861:                                if (n == 0) continue;
        !          11862:                                Pexpr e = il->i_args[i].arg;
        !          11863:                                        // if used assign
        !          11864:                                        // otherwise (e.g. unused argument)
        !          11865:                                        // simply evaluate for sideeffects
        !          11866:                                if (n->n_used
        !          11867:                                || n->n_assigned_to
        !          11868:                                || n->n_addr_taken) {
        !          11869: Pexpr mptr_assign(Pexpr n, Pexpr in);
        !          11870:                                Pptr p1 = n->tp->is_ptr();
        !          11871:                                 Pptr p2 = e->tp ? e->tp->is_ptr() : 0;
        !          11872:                                if (p1 && p1->memof && p1!=p2) {
        !          11873:                                        switch (e->base) {
        !          11874:                                        case CM:
        !          11875:                                        case G_CM:
        !          11876:                                                e->e2 = mptr_assign(n,e->e2);
        !          11877:                                                break;
        !          11878:                                        case ICALL:
        !          11879:                                                break;
        !          11880:                                        default:
        !          11881:                                                e = mptr_assign(n,e);
        !          11882:                                        }
        !          11883:                                        etail->e1 = e;
        !          11884:                                }
        !          11885:                                else
        !          11886:                                        etail->e1 = new expr(ASSIGN,n,e);
        !          11887:                                }
        !          11888:                                else
        !          11889:                                        etail->e1 = e;
        !          11890:                                if (--not_simple)
        !          11891:                                        etail = etail->e2 = new expr(CM,0,0);
        !          11892:                                else
        !          11893:                                        break;
        !          11894:                        }
        !          11895:                        etail->e2 = f_expr;
        !          11896:                }
        !          11897:                else
        !          11898:                        ex = f_expr;
        !          11899:                ic->e1 = ex;
        !          11900:        }
        !          11901:        else {          // generate block:
        !          11902:                for (n=tbl->get_mem(i=1); n; n=tbl->get_mem(++i) ) {
        !          11903:                        // mangle local names
        !          11904:                        if (n->base==NAME
        !          11905:                        && (n->n_used || n->n_assigned_to || n->n_addr_taken)) {
        !          11906:                        //      Pname cn = fn->n_table->t_name;
        !          11907:                        //      n->string = temp(n->string,fn->string,(cn)?cn->string:0);
        !          11908:                                n->string = temp(n->string,fn);
        !          11909:                        }
        !          11910:                }
        !          11911:                Pstmt ss;
        !          11912:                if (not_simple) {
        !          11913:                        if(!curr_expr) curr_expr = dummy;
        !          11914:                        last_expanded = curr_expr;
        !          11915:                        last_stmt = stmtno;
        !          11916:                        Pstmt st = new estmt(SM,curloc,0,0);
        !          11917:                        st->where.line = 0;
        !          11918:                        Pstmt stail = st;
        !          11919:                        for (i=0; i<il->i_slots; i++) {
        !          11920:                                Pname n = il->i_args[i].local;
        !          11921:                                if (n == 0) continue;
        !          11922:                                Pexpr e = il->i_args[i].arg;
        !          11923:                                Pptr p1 = n->tp->is_ptr();
        !          11924:                                Pptr p2 = e->tp->is_ptr();
        !          11925:                                Pexpr mptr_assign(Pexpr n, Pexpr in);
        !          11926:                                if (p1 && p1->memof && p1!=p2) {
        !          11927:                                        switch (e->base) {
        !          11928:                                        case CM:
        !          11929:                                        case G_CM:
        !          11930:                                                e->e2 = mptr_assign(n,e->e2);
        !          11931:                                                break;
        !          11932:                                        default:
        !          11933:                                                e = mptr_assign(n,e);
        !          11934:                                        }
        !          11935:                                        stail->e = e;
        !          11936:                                }
        !          11937:                                else
        !          11938:                                        stail->e = new expr(ASSIGN,n,e);
        !          11939:                                if (--not_simple) {
        !          11940:                                        stail = stail->s_list = new estmt(SM,curloc,0,0);
        !          11941:                                        stail->where.line = 0;
        !          11942:                                }
        !          11943:                                else
        !          11944:                                        break;
        !          11945:                        }
        !          11946:                        stail->s_list = body;
        !          11947:                        ss = new block(curloc,0,st);
        !          11948:                        ss->where.line = 0;
        !          11949:                }
        !          11950:                else
        !          11951:                        ss = body;
        !          11952:                ic->e2 = Pexpr(ss);
        !          11953:        }
        !          11954: 
        !          11955:        f_inline--;
        !          11956: //error('d',"expand%n -- returning%k", fn, ic?ic->base:0);
        !          11957: //display_expr(ic);
        !          11958:        return ic;
        !          11959: }
        !          11960: 0707071010112044261004440001630000160000010177000466055400600000700000116316expr.c/*ident     "@(#)ctrans:src/expr.c  1.8" */
        !          11961: /***************************************************************************
        !          11962: 
        !          11963:        C++ source for cfront, the C++ compiler front-end
        !          11964:        written in the computer science research center of Bell Labs
        !          11965: 
        !          11966:        Copyright (c) 1984 AT&T, Inc. All rights Reserved
        !          11967:        THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T, INC.
        !          11968: 
        !          11969: expr.c:
        !          11970: 
        !          11971:        type check expressions
        !          11972: 
        !          11973: ************************************************************************/
        !          11974: 
        !          11975: #include "cfront.h"
        !          11976: #include "size.h"
        !          11977: 
        !          11978: int const_save;
        !          11979: int const_ptr;
        !          11980: extern Ptype Pfct_type;
        !          11981: 
        !          11982: Pexpr expr::address()
        !          11983: {
        !          11984: // error('d',"address %k %d %s",base,base,base==NAME||base==ANAME?string:"?");
        !          11985: // error('d',"address e1 %d %k e2 %d %k", e1, e1?e1->base:0, e2, e2?e2->base:0); 
        !          11986:        switch (base) {
        !          11987:        case DEREF:
        !          11988:                if (e2 == 0) return e1;                 // &*e  => e
        !          11989:                break;
        !          11990:        case QUEST:                                     // &(a?b:c) => a?&b:&c
        !          11991:                e1 = e1->address();
        !          11992:                // no break;
        !          11993:        case G_CM:
        !          11994:                if ( e1 && e1->base == G_CALL &&
        !          11995:                        e2 && e2->base == G_ADDROF)
        !          11996:                        return this;
        !          11997:        case CM:
        !          11998:                e2 = e2->address();                     // &(e1,e2) => (e1,&e2)
        !          11999:                tp = e2->tp;    //LLL
        !          12000:                return this;
        !          12001:        case INCR:
        !          12002:        case DECR:                                      // &(++a) => (++a,&a)
        !          12003:                if (e1) break;
        !          12004:                nin++;
        !          12005:                if (e2->not_simple()) error('s',"& of%k",base);
        !          12006:                nin--;
        !          12007:                e1 = new expr(base,0,e2);
        !          12008:                e2 = e2->address();
        !          12009:                base = G_CM;
        !          12010:                tp = e2->tp;
        !          12011:                return this;
        !          12012:        case ASSIGN:                                    // &(a=b) => ((a=b),&a)
        !          12013:        case ASPLUS:
        !          12014:        case ASMINUS:
        !          12015:        case ASMUL:
        !          12016:        case ASDIV:
        !          12017:        case ASMOD:
        !          12018:        case ASAND:
        !          12019:        case ASOR:
        !          12020:        case ASER:
        !          12021:        case ASLS:
        !          12022:        case ASRS:
        !          12023:                nin++;
        !          12024:                if (e1->not_simple()) error('s',"& of%k",base);
        !          12025:                nin--;
        !          12026:                Pexpr a = new expr(base,e1,e2);
        !          12027:                a->tp = a->e1->tp;
        !          12028:                base = G_CM;
        !          12029:                e1 = a;
        !          12030:                e2 = a->e1->address();
        !          12031:                tp = e2->tp;
        !          12032:                return this;
        !          12033: 
        !          12034:        case NAME:
        !          12035:                if (Pname(this)->n_stclass == REGISTER) error("& register%n",Pname(this));
        !          12036:                Pname(this)->take_addr();
        !          12037:                break;
        !          12038:        case CALL:
        !          12039:        case CAST:
        !          12040:        case NEW:
        !          12041:        case GNEW:
        !          12042:                if (tp && tp->is_ptr_or_ref()) {        // hack?
        !          12043:                        return this;
        !          12044:                }
        !          12045:                break;
        !          12046:        }
        !          12047: 
        !          12048:        register Pexpr ee = new expr(G_ADDROF,0,this);
        !          12049:        if (tp) {                                       // tp==0 ???
        !          12050:                ee->tp = tp->addrof();
        !          12051: 
        !          12052:                switch (tp->base) {
        !          12053:                case PTR:
        !          12054:                        Pptr(ee->tp)->memof = Pptr(tp)->memof;
        !          12055:                        break;
        !          12056:                case FCT:
        !          12057:                        if (Pfct(tp)->f_static==0)
        !          12058:                        Pptr(ee->tp)->memof = Pfct(tp)->memof;
        !          12059:                        break;
        !          12060:                case OVERLOAD:
        !          12061:                        if (Pfct(Pgen(tp)->fct_list->f->tp)->f_static==0)
        !          12062:                        Pptr(ee->tp)->memof = Pfct(Pgen(tp)->fct_list->f->tp)->memof;
        !          12063:                }
        !          12064:        }
        !          12065: 
        !          12066:        return ee;
        !          12067: }
        !          12068: 
        !          12069: Pexpr expr::contents()
        !          12070: {
        !          12071: //error('d',"deref %k %d %t",base,base,tp);
        !          12072: //     if (base==ADDROF || base==G_ADDROF) return e2;          // *&
        !          12073:        switch (base) {
        !          12074:        case ADDROF:
        !          12075:        case G_ADDROF:
        !          12076:                return e2;              // *&
        !          12077:        case ELIST:
        !          12078: //error('d',"contents of  elist");
        !          12079:                e1 = e1->contents();
        !          12080:                tp = e1->tp;
        !          12081:                return this;
        !          12082:        };
        !          12083: 
        !          12084:        register Pexpr ee = new expr(DEREF,this,0);
        !          12085:        if (tp) {                       // tp==0 ???
        !          12086:                Ptype tt = tp;
        !          12087:                while (tt->base == TYPE) tt = Pbase(tt)->b_name->tp;
        !          12088:                ee->tp = Pptr(tt)->typ;
        !          12089:                Pname cn = ee->tp->is_cl_obj();
        !          12090:                if (cn) {
        !          12091:                        Pclass cl = Pclass(cn->tp);
        !          12092:                        if (cl->c_body==1) cl->dcl_print(0);    // look for first use of cl
        !          12093:                }
        !          12094:        }
        !          12095:        return ee;
        !          12096: }
        !          12097: 
        !          12098: static Pexpr 
        !          12099: make_postfix( Pexpr op ) 
        !          12100: { // apply the postfix form of increment/decrement operator
        !          12101:        Pexpr e = op->e1->base==NAME?op->e1:op->e1->mem;
        !          12102:        for (Plist fl=Pgen(e->tp)->fct_list;fl; fl=fl->l) {
        !          12103:                Pname n = fl->f;
        !          12104:                Pfct f = Pfct(n->tp);
        !          12105:                if ((f->nargs==1 && f->f_this) ||
        !          12106:                    (f->nargs==2 && f->f_this==0)) {
        !          12107: 
        !          12108:                        if (op->e1->base == NAME) {
        !          12109:                                op->e1 = n;     
        !          12110:                                op->e2->e2 = new expr(ELIST,zero,0);
        !          12111:                        } else {
        !          12112:                                op->e1->mem = n;  
        !          12113:                                op->e2 = new expr(ELIST,zero,0); 
        !          12114:                        }
        !          12115: 
        !          12116:                        op->fct_name = n; 
        !          12117:                        n->dcl_print(0); 
        !          12118:                        return op;
        !          12119:                }
        !          12120:        }
        !          12121:        error('w',"no postfix instance of%n, although overloaded",Pname(e));
        !          12122:        return op; // as it were
        !          12123: }
        !          12124: 
        !          12125: int bound;
        !          12126: int chars_in_largest;  // no of characters in largest int
        !          12127: static Pclass mpglob;
        !          12128: 
        !          12129: Pexpr expr::typ(Ptable tbl)
        !          12130: /*
        !          12131:        find the type of "this" and place it in tp;
        !          12132:        return the typechecked version of the expression:
        !          12133:        "tbl" provides the scope for the names in "this"
        !          12134: */
        !          12135: {
        !          12136:        //if (this == 0) error('i',"0->expr::typ");
        !          12137:        Pname n;
        !          12138:        Ptype t = 0;
        !          12139:        Ptype t1, t2;
        !          12140:        TOK b = base;
        !          12141:        TOK r1, r2;
        !          12142: #define nppromote(b)   t=np_promote(b,r1,r2,t1,t2,1)
        !          12143: #define npcheck(b)     (void)np_promote(b,r1,r2,t1,t2,0)
        !          12144:        if (tbl->base != TABLE) error('i',"expr::typ(%d)",tbl->base);
        !          12145: 
        !          12146:        DB( if(Tdebug>=1) {
        !          12147:                error('d',"%d->expr::typ(%d) %k %t",this,tbl,b,tp);
        !          12148:                display_expr(this);
        !          12149:        });
        !          12150: // error('d',"%k->typ %n tp: %t", b,b==NAME?this:0,tp);
        !          12151: // error('d',"     e1 %d %k e1 %d %k",e1,e1?e1->base:0,e2,e2?e2->base:0);
        !          12152: 
        !          12153:        if (tp) {
        !          12154:                switch (b) {
        !          12155:                case NAME:
        !          12156: //??                   Pname(this)->use();
        !          12157:                        break;
        !          12158:                case MDOT:
        !          12159:                        mem = mem->typ(tbl);
        !          12160:                }       ;
        !          12161:        //      if (b == NAME) Pname(this)->use();
        !          12162:                return this;
        !          12163:        }
        !          12164: 
        !          12165: extern Pname Ntmp;
        !          12166: 
        !          12167:        switch (b) {            // is it a basic type
        !          12168:        case MDOT:
        !          12169:                error('i',"mdot %s",string2);
        !          12170:        case DUMMY:
        !          12171:                error("emptyE");
        !          12172:                tp = any_type;
        !          12173:                return this;
        !          12174: 
        !          12175:        case ZERO:
        !          12176:                tp = zero_type;
        !          12177:                return this;
        !          12178: 
        !          12179:        case IVAL:
        !          12180:                tp = int_type;
        !          12181:                return this;
        !          12182: 
        !          12183:        //case FVAL:
        !          12184:        //      tp = float_type;
        !          12185:        //      return this;
        !          12186: 
        !          12187:        case ICON:
        !          12188:                /*      is it long?
        !          12189:                        explicit long?
        !          12190:                        decimal larger than largest signed int
        !          12191:                        octal or hexadecimal larger than largest unsigned int
        !          12192:                 */
        !          12193:        {       int ll = strlen(string);
        !          12194:                switch (string[ll-1]) {
        !          12195:                case 'l':
        !          12196:                case 'L':
        !          12197:                        switch (string[ll-2]) {
        !          12198:                        case 'u':
        !          12199:                        case 'U':
        !          12200:                                string[ll-2] = 0;
        !          12201:                                tp = ulong_type;
        !          12202:                                goto cast_n_save;
        !          12203:                        }
        !          12204:                lng:
        !          12205:                        tp = long_type;
        !          12206:                        goto save;
        !          12207:                case 'u':
        !          12208:                case 'U':                       // 1u => unsigned(1)
        !          12209:                        switch (string[ll-2]) {
        !          12210:                        case 'l':
        !          12211:                        case 'L':
        !          12212:                                string[ll-2] = 0;
        !          12213:                ulng:
        !          12214:                                tp = ulong_type;
        !          12215:                                goto cast_n_save;
        !          12216:                        default:
        !          12217:                                string[ll-1] = 0;
        !          12218:                uint:
        !          12219:                                tp = uint_type;
        !          12220:                                goto cast_n_save;
        !          12221:                        }
        !          12222:                }
        !          12223: 
        !          12224:                // no suffix - see if we can figure it out
        !          12225:                if  (string[0] == '0') {        // assume 8 bits in byte
        !          12226:                        register index = 1;
        !          12227:                        switch (string[1]) {
        !          12228:                        case 'x':
        !          12229:                        case 'X':
        !          12230:                                while(string[++index]=='0') ;
        !          12231:                                ll -= index;
        !          12232:                                int HSZ = SZ_INT+SZ_INT;
        !          12233:                                if(ll < HSZ) goto nrm;
        !          12234:                                if(ll == HSZ)
        !          12235:                                        if(string[2]>='8') goto uint;
        !          12236:                                        else goto nrm;
        !          12237:                                if(SZ_INT==SZ_LONG) break;
        !          12238:                                HSZ = SZ_LONG+SZ_LONG;
        !          12239:                                if(ll < HSZ) goto lng;
        !          12240:                                if(ll == HSZ)
        !          12241:                                        if(string[2]>='8') goto ulng;
        !          12242:                                        else goto lng;
        !          12243:                                break;
        !          12244:                        default:   // OCTAL
        !          12245:                                register IBITS = BI_IN_BYTE*SZ_INT;
        !          12246:                                while(string[index]=='0') index++;
        !          12247:                                register char x = string[index];
        !          12248:                                int lbt = x=='1' ? 1 :
        !          12249:                                        ( x=='2' || x=='3' ? 2 : 3 );
        !          12250:                                int nbits = (ll-index-1)*3 + lbt;
        !          12251:                                if(nbits < IBITS) goto nrm;
        !          12252:                                if(nbits == IBITS) goto uint;
        !          12253:                                if(nbits < BI_IN_BYTE*SZ_LONG) goto lng;
        !          12254:                        }
        !          12255:                        goto ulng;
        !          12256:                }
        !          12257:                else {  // DECIMAL
        !          12258:                        if (ll<chars_in_largest) {
        !          12259:                nrm:
        !          12260:                                tp = int_type;
        !          12261:                                goto save;
        !          12262:                        }
        !          12263:                        if (ll>chars_in_largest) {
        !          12264:                                if(SZ_INT==SZ_LONG || ll>2*chars_in_largest)
        !          12265:                                        goto ulng;
        !          12266:                                goto lng;
        !          12267:                        }
        !          12268:                        // ll == chars_in_largest
        !          12269:                        char* p = string;
        !          12270:                        char* q = LARGEST_INT;
        !          12271:                        do if (*p>*q) {
        !          12272:                                if(SZ_INT==SZ_LONG) goto ulng;
        !          12273:                                goto lng; 
        !          12274:                        } while (*p++==*q++ && *p);
        !          12275:                }
        !          12276: 
        !          12277:                goto nrm;
        !          12278:        }
        !          12279:        case CCON:
        !          12280:                tp = c_strlen(string)<5 ? char_type : int_type; // stored as 'a'
        !          12281:                goto save;
        !          12282: 
        !          12283:        case FCON:
        !          12284:        {       int ll = strlen(string);
        !          12285:                int last = string[ll-1];
        !          12286:                tp = double_type;
        !          12287:                if (last=='F' || last=='f') {
        !          12288:                        tp = float_type;
        !          12289:                        if (!ansi_opt) {
        !          12290:                                string[ll-1] = 0;
        !          12291:                                goto cast_n_save;
        !          12292:                        }
        !          12293:                }
        !          12294:                else if (last=='L' || last=='l') {
        !          12295:                        if (ansi_opt == 0) string[ll-1] = 0;
        !          12296:                        tp = ldouble_type;
        !          12297:                }
        !          12298:                goto save;
        !          12299:        }
        !          12300:        case STRING:                    // type of "as\tdf" is char[6]
        !          12301:                                        // c_strlen counts the terminating '\0'
        !          12302:        {       Pvec v = new vec(char_type,0);
        !          12303:                v->size = c_strlen(string);
        !          12304:                tp = v;
        !          12305:        }
        !          12306:        save:
        !          12307:                if (const_save) {       // "as\tdf" needs 7 chars for storage
        !          12308:                        char* p = new char[strlen(string)+1];
        !          12309:                        strcpy(p,string);
        !          12310:                        string = p;
        !          12311:                }
        !          12312: 
        !          12313:                return this;
        !          12314: 
        !          12315:        cast_n_save:
        !          12316:                if (const_save) {       // "as\tdf" needs 7 chars for storage
        !          12317:                        char* p = new char[strlen(string)+1];
        !          12318:                        strcpy(p,string);
        !          12319:                        string = p;
        !          12320:                }
        !          12321:                
        !          12322:                return new cast(tp,this);
        !          12323: 
        !          12324:        case THIS:
        !          12325:                delete this;
        !          12326:                if (cc->c_this) {
        !          12327:                        cc->c_this->use();
        !          12328:                        return cc->c_this;
        !          12329:                }
        !          12330:                error("``this'' used in nonC context");
        !          12331:                n = new name("this");
        !          12332:                n->tp = any_type;
        !          12333:                return tbl->insert(n,0); 
        !          12334: 
        !          12335:        case NAME:
        !          12336:        {       
        !          12337:                Pname q = Pname(this)->n_qualifier; // suppress virtual iff x::
        !          12338:                Pexpr ee = find_name(Pname(this),cc->cot,tbl,0,cc->nof);
        !          12339:                if (q && (ee->base==REF || ee->base==DOT))
        !          12340:                        ee->n_initializer = Pexpr(q);
        !          12341: //error('d',"ee %k %t %n",ee->base,ee->tp,ee->base==NAME?ee:ee->base==REF?ee->mem:0);
        !          12342:        //      if (ee->tp->base == RPTR) return ee->contents();
        !          12343:                if (ee->tp->is_ref()) return ee->contents();
        !          12344: 
        !          12345:                if (ee->base==NAME && Pname(ee)->n_xref) {
        !          12346:                // fudge to handle X(X&) args
        !          12347:                        ee = new expr(DEREF,ee,0);
        !          12348:                        ee->tp = ee->e1->tp;    // !!
        !          12349:                }
        !          12350: 
        !          12351:                return ee;
        !          12352:        }
        !          12353: 
        !          12354:        case ADDROF:
        !          12355:        case G_ADDROF:  // handle lookup for &s::i
        !          12356:                mpglob = 0;
        !          12357:                if (e2->base == NAME) e2 = find_name(Pname(e2),cc->cot,tbl,ADDROF,cc->nof);
        !          12358:                if (e2->base==NAME && Pname(e2)->n_xref) {
        !          12359:                        // fudge to handle X(X&) args
        !          12360:                        e2 = new expr(DEREF,e2,0);
        !          12361:                        e2->tp = e2->e1->tp;    // !!
        !          12362:                }
        !          12363:                if (e2->base==DOT) {    // &f().x  = > &(tmp=f(),&tmp)->x
        !          12364:                        switch (e2->e1->base) {
        !          12365:                        case CALL:
        !          12366:                        case G_CALL:
        !          12367:                        case VALUE:
        !          12368:                                error("& non-lvalue");
        !          12369:                        }
        !          12370:                }
        !          12371:                break;
        !          12372: 
        !          12373:        case SIZEOF:
        !          12374:                if (tp2) {      
        !          12375:                        tp2->dcl(tbl);
        !          12376:                        switch (tp2->base) {
        !          12377:                        case VOID:
        !          12378:                                error("sizeof(void)");
        !          12379:                                break;
        !          12380:                        case CLASS:
        !          12381:                        {
        !          12382:                                Pclass cl = Pclass(tp2);
        !          12383:                                if (cl->c_body==1
        !          12384:                                && (cl->defined&(DEFINED|SIMPLIFIED)) == 0) 
        !          12385:                                        error('s',"class defined within sizeof");
        !          12386:                        }
        !          12387:                        }
        !          12388:        
        !          12389:                        if (e1 && e1!=dummy) {
        !          12390:                                e1 = e1->typ(tbl);
        !          12391:                                DEL(e1);
        !          12392:                                e1 = dummy;
        !          12393:                        }
        !          12394:                        Pptr r = tp2->is_ref();
        !          12395:                        if (r) tp2 = r->typ;    // sizeof(T&)==sizeof(T)
        !          12396:                }
        !          12397:                else if (e1 == dummy) {
        !          12398:                        error("sizeof emptyE");
        !          12399:                        tp = any_type;
        !          12400:                        return this;
        !          12401:                }
        !          12402:                else {
        !          12403:                        e1 = e1->typ(tbl);
        !          12404:                        tp2 = e1->tp;
        !          12405:                        if(tp2->base == VEC) tp2->permanent = 1;
        !          12406:                        if (e1->base==ILIST)    // PtoM
        !          12407:                                e1 = dummy;
        !          12408:                        else if (tp2 == char_type)      // sizeof ('a')
        !          12409:                                e1 = dummy;
        !          12410:                }
        !          12411:                (void) tp2->tsizeof();
        !          12412:                tp = size_t_type;
        !          12413:                return this;
        !          12414: 
        !          12415:        case CAST:
        !          12416: //             return docast(tbl);
        !          12417: 
        !          12418:        {       Pexpr ee = docast(tbl);
        !          12419:                return ee->tp->is_ref() ? ee->contents() : ee;
        !          12420:        }
        !          12421: 
        !          12422: 
        !          12423:        case VALUE:
        !          12424:                 if ( tp2->base == COBJ || tp2->base == EOBJ) {
        !          12425:                         char *s = Pbase(tp2)->b_name->string;
        !          12426:                         //Pname tn = gtbl->look( s, 0 );
        !          12427:                        //??? non type name apparently takes precedence
        !          12428:                        //    Don't use global ftn if it hides local
        !          12429:                        //    class ctor.  (Note: More info is needed
        !          12430:                        //    to detect all cases.)
        !          12431:                         Pname tn = tbl->look( s, 0 );
        !          12432: //error( 'd', "tn: %n %t lex_levels: %d %d", tn, tn?tn->tp:0, tn?tn->lex_level:0, Pbase(tp2)->b_name->lex_level );
        !          12433:                        if ( tn && tn->n_qualifier == 0
        !          12434:                        &&   tn->lex_level == Pbase(tp2)->b_name->lex_level
        !          12435:                        &&   (tn->tp->base==FCT || tn->tp->base==OVERLOAD)) 
        !          12436:                        {
        !          12437:                                 Pexpr et = new expr( CALL, tn, e1 );
        !          12438:                                 *this = *et;
        !          12439:                                 b = CALL;
        !          12440:                                 break;
        !          12441:                        }
        !          12442:                }
        !          12443:                return dovalue(tbl);
        !          12444: 
        !          12445:        case NEW:
        !          12446:        case GNEW:
        !          12447:                return donew(tbl);
        !          12448: 
        !          12449:        case DELETE:    // delete e1 OR delete[e2] e1
        !          12450:        case GDELETE:
        !          12451:        {       int i;
        !          12452:                if (e1->base == ADDROF) error('w',"delete &E");
        !          12453:                e1 = e1->typ(tbl);
        !          12454:                i = e1->tp->num_ptr(DELETE);
        !          12455:                if (i != 'P') error("nonP deleted");
        !          12456:                if (e2) {
        !          12457:                        e2 = e2->typ(tbl);
        !          12458:                        e2->tp->integral(DELETE);
        !          12459:                }
        !          12460:                tp = void_type;
        !          12461:                return this;
        !          12462:        }
        !          12463: 
        !          12464:        case ILIST:     /* an ILIST is pointer to an ELIST */
        !          12465:                e1 = e1->typ(tbl);
        !          12466:                tp = any_type;
        !          12467:                return this;
        !          12468: 
        !          12469:        case ELIST:
        !          12470:        {       Pexpr e;
        !          12471:                Pexpr ex;
        !          12472: 
        !          12473:                if (e1 == dummy && e2==0) {
        !          12474:                        error("emptyIrL");
        !          12475:                        tp = any_type;
        !          12476:                        return this;
        !          12477:                }
        !          12478:                                
        !          12479:                for (e=this; e; e=ex) {
        !          12480:                        Pexpr ee = e->e1;
        !          12481: //error('d',"e %d %d ee %d %d",e,e?e->base:0,ee,ee?ee->base:0);
        !          12482:                        if (e->base != ELIST) error('i',"elist%k",e->base);
        !          12483:                        if (ex = e->e2) {       /* look ahead for end of list */
        !          12484:                                if (ee == dummy) error("EX in EL");
        !          12485:                                if (ex->e1 == dummy && ex->e2 == 0) {
        !          12486:                                        /* { ... , } */
        !          12487:                                        DEL(ex);
        !          12488:                                        e->e2 = ex = 0;
        !          12489:                                }
        !          12490:                        }
        !          12491:                        e->e1 = ee->typ(tbl);
        !          12492:                        t = e->e1->tp;
        !          12493:                        if (t->base == FCT) {   // yuk!
        !          12494:                                ee = new expr(G_ADDROF,0,e->e1);
        !          12495:                                e->e1 = ee->typ(tbl);
        !          12496:                                t = e->e1->tp;
        !          12497:                        }
        !          12498:                }
        !          12499:                tp = t;
        !          12500:                return this;
        !          12501:        }
        !          12502: 
        !          12503:        case DOT:
        !          12504:        case REF:
        !          12505:        {       if (e2) { // *. or ->*
        !          12506:                        if (b == REF) b = base = REFMUL;
        !          12507:                        break;
        !          12508:                }
        !          12509: 
        !          12510:                Pbase b;
        !          12511: 
        !          12512:                e1 = e1->typ(tbl);
        !          12513:                t = e1->tp;
        !          12514: 
        !          12515:                // check that . (->) is applied to class object (pointer)
        !          12516:                if (base == REF) {
        !          12517:                xxx:
        !          12518:                        switch (t->base) {
        !          12519:                        case TYPE:
        !          12520:                                t = Pbase(t)->b_name->tp;
        !          12521:                                goto xxx;
        !          12522:                        case COBJ:
        !          12523:                        {       Pname n = Pclass(Pbase(t)->b_name->tp)->has_oper(REF);
        !          12524:                                if (n) {
        !          12525:                                        n->n_used += 2;
        !          12526:                                        e1 = new call(new ref(DOT,e1,n),0);
        !          12527:                                        return typ(tbl);
        !          12528:                                }
        !          12529:                                // no break;
        !          12530:                        }
        !          12531:                        default:
        !          12532:                                error("nonP ->%n",mem);
        !          12533:                                t = any_type;
        !          12534:                                // no break;
        !          12535:                        case ANY:
        !          12536:                                goto qqq;
        !          12537:                        case PTR:
        !          12538:                        case VEC:
        !          12539:                                b = Pbase(Pptr(t)->typ);
        !          12540:                        }
        !          12541:                }
        !          12542:                 else {  // base == DOT
        !          12543:                qqq:
        !          12544:                        switch (t->base) {
        !          12545:                        case TYPE:      t = Pbase(t)->b_name->tp;       goto qqq;
        !          12546:                        default:        error("nonO .%n",mem); t = any_type;
        !          12547:                        case ANY:
        !          12548:                        case COBJ:      break;
        !          12549:                        }
        !          12550: //error('d',"dot %k",e1->base);
        !          12551:                        switch (e1->base) { 
        !          12552:                        case QUEST:
        !          12553:                        case ASSIGN:
        !          12554:                        case INCR:
        !          12555:                        case DECR:
        !          12556:                        case ASPLUS:
        !          12557:                        case ASMINUS:
        !          12558:                        case ASMUL:
        !          12559:                        case ASDIV:
        !          12560:                        case ASMOD:
        !          12561:                        case ASAND:
        !          12562:                        case ASOR:
        !          12563:                        case ASER:
        !          12564:                        case ASLS:
        !          12565:                        case ASRS:
        !          12566:                        case CM:
        !          12567:                        case G_CM:
        !          12568:                                base = REF;
        !          12569:                                e1 = e1->address();
        !          12570:                                break;
        !          12571:                         case CALL:
        !          12572:                         case G_CALL:
        !          12573: //error('d'," f().  %n mem->tp %t",e1->fct_name,mem->tp);
        !          12574: #ifdef FDOTRIGHT
        !          12575: // this rewrite is only necessary on machines with broken C compilers
        !          12576: // there seems to be a lot of those
        !          12577: // and for inlines (a,b).c
        !          12578:                         if (e1->fct_name && Pfct(e1->fct_name->tp)->f_inline)
        !          12579: #endif
        !          12580:                         {       // f(). => (tmp=f(),&tmp)->
        !          12581:                                 Pname tmp = make_tmp('Q',e1->tp,tbl);
        !          12582: //error('d',"fdot2 %k",e1->base);
        !          12583:                                 e1 = init_tmp(tmp,e1,tbl);
        !          12584:                                 Pexpr aa = tmp->address();
        !          12585:                                 e1 = new expr(G_CM,e1,aa);
        !          12586:                                 e1->tp = aa->tp;
        !          12587:                                 base = REF;
        !          12588:                                 break;
        !          12589:                         }
        !          12590:                         }
        !          12591:                        b = Pbase(t);
        !          12592:                }
        !          12593: 
        !          12594:        xxxx:
        !          12595:                switch (b->base) {
        !          12596:                case TYPE:
        !          12597:                        b = Pbase(b->b_name->tp);
        !          12598:                        goto xxxx;
        !          12599:                default:
        !          12600:                        error("(%t) before %k%n (%n not aM)",e1->tp,base,mem,mem);
        !          12601:                case ANY:
        !          12602:                        tp = any_type;
        !          12603:                        return this;
        !          12604:                case COBJ:
        !          12605:                {       Pclass cl = Pclass(Pbase(b)->b_name->tp);
        !          12606:                        if (cl->c_body == 1) cl->dcl_print(0);
        !          12607:                        break;
        !          12608:                }
        !          12609:                }       
        !          12610: 
        !          12611: /*
        !          12612:        x.m is not a const even if x is a const object, this case is handled
        !          12613:        by lval() rejecting it
        !          12614: */
        !          12615: 
        !          12616:                if (mem->tp) {
        !          12617:                        tp = mem->tp;
        !          12618:                        for (Pexpr ee = mem; ee->base==REF; ee = ee->e1) {
        !          12619:                                if (ee->e1 == cc->c_this) { // this-> => p->
        !          12620:                                        ee->e1 = e1;
        !          12621:                                        ee->base = base;
        !          12622:                                        return mem->tp->is_ref() ? mem->contents() : mem;
        !          12623:                                }
        !          12624:                        }
        !          12625: 
        !          12626:                //      return tp->base==RPTR ? contents() : this;
        !          12627:                        return tp->is_ref() ? contents() : this;
        !          12628:                }
        !          12629: 
        !          12630:                
        !          12631:                Pname q = Pname(mem)->n_qualifier;
        !          12632:                Pexpr e = find_name(Pname(mem),Pclass(b->b_name->tp),0,base,cc->nof);           
        !          12633:                if (q && (e->base==REF || e->base==DOT))
        !          12634:                        Pname(e)->n_initializer = Pexpr(q);
        !          12635: //error('d',"e %k %t %n",e->base,e->tp,e->base==NAME?e:e->base==REF?e->mem:0); 
        !          12636: 
        !          12637:                for (Pexpr ee = e; ee->base==REF; ee = ee->e1) {
        !          12638:                        if (ee->e1 == cc->c_this) { // this-> => p->
        !          12639:                                ee->e1 = e1;
        !          12640:                                ee->base = base;
        !          12641:                                break;
        !          12642:                        }
        !          12643:                }
        !          12644: 
        !          12645:                if (e->base == NAME) {
        !          12646:                        switch (e->tp->base) {
        !          12647:                        case FCT:
        !          12648:                        case OVERLOAD:
        !          12649:                                mem = e;
        !          12650:                                tp = e->tp;
        !          12651:                                e = this;
        !          12652:                        }
        !          12653:                }
        !          12654:                        
        !          12655:                        // function or static member
        !          12656:                return e->tp->is_ref() ? e->contents() : e;
        !          12657:        }
        !          12658: 
        !          12659: //??   case G_CALL:
        !          12660:        case CALL:      /* handle undefined function names */
        !          12661: //error('d',"call %k %t %k",e1->base,e1->tp,e2?e2->base:0);
        !          12662:                if (e1->base==NAME && e1->tp==0) {
        !          12663:                        Pname q = Pname(e1)->n_qualifier;
        !          12664:                        e1 = find_name(Pname(e1),cc->cot,tbl,CALL,cc->nof);
        !          12665: //error('d',"e1 %k %t %n",e1->base,e1->tp,e1->base==NAME?e1:e1->base==REF?e1->mem:0);
        !          12666:                        if (q && (e1->base==REF ||e1->base==DOT)) // suppress virtual call
        !          12667:                                e1->n_initializer = Pexpr(q);
        !          12668:                }
        !          12669: 
        !          12670:                if (e1->base==NAME && Pname(e1)->n_xref) {
        !          12671:                        // fudge to handle X(X&) args
        !          12672:                        e1 = new expr(DEREF,e1,0);
        !          12673:                        e1->tp = e1->e1->tp;    // !!
        !          12674:                }
        !          12675: 
        !          12676:                switch (e1->base) {
        !          12677:                case DOT:
        !          12678: /*
        !          12679: #ifdef FDOTRIGHT
        !          12680:                {
        !          12681: //error('d',"fdot1 %k",e1->e1->base);
        !          12682:                        switch (e1->e1->base) {
        !          12683:                        case CALL:
        !          12684:                        case G_CALL:    // f().g() => (tmp=f(),tmp.g())
        !          12685:                        {       Pexpr ee = e1->e1;
        !          12686:                                Pexpr ex = ee->typ(tbl);
        !          12687:                                Pname tmp = make_tmp('Q',ex->tp,tbl);
        !          12688:                                ex = init_tmp(tmp,ex,tbl);
        !          12689: 
        !          12690:                                Pexpr ee2 = new expr(base,e1,e2);
        !          12691:                                e1->base = DOT;
        !          12692:                                e1->e1 = tmp;
        !          12693: 
        !          12694:                                base = G_CM;
        !          12695:                                e1 = ex;
        !          12696:                                e2 = ee2;
        !          12697: 
        !          12698:                                return typ(tbl);
        !          12699:                        }
        !          12700:                        }
        !          12701:                        break;
        !          12702:                }
        !          12703: #endif
        !          12704: */
        !          12705:                case REF:                       // becomes ob.x::~x(0) or
        !          12706:                        if (e2==0               // becomes p->x::~x(0)
        !          12707:                        && Pref(e1)->mem 
        !          12708:                        && Pref(e1)->mem->base==NAME
        !          12709:                        && Pname(Pref(e1)->mem)->n_oper==DTOR) {
        !          12710:                                e1 = e1->typ(tbl);
        !          12711:                                Pexpr ee = call_dtor(e1->e1,Pref(e1)->mem,0,e1->base,one);
        !          12712:                                ee->tp = void_type;
        !          12713:                                return ee;
        !          12714:                        }
        !          12715:                }
        !          12716:                break;
        !          12717: 
        !          12718:        case QUEST:
        !          12719:                cond = cond->typ(tbl);
        !          12720:        case ANDAND:
        !          12721:        case OROR:
        !          12722:                Ntmp = 0;
        !          12723:        }
        !          12724: 
        !          12725:        if (e1) {
        !          12726:                e1 = e1->typ(tbl);
        !          12727:                if (e1->tp->is_ref()) e1 = e1->contents();
        !          12728:                t1 = e1->tp;
        !          12729:        //      if (t1->is_cl_obj()) t1->tsizeof();
        !          12730:        }
        !          12731:        else
        !          12732:                t1 = 0;
        !          12733: 
        !          12734:        if (e2) {
        !          12735:                e2 = e2->typ(tbl);
        !          12736:                if (e2->tp->is_ref()) e2 = e2->contents();
        !          12737:                t2 = e2->tp;
        !          12738:        //      if (t2->is_cl_obj()) t2->tsizeof();
        !          12739:        }
        !          12740:        else 
        !          12741:                t2 = 0;
        !          12742: 
        !          12743: // error('d',"b %k t1 %t t2 %t",b,t1,t2);
        !          12744:        switch (b) {    // filter out non-overloadable operators
        !          12745:        default:
        !          12746:        {       
        !          12747:                Pexpr x = try_to_overload(tbl);
        !          12748:                if (x) {
        !          12749:                        if (b==INCR || b==DECR) {
        !          12750:                                Pexpr fe = x->e1->base==NAME?x->e1:x->e1->mem;
        !          12751:                                // by default, prefix version of operator is chosen
        !          12752:                                // t2 set ==> ++n, t1 set ==> n++
        !          12753:                                if (fe->tp->base==OVERLOAD && t2==0 && t1) 
        !          12754:                                        x=make_postfix(x);
        !          12755:                        }       
        !          12756:                        return x;
        !          12757:                }
        !          12758: //             if (x) return x;
        !          12759: // error('d',"e2: %t t2: %t", e2->tp, t2);
        !          12760:                if (t2 && t1==0 && t2!=e2->tp) t2 = e2->tp;
        !          12761:        }
        !          12762:        case DOT:
        !          12763:        case G_CM:
        !          12764:        case G_ADDROF:
        !          12765:        case G_CALL:
        !          12766:        case QUEST:
        !          12767:                break;
        !          12768:        }
        !          12769: 
        !          12770:        switch (b) {
        !          12771:        case QUEST:
        !          12772:        case ANDAND:
        !          12773:        case OROR:
        !          12774:                if (Ntmp) error('s',"temporary ofC%n with destructor needed in%kE",Ntmp,b);
        !          12775:        }
        !          12776: 
        !          12777:        t = (t1==0) ? t2 : (t2==0) ? t1 : 0;
        !          12778: // error('d', "expr::typ t %t", t );
        !          12779: // error('d',"b2 %d %k",b,b);
        !          12780:        switch (b) {            /* are the operands of legal types */
        !          12781:        case REFMUL:
        !          12782:                base = REF;
        !          12783:                // no break;
        !          12784:        case DOT:
        !          12785:        {       // a .* p => &a MEMPTR p => appropriate indirection
        !          12786:                        // to be considered: what happens if a .* expression
        !          12787:                        // is used except in a call/=?
        !          12788:                Pexpr a = e1->typ(tbl);
        !          12789:                Ptype at = a->tp;
        !          12790:                if (base == DOT) {
        !          12791:                        a = a->address();
        !          12792:                        at = at->addrof();      // beware of n_xref
        !          12793:                }
        !          12794: 
        !          12795:                while (at->base == TYPE) at = Pbase(at)->b_name->tp;
        !          12796:                Pname cn = Pptr(at)->typ->is_cl_obj();
        !          12797:                Pclass mm = cn ? Pclass(cn->tp) : 0;
        !          12798: 
        !          12799:                Pexpr p = e2->typ(tbl);
        !          12800:                Ptype pt = p->tp;
        !          12801:                Pname pcn = pt->is_cl_obj();
        !          12802: 
        !          12803: //error('d',"mm %t pt %t",mm,pt);
        !          12804:                if (pcn) {
        !          12805:                        Pclass cl = Pclass(pcn->tp);
        !          12806:                        Pname found = 0;
        !          12807:                        for (Pname on=cl->conv; on; on=on->n_list) {
        !          12808:                                Pfct f = Pfct(on->tp);
        !          12809:                                Pptr frt = Pptr(f->returns);
        !          12810:                                while (frt->base == TYPE) frt = Pptr(Pbase(frt)->b_name->tp);
        !          12811:                                if (frt->base!=PTR || Pptr(frt)->memof==0) break;
        !          12812:                                if (Pptr(frt)->memof==mm || mm->has_base(Pptr(frt)->memof)) {
        !          12813:                                        if (found)
        !          12814:                                                error("two possible conversions forP toM: %n and %n",found,on);
        !          12815:                                        else
        !          12816:                                                found = on;
        !          12817:                                }
        !          12818:                        }
        !          12819: //error('d',"found %n",found);
        !          12820:                        if (found) {
        !          12821:                                p = new ref(DOT,p,found);
        !          12822:                                p = new call(p,0);
        !          12823:                                p = p->typ(tbl);
        !          12824:                                pt = p->tp;
        !          12825:                        }
        !          12826:        
        !          12827:                }
        !          12828:                while (pt->base == TYPE) pt = Pbase(pt)->b_name->tp;
        !          12829:                if (pt->base!=PTR || Pptr(pt)->memof==0) {
        !          12830:                        error("P toMX in .*E: %t",pt);
        !          12831:                        tp = any_type;
        !          12832:                        base = DUMMY;
        !          12833:                        return this;
        !          12834:                }
        !          12835:                Pclass pm = Pptr(pt)->memof;
        !          12836: 
        !          12837:        //      while (at->base == TYPE) at = Pbase(at)->b_name->tp;
        !          12838:        //      Pname cn = Pptr(at)->typ->is_cl_obj();
        !          12839:        //      Pclass mm = cn ? Pclass(cn->tp) : 0;
        !          12840: //error('d',"mm %t %t %d %d",mm,pm,pm->baseof(mm),mm->has_base(pm));
        !          12841: 
        !          12842:        //      if (mm!=pm && pm->baseof(mm)==0 && mm->has_base(pm)==0) {
        !          12843:                if (mm != pm) {
        !          12844:                        if (mm->has_base(pm) == 0) {
        !          12845:                                error("badOT in .*E: %t (%s*X)",a->tp,pm->string);
        !          12846:                                tp = any_type;
        !          12847:                                //return this;
        !          12848:                        }
        !          12849:                        a = new texpr(CAST,pm->this_type,a);
        !          12850:                        e1 = a = a->typ(tbl);
        !          12851:                }
        !          12852: 
        !          12853:                Ptype tpx = Pptr(pt)->typ;
        !          12854:                while (tpx->base == TYPE) tpx = Pbase(tpx)->b_name->tp;
        !          12855: 
        !          12856:                if (tpx->base == FCT) { // a.*p => (&a MEMPTR p)
        !          12857:                        base = MEMPTR;
        !          12858:                        tp2 = mm;       // keep the class for simpl.c
        !          12859:                        e1 = a;
        !          12860:                        e2 = p;
        !          12861:                }
        !          12862:                else {  // a .* p => *(typeof(p))((char*)&a + (int)p-1)
        !          12863:                        a = new cast(Pchar_type,a);
        !          12864:                        p = new cast(int_type,p);
        !          12865:                        p = new expr(MINUS,p,one);
        !          12866:                        p->tp = int_type;
        !          12867:                        Pexpr pl = new expr(PLUS,a,p);
        !          12868:                        pl->tp = Pchar_type;
        !          12869:                        base = DEREF;
        !          12870:                        pt = new ptr(PTR,tpx);  // need a T* not a T C::*
        !          12871:                        Pptr(pt)->rdo = Pptr(tpx)->rdo;
        !          12872:                        mpglob = pm;
        !          12873:                //      PERM(pt);
        !          12874:                        e1 = new cast(pt,pl);
        !          12875:                        e2 = 0;
        !          12876:                }
        !          12877:                tp = tpx;
        !          12878:                return tp->is_ref() ? contents() : this;
        !          12879:        }
        !          12880: 
        !          12881:        case G_CALL:
        !          12882:        case CALL:
        !          12883:                tp = call_fct(tbl);     /* two calls of use() for e1's names */
        !          12884:                if (tp->is_ref()) return contents();
        !          12885:                return this;
        !          12886: 
        !          12887:        case DEREF:
        !          12888:                if (e1 == dummy) error("O missing before []\n");
        !          12889:                if (e2 == dummy) error("subscriptE missing");
        !          12890: 
        !          12891:                if (t) {        /*      *t      */
        !          12892:                        while (t->base == TYPE) t = Pbase(t)->b_name->tp;
        !          12893:                //      t->vec_type();
        !          12894:                        if (t->base==PTR && Pptr(t)->memof) error("P toM dereferenced");
        !          12895:                        tp = t->deref();
        !          12896:                }
        !          12897:                else {                                  // e1[e2] that is *(e1+e2)
        !          12898: //error('d',"deref %t[%t]",t1,t2);
        !          12899:                        if (t1->vec_type()) {           // e1[e2]
        !          12900:                                switch (t2->base) {
        !          12901:                                case CHAR:
        !          12902:                                case SHORT:
        !          12903:                                case INT:
        !          12904:                                case LONG:
        !          12905:                                case EOBJ:
        !          12906:                                        break;
        !          12907:                                default:
        !          12908:                                {       Pname cn = t2->is_cl_obj();
        !          12909:                                        if (cn) // conversion to integral?
        !          12910:                                                e2 = check_cond(e2,DEREF,tbl);
        !          12911:                                        else
        !          12912:                                                t2->integral(DEREF);
        !          12913:                                }
        !          12914:                                }
        !          12915:                                while (t1->base == TYPE) t1 = Pbase(t1)->b_name->tp;
        !          12916:                                if (t1->base==PTR && Pptr(t1)->memof) error("P toM dereferenced");
        !          12917:                                tp = t1->deref();
        !          12918:                                (void) tp->tsizeof();
        !          12919:                        }
        !          12920:                        else if (t2->vec_type()) {      // really e2[e1]
        !          12921:                                t1->integral(DEREF);
        !          12922:                                while (t2->base == TYPE) t2 = Pbase(t2)->b_name->tp;
        !          12923:                                if (t2->base==PTR && Pptr(t2)->memof) error("P toM dereferenced");
        !          12924:                                tp = t2->deref();
        !          12925:                                (void) tp->tsizeof();
        !          12926:                        }
        !          12927:                        else {
        !          12928:                                error("[] applied to nonPT:%t[%t]",t1,t2);
        !          12929:                                tp = any_type;
        !          12930:                        }
        !          12931:                }
        !          12932: 
        !          12933:                if (tp->is_ref()) return contents();
        !          12934: 
        !          12935:                return this;
        !          12936: 
        !          12937:        case G_ADDROF:
        !          12938:        case ADDROF:
        !          12939: //error('d',"addrof(%d) %k %d",base,e2->base,e2->base);
        !          12940:                switch (e2->base) {     // potential lvalues
        !          12941:                case G_CM:
        !          12942:                        if (base==ADDROF && e2->e2->base==NAME) {
        !          12943:                                // check for cfront generated result variable
        !          12944:                                char* s = e2->e2->string;
        !          12945:                                if (s[0]=='_' && s[1] && s[1]=='_') {
        !          12946:                                        if (s[2] && (s[2]=='R' || s[2]=='V')) {
        !          12947:                                                error("address of non-lvalue");
        !          12948:                                                break;
        !          12949:                                        }
        !          12950:                                }
        !          12951:                        }
        !          12952:                case CM:        // &(a,b) => (a,&b)
        !          12953:                {
        !          12954:                        Pexpr ee = e2;
        !          12955:                        ee->tp = 0;
        !          12956:                        ee->e2 = new expr(base,0,ee->e2);
        !          12957:                        delete this;
        !          12958:                        return ee->typ(tbl);
        !          12959:                }
        !          12960:                case QUEST:     // & (a?b:c) => (a?&b:&c)
        !          12961:                {
        !          12962:                        Pexpr ee = e2;
        !          12963:                        ee->tp = 0;
        !          12964:                        ee->e1 = new expr(base,0,ee->e1);
        !          12965:                        ee->e2 = new expr(base,0,ee->e2);
        !          12966:                        delete this;
        !          12967:                        return ee->typ(tbl);
        !          12968:                }
        !          12969:                case INCR:
        !          12970:                case DECR:
        !          12971:                        if (e2->e1) break;
        !          12972:                case ASSIGN:
        !          12973:                case ASPLUS:
        !          12974:                case ASMINUS:
        !          12975:                case ASMUL:
        !          12976:                case ASDIV:
        !          12977:                case ASMOD:
        !          12978:                case ASAND:
        !          12979:                case ASOR:
        !          12980:                case ASER:
        !          12981:                case ASLS:
        !          12982:                case ASRS:
        !          12983:                        return e2->address();
        !          12984:                }
        !          12985: 
        !          12986:                if (e2->lval(ADDROF) == 0) {
        !          12987:                        if (error_count) {      // error_count == 0 possible
        !          12988:                                                // in case of & const
        !          12989:                                tp = any_type;
        !          12990:                                return this;
        !          12991:                        }
        !          12992:                }
        !          12993: 
        !          12994:                tp = t->addrof();
        !          12995: 
        !          12996:                if( base==ADDROF && mpglob)
        !          12997:                        Pptr(tp)->memof = mpglob;
        !          12998: 
        !          12999:                if (e2->tp->base == VEC) {
        !          13000:                        if(e2->base != NAME) {
        !          13001:                                base = CAST;
        !          13002:                                tp2 = tp;
        !          13003:                                e1 = e2;
        !          13004:                                e2 = 0;
        !          13005:                                return this;
        !          13006:                        }
        !          13007:                }
        !          13008: 
        !          13009:        //      tp = t->addrof();
        !          13010: 
        !          13011:                if (t->base==FCT) 
        !          13012:                        Pptr(tp)->memof = Pfct(t)->memof;
        !          13013: 
        !          13014: //             if (t->tconst() && vec_const==0 && fct_const==0) Pptr(tp)->rdo = 1;
        !          13015: // ??? & (const T) is NOT T*const but const T*
        !          13016: 
        !          13017:                switch (e2->base) {
        !          13018:                case NAME:
        !          13019:                mname:                                  // check for &s::i
        !          13020:                {       Pname n2 = Pname(e2);
        !          13021:                        Pname cn = (n2->n_table && n2->n_table!=gtbl) ? n2->n_table->t_name : 0;
        !          13022: // error('d',"n2 %k cn %n t %t",n2->base,cn,t);
        !          13023:                        if (cn == 0) break;
        !          13024:                //      Pptr(tp)->memof = Pclass(cn->tp);
        !          13025: 
        !          13026:                        if (t->base==FCT && Pfct(t)->f_this==0) {
        !          13027:                                Pptr(tp)->memof = 0;
        !          13028:                                break;
        !          13029:                        }
        !          13030: 
        !          13031:                        switch (t->base) {
        !          13032:                        case OVERLOAD:
        !          13033:                                return e2;
        !          13034:                        case FCT:
        !          13035: // error('d', "cn->tp: %d, %k", cn->tp, cn->tp->base);
        !          13036:                                Pptr(tp)->memof = Pclass(cn->tp); //SSS
        !          13037:                                
        !          13038:                                if (Pfct(t)->f_virtual) {
        !          13039:                                        // { 0,vtbl index,0 }
        !          13040:                                        e1 = new ival(Pfct(t)->f_virtual);
        !          13041:                                        e1 = new expr(ELIST,zero,e1);
        !          13042:                                        e2 = zero;
        !          13043:                                        base = ILIST;
        !          13044:                                //      tp = int_type;
        !          13045:                                        return this;
        !          13046:                                }               // use the pointer
        !          13047:                                
        !          13048:                                // { 0,-1,(int(*)())ptr }
        !          13049:                                e1 = new ival(-1);
        !          13050:                                e1 = new expr(ELIST,zero,e1);
        !          13051:                                // e2 is the name
        !          13052:                                e2 = new cast(Pfct_type,e2);
        !          13053:                                base = ILIST;
        !          13054:                        //      tp = int_type;
        !          13055:                                return this;
        !          13056: 
        !          13057:                        //      return e2;
        !          13058: 
        !          13059:                        default:
        !          13060:                                if (n2->n_stclass != STATIC) {  // offset + 1
        !          13061: //error('d',"n2 %n %d",n2,n2->n_offset);
        !          13062: //error('d',"q %n cn %n",n2->n_qualifier,cn);
        !          13063:                                        e1 = new ival(n2->n_offset+1);
        !          13064:                                        Pptr(tp)->memof = Pclass(cn->tp);
        !          13065: //error('d',"cl %d %s i %d",Pclass(cn->tp),Pclass(cn->tp)?Pclass(cn->tp)->string:"0",n2->n_offset);
        !          13066:                                }
        !          13067:                                else
        !          13068:                                        return this;
        !          13069:                        }
        !          13070: //error('d',"int_type");
        !          13071:                        e1->tp = int_type;
        !          13072:                        e2 = 0;
        !          13073:                        tp2 = tp;
        !          13074:                        base = CAST;
        !          13075:                        return this;
        !          13076:                }
        !          13077:                case DOT:
        !          13078:                 case REF:
        !          13079:                 {       
        !          13080:                         Pname m = Pname(e2->mem);
        !          13081: // error( 'd', "e2->mem->base: %k", e2->mem->base );
        !          13082: //                      Pname m = (e2->mem->base == MDOT) ? Pname(e2->mem->mem) : Pname(e2->mem);
        !          13083:                        while ( m->base == MDOT ) m = Pname(Pexpr(m)->mem);
        !          13084: 
        !          13085:                        Pfct f = Pfct(m->tp);
        !          13086: 
        !          13087:                        if (f->base == FCT || f->base == OVERLOAD) {  // &p->f
        !          13088:                                Pexpr q = Pname(e2)->n_initializer;  // &p->x::f
        !          13089: 
        !          13090:                                if (q && bound==0 && e2->e1==cc->c_this) {      
        !          13091:                                        // FUDGE: &this->x::f => &x::f
        !          13092:                                        DEL(e2);
        !          13093:                                        e2 = m;
        !          13094:                                        goto mname;
        !          13095:                                }
        !          13096: 
        !          13097:                                bound = 1;
        !          13098:                                if(!f->f_static) {
        !          13099:                                        error(strict_opt?0:'w',
        !          13100:                                            "address of boundF (try using ``%s::*'' forPT and ``&%s::%s'' for address) (anachronism)",
        !          13101:                                            m->n_table->t_name->string,
        !          13102:                                            m->n_table->t_name->string,
        !          13103:                                            m->string
        !          13104:                                        );
        !          13105:                                }
        !          13106: 
        !          13107:                                if (q || f->f_virtual==0) {
        !          13108:                                        // & x.f  =>  & f
        !          13109:                                        DEL(e2);
        !          13110:                                        e2 = m;
        !          13111:                                }
        !          13112:                        }
        !          13113:                        break;
        !          13114: 
        !          13115:                }
        !          13116:                case MEMPTR:
        !          13117:                        // &(p->*q)
        !          13118:                        error("& .* E");
        !          13119:                }
        !          13120: 
        !          13121:                return this;
        !          13122: 
        !          13123:        case UMINUS:
        !          13124:                t->numeric(UMINUS);
        !          13125:                tp = t;
        !          13126:                return this;
        !          13127: 
        !          13128:        case UPLUS:
        !          13129:                t->num_ptr(UPLUS);
        !          13130:                tp = t;
        !          13131:                if (ansi_opt==0) {
        !          13132:                        base = PLUS;
        !          13133:                        e1 = zero;
        !          13134:                }
        !          13135:                return this;
        !          13136: 
        !          13137:        case NOT:
        !          13138:                e2 = check_cond(e2,NOT,tbl);
        !          13139:                tp = int_type;
        !          13140:                return this;
        !          13141: 
        !          13142:        case COMPL:
        !          13143:                t->integral(COMPL);
        !          13144:                tp = t;
        !          13145:                return this;
        !          13146: 
        !          13147:        case INCR:
        !          13148:        case DECR:
        !          13149:                {
        !          13150: // error('d',"incr-decr: e1: %k e2: %k", e1?e1->base:0, e2?e2->base:0);
        !          13151:                Pexpr e = e1?e1:e2;     // e1!=0 ==> e++ or e--
        !          13152:                                        // e1==0 ==> ++e or --e
        !          13153: 
        !          13154:                e->lval(b);
        !          13155: 
        !          13156:                switch(e->base) {
        !          13157:                case QUEST:
        !          13158:                        e->tp=0;
        !          13159:                        e->e1 = e1 ? new expr(base,e->e1,0) : new expr(base,0,e->e1);
        !          13160:                        e->e2 = e1 ? new expr(base,e->e2,0) : new expr(base,0,e->e2);
        !          13161:                        delete this;
        !          13162:                        return e->typ(tbl);
        !          13163:                case CM:
        !          13164:                case G_CM:
        !          13165:                        e->tp=0;
        !          13166:                        e->e2 = e1 ? new expr(base,e->e2,0) : new expr(base,0,e->e2);
        !          13167:                        delete this;
        !          13168:                        return e->typ(tbl);
        !          13169:                case INCR:
        !          13170:                case DECR:
        !          13171:                        if(e->e1)
        !          13172:                                break;
        !          13173:                        nin++;
        !          13174:                        if(e->e2->not_simple())
        !          13175:                                error('s',"overly complex %k of %k",b,e->base);
        !          13176:                        nin--;
        !          13177:                        e = new expr(G_CM,e,e->e2->typ(tbl));
        !          13178:                        if (e1) e1=e; else e2=e;
        !          13179:                        // e1?e1:e2 = e;
        !          13180:                        return typ(tbl);
        !          13181:                case ASSIGN:
        !          13182:                case ASPLUS:
        !          13183:                case ASMINUS:
        !          13184:                case ASMUL:
        !          13185:                case ASDIV:
        !          13186:                case ASMOD:
        !          13187:                case ASAND:
        !          13188:                case ASOR:
        !          13189:                case ASER:
        !          13190:                case ASLS:
        !          13191:                case ASRS:
        !          13192:                        nin++;
        !          13193:                        if(e->e1->not_simple())
        !          13194:                                error('s',"overly complex %k of %k",b,e->base);
        !          13195:                        nin--;
        !          13196:                        e = new expr(G_CM,e,e->e1->typ(tbl));
        !          13197:                        if (e1) e1=e; else e2=e;
        !          13198:                        // e1?e1:e2 = e;
        !          13199:                        return typ(tbl);
        !          13200:                }
        !          13201:                }
        !          13202: 
        !          13203:                r1 = t->num_ptr(b);
        !          13204:                if (r1='P' && t->check(Pvoid_type,0)==0) error("%k of void*",b);
        !          13205:                tp = t;
        !          13206:                return this;
        !          13207:        
        !          13208:        }
        !          13209: 
        !          13210:        if (e1==dummy || e2==dummy || e1==0 || e2==0) error("operand missing for%k",b);
        !          13211:        switch (b) {
        !          13212:        case MUL:
        !          13213:        case DIV:
        !          13214:                r1 = t1->numeric(b);
        !          13215:                r2 = t2->numeric(b);
        !          13216:                nppromote(b);
        !          13217:                break;
        !          13218: 
        !          13219:        case PLUS:
        !          13220:                r2 = t2->num_ptr(PLUS);
        !          13221:                r1 = t1->num_ptr(PLUS);
        !          13222:                nppromote(PLUS);
        !          13223:                goto void_check;
        !          13224: 
        !          13225:        case MINUS:
        !          13226:                r2 = t2->num_ptr(MINUS);
        !          13227:                r1 = t1->num_ptr(MINUS);
        !          13228:                if (r2=='P' && r1!='P' && r1!='A') error("nonP - P");
        !          13229:                nppromote(MINUS);
        !          13230:        void_check:
        !          13231:                if ((r1='P' && t1->check(Pvoid_type,0)==0) 
        !          13232:                ||  (r2='P' && t2->check(Pvoid_type,0)==0))
        !          13233:                        error("%k of void*",b);
        !          13234:                tp = t;
        !          13235:                break;
        !          13236: 
        !          13237:        case LS:
        !          13238:        case RS:
        !          13239:        case AND:
        !          13240:        case OR:
        !          13241:        case ER:
        !          13242:                switch (e1->base) {
        !          13243:                case LT:
        !          13244:                case LE:
        !          13245:                case GT:
        !          13246:                case GE:
        !          13247:                case EQ:
        !          13248:                case NE:
        !          13249:                        error('w',"%kE as operand for%k",e1->base,b);
        !          13250:                }
        !          13251:                switch (e2->base) {
        !          13252:                case LT:
        !          13253:                case LE:
        !          13254:                case GT:
        !          13255:                case GE:
        !          13256:                case EQ:
        !          13257:                case NE:
        !          13258:                        error('w',"%kE as operand for%k",e2->base,b);
        !          13259:                }
        !          13260:        case MOD:
        !          13261:                r1 = t1->integral(b);
        !          13262:                r2 = t2->integral(b);
        !          13263:                nppromote(b);
        !          13264:                break;
        !          13265: 
        !          13266:        case LT:
        !          13267:        case LE:
        !          13268:        case GT:
        !          13269:        case GE:
        !          13270:        case EQ:
        !          13271:        case NE:
        !          13272:                r1 = t1->num_ptr(b);
        !          13273:                r2 = t2->num_ptr(b);
        !          13274:                if (r1=='P' && r2=='I') {       // allow things like:
        !          13275:                                                // if (p==2-2)
        !          13276:                                                // YUCK!
        !          13277:                        Neval = 0;
        !          13278:                        long i = e2->eval();
        !          13279:                        if (Neval==0 && i==0) {
        !          13280:                                DEL(e2);
        !          13281:                                e2 = zero;
        !          13282:                                r2 = 'Z';
        !          13283:                        }
        !          13284:                }
        !          13285:                else if (r2=='P' && r1=='I') {
        !          13286:                        Neval = 0;
        !          13287:                        long i = e1->eval();
        !          13288:                        if (Neval==0 && i==0) {
        !          13289:                                DEL(e1);
        !          13290:                                e1 = zero;
        !          13291:                                r1 = 'Z';
        !          13292:                        }
        !          13293:                }
        !          13294: 
        !          13295:                if (b!=EQ && b!=NE) {
        !          13296:                        if (r1=='P' && r2=='Z') error("P%k 0",b);
        !          13297:                        if (r2=='P' && r1=='Z') error("P%k 0",b);
        !          13298:                }
        !          13299: 
        !          13300:                // make sure functions are properly converted to pointers to
        !          13301:                // functions and make sure overloaded functions are rejected
        !          13302:                Pexpr ptof(Pfct ef, Pexpr e, Ptable tbl);
        !          13303:                if (r1 == FCT) e1 = ptof(0,e1,tbl);
        !          13304:                if (r2 == FCT) e2 = ptof(0,e2,tbl);
        !          13305: 
        !          13306:                npcheck(b);
        !          13307: 
        !          13308:                if (r1=='P') { // need cast for pointers to virtual and second bases
        !          13309:                        Pptr p1 = t1->is_ptr();
        !          13310:                        Pptr p2 = t2->is_ptr();
        !          13311:                        Pname cn = p1?p1->typ->is_cl_obj():0;
        !          13312:                        Pname cn2 = p2?p2->typ->is_cl_obj():0;
        !          13313: 
        !          13314:                        if (cn && cn2) {
        !          13315:                                Pclass cl = Pclass(cn->tp);
        !          13316:                                Pclass cl2 = Pclass(cn2->tp);
        !          13317: 
        !          13318:                                if (cl->has_base(cl2)) {
        !          13319:                                        e1 = cast_cptr(cl2,e1,tbl,0);
        !          13320:                                        e1 = new cast(p2,e1);
        !          13321:                                }
        !          13322:                                else if (cl2->has_base(cl)) {
        !          13323:                                        e2 = cast_cptr(cl,e2,tbl,0);
        !          13324:                                        e2 = new cast(p1,e2);
        !          13325:                                }
        !          13326:                        }
        !          13327:                }
        !          13328: 
        !          13329:                if (r1=='P' && t1->memptr()) {
        !          13330:                mpmp:
        !          13331:                        if (r2=='Z') {
        !          13332:                                e2 = zero;
        !          13333:                                e1 = new mdot("i",e1);
        !          13334:                                e1->i1 = 9;
        !          13335:                        }
        !          13336:                        else if (r2=='P' && t2->memptr()) {
        !          13337:                                // ERROR: no check for sideeffects
        !          13338:                                Pexpr i1 = new mdot("i",e1);
        !          13339:                                Pexpr i2;
        !          13340:                                i1->i1 = 9;
        !          13341: 
        !          13342:                                i2 = e2;
        !          13343:                                while ( i2->base == CAST )
        !          13344:                                    i2 = i2->e1;
        !          13345:                                if ( i2->base == ILIST )
        !          13346:                                    e2 = i2;
        !          13347: 
        !          13348:                                if (e2->base==ILIST)
        !          13349:                                        i2 = e2->e1->e2;
        !          13350:                                else {
        !          13351:                                        i2 = new mdot("i",e2);
        !          13352:                                        i2->i1 = 9;
        !          13353:                                }
        !          13354: 
        !          13355:                                Pexpr f1 = new mdot("f",e1);
        !          13356:                                Pexpr f2;
        !          13357:                                f1->i1 = 9;
        !          13358:                                if (e2->base == ILIST)
        !          13359:                                //      f2 = new cast(Pfct_type,e2->e2);
        !          13360:                                        f2 = e2->e2;
        !          13361:                                else {
        !          13362:                                        f2 = new mdot("f",e2);
        !          13363:                                        f2->i1 = 9;
        !          13364:                                }
        !          13365: 
        !          13366:                                Pexpr ei = new expr(base,i1,i2);
        !          13367:                                Pexpr fi = new expr(base,f1,f2);
        !          13368: 
        !          13369:                                base = ANDAND;
        !          13370:                                e1 = ei;
        !          13371:                                e2 = fi;
        !          13372:                        } else if (r2=='P') {
        !          13373:                                error('s',"%t %k %t",t1,base,t2);
        !          13374:                        }
        !          13375:                }
        !          13376:                else if (r2=='P' && t2->memptr()) {
        !          13377:                        Pexpr ee = e1;  // swap
        !          13378:                        e1 = e2;
        !          13379:                        e2 = ee;
        !          13380:                        int rr = r1;
        !          13381:                        r1 = r2;
        !          13382:                        r2 = rr;
        !          13383:                        Ptype tt = t1;
        !          13384:                        t1 = t2;
        !          13385:                        t2 = tt;
        !          13386:                        goto mpmp;
        !          13387:                }
        !          13388:                t = int_type;
        !          13389:                break;
        !          13390: 
        !          13391:        case ANDAND:
        !          13392:        case OROR:
        !          13393:                e1 = check_cond(e1,b,tbl);
        !          13394:                e2 = check_cond(e2,b,tbl);
        !          13395:                t = int_type;
        !          13396:                break;
        !          13397: 
        !          13398:        case QUEST:
        !          13399:                {
        !          13400:                Pname c1, c2;
        !          13401:                cond = check_cond(cond,b,tbl);
        !          13402: //error('d',"cond %k %t",cond->base,cond->tp);
        !          13403: //error('d',"t1 %t t2 %t",t1,t2);
        !          13404: 
        !          13405:                // still doesn't do complete checking for possible conversions...
        !          13406: 
        !          13407:                bit MPTR = 0; // local hack
        !          13408: 
        !          13409:                extern int suppress_error;                      // global hack
        !          13410:                suppress_error++;
        !          13411:                r1 = t1->num_ptr(b);
        !          13412:                r2 = t2->num_ptr(b);
        !          13413:                suppress_error--;
        !          13414: if (r1=='P' && r2=='P' && t1->memptr() && t2->memptr()) {
        !          13415: 
        !          13416:                ++MPTR; // prevent later sorry
        !          13417: 
        !          13418:                // watch for casts
        !          13419:                Pexpr tt = e1;
        !          13420:                while ( tt->base == CAST ) tt = tt->e1;
        !          13421:                if ( tt->base == ILIST ) e1 = tt; 
        !          13422: 
        !          13423:                tt = e2;
        !          13424:                while ( tt->base == CAST ) tt = tt->e1;
        !          13425:                if ( tt->base == ILIST ) e2 = tt; 
        !          13426: 
        !          13427:                // cannot have sides return (expr?{}:{})
        !          13428:                // reuse same temp for both sides ?:
        !          13429:                Pname temp = make_tmp( 'A', mptr_type, tbl );
        !          13430: 
        !          13431:                e1 = mptr_assign( temp, e1 );
        !          13432:                e1 = new expr( G_CM, e1, temp );
        !          13433:                e1->tp = temp->tp;
        !          13434: 
        !          13435:                e2 = mptr_assign( temp, e2 );
        !          13436:                e2 = new expr( G_CM, e2, temp );
        !          13437:                e2->tp = temp->tp;
        !          13438: }
        !          13439: 
        !          13440:                if (t1==t2
        !          13441:                || (    (c1=t1->is_cl_obj())
        !          13442:                        && (c2=t2->is_cl_obj())
        !          13443:                        && (c1->tp==c2->tp)
        !          13444:                ))
        !          13445:                        t = t1;
        !          13446:                else {
        !          13447:                        r1 = t1->num_ptr(b);
        !          13448:                        r2 = t2->num_ptr(b);
        !          13449: 
        !          13450:                        if (r1=='P' && r2=='P') {
        !          13451:                                Pptr p1 = t1->is_ptr();
        !          13452:                                Pptr p2 = t2->is_ptr();
        !          13453: //error('d',"p1 %t p2 %t",p1,p2);
        !          13454:                                if ((c1 = p1->typ->is_cl_obj())
        !          13455:                                && (c2 = p2->typ->is_cl_obj())) {
        !          13456:                                        Pclass cl1 = Pclass(c1->tp);
        !          13457:                                        Pclass cl2 = Pclass(c2->tp);
        !          13458:                                        if (cl1==cl2 || cl2->has_base(cl1)) {
        !          13459:                                                t = t1;
        !          13460:                                                goto caca;
        !          13461:                                        }
        !          13462:                                        else if (cl1->has_base(cl2)) {
        !          13463:                                                t = t2;
        !          13464:                                                goto caca;
        !          13465:                                        }
        !          13466:                                }
        !          13467:                        }
        !          13468: 
        !          13469:                        if (r1==FCT && r2==FCT) {       // fudge
        !          13470:                                if (t1->check(t2,ASSIGN))
        !          13471:                                        error("badTs in ?:E: %t and %t",t1,t2);
        !          13472:                                else if (Pfct(t1)->memof) error('s',"conditionalE with%t",t1);
        !          13473:                                t = t1;
        !          13474:                        }
        !          13475:                        else 
        !          13476:                                nppromote(b);
        !          13477:                caca:
        !          13478: //error('d',"?: t %t t1 %t t2 %t",t,t1,t2);
        !          13479:                        if (t!=t1 && t->check(t1,0)) {
        !          13480:                                PERM(t);
        !          13481:                                e1 = new cast(t,e1);
        !          13482:                        }
        !          13483: 
        !          13484:                        if (t!=t2 && t->check(t2,0)) {
        !          13485:                                PERM(t);
        !          13486:                                e2 = new cast(t,e2);
        !          13487:                        }
        !          13488: 
        !          13489:                        Pptr pt = t->is_ptr();
        !          13490:                        //if (pt && pt->base==PTR && pt->memof) error('s',"conditionalE with%t",t);
        !          13491:                        if (pt && pt->base==PTR && pt->memof && MPTR == 0) error('s',"conditionalE with%t",t);
        !          13492:                }
        !          13493:                }
        !          13494:                break;
        !          13495: 
        !          13496:        case ASPLUS:
        !          13497:                r1 = t1->num_ptr(ASPLUS);
        !          13498:                r2 = t2->num_ptr(ASPLUS);
        !          13499:                nppromote(ASPLUS);
        !          13500:                goto ass;
        !          13501: 
        !          13502:        case ASMINUS:
        !          13503:                r1 = t1->num_ptr(ASMINUS);
        !          13504:                r2 = t2->num_ptr(ASMINUS);
        !          13505:                if (r2=='P' && r1!='P' && r1!='A') error("P -= nonP");
        !          13506:                nppromote(ASMINUS);
        !          13507:                goto ass;
        !          13508: 
        !          13509:        case ASMUL:
        !          13510:        case ASDIV:
        !          13511:                r1 = t1->numeric(b);
        !          13512:                r2 = t1->numeric(b);
        !          13513:                nppromote(b);
        !          13514:                goto ass;
        !          13515: 
        !          13516:        case ASMOD:
        !          13517:                r1 = t1->integral(ASMOD);
        !          13518:                r2 = t2->integral(ASMOD);
        !          13519:                nppromote(ASMOD);
        !          13520:                goto ass;
        !          13521: 
        !          13522:        case ASAND:
        !          13523:        case ASOR:
        !          13524:        case ASER:
        !          13525:        case ASLS:
        !          13526:        case ASRS:
        !          13527:                r1 = t1->integral(b);
        !          13528:                r2 = t2->integral(b);
        !          13529:                npcheck(b);
        !          13530:                t = int_type;
        !          13531:                goto ass;
        !          13532:        ass:
        !          13533:                if (r1='P' && t1->check(Pvoid_type,0)==0) error("%k of void*",b);
        !          13534:                tp = t;
        !          13535:                as_type = t;    /* the type of the rhs */
        !          13536:                t2 = t;
        !          13537: 
        !          13538:        case ASSIGN:
        !          13539: //error('d',"assign %k: %t %t %s",b,t1,t2,ignore_const?"ignore const":"");
        !          13540: //error('d',"    e1 %d %k e1 %d %k",e1,e1->base,e2,e2->base);
        !          13541:                if (ignore_const) {     // handle static initializers
        !          13542:                                        // represented as assignments
        !          13543:                                        // ignore consts.
        !          13544:                        tp = e1->tp;
        !          13545:                        return this;
        !          13546:                }
        !          13547: 
        !          13548:                switch (e1->base) {
        !          13549:                case G_CM:
        !          13550:                case CM:        // (a,b)=c => *(a,&b)=c
        !          13551:                {
        !          13552:                        e1->e2 = new expr(G_ADDROF,0,e1->e2);
        !          13553:                        e1->tp = 0;
        !          13554:                        e1 = new expr(DEREF,e1,0);
        !          13555:                        return typ(tbl);
        !          13556:                }
        !          13557:                case QUEST:     // (a?b:c)=d => *(a?&b:&c)=c
        !          13558:                {
        !          13559:                        e1->e1 = new expr(G_ADDROF,0,e1->e1);
        !          13560:                        e1->e2 = new expr(G_ADDROF,0,e1->e2);
        !          13561:                        e1->tp = 0;
        !          13562:                        e1 = new expr(DEREF,e1,0);
        !          13563:                        return typ(tbl);
        !          13564:                }
        !          13565:                case ASSIGN:    // (a*=b)=c => a*=b,a=c
        !          13566:                case ASPLUS:
        !          13567:                case ASMINUS:
        !          13568:                case ASMUL:
        !          13569:                case ASDIV:
        !          13570:                case ASMOD:
        !          13571:                case ASAND:
        !          13572:                case ASOR:
        !          13573:                case ASER:
        !          13574:                case ASLS:
        !          13575:                case ASRS:
        !          13576:                {
        !          13577:                        base = G_CM;
        !          13578:                        nin++;
        !          13579:                        if (e1->e1->not_simple()) error('s',"lvalue %k too complicated",b);
        !          13580:                        nin--;
        !          13581:                        Pexpr aa = new expr(e1->base,e1->e1,e1->e2);
        !          13582:                        Pexpr bb = new expr(b,e1->e1,e2);
        !          13583:                        e1 = aa;
        !          13584:                        e2 = bb;
        !          13585:                        return typ(tbl);
        !          13586:                }
        !          13587:                case INCR:
        !          13588:                case DECR:      // ++a=b => ++a,a=b
        !          13589:                {
        !          13590:                        if(!e1->e2) break ;
        !          13591:                        base = G_CM;
        !          13592:                        nin++;
        !          13593:                        if (e1->e2->not_simple()) error('s',"lvalue %k too complicated",b);
        !          13594:                        nin--;
        !          13595:                        Pexpr aa = new expr(e1->base,0,e1->e2);
        !          13596:                        Pexpr bb = new expr(b,e1->e2,e2);
        !          13597:                        e1 = aa;
        !          13598:                        e2 = bb;
        !          13599:                        return typ(tbl);
        !          13600:                }
        !          13601:                case REF:
        !          13602:                {
        !          13603:                        Pexpr r = e1;
        !          13604:                        // hack to prevent
        !          13605:                        //      f().i = j
        !          13606:                        // transformed into
        !          13607:                        //      ((t=f()),&t)->i = j
        !          13608:                        if (r->e1->base==G_CM
        !          13609:                        && r->e1->e2->base==G_ADDROF
        !          13610:                        && r->e1->e2->e2->base==NAME) {
        !          13611:                                char* s = r->e1->e2->e2->string;
        !          13612:                                if (s[0]=='_' && s[1]=='_')
        !          13613:                                        error("left hand side not lvalue");
        !          13614:                        }
        !          13615:                }
        !          13616:                }
        !          13617: 
        !          13618:                if (e1->lval(b) == 0) {
        !          13619:                        tp = any_type;
        !          13620:                        return this;
        !          13621:                }
        !          13622:        lkj:
        !          13623:                switch (t1->base) {
        !          13624:                case TYPE:
        !          13625:                        t1 = Pbase(t1)->b_name->tp;
        !          13626:                        goto lkj;
        !          13627:                case INT:
        !          13628:                case CHAR:
        !          13629:                case SHORT:
        !          13630:                //      if (e2->base==ICON && e2->tp==long_type)
        !          13631:                //              error('w',"long constant assigned to%k",t1->base);
        !          13632:                {       Ptype t = e2->tp;
        !          13633:                csi:
        !          13634:                        switch (t->base) {
        !          13635:                        case TYPE:
        !          13636:                                t = Pbase(t)->b_name->tp; goto csi;
        !          13637:                        case LONG:
        !          13638:                        case FLOAT:
        !          13639:                        case DOUBLE:
        !          13640:                        case LDOUBLE:
        !          13641:                                error('w',"%t assigned to %t",e2->tp,t1);
        !          13642:                        }
        !          13643:                }
        !          13644:                        // no break
        !          13645:                case LONG:
        !          13646:                        if (b==ASSIGN
        !          13647:                        && Pbase(t1)->b_unsigned
        !          13648:                        && e2->base==UMINUS
        !          13649:                        && e2->e2->base==ICON)
        !          13650:                                error('w',"negative assigned to unsigned");
        !          13651:                        break;
        !          13652:                case PTR:
        !          13653:                        if (b == ASSIGN) {
        !          13654: //error('d',"ptr t1 %t %d %t",t1,t1->memptr(),t2);
        !          13655:                        //??    if (t1->memptr() && t2->base!=OVERLOAD) break;
        !          13656:                                e2 = ptr_init(Pptr(t1),e2,tbl);
        !          13657:                                t2 = e2->tp;
        !          13658: //error('d',"pchecked %d",Pchecked);
        !          13659:                                if (Pchecked) {
        !          13660:                                        tp = e1->tp;
        !          13661:                                        return this;
        !          13662:                                }
        !          13663:                        }
        !          13664:                        break;
        !          13665:                case COBJ:
        !          13666:                {       Pname c1 = t1->is_cl_obj();
        !          13667:                                // test of c1->tp necessary for ``fake classes''
        !          13668:                                // _Sdd generated for vector assignemnts
        !          13669:                        if (c1
        !          13670:                        && c1->tp
        !          13671:                /*      && Pclass(c1->tp)->memtbl->look("__as",0)==0*/) {
        !          13672:                        //&& Pclass(c1->tp)->has_oper(ASSIGN)==0) {
        !          13673:                                Pname c2 = t2->is_cl_obj();
        !          13674: // error('d', "expr::typ: c1: %n c2: %n", c1, c2 );
        !          13675:                                if (c1 != c2) {
        !          13676: /*
        !          13677:        consider:
        !          13678: 
        !          13679:        struct A { A(B&); };
        !          13680:        struct B : A {};
        !          13681: 
        !          13682:        A aa;
        !          13683:        B bb;
        !          13684: 
        !          13685:        aa = bb;        // aa.operator=(A(bb));
        !          13686:                        // optimize to aa.A(bb) when possible
        !          13687:                        // avoid temporary where aa = *(A*)&bb is legal
        !          13688: */
        !          13689: // error('d',"expr::typ c1 %n %d c2 %n %d",c1,c1?c1->tp:0,c2,c2?c2->tp:0);
        !          13690:                                        if (c2
        !          13691:                                        && c2->tp
        !          13692:                                        && can_coerce(t1,t2)==0
        !          13693:                                        //&& Pclass(c2->tp)->has_base(Pclass(c1->tp))
        !          13694:                                        //&& (1<is_unique_base(Pclass(c2->tp),c1->string,0))
        !          13695:                                        && (vcllist->clear(),vcllist=0,1<is_unique_base(Pclass(c2->tp),c1->string,0))
        !          13696:                                        && Pclass(c1->tp)->c_xref&(C_VBASE|C_VPTR|C_ASS)) {
        !          13697: // error('d',"aaa");
        !          13698:                                                if (make_assignment(c1)) return try_to_overload(tbl);
        !          13699:                                        }
        !          13700:                                // optimize
        !          13701:                                        else {
        !          13702:                                                e2 = new expr(ELIST,e2,0);
        !          13703:                                                e2 = new texpr(VALUE,t1,e2);
        !          13704:                                                if (Pclass(c1->tp)->has_dtor()==0 &&
        !          13705:                                                        Pclass(c1->tp)->has_oper(ASSIGN)==0) {
        !          13706:                                // optimize
        !          13707: // error('d',"bbb");
        !          13708:                                                        e2->e2 = e1;
        !          13709:                                                        e2 = e2->typ(tbl);
        !          13710:                                                        if (e2->base==DEREF && e2->e1->base==G_CALL ||
        !          13711:                                                        e2->base==ASSIGN && e2->e1==e1) {
        !          13712: // error('d',"ccc");
        !          13713:                                                                *this = *e2;
        !          13714:                                                        }
        !          13715:                                                        tp = t1;
        !          13716:                                                        return this;
        !          13717:                                                }
        !          13718:                                                return typ(tbl);
        !          13719:                                        }
        !          13720:                                }
        !          13721:                                        // test of c1->tp necessary for ``fake classes''
        !          13722:                                        // _Sdd generated for vector assignemnts
        !          13723:                                else if (c1->tp && Pclass(c1->tp)->c_xref&(C_VBASE|C_VPTR|C_ASS)) {
        !          13724:                                        if (make_assignment(c1)) return try_to_overload(tbl);
        !          13725:                                }
        !          13726:                        }
        !          13727:                        (void) t1->tsizeof();
        !          13728:                        break;
        !          13729:                }
        !          13730:                }
        !          13731: 
        !          13732: //error('d',"check(%t,%t) -> %d",e1->tp,t2,try_to_coerce(t1,e2,"assignment",tbl));
        !          13733:                {       Pexpr x = try_to_coerce(t1,e2,"assignment",tbl);
        !          13734:                        if (x)
        !          13735:                                e2 = x;
        !          13736:                        else if (e1->tp->check(t2,ASSIGN))
        !          13737:                                error("bad assignmentT:%t =%t",e1->tp,t2);
        !          13738:                        else if ((t1 = t1->is_ptr()) && t1->memptr()) {
        !          13739:                                if (t2 == zero_type) {
        !          13740:                                        Pexpr ee = new expr(ELIST,zero,zero);
        !          13741:                                        e2 = new expr(ILIST,ee,zero);
        !          13742:                                }
        !          13743:                                else if (t2->base==PTR && t2->memptr()) {
        !          13744:                                        // do nothing: structure assignment
        !          13745:                                }
        !          13746:                                else {
        !          13747:                                        Pexpr x = ptr_init(Pptr(t1),e2,tbl);
        !          13748:                                        if (x != e2) e2 = x;
        !          13749:                                }
        !          13750:                        }
        !          13751:                }               
        !          13752:                t = e1->tp;     // the type of the lhs
        !          13753:                break;
        !          13754:        case CM:
        !          13755:        case G_CM:
        !          13756:                t = t2;
        !          13757:                break;
        !          13758:        default:
        !          13759:                error('i',"unknown operator%k",b);
        !          13760:        }
        !          13761: 
        !          13762:        tp = t;
        !          13763:        return this;
        !          13764: }
        !          13765: 0707071010112044271004440001630000160000010200100466055401400001000000130600expr2.c/*ident    "@(#)ctrans:src/expr2.c 1.5" */
        !          13766: /***************************************************************************
        !          13767: 
        !          13768:        C++ source for cfront, the C++ compiler front-end
        !          13769:        written in the computer science research center of Bell Labs
        !          13770: 
        !          13771:        Copyright (c) 1984 AT&T, Inc. All rights Reserved
        !          13772:        THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T, INC.
        !          13773: 
        !          13774: expr2.c:
        !          13775: 
        !          13776:        type check expressions
        !          13777: 
        !          13778: ************************************************************************/
        !          13779: 
        !          13780: #include "cfront.h"
        !          13781: #include "size.h"
        !          13782: 
        !          13783: extern Pname conv_dominates(Pname,Pname);
        !          13784: static int const_obj1,const_obj2;
        !          13785: 
        !          13786: Pname really_dominate(Pname on1, Pname on2, bit tc)
        !          13787: {
        !          13788:        Pfct f1 = on1->tp->base==FCT ? Pfct(on1->tp) :
        !          13789:                Pfct(Pgen(on1->tp)->fct_list->f->tp);
        !          13790:        Pfct f2 = on2->tp->base==FCT ? Pfct(on2->tp) :
        !          13791:                Pfct(Pgen(on2->tp)->fct_list->f->tp);
        !          13792: 
        !          13793:        // const check
        !          13794:        int c1 = f1->f_const;
        !          13795:        int c2 = f2->f_const;
        !          13796: 
        !          13797:        if(c1 == c2) ;
        !          13798:        else if(c1 && !c2) return tc ? on1 : on2;
        !          13799:        else if(c2 && !c1) return tc ? on2 : on1;
        !          13800: 
        !          13801:        // hierarchy check
        !          13802:        Pname on = conv_dominates(on1,on2);
        !          13803:        if(on) return on;
        !          13804:        else return 0;
        !          13805: }
        !          13806: 
        !          13807: void name::assign()
        !          13808: {
        !          13809:        if (n_assigned_to++ == 0) {
        !          13810:                switch (n_scope) {
        !          13811:                case FCT:
        !          13812:                        if (n_used && n_addr_taken==0)  {
        !          13813:                                Ptype t = tp;
        !          13814:                        ll:
        !          13815:                                switch (t->base) {
        !          13816:                                case TYPE:
        !          13817:                                        t=Pbase(t)->b_name->tp; goto ll;
        !          13818:                                case VEC:
        !          13819:                                        break;
        !          13820:                                default:
        !          13821:                                        if (curr_loop)
        !          13822:                                                error('w',&where,"%n may have been used before set",this);
        !          13823:                                        else
        !          13824:                                                error('w',&where,"%n used before set",this);
        !          13825:                                }
        !          13826:                        }
        !          13827:                }
        !          13828:        }
        !          13829: }
        !          13830: 
        !          13831: void name::take_addr()
        !          13832: {
        !          13833: // error('d', "%n->take_addr tp: %t", this, tp?tp:0 );
        !          13834: // error('d', "%n->take_addr tp: %d %d", this, tp?tp:0, tp?tp->base:0 );
        !          13835:        if ( (warning_opt) && (! n_addr_taken) && (tp) && (tp->base==FCT) && Pfct (tp)->f_inline)
        !          13836:                error('w',"can't take address of inline function %n, %n not inlined", this, this);  
        !          13837:        n_addr_taken++; 
        !          13838:        if ( n_sto == EXTERN && tp ) {
        !          13839:                Ptype t = tp;
        !          13840:                while ( t->base == TYPE )  
        !          13841:                        t = Pbase(t)->b_name->tp;
        !          13842:                switch ( t->base ) {
        !          13843:                        case COBJ:
        !          13844:                                t = Pbase(t)->b_name->tp; // no break
        !          13845:                        case CLASS: {
        !          13846:                                Pclass cl = Pclass(t);
        !          13847:                                if ( cl->c_body == 1 )
        !          13848:                                        cl->dcl_print(0);
        !          13849:                        }
        !          13850:                }
        !          13851:        }
        !          13852: }
        !          13853: 
        !          13854: int ignore_const;      // for use by ref_init
        !          13855: static is_dataMemPtr(Pexpr);
        !          13856: 
        !          13857: int expr::lval(TOK oper)
        !          13858: {
        !          13859:        register Pexpr ee = this;
        !          13860:        register Pname n;
        !          13861:        int deref = 0;
        !          13862:        char* es;
        !          13863: 
        !          13864: //error('d',"%k expr::lval %k",base,oper);
        !          13865: 
        !          13866:        switch (oper) {
        !          13867:        case ADDROF:
        !          13868:        case G_ADDROF:  es = "address of";      break;
        !          13869:        case DEREF:     es = "dereference of";  break;
        !          13870:        case INCR:      es = "increment of";    goto def;
        !          13871:        case DECR:      es = "decrement of";    goto def;
        !          13872:        default:        es = "assignment to";
        !          13873:        def:
        !          13874:                if (ignore_const==0 && tp->tconst()) {
        !          13875:                        if (oper) {
        !          13876:                                if (base == NAME) {
        !          13877:                                        if (vec_const && Pname(this)->n_scope==ARG) break;
        !          13878:                                        error("%s constant%n",es,this);
        !          13879:                                }
        !          13880:                                else
        !          13881:                                        error("%s constant",es);
        !          13882:                        }
        !          13883:                        return 0;
        !          13884:                }
        !          13885:        }
        !          13886: 
        !          13887:        for(;;) {
        !          13888: //error('d',"loop %k",ee->base);
        !          13889:                switch (ee->base) {
        !          13890:        //      case G_CALL:
        !          13891:        //      case CALL:
        !          13892:                default:
        !          13893:                defa:
        !          13894:                        if (deref == 0) {
        !          13895:                                if (oper) error("%s%k (not an lvalue)",es,ee->base);
        !          13896:                                return 0;
        !          13897:                        }
        !          13898:                        return 1;
        !          13899:                case ZERO:
        !          13900:                case CCON:
        !          13901:                case ICON:
        !          13902:                case FCON:
        !          13903:                        if (oper) error("%s numeric constant",es);
        !          13904:                        return 0;
        !          13905:                case STRING:
        !          13906:                        if (oper) error('w',"%s string constant",es);
        !          13907:                        return 1;
        !          13908:                case CAST:
        !          13909:                switch( oper ) {
        !          13910:                case 0:
        !          13911:                case ADDROF:
        !          13912:                case G_ADDROF:
        !          13913:                case DEREF:
        !          13914:                        goto defa;
        !          13915:                default:
        !          13916:                        if ( ee->tp->base == PTR 
        !          13917:                             && is_dataMemPtr(ee) ) 
        !          13918:                        { // check for const class object
        !          13919:                                Pexpr te;
        !          13920:                                te = ee->e1->e1->e1;     
        !          13921:                                        if ( te->base == G_ADDROF )
        !          13922:                                        te = te->e2;
        !          13923:                                        if ( te->base == NAME ) {
        !          13924:                                        Ptype pt = te->tp;
        !          13925:                                        if ( pt->base == PTR )
        !          13926:                                                pt = Pptr(pt)->typ;
        !          13927:                                        if ( pt->tconst() ) 
        !          13928:                                                error("%sCMP of const%n",es,te);
        !          13929:                                        return 0;
        !          13930:                                }
        !          13931:                        }
        !          13932:                        goto defa;
        !          13933:                }
        !          13934: 
        !          13935:                case DEREF:
        !          13936:                {       
        !          13937:                        Pexpr ee1 = ee->e1;
        !          13938: // error( 'd', "ee1: %k", ee1->base );
        !          13939:                        switch (ee1->base) {    // *& vanishes
        !          13940:                        case ADDROF:    // *&
        !          13941:                                return 1;
        !          13942:                        case G_CM:
        !          13943:                        case CM:        // look for *(a,&b)
        !          13944:                                if (ee1->e2->base==G_ADDROF
        !          13945:                                || ee1->e2->base==ADDROF)
        !          13946:                                        return 1;
        !          13947:                                goto defaa;
        !          13948:                        case QUEST:     // look for *(q?&a:&b)
        !          13949:                                if ((ee1->e1->base==G_ADDROF
        !          13950:                                        || ee1->e1->base==ADDROF)
        !          13951:                                && (ee1->e2->base==G_ADDROF
        !          13952:                                        || ee1->e2->base==ADDROF))
        !          13953:                                        return 1;
        !          13954:                                // no break
        !          13955:                        default:
        !          13956:                        defaa:
        !          13957:                                ee = ee1;
        !          13958:                                deref = 1;
        !          13959:                        }
        !          13960:                        break;
        !          13961:                }
        !          13962: 
        !          13963:                case QUEST:
        !          13964:                {       int x1 = ee->e1->lval(deref?0:oper);
        !          13965:                        int x2 = ee->e2->lval(deref?0:oper);
        !          13966:                        if (ee->e1->tp->check(ee->e2->tp,0)) return 0;
        !          13967:                        if (deref) return 1;
        !          13968:                        return x1 && x2;
        !          13969:                }
        !          13970: 
        !          13971:                case INCR:
        !          13972:                case DECR:
        !          13973:                        if (e1) goto defa;      // postfix does not preserve lval
        !          13974:                case ASSIGN:
        !          13975:                case ASPLUS:
        !          13976:                case ASMINUS:
        !          13977:                case ASMUL:
        !          13978:                case ASDIV:
        !          13979:                case ASMOD:
        !          13980:                case ASAND:
        !          13981:                case ASOR:
        !          13982:                case ASER:
        !          13983:                case ASLS:
        !          13984:                case ASRS:
        !          13985:                        return 1;
        !          13986: 
        !          13987:                case CM:
        !          13988:                case G_CM:
        !          13989:                        if (ee->e2->lval(deref?0:oper)==0) return deref;
        !          13990:                        return 1;
        !          13991: 
        !          13992:                case MEMPTR:
        !          13993:                        ee = ee->e2;
        !          13994:                        break;
        !          13995: 
        !          13996:                case MDOT:
        !          13997:                        ee = ee->mem;
        !          13998:                        break;
        !          13999: 
        !          14000:                case DOT:
        !          14001:                {
        !          14002: // error('d',"dot %k oper %k",ee->e1->base,oper);
        !          14003:                        Pexpr e = 0;
        !          14004:                        int e_const = 0; // to catch x.y.val = 1, where x is const
        !          14005: 
        !          14006:                        switch (ee->e1->base) {         // update use counts, etc.
        !          14007:                        case NAME:
        !          14008:                                switch (oper) {
        !          14009:                                case ADDROF:
        !          14010:                                case G_ADDROF:  Pname(ee->e1)->take_addr();
        !          14011:                                case 0:         break;
        !          14012:                                case ASSIGN:    Pname(ee->e1)->n_used--;
        !          14013:                                default:        Pname(ee->e1)->assign(); // asop
        !          14014:                                }
        !          14015:                                break;
        !          14016:                        case DOT:
        !          14017:                                e = ee->e1;
        !          14018:                                do e=e->e1; while (e->base==DOT);
        !          14019:                                if (e->base == NAME) {
        !          14020:                                        e_const = e->tp->tconst();
        !          14021:                                        switch (oper) {
        !          14022:                                        case ADDROF:
        !          14023:                                        case G_ADDROF:  Pname(e)->take_addr();
        !          14024:                                        case 0:         break;
        !          14025:                                        case ASSIGN:    Pname(e)->n_used--;
        !          14026:                                        default:        Pname(e)->assign(); // asop
        !          14027:                                        }
        !          14028:                                }
        !          14029:                        }
        !          14030: 
        !          14031:                        n = Pname(ee->mem);
        !          14032:                        while (n->base == MDOT) n = Pname(Pref(n)->mem);
        !          14033: 
        !          14034:                        if (deref==0 && 
        !          14035:                                (ee->e1->tp->tconst() || e_const)) {
        !          14036: 
        !          14037:                                switch (oper) {
        !          14038:                                case 0:
        !          14039:                                case ADDROF:
        !          14040:                                case G_ADDROF:
        !          14041:                                case DEREF:
        !          14042:                                        break;
        !          14043:                                default:
        !          14044:                                        error("%sM%n of%t",es,n,e_const?e->tp:ee->e1->tp);
        !          14045:                                }
        !          14046:                                return 0;
        !          14047:                        }
        !          14048:                }
        !          14049:                goto xx;
        !          14050: 
        !          14051:                case REF:
        !          14052:                        n = Pname(ee->mem);
        !          14053:                        while (n->base == MDOT) n = Pname(Pref(n)->mem);
        !          14054: 
        !          14055:                        if (deref==0 && ee->e1) {  //BR
        !          14056:                                Ptype p = ee->e1->tp;
        !          14057:                        zxc:
        !          14058:                                switch (p->base) {
        !          14059:                                case TYPE:      p = Pbase(p)->b_name->tp; goto zxc;
        !          14060:                                case PTR:
        !          14061:                                case VEC:       break;
        !          14062:                                default:        error('i',"expr::lval %t->%n",p,n);
        !          14063:                                }
        !          14064:                                if (Pptr(p)->typ->tconst()) {
        !          14065:                                        switch (oper) {
        !          14066:                                        case 0:
        !          14067:                                        case G_ADDROF:
        !          14068:                                        case DEREF:
        !          14069:                                                break;
        !          14070:                                        case ADDROF:
        !          14071:                                                if ( cm_const_save == 0 && const_ptr == 0 ) 
        !          14072:                                                        error(strict_opt?0:'w',"%sM%n of%t",es,n,Pptr(p)->typ);
        !          14073:                                                break;
        !          14074:                                        default:
        !          14075:                                                error("%sM%n of%t",es,n,Pptr(p)->typ);
        !          14076:                                        }
        !          14077:                                        return 0;
        !          14078:                                }
        !          14079:                        }
        !          14080:                        goto xx;
        !          14081: 
        !          14082:                case NAME:
        !          14083:                        n = Pname(ee);
        !          14084:                xx:
        !          14085: // error('d',"name xx: %n oper %d lex_level: %d",n,oper,n->lex_level);
        !          14086:                        if (deref) return 1;
        !          14087:                        if (oper==0) return n->n_stclass != ENUM ;
        !          14088: 
        !          14089:                        if (n->tp->base==FIELD && Pbase(n->tp)->b_bits==0) {
        !          14090:                                error("%s 0-length field%n",es,n);
        !          14091:                                return 0;
        !          14092:                        }
        !          14093: 
        !          14094:                        switch (oper) {
        !          14095:                        case ADDROF:
        !          14096:                        case G_ADDROF:
        !          14097:                        {       Pfct f = (Pfct)n->tp;
        !          14098: 
        !          14099:                                if (n->n_sto == REGISTER) {
        !          14100:                                        if (warning_opt) error('w',"& register%n",n);
        !          14101:                                //      return 0;
        !          14102:                                        n->n_sto = 0;
        !          14103:                                        n->n_stclass = AUTO;
        !          14104:                                }
        !          14105: 
        !          14106:                                if (f == 0) {
        !          14107:                                        error("& label%n",n);
        !          14108:                                        return 0;
        !          14109:                                }
        !          14110: 
        !          14111:                                if (n->n_stclass == ENUM) {
        !          14112:                                        error("& enumerator%n",n);
        !          14113:                                        return 0;
        !          14114:                                }
        !          14115: 
        !          14116:                                if (n->tp->base == FIELD) {
        !          14117:                                        error("& field%n",n);
        !          14118:                                        return 0;
        !          14119:                                }
        !          14120: 
        !          14121:                                n->n_used--;
        !          14122:                                if (n->n_qualifier) { // oops, not the real one
        !          14123:                                        Pname tn = Pclass(n->n_table->t_name->tp)->memtbl->look(n->string,0);
        !          14124:                                        n = tn ? tn : n;
        !          14125:                                }
        !          14126:                                n->take_addr();
        !          14127: 
        !          14128:                                // suppress hoisting of local consts
        !          14129:                                int statmem = n->n_scope==0 || n->n_scope==PUBLIC || n->n_scope == FCT;
        !          14130:                                if (n->n_evaluated && n->n_scope!=ARG) { // &const
        !          14131:                                        if (statmem == 0 && n->n_dcl_printed==0) {
        !          14132:                                                n->n_initializer = new ival(n->n_val);
        !          14133:                                                n->dcl_print(0);
        !          14134:                                        }
        !          14135:                                }
        !          14136:                                else if (f->base==FCT && n->n_dcl_printed==0)
        !          14137:                                        n->dcl_print(0);
        !          14138:                                break;
        !          14139:                        }
        !          14140: 
        !          14141:                        case ASSIGN:
        !          14142: //error('d',"ass %n %d",n,n->n_used);
        !          14143:                                n->n_used--;
        !          14144:                                n->assign();
        !          14145:                                break;
        !          14146:                        //      goto check_void;
        !          14147:                        default:        /* incr ops, and asops */
        !          14148:                                if (cc->tot && n==cc->c_this) {
        !          14149:                                        error("%n%k",n,oper);
        !          14150:                                        return 0;
        !          14151:                                }
        !          14152:                //      check_void:
        !          14153:                //              {       Ptype t = n->tp;
        !          14154:                //                      while (t->base==TYPE) t = Pbase(t)->b_name->tp;
        !          14155:                //                      if (t==Pvoid_type) {
        !          14156:                //                              error("%s%t",es,n->tp);
        !          14157:                //                              return 0;
        !          14158:                //                      }
        !          14159:                //              }
        !          14160:                                n->assign();
        !          14161:                        }
        !          14162:                        return 1;
        !          14163:                }
        !          14164:        }
        !          14165: }
        !          14166: 
        !          14167: int char_to_int(char* s)
        !          14168: /*     assume s points to a string:
        !          14169:                'c'
        !          14170:        or      '\c'
        !          14171:        or      '\0'
        !          14172:        or      '\ddd'
        !          14173:        or multi-character versions of the above
        !          14174:        (hex constants have been converted to octal by the parser)
        !          14175: */
        !          14176: {
        !          14177:        register int i = 0;
        !          14178:        register char c, d, e;
        !          14179: 
        !          14180:        switch (*s) {
        !          14181:        default:
        !          14182:                error('i',"char constant store corrupted");
        !          14183:        case '`':
        !          14184:                error("bcd constant");
        !          14185:                return 0;
        !          14186:        case '\'':
        !          14187:                break;
        !          14188:        }
        !          14189: 
        !          14190:        for(;;)                 /* also handle multi-character constants */
        !          14191:        switch (c = *++s) {
        !          14192:        case '\'':
        !          14193:                return i;
        !          14194:        case '\\':                      /* special character */
        !          14195:                switch (c = *++s) {
        !          14196:                case '0': case '1': case '2': case '3': case '4':
        !          14197:                case '5': case '6': case '7':   /* octal representation */
        !          14198:                        c -= '0';
        !          14199:                        switch (d = *++s) {             /* try for 2 */
        !          14200:                                
        !          14201:                        case '0': case '1': case '2': case '3': case '4':
        !          14202:                        case '5': case '6': case '7':
        !          14203:                                d -= '0';
        !          14204:                                switch (e = *++s) {     /* try for 3 */
        !          14205:                                        
        !          14206:                                case '0': case '1': case '2': case '3': case '4':
        !          14207:                                case '5': case '6': case '7':
        !          14208:                                        c = c*64+d*8+e-'0';
        !          14209:                                        break;
        !          14210:                                default:
        !          14211:                                        c = c*8+d;
        !          14212:                                        s--;
        !          14213:                                }
        !          14214:                                break;
        !          14215:                        default:
        !          14216:                                s--;
        !          14217:                        }
        !          14218:                        break;
        !          14219:                case 'a':
        !          14220:                        c = '\a';
        !          14221:                        break;
        !          14222:                case 'b':
        !          14223:                        c = '\b';
        !          14224:                        break;
        !          14225:                case 'f':
        !          14226:                        c = '\f';
        !          14227:                        break;
        !          14228:                case 'n':
        !          14229:                        c = '\n';
        !          14230:                        break;
        !          14231:                case 'r':
        !          14232:                        c = '\r';
        !          14233:                        break;
        !          14234:                case 't':
        !          14235:                        c = '\t';
        !          14236:                        break;
        !          14237:                case 'v':
        !          14238:                        c = '\v';
        !          14239:                        break;
        !          14240:                case '\\':
        !          14241:                        c = '\\';
        !          14242:                        break;
        !          14243:                case '\'':
        !          14244:                        c = '\'';
        !          14245:                        break;
        !          14246:                }
        !          14247:                /* no break */
        !          14248:        default:
        !          14249:                if (i) i <<= BI_IN_BYTE;
        !          14250:                i += c;
        !          14251:        }
        !          14252: }
        !          14253: 
        !          14254: const A10 = 'A'-10;
        !          14255: const a10 = 'a'-10;
        !          14256: 
        !          14257: long str_to_long(register const char* p)
        !          14258: {
        !          14259:        register c;
        !          14260:        register unsigned long i= 0;
        !          14261:        const char* pp = p;
        !          14262: 
        !          14263: // error( 'd', "str_to_long: %s", p );
        !          14264: 
        !          14265:        if ((c=*p++) == '0') {
        !          14266:                switch (c = *p++) {
        !          14267:                case 0:
        !          14268:                        return 0;
        !          14269: 
        !          14270:                case 'l':
        !          14271:                case 'L':       /* long zero */
        !          14272:                        return 0;
        !          14273: 
        !          14274:                case 'x':
        !          14275:                case 'X':       /* hexadecimal */
        !          14276:                        while (c=*p++) {
        !          14277:                                switch (c) {
        !          14278:                                case 'l':
        !          14279:                                case 'L':
        !          14280:                                case 'U':
        !          14281:                                case 'u':
        !          14282:                                        return i;
        !          14283:                                case 'A':
        !          14284:                                case 'B':
        !          14285:                                case 'C':
        !          14286:                                case 'D':
        !          14287:                                case 'E':
        !          14288:                                case 'F':
        !          14289:                                        i = i*16 + c-A10;
        !          14290:                                        break;
        !          14291:                                case 'a':
        !          14292:                                case 'b':
        !          14293:                                case 'c':
        !          14294:                                case 'd':
        !          14295:                                case 'e':
        !          14296:                                case 'f':
        !          14297:                                        i = i*16 + c-a10;
        !          14298:                                        break;
        !          14299:                                default:
        !          14300:                                        i = i*16 + c-'0';
        !          14301:                                }
        !          14302:                        }
        !          14303:                        return i;
        !          14304: 
        !          14305:                default:        /* octal */
        !          14306:                        do 
        !          14307:                                switch (c) {
        !          14308:                                case 'l':
        !          14309:                                case 'L':
        !          14310:                                case 'U':
        !          14311:                                case 'u':
        !          14312:                                        return i;
        !          14313:                                default:
        !          14314:                                        i = i*8 + c-'0';
        !          14315:                                }
        !          14316:                        while (c=*p++);
        !          14317:                        return i;
        !          14318:                }
        !          14319:        }       
        !          14320:                                /* decimal */
        !          14321:        i = c-'0';
        !          14322:        while (c=*p++)
        !          14323:                switch (c) {
        !          14324:                case 'l':
        !          14325:                case 'L':
        !          14326:                case 'U':
        !          14327:                case 'u':
        !          14328:                        return i;
        !          14329:                default:
        !          14330:                {       unsigned long ii = i;
        !          14331:                        i = i*10 + c-'0';
        !          14332:                        if (i<ii) goto bad;
        !          14333:                }
        !          14334:                }
        !          14335:        return i;
        !          14336: bad:
        !          14337:        error("integer constant %s larger than the largest long",pp);
        !          14338:        return i;
        !          14339:        
        !          14340:                
        !          14341: }
        !          14342: 
        !          14343: bit type::is_unsigned()
        !          14344: {
        !          14345:        Ptype t = this;
        !          14346:        while (t->base==TYPE) t = Pbase(t)->b_name->tp;
        !          14347:        if (t->base == PTR) return 0;
        !          14348:        return Pbase(t)->b_unsigned;
        !          14349: }
        !          14350: 
        !          14351: char* Neval;
        !          14352: bit binary_val;
        !          14353: 
        !          14354: unsigned long expr::ueval(long x1, long x2)
        !          14355: {
        !          14356:        unsigned long i1 = (unsigned long) x1;  
        !          14357:        unsigned long i2 = (unsigned long) x2;
        !          14358: //error('d',"ueval %k %ld %ld",base,x1,x2);
        !          14359:        switch (base) {
        !          14360:        case UMINUS:    return -i2;
        !          14361:        case UPLUS:     return i2;
        !          14362:        case NOT:       return !i2;
        !          14363:        case COMPL:     return ~i2;
        !          14364:        case CAST:      return i1;
        !          14365:        case PLUS:      return i1+i2;
        !          14366:        case MINUS:     return i1-i2;
        !          14367:        case MUL:       return i1*i2;
        !          14368:        case LS:        return i1<<i2;
        !          14369:        case RS:        return i1>>i2;
        !          14370:        case NE:        return i1!=i2;
        !          14371:        case EQ:        return i1==i2;
        !          14372:        case LT:        return i1<i2;
        !          14373:        case LE:        return i1<=i2;
        !          14374:        case GT:        return i1>i2;
        !          14375:        case GE:        return i1>=i2;
        !          14376:        case AND:       return i1&i2;
        !          14377:        case ANDAND:    return i1&&i2;
        !          14378:        case OR:        return i1|i2;
        !          14379:        case OROR:      return i1||i2;
        !          14380:        case ER:        return i1^i2;
        !          14381:        case MOD:       if (i2 == 0) {
        !          14382:                                if (Neval == 0) { 
        !          14383:                                        Neval = "mod zero";
        !          14384:                                        error("mod zero");
        !          14385:                                }
        !          14386:                                return 1;
        !          14387:                        }
        !          14388:                        return i1%i2;
        !          14389:        case QUEST:     return (cond->eval()) ? i1 : i2;
        !          14390:        case DIV:       if (i2 == 0) {
        !          14391:                                if (Neval == 0) { 
        !          14392:                                        Neval = "divide by zero";
        !          14393:                                        error("divide by zero");
        !          14394:                                }
        !          14395:                                return 1;
        !          14396:                        }
        !          14397:                        return i1/i2;
        !          14398:        case CM:
        !          14399:        case G_CM:
        !          14400:                return i2;
        !          14401:        }
        !          14402: 
        !          14403:        Neval = "unsigned expression";
        !          14404:        return 0;
        !          14405: }
        !          14406: 
        !          14407: long expr::eval()
        !          14408: {
        !          14409:        if (Neval) return 1;
        !          14410: // error('d',"eval %k",base);
        !          14411: 
        !          14412:        static int targno=0;
        !          14413:        static int icallflag=0;
        !          14414: 
        !          14415:        switch (base) {
        !          14416:        case ZERO:      return 0;
        !          14417:        case IVAL:      return i1;
        !          14418:        case ICON:      return str_to_long(string);
        !          14419:        case CCON:      return char_to_int(string);
        !          14420:        case FCON:      Neval = "float in constant expression"; return 1;
        !          14421:        case STRING:    Neval = "string in constant expression"; return 1;
        !          14422:        case EOBJ:      return Pname(this)->n_val;
        !          14423:        case SIZEOF:
        !          14424:                extern no_sizeof;
        !          14425:                if (no_sizeof) Neval = "sizeof";
        !          14426:                return tp2->tsizeof();
        !          14427:                
        !          14428:        case NAME:
        !          14429:        {       Pname n = Pname(this);
        !          14430: // error('d',"eval %n eval %d %d",n,n->n_evaluated,n->n_val);
        !          14431: // error('d',"eval tp->tconst() %d, n->n_initializer: %k", n->tp->tconst(), n->n_initializer?n->n_initializer->base:0 );
        !          14432:                if (n->n_evaluated && n->n_scope!=ARG) return n->n_val;
        !          14433:                if (binary_val && strcmp(string,"_result")==0) return 8888;
        !          14434:                Neval = "cannot evaluate constant";
        !          14435:                return 1;
        !          14436:        }
        !          14437:        case ICALL:
        !          14438:                if (e1) {
        !          14439:                        icallflag=1;
        !          14440:                        targno=0;
        !          14441:                        il->i_next = curr_icall;
        !          14442:                        curr_icall = il;
        !          14443:                        long i = e1->eval();
        !          14444:                        curr_icall = il->i_next;
        !          14445:                        icallflag=0;
        !          14446:                        return i;
        !          14447:                }
        !          14448:                Neval = "void inlineF";
        !          14449:                return 1;
        !          14450:        case ANAME:
        !          14451:        {       Pname n = (Pname)this;
        !          14452: 
        !          14453: /*
        !          14454:                int argno;
        !          14455:                if (icallflag) {
        !          14456:                argno=targno;
        !          14457:                targno++;
        !          14458:                }
        !          14459: */
        !          14460:                int argno = (int) n->n_val;
        !          14461:        
        !          14462:                Pin il;
        !          14463:                for (il=curr_icall; il; il=il->i_next)
        !          14464:                        if (il->i_table == n->n_table) goto aok;
        !          14465:                goto bok;
        !          14466:        aok:
        !          14467:                if (il->i_args[argno].local) {
        !          14468:        bok:
        !          14469:                        Neval = "inlineF call too complicated for constant expression";
        !          14470:                        return 1;
        !          14471:                }
        !          14472:                Pexpr aa = il->i_args[argno].arg;
        !          14473:                return aa->eval();
        !          14474:        }
        !          14475:        case CAST:
        !          14476:        {       if (e1->base==FCON && tp2->base!=FLOAT && tp2->base!=DOUBLE) {
        !          14477:                        char* p = e1->string;
        !          14478:                        while (*p!='.') p++;
        !          14479:                        if (p==e1->string) *p++ = '0';
        !          14480:                        *p = 0;
        !          14481:                        e1->base = ICON;
        !          14482:                }               
        !          14483:                long i = e1->eval();
        !          14484:                Ptype tt = tp2;
        !          14485:        strip:
        !          14486:                switch (tt->base) {
        !          14487:                default:
        !          14488:                        Neval = "cast to non-integral type in constant expression";
        !          14489:                        break;
        !          14490:                case TYPE:
        !          14491:                        tt = Pbase(tt)->b_name->tp;
        !          14492:                        goto strip;
        !          14493:                case EOBJ:
        !          14494:                case LONG:
        !          14495:                case INT:
        !          14496:                case CHAR:
        !          14497:                case SHORT:
        !          14498:                        i &= ~(((~(unsigned long)0)<<(BI_IN_BYTE*(tp2->tsizeof()-1)))<<BI_IN_BYTE);
        !          14499:                        break;
        !          14500:                }
        !          14501:                return i;
        !          14502:        }
        !          14503:        case UMINUS:
        !          14504:        case UPLUS:
        !          14505:        case NOT:
        !          14506:        case COMPL:
        !          14507:        case PLUS:
        !          14508:        case MINUS:
        !          14509:        case MUL:
        !          14510:        case LS:
        !          14511:        case RS:
        !          14512:        case NE:
        !          14513:        case LT:
        !          14514:        case LE:
        !          14515:        case GT:
        !          14516:        case GE:
        !          14517:        case AND:
        !          14518:        case OR:
        !          14519:        case ER:
        !          14520:        case DIV:
        !          14521:        case MOD:
        !          14522:        case QUEST:
        !          14523:        case EQ:
        !          14524:        case ANDAND:
        !          14525:                break;
        !          14526:        case OROR:
        !          14527:                if (binary_val) {       // a||b, don't evaluate b if a!=0
        !          14528:                        long i1 = (e1) ? e1->eval() : 0;
        !          14529:                        if (Neval==0 && i1 && e1->tp->is_unsigned()==0) return i1;
        !          14530:                }
        !          14531:                break;
        !          14532:        case CM:
        !          14533:        case G_CM:
        !          14534:                break;
        !          14535:        case G_ADDROF:
        !          14536:        case ADDROF:
        !          14537:                if (binary_val) {       // beware of &*(T*)0
        !          14538:                        switch (e2->base) {
        !          14539:                        case NAME:
        !          14540:                        case DOT:
        !          14541:                        case REF:       return 9999;
        !          14542:                        }
        !          14543:                }
        !          14544:        default:
        !          14545:                Neval = "bad operator in constant expression";
        !          14546:                return 1;
        !          14547:        }
        !          14548: 
        !          14549:        long i1 = (e1) ? e1->eval() : 0;
        !          14550:        long i2 = (e2) ? e2->eval() : 0;
        !          14551: 
        !          14552:        if (binary_val && i1==9999 && i2==9999) {
        !          14553:                Neval = "";
        !          14554:                return 1;
        !          14555:        }
        !          14556:        
        !          14557:        if (Neval==0
        !          14558:        && ((e1&&e1->tp->is_unsigned()) || (e2&&e2->tp->is_unsigned())))
        !          14559:                return (long) ueval(i1,i2);
        !          14560:        
        !          14561:        switch (base) {
        !          14562:        case UMINUS:    return -i2;
        !          14563:        case UPLUS:     return i2;
        !          14564:        case NOT:       return !i2;
        !          14565:        case COMPL:     return ~i2;
        !          14566:        case CAST:      return i1;
        !          14567:        case PLUS:      return i1+i2;
        !          14568:        case MINUS:     return i1-i2;
        !          14569:        case MUL:       return i1*i2;
        !          14570:        case LS:        return i1<<i2;
        !          14571:        case RS:        return i1>>i2;
        !          14572:        case NE:        return i1!=i2;
        !          14573:        case EQ:        return i1==i2;
        !          14574:        case LT:        return i1<i2;
        !          14575:        case LE:        return i1<=i2;
        !          14576:        case GT:        return i1>i2;
        !          14577:        case GE:        return i1>=i2;
        !          14578:        case AND:       return i1&i2;
        !          14579:        case ANDAND:    return i1&&i2;
        !          14580:        case OR:        return i1|i2;
        !          14581:        case OROR:      return i1||i2;
        !          14582:        case ER:        return i1^i2;
        !          14583:        case MOD:       if (i2 == 0) {
        !          14584:                                if (Neval == 0) { 
        !          14585:                                        Neval = "mod zero";
        !          14586:                                        error("mod zero");
        !          14587:                                }
        !          14588:                                return 1;
        !          14589:                        }
        !          14590:                        return i1%i2;
        !          14591:        case QUEST:     return (cond->eval()) ? i1 : i2;
        !          14592:        case DIV:       if (i2 == 0) {
        !          14593:                                if (Neval == 0) { 
        !          14594:                                        Neval = "divide by zero";
        !          14595:                                        error("divide by zero");
        !          14596:                                }
        !          14597:                                return 1;
        !          14598:                        }
        !          14599:                        return i1/i2;
        !          14600:        case CM:
        !          14601:        case G_CM:
        !          14602:                return i2;
        !          14603:        }
        !          14604: }
        !          14605: bit classdef::baseof(Pname f)
        !          14606: /*
        !          14607:        is ``this'' class a public base class of "f"'s class
        !          14608:        or its immediate base class
        !          14609: */
        !          14610: {
        !          14611:        Ptable ctbl = f->n_table;
        !          14612:        Pname b = ctbl->t_name;
        !          14613: 
        !          14614:        if (b == 0) return 0;
        !          14615:        Pclass cl = Pclass(b->tp);
        !          14616:        if (cl == 0) return 0;
        !          14617:        if (cl == this) return 1;
        !          14618:        ppbase = PUBLIC;
        !          14619:        Pclass bcl = is_base(cl->string);
        !          14620:        return (bcl && ppbase==PUBLIC);
        !          14621: }
        !          14622: 
        !          14623: bit classdef::baseof(Pclass cl)
        !          14624: /*
        !          14625:        is ``this'' class a public base class of "cl"
        !          14626: */
        !          14627: {
        !          14628:        if (cl == 0) return 0;
        !          14629:        if (cl == this) return 1;
        !          14630:        ppbase = PUBLIC;
        !          14631:        Pclass bcl = is_base(cl->string);
        !          14632:        return (bcl && ppbase==PUBLIC);
        !          14633: }
        !          14634: 
        !          14635: static int mem_match(Pfct f1, Pfct f2)
        !          14636: /*
        !          14637:        check class membership.
        !          14638: 
        !          14639:        For some reason checking f_this==0 works and f_static doesn't
        !          14640: */
        !          14641: {
        !          14642: //     if (f1->memof) return f2->f_this ?f2->memof==f1->memof : 0;
        !          14643: //     if (f1 && f1->memof) return f2->f_this?f2->memof==f1->memof : 0;
        !          14644: //     return f2->f_this==0;
        !          14645:        if (f1==0 || f2==0) return 0;
        !          14646:        if (f1->memof && f2->f_this && f2->memof!=f1->memof) return 0;
        !          14647:        if (f2->f_this) return 0;
        !          14648:        if (f1->memof && f2->f_static) return 0;
        !          14649:        if (f1->check(f2,ASSIGN)) return 0;
        !          14650:        return 1;
        !          14651: }
        !          14652: 
        !          14653: int Pchecked;
        !          14654: 
        !          14655: Pexpr ptof(Pfct ef, Pexpr e, Ptable tbl)
        !          14656: /*
        !          14657:        a kludge: initialize/assign-to pointer to function
        !          14658: */
        !          14659: {
        !          14660:        Pfct f;
        !          14661:        Pname n = 0;
        !          14662: eee:
        !          14663: //error('d',"ptof %t %t %k",ef,e->tp,e->base);
        !          14664:        switch (e->base) {
        !          14665:        case QUEST:
        !          14666:                e->e1 = ptof(ef,e->e1,tbl);
        !          14667:                e->e2 = ptof(ef,e->e2,tbl);
        !          14668:                return e;
        !          14669:        case CM:
        !          14670:        case G_CM:
        !          14671:                e->e2 = ptof(ef,e->e2,tbl);
        !          14672:                return e;
        !          14673:        case NAME:
        !          14674:                f = Pfct(e->tp);
        !          14675:                Pname nn = Pname(e);
        !          14676: 
        !          14677:                switch (f->base) {
        !          14678:                case OVERLOAD:
        !          14679:                        e = Pgen(f)->find(ef,0);
        !          14680:                        if (e == 0) {
        !          14681:                                error("cannot deduceT for &overloaded%n",nn);
        !          14682:                                return e;
        !          14683:                        }
        !          14684:                //      e = n;
        !          14685:                        // no break
        !          14686:                case FCT:
        !          14687:                        Pchecked = mem_match(ef,Pfct(e->tp));
        !          14688:                        e = new expr(G_ADDROF,0,e);
        !          14689:                        return e->typ(tbl);     // handle &B::f
        !          14690:                        //e->tp = f;
        !          14691:                }
        !          14692:                goto ad;
        !          14693: 
        !          14694:        case ZERO:
        !          14695:                if (ef->memof) {
        !          14696:                        e = new expr(ELIST,zero,zero);
        !          14697:                        e = new expr(ILIST,e,zero);
        !          14698:                        e->tp = zero_type;
        !          14699:                        return e; 
        !          14700:                }
        !          14701:                break;
        !          14702: 
        !          14703:        case MDOT:
        !          14704:                // ?? error('s',"P toM of not firstB");
        !          14705:                do e = e->mem; while (e->base == MDOT);
        !          14706:                goto eee;
        !          14707: 
        !          14708:        case DOT:
        !          14709:        case REF:
        !          14710:                f = Pfct(e->mem->tp);
        !          14711: 
        !          14712:                switch (f->base) {
        !          14713:                case OVERLOAD:
        !          14714:                        n = Pgen(f)->find(ef,0);
        !          14715:                        if (n == 0) error("cannot deduceT for &overloaded%n",e->mem);
        !          14716:                        else e = n;
        !          14717:                        // no break
        !          14718:                case FCT:
        !          14719:                        Pchecked = mem_match(ef,Pfct(e->tp));
        !          14720:                        e = new expr(G_ADDROF,0,e);
        !          14721:                        return e->typ(tbl);     // handle &B::f
        !          14722:                //      n = Pname(e->mem);
        !          14723:                //      e = n->address();
        !          14724:                }
        !          14725:                goto ad;
        !          14726: 
        !          14727:        case ADDROF:
        !          14728:        case G_ADDROF:
        !          14729:                f = Pfct(e->e2->tp);
        !          14730:        ad:
        !          14731:                if (f->base == OVERLOAD) {
        !          14732:                        n = Pgen(f)->find(ef,0);
        !          14733:                        if (n == 0) error("cannot deduceT for &overloaded %s()",Pgen(f)->fct_list->f->string);
        !          14734:                        Pchecked = mem_match(ef,Pfct(n->tp));
        !          14735:                        e->e2 = n;
        !          14736:                        e->tp = n->tp;
        !          14737:                }
        !          14738:                if (n) n->lval(ADDROF);
        !          14739:                break;
        !          14740: 
        !          14741:        case CAST:
        !          14742:        {
        !          14743:                Pexpr te = e->e1;
        !          14744:                if (e->e1->base == G_ADDROF) te = e->e1->e2;
        !          14745:                (void) ptof(ef,te,tbl);
        !          14746:        }
        !          14747:        }
        !          14748:        return e;
        !          14749: }
        !          14750: 
        !          14751: Pexpr ptr_init(Pptr p, Pexpr init, Ptable tbl)
        !          14752: /*
        !          14753:        check for silly initializers
        !          14754: 
        !          14755:        char* p = 0L;    ??     fudge to allow redundant and incorrect `L'
        !          14756:        char* p = 2 - 2; ??     worse
        !          14757: */
        !          14758: {
        !          14759: // error('d',"ptr_init: p=%t init->tp=%t init->base %k",p,init->tp,init->base);
        !          14760: 
        !          14761:        Pchecked = 0;
        !          14762: 
        !          14763:        Ptype it = init->tp;
        !          14764: itl:
        !          14765:        switch (it->base) {
        !          14766:        case TYPE:
        !          14767:                it = Pbase(it)->b_name->tp; goto itl;
        !          14768:        case ZTYPE:
        !          14769: //             if (init == zero) break;
        !          14770:                break;
        !          14771:        case EOBJ:
        !          14772:        case INT:
        !          14773:        case CHAR:
        !          14774:        case SHORT:
        !          14775:        case LONG:
        !          14776:        {       Neval = 0;
        !          14777:                long i = init->eval();
        !          14778:                if (Neval)
        !          14779:                        error("badPIr: %s",Neval);
        !          14780:                else
        !          14781:                if (i)
        !          14782:                        error("badPIr value %d",i);
        !          14783:                else {
        !          14784:                        DEL(init);
        !          14785:                        init = zero;
        !          14786:                }
        !          14787:                break;
        !          14788:        }               
        !          14789:        }
        !          14790: 
        !          14791:        Pclass c1 = p->memof;
        !          14792: 
        !          14793:        if (c1) {
        !          14794:                if (init==zero)
        !          14795:                        ;
        !          14796:                else {
        !          14797:                        Pclass c2;
        !          14798: // error('d',"it %t %d",it,it->base);
        !          14799:                        switch (it->base) {
        !          14800:                        case FCT:
        !          14801:                                c2 = Pfct(it)->memof;
        !          14802:                                break;
        !          14803:                        case OVERLOAD:
        !          14804:                                c2 = Pfct(Pgen(it)->fct_list->f->tp)->memof;
        !          14805:                                break;
        !          14806:                        case PTR:
        !          14807:                        case RPTR:
        !          14808:                                c2 = Pptr(it)->memof;
        !          14809:                                break;
        !          14810:                        default:
        !          14811:                                c2 = 0;
        !          14812:                        }
        !          14813: 
        !          14814:                        if (c2 == 0) {
        !          14815:                                // initialization by &A::f
        !          14816: //error('d',"curious");
        !          14817:                        }
        !          14818:                        else if (c1 != c2) {
        !          14819:                                 Nptr = 0;
        !          14820:                                Noffset = 0;
        !          14821:                                vcllist->clear();
        !          14822:                                vcllist=0;
        !          14823:                                int u1 = is_unique_base(c1,c2->string,0);
        !          14824: //error('d',"c1 %t c2 %t u1 %d off %d",c1,c2,u1,Noffset);
        !          14825:                                 if (u1 && (Nptr || Noffset)) {
        !          14826:                                        // requires offset manipulation
        !          14827:                                        int bad = 0;
        !          14828:                                        if (u1 == 1 && !Nptr) {
        !          14829:                                                if (init->base==ILIST) {
        !          14830:                                                        // d = d+Noffset;
        !          14831:                                                        switch (init->e1->e1->base) {
        !          14832:                                                                case IVAL:
        !          14833:                                                                        init->e1->e1->i1 += Noffset;
        !          14834:                                                                        break;
        !          14835:                                                                case ZERO:
        !          14836:                                                                        init->e1->e1 = new ival(Noffset);
        !          14837:                                                                        break;
        !          14838:                                                                default:
        !          14839:                                                                        bad = 1;
        !          14840:                                                                }
        !          14841: 
        !          14842:                                                        // if (i<0) f = vptroffset
        !          14843:                                                        switch (init->e1->e2->base) {
        !          14844:                                                                case IVAL:
        !          14845:                                                                        if (0<init->e1->e2->i1) {
        !          14846:                                                                        // extern Ptype Pfct_type;
        !          14847:                                                                        // store vptr offset
        !          14848:                                                                        //  init->e2=new cast(Pfct_type,zero);
        !          14849:                                                                        }
        !          14850:                                                                        else
        !          14851:                                                                                break;
        !          14852:                                                                default:
        !          14853:                                                                        bad = 1;
        !          14854:                                                                }       
        !          14855:                                                } // end if (init->base==ILIST)
        !          14856:                                                else
        !          14857:                                                        bad = 1;
        !          14858:                                        } // end if (u1 == 1 ...
        !          14859:                                        else
        !          14860:                                                bad = 1;
        !          14861: 
        !          14862:                                if (bad) error('s',"%t assigned to %t (too complicated)",init->tp,p);
        !          14863:                                } // end if (u1 && ...
        !          14864: 
        !          14865:                                 Nptr = 0;
        !          14866:                                Noffset = 0;
        !          14867:                                vcllist->clear();
        !          14868:                                vcllist=0;
        !          14869:                                int u2 = is_unique_base(c2,c1->string,0);
        !          14870: //error('d',"c1 %t c2 %t u2 %d off %d",c1,c2,u2,Noffset);
        !          14871:                                 if (u2 && (Nptr || Noffset)) {
        !          14872:                                        // requires offset manipulation
        !          14873:                                        error('s',"%t assigned to %t",init->tp,p);
        !          14874:                                }
        !          14875:                        } // end if (c1 != c2
        !          14876:                } // end else
        !          14877:        } // end if (c1)
        !          14878: 
        !          14879:        Ptype pit = p->typ;
        !          14880: lll:
        !          14881: // error('d',"p %t pit %t",p,pit);
        !          14882:        switch (pit->base) {
        !          14883:        case TYPE:
        !          14884:                pit = Pbase(pit)->b_name->tp;
        !          14885:                goto lll;
        !          14886:        case FCT:
        !          14887:                return ptof(Pfct(pit),init,tbl);
        !          14888:        case COBJ:
        !          14889:        {       Pptr r;
        !          14890: // error('d',"cobj: ptr %t, ref %t",it->is_ptr(),it->is_ref());
        !          14891:                if (r=it->is_ptr_or_ref()) {
        !          14892:                        Pchecked = 1;
        !          14893:                        TOK b = p->base;                // could be REF
        !          14894:                        TOK bb = r->base;
        !          14895:                        if (b==RPTR) p->base = PTR;
        !          14896:                        if (bb==RPTR) r->base = PTR;
        !          14897:                        if (p->check(r,ASSIGN)) {
        !          14898:                                if ( cc && cc->nof && 
        !          14899:                                        Pfct(cc->nof->tp)->f_const &&
        !          14900:                                        cc->c_this == init )
        !          14901:                                                error("%n const: assignment of%n (%t) to%t",cc->nof,init,init->tp,p);
        !          14902:                                else
        !          14903:                                        error("no standard conversion of %t to %t",init->tp,p);
        !          14904:                        }
        !          14905:                        p->base = b;
        !          14906:                        r->base = bb;
        !          14907:                        Pexpr cp = cast_cptr(Pclass(Pbase(pit)->b_name->tp),init,tbl,0);
        !          14908:                        if (cp != init) {
        !          14909:                                PERM(p);        // or else it will be deleted twice!
        !          14910:                                return new cast(p,cp);
        !          14911:                        }
        !          14912:                }
        !          14913:                // no break
        !          14914:        }
        !          14915:        default:
        !          14916:                return init;
        !          14917:        }
        !          14918: }
        !          14919: 
        !          14920: static Pname Lcoerce, Rcoerce;
        !          14921: extern int suppress_error;
        !          14922: 
        !          14923: int try_to_demote(TOK oper, Ptype t1, Ptype t2)
        !          14924: /*
        !          14925:        look at t1 and t2 and see if there are ``demotions'' of t1 and/or t2
        !          14926:        so that ``t1 oper t2'' can be made legal
        !          14927: 
        !          14928:        return  0 is not
        !          14929:                1 if there is exactly one way
        !          14930:                >1 if there is more than one way (if in doubt return 2)
        !          14931: */
        !          14932: {
        !          14933: //error('d',"try_to_demote(%k : %t : %t)",oper,t1,t2);
        !          14934: 
        !          14935:        Pname n1 = t1 ? t1->is_cl_obj() : 0;
        !          14936:        Pclass c1 = n1 ? Pclass(n1->tp) : 0;
        !          14937:        Pname n2 = t2 ? t2->is_cl_obj() : 0;
        !          14938:        Pclass c2 = n2 ? Pclass(n2->tp) : 0;
        !          14939: 
        !          14940:        Ptype lt = t1;
        !          14941:        Ptype rt = t2;
        !          14942: 
        !          14943:        Lcoerce = Rcoerce = 0;
        !          14944: 
        !          14945: //     if (oper == DOT) return 0;
        !          14946: 
        !          14947:        if (c1)
        !          14948:                switch (oper) {
        !          14949:                case ASSIGN:
        !          14950:                case ASPLUS:
        !          14951:                case ASMINUS:
        !          14952:                case ASMUL:
        !          14953:                case ASDIV:
        !          14954:                case ASMOD:
        !          14955:                case ASAND:
        !          14956:                case ASOR:
        !          14957:                case ASER:
        !          14958:                case ASLS:
        !          14959:                case ASRS:      // don't coerce left hand side of assignment
        !          14960:                //      c1 = 0;
        !          14961:                        if (c1->memtbl->look("__as",0)) return 0;
        !          14962:                }
        !          14963:        else
        !          14964:                switch (oper) {
        !          14965:                case ADDROF:
        !          14966:                case INCR:
        !          14967:                case DECR:      // don't coerce unary requiring an lval
        !          14968:                        return 0;
        !          14969:                }
        !          14970: 
        !          14971:        if (c1) {
        !          14972: //error('d',"c1 %t",c1);
        !          14973:                for (Pname on1 = c1->conv; on1; on1=on1->n_list) {
        !          14974: // error( 'd', "on1: %s tp: %k", on1->string, on1->tp->base );
        !          14975:                        Pfct f = Pfct(on1->tp);
        !          14976:                        lt = f->base==FCT ? f->returns :
        !          14977:                                Pfct(Pgen(on1->tp)->fct_list->f->tp)->returns;
        !          14978:                        Pname cn = lt->is_cl_obj();
        !          14979: 
        !          14980:                        if (cn && (Lcoerce==0 || Lcoerce->tp->check(f,0))) {
        !          14981:                                Pclass cl = Pclass(cn->tp);
        !          14982:                                Pname n = cl->has_oper(oper);
        !          14983:                                if (n == 0) continue;
        !          14984:                //              while (n->base==REF || n->base==MDOT) n=Pname(n->mem) ;
        !          14985:                                Pfct nf = Pfct(n->tp);
        !          14986: // error( 'd', "nf: %d %k", nf->base, nf->base );
        !          14987:                                if (nf->base == FCT) {
        !          14988:                                        if (nf->nargs==1
        !          14989:                                        && t2
        !          14990:                                        && (nf->argtype->tp->check(t2,ARG)==0
        !          14991:                                                || can_coerce(nf->argtype->tp,t2)==1)
        !          14992:                                        ) {
        !          14993:                                                if (Lcoerce) return 2;
        !          14994:                                                Lcoerce = on1;
        !          14995:                                        }
        !          14996:                                }
        !          14997:                                else {
        !          14998:                                        for (Plist gl=Pgen(nf)->fct_list; gl; gl=gl->l) {
        !          14999:                                                Pfct nf = Pfct(gl->f->tp);
        !          15000:                                                if (nf->nargs==1
        !          15001:                                                && t2
        !          15002:                                                && (nf->argtype->tp->check(t2,ARG)==0
        !          15003:                                                        || can_coerce(nf->argtype->tp,t2)==1)
        !          15004:                                                ) {
        !          15005:                                                        if (Lcoerce) return 2;
        !          15006:                                                        Lcoerce = on1;
        !          15007:                                                }
        !          15008:                                        }
        !          15009:                                }
        !          15010:                                continue;
        !          15011:                        }
        !          15012:                        //if (lt->is_cl_obj()) continue;
        !          15013:                        if (c2) {
        !          15014: //error('d',"c2 %t",c2);
        !          15015:                                for (Pname on2 = c2->conv; on2; on2=on2->n_list) {
        !          15016:                                        Pfct f = Pfct(on2->tp);
        !          15017:                                        rt = f->base==FCT ? f->returns :
        !          15018:                                                Pfct(Pgen(on2->tp)->fct_list->f->tp)->returns;
        !          15019:                                        if (rt->is_cl_obj()) continue;
        !          15020: 
        !          15021:                                        suppress_error = 1;
        !          15022:                                        int r1 = lt->kind(oper,0);
        !          15023:                                        int r2 = rt->kind(oper,0);
        !          15024:                                        if (np_promote(oper,r1,r2,lt,rt,1)!=any_type) {
        !          15025:                                                Pname sn = on1;
        !          15026:                                                if (Lcoerce) {
        !          15027:                                                    Pname tn = really_dominate(
        !          15028:                                                        Lcoerce, 
        !          15029:                                                        on1, 
        !          15030:                                                        const_obj1
        !          15031:                                                    );
        !          15032:                                                    if(!tn) {
        !          15033:                                                        suppress_error = 0;
        !          15034:                                                        return 2;
        !          15035:                                                    }
        !          15036:                                                    else sn = tn;
        !          15037:                                                }
        !          15038:                                                Lcoerce = sn;
        !          15039:                                                Rcoerce = on2;
        !          15040:                                        
        !          15041:                                        }
        !          15042:                                        suppress_error = 0;
        !          15043:                                }
        !          15044:                                        
        !          15045:                        }
        !          15046:                        else if (rt) {
        !          15047:                                suppress_error = 1;
        !          15048:                                int r1 = lt->kind(oper,0);
        !          15049:                                int r2 = rt->kind(oper,0);
        !          15050:                                if (np_promote(oper,r1,r2,lt,rt,1)!=any_type) {
        !          15051:                                        Pname sn = on1;
        !          15052:                                        if (Lcoerce) {
        !          15053:                                                Pname tn = really_dominate(
        !          15054:                                                        Lcoerce, 
        !          15055:                                                        on1, 
        !          15056:                                                        const_obj1
        !          15057:                                                );
        !          15058:                                                if(!tn) {
        !          15059:                                                        suppress_error = 0;
        !          15060:                                                        return 2;
        !          15061:                                                }
        !          15062:                                                else sn = tn;
        !          15063:                                        }
        !          15064:                                        Lcoerce = sn;
        !          15065:                                }
        !          15066:                                suppress_error = 0;
        !          15067:                        }
        !          15068:                        else {
        !          15069:                                Pname sn = on1;
        !          15070:                                if (Lcoerce) {
        !          15071:                                        Pname tn = really_dominate(
        !          15072:                                                Lcoerce, 
        !          15073:                                                on1, 
        !          15074:                                                const_obj1
        !          15075:                                        );
        !          15076:                                        if(!tn) return 2;
        !          15077:                                        else sn = tn;
        !          15078:                                }
        !          15079:                                Lcoerce = sn;
        !          15080:                        }
        !          15081:                }
        !          15082:        }
        !          15083:        else if (c2) {
        !          15084: //error('d',"c2 %n",c2);
        !          15085:                for (Pname on = c2->conv; on; on=on->n_list) {
        !          15086:                        Pfct f = Pfct(on->tp);
        !          15087:                        rt = f->base==FCT ? f->returns :
        !          15088:                                Pfct(Pgen(on->tp)->fct_list->f->tp)->returns;
        !          15089:                        Pname cn = rt->is_cl_obj();
        !          15090: //error('d',"cn %n",cn);
        !          15091:                        if (cn && (Rcoerce==0 || Rcoerce->tp->check(f,0))) {
        !          15092:                                Pclass cl = Pclass(cn->tp);
        !          15093:                                Pname n = cl->has_oper(oper);
        !          15094:                                if (n == 0) continue;
        !          15095: 
        !          15096:                //              while (n->base==REF || n->base==MDOT) n=Pname(n->mem);
        !          15097:                                Pfct nf = Pfct(n->tp);
        !          15098:                                if (nf->base == FCT) {
        !          15099:                                        if (nf->nargs == 0) {
        !          15100:                                                if (Lcoerce || Rcoerce) return 2;
        !          15101:                                                Rcoerce = on;
        !          15102:                                        }
        !          15103:                                }
        !          15104:                                else {
        !          15105:                                        for (Plist gl=Pgen(nf)->fct_list; gl; gl=gl->l) 
        !          15106:                                                if (Pfct(gl->f->tp)->nargs == 0) {
        !          15107:                                                        if (Lcoerce || Rcoerce) return 2;
        !          15108:                                                        Rcoerce = on;
        !          15109:                                                }
        !          15110:                                }
        !          15111:                                continue;
        !          15112:                        }
        !          15113:                        //if (rt->is_cl_obj()) continue;
        !          15114:                        if( lt ) {
        !          15115:                                suppress_error = 1;
        !          15116:                                int r1 = lt->kind(oper,0);
        !          15117:                                int r2 = rt->kind(oper,0);
        !          15118: 
        !          15119:                                if (np_promote(oper,r1,r2,lt,rt,1)!=any_type) {
        !          15120:                                        Pname sn = on;
        !          15121:                                        if (Lcoerce || Rcoerce) {
        !          15122:                                                Pname tn = really_dominate(
        !          15123:                                                        Rcoerce, 
        !          15124:                                                        on, 
        !          15125:                                                        const_obj2
        !          15126:                                                );
        !          15127:                                                if(!tn) {
        !          15128:                                                        suppress_error = 0;
        !          15129:                                                        return 2;
        !          15130:                                                }
        !          15131:                                                else sn = tn;
        !          15132:                                        }
        !          15133:                                        Rcoerce = sn;
        !          15134:                                }
        !          15135:                                suppress_error = 0;
        !          15136:                        }
        !          15137:                }
        !          15138:        }
        !          15139: 
        !          15140: //error('d',"->%d || %d",Lcoerce,Rcoerce);
        !          15141:        return (Lcoerce || Rcoerce);
        !          15142: }
        !          15143: 
        !          15144: Pexpr expr::try_to_overload(Ptable tbl)
        !          15145: {
        !          15146: //     TOK bb = (base==DEREF && e2==0) ? MUL : base;
        !          15147: // error('d',"try_to_overload %k %d",base,base);
        !          15148: 
        !          15149:        Pname n1 = 0;
        !          15150:        Ptype t1 = 0;
        !          15151:        const_obj1 = 0;
        !          15152:        const_obj2 = 0;
        !          15153: 
        !          15154:        if (e1) {
        !          15155:                t1 = e1->tp;
        !          15156:                Ptype tpx = t1;
        !          15157:                while (tpx->base == TYPE) tpx = Pbase(tpx)->b_name->tp;
        !          15158:                n1 = tpx->is_cl_obj();
        !          15159:                const_obj1 = t1->tconst();
        !          15160: 
        !          15161:                Pexpr ee = e1;
        !          15162:                 while (ee && (ee->base==DOT || ee->base==REF)) {
        !          15163:                                Pexpr m = ee->mem;
        !          15164:                                if ( ee->base==REF && m->tp &&  m->tp->is_ptr())
        !          15165:                                        break;
        !          15166:                                ee = ee->e1;
        !          15167:                 }
        !          15168:                 if (ee) {
        !          15169:                        int tc;
        !          15170:                                Ptype ttt = ee->tp;
        !          15171:                                switch (e1->base) {
        !          15172:                                case REF:
        !          15173:                                        Pptr p = ttt?ttt->is_ptr():0;
        !          15174:                                        if (p && p->typ->tconst())
        !          15175:                                                const_obj1 = 1;
        !          15176:                                        break;
        !          15177:                                case DOT:
        !          15178:                                tc = ttt ? ttt->tconst() : 0;
        !          15179:                                        if (ttt && tc && (!strict_opt || tc!=2))
        !          15180:                                                const_obj1 = 1;
        !          15181:                                }
        !          15182:                 }
        !          15183:        }
        !          15184: 
        !          15185:        TOK bb = base;
        !          15186:        switch (bb) {
        !          15187:        case DEREF:
        !          15188:                if (e2 == 0) bb = MUL;
        !          15189:                // no break;
        !          15190:        case CALL:
        !          15191:        case G_CALL:
        !          15192:                if (n1 == 0) return 0;  // ignore type of argument list
        !          15193:        }
        !          15194: 
        !          15195:        Pname n2 = 0;
        !          15196:        Ptype t2 = 0;
        !          15197: 
        !          15198:        if (e2 && e2->base!=ELIST) {
        !          15199:                t2 = e2->tp;
        !          15200:                Ptype tpx = t2;
        !          15201:                while (tpx->base == TYPE) tpx = Pbase(tpx)->b_name->tp;
        !          15202:                n2 = tpx->is_cl_obj();
        !          15203:                const_obj2 = t2->tconst();
        !          15204:                Pexpr ee = e2;
        !          15205:                 while (ee && (ee->base==DOT || ee->base==REF)) {
        !          15206:                                Pexpr m = ee->mem;
        !          15207:                                if ( ee->base==REF && m->tp &&  m->tp->is_ptr())
        !          15208:                                        break;
        !          15209:                                ee = ee->e1;
        !          15210:                 }
        !          15211:                 if (ee) {
        !          15212:                        int tc;
        !          15213:                                Ptype ttt = ee->tp;
        !          15214:                                switch (e2->base) {
        !          15215:                                case REF:
        !          15216:                                        Pptr p = ttt?ttt->is_ptr():0;
        !          15217:                                        if (p && p->typ->tconst())
        !          15218:                                                const_obj2 = 1;
        !          15219:                                        break;
        !          15220:                                case DOT:
        !          15221:                                tc = ttt ? ttt->tconst() : 0;
        !          15222:                                        if (ttt && tc && (!strict_opt || tc!=2))
        !          15223:                                                const_obj2 = 1;
        !          15224:                                }
        !          15225:                 }
        !          15226:        }
        !          15227: 
        !          15228:        if (n1==0 && n2==0) return 0;
        !          15229:        if (n1 && n1->tp == 0) return 0;        // make_assign() fudge
        !          15230: // error('d',"e1: %k e2: %k", e1?e1->base:0, e2?e2->base:0 );
        !          15231: // error('d',"t1 %t t2 %t",t1,t2);
        !          15232: // error('d',"n1 %n n2 %n",n1,n2);
        !          15233:        /* first try for non-member function:   op(e1,e2) or op(e2) or op(e1) */
        !          15234:        Pexpr oe2 = e2;
        !          15235:        Pexpr ee2 = (e2 && e2->base!=ELIST) ? e2 = new expr(ELIST,e2,0) : 0;
        !          15236:        Pexpr ee1 = e1 ? new expr(ELIST,e1,e2) : ee2;
        !          15237:        char* obb = oper_name(bb);
        !          15238:        Pname gname = tbl->look(obb,0);
        !          15239:        // if necessary check for ambiguities
        !          15240:        int go = gname ? over_call(gname,ee1) : 0;
        !          15241: //error('d',"go %d",go);
        !          15242:        if (go) gname = Nover;
        !          15243: 
        !          15244:        if (n1) {
        !          15245:                if (bb == ASSIGN) {
        !          15246:                        Pclass c1 = Pclass(n1->tp);
        !          15247: //error('d',"look %k %d",bb,c1->memtbl->look(obb,0));
        !          15248:                        if (c1->memtbl->look(obb,0)==0) {
        !          15249:                                Pclass bcl = c1->baselist?c1->baselist->bclass:0;
        !          15250:                                if (n2==0
        !          15251:                                || (Pclass(n2->tp)!=c1
        !          15252:                                        && Pclass(n2->tp)->has_base(c1)==0)) {
        !          15253:                                        // if legal, a=1 can be optimized to a.ctor(1)
        !          15254:                                                if (2 < go) goto glob;
        !          15255:                                                return 0;
        !          15256:                                        }
        !          15257: 
        !          15258:                                if (bcl
        !          15259:                                && c1->obj_size!=bcl->obj_size
        !          15260:                                && bcl->memtbl->look(obb,0)) {
        !          15261:                                        // cannot inherit from smaller base class
        !          15262:                                //      make_assignment(n1);
        !          15263:                                //      return try_to_overload(tbl);
        !          15264:                                        goto mkas;
        !          15265:                                }
        !          15266: 
        !          15267:                                if (c1->c_xref&(C_VBASE|C_VPTR|C_ASS)) {
        !          15268:                                        // make operator=() if
        !          15269:                                        //      no base (shouldn't happen
        !          15270:                                        //      different (smaller) sized base
        !          15271:                                        //      two bases
        !          15272:                                mkas:
        !          15273:                                        if (2 < go) goto glob;
        !          15274:                                //      make_assignment(n1);
        !          15275:                                //      return try_to_overload(tbl);
        !          15276:                                        return make_assignment(n1) ? try_to_overload(tbl) : 0;
        !          15277:                                }
        !          15278: // error('d',"n2 %n",n2);
        !          15279:                        //      if (n2 && Pclass(n2->tp)==c1)
        !          15280:                                return 0;
        !          15281:                        }
        !          15282:                        // now take care of other assignments, 
        !          15283:                }
        !          15284: 
        !          15285:                int dbconv = 0;
        !          15286:                Pclass ccl = Pclass(n1->tp);
        !          15287:                // Pexpr mn = Pclass(n1->tp)->memtbl->look(obb,0);
        !          15288:                Pexpr mn = ccl->memtbl->look(obb,0);
        !          15289: // error('d', "tcl %d %t cl %d %t", tcl, tcl, ccl, ccl);
        !          15290:                if(strcmp(obb,"__as")) {
        !          15291:                        tcl = ccl; // ugh!!! 
        !          15292:                        if(!mn) dbconv = 2;
        !          15293:                }
        !          15294: //             tcl = ccl; // ugh!!! 
        !          15295:                mn = ccl->find_name(obb,0);
        !          15296: 
        !          15297:                Pname mname = Pname(mn);
        !          15298: // error('d',"mn %n %d %k %s",mname,mn,mn?mn->base:0,obb);
        !          15299:                if (mname == 0) goto glob;
        !          15300: 
        !          15301:        zaq:
        !          15302:                switch (mname->base) {
        !          15303:                case REF:
        !          15304:                case MDOT:
        !          15305:                        mname = Pname(Pexpr(mname)->mem);
        !          15306:                        goto zaq;
        !          15307:                }
        !          15308: 
        !          15309:                int mo = over_call(mname,e2);
        !          15310:                int smo = mo;
        !          15311:                if(mo && dbconv && mo >= dbconv) mo = dbconv;
        !          15312: //error('d',"mo %d (go %d)",mo,go);
        !          15313:                if (mo==0 || mo<go)
        !          15314:                        goto glob;
        !          15315:                else if (mo && mo==go) {
        !          15316: //error('d',"t1 %t t2 %t",t1,t2);
        !          15317:                        if (gname->tp->base == OVERLOAD) { // find right version
        !          15318:                                for (Plist l = Pgen(gname->tp)->fct_list; l; l=l->l) {
        !          15319:                                        Pname n = l->f;
        !          15320:                                        int x = over_call(n,ee1);
        !          15321:                                        if (x == go) {
        !          15322:                                                gname = n;
        !          15323:                                                break;
        !          15324:                                        }
        !          15325:                                }
        !          15326:                        }
        !          15327: //error('d',"gname %n: %t",gname,gname->tp);
        !          15328:                        Pname aa = Pfct(gname->tp)->argtype;
        !          15329:                        Pptr p;
        !          15330:                        Ptype gt1 = aa->tp;
        !          15331:                        if (p = gt1->is_ref()) gt1 = p->typ;
        !          15332:                        Ptype gt2 = aa->n_list->tp;
        !          15333: //error('d',"gt1 %t gt2 %t",gt1,gt2);
        !          15334:                        if (mname->tp->base == OVERLOAD) { // find right version
        !          15335:                                for (Plist l = Pgen(mname->tp)->fct_list; l; l=l->l) {
        !          15336:                                        Pname n = l->f;
        !          15337:                                        int x = over_call(n,e2);
        !          15338:                                        if (x == smo) {
        !          15339:                                                mname = n;
        !          15340:                                                break;
        !          15341:                                        }
        !          15342:                                }
        !          15343:                        }
        !          15344: //error('d',"mname %n: %t",mname,mname->tp);
        !          15345:                        Ptype mt1 = Pfct(mname->tp)->f_this->tp;
        !          15346:                        mt1 = Pptr(mt1)->typ;
        !          15347:                        Ptype mt2 = Pfct(mname->tp)->argtype->tp;
        !          15348: //error('d',"mt1 %t mt2 %t",mt1,mt2);
        !          15349:                        Pname mm = new name;
        !          15350:                        Pname a1 = new name;
        !          15351:                        a1->tp = mt1;
        !          15352:                        Pname a2 = new name;
        !          15353:                        a2->tp = mt2;
        !          15354:                        a1->n_list = a2;
        !          15355:                        mm->tp = new fct(void_type,a1,2);
        !          15356:                        Pname gg = new name;
        !          15357:                        Pname a3 = new name;
        !          15358:                        a3->tp = gt1;
        !          15359:                        Pname a4 = new name;
        !          15360:                        a4->tp = gt2;
        !          15361:                        a3->n_list = a4;
        !          15362:                        gg->tp = new fct(void_type,a3,1);
        !          15363: extern Pname dominate(Pname,Pname,Pexpr,int,int);
        !          15364:                        aa = dominate(gg,mm,ee1,0,1);
        !          15365:                        delete a1;
        !          15366:                        delete a2;
        !          15367:                        delete a3;
        !          15368:                        delete a4;
        !          15369:                        DEL( gg->tp );
        !          15370:                        DEL( mm->tp );
        !          15371:                        //delete gg->tp;
        !          15372:                        //delete mm->tp;
        !          15373:                        if (aa == 0) {
        !          15374:                                delete gg;
        !          15375:                                delete mm;
        !          15376:                                error("ambiguous operandTs%n and%t for%k",n1,t2,bb);
        !          15377:                                tp = any_type;
        !          15378:                                return this;
        !          15379:                        }
        !          15380:                        else if (aa == gg) {
        !          15381:                                delete gg;
        !          15382:                                delete mm;
        !          15383:                                goto glob;
        !          15384:                        }
        !          15385:                        delete gg;
        !          15386:                        delete mm;
        !          15387:                }
        !          15388:                else if (mo < 2) {      // user-defined conversion user
        !          15389: 
        !          15390:                        if (try_to_demote(bb,t1,t2))
        !          15391:                                error("ambiguous use of overloaded%k",bb);
        !          15392:                }
        !          15393: 
        !          15394:                base = G_CALL;                          // e1.op(e2) or e1.op()
        !          15395:                Pname xx = new name(mname->string);     // do another lookup
        !          15396:                                                        // . suppresses virtual
        !          15397:                e1 = new ref(DOT,e1,xx);
        !          15398:                if (ee1) delete ee1;
        !          15399:                return typ(tbl);
        !          15400:        }
        !          15401:        
        !          15402:        if (n2 && e1==0) {                      /* look for unary operator */
        !          15403:                suppress_error++;
        !          15404:                Pexpr mn = Pclass(n2->tp)->find_name(obb,0);
        !          15405:                suppress_error--;
        !          15406:                Pname mname = Pname(mn);
        !          15407:                if (mname == 0) goto glob;
        !          15408:        zaqq:
        !          15409:                switch (mname->base) {
        !          15410:                case REF:
        !          15411:                case MDOT:
        !          15412:                        mname = Pname(Pexpr(mname)->mem);
        !          15413:                        goto zaqq;
        !          15414:                }       
        !          15415: 
        !          15416:                switch (mname->n_scope) {
        !          15417:                default:        goto glob;
        !          15418:                case 0:
        !          15419:                case PUBLIC:    break;          // try e2.op()
        !          15420:                }
        !          15421:                
        !          15422:                int mo = over_call(mname,0);
        !          15423: //error('d',"e2 mo %d (go %d)",mo,go);
        !          15424:                if (mo==0 || mo<go)
        !          15425:                        goto glob;
        !          15426:                else if (mo==go) {
        !          15427:                        error("ambiguous operandT%n for%k",n2,bb);
        !          15428:                        tp = any_type;
        !          15429:                        return this;
        !          15430:                }
        !          15431:                else if (mo < 2) {      // user-defined conversion user
        !          15432:                        if (try_to_demote(bb,t1,t2))
        !          15433:                                error("ambiguous use of overloaded%k",bb);
        !          15434:                }
        !          15435:                base = G_CALL;                          // e2.op()
        !          15436:                Pname xx = new name(Nover->string);     // do another lookup
        !          15437:                                                        // . suppresses virtual
        !          15438:                e1 = new ref(DOT,oe2,xx);
        !          15439:                e2 = 0;
        !          15440:                if (ee2) delete ee2;
        !          15441:                if (ee1 && ee1!=ee2) delete ee1;
        !          15442:                return typ(tbl);
        !          15443:        }
        !          15444:        
        !          15445: glob:
        !          15446: // error('d',"glob %d",go);
        !          15447: 
        !          15448:        if (go) {
        !          15449:                if (go < 2) {   // user-defined conversion necessary => binary
        !          15450:                        if (try_to_demote(bb,t1,t2))
        !          15451:                                error("ambiguous use of overloaded%k: %t and %t",bb,t1,t2);
        !          15452:                }
        !          15453: 
        !          15454:                base = gname->n_table == gtbl ? G_CALL : CALL;
        !          15455: //error('d',"gname %n %t",gname,gname->tp);
        !          15456:                e1 = new name(gname->string);
        !          15457:                // if global scope, look only for globals
        !          15458:                if(gname->n_table == gtbl) Pname(e1)->n_qualifier = sta_name;
        !          15459:                e2 = ee1;
        !          15460:                return typ(tbl);
        !          15461:        }
        !          15462: 
        !          15463:        if (ee2) delete ee2;
        !          15464:        if (ee1 && ee1!=ee2) delete ee1;
        !          15465:        e2 = oe2;
        !          15466: 
        !          15467: // error('d',"bb %d %k",bb,bb);
        !          15468:        switch (bb) {
        !          15469:        case CM:
        !          15470:        case G_CM:
        !          15471:        case G_ADDROF:
        !          15472:                return 0;
        !          15473:        case ASSIGN:
        !          15474:                if (n1
        !          15475:                && n2
        !          15476:                && (n1->tp==n2->tp || Pclass(n2->tp)->has_base(Pclass(n1->tp)))) {
        !          15477:                        if (make_assignment(n1))
        !          15478:                                return try_to_overload(tbl);
        !          15479:                        else
        !          15480:                                return 0;
        !          15481:                }
        !          15482:        case DEREF:
        !          15483:        case CALL:
        !          15484:                if (n1 == 0) break;
        !          15485: 
        !          15486:        default:        /* look for conversions to basic types */
        !          15487:                if (n1
        !          15488:                && Pclass(n1->tp)->conv
        !          15489:                && (bb==ANDAND || bb==OROR)) {
        !          15490:                        e1 = check_cond(e1,bb,tbl);
        !          15491:                        return 0;
        !          15492:                }
        !          15493: 
        !          15494:                if (n2
        !          15495:                && Pclass(n2->tp)->conv
        !          15496:                && (bb==ANDAND || bb==OROR || bb==NOT || 
        !          15497:                        bb==UMINUS || bb==UPLUS || bb==COMPL)) {
        !          15498:                                e2 = check_cond(e2,bb,tbl);
        !          15499:                                return 0;
        !          15500:                }
        !          15501: 
        !          15502: // error( 'd', "bb: %k t1: %k t2: %k", bb, t1?t1->base:0, t2?t2->base:0 );
        !          15503:                switch (try_to_demote(bb,t1,t2)) {
        !          15504:                default:
        !          15505:                        if (Lcoerce) error("ambiguous conversion of%n",n1);
        !          15506:                        if (Rcoerce) error("ambiguous conversion of%n",n2);
        !          15507:                case 0:
        !          15508:                        break;
        !          15509:                case 1:
        !          15510:                        if (Lcoerce) {
        !          15511:                                Pname xx = new name(Lcoerce->string);
        !          15512:                                Pref r = new ref(DOT,e1,xx);
        !          15513:                                e1 = new expr(G_CALL,r,0);
        !          15514:                        }
        !          15515: 
        !          15516:                        if (Rcoerce) {
        !          15517:                                Pname xx = new name(Rcoerce->string);
        !          15518:                                Pref r = new ref(DOT,e2,xx);
        !          15519:                                e2 = new expr(G_CALL,r,0);
        !          15520:                        }
        !          15521:                        return typ(tbl);
        !          15522:                }
        !          15523: 
        !          15524:                switch (bb) {
        !          15525:                case CM:
        !          15526:                case ADDROF:    // has legal built-in meaning
        !          15527:                        return 0;
        !          15528:                }
        !          15529: 
        !          15530:                if (t1 && t2)
        !          15531:                        error("bad operandTs%t%t for%k",t1,t2,bb);
        !          15532:                else
        !          15533:                        error("bad operandT%t for%k",t1?t1:t2,bb);
        !          15534: 
        !          15535:                tp = any_type;
        !          15536:                return this;
        !          15537:        }
        !          15538: 
        !          15539:        return 0;
        !          15540: }
        !          15541: 
        !          15542: Pexpr cast_cptr(Pclass ccl, Pexpr ee, Ptable tbl, int real_cast)
        !          15543: /*
        !          15544:        "ee" is being cast to pointer object of class "ccl"
        !          15545:        if necessary modify "ee"
        !          15546: */
        !          15547: {
        !          15548: 
        !          15549: //     Ptype etp = ee->tp;
        !          15550: // error('d',"cast_cptr %k ccl %t ee->tp %t",ee->tp->base,ccl,ee->tp);
        !          15551: //     if (etp->base!=PTR && etp->base!=RPTR) return ee;
        !          15552:        Ptype etp = ee->tp->is_ptr_or_ref();
        !          15553:        if (etp == 0) return ee;
        !          15554: 
        !          15555:        Pname on = Pptr(etp)->typ->is_cl_obj();
        !          15556:        if (on == 0) return ee;
        !          15557: 
        !          15558:        Pclass ocl = Pclass(on->tp);
        !          15559:        if (ocl==ccl || ccl==0 || ocl==0) return ee;
        !          15560: 
        !          15561: // error('d',"cast_cptr %t(%t) real %d",ccl,ocl,real_cast);
        !          15562:        int oo = 0;
        !          15563:        Pexpr r = 0;
        !          15564: 
        !          15565:        if (ocl->baselist
        !          15566:        && (ocl->baselist->bclass!=ccl || ocl->baselist->base!=NAME)) {
        !          15567:                // casting derived to second or virtual base?
        !          15568:                Nptr = 0;
        !          15569:                Nvis = 0; 
        !          15570:                Nalloc_base = 0;
        !          15571:                vcllist->clear();
        !          15572:                vcllist=0;
        !          15573:                int x = is_unique_base(ocl,ccl->string,0);
        !          15574:                if (Nvis) {
        !          15575:                        if (real_cast==0)
        !          15576:                                error("cast:%n* ->B%t*; privateBC",on,ccl);
        !          15577:                        else if (warning_opt)
        !          15578:                                error('w',"cast:%n* ->B%t*; privateBC",on,ccl);
        !          15579:                        real_cast = 1;  // suppress further error mesages
        !          15580:                        Nvis = 0;
        !          15581:                }
        !          15582: 
        !          15583:                switch (x) {
        !          15584:                default:
        !          15585:                        error("cast:%n* ->B%t*;%t isB more than once",on,ccl,ccl);
        !          15586:                case 0:         // unrelated;
        !          15587:                        break;
        !          15588:                case 1:
        !          15589:                        oo = Noffset;
        !          15590:                        break;
        !          15591:                }
        !          15592: 
        !          15593:                if (Nptr) {     // => ee?Nptr:0
        !          15594:                         if (ocl->c_body==1) ocl->dcl_print(0);
        !          15595:                         Nptr->mem = ee; // ee->Pbase_class
        !          15596:                        if ( Nalloc_base ) {
        !          15597: // error('d', "cast_cptr: nalloc_base: %s", Nalloc_base);
        !          15598:                                Nptr->i1 = 5;
        !          15599:                                Nptr->string4 = new char[strlen(Nalloc_base)];
        !          15600:                                strcpy(Nptr->string4,Nalloc_base);
        !          15601:                                Nalloc_base = 0;
        !          15602:                        }
        !          15603:                        else Nptr->i1 = 3;
        !          15604: 
        !          15605:                         if (ee->base==ADDROF || ee->base==G_ADDROF)   
        !          15606:                                 ee = Nptr;
        !          15607:                         else {
        !          15608:                                Pexpr p = new expr(QUEST,Nptr,zero);
        !          15609:                                nin = 1;
        !          15610:                                if (ee->not_simple()) { // need temp
        !          15611:                                        Ptype t = ee->tp;
        !          15612:                                        Pname pp = make_tmp('N',t,tbl);
        !          15613:                                        Pname(pp)->n_assigned_to = 1;
        !          15614:                                        ee = new expr(ASSIGN,pp,ee);
        !          15615:                                        ee->tp = t;
        !          15616:                                        Nptr->mem = pp;
        !          15617:                                }
        !          15618:                                nin = 0;
        !          15619:                                p->cond = ee;
        !          15620:                                p->tp = ee->tp;
        !          15621:                                 ee = p;
        !          15622:                        }
        !          15623:                }                       
        !          15624:        }
        !          15625: 
        !          15626:        if (ccl->baselist
        !          15627:        && (ccl->baselist->bclass!=ocl || ccl->baselist->base!=NAME)) {
        !          15628:                // casting second or virtual base to derived?
        !          15629:                Nptr = 0;
        !          15630:                vcllist->clear();
        !          15631:                vcllist=0;
        !          15632:                int x = is_unique_base(ccl,ocl->string,0);
        !          15633:                switch (x) {
        !          15634:                default:
        !          15635:                        error("cast:%n* ->derived%t*;%n isB more than once",on,ccl,on);
        !          15636:                case 0:         // unrelated;
        !          15637:                        break;
        !          15638:                case 1:
        !          15639:                        oo = -Noffset;
        !          15640:                         if (Nptr)
        !          15641:                                 error("cast:%n* ->derived%t*;%n is virtualB",on,ccl,on);
        !          15642:                         break;
        !          15643:                }
        !          15644:                Nvis = 0;       // visibility no concern when converting from base to derived
        !          15645:        }
        !          15646: // error('d',"oo %d ee %k",oo,ee->base);
        !          15647:        if (oo) {       // => ee?ee+offset:0
        !          15648:                 if (ee->base==ADDROF || ee->base==G_ADDROF)
        !          15649:                         ee = rptr(ee->tp,ee,oo);
        !          15650:                 else {
        !          15651:                        Pexpr p;
        !          15652:                        nin = 1;
        !          15653:                        if (ee->not_simple()) { // need temp
        !          15654:                                Ptype t = ee->base==MDOT?ee->mem->tp:ee->tp;
        !          15655:                                Pname pp = make_tmp('M',t,tbl);
        !          15656:                                Pname(pp)->n_assigned_to = 1;
        !          15657:                                ee = new expr(ASSIGN,pp,ee);
        !          15658:                                ee->tp = t;
        !          15659:                                p = rptr(t,pp,oo);
        !          15660:                        }
        !          15661:                        else
        !          15662:                                p = rptr(ee->base==MDOT?ee->mem->tp:ee->tp,ee,oo);
        !          15663:                        nin = 0;
        !          15664:                        Pexpr pp = new expr(QUEST,p,zero);
        !          15665:                        pp->tp = ee->tp;
        !          15666:                        pp->cond = ee;
        !          15667:                         ee = pp;
        !          15668:                }
        !          15669:        }
        !          15670: 
        !          15671:        Nvis = 0; // Nvis set by has_base()
        !          15672:        if (ocl->has_base(ccl) && Nvis) {
        !          15673:                if (real_cast==0)
        !          15674:                        error("cast:%n* ->B%t*; privateBC",on,ccl);
        !          15675:                else if (warning_opt)
        !          15676:                        error('w',"cast:%n* ->B%t*; privateBC",on,ccl);
        !          15677:                Nvis = 0;
        !          15678:        }
        !          15679: 
        !          15680: // error('d',"return %d %k %t",ee,ee->base,ee->tp);
        !          15681:        return ee;
        !          15682: }
        !          15683: 
        !          15684: Pexpr expr::donew(Ptable tbl)
        !          15685: {
        !          15686:        Ptype tt = tp2;
        !          15687:        Ptype tpx = tt;
        !          15688:        bit v = 0;
        !          15689:        bit old = new_type;
        !          15690:        int init = 0;   // non-constructor initialization
        !          15691:        new_type = 1;
        !          15692: 
        !          15693:        tt->dcl(tbl);
        !          15694:        new_type = old;
        !          15695: // error('d',"donew %d %d (%k) tt %t",e1,e2,e2?e2->base:0,tt);
        !          15696:        if (e1) e1 = e1->typ(tbl);
        !          15697:        if (e2) e2 = e2->typ(tbl);
        !          15698: ll:
        !          15699: //error('d',"ll %d",tt->base);
        !          15700:        switch (tt->base) {
        !          15701:        default:
        !          15702:                if ( e1) {
        !          15703:                        if (v) {
        !          15704:                                error("Ir for array created using \"new\"");
        !          15705:                                break;
        !          15706:                        }
        !          15707:                        init = 1;
        !          15708:                } 
        !          15709:        //      if (e1) {
        !          15710:        //              error("Ir for nonCO created using \"new\"");
        !          15711:        //              e1 = 0;
        !          15712:        //      }
        !          15713:                break;
        !          15714:        case VEC:
        !          15715:                if (v && Pvec(tt)->dim) error("only 1st array dimension can be non-constant");
        !          15716:                if (Pvec(tt)->size==0 && Pvec(tt)->dim==0) error("array dimension missing in `new'");
        !          15717:        //      if (Pvec(tt)->dim==zero) {
        !          15718:        //              Pvec(tt)->size = 0;
        !          15719:        //              Pvec(tt)->dim = 0;
        !          15720:        //      }
        !          15721:                v++;
        !          15722:                tt = Pvec(tt)->typ;
        !          15723:                goto ll;
        !          15724:        case TYPE:
        !          15725:                tt = Pbase(tt)->b_name->tp;
        !          15726:                goto ll;
        !          15727:        case VOID:
        !          15728:                error("badT for `new': void");
        !          15729:                break;
        !          15730:        case COBJ:
        !          15731:        {       Pname cn = Pbase(tt)->b_name;
        !          15732:                Pclass cl = Pclass(cn->tp);
        !          15733:                Pname icn = 0;
        !          15734: 
        !          15735:                if ( e1 ) { // arguments
        !          15736:                        if ( e1->e2 == 0 && e1->base == ELIST ) {
        !          15737:                                e1 = e1->e1;
        !          15738:                                e1 = e1->typ(tbl);
        !          15739:                        }
        !          15740:                        icn = (e1->base!=ELIST)?e1->tp->is_cl_obj():0;
        !          15741:                }
        !          15742:                //Pname icn = (e1 && e1->base!=ELIST)?e1->tp->is_cl_obj() : 0;
        !          15743: 
        !          15744:                Pclass icl = icn ? Pclass(icn->tp) : 0;
        !          15745: 
        !          15746:                if (cl->c_abstract) {
        !          15747:                        error("`new' of abstractC%t",cl);
        !          15748:                        break;
        !          15749:                }
        !          15750: 
        !          15751:                if (v && e1) {
        !          15752:                        error("Ir for array ofCO created using \"new\"");
        !          15753:                        break;
        !          15754:                }
        !          15755: 
        !          15756:                if ((cl->defined&(DEFINED|SIMPLIFIED)) == 0) {
        !          15757:                        error("new%n;%n isU",cn,cn);
        !          15758:                        break;
        !          15759:                }
        !          15760: 
        !          15761:                Pname ctor = cl->has_ctor();
        !          15762: 
        !          15763:                if (ctor) {
        !          15764:                        if (v) {
        !          15765:                                Pname ic;
        !          15766:                                if ((ic = cl->has_ictor())==0) {
        !          15767:                                        error("array ofC%n that does not have aK taking noAs",cn);
        !          15768:                                        break;
        !          15769:                                }
        !          15770:                                        
        !          15771:                                if (Pfct(ic->tp)->nargs) {
        !          15772:                                        error("defaultAs forK for array ofC%n",cn);
        !          15773:                                        break;
        !          15774:                                }
        !          15775:                        }
        !          15776: 
        !          15777:                        if (icl
        !          15778:                        && cl->has_itor()==0    // incomplete:
        !          15779:                                                // what if X(Y&) exists
        !          15780:                                                // for class Y : X ?
        !          15781:                        && (icl==cl || icl->has_base(cl))) {
        !          15782:                                init = 1;
        !          15783:                                break;
        !          15784:                        }
        !          15785:                        e1 = call_ctor(tbl,0,ctor,e1);
        !          15786:                }
        !          15787:                else if (e1) {
        !          15788:                        if (icl==cl || icl->has_base(cl)) 
        !          15789:                                init = 1;
        !          15790:                        else
        !          15791:                                error("new%n(As ); %n does not have aK",cn,cn);
        !          15792:                }
        !          15793:        }
        !          15794:        }
        !          15795: 
        !          15796:        if (init) {
        !          15797:                Pname tmp = make_tmp('N',tt->addrof(),tbl);
        !          15798:                e1 = e1->typ(tbl);
        !          15799:                if (tt->check(e1->tp,ASSIGN))
        !          15800:                        error("badIrT %t for new operator (%t X)",e1->tp,tt);
        !          15801:                e1 = new expr(0,tmp,e1);
        !          15802:                tmp->assign();
        !          15803:        }
        !          15804: 
        !          15805: //     tp = (v) ? tpx : tpx->addrof();
        !          15806:        switch (v) {
        !          15807:                case 0:
        !          15808:                        tp = tpx->addrof();
        !          15809:                        break;
        !          15810:                case 1:
        !          15811:                        tp = tpx;
        !          15812:                        break;
        !          15813:                default:
        !          15814:                        tp = tpx;
        !          15815:        }
        !          15816: //error('d',"donew(%d) -> %t",v,tp);
        !          15817:        return this;
        !          15818: }
        !          15819: 
        !          15820: static is_dataMemPtr( Pexpr ee ) 
        !          15821: /* this is utterly implementation dependent 
        !          15822:  * called by expr::lval to determine 
        !          15823:  * const objects bounds to pointers to data members 
        !          15824:  */
        !          15825: {
        !          15826:        Pexpr te = ee->e1;
        !          15827:        if ( te == 0 ) return 0;
        !          15828:        if ( te->base != PLUS ) return 0;
        !          15829:        if ( (te = te->e2) == 0 ) return 0;
        !          15830:        if ( te->base != MINUS ) return 0;
        !          15831:        if ( (te = te->e1) == 0 ) return 0;
        !          15832:        if ( te->base != CAST ) return 0;
        !          15833:        if ( (te = te->e1) == 0 ) return 0;
        !          15834:        if ( te->tp->base != PTR ) return 0;
        !          15835:         if ( Pptr(te->tp)->memof == 0 ) return 0;
        !          15836:        return 1;
        !          15837: }
        !          15838: 0707071010112044301004440001630000160000010200700466055402100001000000162346expr3.c/*ident    "@(#)ctrans:src/expr3.c 1.6" */
        !          15839: /***************************************************************************
        !          15840: 
        !          15841:        C++ source for cfront, the C++ compiler front-end
        !          15842:        written in the computer science research center of Bell Labs
        !          15843: 
        !          15844:        Copyright (c) 1984 AT&T, Inc. All Rights Reserved
        !          15845:        THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T, INC.
        !          15846: 
        !          15847: expr3.c:
        !          15848: 
        !          15849:        type check function calls, casts, and explicit coercions
        !          15850: 
        !          15851: ************************************************************************/
        !          15852: 
        !          15853: #include "cfront.h"
        !          15854: #include "size.h"
        !          15855: 
        !          15856: int pr_dominate(Ptype t1, Ptype t2)
        !          15857: /*
        !          15858: */
        !          15859: {
        !          15860:        Pname cn1 = t1->is_cl_obj();
        !          15861:        Pname cn2 = t2->is_cl_obj();
        !          15862: //error('d',"pr_dominate(%t,%t)",t1,t2);
        !          15863: 
        !          15864:        if (cn1==0 || cn2==0) {
        !          15865:                Ptype p1 = t1->is_ptr();
        !          15866:                Ptype p2 = t2->is_ptr();
        !          15867:                if (p1 && p2) {                 // pointers
        !          15868:                        cn1 = Pptr(p1)->typ->is_cl_obj();
        !          15869:                        cn2 = Pptr(p2)->typ->is_cl_obj();
        !          15870:                        if (cn1==0 || cn2==0) return 0;
        !          15871:                }
        !          15872:                else {
        !          15873:                        p1 = t1->is_ref();
        !          15874:                        p2 = t2->is_ref();
        !          15875:                        if (p1 && p2) {         // references
        !          15876:                                cn1 = Pptr(p1)->typ->is_cl_obj();
        !          15877:                                cn2 = Pptr(p2)->typ->is_cl_obj();
        !          15878:                                if (cn1==0 || cn2==0) return 0;
        !          15879:                        }
        !          15880:                //      else if (p1 && cn2) {
        !          15881:                //              cn1 = Pptr(p1)->typ->is_cl_obj();
        !          15882:                //      }
        !          15883:                        else
        !          15884:                                return 0;       // not the same and not classes
        !          15885:                }
        !          15886:        }
        !          15887:        Pclass c1 = Pclass(cn1->tp);
        !          15888:        Pclass c2 = Pclass(cn2->tp);
        !          15889: //error('d'," c1 : c2 %d; c2 : c1 %d",c1->has_base(c2),c2->has_base(c1));
        !          15890:        if (c1->has_base(c2)) return 1;
        !          15891:        if (c2->has_base(c1)) return 2;
        !          15892:        return 0;
        !          15893: }
        !          15894: 
        !          15895: int exact1(Pname,Ptype);
        !          15896: static exact2(Pname,Ptype);
        !          15897: static exact3(Pname,Ptype);
        !          15898: 
        !          15899: static Pname user_dominate(Pname n1, Pname n2, Pexpr arg)
        !          15900: {
        !          15901:        Pfct f1 = Pfct(n1->tp);
        !          15902:        Pfct f2 = Pfct(n2->tp);
        !          15903: 
        !          15904:        Pname a1 = f1->argtype;
        !          15905:        Pname a2 = f2->argtype;
        !          15906: //error('d',"user_dominate: %n %t %t",n1,f1,f2);
        !          15907: 
        !          15908:        for(; a1 && a2; a1 = a1->n_list, a2 = a2->n_list) {
        !          15909:                Ptype t1 = a1->tp;
        !          15910:                Ptype t2 = a2->tp;
        !          15911:        }
        !          15912: 
        !          15913:        if (a1 && !a1->n_evaluated) return n1;
        !          15914:        if (a2 && !a2->n_evaluated) return n2;
        !          15915: 
        !          15916:        a1 = f1->argtype;
        !          15917:        a2 = f2->argtype;
        !          15918: 
        !          15919:        Pname prev = 0;
        !          15920:        Pexpr e = arg;
        !          15921: 
        !          15922:        for(; a1 && a2 && e; a1 = a1->n_list, a2 = a2->n_list, e = e->e2) {
        !          15923:                Ptype t1 = a1->tp;
        !          15924:                Ptype t2 = a2->tp;
        !          15925:                Ptype at = e->e1->tp;
        !          15926: 
        !          15927:                int j = can_coerce(t1,at);
        !          15928:                Ptype tt1 = Ncoerce ? Pfct(Ncoerce->tp)->returns : 0;
        !          15929:                j = can_coerce(t2,at);
        !          15930:                Ptype tt2 = Ncoerce ? Pfct(Ncoerce->tp)->returns : 0;
        !          15931:                if(!tt1 || !tt2 || tt1->check(tt2,OVERLOAD)) 
        !          15932:                        return 0;
        !          15933: 
        !          15934:                int one = 0, two = 0;
        !          15935:                if(exact1(a1,tt1)) one = 4;
        !          15936:                else if(exact2(a1,tt1)) one = 3;
        !          15937:                else if(exact3(a1,tt1)) one = 2;
        !          15938:                else one = 1;
        !          15939:                if(exact1(a2,tt1)) two = 4;
        !          15940:                else if(exact2(a2,tt1)) two = 3;
        !          15941:                else if(exact3(a2,tt1)) two = 2;
        !          15942:                else two = 1;
        !          15943: 
        !          15944:                if(one > two && (!prev || prev==n1)) prev = n1;
        !          15945:                else if(two > one && (!prev || prev==n2)) prev = n2;
        !          15946:                else if(one == two && one) ;
        !          15947:                else return 0;
        !          15948:        }
        !          15949:        if(prev) return prev;
        !          15950:        
        !          15951:        return 0;
        !          15952: }
        !          15953: 
        !          15954: Pname dominate(Pname n1, Pname n2, Pexpr arg, int const_obj, int level)
        !          15955: /*
        !          15956:        the two functions n1 and n2 can each respond to a call using
        !          15957:        standard conversions. Does the one dominate the other in the
        !          15958:        sense that all its arguments are identical to the other or
        !          15959:        classes defived from the class of the corresponding argument
        !          15960:        of the other.
        !          15961: 
        !          15962:        If so return it, otherwise return 0;
        !          15963: */
        !          15964: {
        !          15965:        Pname res = 0;
        !          15966: 
        !          15967:        Pfct f1 = Pfct(n1->tp);
        !          15968:        Pfct f2 = Pfct(n2->tp);
        !          15969: 
        !          15970:        Pname a1 = f1->argtype;
        !          15971:        Pname a2 = f2->argtype;
        !          15972:        Pexpr e = arg;
        !          15973: //error('d',"dominate: %n %t %t e %d",n1,f1,f2,e);
        !          15974: 
        !          15975:        if (e == 0) {
        !          15976:                if (const_obj) {
        !          15977:                        if (f1->f_const && f2->f_const==0) return n1;
        !          15978:                        if (f2->f_const && f1->f_const==0) return n2;
        !          15979:                }
        !          15980:                else {
        !          15981:                        if (f1->f_const==0 && f2->f_const) return n1;
        !          15982:                        if (f2->f_const==0 && f1->f_const) return n2;
        !          15983:                }
        !          15984:                return 0;
        !          15985:        }
        !          15986: 
        !          15987:        for(; a1 && a2 && e; a1 = a1->n_list, a2 = a2->n_list, e = e->e2) {
        !          15988:                Ptype t1 = a1->tp;
        !          15989:                Ptype t2 = a2->tp;
        !          15990:                Ptype at = e->e1->tp;
        !          15991: //error('d',"t1 %t t2 %t at %t",t1,t2,at);
        !          15992:                if (t1==t2 || t1->check(t2,0)==0 )
        !          15993:                        continue;
        !          15994:                Pptr r1 = t1->is_ref();
        !          15995:                Pptr r2 = t2->is_ref();
        !          15996: //error('d',"const_problem %t %t %t %d",t1,t2,at,const_problem);
        !          15997:                if (const_problem) {    // t1 and t1 differs only in const
        !          15998:                        Pname rr;
        !          15999:                        if (at->check(t1,0)==0 && const_problem==0) {
        !          16000:                                if (t1->is_ptr())
        !          16001:                                        rr = n1;
        !          16002:                                else
        !          16003:                                        goto nc;
        !          16004:                        }
        !          16005:                        else if (at->check(t2,0)==0 && const_problem==0) {
        !          16006:                                if (t2->is_ptr())
        !          16007:                                        rr = n2;
        !          16008:                                else
        !          16009:                                        goto nc;
        !          16010:                        }
        !          16011:                        else if (r1 && r1->typ->check(at,0)==0 && const_problem==0)
        !          16012:                                rr = n1;
        !          16013:                        else if (r2 && r2->typ->check(at,0)==0 && const_problem==0)
        !          16014:                                rr = n2;
        !          16015:                        else
        !          16016:                                goto nc;
        !          16017:                
        !          16018:                        if (res && res!=rr) return 0;   // mutual dominace
        !          16019:                        res = rr;
        !          16020:                        continue;       // identical
        !          16021:                }
        !          16022:        nc:
        !          16023:                if (r2 && (t1==r2 || t1->check(r2->typ,0)==0)) continue;
        !          16024:                if (r1 && (t2==r1 || t2->check(r1->typ,0)==0)) continue;
        !          16025: 
        !          16026:                Pname rr = 0;
        !          16027:                if (t1==at || exact1(a1,at))
        !          16028:                        rr = n1;
        !          16029:                else if (t2==at || exact1(a2,at))
        !          16030:                        rr = n2;
        !          16031:                else if (1<level) {     // try integral promotion
        !          16032:                        if (exact2(a1,at))
        !          16033:                                rr = n1;
        !          16034:                        if (exact2(a2,at)) {
        !          16035:                                if (rr) rr = 0;
        !          16036:                                else rr = n2;
        !          16037:                        }
        !          16038:                }
        !          16039:                if (!rr && 2<level) {   // try standard conversions
        !          16040:                        if (exact3(a1,at))
        !          16041:                                rr = n1;
        !          16042:                        if (exact3(a2,at)) {
        !          16043:                                if (rr) rr = 0;
        !          16044:                                else rr = n2;
        !          16045:                        }
        !          16046:                }
        !          16047:                if (rr) {
        !          16048:                        if  (res && res!=rr) return 0;  // mutual dominance
        !          16049:                        res = rr;
        !          16050:                        continue;
        !          16051:                }
        !          16052: 
        !          16053:                int r = pr_dominate(t1,t2);
        !          16054: //error('d',"pr1 %d",r);
        !          16055:                if (r) {
        !          16056:                        Pname rr = r==1?n1:n2;
        !          16057:                        if (res && res!=rr) return 0;   // mutual dominace
        !          16058:                        res = rr;
        !          16059:                        continue;
        !          16060:                }
        !          16061: 
        !          16062:                r = pr_dominate(t1,at);
        !          16063: //error('d',"pr2 %d",r);
        !          16064:                if (r==2) {
        !          16065:                        if (res && res!=n1) return 0;   // mutual dominace
        !          16066:                        res = n1;
        !          16067:                        r = pr_dominate(t2,at);
        !          16068:                        if (r==2) return 0;     // mutual dominace
        !          16069:                        continue;
        !          16070:                }
        !          16071: 
        !          16072:                r = pr_dominate(t2,at);
        !          16073: //error('d',"pr3 %d",r);
        !          16074:                if (r==2) {
        !          16075:                        if (res && res!=n2) return 0;   // mutual dominace
        !          16076:                        res = n2;
        !          16077:                        continue;
        !          16078:                }
        !          16079: 
        !          16080:        }
        !          16081:        //if (a1==0 && a2 && a2->n_initializer==0) return 0;    // wrong number of arguments
        !          16082:        //if (a2==0 && a1 && a1->n_initializer==0) return 0;    // wrong number of arguments
        !          16083: 
        !          16084:        if (e) {
        !          16085: //error('d',"more args %t a1 %t a2 %t",e->e1->tp,a1?a1->tp:0,a2?a2->tp:0);
        !          16086:                int k1 = f1->nargs_known!=ELLIPSIS;
        !          16087:                int k2 = f2->nargs_known!=ELLIPSIS;
        !          16088:                if (a1 && a1->tp->check(e->e1->tp,ASSIGN)==0) return n1;
        !          16089:                if (a2 && a2->tp->check(e->e1->tp,ASSIGN)==0) return n2;
        !          16090:                if (k1 && k2) return 0;
        !          16091:        }
        !          16092: 
        !          16093:        if (a1==0 && a2 && a2->n_initializer==0) return 0;
        !          16094:        if (a2==0 && a1 && a1->n_initializer==0) return 0;
        !          16095:        if (res==0)
        !          16096:                if (const_obj) {
        !          16097:                        if (f1->f_const && f2->f_const==0) return n1;
        !          16098:                        if (f2->f_const && f1->f_const==0) return n2;
        !          16099:                }
        !          16100:                else {
        !          16101:                        if (f1->f_const==0 && f2->f_const) return n1;
        !          16102:                        if (f2->f_const==0 && f1->f_const) return n2;
        !          16103:                }
        !          16104: //error('d'," -> %n %t",res,res?res->tp:0);
        !          16105:        return res;
        !          16106: }
        !          16107: 
        !          16108: Pname Ntmp;
        !          16109: 
        !          16110: static refd;   // initialization routine called by ref_init, do not apply itor
        !          16111: static no_sti;
        !          16112: extern int stat_init;
        !          16113: 
        !          16114: Pname make_tmp(char c, Ptype t, Ptable tbl)
        !          16115: {
        !          16116:        int dt = 0; 
        !          16117:        Pname tn = tbl->t_name;
        !          16118:        Pname cn = t->is_cl_obj();
        !          16119: 
        !          16120:        if (tn && tn->tp) error('s',"defaultA too complicated");
        !          16121:        if (cn && Pclass(cn->tp)->has_dtor()) dt = 1;
        !          16122:        if (Ntmp == 0 && dt ) Ntmp = cn;
        !          16123: 
        !          16124: //error('d',"tbl %d cstmt %d %d sti %d",tbl,Cstmt,Cstmt?Cstmt->memtbl:0,sti_tbl);
        !          16125:        if (Cstmt) {    //      make Cstmt into a block
        !          16126:                if (Cstmt->memtbl == 0) Cstmt->memtbl = new table(4,tbl,0);
        !          16127:                tbl = Cstmt->memtbl;
        !          16128:        }
        !          16129:        else if (tbl == gtbl && no_sti == 0) {
        !          16130:                if (sti_tbl == 0) sti_tbl = new table(8,gtbl,0);
        !          16131:                tbl = sti_tbl;
        !          16132:        }
        !          16133: 
        !          16134:        Pname tmpx = new name(make_name(c));
        !          16135:        tmpx->where = no_where;
        !          16136:        tmpx->tp = t;
        !          16137:        (void) t->tsizeof();
        !          16138:        if ( t->base == COBJ ) {
        !          16139:                Pclass cl = Pclass(Pbase(t)->b_name->tp);
        !          16140:                if ( cl->lex_level ) tmpx->lex_level = cl->lex_level;
        !          16141:        }
        !          16142: 
        !          16143:        TOK scop = ARG;
        !          16144:        if (stat_init && dt) { 
        !          16145:                tmpx->n_sto = STATIC; scop = ARGS; 
        !          16146:        }
        !          16147: 
        !          16148:        // ARG[S]: no init; ARGS: static dtor
        !          16149:        Pname tmp = tmpx->dcl(tbl,scop); 
        !          16150:        delete tmpx;
        !          16151: 
        !          16152:        // n_scope == ARGS sets static dtor in simpl2.c
        !          16153:        tmp->n_scope = (scop==ARG) ? FCT : ARGS;
        !          16154:        return tmp;
        !          16155: }
        !          16156: 
        !          16157: Pexpr init_tmp(Pname tmp, Pexpr init, Ptable tbl)
        !          16158: {
        !          16159:        Pname cn = tmp->tp->is_cl_obj();
        !          16160:        Pname ct = cn ? Pclass(cn->tp)->has_itor() : 0;
        !          16161: 
        !          16162:        tmp->n_assigned_to = 1;
        !          16163: //error('d',"init_tmp %n ct %n refd %d",tmp,ct,refd);
        !          16164:        if (ct) {       // must initialize
        !          16165:                if (refd) {
        !          16166: //error('d',"'orrible %k",init->e1->base);
        !          16167:                        switch (init->e1->base) {       // 'orrible 'ack
        !          16168:                        case NAME:
        !          16169:                        case REF:
        !          16170:                        case DEREF:
        !          16171:                                if (init->e1->tp->is_ptr())
        !          16172:                                        init = init->e1;
        !          16173:                                else
        !          16174:                                        init = new expr(G_CM,init,init->e1->address());
        !          16175:                                        
        !          16176:                        }
        !          16177:                        if (ct->tp->base == OVERLOAD) ct = Pgen(ct->tp)->fct_list->f;   // first fct
        !          16178:                        tbl = 0;
        !          16179:                }
        !          16180:                return call_ctor(tbl,tmp,ct,init,DOT);
        !          16181:        }
        !          16182:        Pexpr ass = new expr(ASSIGN,tmp,init); // no ctor: can assign
        !          16183:        ass->tp = tmp->tp;
        !          16184:        return ass;
        !          16185: }
        !          16186: /*
        !          16187: int exact0(Pname nn, Ptype at)
        !          16188: //     return 1 if
        !          16189: //     exact match
        !          16190: 
        !          16191: {
        !          16192:        if (nn == 0) return 0; //known==ELLIPSIS;
        !          16193:        Ptype nt = nn->tp;
        !          16194:        if (at == nt) return 1;
        !          16195: //error('d',"exact0 %d",nt->check(at,0));
        !          16196:        return nt->check(at,0)==0;
        !          16197: }
        !          16198: */
        !          16199: 
        !          16200: int exact3(Pname nn, Ptype at)
        !          16201: /*
        !          16202:        return 1 if
        !          16203:        match with standard conversions
        !          16204: */
        !          16205: {
        !          16206:        if (nn == 0) return 0; //known==ELLIPSIS;
        !          16207:        Ptype nt = nn->tp;
        !          16208: 
        !          16209:        while(nt->base == TYPE)
        !          16210:                nt = Pbase(nt)->b_name->tp;
        !          16211: 
        !          16212:        if (at == nt) return 1;
        !          16213: 
        !          16214:        switch (nt->base) {
        !          16215:        case RPTR:
        !          16216:                if (at==zero_type && Pptr(nt)->typ->is_ptr()==0) return 0; //break;
        !          16217:                if (nt->check(at,COERCE)) {
        !          16218:                        Pptr pt = at->addrof();
        !          16219:                        nt->base = PTR;         // handle derived classes
        !          16220:                        if (nt->check(pt,COERCE)) {
        !          16221:                                nt->base = RPTR;
        !          16222:                                delete pt;
        !          16223:                                return 0;
        !          16224:                        }
        !          16225:                        nt->base = RPTR;
        !          16226:                        delete pt;
        !          16227:                }
        !          16228:                break;
        !          16229:        default:
        !          16230:                switch (at->base) {
        !          16231:                default: 
        !          16232:                        if (nt->check(at,COERCE)) return 0;
        !          16233:                        break;
        !          16234:                case OVERLOAD:
        !          16235:                        // the actual argument is an overloaded function
        !          16236:                        // we'll try each instance until one matches
        !          16237:                        register Plist gl;
        !          16238:                        int no_match = 1;
        !          16239: 
        !          16240:                        for (gl = Pgen(at)->fct_list; gl; gl=gl->l) {
        !          16241:                                if (nt->check(gl->f->tp,COERCE)==0) {
        !          16242:                                        no_match = 0;
        !          16243:                                        break;
        !          16244:                                }
        !          16245:                        }
        !          16246: 
        !          16247:                        if ( no_match ) return 0;
        !          16248:                } 
        !          16249:        }
        !          16250:        return 1;
        !          16251: }
        !          16252: 
        !          16253: int exact1(Pname nn, Ptype at)
        !          16254: /*
        !          16255:        return 1 if
        !          16256:        exact match with
        !          16257:                T <-> const T
        !          16258:                X -> X&
        !          16259:                T* -> const T*
        !          16260:                T* -> T*const
        !          16261:        taken into account
        !          16262: */
        !          16263: {
        !          16264:        if (nn == 0) return 0;//known==ELLIPSIS;
        !          16265:        Ptype nt = nn->tp;
        !          16266:        if (at == nt) return 1;
        !          16267: 
        !          16268: //error('d',"exact1 nt %t at %t",nt,at);
        !          16269:        if (nt->check(at,0)) {
        !          16270: //error('d',"nt %t at %t cp %d",nt,at,const_problem);
        !          16271:                if (const_problem)  return 1;   // handle T <-> const T
        !          16272: 
        !          16273:                Pptr rt = nt->is_ref(); //handle X -> X&
        !          16274:                if (rt && (at->check(Pptr(rt)->typ,0)==0 || const_problem))  return 1;
        !          16275: 
        !          16276:                Pptr art = at->is_ptr();
        !          16277:                if (rt && art) return 0; // ptrs do not match refs
        !          16278: 
        !          16279:                // handle T* -> const T* and
        !          16280:                // T* -> T*const
        !          16281:                if (rt || (rt = nt->is_ptr())) {
        !          16282:                        if (art == 0) art = at->is_ref();
        !          16283:                        if (art) {
        !          16284: //error('d',"art %t %t",art->typ,rt->typ);
        !          16285:                                if (art->typ->check(rt->typ,0)) {
        !          16286:                                        if (const_problem)  return 1;
        !          16287:                                }
        !          16288:                                else    // T* -> T*const
        !          16289:                                         return 1;
        !          16290:                        }
        !          16291:                }
        !          16292:                return 0;
        !          16293:        }
        !          16294:        return 1;
        !          16295: }
        !          16296: 
        !          16297: Pexpr Ninit;   // default argument used;
        !          16298: int Nstd;      // standard coercion used (derived* =>base* or int=>long or ...)
        !          16299: 
        !          16300: bit exact_match(Pname n, Pexpr arg)
        !          16301: /*
        !          16302:        look for an exact match between "n" and the argument list "arg"
        !          16303:        This function goes through three stages:
        !          16304:        (1) exact match (no coercions at all)
        !          16305:        (2) do integral promotions and float->double and re-try exact match
        !          16306:        (3) try for unique standard conversions
        !          16307: 
        !          16308: */
        !          16309: {
        !          16310:        Pfct f = Pfct(n->tp);
        !          16311:        register Pexpr e;
        !          16312:        register Pname nn;
        !          16313: 
        !          16314: // error('d',"exact_match(%n) %t",n,n->tp);
        !          16315: 
        !          16316:        for (e=arg, nn=f->argtype; e; e=e->e2, nn=nn->n_list) {
        !          16317:                Pexpr a = e->e1;
        !          16318:                Ptype at = a->tp;
        !          16319:                if (at->base == ANY) return 0;
        !          16320:                if (at->base == ZTYPE) at = int_type;
        !          16321:                if (exact1(nn,at)==0) return 0;
        !          16322:        }
        !          16323: 
        !          16324: //error('d',"exact %d -> %d",nn,nn?nn->n_initializer!=0:1);
        !          16325:        if (nn) {
        !          16326:                Ninit = nn->n_initializer;
        !          16327:                return Ninit!=0;
        !          16328:        }
        !          16329: 
        !          16330: //error('d',"return 1");
        !          16331:        return 1;       // exact match without any promotions
        !          16332: }
        !          16333: 
        !          16334: int exact2(Pname nn, Ptype at)
        !          16335: /*
        !          16336:        return 1 if
        !          16337:        do integral promotion and float->double on at, then match
        !          16338: */
        !          16339: {
        !          16340: //error('d',"exact2 nt %t at %t",nn?nn->tp:0,at);
        !          16341:        while(at->base == TYPE)
        !          16342:                at = Pbase(at)->b_name->tp;
        !          16343: 
        !          16344:        switch (at->base) {
        !          16345:        case EOBJ:
        !          16346:                at = Penum(Pbase(at)->b_name->tp)->e_type;
        !          16347:                break;
        !          16348:        case ZTYPE:
        !          16349:                at = int_type;
        !          16350:                break;
        !          16351:        case CHAR:
        !          16352:        case SHORT:
        !          16353:                at = (Pbase(at)->b_unsigned && at->tsizeof()==SZ_INT) ? uint_type : int_type;
        !          16354:                break;
        !          16355:        case FLOAT:
        !          16356:                at = double_type;
        !          16357:        }
        !          16358: 
        !          16359:        if (nn == 0) return 0;//known==ELLIPSIS;
        !          16360:        Ptype nt = nn->tp;
        !          16361: //error('d',"  exact2 nt %t at %t",nt,at);
        !          16362:        if (at == nt) return 1;
        !          16363:        if (nt->check(at,0)) {
        !          16364:                if (const_problem) return 1;
        !          16365: 
        !          16366:                Pptr rt = nt->is_ref(); // handle X -> X&
        !          16367:                if (rt && (at->check(Pptr(rt)->typ,0)==0 || const_problem)) return 1;
        !          16368: 
        !          16369:                Pptr art = at->is_ptr();
        !          16370:                if (rt && art) return 0; // ptrs do not match refs
        !          16371: 
        !          16372:                // handle T* -> const T* and
        !          16373:                // T* -> T*const
        !          16374:                if (rt || (rt = nt->is_ptr())) {
        !          16375:                        if (art == 0) art = at->is_ref();
        !          16376:                        if (art) {
        !          16377:                                if (art->typ->check(rt->typ,0)) {
        !          16378:                                        if (const_problem) return 1;
        !          16379:                                }
        !          16380:                                else    // T* -> T*const
        !          16381:                                        return 1;
        !          16382:                        }
        !          16383:                }
        !          16384:                return 0;
        !          16385:        }
        !          16386:        return 1;
        !          16387: }
        !          16388: 
        !          16389: bit prom_match(Pname n, Pexpr arg)
        !          16390: /*
        !          16391:        look for an exact match between "n" and the argument list "arg"
        !          16392:        using integral promotions and float->double
        !          16393: 
        !          16394: */
        !          16395: {
        !          16396:        Pfct f = Pfct(n->tp);
        !          16397:        register Pexpr e;
        !          16398:        register Pname nn;
        !          16399: 
        !          16400: // error('d',"prom_match(%n) %t",n,n->tp);
        !          16401: 
        !          16402:        for (e=arg, nn=f->argtype; e; e=e->e2, nn=nn->n_list) {
        !          16403:                Pexpr a = e->e1;
        !          16404:                Ptype at = a->tp;
        !          16405:                if (at->base == ANY) return 0;
        !          16406: 
        !          16407:                if (exact2(nn,at)==0) return 0;
        !          16408:        }
        !          16409:        
        !          16410:        if (nn) {
        !          16411:                Ninit = nn->n_initializer;
        !          16412:                return Ninit!=0;
        !          16413:        }
        !          16414: 
        !          16415:        return 1;       // exact match with promotions
        !          16416: }
        !          16417: 
        !          16418: bit std_match(Pname n, Pexpr arg)
        !          16419: /*
        !          16420:        look for an exact match between "n" and the argument list "arg"
        !          16421:        using standard conversions
        !          16422: 
        !          16423: */
        !          16424: {
        !          16425:        Pfct f = Pfct(n->tp);
        !          16426:        register Pexpr e;
        !          16427:        register Pname nn;
        !          16428: 
        !          16429: // error('d',"std_match(%n) %t",n,n->tp);
        !          16430: 
        !          16431:        for (e=arg, nn=f->argtype; e; e=e->e2, nn=nn->n_list) {
        !          16432:                Pexpr a = e->e1;
        !          16433:                Ptype at = a->tp;
        !          16434: 
        !          16435:                if (at->base == ANY) return 0;
        !          16436:                if ( exact3(nn,at) == 0) return 0;
        !          16437:        }
        !          16438: 
        !          16439:        if (nn) {
        !          16440:                Ninit = nn->n_initializer;
        !          16441:                return Ninit!=0;
        !          16442:        }
        !          16443: 
        !          16444:        return 1;
        !          16445: }
        !          16446: 
        !          16447: Pname Ncoerce;
        !          16448: int ref_cast;
        !          16449: 
        !          16450: bit can_coerce(Ptype t1, Ptype t2)
        !          16451: /*     return number of possible coercions of t2 into t1,
        !          16452:        Ncoerce holds a coercion function (not constructor), if found
        !          16453: */
        !          16454: {
        !          16455:        int zz = 0;
        !          16456:        Ncoerce = 0;
        !          16457:        if (t2->base == ANY) return 0;
        !          16458: // error('d',"can_coerce t1 %t t2 %t",t1, t2);
        !          16459: 
        !          16460:        while(t1->base == TYPE)
        !          16461:                t1 = Pbase(t1)->b_name->tp;
        !          16462: 
        !          16463:        switch (t1->base) {
        !          16464:        case RPTR:
        !          16465:                while(t2->base == TYPE)
        !          16466:                        t2 = Pbase(t2)->b_name->tp;
        !          16467: 
        !          16468:                switch (t2->base) {
        !          16469:        //      case VEC:
        !          16470:        //      case PTR:
        !          16471:        //      case RPTR:
        !          16472:        //              if (t1->check(t2,COERCE) == 0) return 1;
        !          16473:                default:        
        !          16474:                {       Ptype tt2 = t2->addrof();
        !          16475:                        if (t1->check(tt2,COERCE) == 0) return 1;
        !          16476:                        if (ref_cast) break;//return 0; // (T&): no coercions
        !          16477:                                                        // except operator T&()
        !          16478:                        Ptype tt1 = Pptr(t1)->typ;
        !          16479:                        while (tt1->base==TYPE) tt1 = Pbase(tt1)->b_name->tp;
        !          16480:                        int bc;
        !          16481:                        if ( tt1->base != PTR && tt1->base != RPTR ) {
        !          16482:                                bc = Pbase(tt1)->b_const;
        !          16483:                                Pbase(tt1)->b_const = 0; 
        !          16484:                        }
        !          16485:                        int i = can_coerce(tt1,t2);
        !          16486:                        if ( tt1->base != PTR && tt1->base != RPTR ) 
        !          16487:                                Pbase(tt1)->b_const = bc;
        !          16488:                        if (i) return i;
        !          16489:                        zz = 1;
        !          16490:                }
        !          16491:                }
        !          16492:        }
        !          16493: 
        !          16494:        Pname c1 = t1->is_cl_obj();
        !          16495:        Pname c2 = t2->is_cl_obj();
        !          16496:        int val = 0;
        !          16497:        if (ref_cast || zz) goto oper_coerce;
        !          16498:        if (c1) {
        !          16499:                Pclass cl = Pclass(c1->tp);
        !          16500:                if (c2 && c2->tp==cl) return 1;
        !          16501: 
        !          16502:                 // A more comprehensive test for template classes
        !          16503:                 if (c2 && (Pclass(c1->tp)->same_class(Pclass(c2->tp))))
        !          16504:                         return 1 ;
        !          16505: 
        !          16506:                /*      look for constructor
        !          16507:                                with one argument
        !          16508:                                or with default for second argument
        !          16509:                        of acceptable type
        !          16510:                */
        !          16511:                Pname ctor = cl->has_ctor();
        !          16512:                if (ctor == 0) goto oper_coerce;
        !          16513:                register Pfct f = Pfct(ctor->tp);
        !          16514: //error('d',"ctor %n f %t",ctor,f);
        !          16515:                switch (f->base) {
        !          16516:                case FCT:
        !          16517:                        switch (f->nargs) {
        !          16518:                        case 1:
        !          16519:                        one:
        !          16520:                        {       Ptype tt = f->argtype->tp;
        !          16521:                                        if (tt->check(t2,COERCE)==0)
        !          16522:                                                val = 1;
        !          16523:                                        else if (const_problem) {
        !          16524:                                                Pptr p1 = tt->is_ptr_or_ref();
        !          16525:                                                if (p1==0 || p1->typ->tconst()) val = 1;
        !          16526:                                        }
        !          16527:                                if (tt = tt->is_ref()) {
        !          16528:                                        Pptr pt = t2->addrof(); // handle derived classed
        !          16529:                                        tt->base = PTR;
        !          16530:                                        if (tt->check(pt,COERCE) == 0) val = 1;
        !          16531:                                        tt->base = RPTR;
        !          16532:                                        delete pt;
        !          16533:                                }
        !          16534:                                goto oper_coerce;
        !          16535:                        }
        !          16536:                        default:
        !          16537:                                if (f->argtype->n_list->n_initializer) goto one;
        !          16538:                        case 0:
        !          16539:                                goto oper_coerce;
        !          16540:                        }
        !          16541:                case OVERLOAD:
        !          16542:                {       register Plist gl;
        !          16543: 
        !          16544:                        for (gl=Pgen(f)->fct_list; gl; gl=gl->l) { // look for match
        !          16545:                                Pname nn = gl->f;
        !          16546:                                Pfct ff = Pfct(nn->tp);
        !          16547: 
        !          16548:                                switch (ff->nargs) {
        !          16549:                                case 0:
        !          16550:                                        break;
        !          16551:                                case 1:
        !          16552:                                over_one:
        !          16553:                                {       Ptype tt = ff->argtype->tp;
        !          16554: //error('d',"over one %t %t -> %d %d",tt,t2,tt->check(t2,COERCE),const_problem);
        !          16555:                                        if (tt->check(t2,COERCE)==0)
        !          16556:                                                val = 1;
        !          16557:                                        else if (const_problem) {
        !          16558:                                                Pptr p1 = tt->is_ptr_or_ref();
        !          16559:                                                if (p1==0 || p1->typ->tconst()) val = 1;
        !          16560:                                        }
        !          16561:                                        if (tt=tt->is_ref()) {
        !          16562:                                                Pptr pt = t2->addrof(); // handle derived classed
        !          16563:                                                tt->base = PTR;
        !          16564:                                                if (tt->check(pt,COERCE) == 0) {
        !          16565:                                                        tt->base = RPTR;
        !          16566:                                                        delete pt;
        !          16567:                                                        val = 1;
        !          16568:                                                        goto oper_coerce;
        !          16569:                                                }
        !          16570:                                                tt->base = RPTR;
        !          16571:                                                delete pt;
        !          16572:                                        }
        !          16573:                                        break;
        !          16574:                                }
        !          16575:                                default:
        !          16576:                                        if (ff->argtype->n_list->n_initializer) goto over_one;
        !          16577:                                }
        !          16578:                        }
        !          16579:                        goto oper_coerce;
        !          16580:                }
        !          16581:                default:
        !          16582:                        error('i',"cannot_coerce(%k)\n",f->base);
        !          16583:                }
        !          16584:        }
        !          16585: 
        !          16586: oper_coerce:
        !          16587: //error('d',"oper_coerce %d",val);
        !          16588:        if (c2) {       
        !          16589:                Pclass cl = Pclass(c2->tp);
        !          16590:                int std = 0;
        !          16591:                int oval = val;
        !          16592:                extern Pname conv_dominates(Pname,Pname);
        !          16593:                for (Pname ox, on=cl->conv; on; on=ox) {
        !          16594:                        ox = on->n_list;
        !          16595: // error( 'd', "can_coerce: ox: %s on: %s tp: %k", ox?ox->string:"", on->string, on->tp->base );
        !          16596:                        Plist gl = 0;
        !          16597:                        if ( on->tp->base == OVERLOAD ) {
        !          16598:                                gl = Pgen(on->tp)->fct_list;
        !          16599:                                on = gl->f;
        !          16600:                                gl = gl->l;
        !          16601:                        }
        !          16602: 
        !          16603: overlist: 
        !          16604: // error( 'd', "can coerce: on: %n tp: %t gl: %d", on, on->tp, gl );
        !          16605: 
        !          16606:                        Pfct f = Pfct(on->tp);
        !          16607:                        Nstd = 0;
        !          16608:                        if (t1->check(f->returns,COERCE) == 0) {
        !          16609:                                if (Nstd==0) {  // forget solutions involving standard conversions
        !          16610:                                        Pname old = Ncoerce;
        !          16611:                                        if (std) {      // forget
        !          16612:                                                val = oval+1;
        !          16613:                                                std = 0;
        !          16614:                                                Ncoerce = on;
        !          16615:                                        }
        !          16616:                                        else if (Ncoerce == 0) {
        !          16617:                                        //      val = 1;
        !          16618:                                                val++;
        !          16619:                                                Ncoerce = on;
        !          16620:                                        }
        !          16621:                                        else if ((Ncoerce = conv_dominates(Ncoerce,on))==0) {
        !          16622:                                                if (val == 1) {
        !          16623: //error('d',"val==1 on %n old %n",on,old);
        !          16624:                                                        Ptype ton = Pfct(on->tp)->returns;
        !          16625:                                                        Ptype tco = Pfct(old->tp)->returns;
        !          16626:                                                        if (t1->check(ton,0)==0)
        !          16627:                                                                ;
        !          16628:                                                        else if (t1->check(tco,0)==0)
        !          16629:                                                                on = old;
        !          16630:                                                        else
        !          16631:                                                                val++;
        !          16632:                                                }
        !          16633:                                                else
        !          16634:                                                        val++;
        !          16635:                                                Ncoerce = on;
        !          16636:                                        }
        !          16637:                                }
        !          16638:                                else {  // take note only if no exact match seen
        !          16639:                                        if (Ncoerce==0 || on->tp->check(Ncoerce->tp,0)) {
        !          16640:                                                if (val==0 || std) {
        !          16641: 
        !          16642:                                                        if (Ncoerce) Ncoerce = conv_dominates(Ncoerce,on);
        !          16643:                                                        if (Ncoerce == 0) {
        !          16644:                                                                Ncoerce = on;
        !          16645:                                                                val++;
        !          16646:                                                                std = 1;
        !          16647:                                                        }       
        !          16648:                                                }
        !          16649:                                        }
        !          16650:                                }
        !          16651:                        }
        !          16652: // error( 'd', "can_coerce: gl: %d", gl );
        !          16653:                        if ( gl ) {
        !          16654:                                on = gl->f;
        !          16655:                                gl = gl->l;
        !          16656:                                goto overlist; // must walk list of overloaded instances
        !          16657:                        }
        !          16658:                }
        !          16659:        }
        !          16660: //error('d',"val %d",val);
        !          16661:        if (val) return val;
        !          16662:        if (c1 && Pclass(c1->tp)->has_itor()) return 0;
        !          16663: //error('d',"%t->check(%t) -> %d",t1,t2,t1->check(t2,COERCE));
        !          16664:        if (t1->check(t2,COERCE)) return 0;
        !          16665:        return 1;
        !          16666: }
        !          16667: 
        !          16668: int gen_coerce(Pname n, Pexpr arg)
        !          16669: /*
        !          16670:        look to see if the argument list "arg" can be coerced into a call of "n"
        !          16671:        1: it can
        !          16672:        0: it cannot or it can be done in more than one way
        !          16673: */
        !          16674: {
        !          16675:        Pfct f = (Pfct) n->tp;
        !          16676:        register Pexpr e;
        !          16677:        register Pname nn;
        !          16678: 
        !          16679: //error('d',"gen_coerce(%n,%d) %t",n,arg,n->tp);
        !          16680:        for (e=arg, nn=f->argtype; e; e=e->e2, nn=nn->n_list) {
        !          16681:                if (nn == 0) return f->nargs_known==ELLIPSIS;
        !          16682:                Pexpr a = e->e1;
        !          16683:                Ptype at = a->tp;
        !          16684:                int i = can_coerce(nn->tp,at);
        !          16685:                if (i != 1) return 0;
        !          16686:        }
        !          16687:        if (nn && nn->n_initializer==0) return 0;
        !          16688:        return 1;
        !          16689: }
        !          16690: 
        !          16691: 
        !          16692: Pname Nover;
        !          16693: // int Nover_coerce;
        !          16694: 
        !          16695: int over_call(Pname n, Pexpr arg)
        !          16696: /*     
        !          16697:        return 4 if n(arg) can be performed without coercion of arg
        !          16698:        return 3 if n(arg) can be performed only with promotion coercion of arg
        !          16699:        return 2 if n(arg) can be performed only with standard coercion of arg
        !          16700:        return 1 if n(arg) can be performed only with user defined coercion of arg
        !          16701:        return 0 if n(arg) is an error
        !          16702:        Nover is the function found, if any
        !          16703:        Nstd is the number of standard coercions used
        !          16704: */
        !          16705: {      
        !          16706:        register Plist gl;
        !          16707:        Pgen g = Pgen(n->tp);
        !          16708:        if (arg && arg->base!= ELIST) error('i',"ALX");
        !          16709: 
        !          16710: //error('d',"over_call(%n) %k",n,n->tp->base);
        !          16711:        extern suppress_error;
        !          16712:        suppress_error = 1;
        !          16713: //     Nover_coerce = 0;
        !          16714:        Nstd = 0;
        !          16715:        switch (g->base) {
        !          16716:        default:        error('i',"over_call(%t)\n",g);
        !          16717:        case OVERLOAD:  break;
        !          16718:        case FCT:
        !          16719:                Nover = n;
        !          16720:                Ninit = 0;
        !          16721:                if (exact_match(n,arg)) {suppress_error = 0; return 4;}
        !          16722:                if (prom_match(n,arg)) {suppress_error = 0; return 3;}
        !          16723:                if (std_match(n,arg) && Ninit==0) {suppress_error = 0; return 2;}
        !          16724:                Nstd = 0;
        !          16725:                suppress_error = 0;
        !          16726:                return gen_coerce(n,arg);
        !          16727:        }
        !          16728: 
        !          16729:        Pname exact = 0;
        !          16730:        int no_exact = 0;
        !          16731:        int ret = 0;
        !          16732:        Pname nret;
        !          16733:        for (gl=g->fct_list; gl; gl=gl->l) {            /* look for match */
        !          16734:                Nover = gl->f;
        !          16735:                Ninit = 0;
        !          16736:                Nstd = 0;
        !          16737:                if (exact_match(Nover,arg)) {suppress_error = 0; return 4;}     // no coercion
        !          16738:        //      if (prom_match(Nover,arg)) return 3;    // only promotion
        !          16739:        //      if (std_match(Nover,arg) && Ninit==0) return 2; // only built-in conversion
        !          16740:                if (ret<3 && prom_match(Nover,arg)) {
        !          16741:                        nret = Nover;
        !          16742:                        ret = 3;
        !          16743:                }
        !          16744:                if (ret<2 && std_match(Nover,arg) && Ninit==0) {
        !          16745:                        nret = Nover;
        !          16746:                        ret = 2;
        !          16747:                }
        !          16748:        }
        !          16749: 
        !          16750: suppress_error = 0;
        !          16751:        if (ret) {
        !          16752:                Nover = nret;
        !          16753:                return ret;
        !          16754:        }
        !          16755: 
        !          16756:        Nover = 0;
        !          16757:        for (gl=g->fct_list; gl; gl=gl->l) {            /* look for coercion */
        !          16758:                Pname nn = gl->f;
        !          16759:                if (gen_coerce(nn,arg)) {
        !          16760:                        Nover = nn;
        !          16761:                        return 1;
        !          16762:                }
        !          16763:        }
        !          16764:        return 0;
        !          16765: 
        !          16766: }
        !          16767: 
        !          16768: Ptype expr::call_fct(Ptable tbl)
        !          16769: /*
        !          16770:        check "this" call:
        !          16771:                 e1(e2)
        !          16772:        e1->typ() and e2->typ() has been done
        !          16773: */
        !          16774: {
        !          16775:        Pfct f;
        !          16776:        Pname fn;
        !          16777:        int x;
        !          16778:        int k;
        !          16779:        Pname nn;
        !          16780:        Pexpr e;
        !          16781:        Ptype t;
        !          16782:        Pexpr arg = e2;
        !          16783:        Ptype t1 = e1?e1->tp:0;
        !          16784:        int argno;
        !          16785:        Pexpr etail = 0;
        !          16786:        bit no_change = 0;
        !          16787:        Pname no_virt = 0;      // set if explicit qualifier was used: c::f()
        !          16788:        Pname chk = 0;          // set if visibility check is needed
        !          16789:                                // that is if function name might have been
        !          16790:                                // found without use of find_name()
        !          16791:        int const_obj = 0;
        !          16792: 
        !          16793:        if (t1 == any_type) return any_type;
        !          16794: 
        !          16795:        switch (base) {
        !          16796:        case CALL:
        !          16797:        case G_CALL:    break;
        !          16798:        default:        error('i',"call_fct(%k)",base);
        !          16799:        }
        !          16800: 
        !          16801: // error('d',"call %d %k %n arg %d",this,e1->base,e1->base==NAME?e1:0,arg);
        !          16802:        if (t1 == 0) error('i',"call_fct(e1=%d,e1->tp=%t)",e1,t1);
        !          16803:        if (arg && arg->base!=ELIST) error('i',"badAL%d%k",arg,arg->base);
        !          16804: 
        !          16805:        switch (e1->base) {
        !          16806:        case NAME:
        !          16807:                fn = Pname(e1);
        !          16808: //error('d',"name %n %k",fn,fn->n_oper);
        !          16809:                switch (fn->n_oper) {
        !          16810:                case 0:
        !          16811:                case CTOR:
        !          16812:                case DTOR:
        !          16813:                case TYPE:
        !          16814:                case NEW:
        !          16815:                case DELETE:
        !          16816:                        break;
        !          16817:                default:        // real operator: check for operator+(1,2);
        !          16818:                        if (arg == 0) break;
        !          16819:                        Pexpr a = arg->e1;      // first operand
        !          16820: 
        !          16821:                        if (Pfct(fn->tp)->memof // obj.operator(1) is OK
        !          16822:                        || a->tp->is_cl_obj()
        !          16823:                        || a->tp->is_ref()) break;
        !          16824:                        a = arg->e2;
        !          16825:                        if (a == 0)             // unary
        !          16826:                                error("%k of basicT",fn->n_oper);
        !          16827:                        else {                  // binary
        !          16828:                                a = a->e1;      // second operand
        !          16829:                                if (a->tp->is_cl_obj() || a->tp->is_ref()) break;
        !          16830:                                error("%k of basicTs",fn->n_oper);
        !          16831:                        }
        !          16832:                        break;
        !          16833:                }
        !          16834:                break;
        !          16835:        case REF:
        !          16836:        case DOT:
        !          16837:                no_virt = Pname(e1->n_initializer);
        !          16838:                e1->n_initializer = 0;
        !          16839:                if (e1 && e1->e1) {
        !          16840:                        Ptype t = e1->e1->tp;
        !          16841:                        Pptr tt = t->is_ptr_or_ref();
        !          16842:                        Ptype ft = tt ? tt->typ : t;
        !          16843:                        Pexpr ee = e1->e1;
        !          16844:                        const_obj = ft->tconst();
        !          16845:                        while (ee && (ee->base==DOT || ee->base==REF)) {
        !          16846:                                Pexpr m = ee->mem;
        !          16847:                                if ( ee->base==REF && m->tp &&  m->tp->is_ptr())
        !          16848:                                        break;
        !          16849:                                ee = ee->e1;
        !          16850:                        }
        !          16851:                        if (ee) {
        !          16852:                                Ptype ttt = ee->tp;
        !          16853:                                int tc;
        !          16854:                                switch (e1->base) {
        !          16855:                                case REF:
        !          16856:                                        Pptr p = ttt?ttt->is_ptr():0;
        !          16857:                                        if (p && p->typ->tconst())
        !          16858:                                                const_obj = 1;
        !          16859:                                        break;
        !          16860:                                case DOT:
        !          16861:                                        tc = ttt ? ttt->tconst() : 0;
        !          16862:                                        if(ttt && tc && (!strict_opt || tc!=2))
        !          16863:                                                const_obj = 1;
        !          16864:                                }
        !          16865:                        }
        !          16866:                }
        !          16867:        case MDOT:
        !          16868:        {       Pexpr n = e1->mem;
        !          16869:        lxlx:
        !          16870:                switch (n->base) {
        !          16871:                case MDOT:
        !          16872:                        // reverse mdot (see expr::print())
        !          16873:                        //      p->a.b()  => (&p->a)->b() => b(&p->a)
        !          16874:                        // or   p->a->b() => (p->a)->b()  => b(p->a)
        !          16875:                        // or   oo.a.b()  => (&oo.a)->b() => b(&oo.a)
        !          16876:                        // or   oo.a->b() => (oo.a)->b()  => b(oo.a)
        !          16877:                {       
        !          16878:                        Pexpr r = e1;
        !          16879:                        Pexpr p = r->e1;
        !          16880:                        for (Pexpr m = r->mem; m->base==MDOT; m = r->mem) {
        !          16881:                                p = new mdot(m->string2,p);
        !          16882:                                p->i1 = m->i1+2;
        !          16883:                                p->tp = p->mem->tp;
        !          16884:                                r->mem = m->mem;
        !          16885:                                r->e1 = p;
        !          16886:                        }
        !          16887:                }
        !          16888:                case REF:
        !          16889:                case DOT:
        !          16890:                        n = n->mem;
        !          16891:                        goto lxlx;
        !          16892:                case NAME:
        !          16893:                        break;
        !          16894:                default:
        !          16895:                        error('i',"ref %k",n->base);
        !          16896:                }
        !          16897:                fn = Pname(n);
        !          16898: //error('d',"mem %n",fn);
        !          16899:                break;
        !          16900:        }
        !          16901:        case MEMPTR:
        !          16902:        default:
        !          16903:                fn = 0;
        !          16904:        };
        !          16905: 
        !          16906: lll:
        !          16907: //error('d',"lll: %t %k",t1,t1->base);
        !          16908:        switch (t1->base) {
        !          16909:        case TYPE:
        !          16910:                t1 = Pbase(t1)->b_name->tp;
        !          16911:                goto lll;
        !          16912: 
        !          16913:        case PTR:       // pf() allowed as shorthand for (*pf)()
        !          16914:                switch (Pptr(t1)->typ->base) {
        !          16915:                case FCT:
        !          16916:                case OVERLOAD:
        !          16917:                        if (Pptr(t1)->memof) error("O missing in call throughP toMF");
        !          16918:                        t1 = Pptr(t1)->typ;
        !          16919:                        fn = 0;
        !          16920:                        goto lll;
        !          16921:                }
        !          16922: 
        !          16923:        default:
        !          16924:                if (fn)
        !          16925:                        error("call of%n;%n is a%t",fn,fn,e1->tp);
        !          16926:                else
        !          16927:                        error("call of%kE ofT%t",e1->base,e1->tp);
        !          16928: 
        !          16929:        case ANY:
        !          16930:                return any_type;
        !          16931:        
        !          16932:        case OVERLOAD:
        !          16933:        {       register Plist gl;
        !          16934:                Pgen g = Pgen(t1);
        !          16935:                Pname found = 0;
        !          16936:                Pname exact = 0;
        !          16937:                int no_exact = 0;
        !          16938:                int no_gen = 0;
        !          16939: 
        !          16940:                for (gl=g->fct_list; gl; gl=gl->l) {    // look for exact match
        !          16941:                        register Pname nn = gl->f;
        !          16942:                        if (exact_match(nn,arg)) {
        !          16943: //error('d',"found exact %n %t",nn,nn->tp);
        !          16944:                                if (found) {
        !          16945:                                        // check if one fct dominates the other
        !          16946:                                        Pname d = dominate(found,nn,arg,const_obj,0);
        !          16947:                                        if (d)
        !          16948:                                                nn = d;
        !          16949:                                        else
        !          16950:                                                error("two exact matches for%n:%t and%t",nn,nn->tp,found->tp);
        !          16951:                                }
        !          16952:                                found = nn;
        !          16953:                        }
        !          16954:                }
        !          16955: //error('d',"found exact2 %n",found);
        !          16956:                if (found) goto fnd;
        !          16957: 
        !          16958: Pname mvec[20];
        !          16959: 
        !          16960: /****************************************************************************
        !          16961:    the next 2 loops have been commented out to eliminate the rule that calls
        !          16962:    requiring only promotions and standard conversions are preferred over
        !          16963:    calls requiring user-defined conversions.
        !          16964: 
        !          16965:                for (gl=g->fct_list; gl; gl=gl->l) {    // look for exact match
        !          16966:                        register Pname nn = gl->f;
        !          16967: 
        !          16968:                        if (prom_match(nn,arg)) {
        !          16969:                                if (found) {
        !          16970:                                        // check if one fct dominates the other
        !          16971:                                        Pname d = dominate(found,nn,arg,const_obj,1);
        !          16972:                                        if (d)
        !          16973:                                                nn = d;
        !          16974:                                        else
        !          16975:                                                error("two exact matches (after integral promotions) for%n:%t and%t",nn,nn->tp,found->tp);
        !          16976:                                }
        !          16977:                                found = nn;
        !          16978:                        }
        !          16979:                }
        !          16980: //error('d',"found exact2 %n",found);
        !          16981:                if (found) goto fnd;
        !          16982: 
        !          16983:        //      for (gl=g->fct_list; gl; gl=gl->l) {    // look for exact match
        !          16984:        //              register Pname nn = gl->f;
        !          16985:        //
        !          16986:        //              if (exact_match(nn,arg) || prom_match(nn,arg)) {
        !          16987:        //                      found = nn;
        !          16988:        //                      goto fnd;
        !          16989:        //              }
        !          16990:        //      }
        !          16991: 
        !          16992:                for (gl=g->fct_list; gl; gl=gl->l) {    // look for match
        !          16993:                                                        // with standard conversion
        !          16994:                        register Pname nn = gl->f;
        !          16995:                        Ninit = 0;
        !          16996:                        Nstd = 0;
        !          16997:                        if (std_match(nn,arg)) {
        !          16998:                        //      if (Nstd == 0)  {
        !          16999:                        //              found = nn;
        !          17000:                        //              goto fnd;
        !          17001:                        //      }
        !          17002:                                if (exact) {
        !          17003:                                        // check if one fct dominates the other
        !          17004:                                        Pname d = dominate(exact,nn,arg,const_obj,2);
        !          17005:                                        if (d == 0) {
        !          17006:                                                mvec[no_exact++] = nn;
        !          17007:                                        //      no_exact++;
        !          17008:                                        //      error("two standard conversions possible for%n: %t and %t",fn,exact->tp,nn->tp);
        !          17009:                                        }
        !          17010:                                        else
        !          17011:                                                exact = d;
        !          17012:                                }
        !          17013:                                else
        !          17014:                                        exact = nn;
        !          17015:                        }
        !          17016:                        
        !          17017:                }
        !          17018: 
        !          17019: //error('d',"excact %n",exact);
        !          17020:                if (exact) {
        !          17021:                        if (no_exact) {
        !          17022:                                while (no_exact) {
        !          17023:                                        Pname d = dominate(exact,mvec[--no_exact],arg,const_obj,2);
        !          17024:                                        if (d)
        !          17025:                                                exact = d;
        !          17026:                                        else
        !          17027:                                                error("two standard conversions possible for%n: %t and %t",fn,exact->tp,mvec[no_exact]->tp);
        !          17028:                                }
        !          17029:                                
        !          17030:                        }
        !          17031: //error('d',"found exact3 %n",found);
        !          17032:                        found = exact;
        !          17033:                        goto fnd;
        !          17034:                }
        !          17035: 
        !          17036:     this is the end of the commented out section.
        !          17037: ************************************************************************/
        !          17038: 
        !          17039:                for (gl=g->fct_list; gl; gl=gl->l) {    /* look for coercion */
        !          17040:                        register Pname nn = gl->f;
        !          17041:                        if (prom_match(nn,arg) ||
        !          17042:                            std_match(nn,arg)  ||
        !          17043:                            gen_coerce(nn,arg)) {
        !          17044: //error('d',"user2 %n %t",nn,nn->tp);
        !          17045:                                if (found) {
        !          17046:                                        // check if one fct dominates the other
        !          17047:                                        Pname d = dominate(found,nn,arg,const_obj,3);
        !          17048: //error('d',"dom d %d",d);
        !          17049:                                        if (d == 0) d = user_dominate(found,nn,arg);
        !          17050:                                        if (d == 0) {
        !          17051:                                                mvec[no_gen++] = nn;
        !          17052:                                        }
        !          17053:                                        else
        !          17054:                                                found = d;
        !          17055:                                }
        !          17056:                                else
        !          17057:                                        found = nn;
        !          17058:                        }
        !          17059:                }
        !          17060:                if(found) {
        !          17061:                        while(no_gen) {
        !          17062:                                Pname d = dominate(found,mvec[--no_gen],arg,const_obj,3);
        !          17063:                                if(d==0) d = user_dominate(found,mvec[no_gen],arg);
        !          17064:                                if(d)
        !          17065:                                        found = d;
        !          17066:                                else {
        !          17067:                                        //error("ambiguousA for%n: %t and %t",fn,found->tp,mvec[no_gen]->tp);
        !          17068:                                        error("ambiguous call of%n: %t and %t",fn,found->tp,mvec[no_gen]->tp);
        !          17069:                                }
        !          17070:                        }
        !          17071:                }
        !          17072:        fnd:
        !          17073: //error('d',"fnd %t",found?found->tp:0);
        !          17074:                if (found) {
        !          17075:                        overFound = chk = fn = found;
        !          17076:                        f = Pfct(fn->tp);
        !          17077:                }
        !          17078:                else {
        !          17079:                        error("badAL for%n (no match against any %n)",fn,fn);
        !          17080:                        return any_type;
        !          17081:                }
        !          17082:                break;
        !          17083:        }
        !          17084:        case FCT:
        !          17085:                f = Pfct(t1);
        !          17086:                if (fn) {
        !          17087:                        switch (fn->n_oper) {
        !          17088:                        case CTOR:
        !          17089:                        case TYPE:
        !          17090:                                chk = fn;
        !          17091:                        }
        !          17092:                }
        !          17093:        }
        !          17094: 
        !          17095: //error('d',"chk %n",chk);
        !          17096:        if (chk) {
        !          17097:                Ptype t = 0;
        !          17098:                Pexpr ee = e1->e1;
        !          17099: 
        !          17100:                switch (e1->base) {
        !          17101:                case REF:       // ptr->chk()
        !          17102:                        if (ee == 0) {  // 0->x() fudge handling new x()
        !          17103:                                check_visibility(chk,no_virt,Pclass(chk->n_table->t_name->tp),tbl,cc->nof);
        !          17104:                                break;
        !          17105:                        };
        !          17106:                        t = ee->tp;
        !          17107:                        while(t->base==TYPE) t = Pbase(t)->b_name->tp;
        !          17108:                        t = Pptr(t)->typ;
        !          17109:                        break;
        !          17110:                case DOT:       // obj.chk()
        !          17111:                        t = ee->tp;
        !          17112:                }
        !          17113: 
        !          17114:                Pname cn = t?t->is_cl_obj():0;
        !          17115:                Pclass cl = cn?Pclass(cn->tp):0; // class of ``this'' for chk
        !          17116: 
        !          17117:                if (cl) {
        !          17118:                        if (chk->n_oper==CTOR
        !          17119:                                && chk->n_protect
        !          17120:                                && cc->nof
        !          17121:                                && cc->nof->n_oper==CTOR)
        !          17122:                                        // BUG: cannot handle protected base
        !          17123:                                        // class constructor
        !          17124:                                ;
        !          17125:                        else {
        !          17126:                                check_visibility(chk,no_virt,cl,tbl,cc->nof);
        !          17127:                        }
        !          17128:                }
        !          17129:        }
        !          17130: 
        !          17131:        if (fn && f->returns->is_cl_obj() && f->f_result==0) {
        !          17132:                // protect against class cn; cn f(); ... class cn { cn(cn&); ... };
        !          17133:                make_res(f);
        !          17134: //error('d',"returns %t",f->returns);
        !          17135:                f->returns->tsizeof();  // make sure it is declared
        !          17136:        }
        !          17137: 
        !          17138: //error('d',"fn %n %t printed %d",fn,fn?fn->tp:0,fn?fn->n_dcl_printed:0);
        !          17139:        if (fn && fn->n_dcl_printed==0) {
        !          17140:                if (f->f_inline==0 && f->f_imeasure) {
        !          17141:                        extern void uninline(Pname fn);
        !          17142:                        uninline(fn);
        !          17143:                }
        !          17144: 
        !          17145:                // ensure printout of class declaration:
        !          17146:                for (Pname nn=f->argtype; nn; nn=nn->n_list)
        !          17147:                        if (nn->tp->is_cl_obj()) (void) nn->tp->tsizeof();
        !          17148: 
        !          17149:                fn->dcl_print(0);
        !          17150:        }
        !          17151: 
        !          17152:        if (no_virt && f->f_static==0) {
        !          17153:                if (e1->base==REF || e1->base==DOT) e1->n_initializer = fn;
        !          17154:        }
        !          17155:        else
        !          17156:                fct_name = fn;
        !          17157: //error('d',"fn %n %t %d %d",fn,f,f->f_this,f->f_static);
        !          17158:        if (f->f_this) {        //SSS call of non-static memberfunction
        !          17159:                switch (e1->base) {
        !          17160:                case MEMPTR:
        !          17161:                case REF:
        !          17162:                case DOT:
        !          17163:                        break;
        !          17164:                default:
        !          17165:                        error("O orP missing for%n ofT %t",fct_name,f);
        !          17166:                }
        !          17167:        }
        !          17168:        else if (fn) {  //SSS call of static function
        !          17169:        sss:
        !          17170:                switch (e1->base) {
        !          17171:                case REF:
        !          17172:                case DOT:
        !          17173:                        e1 = e1->mem;
        !          17174:                        goto sss;
        !          17175:                }
        !          17176:        }
        !          17177: 
        !          17178:        if (fn) fn->use();      // a patch: ctors are sometimes not use()d
        !          17179: 
        !          17180:        if (f->f_const==0
        !          17181:        && (fn==0 || (fn->n_oper!=CTOR && fn->n_oper!=DTOR))) { //CCC
        !          17182:                Pexpr ee = e1->e1;
        !          17183:                 // while (ee && (ee->base==DOT || ee->base==REF)) ee = ee->e1;
        !          17184:                 while (ee && (ee->base==DOT || ee->base==REF)) {
        !          17185:                        Pexpr m = ee->mem;
        !          17186: // error('d', "m: %k tp %t", m?m->base:0, m?m->tp:0 ); 
        !          17187:                        if ( ee->base==REF && m->tp &&  m->tp->is_ptr())
        !          17188:                                break;
        !          17189:                        ee = ee->e1;
        !          17190:                }
        !          17191: // error('d', "ee: %k tp %k", ee?ee->base:0, ee?ee->tp->base:0);
        !          17192: 
        !          17193:                if (ee) {
        !          17194:                        Ptype tt = ee->tp;
        !          17195:                        switch (e1->base) {
        !          17196:                        case REF:
        !          17197:                        {       Pptr p = tt?tt->is_ptr():0;
        !          17198:                                if (p && p->typ->tconst())
        !          17199:                                        error(strict_opt?0:'w',"non-constMF%n called for constO (anachronism)",fn);
        !          17200:                                // is really an error, but only warn to help transition
        !          17201:                                break;
        !          17202:                        }
        !          17203:                        case DOT:
        !          17204:                                int tc = tt ? tt->tconst() : 0;
        !          17205:                                if (tt && tc && (!strict_opt || tc!=2))
        !          17206:                                        error(strict_opt?0:'w',"non-constMF%n called for constO (anachronism)",fn);
        !          17207:                                // is really an error, but only warn to help transition
        !          17208:                        }
        !          17209:                }
        !          17210:        }
        !          17211: 
        !          17212:        t = f->returns;
        !          17213:        x = f->nargs;
        !          17214:        k = f->nargs_known;
        !          17215: 
        !          17216:        e = arg;
        !          17217:        if (k == 0) goto rlab;
        !          17218: 
        !          17219:        for (nn=f->argtype, argno=1; e||nn; nn=nn->n_list, e=etail->e2, argno++) {
        !          17220:                Pexpr a;
        !          17221:                int save_base = 0;
        !          17222:                char* save_name = 0;
        !          17223: 
        !          17224:                if (e) {
        !          17225:                        a = e->e1;
        !          17226:                        etail = e;
        !          17227: 
        !          17228:                        if (nn) {       /* type check */
        !          17229:                                Ptype t1 = nn->tp;
        !          17230: //error('d',"argtp %t etp %t a %k",t1,a->tp,a->base);
        !          17231: 
        !          17232:                                while(t1->base == TYPE)
        !          17233:                                        t1 = Pbase(t1)->b_name->tp;
        !          17234: 
        !          17235:                                switch (t1->base) {
        !          17236:                                case RPTR:
        !          17237:                                {       Ptype pt = Pptr(t1)->typ;
        !          17238:                                        if (pt->base != FCT ||
        !          17239:                                                ( pt->base == FCT && 
        !          17240:                                                  pt->check(a->tp,0)))
        !          17241:                                                        a = ref_init(Pptr(nn->tp),a,tbl);
        !          17242:                                        goto cbcb;
        !          17243:                                }
        !          17244:                                case COBJ:
        !          17245:                                        if (a->base!=G_CM
        !          17246:                                        || nn->tp->check(a->tp,ASSIGN))
        !          17247:                                                a = class_init(0,t1,a,tbl);
        !          17248:                                        else
        !          17249:                                                a->e2=class_init(0,t1,a->e2,tbl);
        !          17250:                                        if (nn->n_xref) {
        !          17251:                                                // (temp.ctor(arg),&arg)
        !          17252:                                                a = a->address();
        !          17253:                                        }
        !          17254:                                        else {
        !          17255:                                                // defend against:
        !          17256:                                                //      int f(X); ... X(X&);
        !          17257:                                                Pname cln = Pbase(t1)->b_name;  
        !          17258:                                                if (cln && Pclass(cln->tp)->has_itor()) {
        !          17259:                                                        // mark X(X&) arguments
        !          17260:                                                        nn->n_xref = 1;
        !          17261:                                                        a = a->address();
        !          17262:                                                }
        !          17263:                                        }
        !          17264:        cbcb:
        !          17265: //error('d',"cbcb: a %d %k %t",a->base,a->base,a->tp);
        !          17266:                if (a->base==G_CM) {
        !          17267:                        if (a->e1->base==DEREF) a->e1 = a->e1->e2; // (*e1,e2) => (e1,e2)
        !          17268: //error('d',"      a %d %k",a->e1->base,a->e1->base);
        !          17269:                        if (a->e1->base==G_CALL
        !          17270:                        && Pname(a->e1->fct_name)
        !          17271:                        && Pname(a->e1->fct_name)->n_oper==CTOR
        !          17272:                        && (a->e2->base==G_ADDROF || a->e2->base==ADDROF)) {
        !          17273:                                a = a->e1;      // (ctor(&tmp),&tmp) => ctor(&tmp)
        !          17274: //error('d',"tmp %k %n",a->e2->base,a->e2->e2);
        !          17275:                                goto cccc;
        !          17276:                        }
        !          17277:                        else if (a->e2->base==G_ADDROF
        !          17278:                        && a->e2->e2->base==NAME)  {
        !          17279:                        cccc:
        !          17280: //error('d',"cccc: a %d %k %t",a->base,a->base,a->tp);
        !          17281:        if (t1->base==RPTR
        !          17282:        && Pptr(t1)->typ->tconst()==0) {        // temporary used
        !          17283:                if (warning_opt)
        !          17284:                        error('w',"temporary used for non-const%tA",nn->tp);
        !          17285:                else {
        !          17286:                        Ptype atp = a->tp;
        !          17287:                        if (atp==void_type
        !          17288:                        && a->base==G_CALL
        !          17289:                        && a->e1->tp->base==FCT)
        !          17290:                                atp = Pfct(a->e1->tp)->s_returns;
        !          17291: 
        !          17292:                        Ptype tt = t1->is_ref();
        !          17293: //error('d',"tt %t atp %t",tt,atp);
        !          17294:                        if (tt) {
        !          17295:                                if (Pptr(tt)->typ->tsizeof()!=atp->tsizeof()) { // sliced
        !          17296:                                        Ptype aat = atp->is_ptr_or_ref();
        !          17297:                                        if (aat==0
        !          17298:                                        || Pptr(tt)->typ->tsizeof()!=Pptr(aat)->typ->tsizeof())
        !          17299:                                                error('w',"temporary used for non-const%tA",nn->tp);
        !          17300:                                }
        !          17301:                        }
        !          17302:                        else if (t1->tsizeof()!=atp->tsizeof()) // sliced
        !          17303:                                error('w',"temporary used for non-const%tA",nn->tp);
        !          17304:                }
        !          17305:                
        !          17306:        //      if (warning_opt                         // blabber
        !          17307:        //      ||  t1->tsizeof()!=a->tp->tsizeof()))   // sliced
        !          17308:        //              error('w',"temporary used for non-const%tA",nn->tp);
        !          17309: 
        !          17310:        }
        !          17311:                        }
        !          17312:                }
        !          17313:                                        e->e1 = a;
        !          17314:                                        break;
        !          17315:                                case ANY:
        !          17316:                                        goto rlab;
        !          17317:                                case PTR:
        !          17318:                                {
        !          17319:                                        save_base = e->e1->base;
        !          17320:                                        if(a->tp->base==OVERLOAD)
        !          17321:                                                save_name = Pgen(a->tp)->fct_list->f->string;
        !          17322:                                        Pexpr te_a = a;
        !          17323:                                        e->e1 = a = ptr_init(Pptr(t1),a,tbl);
        !          17324:                                        no_change = (te_a == a);
        !          17325:                                //      if (x==a || x==a->e2) goto def; // needs checking
        !          17326:                                        if (Pchecked == 0) goto def;
        !          17327:                                        break;
        !          17328:                                }
        !          17329:                                //      e->e1 = a = ptr_init(Pptr(t1),a,tbl);
        !          17330:                                //      goto def;
        !          17331:                                case CHAR:
        !          17332:                                case SHORT:
        !          17333:                                case INT:
        !          17334:                                //      if (a->base==ICON && a->tp==long_type)
        !          17335:                                //              error('w',"long constantA for%n,%kX",fn,t1->base);
        !          17336:                                {       Ptype t = a->tp;
        !          17337:                                        while(t->base == TYPE)
        !          17338:                                                t = Pbase(t)->b_name->tp;
        !          17339: 
        !          17340:                                        switch (t->base) {
        !          17341:                                        case LONG:
        !          17342:                                        case FLOAT:
        !          17343:                                        case DOUBLE:
        !          17344:                                        case LDOUBLE:
        !          17345:                                                error('w',"A%d: %t passed as %t",argno,a->tp,t1);
        !          17346:                                        }
        !          17347:                                }
        !          17348:                                        // no break
        !          17349:                                case LONG:
        !          17350:                                        if (Pbase(t1)->b_unsigned
        !          17351:                                        && a->base==UMINUS
        !          17352:                                        && a->e2->base==ICON)
        !          17353:                                                error('w',"negativeA for%n, unsignedX",fn);
        !          17354:                                default:
        !          17355:                                def:
        !          17356:                                {       Pexpr x = try_to_coerce(t1,a,"argument",tbl);
        !          17357: //error('d',"x %d t1 %t nn %t a1 %t",x,t1,nn->tp,a->tp);
        !          17358:                                        if (x) {
        !          17359:                                                if (Pchecked == 0 && no_change) { 
        !          17360:                                                        Pexpr te_x = ptr_init(Pptr(t1), x, tbl);
        !          17361: 
        !          17362:                                                        if ( te_x != x ) e->e1 = a = te_x; else e->e1=x;
        !          17363:                                                }
        !          17364:                                                else
        !          17365:                                                        e->e1 = x;
        !          17366:                                        }
        !          17367:                                        else if (nn->tp->check(a->tp,ARG)) {
        !          17368:                                                error("badA %dT for%n:%t (%tX)",argno,fn,a->tp,nn->tp);
        !          17369:                                                return any_type;
        !          17370:                                        }
        !          17371:                                }
        !          17372:                                }
        !          17373: 
        !          17374:                                 Pexpr tt = e->e1;
        !          17375:                                 while ( tt->base == CAST )
        !          17376:                                         tt = tt->e1;
        !          17377:                                 if ( tt->base == ILIST )
        !          17378:                                         e->e1 = tt;
        !          17379: 
        !          17380:                                 if (e->e1->base == ILIST) {
        !          17381:                                         // memptr constant
        !          17382:                                         // f({1,2,f}) ==> memptr t; f((t={1,2,f},t))
        !          17383:                                        if(save_base == REF) {
        !          17384:                                                Pptr m = Pptr(a->tp);
        !          17385:                                                error(strict_opt?0:'w',
        !          17386:                                                "address of boundF (try using ``%s::*'' forPT and ``&%s::%s'' for address) (anachronism)",
        !          17387:                                                m->memof->string,
        !          17388:                                                m->memof->string,
        !          17389:                                                save_name
        !          17390:                                                );
        !          17391:                                        }
        !          17392:                                         Pname temp = make_tmp('A',mptr_type,tbl);
        !          17393:                                         e->e1 = mptr_assign(temp,e->e1);
        !          17394:                                         e->e1 = a = new expr(G_CM,e->e1,temp);
        !          17395:                                         a->tp = temp->tp;
        !          17396:                                 }
        !          17397: 
        !          17398:                        }
        !          17399:                        else {
        !          17400:                                if (k != ELLIPSIS) {
        !          17401:                                        error("unexpected %dA for%n",argno,fn);
        !          17402:                                        return any_type;
        !          17403:                                }
        !          17404:                                Pexpr te=e;
        !          17405:                                while(e) {
        !          17406:                                        if (e->e1->base == ILIST) {
        !          17407:                                                // memptr constant
        !          17408:                                                // f({1,2,f}) ==> memptr t; f((t={1,2,f},t))
        !          17409:                                                Pname temp = make_tmp('A',mptr_type,tbl);
        !          17410:                                                e->e1 = mptr_assign(temp,e->e1);
        !          17411:                                                e->e1 = a = new expr(G_CM,e->e1,temp);
        !          17412:                                                a->tp = temp->tp;
        !          17413:                                        }
        !          17414:                                        e = e->e2;
        !          17415:                                }
        !          17416:                                e = te;
        !          17417:                                goto rlab;
        !          17418:                        }
        !          17419:                }
        !          17420:                else {  /* default argument? */
        !          17421:                        a = nn->n_initializer;
        !          17422:                        if (a == 0) {
        !          17423:                                error("A %d ofT%tX for%n",argno,nn->tp,fn);
        !          17424:                                return any_type;
        !          17425:                        }
        !          17426:                                 if (a->base == ILIST) {
        !          17427:                                         // memptr constant
        !          17428:                                         // f({1,2,f}) ==> memptr t; f((t={1,2,f},t))
        !          17429:                                         Pname temp = make_tmp('A',mptr_type,tbl);
        !          17430:                                         a = mptr_assign(temp,a);
        !          17431:                                         a = new expr(G_CM,a,temp);
        !          17432:                                         a->tp = temp->tp;
        !          17433:                                 }
        !          17434:                        a->permanent = 2;       // ought not be necessary, but it is
        !          17435:                        e = new expr(ELIST,a,0);
        !          17436:                        if (etail)
        !          17437:                                etail->e2 = e;
        !          17438:                        else
        !          17439:                                e2 = e;
        !          17440:                        etail = e;
        !          17441:                }
        !          17442:        }
        !          17443: 
        !          17444: rlab:
        !          17445: //error('d',"rlab fct_name %n %t",fct_name,fct_name?fct_name->tp:0);
        !          17446:        for (; e; e = e->e2) {  // unchecked arguments
        !          17447:                Pexpr a = e->e1;
        !          17448:                Pname cn;
        !          17449: 
        !          17450:                if (a->base==NAME && a->tp->base==FCT) {
        !          17451:                        // function name that escaped the type system:
        !          17452:                        // update use count
        !          17453:                        a->lval(ADDROF);
        !          17454:                }
        !          17455:                else if (warning_opt && (cn = a->tp->is_cl_obj())) {
        !          17456:                        Pclass cl = Pclass(cn->tp);
        !          17457:                        if (cl->has_ctor() || cl->memtbl->look("__as",0))//cl->has_oper(ASSIGN)
        !          17458:                        {
        !          17459:                                if (fct_name)
        !          17460:                                error('w',"O ofC%t withK or = copied asA to%n (%t)",cl,fct_name,fct_name->tp);
        !          17461:                                else
        !          17462:                                error('w',"O ofC%t withK or = copied asA to `...'",cl);
        !          17463:                        }
        !          17464:                }
        !          17465:                else if (a->tp->is_ref())
        !          17466:                        e->e1 = a->contents();
        !          17467:        }
        !          17468: 
        !          17469:        if (f->f_result) {              // f(args) => (f(&temp,args),temp)
        !          17470:                Pname tn = make_tmp('R',f->returns,tbl);
        !          17471:                e2 = new expr(ELIST,tn->address(),e2);
        !          17472: // error('d',"result %n refd: %d",fn, refd);
        !          17473:                Pexpr ee = new expr(0,0,0);
        !          17474:                *ee = *this;
        !          17475:                base = G_CM;            // (f(&temp,args),temp)
        !          17476:                e1 = ee;
        !          17477:                if (refd == 2)
        !          17478:                        e2 = tn->address();
        !          17479:                else e2 = tn;
        !          17480:                tp = tn->tp;
        !          17481:        }
        !          17482: 
        !          17483:        return t;
        !          17484: }
        !          17485: 
        !          17486: int cm_const_save; 
        !          17487: 
        !          17488: Pexpr ref_init(Pptr p, Pexpr init, Ptable tbl)
        !          17489: /*
        !          17490:        initialize the "p" with the "init"
        !          17491:        remember to call ptr_init to ensure that pointers to second bases
        !          17492:        are handled correctly.
        !          17493: */
        !          17494: {
        !          17495:        register Ptype it = init->tp;
        !          17496:        Pptr px = p;
        !          17497:        while (px->base == TYPE) px = Pptr(Pbase(px)->b_name->tp);
        !          17498:        Ptype p1 = px->typ;
        !          17499:        Pname c1 = p1->is_cl_obj();
        !          17500: // error('d',"ref_init: p %t, p1 %t, px %t, init->tp %t",p,p1,px,it);
        !          17501: // error('d', "ref_init: nof: %n f_const: %d", cc?cc->nof:0, cc?(cc->nof?Pfct(cc->nof->tp)->f_const:0):0);
        !          17502: 
        !          17503:        if (init->base == ILIST) error("IrL as RIr");
        !          17504: 
        !          17505:        if (init->base==NAME
        !          17506:        && Pname(init)->n_scope==ARG
        !          17507:        && init->tp->base==FLOAT)
        !          17508:                error('w',"initializing a float& with floatA is non-portable");
        !          17509: 
        !          17510:        while(it->base == TYPE)
        !          17511:                it = Pbase(it)->b_name->tp; 
        !          17512: 
        !          17513:        switch (it->base) {
        !          17514:        default:
        !          17515:                {       Ptype tt = it->addrof();
        !          17516:                        px->base = PTR; // allow &x for y& when y : public x
        !          17517:                                        // but not &char for int&
        !          17518:                        int x = px->check(tt,COERCE);
        !          17519: 
        !          17520:                        if (x == 0) {   //CCC type is fine check for constness:
        !          17521:                                if (init->tp->tconst()
        !          17522:                                && vec_const==0
        !          17523:                                && fct_const==0) {
        !          17524:                                        // not ``it''
        !          17525:                                        if (init->base == ELIST) init = init->e1;
        !          17526:                                        if (px->typ->tconst() == 0) error("R to constO");
        !          17527:                                        px->base = RPTR;
        !          17528:                                        // if we have a const lvalue we can still pass its address
        !          17529:                                        ignore_const++;
        !          17530:                                        if (init->lval(0)) {
        !          17531:                                                init->lval(ADDROF); // force output
        !          17532:                                                ignore_const--;
        !          17533: //error('d',"in1 %t",init->tp);
        !          17534:                                                return ptr_init(px,init->address(),tbl);//return init->address();
        !          17535:                                        }
        !          17536:                                        ignore_const--;
        !          17537:                                        goto xxx;
        !          17538:                                }
        !          17539:                                px->base = RPTR;
        !          17540:                                 if (init->lval(0)) {   // can pass the address                                                 // no temporary needed 
        !          17541:                                        init->lval(ADDROF); // force output
        !          17542: //error('d',"px %t init %t init %t",px,init->tp,init->tp);
        !          17543:                                        return ptr_init(px,init->address(),tbl);
        !          17544:                                }
        !          17545:                                goto xxx;
        !          17546:                        }
        !          17547: 
        !          17548:                        px->base = RPTR;
        !          17549:                }
        !          17550:        }
        !          17551: 
        !          17552: //error('d',"c1 %n",c1);
        !          17553:        if (c1) {       // assigning to a const X & is fine
        !          17554:                ref_cast++;
        !          17555:                Pexpr x = try_to_coerce(p,init,"reference initialization",tbl);
        !          17556:                ref_cast--;
        !          17557:                if (x) {
        !          17558:                        init = x;
        !          17559:                        goto xxx;
        !          17560:                }
        !          17561:                while (p1->base==TYPE) p1 = Pbase(p1)->b_name->tp;
        !          17562:                int bc = Pbase(p1)->b_const;
        !          17563:                Pbase(p1)->b_const = 0;
        !          17564: //             refd = 1;       
        !          17565:                switch ( init->base ) {
        !          17566:                        case STRING: case ZERO: case CCON:
        !          17567:                        case ICON: case FCON: case IVAL:
        !          17568:                        case NAME:
        !          17569:                                refd = 1; 
        !          17570:                                break;
        !          17571:                        default:
        !          17572:                                refd = (init->e1 && init->e1->base == NAME && 
        !          17573:                                        init->e1->tp->base != RPTR &&
        !          17574:                                        Pname(init->e1)->n_xref == 0) ? 2: 1;
        !          17575:                                break;
        !          17576:                }
        !          17577: // error('d', "***** refd: %d", refd );
        !          17578:                Pexpr a = class_init(0,p1,init,tbl);
        !          17579:                Pbase(p1)->b_const = bc;
        !          17580:                refd = 0;
        !          17581:                if (a==init && init->tp!=any_type) goto xxx;
        !          17582: // error('d',"ri a %d %k",a->base,a->base);
        !          17583:                switch (a->base) {
        !          17584:                case G_CALL:
        !          17585:        //      case CM:
        !          17586:        //      case G_CM:
        !          17587:                        init = a;
        !          17588:                        goto xxx;
        !          17589:                }
        !          17590:                a = a->address();
        !          17591:                a =  ptr_init(px,a,tbl);
        !          17592:                return a;
        !          17593: //             return ptr_init(px,a->address(),tbl);//a->address();
        !          17594:        }
        !          17595: 
        !          17596: //error('d',"p1 %t it %t",p1,it);
        !          17597:        if (p1->check(it,0)) {
        !          17598: 
        !          17599:                if (p1->check(it,ASSIGN) == 0) {
        !          17600:                //      if (p1->is_ptr())  // check for base* = derived*
        !          17601:                //              goto xxx;
        !          17602: 
        !          17603:                        // things like ``double& rr = 1;'' temporary needed
        !          17604:                        // warn in case of ``slightly wrong lvalue'', e.g.
        !          17605:                        //      int i; double& r = i;
        !          17606:                        if (init->lval(0) && p1->tconst()==0)
        !          17607:                                error('w',"temporary used toIR; no changes will be propagated to actualA");
        !          17608:                        goto def;
        !          17609:                }
        !          17610: 
        !          17611:                Pexpr x = try_to_coerce(p1,init,"reference",tbl);       // x==init
        !          17612:                if (x==0) x = try_to_coerce(px,init,"reference",tbl);   // x&=init
        !          17613:                if (x) {
        !          17614:                        init = x;
        !          17615:                        goto def;
        !          17616:                }
        !          17617: 
        !          17618:                error("badIrT:%t (%tX)",it,p);
        !          17619:                if (init->base != NAME) init->tp = any_type;
        !          17620:                return init;
        !          17621:        }
        !          17622:        
        !          17623: xxx:   /*
        !          17624:                here comes the test of a ``fundamental theorem'':
        !          17625:                a structure valued expression is
        !          17626:                        (1) an lvalue of type T (possibly const)
        !          17627:                or      (2) the result of a function (a _result if X(X&) is defined)
        !          17628:                or      (3) a * or [] or ? or , expression
        !          17629:        */
        !          17630: //error('d',"xxx %k %d %t",init->base,init->base,init->tp);
        !          17631: 
        !          17632:        switch (init->base) {
        !          17633:        case NAME:
        !          17634:        case DEREF:
        !          17635:        case REF:
        !          17636:        case DOT:                       // init => &init
        !          17637:                if (it->tconst() && vec_const==0 && fct_const==0) goto def;
        !          17638:                if ( cc && cc->nof && 
        !          17639:                        Pfct(cc->nof->tp)->f_const ) 
        !          17640:                                cm_const_save = Pbase(p->typ)->b_const;
        !          17641:                init->lval(ADDROF);
        !          17642:                cm_const_save = 0;
        !          17643: 
        !          17644:                if (vec_const) return init;
        !          17645:                if (fct_const && p1->is_ptr()) goto def;        // fptr& = fct
        !          17646:                // no break
        !          17647:        case CM:
        !          17648:        case G_CM:                      // & (f(&temp), temp)
        !          17649:                return ptr_init(px,init->address(),tbl);//init->address();
        !          17650:        default:
        !          17651:        def:
        !          17652:        {
        !          17653: // error('d',"def: init->tp %t p1 %t ",init->tp,p1);   
        !          17654: // error('d',"p1: %t const_ptr: %d", p1, const_ptr);
        !          17655:                if (const_ptr == 0) {
        !          17656:                        if (tbl == gtbl || strict_opt) 
        !          17657:                                error("Ir for%snon-constR not an lvalue", strict_opt?"":" global ");
        !          17658:                        else
        !          17659:                        if (warning_opt) 
        !          17660:                                error('w', "Ir for non-constR not an lvalue (anachronism)");
        !          17661:                }
        !          17662: 
        !          17663:                 Pname tcl = p1->is_cl_obj ();
        !          17664:                 if(tcl && Pclass(tcl->tp)->c_abstract)
        !          17665:                        error("a temporary is needed for a parameter, but the argument type is abstract class %t.", tcl->tp);
        !          17666: 
        !          17667:                Pname n = make_tmp('I',p1,tbl);
        !          17668:                Pexpr a;
        !          17669:                Pname ic = init->tp->is_cl_obj();
        !          17670: 
        !          17671:                if (p1->tconst()==0
        !          17672:                && (init->tp->tconst() && vec_const==0 && fct_const==0)
        !          17673:                && p1->check(it,ASSIGN)==0)
        !          17674:                        error('w',"constIr: temporary used toI reference");
        !          17675: 
        !          17676:                switch (p1->base) {
        !          17677:                case INT:
        !          17678:                case CHAR:
        !          17679:                case SHORT:
        !          17680:                        switch (it->base) {
        !          17681:                        case LONG:
        !          17682:                        case FLOAT:
        !          17683:                        case DOUBLE:
        !          17684:                        case LDOUBLE:
        !          17685:                                error('w',"%t assigned to %t inRIr",it,p1);
        !          17686:                        }
        !          17687:                }
        !          17688: 
        !          17689:                if (ic!=c1 && Pclass(ic->tp) != Pclass(c1->tp)) {
        !          17690:                        // derived class1 => must cast: ``it Ix; (Ix=init,(p)&Ix);''
        !          17691:                        n->tp = init->tp;
        !          17692:                        a = ptr_init(px,n->address(),tbl);//n->address();
        !          17693:                        PERM(p);
        !          17694:                        a = new texpr(CAST,p,a);
        !          17695:                        a->tp = p;
        !          17696:                }
        !          17697:                else
        !          17698:                        a = n->address();
        !          17699: 
        !          17700:                refd = 1;
        !          17701:                Pexpr as = init_tmp(n,init,tbl);
        !          17702:                refd = 0;
        !          17703:                a = new expr(G_CM,as,a);
        !          17704:                a->tp = a->e2->tp;
        !          17705:                return a;
        !          17706:        }
        !          17707:        }
        !          17708: }
        !          17709: 
        !          17710: Pexpr class_init(Pexpr nn, Ptype tt, Pexpr init, Ptable tbl)
        !          17711: /*
        !          17712:        initialize "nn" of type "tt" with "init"
        !          17713:        if nn==0 make a temporary,
        !          17714:        nn may not be a name
        !          17715: */
        !          17716: {      
        !          17717:        if (init == dummy) return 0;
        !          17718: //error('d',"class_init %t with %t init %k refd %d",tt,init->tp,init->base,refd);
        !          17719:        Pname c1 = tt->is_cl_obj();
        !          17720: 
        !          17721:         if (init == 0) {
        !          17722:                 error("emptyIr");
        !          17723:                 return dummy;
        !          17724:         }
        !          17725: 
        !          17726:        if (c1) {
        !          17727:                Pclass cl = Pclass(c1->tp);
        !          17728:                Pname c2 = init->tp->is_cl_obj();
        !          17729: 
        !          17730:                if (c1!=c2 || (refd==0 && cl->has_itor())) {
        !          17731:                        /*      really ought to make a temp if refd,
        !          17732:                                but ref_init can do that
        !          17733:                        */
        !          17734:                        int i = can_coerce(tt,init->tp);
        !          17735: //error('d',"i %d nn %n",i,nn);
        !          17736:                        switch (i) {
        !          17737:                        default:
        !          17738:                                error("%d ways of making a%n from a%t",i,c1,init->tp);
        !          17739:                                init->tp = any_type;
        !          17740:                                return init;
        !          17741:                        case 0:
        !          17742:                                if (c2 && Pclass(c2->tp)->has_base(cl)) {
        !          17743:                                        init = init->address();
        !          17744:                                        Pexpr x = cast_cptr(cl,init,tbl,0);
        !          17745: 
        !          17746:                                        if (x == init) {
        !          17747:                                                Ptype pt = tt->addrof();
        !          17748:                                                PERM(pt);
        !          17749:                                                x = new cast(pt,init);
        !          17750:                                        }
        !          17751: 
        !          17752:                                        return x->contents();
        !          17753:                                }
        !          17754:                                error("cannot make a%n from a%t",c1,init->tp);
        !          17755:                                init->tp = any_type;
        !          17756:                                return init;
        !          17757:                        case 1:
        !          17758: //error('d',"ncoerce %n %k %d",Ncoerce,init->base,init->base);
        !          17759:                                if (Ncoerce == 0) {
        !          17760:                                        Pexpr a = new expr(ELIST,init,0);
        !          17761:                                        a = new texpr(VALUE,tt,a);
        !          17762:                                        a->e2 = nn;
        !          17763:                                //      return a->typ(tbl);
        !          17764:                                        a = a->typ(tbl);
        !          17765: //error('d',"ci a %k %d %t",a->base,a->base,a->tp);
        !          17766:                                        return a;
        !          17767:                                }
        !          17768: 
        !          17769:                                switch (init->base) {
        !          17770:                                case CM:
        !          17771:                                case G_CM:      //ddd
        !          17772:                                case NAME:      /* init.coerce() */
        !          17773:        /* *ref */              case DEREF:
        !          17774:                                {       Pref r = new ref(DOT,init,Ncoerce);
        !          17775:                                        Pexpr rr = r->typ(tbl);
        !          17776:                                        init = new expr(G_CALL,rr,0);
        !          17777:                                        init->fct_name = Ncoerce;
        !          17778:                                        break;
        !          17779:                                }
        !          17780:                                default:        // (temp=init,temp.coerce())
        !          17781:                                {       Pname tmp = make_tmp('U',init->tp,tbl); 
        !          17782:                                        int x = refd;   
        !          17783:                                        refd = 0;       // ??
        !          17784:                                        Pexpr ass = init_tmp(tmp,init,tbl);
        !          17785:                                        refd = x;
        !          17786:                                        Pref r = new ref(DOT,tmp,Ncoerce);
        !          17787:                                        Pexpr rr = r->typ(tbl);
        !          17788:                                        Pexpr c = new expr(G_CALL,rr,0);
        !          17789:                                        c->fct_name = Ncoerce;
        !          17790:                                        c = c->typ(tbl);
        !          17791:                                        init = new expr(CM,ass,c);
        !          17792:                                        init->tp = c->tp;
        !          17793:                                        if (refd) {     // &f() => (t=f(), &t)
        !          17794:                                                Pname tmp2 = make_tmp('L',c->tp,tbl); 
        !          17795:                                                ass = init_tmp(tmp2,init,tbl);
        !          17796:                                                init = new expr(G_CM,ass,tmp2);
        !          17797:                                        }
        !          17798:                                }
        !          17799:                                }
        !          17800: //error('d',"nn %n",nn);
        !          17801:                                if (nn) {
        !          17802:                                        Pexpr a = new expr(ELIST,init,0);
        !          17803:                                        a = new texpr(VALUE,tt,a);
        !          17804:                                        a->e2 = nn;
        !          17805:                                        return a->typ(tbl);
        !          17806:                                }
        !          17807:                        }
        !          17808: //error('d',"c1 %n c2 %n",c1,c2);
        !          17809:                        return init->typ(tbl);
        !          17810:                }
        !          17811:                return init;
        !          17812:        }
        !          17813: //error('d',"ci check tt %t init->tp %t",tt,init->tp);
        !          17814:        if (tt->check(init->tp,ASSIGN) && refd==0) {
        !          17815:                error("badIrT:%t (%tX)",init->tp,tt);
        !          17816:                init->tp = any_type;
        !          17817:        }
        !          17818: 
        !          17819:        return init;
        !          17820: }
        !          17821: 
        !          17822: extern int bound;      // fudge for bound pointers to functions
        !          17823: 
        !          17824: Pexpr expr::docast(Ptable tbl)
        !          17825: {      
        !          17826:        // check cast against value, INCOMPLETE
        !          17827: 
        !          17828: //error('d',"docast %d %t %k",this,tp2,e1->base);
        !          17829:        if (e1 == dummy) {
        !          17830:                error("E missing for cast");
        !          17831:                tp = any_type;
        !          17832:                return this;
        !          17833:        }
        !          17834: 
        !          17835:        int pmf = 0;
        !          17836:        int ptom_cast = 0;
        !          17837:        Pexpr ee = e1;
        !          17838: 
        !          17839: //error('d',"ee %k %d",ee->base,ee->base);
        !          17840:        switch (ee->base) {
        !          17841:        case ADDROF:
        !          17842:                ee = ee->e2;
        !          17843:                switch (ee->base) {
        !          17844:                case NAME:      goto nm;
        !          17845:                case REF:       goto rf;
        !          17846:                }
        !          17847:                break;
        !          17848: 
        !          17849:        case NAME:
        !          17850:        nm:
        !          17851:                if (Pname(ee)->n_qualifier) pmf = 1;
        !          17852:                break;
        !          17853:                
        !          17854:        case REF:
        !          17855:        rf:
        !          17856:                if (ee->e1->base == THIS) bound = 1;
        !          17857:                break;
        !          17858:        }
        !          17859: 
        !          17860:        e1 = e1->typ(tbl);
        !          17861: 
        !          17862:        int b = bound;  // distinguish between explicit and implicit THIS
        !          17863:        bound = 0;
        !          17864:        pmf = pmf && e1->base==CAST;
        !          17865: 
        !          17866:        Ptype etp = e1->tp;
        !          17867:        Ptype tt = tp2;
        !          17868:        Ptype t = tt;
        !          17869:        tt->dcl(tbl);
        !          17870: 
        !          17871:        while (etp->base == TYPE) etp = Pbase(etp)->b_name->tp;
        !          17872:        while (tt->base == TYPE) tt = Pbase(tt)->b_name->tp;
        !          17873:        
        !          17874: //error('d',"e1 %k etp %t tt %t",e1->base,etp,tt);
        !          17875: 
        !          17876:        switch (etp->base) {
        !          17877:        case PTR:
        !          17878:        case RPTR:
        !          17879:                if (Pptr(etp)->typ->base == OVERLOAD) goto over;
        !          17880: 
        !          17881:                if (warning_opt && i2==0 && Pptr(etp)->typ->tconst()) {
        !          17882:                        switch (tt->base) {
        !          17883:                        case FCT:
        !          17884:                                break;
        !          17885:                        case PTR:
        !          17886:                        case RPTR:
        !          17887:                                if (Pptr(tt)->typ->tconst()) break;
        !          17888:                        default:
        !          17889:                                // casting away const
        !          17890:                                // should be an error
        !          17891:                                // but ANSI says OK so I chicken out
        !          17892:                                // to be able to compile strtok(), etc.
        !          17893:                                error('w',"const cast away:%t->%t",e1->tp,tp2);
        !          17894:                        }
        !          17895:                }
        !          17896:                else
        !          17897:                        i2 = 0; // to allow cfront to escape its own checking
        !          17898:                break;
        !          17899:        case COBJ:
        !          17900:        {       ref_cast = 1;
        !          17901:                Pexpr x = try_to_coerce(tt,e1,"cast",tbl);
        !          17902:                ref_cast = 0;
        !          17903: //error('d',"x %k %t tt %d %t",x?x->base:0,x?x->tp:0,tt,tt);
        !          17904:                if (x) {
        !          17905:                        if (x!=e1 && x->base==DEREF && tt->is_ref()) x = x->e1;
        !          17906:                        if (tt==x->tp || tt->check(x->tp,0)==0 || const_problem)
        !          17907:                                return x;
        !          17908:                        else
        !          17909:                                return new cast(tt,x);
        !          17910:                }
        !          17911:        //      else if (e1->base==DEREF && tt->is_ref()) return e1;
        !          17912:                break;
        !          17913:        }
        !          17914:        case VOID:
        !          17915:                if (tt->base == VOID) {
        !          17916:                        tp = t;
        !          17917:                        return this;
        !          17918:                }
        !          17919:                error("cast of void value");
        !          17920:                // no break;
        !          17921:        case ANY:
        !          17922:        any:
        !          17923:                tp = any_type;
        !          17924:                return this;
        !          17925:        case FCT:
        !          17926:                if (tt->base == PTR && Pptr(tt)->typ->base != FCT)
        !          17927:                        error('w',"P toF cast toP to nonF");
        !          17928:                break;
        !          17929:        case OVERLOAD:
        !          17930:        over:
        !          17931:                error("cast of overloaded");
        !          17932:                goto any;
        !          17933:        }
        !          17934: 
        !          17935: //error('d',"tt %t",tt);
        !          17936:        switch (tt->base) {
        !          17937:        case PTR:
        !          17938:                if (Pptr(tt)->typ->base==FCT && Pptr(tt)->memof) {
        !          17939:                        if (etp->base!=PTR
        !          17940:                        || Pptr(etp)->typ->base!=FCT
        !          17941:                        || Pptr(etp)->memof==0)
        !          17942:                                error("cast toP toM %t",tt);
        !          17943:                        else {  // adjust delta in MI case
        !          17944:                                // for the moment just suppress the cast
        !          17945:                                // all pmfs are the same to cc
        !          17946: /*
        !          17947:                                Pclass c1 = Pptr(tt)->memof;
        !          17948:                                Pclass c2 = Pptr(etp)->memof;
        !          17949: */
        !          17950:                                ptom_cast = 1;
        !          17951:                                tp2 = void_type;
        !          17952:                        }
        !          17953:                }
        !          17954: 
        !          17955:                switch (etp->base) {
        !          17956:                case COBJ:
        !          17957:                        error("cannot castCO toP");
        !          17958:                        break;
        !          17959:                case FCT:
        !          17960:                        e1 = new expr(G_ADDROF,0,e1);
        !          17961:                        bound = b;
        !          17962:                        e1 = e1->typ(tbl);
        !          17963:                        bound = 0;
        !          17964:                        if (e1->base == CAST)
        !          17965:                                pmf = 1;
        !          17966:                        else
        !          17967:                                break;
        !          17968:                        // no break;
        !          17969: 
        !          17970:                case PTR:
        !          17971:                {       Pname cn = Pptr(tt)->typ->is_cl_obj();
        !          17972:                        if (cn) {
        !          17973:                                Pexpr x = cast_cptr(Pclass(cn->tp),e1,tbl,1);
        !          17974: 
        !          17975:                                if (x == e1) {
        !          17976:                                        PERM(tt);
        !          17977:                                        e1 = new cast(tt,e1);
        !          17978:                                        e1->i2 = i2;
        !          17979:                                }
        !          17980:                                else
        !          17981:                                        e1 = x;
        !          17982:                        }
        !          17983:                        if (pmf) {
        !          17984:                                while(tt->base == TYPE)
        !          17985:                                        tt = Pbase(tt)->b_name->tp;
        !          17986: 
        !          17987:                                switch (tt->base) {
        !          17988:                                case PTR:
        !          17989:                                        if (Pptr(tt)->memof) break;
        !          17990:                                default:
        !          17991:                                        error("%t cast to%t (%t is not aP toM)",e1->tp,tp2,tp2);
        !          17992:                                }
        !          17993:                        }
        !          17994:                }
        !          17995:                }
        !          17996:                break;
        !          17997: 
        !          17998:        case RPTR:              // (x&)e: pretend e is an x
        !          17999:        {       Ptype er = etp;
        !          18000:                Ptype cr = tt;
        !          18001:                do {
        !          18002:                        if (er = er->is_ptr_or_ref()) er = Pptr(er)->typ;
        !          18003:                        if (cr = cr->is_ptr_or_ref()) cr = Pptr(cr)->typ;
        !          18004:                } while (er && cr);
        !          18005:                int pp = er!=0; //      if `e' is a suitable pointer cast it:
        !          18006:                                //      (x&)e => (x*)e, otherwise
        !          18007:                                //      (x&)e => *(x*)&e
        !          18008: // error('d',"rptr tt %t e1->base %k e1->tp %t",tt,e1->base,e1->tp);
        !          18009:        //      if (Pptr(tt)->typ->tsizeof()>etp->tsizeof()) goto zse;
        !          18010:        // we need to be able to ``raise the type'' from base to derived
        !          18011:        //      if (etp->is_cl_obj() && Pptr(tt)->typ->is_cl_obj()==0) goto zse;
        !          18012: 
        !          18013:                if (e1->base==G_CM
        !          18014:                || e1->base==CALL
        !          18015:                || e1->base==G_CALL
        !          18016:                || e1->lval(0))
        !          18017:                        ;
        !          18018:                else if (e1->tp->tconst()) {
        !          18019:                                // casting away const
        !          18020:                                // should be an error
        !          18021:                                // but ANSI says OK so I chicken out
        !          18022:                                // to be able to compile strtok(), etc.
        !          18023:                        if (warning_opt && Pptr(tt)->typ->tconst()==0)
        !          18024:                                error('w',"const cast away:%t->%t",e1->tp,tp2);
        !          18025: 
        !          18026:                }
        !          18027:                else
        !          18028:                        error("cannot cast%t to%t",etp,t);
        !          18029: //error('d',"e1 %k %t %d",e1->base,e1->tp,pp);
        !          18030:                if (pp == 0) e1 = e1->address();        // *(x*)&e
        !          18031:                tp = t;
        !          18032: 
        !          18033:                // do proper pointer manipulation for multiple inheritance
        !          18034:                Pname cn = Pptr(tt)->typ->is_cl_obj();
        !          18035:                if (cn) {
        !          18036:                        Pexpr x = cast_cptr(Pclass(cn->tp),e1,tbl,1);
        !          18037: 
        !          18038:                        if (x == e1) {
        !          18039:                                PERM(tt);
        !          18040:                                e1 = new cast(tt,e1);
        !          18041:                                e1->i2 = i2;
        !          18042:                        }
        !          18043:                        else
        !          18044:                                e1 = x;
        !          18045:                }
        !          18046: 
        !          18047:                return pp ? this : contents();
        !          18048: //     zse:
        !          18049: //             error("cannot cast%t to%t",etp,t);
        !          18050: //             tp2 = tt = any_type;
        !          18051: //             break;
        !          18052:        }
        !          18053:        case COBJ:
        !          18054:                base = VALUE;   // (x)e => x(e): construct an x from e
        !          18055:                e1 = new expr(ELIST,e1,0);
        !          18056:                return typ(tbl);
        !          18057: 
        !          18058:        case CHAR:
        !          18059:        case INT:
        !          18060:        case SHORT:
        !          18061:        case LONG:
        !          18062:                switch (etp->base) {
        !          18063:                case FCT:
        !          18064:                        e1 = new expr(ADDROF,0,e1);
        !          18065:                        e1 = e1->typ(tbl);
        !          18066:                        //etp = e1->tp;
        !          18067:                case PTR:
        !          18068:                        if(!e1->tp->memptr() && e1->tp->tsizeof()>tt->tsizeof())
        !          18069:                                error("type ``%t'' not large enough for values of ``%t ''",tt,etp);
        !          18070:                        break;
        !          18071:                case COBJ:
        !          18072:                        error("cannot castCO to%k",tt->base);
        !          18073:                        break;
        !          18074:                }       
        !          18075:                break;
        !          18076: 
        !          18077:        case FLOAT:
        !          18078:        case DOUBLE:
        !          18079:        case LDOUBLE:
        !          18080:                switch (etp->base) {
        !          18081:                case FLOAT:
        !          18082:                case DOUBLE:
        !          18083:                case LDOUBLE:
        !          18084:                case CHAR:
        !          18085:                case INT:
        !          18086:                case SHORT:
        !          18087:                case LONG:
        !          18088:                case EOBJ:
        !          18089:                case ZTYPE:
        !          18090:                        break;
        !          18091:                default:
        !          18092:                        error("cannot cast ``%t '' to ``%t''",etp,tt);
        !          18093:                        break;
        !          18094:                }       
        !          18095:                break;
        !          18096: 
        !          18097:        case FCT:
        !          18098:                error("cannot cast toFT");
        !          18099:                break;
        !          18100:        }
        !          18101: 
        !          18102:        tp = t;
        !          18103: 
        !          18104:        if (e1->base==ILIST && ptom_cast==0) { // pointer to member constant
        !          18105:                Pexpr ee = e1->e1;      // ELIST
        !          18106:                int i;
        !          18107:                switch (ee->e2->base) {
        !          18108:                case IVAL:
        !          18109:                        i = int(ee->e2->i1);
        !          18110:                        break;
        !          18111:                case ZERO:
        !          18112:                        i = 0;
        !          18113:                }
        !          18114: 
        !          18115:                if (i<0)
        !          18116:                        e1 = e1->e2;    // just the function
        !          18117:                else
        !          18118:                        e1 = ee->e2;    // just the index
        !          18119:                return this;
        !          18120:        }
        !          18121: 
        !          18122:        if (etp->base==PTR && Pptr(etp)->memof && Pptr(etp)->typ->base==FCT) {
        !          18123:                Pclass cl = Pptr(etp)->memof;
        !          18124: 
        !          18125:                if (Pptr(tt)->memof==0 && b == 0 ) {
        !          18126:                        Pexpr y = new mdot("f",e1);
        !          18127:                        y->i1 = 9;
        !          18128:                        y = new cast(tt,y);
        !          18129:                        if (cl->virt_count && b==0) {
        !          18130:                                // ERROR: no check for side effects
        !          18131:                                Pexpr z = new mdot("i",e1);
        !          18132:                                Pexpr x = new mdot("i",e1);
        !          18133:                                x->i1 = 9;
        !          18134:                                x = new cast(tt,x);
        !          18135:                                z->i1 = 9;
        !          18136:                                Pexpr q = new expr (QUEST,x,y);
        !          18137:                                q->cond = new expr(LE,zero,z);
        !          18138:                                q->tp = tt;
        !          18139:                                delete this;
        !          18140:                                return q;
        !          18141:                        }
        !          18142:                        delete this;
        !          18143:                        return y;
        !          18144:                }
        !          18145:        }
        !          18146: 
        !          18147:        return this;
        !          18148: }
        !          18149: 
        !          18150: Pexpr expr::dovalue(Ptable tbl)
        !          18151: {
        !          18152:        Ptype tt = tp2;
        !          18153:        Pclass cl;
        !          18154:        Pname cn;
        !          18155: 
        !          18156: //error('d',"value %d %t e1 %d e2 %d",tt,tt,e1,e2);
        !          18157:        
        !          18158:        tt->dcl(tbl);
        !          18159: 
        !          18160:        while(tt->base == TYPE)
        !          18161:                tt = Pbase(tt)->b_name->tp;
        !          18162: 
        !          18163:        switch (tt->base) {
        !          18164:        case EOBJ:
        !          18165:        default:
        !          18166:                if (e1 == 0) {
        !          18167:                        error("value missing in conversion to%t",tt);
        !          18168:                        return dummy;
        !          18169:                }
        !          18170:                base = CAST;
        !          18171:                e1 = e1->e1;    // strip ELIST
        !          18172:                return typ(tbl);
        !          18173: 
        !          18174:        case CLASS:
        !          18175:                cl = Pclass(tt);
        !          18176:                tp2 = Pptr(cl->this_type)->typ;
        !          18177:                break;
        !          18178: 
        !          18179:        case COBJ:
        !          18180:                cn = Pbase(tt)->b_name;
        !          18181:                cl = Pclass(cn->tp);
        !          18182:        }
        !          18183: 
        !          18184: //error('d',"e1 %k e1->e2 %k",e1->base,e1?e1->e2->base:0);
        !          18185:        if (e1 && e1->e2==0) {          // single argument
        !          18186:                if (e1->e1->base==ELIST) e1->e1 = e1->e1->e1;   // spurious elist
        !          18187:                e1->e1 = e1->e1->typ(tbl);
        !          18188:                if (tt->base==COBJ) {
        !          18189:                        Pexpr x = try_to_coerce(tt,e1->e1,"type conversion",tbl);
        !          18190:                        if (x) return x;
        !          18191:                }
        !          18192: 
        !          18193:                Pname acn = e1->e1->tp->is_cl_obj();
        !          18194: //error('d',"acn %n %d",acn,cl->has_itor());
        !          18195:                if (acn && cl->has_itor()==0) {
        !          18196:                        Pclass acl = Pclass(acn->tp);
        !          18197:                        int hb = acl->has_base(cl);
        !          18198: 
        !          18199:                        if (acl==cl || hb) {
        !          18200:                                vcllist->clear();
        !          18201:                                vcllist=0;
        !          18202:                                if (1<is_unique_base(acl,cl->string,0)) error("ambiguous assignment to base %t",cl);
        !          18203:                                Pexpr ee = e1->e1;
        !          18204:                                if (ee->base == ELIST) ee = ee->e1;     // ???
        !          18205:                                if (hb) {       // ee => *(tp2*)&ee
        !          18206:                                                // remember = may be overloaded
        !          18207: //error('d',"hb %k %t %d",ee->base,ee->tp,ee->lval(0));
        !          18208:                                        ignore_const++;
        !          18209:                                        if (ee->lval(0)==0) {
        !          18210:                                                Pname tmp = make_tmp('T',ee->tp,tbl);
        !          18211:                                                ee = init_tmp(tmp,ee,tbl);
        !          18212:                                                ee = new expr(G_CM,ee,tmp->address());
        !          18213:                                        }
        !          18214:                                        else
        !          18215:                                                ee = ee->address();
        !          18216:                                        ignore_const--;
        !          18217:                                        ee = new texpr(CAST,new ptr(PTR,tp2),ee); //new cast(new ptr(PTR,tp2),ee);
        !          18218:                                        ee = ee->contents();
        !          18219:                                        ee->typ(tbl);
        !          18220:                                }
        !          18221: 
        !          18222:                                if (e2) {       // x(x_obj) => e2=x_obj
        !          18223:                                        base = ASSIGN;
        !          18224:                                        e1 = e2;
        !          18225:                                        e2 = ee;
        !          18226:                                        tp = tp2;
        !          18227:                                        return this;
        !          18228:                                }
        !          18229:                                return ee;      // strip ELIST: x(x_obj) => x_obj
        !          18230:                        }
        !          18231:                }
        !          18232:        }
        !          18233: 
        !          18234: 
        !          18235:        /* x(a) => obj.ctor(a); where e1==obj */
        !          18236:        Pname ctor = cl->has_ctor();
        !          18237:        if (ctor == 0) {
        !          18238:                error("cannot make a%t",cl);
        !          18239:                return dummy;
        !          18240:        }
        !          18241: 
        !          18242: // error('d',"e2 %k",e2?e2->base:0);
        !          18243: // error('d',"refd: %d const_ptr: %d", refd, const_ptr);
        !          18244:        if (e2 == 0) {          // x(a) => x temp; (temp.x(a),temp)
        !          18245: /* incomplete condition
        !          18246:                if ( refd && const_ptr == 0) {
        !          18247:                        if ( tbl == gtbl ) {
        !          18248:                                error("Ir forG non-constCR not an lvalue");
        !          18249:                        }
        !          18250:                        else    
        !          18251:                        if (strict_opt) 
        !          18252:                                error("Ir for non-constCR not an lvalue");
        !          18253:                        else
        !          18254:                        if (warning_opt) 
        !          18255:                                error('w', "Ir for non-constR not an lvalue (anachronism)");
        !          18256:                        }
        !          18257: */
        !          18258:        
        !          18259:                no_sti = 1;
        !          18260:                Pname n = make_tmp('V',tp2,tbl);
        !          18261:                no_sti = 0;
        !          18262:                n->assign();
        !          18263:                if (tbl == gtbl) n->dcl_print(0);       // a hack
        !          18264:                Pexpr c = call_ctor(tbl,n,ctor,e1,DOT);
        !          18265:                c = new expr(G_CM,c,n);
        !          18266:                c->tp = n->tp;
        !          18267: //error('d',"tp1 %t",c->tp);
        !          18268:                return c;
        !          18269:        }
        !          18270:        else {
        !          18271:                Pexpr c = call_ctor(tbl,e2,ctor,e1,DOT);
        !          18272:                c = new expr(DEREF,c,0); // deref value returned by constructor
        !          18273:                c->tp = c->e1->tp;
        !          18274: //error('d',"tp2 %t",c->tp);
        !          18275:                return c;
        !          18276:        }
        !          18277: }
        !          18278: 
        !          18279: 0707071010112044311004440001630000160000010201300466055402500000700000074341find.c/*ident     "@(#)ctrans:src/find.c  1.5" */
        !          18280: /******************************************************************
        !          18281: 
        !          18282:        C++ source for cfront, the C++ compiler front-end
        !          18283:        written in the computer science research center of Bell Labs
        !          18284: 
        !          18285:        Copyright (c) 1986 AT&T, Inc. All Rights Reserved
        !          18286:        THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T, INC.
        !          18287: 
        !          18288: find.c:
        !          18289: 
        !          18290:        name lookup and visibility checks
        !          18291: 
        !          18292: *******************************************************************/
        !          18293: 
        !          18294: #include "cfront.h"
        !          18295: 
        !          18296: Pname undef(Pname n, Ptable tbl, TOK f)
        !          18297: {
        !          18298:        switch (f) {
        !          18299:        case CCON:
        !          18300:                error("illegalF call: explicit call ofK %s()",n->string);
        !          18301:                break;
        !          18302:        case 0:         error("%nU",n);                 break;
        !          18303:        case CALL:      error("UF%n called",n);         break;
        !          18304:        case REF:
        !          18305:        case DOT:       error("M%nU",n);                break;
        !          18306:        case ADDROF:    error("address ofU%n",n);       break;
        !          18307:        }
        !          18308: 
        !          18309:        if (tbl == gtbl) {
        !          18310:                Pname nn = tbl->insert(n,0);
        !          18311:                if (f == CALL) {
        !          18312:                        nn->tp = new fct(defa_type,0,0);
        !          18313:                        nn->n_sto = nn->n_scope = EXTERN;
        !          18314:                }
        !          18315:                else
        !          18316:                        nn->tp = any_type;
        !          18317:                delete n;
        !          18318:                return nn;
        !          18319:        }
        !          18320:        
        !          18321:        n->n_table = tbl;
        !          18322:        n->tp = any_type;
        !          18323:        return n;
        !          18324: }
        !          18325: 
        !          18326: 
        !          18327: 
        !          18328: static int mptr;       // &C::m
        !          18329: static Pname me;       // name of fct requesting access to name using find_name()
        !          18330: static Pfct mef;       // fct requesting access to name using find_name()
        !          18331: Pclass tcl;            // class of original ``this''
        !          18332: Pclass mec;            // class requesting access to name using find_name()
        !          18333: int mex;
        !          18334: 
        !          18335: Ptable lcl_tbl = 0;    // handle local function reference of local const for dimen size
        !          18336: 
        !          18337: 
        !          18338: Pexpr find_name(Pname n, Pclass cl, Ptable tbl, int f, Pname m)
        !          18339: /*
        !          18340:        in function ``m'' find the true name for "n",
        !          18341:        implicitly define if undefined
        !          18342: 
        !          18343:        f==CALL:        n()             cl == cc->cot
        !          18344:        f==REF:         p->n            cl == class of *p
        !          18345:        f==DOT:         obj.n           cl == class of obj
        !          18346:        f==ADDROF:      &n              cl == cc->cot
        !          18347:        f==0            n               (none of the above)
        !          18348: 
        !          18349:        "tbl" defines local scope (block or global)
        !          18350: 
        !          18351: */
        !          18352: {
        !          18353:        if ( n == 0 ) error('i',"find_name(n==0,cl==%t,tbl==%d,f==%k,m==%n)",cl,tbl,f,m);
        !          18354:        Pname q = n->n_qualifier;
        !          18355:        char* s = n->string;
        !          18356:        Pexpr ee;
        !          18357:        DB( if(Ddebug>=3) {
        !          18358:                error('d',"find_name %s::%s cl %t",q?q->string:"",s,cl);
        !          18359:                error('d',"     f %d m %n",f,m);
        !          18360:                if(q&&q->tp&&q->tp->base==COBJ)
        !          18361:                        fprintf(stderr," -- cb==%d\n",Pclass(q->tp)->c_body);
        !          18362:        });
        !          18363: 
        !          18364:        tcl = cl;
        !          18365: 
        !          18366:        //if (n) {
        !          18367:                mex = 1;
        !          18368:                if (me = m) {
        !          18369:                        mef = Pfct(me->tp);
        !          18370:                         if (mef->base!=FCT) 
        !          18371:                                 error('i',"mef %d %k",mef,mef->base);
        !          18372:                        mec = mef->memof;
        !          18373:                }
        !          18374:                else {
        !          18375:                        mef = 0;
        !          18376:                        mec = cl;
        !          18377:                }
        !          18378:        //}
        !          18379:        //else
        !          18380:        //      mex = 0;
        !          18381: 
        !          18382:        if (n->base == MDOT) error('i',"find (mdot %n)",n);
        !          18383: 
        !          18384:        if (n->n_table) { me = 0; return n; }
        !          18385: 
        !          18386: //error('d',"q %n %t f %k",q,q?q->tp:0,f);
        !          18387:        if (q) {                        // qualified name:      q::s
        !          18388: 
        !          18389:                if (q == sta_name) {    // explicitly global:   ::s
        !          18390:                        Pname nn = gtbl->look(s,0);
        !          18391:                        if (nn == 0) { me = 0; return undef(n,gtbl,f); }
        !          18392:                        nn->use();
        !          18393:                        delete n;
        !          18394:                        me = 0;
        !          18395:                        return nn;
        !          18396:                }
        !          18397: 
        !          18398:                {
        !          18399:                  Pname aq = q; // actual q
        !          18400:                  while ( aq->tp->base == TYPE ) aq = Pbase(aq->tp)->b_name;
        !          18401:                  if (aq->tp->base != COBJ) {
        !          18402:                    error("Qr%nnot aCN",q);
        !          18403:                    me = 0;
        !          18404:                    return undef(n,gtbl,f);
        !          18405:                  }
        !          18406:                  q = aq;
        !          18407:                }
        !          18408:                Pclass qcl = Pclass(Pbase(q->tp)->b_name->tp);
        !          18409: 
        !          18410:                Pclass bcl = cl;
        !          18411: 
        !          18412:                if (cl==0 || f==ADDROF)
        !          18413:                        bcl = cl = qcl; // Pclass(Pbase(q->tp)->b_name->tp);
        !          18414:                else {
        !          18415:                //      if (strcmp(q->string,cl->string)) {     // really a base?
        !          18416:                //              bcl = cl->is_base(q->string);
        !          18417:                        if (strcmp(qcl->string,cl->string)) {   // really a base?
        !          18418:                                bcl = cl->is_base(qcl->string);
        !          18419:                                if (bcl == 0) {
        !          18420:                                        if (f==REF || f==DOT) {
        !          18421:                                                error("%s is not aBC of %t",q->string,cl);
        !          18422:                                                me = 0;
        !          18423:                                                return undef(n,cl->memtbl,7);
        !          18424:                                        }
        !          18425:                                        goto sss;
        !          18426:                                }
        !          18427:                                // else try in base or for static
        !          18428:                        }
        !          18429:                }
        !          18430: 
        !          18431:                if (f == ADDROF) mptr = 1;              // &C::m
        !          18432:                ee = cl->find_name(s,bcl==cl?0:bcl);    // really a member?
        !          18433:                mptr = 0;
        !          18434: 
        !          18435:                if (ee == 0) {
        !          18436:                sss:
        !          18437: //error('d',"sss %k",f);
        !          18438:                        if (f!=REF && f!=DOT) {
        !          18439:                                // try for static member of other class:
        !          18440:                                Pclass qcl = Pclass(Pbase(q->tp)->b_name->tp);
        !          18441:                                mptr = 1;
        !          18442:                                if ( cl && cl->csu == ANON ) {
        !          18443:                                        mec = (cc-1)->cot;
        !          18444:                                        ee = qcl->find_name(s,qcl);
        !          18445:                                } else
        !          18446:                                        ee = qcl->find_name(s,qcl);
        !          18447:                                mptr = 0;
        !          18448:                                if (ee && ee->base==NAME) {
        !          18449:                                //      switch (ee->tp->base) {
        !          18450:                                //      case FCT:
        !          18451:                                //      case OVERLOAD:
        !          18452:                                //              break;
        !          18453:                                //      default:
        !          18454:                                                delete n;
        !          18455:                                                me = 0;
        !          18456:                                                return ee;
        !          18457:                                //      }
        !          18458:                                }
        !          18459:                        }
        !          18460:                        error("QdN%n::%n not found in %t",q,n,cl);
        !          18461:                        me = 0;
        !          18462:                        return undef(n,bcl?bcl->memtbl:cl->memtbl,7);
        !          18463:                }
        !          18464: 
        !          18465:                if (ee->base==REF && ee->e1==0) {       // &C::f, no ``this''
        !          18466: //error('d',"ee %k %d f %k",ee->base,ee->e1,f);
        !          18467:                        switch (f) {
        !          18468:                        case 0:
        !          18469:                        case CALL:      //SSS
        !          18470:                                {       Pexpr mm = ee->mem;
        !          18471:                                        while (mm->base==REF || mm->base==MDOT) mm = mm->mem;
        !          18472:                                        if (mm->base==NAME)
        !          18473:                                                switch (mm->tp->base) {
        !          18474:                                                case FCT:
        !          18475:                                                case OVERLOAD:
        !          18476:                                                        goto addrof;
        !          18477:                                                default:
        !          18478:                                                        if (Pname(mm)->n_stclass == STATIC) goto addrof;
        !          18479:                                                }
        !          18480:                                }
        !          18481:                                error("O orOP missing forM%n",n);
        !          18482:                                        
        !          18483:                        case ADDROF:
        !          18484:                        addrof:
        !          18485:                                Pexpr x = ee;
        !          18486:                                ee = ee->mem;
        !          18487:                                delete x;
        !          18488:                        case REF:
        !          18489:                        case DOT:
        !          18490:                                break;
        !          18491:                        default:
        !          18492:                                error("QdN%n::%n used in nonC context",q,n);
        !          18493:                        }
        !          18494:                }
        !          18495: 
        !          18496:                delete n;
        !          18497:                me = 0;
        !          18498:                return ee;
        !          18499:        }
        !          18500: 
        !          18501:        if (f!=DOT && f!=REF) { // not .s or ->s: look for local, global, and member
        !          18502: 
        !          18503:                Pname nn = tbl->look(s,0);
        !          18504:                if (nn) {       // local, global, or member
        !          18505:                        if (nn->n_table->t_name) {      // global or member
        !          18506:                                if (cl) {               // might be member
        !          18507:                                        if ((ee = cl->find_name(s,0))==0 &&
        !          18508:                                                cl->in_class) 
        !          18509:                                        { // nested class
        !          18510:                                                Pclass nstd_cl = cl->in_class;
        !          18511:                                                for (; nstd_cl; nstd_cl=nstd_cl->in_class) 
        !          18512:                                                {
        !          18513: // error( 'd', "find_name( %s ): nested class %t",s,nstd_cl ); 
        !          18514:                                                        if (ee=nstd_cl->find_name(s,0)) 
        !          18515:                                                        {
        !          18516:                                                                if ( cl->nested_sig == 0 ) {
        !          18517:                                                                        error('w',"%s, accessed within nestedC%t, is visible bothGly and within enclosingC%t -- using %n (anachronism)", s, cl, nstd_cl, nn );
        !          18518:                                                                        ee = 0;
        !          18519:                                                                }
        !          18520:                                                                break;
        !          18521:                                                        }
        !          18522:                                                }       
        !          18523:                                        } // nested class
        !          18524:                                
        !          18525:                                        if ( ee ) 
        !          18526:                                        {  // class member name
        !          18527:                                                if (ee->base==REF && ee->e1==0 )
        !          18528:                                                {
        !          18529:                                                        Pexpr mm = ee->mem;
        !          18530:                                                        while (mm->base==REF || mm->base==MDOT) mm = mm->mem;
        !          18531:                                                        if (mm->base==NAME)
        !          18532:                                                                switch (mm->tp->base) {
        !          18533:                                                                default:
        !          18534:                                                                        if (Pname(mm)->n_stclass != STATIC)
        !          18535:                                                                                break;
        !          18536:                                                                case FCT:
        !          18537:                                                                case OVERLOAD:
        !          18538:                                                                        delete n;
        !          18539:                                                                        me = 0;
        !          18540:                                                                        return mm;
        !          18541:                                                                }
        !          18542:                                                        error("O orOP missing for%n",Pref(ee)->mem);
        !          18543:                                                }
        !          18544:                                                delete n;
        !          18545:                                                me = 0;
        !          18546:                                                return ee;
        !          18547:                                          }  // if ee
        !          18548:                                }  // if cl
        !          18549:                        } // else local, global, or member
        !          18550: 
        !          18551:                        nn->use();
        !          18552:                        delete n;
        !          18553:                        me = 0;
        !          18554:                        return nn;
        !          18555:                }
        !          18556: 
        !          18557:                if (cl) {
        !          18558:                        if ( cl->csu == ANON ) {
        !          18559:                                mec = (cc-1)->cot;
        !          18560:                                ee = (cc-1)->cot->find_name(s,0);
        !          18561:                        } else
        !          18562:                                ee = cl->find_name(s,0);
        !          18563:                        if (ee) {
        !          18564:                        if (ee->base==REF && ee->e1==0) {
        !          18565:                                Pexpr mm = ee->mem;
        !          18566:                                while (mm->base==REF || mm->base==MDOT) mm = mm->mem;
        !          18567:                                if (mm->base==NAME)
        !          18568:                                        switch (mm->tp->base) {
        !          18569:                                        default:
        !          18570:                                                if (Pname(mm)->n_stclass != STATIC)
        !          18571:                                                        break;
        !          18572:                                        case FCT:
        !          18573:                                        case OVERLOAD:
        !          18574:                                                delete n;
        !          18575:                                                me = 0;
        !          18576:                                                return mm;
        !          18577:                                        
        !          18578:                                        }
        !          18579:                                error("O orOP missing for%n",Pref(ee)->mem);
        !          18580:                        }
        !          18581:                                delete n;
        !          18582:                                me = 0;
        !          18583:                                return ee;
        !          18584:                        }
        !          18585:                }
        !          18586: 
        !          18587:                if ( lcl_tbl && (nn=lcl_tbl->look(s,0)) ) {
        !          18588:                        nn->use();
        !          18589:                        delete n;
        !          18590:                        me = 0;
        !          18591:                        return nn;
        !          18592:                }
        !          18593: 
        !          18594:                if (nn = gtbl->look(s,0)) {     // global
        !          18595:                        nn->use();
        !          18596:                        delete n;
        !          18597:                        me = 0;
        !          18598:                        return nn;
        !          18599:                }
        !          18600: 
        !          18601:                me = 0;
        !          18602:                return undef(n,gtbl,f);
        !          18603:        }
        !          18604: 
        !          18605:        if (ee = cl->find_name(s,cl)) { // .s or ->s
        !          18606:                delete n;
        !          18607:                me = 0;
        !          18608:                return ee;
        !          18609:        }
        !          18610: 
        !          18611:        if(!strcmp(s,cl->string)) {
        !          18612:                me = 0;
        !          18613:                return undef(n,gtbl,CCON);
        !          18614:        }
        !          18615: 
        !          18616:        me = 0;
        !          18617:        return undef(n,gtbl,f);
        !          18618: }
        !          18619: 
        !          18620: int classdef::check_dup(Pclass cl, TOK bb)
        !          18621: /*
        !          18622:         see if cl is a base of this; return 0 if no clash
        !          18623: */
        !          18624: {
        !          18625:        for (Pbcl b = baselist; b; b=b->next) {
        !          18626:                if (cl == b->bclass) {
        !          18627:                        if (bb!=VIRTUAL) {
        !          18628:                                if (b->base==VIRTUAL)
        !          18629:                                        error('w',"%t inaccessible because of virtual%t in%t",cl,cl,this);
        !          18630:                                else
        !          18631:                                        error('w',"%t inaccessible because of%t in%t",cl,cl,this);
        !          18632:                                return 1;
        !          18633:                        }
        !          18634:                        else if (b->base!=VIRTUAL) {
        !          18635:                                error('w',"virtual %t inaccessible because of%t in%t",cl,cl,this);
        !          18636:                                return 1;
        !          18637:                        }
        !          18638:                }
        !          18639:                if (b->bclass->check_dup(cl,bb)) return 1;
        !          18640:        }
        !          18641:        return 0;
        !          18642: }
        !          18643: 
        !          18644: 
        !          18645: int Nvis;
        !          18646: TOK Nvirt;
        !          18647: TOK ppbase;
        !          18648: 
        !          18649: Pclass classdef::is_base(char* s)
        !          18650: /*
        !          18651:        is "s" a public base class of this?
        !          18652: */
        !          18653: {
        !          18654: //error('d',"%s->is_base(%s) %k",string,s,ppbase);
        !          18655:        TOK pp = ppbase;
        !          18656:        for (Pbcl b = baselist; b; b=b->next) {
        !          18657: /*
        !          18658:                if (b->ppp!=PUBLIC
        !          18659:                && cc->cot!=this
        !          18660:                && (cc->nof==0 || this->has_friend(Pfct(cc->nof->tp))==0))
        !          18661:                        ppbase = b->ppp<pp?pp:b->ppp;   // PUBLIC<PROTECTED<PRIVATE
        !          18662: */
        !          18663:                if (strcmp(s,b->bclass->string) == 0) {
        !          18664:                if (b->ppp!=PUBLIC
        !          18665:                && cc->cot!=this
        !          18666:                && (cc->nof==0 || this->has_friend(Pfct(cc->nof->tp))==0))
        !          18667:                        ppbase = b->ppp<pp?pp:b->ppp;   // PUBLIC<PROTECTED<PRIVATE
        !          18668:                        Nvirt = b->base;
        !          18669:                        return b->bclass;
        !          18670:                }
        !          18671:                else {
        !          18672:                        Pclass bc = b->bclass->is_base(s);
        !          18673:                        if (bc) {
        !          18674:                if (b->ppp!=PUBLIC
        !          18675:                && cc->cot!=this
        !          18676:                && (cc->nof==0 || this->has_friend(Pfct(cc->nof->tp))==0))
        !          18677:                        ppbase = b->ppp<pp?pp:b->ppp;   // PUBLIC<PROTECTED<PRIVATE
        !          18678:                                return bc;
        !          18679:                        }
        !          18680:                }
        !          18681:        }
        !          18682:        ppbase = pp;
        !          18683:        return 0;
        !          18684: }
        !          18685: 
        !          18686: bit classdef::has_base(Pclass cl)
        !          18687: /*
        !          18688:        is "cl" a base of this?
        !          18689: */
        !          18690: {
        !          18691: // error('d', "%t->has_base( %t ) cc->cot: %t", this, cl, cc->cot?cc->cot:0 );
        !          18692: 
        !          18693:        if (this == 0) return 0;
        !          18694:        for (Pbcl b = baselist; b; b=b->next) {
        !          18695: // error('d', "b: %t ppp: %k", b->bclass, b->ppp );
        !          18696:                if (b->bclass==cl) {
        !          18697:                        if (b->ppp!=PUBLIC
        !          18698:                        && cc->cot!=this
        !          18699:                        && (cc->nof==0 ||
        !          18700:                                this->has_friend(Pfct(cc->nof->tp))==0) 
        !          18701:                        && this->has_friend(cc->cot)==0)
        !          18702:                                Nvis = 1;       // no standard coercion
        !          18703:                        Nvirt = b->base;
        !          18704:                        return 1;
        !          18705:                }
        !          18706:                if (b->bclass->has_base(cl)) return 1;
        !          18707:        }
        !          18708:        return 0;
        !          18709: }
        !          18710: 
        !          18711: int Noffset;
        !          18712: Pexpr Nptr;
        !          18713: char *Nalloc_base;
        !          18714: clist* vcllist;
        !          18715: 
        !          18716: int clist::onlist(Pclass c)
        !          18717: {
        !          18718:        for (clist* p = this; p; p = p->next)
        !          18719:                if (p->cl == c) return 1;
        !          18720:        return 0;
        !          18721: }
        !          18722: 
        !          18723: void clist::clear()
        !          18724: {
        !          18725:        if (this == 0) return;
        !          18726:        clist* p = next;
        !          18727:        while (p) {
        !          18728:                clist* q = p->next;
        !          18729:                delete p;
        !          18730:                p = q;
        !          18731:        };
        !          18732:        delete this;
        !          18733: }
        !          18734: 
        !          18735: Pbcl Nvbc_alloc;
        !          18736: int is_unique_base(Pclass cl, char* s, int offset, int in_base )
        !          18737: /*
        !          18738:        is "s" a unique base class of this?
        !          18739: */
        !          18740: {
        !          18741:        int i = 0;
        !          18742:        static Pclass priSeen = 0;
        !          18743: // error('d',"is_unique_base(cl: %t, s: %s,%d,%d)",cl,s,offset,in_base);
        !          18744:        for (Pbcl b = cl->baselist; b; b=b->next) {
        !          18745:                int no = 0;
        !          18746:                if (b->base!=VIRTUAL)
        !          18747:                        no = offset + b->obj_offset;
        !          18748:                else if (in_base)
        !          18749:                        continue;
        !          18750:                if (strcmp(s,b->bclass->string) == 0) {
        !          18751:                        Noffset = no;
        !          18752:                        i++;
        !          18753:                        if ((b->ppp!=PUBLIC || priSeen )
        !          18754:                                && (cc->cot!=cl || cc->cot != priSeen )
        !          18755:                                && (cc->nof==0 || cl->has_friend(Pfct(cc->nof->tp))==0)
        !          18756:                                        || (priSeen && priSeen->has_friend(Pfct(cc->nof->tp))==0))
        !          18757:                                                Nvis = 1;       // no standard coercion
        !          18758: 
        !          18759:                        if (b->base==VIRTUAL) {
        !          18760:                                Nptr = new mdot(s,0);
        !          18761:                                if (b->allocated == 0) {
        !          18762:                                        Nvbc_alloc = 0;
        !          18763:                                        Nalloc_base = cl->has_allocated_base(s);
        !          18764:                                }
        !          18765:                        }
        !          18766:                }
        !          18767:                else {
        !          18768:                        if (b->base==VIRTUAL) {
        !          18769:                                if (vcllist->onlist(b->bclass) )continue;
        !          18770:                                vcllist = new clist(b->bclass,vcllist);
        !          18771:                        }
        !          18772: 
        !          18773:                        Pclass clscope = 0;
        !          18774:                        if ( cc && cc->c_this ) {
        !          18775:                                Ptype t = Pptr(cc->c_this->tp)->typ;
        !          18776:                                clscope = Pclass(Pbase(t)->b_name->tp);
        !          18777:                        }
        !          18778: // error('d', "cl: %t %d clscope: %t %d", cl, cl, clscope, clscope);
        !          18779:                        if (b->ppp != PUBLIC && 
        !          18780:                                cl != clscope && priSeen == 0 ) priSeen = cl;
        !          18781: 
        !          18782:                        int ii = is_unique_base(b->bclass,s,no,1);
        !          18783:                        if (in_base == 0) priSeen = 0;
        !          18784: // error('d',"base %t i %d ii %d",b->bclass,i,ii);
        !          18785: // error('d',"base %t %k allocated: %d", b->bclass, b->base, b->allocated);
        !          18786:                        i += ii;
        !          18787:                        if (ii==1 && b->base==VIRTUAL) {
        !          18788:                                Nptr = new mdot(b->bclass->string,0);
        !          18789:                                if (b->allocated == 0) {
        !          18790:                                        Nvbc_alloc = 0;
        !          18791:                                        Nalloc_base = cl->has_allocated_base(b->bclass->string);
        !          18792:                                }
        !          18793:                        }
        !          18794:                }
        !          18795:        }
        !          18796: 
        !          18797:        return i;
        !          18798: }
        !          18799: 
        !          18800: /*
        !          18801: int classdef::has_allocated_base(Pclass bcl)
        !          18802: 
        !          18803:        search the list of !first base classes for this virtual base
        !          18804:        space will have been allocated in !first bases for virtual bases
        !          18805:        declared in !first classes
        !          18806: 
        !          18807:        in addition bcl may bave been specified explicitly as a base
        !          18808: 
        !          18809: {
        !          18810:        int off;
        !          18811:        for (Pbcl l = baselist; l; l=l->next) {
        !          18812:                if (l->base == VIRTUAL) continue; // another non-allocated virtual base
        !          18813:                if (l==baselist) continue;      // first base
        !          18814: 
        !          18815:                Pclass bc = l->bclass;
        !          18816:                off = l->obj_offset;
        !          18817: 
        !          18818:                for (Pbcl ll = bc->baselist; ll; ll=ll->next) {
        !          18819:                        // cannot share non-virtual base
        !          18820:                        if (ll->base != VIRTUAL) continue;
        !          18821:                        if (ll->bclass==bcl) return off + ll->obj_offset;
        !          18822:                }
        !          18823:        }
        !          18824:        return 0;
        !          18825: }
        !          18826: */
        !          18827: 
        !          18828: int classdef::has_allocated_base(Pclass bcl)
        !          18829: /*
        !          18830:        search the list of base classes for this virtual base
        !          18831:        space will be allocated in first virtual version found.
        !          18832:        return offset.
        !          18833: 
        !          18834:        A virtual base cannot have offset 0 (its pointer at least is ahead)
        !          18835: */
        !          18836: {
        !          18837: //error('d',"%t->has_allocated_base(%t) ",this,bcl);
        !          18838:        for (Pbcl l = baselist; l; l=l->next) {
        !          18839:                if (l->base==VIRTUAL
        !          18840:                && l->bclass==bcl
        !          18841:                && l->obj_offset)
        !          18842:                        return l->obj_offset;
        !          18843: 
        !          18844:                if (l->base==VIRTUAL || l!=baselist) {
        !          18845:                        // allocated as an object,
        !          18846:                        // not unravelled as a set of members
        !          18847:                        int i = l->bclass->has_allocated_base(bcl);
        !          18848:                        if (i) return l->obj_offset + i;
        !          18849:                }
        !          18850:        }
        !          18851:        return 0;
        !          18852: }
        !          18853: 
        !          18854: char *classdef::has_allocated_base(char *str) 
        !          18855: /*
        !          18856:  *     str is an unallocated virtual base class of this
        !          18857:  *     return the name of the second or subsequent base class 
        !          18858:  *             containing the member ``struct str *P<str>''
        !          18859:  */
        !          18860: {
        !          18861: // error('d',"%t::has_allocated_base(%s) baselist: %t",this,str,baselist->bclass);
        !          18862:        for (Pbcl l = baselist; l; l=l->next) {
        !          18863:                if (l->base == VIRTUAL) {
        !          18864:                        if ( l->allocated ) Nvbc_alloc = l; 
        !          18865:                        continue; 
        !          18866:                }
        !          18867: 
        !          18868:                Pclass bc = l->bclass;
        !          18869:                for (Pbcl ll = bc->baselist; ll; ll=ll->next) {
        !          18870:                        if (ll->base != VIRTUAL) continue;
        !          18871:                        if (ll->allocated && 
        !          18872:                            strcmp( str, ll->bclass->string) == 0 )
        !          18873:                                { 
        !          18874:                                        if (bc == baselist->bclass) {
        !          18875:                                                // NfirstBase=1; 
        !          18876:                                                return 0;
        !          18877:                                        }
        !          18878:                                        return bc->string;
        !          18879:                                }
        !          18880:                }
        !          18881:        }
        !          18882:        return 0;
        !          18883: }
        !          18884: 
        !          18885: /*
        !          18886: int allocated_base(Pclass cl,Pclass bcl)
        !          18887: {
        !          18888: static second;
        !          18889: int s2 = second;
        !          18890:        for (Pbcl l = cl->baselist; l; l=l->next) {
        !          18891:                if (l->base==VIRTUAL
        !          18892:                && l->bclass==bcl
        !          18893:                && l->obj_offset
        !          18894:                && (second || l!=cl->baselist)) return (second=s2,1);
        !          18895:                int i = allocated_base(l->bclass,bcl);
        !          18896:                if (i) return (second=s2,1);
        !          18897:                second = 1;
        !          18898:        }
        !          18899:        second = s2;
        !          18900:        return 0;
        !          18901: }
        !          18902: */
        !          18903: Pname vfct(Pclass cl, char* s)
        !          18904: /*
        !          18905:        Called for each name "s" in a vtbl for "cl"
        !          18906:        Find the "s" to go in the vtbl.
        !          18907:        The "s" that caused the vtbl entry to be created
        !          18908:                is found if nothing else is
        !          18909: */
        !          18910: {
        !          18911:        Pname n = cl->memtbl->look(s,0);
        !          18912:        if (n) return n;
        !          18913: 
        !          18914:        for (Pbcl b = cl->baselist; b; b=b->next) {
        !          18915:                Pname nn = vfct(b->bclass,s);
        !          18916:                if (nn) {
        !          18917: //error('d',"nn %nn",nn);
        !          18918:                        if (n && n!=nn) {
        !          18919:                                Pclass ncl = Pclass(n->n_table->t_name->tp);
        !          18920:                                Pclass nncl = Pclass(nn->n_table->t_name->tp);
        !          18921: //error('d',"ncl %t nncl %t",ncl,nncl);
        !          18922:                                if (nncl->is_base(ncl->string))
        !          18923:                                        n = nn;         // use nn
        !          18924:                        }
        !          18925:                        else
        !          18926:                                n = nn;
        !          18927:                }
        !          18928:        }
        !          18929: 
        !          18930:        return n;
        !          18931: }
        !          18932: 
        !          18933: Pexpr rptr(Ptype t, Pexpr p, int offset)
        !          18934: /*
        !          18935:        return rvalue of offset off pointer:
        !          18936:        (t)((char*)p+offset)
        !          18937: */
        !          18938: {
        !          18939:        if ( t == 0 ) error( 'i', "rptr(), t==0 (type passed for cast)" );
        !          18940:        Pexpr pp = p;
        !          18941: //error('d',"rptr %t %d",t,offset);
        !          18942:        if (offset) {
        !          18943:                Pexpr i = new ival(offset);
        !          18944:        //      pp = new texpr(CAST,Pchar_type,pp);
        !          18945:                pp = new cast(Pchar_type,pp);
        !          18946:                pp = new expr(PLUS,pp,i);
        !          18947:        }
        !          18948:        pp = new cast(t,pp);
        !          18949:        return pp;
        !          18950: }
        !          18951: /*
        !          18952: Pexpr lptr(Ptype t, Pexpr p, int offset)
        !          18953: 
        !          18954:        return lvalue of offset off pointer:
        !          18955:        *(t*)((char*)p+offset)
        !          18956: 
        !          18957: {
        !          18958:        Pexpr pp = p;
        !          18959:        if (offset) {
        !          18960:                Pexpr i = new ival(offset);
        !          18961:        //      pp = new texpr(CAST,Pchar_type,pp);
        !          18962:                pp = new cast(Pchar_type,pp);
        !          18963:                pp = new expr(PLUS,pp,i);
        !          18964:        }
        !          18965:        pp = new cast(t->addrof(),pp);
        !          18966:        pp = new expr(DEREF,pp,0);
        !          18967:        pp->tp = t;
        !          18968:        return pp;
        !          18969: }
        !          18970: */
        !          18971: int friend_check(Pclass start,Pclass stop, Pfct f)
        !          18972: /*
        !          18973:        is `f' a friend of a class between `start' and `stop'
        !          18974:        in a class DAG?
        !          18975: */
        !          18976: {
        !          18977: //error('d',"friend_check(%t,%t)",start,stop);
        !          18978:        
        !          18979:        if (start->has_friend(f)) return 1;
        !          18980:        if (stop == start) return 0;
        !          18981:        for (Pbcl b = start->baselist; b; b = b->next) {
        !          18982:                if (b->bclass->has_friend(f)) return 1;
        !          18983:                if (friend_check(b->bclass,stop,f)) return 1;
        !          18984:        }
        !          18985:        return 0;
        !          18986: }
        !          18987: 
        !          18988: bit classdef::has_friend(Pfct f)
        !          18989: /*
        !          18990:        does this class have function "f" as its friend?
        !          18991: */
        !          18992: {
        !          18993: // error('d',"%t->has_friend(%t) %d %d ",this,f,f,f->base);
        !          18994: 
        !          18995:        for (Plist l=friend_list; l; l=l->l) {
        !          18996:                Pname fr = l->f;
        !          18997:                Ptype frt = fr->tp;
        !          18998: //error('d',"frt %t %d %d",frt,frt,frt->base);
        !          18999:                switch (frt->base) {
        !          19000:                case FCT:
        !          19001:                        if (f == frt) return 1;
        !          19002:                        break;
        !          19003:                case OVERLOAD:
        !          19004:                        l->f = fr = Pgen(frt)->fct_list->f;     // first fct
        !          19005:                        if (fr->tp == f) return 1;
        !          19006:                case CLASS:
        !          19007:                        break;
        !          19008:                default:
        !          19009:                        error('i',"bad friend %k",fr->tp->base);
        !          19010:                }
        !          19011:        }
        !          19012:        return 0;
        !          19013: }
        !          19014: 
        !          19015: bit classdef::has_friend(Pclass cl)
        !          19016: /*
        !          19017:        does this class have class "cl" as its friend?
        !          19018: */
        !          19019: {
        !          19020: // error('d',"%t->has_friend(%t) ",this,cl);
        !          19021: 
        !          19022:        for (Plist l=friend_list; l; l=l->l) {
        !          19023:                Pname fr = l->f;
        !          19024:                Ptype frt = fr->tp;
        !          19025:                switch (frt->base) {
        !          19026:                case CLASS:
        !          19027: // error('d',"class friend: %t", frt);
        !          19028:                        if ((frt == cl) || cl->same_class(Pclass(frt))) 
        !          19029:                                return 1;
        !          19030:                case FCT:
        !          19031:                case OVERLOAD:
        !          19032:                        break;
        !          19033:                default:
        !          19034:                        {error('i',"bad friend %k",frt->base);}
        !          19035:                }
        !          19036:        }
        !          19037:        return 0;
        !          19038: }
        !          19039: 
        !          19040: Pname find_virtual(Pclass cl, Pname s)
        !          19041: /*
        !          19042:        does ``cl'' have a virtual function ``s'' in some base class
        !          19043: */
        !          19044: {
        !          19045:        for (Pbcl b = cl->baselist; b; b = b->next) {
        !          19046:                Pclass bcl = b->bclass;
        !          19047:                Pname n;
        !          19048:                if (n = bcl->memtbl->look(s->string,0)) {
        !          19049: // error('d', "find_virtual: n: %d base: %k", n, n->base );
        !          19050:                        if ( n->base == PUBLIC ) // x::foo;
        !          19051:                                continue;
        !          19052:                        Pfct f = Pfct(n->tp);
        !          19053:                        if (f->base == OVERLOAD) {
        !          19054:                                for (Plist gl=Pgen(f)->fct_list; gl; gl=gl->l) {
        !          19055:                                        n = gl->f;
        !          19056:                                        // if (f != s->tp) continue;
        !          19057:                                        // Replaced by:
        !          19058:                                        if (n->tp->check(s->tp,VIRTUAL)) continue;
        !          19059:                                        if (Pfct(n->tp)->f_virtual) return n;
        !          19060:                                }
        !          19061:                        }
        !          19062:                        // else if (f->f_virtual)
        !          19063:                        else if (f->f_virtual && n->tp->check(s->tp,VIRTUAL)==0)
        !          19064:                                return n;
        !          19065:                }
        !          19066:                else if (n = find_virtual(bcl,s))
        !          19067:                        return n;
        !          19068:        }
        !          19069:        return 0;
        !          19070: }
        !          19071: 
        !          19072: Pname dummy_fct;
        !          19073: 
        !          19074: static int 
        !          19075: is_accessible(Pname n, Pclass this_class, bit noCdcl = 0)
        !          19076: // 0 means n is not accessible to this_class
        !          19077: {
        !          19078: // error('d',"is_accessible(%n,%t)", n, this_class
        !          19079: // error('d',"%n: %k mef %t",n,n->n_protect,mef);
        !          19080: // error('d',"         this_class %d %t",this_class,this_class);
        !          19081: // error('d',"         mec  %d %t",mec,mec);
        !          19082: // error('d',"         tcl  %d %t",tcl,tcl);
        !          19083: // error('d',"mec->has_base(this_class) %d",mec?mec->has_base(this_class):0);
        !          19084: // error('d',"tcl->has_base(mec) %d",tcl?tcl->has_base(mec):0);
        !          19085: // error('d',"tcl->has_base(this_class) %d",tcl?tcl->has_base(this_class):0);
        !          19086: // error('d',"tcl->has_friend(mef) %d",tcl?tcl->has_friend(mef):0);
        !          19087: 
        !          19088:        if (this_class==mec || 
        !          19089:                (mec && this_class->has_friend(mec)) || 
        !          19090:                (mef && this_class->has_friend(mef)))
        !          19091:                        return 1;
        !          19092:        
        !          19093:        if ( n->n_protect && tcl ) {
        !          19094:                if ( mec ) 
        !          19095:                {
        !          19096:                        if ( tcl->has_friend(mec) ||
        !          19097:                                ( mec->has_base(this_class) && 
        !          19098:                                        (tcl==mec || tcl->has_base(mec))))
        !          19099:                                                return 1;
        !          19100:                }       
        !          19101: 
        !          19102:                if ( mef ) 
        !          19103:                {
        !          19104:                        if ( tcl->has_base(this_class) &&
        !          19105:                                // && tcl->has_friend(mef))
        !          19106:                                friend_check(tcl,this_class,mef))
        !          19107:                                        return 1;
        !          19108:                }
        !          19109:        }
        !          19110: 
        !          19111:        // call from check_visibility
        !          19112:        if ( noCdcl ) return 0; 
        !          19113:        
        !          19114:        if ( Cdcl && Cdcl->base == NAME && 
        !          19115:                Cdcl->n_stclass == STATIC && 
        !          19116:                Cdcl->n_initializer && 
        !          19117:                Cdcl->n_qualifier ) 
        !          19118:        {
        !          19119:                Pbase bn = Pbase(Cdcl->n_qualifier->tp);
        !          19120:                Pclass cl = Pclass(bn->b_name->tp);
        !          19121: 
        !          19122:                if ( cl == this_class ||
        !          19123:                        (n->n_protect && cl->has_base(this_class)) || 
        !          19124:                        cl->has_friend(this_class))
        !          19125:                                return 1;
        !          19126:        }
        !          19127: 
        !          19128:        return 0;
        !          19129: }
        !          19130: 
        !          19131: Pexpr classdef::find_name(char* s, Pclass cl, int access_only)
        !          19132: /*
        !          19133:        look for "s" in "this" class and its base classes
        !          19134:        if (cl)
        !          19135:                accept only a member of "cl" or "cl"'s base classes
        !          19136:                (that is cl::s was seen)
        !          19137: 
        !          19138:        complicated by hiding rules: private, protected, friend
        !          19139:        
        !          19140: */
        !          19141: {
        !          19142: // error('d',"%s->find_name(%s,%s) memtbl %d",string,s,cl?cl->string:"",memtbl);
        !          19143:        Pname n = memtbl->look(s,0);
        !          19144: 
        !          19145:        if (n) {
        !          19146:                if (n->tp) {
        !          19147:                        switch (n->tp->base) {
        !          19148:                        case OVERLOAD:
        !          19149:                                break;
        !          19150:                        case FCT:
        !          19151:                                if (Pfct(n->tp)->f_virtual==0) {
        !          19152:                                        if (n->n_dcl_printed==0) n->dcl_print(0);
        !          19153:                                        break;
        !          19154:                                }
        !          19155:                        default:
        !          19156:                                  if (c_body==1) dcl_print(0);
        !          19157:                        }
        !          19158:                }
        !          19159: 
        !          19160:                if (n->base == PUBLIC) {
        !          19161:                        if (mex && n->n_scope==0) {
        !          19162:                                if ( is_accessible(n,this) == 0 ) 
        !          19163:                                {
        !          19164:                                        if ( me == dummy_fct )
        !          19165:                                                error("G scope cannot access%n: %sM",n,n->n_protect?"protected":"private");
        !          19166:                                        else error("%n cannot access%n: %sM",me,n,n->n_protect?"protected":"private");
        !          19167:                                        mex = 0;        // suppress further error messages
        !          19168:                                }
        !          19169:                        }
        !          19170:                        mex = 0; // don't have find_in_base complain about n
        !          19171:                        return find_in_base(s, cl);
        !          19172:                }
        !          19173: 
        !          19174:                if (cl==0 || cl==this) {
        !          19175:                        if (mptr==0
        !          19176:                        && n->n_stclass!=STATIC
        !          19177:                        && n->n_stclass!=ENUM) {
        !          19178:                                Ptype t = n->tp;
        !          19179: 
        !          19180: // error('d',"cl %d this %d",cl,this);
        !          19181: 
        !          19182:                                if (mex && n->n_scope==0 && n->tp->base!=OVERLOAD) {
        !          19183:                                        if ( is_accessible(n,this)==0 )
        !          19184:                                        {
        !          19185:                                                if ( me == dummy_fct )
        !          19186:                                                        error("G scope cannot access%n: %sM",n,n->n_protect?"protected":"private");
        !          19187:                                                else error("%n cannot access%n: %sM",me,n,n->n_protect?"protected":"private");
        !          19188:                                                mex = 0;        // suppress further error messages
        !          19189:                                        }
        !          19190:                                }
        !          19191: 
        !          19192:                                Pname th = cc->c_this;
        !          19193:                                Pexpr r = new ref(REF,th,n);
        !          19194: 
        !          19195:                                if ( access_only == 0 ) {
        !          19196:                                        if (th) th->use();
        !          19197:                                        n->use();
        !          19198:                                }
        !          19199:                                r->tp = t;
        !          19200:                                return r;
        !          19201:                        }
        !          19202: 
        !          19203:                        if (mex && n->n_scope==0 && n->tp->base!=OVERLOAD) {
        !          19204:                                if ( is_accessible(n,this)==0 )
        !          19205:                                {
        !          19206:                                        if ( me == dummy_fct )
        !          19207:                                                error("G scope cannot access%n: %sM",n,n->n_protect?"protected":"private");
        !          19208:                                        else error("%n cannot access%n: %sM",me,n,n->n_protect?"protected":"private");
        !          19209:                                        mex = 0;        // suppress further error messages
        !          19210:                                }
        !          19211:                        }
        !          19212:                        n->use();
        !          19213:                        return n;
        !          19214:                }
        !          19215:        }
        !          19216: 
        !          19217:        if ((cl==0 || cl==this) // not qualified to a base class
        !          19218:        && csu!=UNION
        !          19219:        && csu!=ANON
        !          19220:        && strcmp(s,"__as")==0) { // assignment is special: you cannot inherit it
        !          19221:                if (baselist==0
        !          19222:                || (baselist && baselist->bclass->obj_size!=obj_size)) {
        !          19223:                        Pname cn = ktbl->look(string,0);
        !          19224:                        if (cn->tp->base == COBJ) cn = Pbase(cn->tp)->b_name;
        !          19225:                        Pname x = gtbl->look("__as",0);
        !          19226:                        if (x) {        // what if there is an (illegal) global assignment operation?
        !          19227:                                        // hack hack don't declare global assignment operations!
        !          19228:                                Pfct f = Pfct(x->tp);
        !          19229:                                if (f->base == FCT) {
        !          19230:                                        Pptr r = f->argtype->tp->is_ref();
        !          19231:                                        if (r) {
        !          19232:                                                Pname cnn = r->typ->is_cl_obj();
        !          19233:                                                if (cnn && cn==cnn) return 0;
        !          19234:                                        }
        !          19235:                                } else {
        !          19236:                                        for (Plist gl = Pgen(f)->fct_list; gl; gl=gl->l) {
        !          19237:                                                Pptr r = Pfct(gl->f)->argtype->tp->is_ref();
        !          19238:                                                if (r) {
        !          19239:                                                        Pname cnn = r->typ->is_cl_obj();
        !          19240:                                                        if (cnn &&cn==cnn) return 0;
        !          19241:                                                }
        !          19242:                                        }
        !          19243:                                }
        !          19244:                        }
        !          19245:                        return make_assignment(cn) ? find_name(s,cl) : 0;
        !          19246:                }
        !          19247:        }
        !          19248: 
        !          19249:        return find_in_base(s, cl);
        !          19250: }
        !          19251: 
        !          19252: static Pclass rootClass;
        !          19253: static Pbcl pubVClass;
        !          19254: static struct PendingMessage { 
        !          19255:     Pbcl bc;
        !          19256:     Pname mf;
        !          19257:     char *nm;
        !          19258: } *pM;
        !          19259: 
        !          19260: Pexpr classdef::find_in_base(char* s, Pclass cl)
        !          19261: {
        !          19262:        Pbcl bc = 0;
        !          19263:        Pexpr e = 0;
        !          19264: 
        !          19265: // error('d',"%s->find_in_base(%s %s)",string,s,cl?cl->string:"");
        !          19266: 
        !          19267:        if ( me == 0 ) mef = 0;
        !          19268:        if (rootClass == 0) rootClass = this;
        !          19269:        for (Pbcl b=baselist; b; b=b->next) {
        !          19270:                Pclass ccl = cl==this?0:cl;
        !          19271: // error('d',"try %t %s %k",b->bclass,b->bclass?b->bclass->string:"?", b->base);
        !          19272:                Pexpr ee = b->bclass->find_name(s,ccl);
        !          19273: 
        !          19274:                if (ee) {
        !          19275:                        if (c_body == 1) {      // look for first use (through this)
        !          19276:                                if (b!=baselist || b->base==VIRTUAL)
        !          19277:                                        dcl_print(0);
        !          19278:                                else {
        !          19279:                                        Pexpr ex = ee;
        !          19280:                                        while ((ex->base==MDOT && ex->i1==1)
        !          19281:                                        || (ex->base==REF && ex->e1==cc->c_this)) ex = ex->mem;
        !          19282:                                        switch (ex->tp->base) {
        !          19283:                                        case OVERLOAD:
        !          19284:                                                break;
        !          19285:                                        case FCT:
        !          19286:                                                if (Pfct(ex->tp)->f_virtual==0) break;
        !          19287:                                        default:
        !          19288:                                                dcl_print(0);
        !          19289:                                        }
        !          19290:                                }
        !          19291:                        }
        !          19292: 
        !          19293:                        if (e) {
        !          19294: // error( 'd', "find_in_base: b( %s ): %k %k ",b->bclass->string,b->base,b->ppp);
        !          19295:                                Pexpr ex = e;
        !          19296:                                int evb = 0;    // number of vbase indirections
        !          19297:                                int eb = 0;
        !          19298: 
        !          19299: // note that this does not catch enum members
        !          19300:                                while (ex->base == MDOT
        !          19301:                                || (ex->base==REF && ex->e1==cc->c_this)) {
        !          19302:                                        if (ex->base==MDOT) evb += int(ex->i1);
        !          19303:                                        ex = ex->mem;
        !          19304:                                }
        !          19305: 
        !          19306:                                Pexpr eex = ee;
        !          19307:                                int eevb = b->base==VIRTUAL;    // number of vbase indirections (incl. possibly this one)
        !          19308:                                int eeb = b->base!=VIRTUAL;
        !          19309: 
        !          19310:                                while (eex->base == MDOT
        !          19311:                                || (eex->base==REF && eex->e1==cc->c_this)) {
        !          19312:                                        if (eex->base==MDOT) eevb += int(eex->i1);
        !          19313:                                        eex = eex->mem;
        !          19314:                                }
        !          19315: 
        !          19316: // error('d', "find_in_base: ex: %k eex: %k, eevb: %d evb: %d", ex->base, eex->base, eevb, evb );
        !          19317: // relying on simple counts for sub-object identification isn't good enough
        !          19318: 
        !          19319:                                if (ex != eex)  {
        !          19320: // error('d',"ex %k tp %k eex %k tp %k", ex->base, ex->tp->base, eex->base, eex->tp->base );
        !          19321:                                //      if (!mqua) {
        !          19322:                                                Pclass ocl, ncl;
        !          19323:                                                if ( ex->tp->base == FCT ) 
        !          19324:                                                        ocl = Pfct(ex->tp)->memof;
        !          19325:                                                else 
        !          19326:                                                if ( ex->tp->base == OVERLOAD )
        !          19327:                                                        ocl = Pfct(Pgen(ex->tp)->fct_list->f->tp)->memof;
        !          19328:                                                else ocl = Pclass(ex->n_table->t_name->tp);
        !          19329: //                                             else ocl = 0;
        !          19330: 
        !          19331:                                                if ( eex->tp->base == FCT ) 
        !          19332:                                                        ncl = Pfct(eex->tp)->memof;
        !          19333:                                                else 
        !          19334:                                                if ( eex->tp->base == OVERLOAD )
        !          19335:                                                        ncl = Pfct(Pgen(eex->tp)->fct_list->f->tp)->memof;
        !          19336:                                                 else ncl = Pclass(eex->n_table->t_name->tp);
        !          19337: //                                             else ncl = 0;
        !          19338: 
        !          19339: //                                             Pclass ocl = Pfct(ex->tp)->memof;
        !          19340: //                                             Pclass ncl = Pfct(eex->tp)->memof;
        !          19341:                                                int eb = ocl?ocl->has_base(ncl):0;
        !          19342:                                                int eeb = ncl?ncl->has_base(ocl):0;
        !          19343: 
        !          19344: //error('d',"eb %d eeb %d evb %d eevb %d",eb,eeb,evb,eevb);
        !          19345:                                                if (eb==0 && eeb==0) {
        !          19346:                                                        // different
        !          19347:                                                        error("ambiguous%n and%n",ex,eex);
        !          19348:                                                        break;
        !          19349:                                                }
        !          19350:                                                else if (eb) {  // ex dominates
        !          19351:                                                        if (eevb<evb) error("ambiguous%n and%n (different sub-objects)",ex,eex);
        !          19352:                                                }
        !          19353:                                                else {  // eex dominates
        !          19354:                                                        e = ee;
        !          19355:                                                        bc = b;
        !          19356:                                                        if (evb<eevb) error("ambiguous%n and%n (different sub-objects)",ex,eex);
        !          19357:                                                }
        !          19358:                                                if (evb==0 && eevb==0) {
        !          19359:                                                        error("ambiguous%n and%n (different sub-objects)",ex,eex);
        !          19360:                                                }
        !          19361:                                //      }
        !          19362:                                //      else {
        !          19363:                                //              // different
        !          19364:                                //              error("ambiguous%n and%n",ex,eex);
        !          19365:                                //              break;
        !          19366:                                //      }
        !          19367:                                }
        !          19368:                                else if (ex->base==NAME
        !          19369:                                && (Pname(ex)->n_evaluated || Pname(ex)->n_sto==EXTERN)) {
        !          19370: //error('d',"enum");
        !          19371:                                }
        !          19372:                                else if (evb==0 && eevb==0) {
        !          19373: //error('d',"e %k",e->base);
        !          19374:                                        // no virtual base => different
        !          19375:                                        error("ambiguous%n and%n (no virtualB)",ex,eex);
        !          19376:                                        break;
        !          19377:                                }
        !          19378:                                else if ((evb && eevb==0) || (eevb && evb==0)) {
        !          19379:                                        // only one virtual base => different
        !          19380:                                        error("ambiguous%n and%n (one not in virtualB)",ex,eex);
        !          19381:                                        break;
        !          19382:                                }
        !          19383:                        }
        !          19384:                        else {
        !          19385:                                e = ee;
        !          19386:                                bc = b;
        !          19387:                        }
        !          19388:                }
        !          19389:        }
        !          19390: 
        !          19391:        if (rootClass == this ) {
        !          19392:                if ( pM ) {
        !          19393:                        // deferred until all base classes of ``this'' examined
        !          19394:                        error("%n cannot access %s: %s is a privateBC",pM->mf,pM->nm,pM->bc->bclass->string);
        !          19395:                        delete pM; pM=0;
        !          19396:                }
        !          19397:                rootClass = 0;
        !          19398:                pubVClass = 0;
        !          19399:        }
        !          19400: 
        !          19401:        if (e == 0) return 0;
        !          19402: 
        !          19403:        if (mex) {
        !          19404:                if ( bc->ppp==PRIVATE ) {       // private base
        !          19405:                        if (this==mec || 
        !          19406:                            (mec && has_friend(mec)) || 
        !          19407:                           (mef && has_friend(mef)))
        !          19408:                                ;
        !          19409:                        else 
        !          19410:                        if ( bc->base == VIRTUAL &&
        !          19411:                             rootClass != this ) { 
        !          19412:                                // if one instance is public, it dominates
        !          19413:                                if ( pubVClass == 0 ||
        !          19414:                                      strcmp(pubVClass->bclass->string,bc->bclass->string)) {
        !          19415:                                        pM = (PendingMessage *) new char[sizeof(*pM)];
        !          19416:                                        pM->bc = bc; pM->mf = me; pM->nm = s;
        !          19417:                                }
        !          19418:                        }
        !          19419:                        else {
        !          19420:                                if ( me == dummy_fct )
        !          19421:                                        error("G scope cannot access %s: %s is a privateBC",s,bc->bclass->string);
        !          19422:                                else error("%n cannot access %s: %s is a privateBC",me,s,bc->bclass->string);
        !          19423:                                mex = 0;
        !          19424:                        }
        !          19425:                }
        !          19426:                else { // public base class
        !          19427:                if ( bc->base == VIRTUAL ) {
        !          19428:                        if ( pM && 
        !          19429:                             strcmp(bc->bclass->string,pM->bc->bclass->string)==0 ) {
        !          19430:                                delete pM;
        !          19431:                                pM=0;
        !          19432:                                pubVClass = bc; 
        !          19433:                                } // previous private member becomes public
        !          19434:                        else pubVClass = bc; // ignore subsequent private instances
        !          19435:                        }
        !          19436:                }
        !          19437:        }
        !          19438: 
        !          19439:        if (e->base==NAME
        !          19440:        && Pname(e)->n_stclass==STATIC) {       // static member
        !          19441:                Pname(e)->use();
        !          19442:                return e;
        !          19443:        }
        !          19444:        if (e->base != NAME)
        !          19445:        if (bc->base == VIRTUAL) {      // this->mem => this->Pbclass->mem
        !          19446:                e->mem = new mdot(bc->bclass->string,e->mem);
        !          19447:                e->mem->i1 = 1;
        !          19448:                e->mem->tp = e->mem->mem->tp;
        !          19449:        }
        !          19450:        else if (bc!=baselist) {        // not first base
        !          19451:                if (e->e1 == cc->c_this) {      // this->mem => this->Obcl.mem
        !          19452:                        e->mem = new mdot(bc->bclass->string,e->mem);
        !          19453:                        e->mem->tp = e->mem->mem->tp;
        !          19454:                }
        !          19455:                else {  // this->p->mem => this->Obcl.p->mem
        !          19456:                        Pexpr ee = e;
        !          19457:                        while (ee->e1->base == REF) ee = ee->e1;
        !          19458:                        ee->mem = new mdot(bc->bclass->string,ee->mem);
        !          19459:                        ee->mem->tp = ee->mem->mem->tp; 
        !          19460:                }
        !          19461:        }
        !          19462: 
        !          19463:        return e;
        !          19464: }
        !          19465: 
        !          19466: int has_virt(Pclass cl)
        !          19467: {
        !          19468:        if (cl->virt_count) return 1;
        !          19469:        for (Pbcl b = cl->baselist; b; b = b->next)
        !          19470:                if (b->bclass->virt_count || has_virt(b->bclass)) return 1;
        !          19471:        return 0;
        !          19472: }
        !          19473: 
        !          19474: Pname find_vptr(Pclass cl)
        !          19475: /*
        !          19476:        find virtual function table
        !          19477:        in memtbl or memtbl of ``first bases''
        !          19478: */
        !          19479: {
        !          19480: //error('d',"find_vptr %t",cl);
        !          19481:        while (cl) {
        !          19482:                Pname vp = cl->memtbl->look("__vptr",0);
        !          19483:                if (vp) return vp;
        !          19484:                Pbcl b = cl->baselist;
        !          19485:                cl = 0;
        !          19486:                for (; b; b = b->next)
        !          19487:                        if (b->base == NAME) {
        !          19488:                                cl = b->bclass;
        !          19489:                                break;
        !          19490:                        }
        !          19491:        }
        !          19492: //error('d',"return 0");
        !          19493:        return 0;
        !          19494: }
        !          19495: 
        !          19496: void make_dummy()
        !          19497: /* a function with no special privileges */
        !          19498: {
        !          19499:         Pname x = new name(".." /*"__static_initializer"*/);
        !          19500:         x->tp = new fct(Pvoid_type,0,1);
        !          19501:         dummy_fct = x->dcl(gtbl,EXTERN);
        !          19502: //     dummy_fct->string = "";
        !          19503:         delete x;
        !          19504: }
        !          19505: 
        !          19506: void check_visibility(Pname n, Pname q, Pclass cl, Ptable tbl, Pname fn)
        !          19507: /*
        !          19508:        "fn" calls "n" a member function of "cl"
        !          19509:        fn can be zero (for functions called in arguments to static constructors) 
        !          19510: */
        !          19511: {
        !          19512: // error('d',"check_visibility(%n, %t, %d, %n)",n,cl,tbl,fn);
        !          19513:        if (fn==0) {
        !          19514:                 if (dummy_fct == 0) make_dummy();
        !          19515:                 fn = dummy_fct;
        !          19516:        }
        !          19517:        Pname nn = new name;
        !          19518:         char* s = n->n_gen_fct_name;    // overloaded name
        !          19519:        nn->string = s?s:n->string;
        !          19520:        nn->n_qualifier = q;
        !          19521:        Pname nx = Pname(find_name(nn,cl,tbl,REF,fn)); // nn deleted by find_name
        !          19522:        if (nx->tp->base != OVERLOAD) return;
        !          19523: 
        !          19524:        // can we get here?
        !          19525: 
        !          19526:        // overloaded not checked by find_name()
        !          19527:        // (since it looks for NAMEs not functions)
        !          19528: 
        !          19529:        for (Plist gl=Pgen(nx->tp)->fct_list; gl; gl=gl->l) {
        !          19530:                Pname nn = gl->f;
        !          19531:                if (n == nn) {
        !          19532:                        if (nn->n_scope) return;        // public member
        !          19533: 
        !          19534:                        Pfct omef = mef;
        !          19535:                        Pclass omec = mec;
        !          19536:                        Pclass otcl = tcl;
        !          19537: 
        !          19538:                        Pclass ncl = Pclass(nn->n_table->t_name->tp);
        !          19539:                        Pname fncn = fn->n_table->t_name;
        !          19540: 
        !          19541:                        mec = fncn?Pclass(fncn->tp):0; 
        !          19542:                        Pfct f = mef = Pfct(fn->tp);
        !          19543:                        tcl = cl;
        !          19544: 
        !          19545:                        int ok = is_accessible( n, ncl, 1 );
        !          19546: 
        !          19547:                        // restore global values
        !          19548:                        mef = omef; mec = omec; tcl = otcl;
        !          19549: 
        !          19550:                        if ( ok ) return;
        !          19551: 
        !          19552:                        if ( Cdcl && Cdcl->base == NAME && 
        !          19553:                                Cdcl->n_stclass == STATIC && 
        !          19554:                                Cdcl->n_initializer && 
        !          19555:                                Cdcl->n_qualifier )
        !          19556:                        {
        !          19557:                                Pbase bn = Pbase(Cdcl->n_qualifier->tp);
        !          19558:                                Pclass ccl = Pclass(bn->b_name->tp);
        !          19559: 
        !          19560:                                if ( ccl == cl || ccl->has_friend(f) ||
        !          19561:                                        (n->n_protect && ccl->has_base(ncl)))
        !          19562:                                                return;
        !          19563:                        }
        !          19564: 
        !          19565:                        if ( fn == dummy_fct )
        !          19566:                                error("G scope cannot access%n: %sM",nn,nn->n_protect?"protected":"private");
        !          19567:                        else error("%n cannot access%n: %sM",fn,nn,nn->n_protect?"protected":"private");
        !          19568:                        return;
        !          19569:                }
        !          19570:        }
        !          19571:        error('i',"visibility check failed");
        !          19572: }
        !          19573: 0707071010112044321004440001630000160000010202000466055403200000700000150132gram.y/*ident     "@(#)ctrans:src/gram.y  1.11" */
        !          19574: /*************************************************************************
        !          19575: 
        !          19576:        C++ source for cfront, the C++ compiler front-end
        !          19577:        written in the computer science research center of Bell Labs
        !          19578: 
        !          19579:        Copyright (c) 1984 AT&T, Inc. All Rights Reserved
        !          19580:        THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T, INC.
        !          19581: 
        !          19582: gram.y:
        !          19583:        
        !          19584:        This is the C++ syntax analyser.
        !          19585: 
        !          19586:        Syntax extensions for error handling:
        !          19587:                nested functions
        !          19588:                any expression can be empty
        !          19589:                any expression can be a constant_expression
        !          19590: 
        !          19591:        A call to error() does not change the parser's state
        !          19592: 
        !          19593: ***************************************************************************/
        !          19594: 
        !          19595: %{
        !          19596: #include "cfront.h"
        !          19597: #include "size.h"
        !          19598: #include "template.h"
        !          19599: #include <string.h>
        !          19600: // include tqueue.h after YYSTYPE is defined ...
        !          19601: 
        !          19602: 
        !          19603: struct parstate {
        !          19604:        Ptype intypedef;
        !          19605:        int   defercheck;
        !          19606:        Pname intag;
        !          19607: } pstate[BLMAX];
        !          19608: static int px;
        !          19609: static void
        !          19610: SAVE_STATE()
        !          19611: {
        !          19612:        if ( px++ >= BLMAX ) error('i',"maximum scope depth exceeded");
        !          19613:        pstate[px].intypedef = in_typedef;
        !          19614:        in_typedef = 0;
        !          19615:        pstate[px].defercheck = defer_check;
        !          19616:        defer_check = 0;
        !          19617:        pstate[px].intag = in_tag;
        !          19618:        in_tag = 0;
        !          19619: }
        !          19620: static void
        !          19621: RESTORE_STATE()
        !          19622: {
        !          19623:        if ( --px < 0 ) error('i',"scope stack underflow");
        !          19624:        in_typedef = pstate[px].intypedef;
        !          19625:        defer_check = pstate[px].defercheck;
        !          19626:        in_tag = pstate[px].intag;
        !          19627: }
        !          19628: 
        !          19629: #define copy_if_need_be(s)  ((templp->in_progress || templp->parameters_in_progress) ? strdup(s) : s) 
        !          19630: #define YYMAXDEPTH 600
        !          19631: 
        !          19632: #ifdef DBG
        !          19633: #ifndef YYDEBUG
        !          19634: #define YYDEBUG 1
        !          19635: #endif
        !          19636: #endif
        !          19637: 
        !          19638: static init_seen = 0;
        !          19639: static cdi = 0;
        !          19640: static Pnlist cd = 0, cd_vec[BLMAX];
        !          19641: static char stmt_seen = 0, stmt_vec[BLMAX];
        !          19642: 
        !          19643: //local class
        !          19644: static Plist tn_vec[BLMAX], lcl_tn_vec[BLMAX], lcl_blk_vec[BLMAX];
        !          19645: extern void local_restore();
        !          19646: extern void local_name();
        !          19647: 
        !          19648: //nested class
        !          19649: static Plist nested_tn_vec[BLMAX], nested_type_vec[BLMAX];
        !          19650: extern void nested_restore();
        !          19651: 
        !          19652: static Pname err_name = 0;
        !          19653: 
        !          19654: // fcts put into norm2.c just to get them out of gram.y
        !          19655: void sig_name(Pname);  
        !          19656: Ptype tok_to_type(TOK);
        !          19657: void memptrdcl(Pname, Pname, Ptype, Pname);
        !          19658: 
        !          19659: static Pptr doptr(TOK p, TOK t)
        !          19660: {
        !          19661:        Pptr r = new ptr(p,0);
        !          19662:        switch (t) {
        !          19663:        case CONST:
        !          19664:                r->rdo = 1;
        !          19665:                // if (p == RPTR) error('w',"redundant `const' after &");
        !          19666:                break;
        !          19667:        case VOLATILE:
        !          19668:                error('w',"\"volatile\" not implemented (ignored)");
        !          19669:                break;
        !          19670:        default:
        !          19671:                error("syntax error: *%k",t);
        !          19672:        }
        !          19673:        return r;
        !          19674: }
        !          19675: 
        !          19676: static Pbcl dobase(TOK pr, Pname n, TOK v = 0)
        !          19677: {
        !          19678:        Pbcl b = new basecl(0,0);
        !          19679: 
        !          19680:        if (pr == PROTECTED) {
        !          19681:                pr = PUBLIC;
        !          19682:                error("protectedBC");
        !          19683:        }
        !          19684:        b->ppp = pr;    // save protection indicator
        !          19685: 
        !          19686:        if (n) {
        !          19687:                if (n->base != TNAME) {
        !          19688:                        error("BN%n not aTN",n);
        !          19689:                        return 0;
        !          19690:                }
        !          19691: 
        !          19692:                Pbase bt = Pbase(n->tp);
        !          19693:                while (bt->base == TYPE) bt = Pbase(bt->b_name->tp);
        !          19694: 
        !          19695:                if (bt->base != COBJ) {
        !          19696:                        error("BN%n not aCN",n);
        !          19697:                        return 0;
        !          19698:                }
        !          19699: 
        !          19700:                if (v) {
        !          19701:                        if (v != VIRTUAL) error("syntax error:%k inBCD",v);
        !          19702:                        b->base = VIRTUAL;
        !          19703:                }
        !          19704:                else
        !          19705:                        b->base = NAME;
        !          19706: 
        !          19707:                b->bclass = Pclass(bt->b_name->tp);
        !          19708:        }
        !          19709: 
        !          19710:        return b;
        !          19711: }
        !          19712: 
        !          19713: 
        !          19714: #define Ndata(a,b)     b->normalize(Pbase(a),0,0)
        !          19715: #define Ncast(a,b)     b->normalize(Pbase(a),0,1)
        !          19716: #define Nfct(a,b,c)    b->normalize(Pbase(a),Pblock(c),0)
        !          19717: #define Ncopy(n)       (n->base==TNAME)?new name(n->string):n
        !          19718: 
        !          19719: #define Finit(p)       Pfct(p)->f_init
        !          19720: #define Fargdcl(p,q,r) Pfct(p)->argdcl(q,r)
        !          19721: #define Freturns(p)    Pfct(p)->returns
        !          19722: #define Vtype(v)       Pvec(v)->typ
        !          19723: #define Ptyp(p)                Pptr(p)->typ
        !          19724: 
        !          19725:                /* avoid redefinitions */
        !          19726: #undef EOFTOK
        !          19727: #undef ASM
        !          19728: #undef BREAK
        !          19729: #undef CASE
        !          19730: #undef CONTINUE
        !          19731: #undef DEFAULT
        !          19732: #undef DELETE
        !          19733: #undef DO
        !          19734: #undef ELSE
        !          19735: #undef ENUM
        !          19736: #undef FOR
        !          19737: #undef FORTRAN
        !          19738: #undef FRIEND
        !          19739: #undef GOTO
        !          19740: #undef IF
        !          19741: #undef NEW
        !          19742: #undef OPERATOR
        !          19743: #undef RETURN
        !          19744: #undef SIZEOF
        !          19745: #undef SWITCH
        !          19746: #undef THIS
        !          19747: #undef WHILE
        !          19748: #undef LP
        !          19749: #undef RP
        !          19750: #undef LB
        !          19751: #undef RB
        !          19752: #undef REF
        !          19753: #undef DOT
        !          19754: #undef NOT
        !          19755: #undef COMPL
        !          19756: #undef MUL
        !          19757: #undef AND
        !          19758: #undef PLUS
        !          19759: #undef MINUS
        !          19760: #undef ER
        !          19761: #undef OR
        !          19762: #undef ANDAND
        !          19763: #undef OROR
        !          19764: #undef QUEST
        !          19765: #undef COLON
        !          19766: #undef ASSIGN
        !          19767: #undef CM
        !          19768: #undef SM
        !          19769: #undef LC
        !          19770: #undef RC
        !          19771: #undef ID
        !          19772: #undef STRING
        !          19773: #undef ICON
        !          19774: #undef FCON
        !          19775: #undef CCON
        !          19776: #undef ZERO
        !          19777: #undef ASOP
        !          19778: #undef RELOP
        !          19779: #undef EQUOP
        !          19780: #undef DIVOP
        !          19781: #undef SHIFTOP
        !          19782: #undef ICOP
        !          19783: #undef TYPE
        !          19784: #undef TNAME
        !          19785: #undef EMPTY
        !          19786: #undef NO_ID
        !          19787: #undef NO_EXPR
        !          19788: #undef FDEF
        !          19789: #undef ELLIPSIS
        !          19790: #undef AGGR
        !          19791: #undef MEM
        !          19792: #undef MEMPTR
        !          19793: #undef PR
        !          19794: #undef TSCOPE
        !          19795: #undef DECL_MARKER
        !          19796: #undef REFMUL
        !          19797: #undef LDOUBLE
        !          19798: #undef LINKAGE
        !          19799: #undef LOCAL
        !          19800: #undef TEMPLATE
        !          19801: 
        !          19802: #undef XVIRT
        !          19803: #undef XNLIST
        !          19804: #undef XILINE
        !          19805: #undef XIA
        !          19806: #undef STATEMENT
        !          19807: #undef EXPRESSION
        !          19808: #undef SM_PARAM
        !          19809: #undef TEMPLATE_TEST
        !          19810: #undef PTNAME
        !          19811: #undef NEW_INIT_KLUDGE
        !          19812: %}
        !          19813: 
        !          19814: %union {
        !          19815:        char*   s;
        !          19816:        TOK     t;
        !          19817:        int     i;
        !          19818:        loc     l;
        !          19819:        Pname   pn;
        !          19820:        Ptype   pt;
        !          19821:        Pexpr   pe;
        !          19822:        Pstmt   ps;
        !          19823:        Pbase   pb;
        !          19824:        Pnlist  nl;
        !          19825:        Pslist  sl;
        !          19826:        Pelist  el;
        !          19827:        Pbcl    pbc;
        !          19828:        Pptr    pp;
        !          19829:        PP      p;      // fudge: pointer to all class node objects
        !          19830:        Plist   pl;
        !          19831:        toknode* q;     // token queue
        !          19832: }
        !          19833: %{
        !          19834: #include "tqueue.h"
        !          19835: extern YYSTYPE yylval, yyval;
        !          19836: extern int yyparse();
        !          19837: 
        !          19838: // in_typedef should allow for nested in_typedef
        !          19839: extern int     declTag;         // !1: inline, virtual mod permitted
        !          19840: int            in_sizeof = 0;
        !          19841: Ptype          in_typedef = 0;  // catch redefinition of TNAME
        !          19842: Pname          in_tag = 0;      // handle complex typedefs: int (*)()
        !          19843: extern int     defer_check;     // redefinition typedef check delay
        !          19844: Pname          curr_scope;
        !          19845: 
        !          19846: extern int     must_be_id;      // !0, TNAME => ID, i.e., int X
        !          19847: int    DECL_TYPE = 0;   // lalex() wants this set for global x(*fp)()
        !          19848: int    in_arg_list=0;   // !0 when parsing argument list
        !          19849: static int in_binit_list=0;
        !          19850: int    in_class_decl=0; // !0 when processing class definition
        !          19851: int    parsing_class_members=0; // !0 when parsing class def but not member function body
        !          19852: int    in_mem_fct=0;    // !0 when parsing member function definition
        !          19853: 
        !          19854: #define yylex lalex
        !          19855: #define NEXTTOK() ( (yychar==-1) ? (yychar=yylex(),yychar) : yychar )
        !          19856: #define EXPECT_ID() must_be_id = 1
        !          19857: #define NOT_EXPECT_ID() must_be_id = 0
        !          19858: 
        !          19859: Pname syn()
        !          19860: {
        !          19861: ll:
        !          19862:        switch (yyparse()) {
        !          19863:        case 0:         return 0;       // EOF
        !          19864:        case 1:         goto ll;        // no action needed
        !          19865:        default:        return yyval.pn;
        !          19866:        }
        !          19867: }
        !          19868: 
        !          19869: %}
        !          19870: /*
        !          19871:        the token definitions are copied from token.h,
        !          19872:        and all %token replaced by %token
        !          19873: */
        !          19874:                        /* keywords in alphabetical order */
        !          19875: %token EOFTOK          0
        !          19876: %token ASM             1
        !          19877: %token AUTO            2
        !          19878: %token BREAK           3
        !          19879: %token CASE            4
        !          19880: %token CONTINUE                7
        !          19881: %token DEFAULT         8
        !          19882: %token DELETE          9
        !          19883: %token DO              10
        !          19884: %token ELSE            12
        !          19885: %token ENUM            13
        !          19886: %token FOR             16
        !          19887: %token FORTRAN         17 
        !          19888: %token FRIEND          18 
        !          19889: %token GOTO            19
        !          19890: %token IF              20
        !          19891: %token NEW             23
        !          19892: %token OPERATOR                24
        !          19893: %token RETURN          28
        !          19894: %token SIZEOF          30
        !          19895: %token SWITCH          33
        !          19896: %token THIS            34
        !          19897: %token WHILE           39
        !          19898: 
        !          19899:                        /* operators in priority order (sort of) */
        !          19900: %token LP              40
        !          19901: %token RP              41
        !          19902: %token LB              42
        !          19903: %token RB              43
        !          19904: %token REF             44
        !          19905: %token DOT             45
        !          19906: %token NOT             46
        !          19907: %token COMPL           47
        !          19908: %token MUL             50
        !          19909: %token AND             52
        !          19910: %token PLUS            54
        !          19911: %token MINUS           55
        !          19912: %token LT              58
        !          19913: %token GT              60
        !          19914: %token ER              64
        !          19915: %token OR              65
        !          19916: %token ANDAND          66
        !          19917: %token OROR            67
        !          19918: %token QUEST           68
        !          19919: %token COLON           69
        !          19920: %token ASSIGN          70
        !          19921: %token CM              71
        !          19922: %token SM              72
        !          19923: %token LC              73
        !          19924: %token RC              74
        !          19925: 
        !          19926:     /* = constants etc. */
        !          19927: %token ID         80
        !          19928: %token STRING     81
        !          19929: %token ICON       82
        !          19930: %token FCON       83
        !          19931: %token CCON       84
        !          19932: %token NAME       85
        !          19933: %token ZERO       86
        !          19934:     /* groups of tokens */
        !          19935: %token ASOP   90       /* op= */
        !          19936: %token RELOP  91       /* LE GE LT GT */
        !          19937: %token EQUOP  92       /* EQ NE */
        !          19938: %token DIVOP  93       /* DIV MOD */
        !          19939: %token SHIFTOP         94      /* LS RS */
        !          19940: %token ICOP            95      /* INCR DECR */
        !          19941: %token TYPE            97
        !          19942:     /* TYPE =  INT FLOAT CHAR DOUBLE REGISTER STATIC EXTERN AUTO
        !          19943:        LONG SHORT UNSIGNED INLINE FRIEND VIRTUAL */
        !          19944: 
        !          19945: %token TNAME     123
        !          19946: %token EMPTY     124
        !          19947: %token NO_ID     125
        !          19948: %token NO_EXPR   126
        !          19949: %token FDEF      127
        !          19950: 
        !          19951: %token ELLIPSIS        155
        !          19952: %token AGGR    156
        !          19953: %token MEM     160
        !          19954: %token MEMPTR  173
        !          19955: %token PR              175     /* PUBLIC PRIVATE PROTECTED */
        !          19956: %token TSCOPE          178     /* TNAME :: */
        !          19957: %token DECL_MARKER     179
        !          19958: %token REFMUL          180     /* ->*, .* */
        !          19959: %token LDOUBLE         181
        !          19960: %token LINKAGE         182     /* extern "asdf" */
        !          19961: %token LOCAL           183     /* local class */
        !          19962: %token TEMPLATE                185     /* local class */
        !          19963: 
        !          19964: /* "tokens" for aux data structures */
        !          19965: 
        !          19966: %token XVIRT           200 /* class virt */
        !          19967: %token XNLIST          201 /* struct name_list */
        !          19968: %token XILINE          202
        !          19969: %token XIA             203
        !          19970: %token STATEMENT        205
        !          19971: %token EXPRESSION       206
        !          19972: %token SM_PARAM         207 
        !          19973: %token TEMPLATE_TEST    208
        !          19974: %token PTNAME           209
        !          19975: %token NEW_INIT_KLUDGE  210
        !          19976: %token XDELETED_NODE    211
        !          19977: %token DUMMY_LAST_NODE  212
        !          19978: 
        !          19979: %type <p>      external_def fct_dcl fct_def att_fct_def arg_dcl_list 
        !          19980:                base_init init_list binit
        !          19981:                data_dcl ext_def vec ptr
        !          19982:                type tp enum_dcl moe_list moe 
        !          19983:                tag ttag enumtag class_head class_dcl cl_mem_list 
        !          19984:                cl_mem dl decl_list 
        !          19985:                fname decl initializer stmt_list
        !          19986:                caselab_stmt caselablist
        !          19987:                block statement simple ex_list elist e ee term prim
        !          19988:                term_elist
        !          19989:                cast_decl cast_type c_decl c_type c_tp
        !          19990:                arg_decl formal_decl at arg_type arg_list arg_type_list
        !          19991:                new_decl new_type
        !          19992:                condition
        !          19993:                TSCOPE tscope TNAME tn_list MEMPTR
        !          19994:                qualified_tname
        !          19995:                PTNAME tname ptname template_def
        !          19996: %type <l>      LC RC SWITCH CASE DEFAULT FOR IF DO WHILE GOTO RETURN DELETE
        !          19997:                BREAK CONTINUE
        !          19998: %type <t>      oper ellipsis_opt
        !          19999:                EQUOP DIVOP SHIFTOP ICOP RELOP GT LT ASOP
        !          20000:                ANDAND OROR PLUS MINUS MUL ASSIGN OR ER AND 
        !          20001:                LP LB NOT COMPL AGGR
        !          20002:                TYPE PR REFMUL
        !          20003:                STATEMENT EXPRESSION stmt_or_expr
        !          20004: %type <s>      CCON ZERO ICON FCON STRING LINKAGE
        !          20005: %type <pn>     ID FDEF inline_fct_def identifier
        !          20006: %type <pbc>    base_list base_unit_list base_unit
        !          20007: %type <q>      EMPTY
        !          20008: %type <i>      fct_attributes
        !          20009: %type <pl>     arg_lp
        !          20010: %type <pe>      temp_inst_parm
        !          20011: %type <el>      temp_inst_parms
        !          20012: 
        !          20013: %left  EMPTY
        !          20014: %left  NO_ID
        !          20015: %left  RC LC ID BREAK CONTINUE RETURN GOTO DELETE DO IF WHILE FOR CASE DEFAULT
        !          20016:        AGGR ENUM TYPE TNAME TSCOPE
        !          20017: %left  NO_EXPR
        !          20018: 
        !          20019: %left  CM
        !          20020: %right ASOP ASSIGN
        !          20021: %right QUEST COLON
        !          20022: %left  OROR
        !          20023: %left  ANDAND
        !          20024: %left  OR
        !          20025: %left  ER
        !          20026: %left  AND
        !          20027: %left  EQUOP
        !          20028: %left  RELOP GT LT
        !          20029: %left  SHIFTOP
        !          20030: %left  PLUS MINUS
        !          20031: %left  MUL DIVOP MEMPTR
        !          20032: %left   REFMUL
        !          20033: %right NOT COMPL NEW
        !          20034: %right ICOP SIZEOF
        !          20035: %left  LB LP DOT REF MEM
        !          20036: 
        !          20037: %start ext_def
        !          20038: 
        !          20039: %%
        !          20040: /*
        !          20041:        this parser handles declarations one by one,
        !          20042:        NOT a complete .c file
        !          20043: */
        !          20044: 
        !          20045: 
        !          20046: /************** DECLARATIONS in the outermost scope: returns Pname (in yylval) ***/
        !          20047: 
        !          20048: ext_def                :  external_def         {       return 2; }
        !          20049:                |  SM                   {       return 1; }
        !          20050:                |  EOFTOK               {       return 0; }
        !          20051:                |  LINKAGE LC
        !          20052:                        {
        !          20053:                                set_linkage($<s>1);
        !          20054:                                bl_level--;
        !          20055:                                return 1;
        !          20056:                        }
        !          20057:                |  RC
        !          20058:                        {
        !          20059:                                set_linkage(0);
        !          20060:                                bl_level++;
        !          20061:                                return 1;
        !          20062:                        }
        !          20063:                |  template              {  return 1; } 
        !          20064:                 |  template_test         {  return 1 ;}
        !          20065:                ;
        !          20066: 
        !          20067: 
        !          20068: template_test   : TEMPLATE_TEST identifier LT temp_inst_parms GT SM
        !          20069:                  { Ptreet t = tree_template::get($<pn>2->string) ;
        !          20070:                     Pexpr  e = 0 ;
        !          20071:                    if (t)
        !          20072:                      e = t->expand(expr_unlist($<el>4)) ;
        !          20073:                    else error ("%s wasn't an expression template",
        !          20074:                                        $<pn>2->string)  ;
        !          20075:                   } ;
        !          20076: 
        !          20077: template    :    TEMPLATE
        !          20078:                  { templp->start() ; }
        !          20079:                  LT template_parm_list GT
        !          20080:                  {templp->enter_parameters() ; }
        !          20081:                  template_def
        !          20082:                  {templp->end($<pn>7);
        !          20083:                   templp->in_progress = false ;
        !          20084:                   goto mod;}
        !          20085:                  ;
        !          20086: 
        !          20087: template_def   : att_fct_def
        !          20088:                  { goto mod; }
        !          20089:                 | fct_def
        !          20090:                   { goto mod; }
        !          20091:                 | class_dcl SM
        !          20092:                   { Pname pn = $<pb>1->aggr();
        !          20093:                     /* basetype:aggr() does not return the name for a forward */
        !          20094:                    /* declaration, so extract it directly */
        !          20095:                     $$ = (pn ? pn : $<pb>1->b_name) ;
        !          20096:                     DECL_TYPE = 0;  }
        !          20097:                 /* internal template specification productions*/
        !          20098:                 | STATEMENT 
        !          20099:                   {templp->curr_tree_template = $1 ; }
        !          20100:                    identifier COLON statement
        !          20101:                   {$<pn>3->n_initializer = $<pe>5 ; /* actually a stmt */
        !          20102:                     $<pn>$ = $<pn>3; }
        !          20103:                 | EXPRESSION 
        !          20104:                   {templp->curr_tree_template = $1 ; }
        !          20105:                   identifier COLON ee SM
        !          20106:                   {$<pn>3->n_initializer = $<pe>5 ; /* actually a stmt */
        !          20107:                     $<pn>$ = $<pn>3 ; }
        !          20108:                  ;
        !          20109: 
        !          20110: identifier     : ID 
        !          20111:                |  qualified_tname
        !          20112:                        { $<pn>$ = Ncopy($<pn>1) ;} ;
        !          20113:                ;
        !          20114: 
        !          20115: external_def   :  data_dcl
        !          20116:                        {       
        !          20117:                        /* if function declartion with arguments
        !          20118:                         * need to make sure modified_tn is traversed */
        !          20119:                        if ( $<pn>1 != 0 
        !          20120:                                && $<pn>1->tp->base == FCT 
        !          20121:                                && Pfct($<pn>1->tp)->nargs !=0 ) 
        !          20122:                                        goto mod;
        !          20123:                        else {
        !          20124:                                modified_tn = 0;
        !          20125:                                curr_scope = 0;
        !          20126:                                if ($<pn>1==0) $<i>$ = 1; 
        !          20127:                             }
        !          20128:                        }
        !          20129:                |  att_fct_def
        !          20130:                        {       goto mod; }
        !          20131:                |  fct_def
        !          20132:                        {       goto mod; }
        !          20133:                |  fct_dcl
        !          20134:                        { mod:  if (modified_tn) {
        !          20135:                                        restore();
        !          20136:                                        modified_tn = 0;
        !          20137:                                }
        !          20138:                                local_blk = 0;
        !          20139:                                curr_scope = 0;
        !          20140:                                if (local_tn) {
        !          20141:                                        local_restore();
        !          20142:                                        local_tn = 0;
        !          20143:                                }
        !          20144:                                
        !          20145:                                if (nested_tn) { // x::f(){}
        !          20146:                                        nested_restore();
        !          20147:                                        nested_tn = 0;
        !          20148:                                        nested_type = 0;
        !          20149:                                }
        !          20150:                        }
        !          20151:                |  ASM LP STRING RP SM
        !          20152:                        {       Pname n = new name(make_name('A'));
        !          20153:                                n->tp = new basetype(ASM,0);
        !          20154:                                Pbase(n->tp)->b_name = Pname($<s>3);
        !          20155:                                $$ = n;
        !          20156:                        }
        !          20157:                ;
        !          20158: 
        !          20159: fct_dcl                : decl ASSIGN initializer SM
        !          20160:                        {
        !          20161:                                err_name = $<pn>1;
        !          20162:                                if(err_name) err_name->n_initializer = $<pe>3;
        !          20163:                                goto fix;
        !          20164:                        }
        !          20165:                | decl SM
        !          20166:                        {
        !          20167:                                Ptype t;
        !          20168:                                err_name = $<pn>1;
        !          20169:                        fix:
        !          20170:                                if (err_name == 0) {
        !          20171:                                        error("syntax error:TX");
        !          20172:                                        $$ = Ndata(defa_type,err_name);
        !          20173:                                }
        !          20174:                                else if ((t=err_name->tp) == 0) {
        !          20175:                                        error("TX for%n",err_name);
        !          20176:                                        $$ = Ndata(defa_type,err_name);
        !          20177:                                }
        !          20178:                                else if (t->base==FCT) {
        !          20179:                                        if (Pfct(t)->returns==0)
        !          20180:                                                $$ = Nfct(defa_type,err_name,0);
        !          20181:                                        else
        !          20182:                                                $$ = Ndata(0,err_name);
        !          20183:                                }
        !          20184:                                else {
        !          20185:                                        error("syntax error:TX for%k%n",t->base,err_name);
        !          20186:                                        $$ = Ndata(defa_type,err_name);
        !          20187:                                }
        !          20188:                        }
        !          20189:                ;
        !          20190: 
        !          20191: att_fct_def    :  type decl arg_dcl_list check_inline base_init block
        !          20192:                        {       Pname n = Nfct($1,$<pn>2,$6);
        !          20193:                                Fargdcl(n->tp,name_unlist($<nl>3),n);
        !          20194:                                Finit(n->tp) = $<pn>5;
        !          20195:                                $$ = n;
        !          20196:                                NOT_EXPECT_ID();
        !          20197:                         //???POP_SCOPE(); // undef arg names
        !          20198:                        }
        !          20199:                |  type decl arg_dcl_list check_inline EMPTY
        !          20200:                        {
        !          20201:                                Pname n = Nfct($1,$<pn>2,dummy);
        !          20202:                                Fargdcl(n->tp,name_unlist($<nl>3),n);
        !          20203:                                $<q>5->retval.pn = n;
        !          20204:                                $$ = n;
        !          20205:                                NOT_EXPECT_ID();
        !          20206:                        }
        !          20207:                |  type decl arg_dcl_list check_inline NO_ID /*syntax error*/
        !          20208:                        {
        !          20209:                                error(&$<pn>2->where,"syntax error -- did you forget a ';'?");
        !          20210:                                Pname n = Nfct($1,$<pn>2,0);
        !          20211:                                $$ = n;
        !          20212:                                NOT_EXPECT_ID();
        !          20213:                        //???POP_SCOPE(); // undef arg names
        !          20214:                        }
        !          20215:                ;
        !          20216: 
        !          20217: fct_def                :  decl arg_dcl_list check_inline base_init block
        !          20218:                        {       Pname n = Nfct(defa_type,$<pn>1,$5);
        !          20219:                                Fargdcl(n->tp,name_unlist($<nl>2),n);
        !          20220:                                if ( $<pn>4 && $<pn>4->n_list && 
        !          20221:                                        ccl && ccl->csu == UNION )  
        !          20222:                                                error( "multiple initializers in unionK %s::%n", $<pn>1->string, $<pn>1 );
        !          20223:                                Finit(n->tp) = $<pn>4;
        !          20224:                                $$ = n;
        !          20225:                                NOT_EXPECT_ID();
        !          20226:                         //???POP_SCOPE(); // undef arg names 
        !          20227:                        }
        !          20228:                |  decl arg_dcl_list check_inline EMPTY
        !          20229:                        {
        !          20230:                                Pname n = Nfct(defa_type,$<pn>1,dummy);
        !          20231:                                Fargdcl(n->tp,name_unlist($<nl>2),n);
        !          20232:                                $<q>4->retval.pn = n;
        !          20233:                                $$ = n;
        !          20234:                                NOT_EXPECT_ID();
        !          20235:                        }
        !          20236:                |  decl arg_dcl_list check_inline NO_ID /*syntax error*/
        !          20237:                        {
        !          20238:                                error(&$<pn>1->where,"badD of%n -- did you forget a ';'?",$<pn>1);
        !          20239:                                Pname n = Nfct(defa_type,$<pn>1,0);
        !          20240:                                $$ = n;
        !          20241:                                NOT_EXPECT_ID();
        !          20242:                          //???POP_SCOPE(); // undef arg names
        !          20243:                        }
        !          20244:                ;
        !          20245: 
        !          20246: inline_fct_def :  FDEF 
        !          20247:                        {//PUSH_ARG_SCOPE
        !          20248:                                arg_redec($<pn>1);
        !          20249:                        }
        !          20250:                   base_init block
        !          20251:                        {
        !          20252:                                Finit($1->tp) = $<pn>3;
        !          20253:                                Pfct($1->tp)->body = Pblock($4);
        !          20254:                                $$ = $1;
        !          20255:                                NOT_EXPECT_ID();
        !          20256:                         //???POP_SCOPE(); // undef arg names
        !          20257:                        }
        !          20258:                ;
        !          20259: 
        !          20260: 
        !          20261: check_inline   :  /* empty */
        !          20262:                   {
        !          20263:                        // if parsing implicit inline def, save body
        !          20264:                        //   of function for parsing after class def
        !          20265:                        switch ( NEXTTOK() ) {
        !          20266:                        case LC: case COLON:
        !          20267:                                if ( in_class_decl ) {
        !          20268:                                        // mem or friend inline def
        !          20269:                                        // save text of mem_init & ftn
        !          20270:                                        la_backup(yychar,yylval);
        !          20271:                                        // yylval used as dummy...
        !          20272:                                        la_backup(FDEF, yylval);
        !          20273:                                        if ( yylval.q = save_text() )
        !          20274:                                                yychar = EMPTY;
        !          20275:                                        else { // syntax error
        !          20276:                                                // just parse in place
        !          20277:                                                yylex(); // FDEF
        !          20278:                                                yychar = yylex();
        !          20279:                                        }
        !          20280:                                } // if in_class_decl
        !          20281:                                break;
        !          20282:                        default:
        !          20283:                                la_backup(yychar,yylval);
        !          20284:                                yychar = NO_ID; // 'graceful' recovery
        !          20285:                                break;
        !          20286:                        }
        !          20287:                   }
        !          20288:                ;
        !          20289: 
        !          20290: base_init      :  COLON { ++in_binit_list; } init_list
        !          20291:                        {       
        !          20292:                                $$ = $3; 
        !          20293:                                in_arg_list = 0;
        !          20294:                                --in_binit_list;
        !          20295:                        }
        !          20296:                |  %prec EMPTY
        !          20297:                        {       $$ = 0; }
        !          20298:                ;
        !          20299: 
        !          20300: init_list      :  binit
        !          20301:                        { $$ = $1; }
        !          20302:                |  init_list CM binit
        !          20303:                        { $<pn>$ = $<pn>3;  $<pn>$->n_list = $<pn>1; }
        !          20304:                ;
        !          20305: 
        !          20306: binit          :  LP elist RP
        !          20307:                        {
        !          20308:                                $<pn>$ = new name;
        !          20309:                                $<pn>$->n_initializer = $<pe>2;
        !          20310:                        }
        !          20311:                |  ttag LP elist RP
        !          20312:                        {
        !          20313:                                Pname n = Ncopy($<pn>1);
        !          20314:                                n->base = $<pn>1->base;
        !          20315:                                n->tp = $<pn>1->tp;
        !          20316:                                n->n_initializer = $<pe>3;
        !          20317:                                $<pn>$ = n;
        !          20318:                        }
        !          20319: 
        !          20320: /*
        !          20321:                |  NEW LP elist RP
        !          20322:                        {       Pname n = new name;
        !          20323:                                n->base = NEW;
        !          20324:                                n->n_initializer = $<pe>3;
        !          20325:                                $<pn>$ = n;
        !          20326:                        }
        !          20327: */
        !          20328:                ;
        !          20329: 
        !          20330: 
        !          20331: 
        !          20332: 
        !          20333: /*************** declarations: returns Pname ********************/
        !          20334: 
        !          20335: arg_dcl_list   :  arg_dcl_list data_dcl
        !          20336:                        {       if ($<pn>2 == 0)
        !          20337:                                        error("badAD");
        !          20338:                                else if ($<pn>2->tp->base == FCT)
        !          20339:                                        error("FD inAL (%n)",$<pn>2);
        !          20340:                                else if ($1)
        !          20341:                                         $<nl>1->add_list($<pn>2);
        !          20342:                                else
        !          20343:                                        $<nl>$ = new nlist($<pn>2);
        !          20344:                        }
        !          20345:                |  %prec EMPTY
        !          20346:                        {
        !          20347:                                 $$ = 0; 
        !          20348:                        }
        !          20349:                ;
        !          20350: 
        !          20351: dl             :  decl
        !          20352:                |  ID COLON 
        !          20353:                         {
        !          20354:                                 if ( in_typedef ) {
        !          20355:                                         error("Tdef field");
        !          20356:                                         in_typedef = 0;
        !          20357:                                 }
        !          20358:                         //      ENTER_NAME($<pn>1);
        !          20359:                         }
        !          20360:                    e           %prec CM
        !          20361:                        {       $$ = $<pn>1;
        !          20362:                                $<pn>$->tp = new basetype(FIELD,$<pn>4);
        !          20363:                        }
        !          20364:                |  COLON e              %prec CM
        !          20365:                        {       $$ = new name;
        !          20366:                                $<pn>$->tp = new basetype(FIELD,$<pn>2);
        !          20367:                                 if ( in_typedef ) {
        !          20368:                                         error("Tdef field");
        !          20369:                                         in_typedef = 0;
        !          20370:                                 }
        !          20371:                        }
        !          20372:                 |  decl ASSIGN
        !          20373:                         {
        !          20374:                         //      ENTER_NAME($<pn>1);
        !          20375:                         }
        !          20376:                    initializer
        !          20377:                         {       Pexpr e = $<pe>4;
        !          20378:                                 if (e == dummy) error("emptyIr");
        !          20379:                                 $<pn>1->n_initializer = e;
        !          20380:                                 init_seen = 0;
        !          20381:                         }
        !          20382:                 ;
        !          20383: 
        !          20384: decl_list      :  dl
        !          20385:                        {       
        !          20386:                                if ($1) $<nl>$ = new nlist($<pn>1); 
        !          20387:                                if ( NEXTTOK() == CM && la_look() == TNAME ) 
        !          20388:                                        EXPECT_ID();
        !          20389:                        }
        !          20390:                |  decl_list CM dl
        !          20391:                        {       if ($1)
        !          20392:                                        if ($3)
        !          20393:                                                $<nl>1->add($<pn>3);
        !          20394:                                        else
        !          20395:                                                error("DL syntax");
        !          20396:                                else {
        !          20397:                                        if ($3) $<nl>$ = new nlist($<pn>3);
        !          20398:                                        error("DL syntax");
        !          20399:                                }
        !          20400:                                if ( NEXTTOK() == CM && la_look() == TNAME ) 
        !          20401:                                        EXPECT_ID();
        !          20402:                        }
        !          20403:                ;
        !          20404: 
        !          20405: data_dcl       :  type decl_list SM    
        !          20406:                        { 
        !          20407:                                extern int co_hack;
        !          20408:                                co_hack = 1;
        !          20409:                                /*$$ = Ndata($1,name_unlist($<nl>2));*/
        !          20410:                                Pname n = Ndata($1,name_unlist($<nl>2)); 
        !          20411:                                if ( in_typedef && in_tag ) { 
        !          20412:                                        if ( n->tp->check( in_tag->tp, 0 ))
        !          20413:                                                error("%nredefined: previous: %t now: %t", in_tag, in_tag->tp, n->tp );
        !          20414:                                }
        !          20415:                                in_typedef = 0;
        !          20416:                                in_tag = 0;
        !          20417:                                co_hack = 0;
        !          20418:                                DECL_TYPE = 0; 
        !          20419:                                $$ = n;
        !          20420:                        }
        !          20421:                |  type SM              
        !          20422:                        {
        !          20423:                                $$ = $<pb>1->aggr(); 
        !          20424:                                in_typedef = 0;
        !          20425:                                in_tag = 0;
        !          20426:                                DECL_TYPE = 0; 
        !          20427:                        }
        !          20428:                
        !          20429:                ;
        !          20430: 
        !          20431: /* This is where parametrized types, and regular types come together. */
        !          20432: 
        !          20433: lt             : LT { templp->parameters_in_progress++; };
        !          20434: gt             : GT { templp->parameters_in_progress--; };
        !          20435: 
        !          20436: tname           : qualified_tname { $<pn>$ = templp->check_tname($<pn>1) ; }
        !          20437:                 | qualified_tname lt temp_inst_parms gt
        !          20438:                   { 
        !          20439:                    $<pn>$ = parametrized_typename($<pn>1,
        !          20440:                                                  (expr_unlist($<el>3))) ; 
        !          20441:                  }
        !          20442:                 | NAME LT temp_inst_parms GT
        !          20443:                   { extern Pbase any_type;
        !          20444:                    error("%n was not a parametrized type.", $<pn>$) ;
        !          20445:                     $<pn>$= $<pn>1->tdef() ;
        !          20446:                     $<pn>$->tp = any_type ; } ;
        !          20447: 
        !          20448: 
        !          20449: 
        !          20450: tp             :  TYPE                 
        !          20451:                        { 
        !          20452:                                $$ = new basetype($<t>1,0); 
        !          20453:                                if ( $<t>1 == TYPEDEF ) in_typedef = $<pt>$;
        !          20454:                                if (DECL_TYPE == -1) DECL_TYPE = 0;
        !          20455:                        }
        !          20456:                |  LINKAGE              
        !          20457:                        {       $$ = new basetype(EXTERN,0);
        !          20458:                                $<pb>$->b_linkage = $<s>1;
        !          20459:                                if (DECL_TYPE == -1) DECL_TYPE = 0;
        !          20460:                        }
        !          20461:                |  qualified_tname
        !          20462:                        { 
        !          20463:                                templp->check_tname($<pn>1);
        !          20464:                                $$ = new basetype(TYPE,$<pn>1); 
        !          20465:                                if (DECL_TYPE == -1) DECL_TYPE = 0;
        !          20466:                        }
        !          20467:        /*XXX*/ |  tn_list DECL_MARKER
        !          20468:                        { // modified tn_list TNAME
        !          20469:                                $$ = new basetype(TYPE,$<pn>2);
        !          20470:                                //xxx qualifier currently ignored...
        !          20471:                                if (DECL_TYPE == -1) DECL_TYPE = 0;
        !          20472:                        }
        !          20473:                | qualified_tname lt temp_inst_parms gt
        !          20474:                        {
        !          20475:                                $<pb>$ = parametrized_basetype($<pn>1,(expr_unlist($<el>3)));
        !          20476:                        }
        !          20477:                |  class_dcl 
        !          20478:                |  enum_dcl
        !          20479:                |  DECL_MARKER          
        !          20480:                        { 
        !          20481:                                if (DECL_TYPE == TNAME)
        !          20482:                                        $$ = new basetype(TYPE,$<pn>1); 
        !          20483:                //      else if (DECL_TYPE == TSCOPE)
        !          20484:                //      $$ = 0;
        !          20485:                                else
        !          20486:                                if (DECL_TYPE == 0 &&
        !          20487:                                        $<p>1->base == TNAME)
        !          20488:                                                $$ = new basetype(TYPE,$<pn>1); 
        !          20489:                                else
        !          20490:                                        $$ = new basetype($<t>1,0); 
        !          20491:                                DECL_TYPE = -1;
        !          20492:                        }
        !          20493:                ;
        !          20494: 
        !          20495: type           :  tp
        !          20496:                |  type TYPE            
        !          20497:                        { 
        !          20498:                                if ( DECL_TYPE != -1 ) {
        !          20499:                                        switch ($<pb>1->base) { Pbase bt;
        !          20500:                                        case COBJ: case EOBJ:
        !          20501:                                                bt = new basetype(0,0);
        !          20502:                                                *bt = *$<pb>1;
        !          20503:                                                DEL($<pb>1);
        !          20504:                                                $<pb>1 = bt;
        !          20505:                                        }
        !          20506:                                        $$ = $<pb>1->type_adj($<t>2); 
        !          20507:                                }
        !          20508:                                DECL_TYPE = 0;
        !          20509:                        }
        !          20510:                |  type tname
        !          20511:                        {
        !          20512: //error('d',"decl_type: %d  $1: %t  $2: %n",DECL_TYPE,$<pb>1,$<pn>2);
        !          20513:                                if ( DECL_TYPE != -1 ) 
        !          20514:                                        $$ = $<pb>1->name_adj($<pn>2);
        !          20515:                        /*XXX*/ else if($<pb>1==0) $$=new basetype(TYPE,$<pn>2);
        !          20516:                                DECL_TYPE = 0;
        !          20517:                        }
        !          20518:                |  type class_dcl       { $$ = $<pb>1->base_adj($<pb>2); }
        !          20519:                |  type enum_dcl        { $$ = $<pb>1->base_adj($<pb>2); }
        !          20520:                |  type DECL_MARKER             
        !          20521:                        { 
        !          20522:                                if (DECL_TYPE == TYPE) {
        !          20523:                                        switch ($<pb>1->base) { Pbase bt;
        !          20524:                                        case COBJ: case EOBJ:
        !          20525:                                                bt = new basetype(0,0);
        !          20526:                                                *bt = *$<pb>1;
        !          20527:                                                DEL($<pb>1);
        !          20528:                                                $<pb>1 = bt;
        !          20529:                                        }
        !          20530:                                        $$ = $<pb>1->type_adj($<t>2);  
        !          20531:                                }
        !          20532:                        /*XXX*/ else if (DECL_TYPE == TSCOPE) {
        !          20533:                        /*XXX*/         error('i',"type decl_marker(tscope)");
        !          20534:                        /*XXX*/ //      $$ = $1;//ignore(?)
        !          20535:                        /*XXX*/ }
        !          20536:                                else
        !          20537:                                        $$ = $<pb>1->name_adj($<pn>2); 
        !          20538:                                DECL_TYPE = -1;
        !          20539:                        }
        !          20540:                ;
        !          20541: 
        !          20542: temp_inst_parms : temp_inst_parms CM temp_inst_parm
        !          20543:                   {$<el>1->add(new expr(ELIST,$<pe>3,NULL)) ; }
        !          20544:                 | temp_inst_parm { $<el>$ =
        !          20545:                                     new elist(new expr(ELIST,$<pe>1,NULL)); } ;
        !          20546: 
        !          20547: temp_inst_parm  : new_type
        !          20548:                   {$<pn>1->n_template_arg = template_actual_arg_dummy ;
        !          20549:                   $<pe>$ = $<pn>1; /* keep yacc happy */ }
        !          20550:                 | e %prec GT
        !          20551:                   { $<pe>$ = $<pe>1 ; } ; 
        !          20552: 
        !          20553: /***************** aggregate: returns Pname *****************/
        !          20554: 
        !          20555: enumtag        :  tag
        !          20556:                { enumcheck:
        !          20557:                        Ptype tx = $<pn>1->tp;
        !          20558:                        $$ = $1;
        !          20559:                        if ( tx->base == TYPE ) {
        !          20560:                                $$ = Pbase(tx)->b_name;
        !          20561:                                tx = $<pn>$->tp;
        !          20562:                                if ( tx->base != EOBJ
        !          20563:                                ||   strcmp($<pn>$->string,$<pn>1->string)
        !          20564:                                )
        !          20565:                                        error("%n of type%t redeclared as enum.",$<pn>1,tx);
        !          20566:                        } else if ( tx->base != EOBJ )
        !          20567:                                error("%n of type%t redeclared as enum",$<pn>1,tx);
        !          20568:                }
        !          20569:        |  DECL_MARKER { goto enumcheck; }
        !          20570:        ;
        !          20571: 
        !          20572: enum_dcl       :  ENUM LC moe_list RC          { $$ = end_enum(0,$<nl>3); }
        !          20573:                |  ENUM enumtag LC moe_list RC { $$ = end_enum($<pn>2,$<nl>4); }
        !          20574:                |  ENUM enumtag         { $<pb>$ = (Pbase)$<pn>2->tp; }
        !          20575:                ;
        !          20576: 
        !          20577: moe_list       :  moe
        !          20578:                        {       if ($1) $<nl>$ = new nlist($<pn>1); }
        !          20579:                |  moe_list CM moe
        !          20580:                        {       if( $3)
        !          20581:                                        if ($1)
        !          20582:                                                $<nl>1->add($<pn>3);
        !          20583:                                        else
        !          20584:                                                $<nl>$ = new nlist($<pn>3);
        !          20585:                        }
        !          20586:                ;
        !          20587: 
        !          20588: template_parm_list : template_parm_list CM template_parm
        !          20589:                    | template_parm
        !          20590:                    | { $<pn>$ = NULL ;} ;
        !          20591: 
        !          20592: 
        !          20593: stmt_or_expr    : STATEMENT | EXPRESSION ;
        !          20594: 
        !          20595: template_parm   : AGGR identifier
        !          20596:                   /* Build the name for the parameter
        !          20597:                  /* Check that AGGR is indeed CLASS */
        !          20598:                  { templp->collect($<t>1, $<pn>2) ; }
        !          20599:                  | stmt_or_expr identifier
        !          20600:                  { templp->collect($<t>1, $<pn>2) ; }  
        !          20601:                  |   type formal_decl
        !          20602:                        {templp->collect(Ndata($1,$<pn>2)); } ; 
        !          20603: 
        !          20604: 
        !          20605: /* Sam: these productions are a variant of the ones for arg_decl,
        !          20606:  verify them against arg_decl for each release. */
        !          20607: formal_decl    :  ID
        !          20608:                        {       $$ = $<pn>1; }
        !          20609:                |  ptr formal_decl              %prec MUL
        !          20610:                        {       Ptyp($1) = $<pn>2->tp;
        !          20611:                                $<pn>2->tp = (Ptype)$1;
        !          20612:                                $$ = $2;
        !          20613:                        }
        !          20614:                |  formal_decl vec              %prec LB
        !          20615:                        {       Vtype($2) = $<pn>1->tp;
        !          20616:                                $<pn>1->tp = (Ptype)$2;
        !          20617:                        }
        !          20618:                |  formal_decl arg_list
        !          20619:                        {       Freturns($2) = $<pn>1->tp;
        !          20620:                                $<pn>1->tp = (Ptype)$2;
        !          20621:                        } ;
        !          20622: 
        !          20623: 
        !          20624: moe            :  ID
        !          20625:                        {       $$ = $<pn>1; $<pn>$->tp = moe_type; }
        !          20626:                |  ID ASSIGN e
        !          20627:                        {       $$ = $<pn>1;
        !          20628:                                $<pn>$->tp = moe_type;
        !          20629:                                $<pn>$->n_initializer = $<pe>3;
        !          20630:                        }
        !          20631:                |  /* empty: handle trailing CM: enum e { a,b, }; */
        !          20632:                        {       $$ = 0; }
        !          20633:                ;
        !          20634: 
        !          20635: class_dcl      :  class_head cl_mem_list RC
        !          20636:                        {       parsing_class_members = 0;
        !          20637:                                RESTORE_STATE();
        !          20638:                                switch ( NEXTTOK() ) {
        !          20639:                                case TYPE: case AGGR: case ENUM: case EOFTOK:
        !          20640:                                        error("`;' or declaratorX afterCD");
        !          20641:                                        la_backup(yychar,yylval);
        !          20642:                                        yychar = SM;
        !          20643:                                        break;
        !          20644:                                }
        !          20645:                                la_backup(yychar,yylval);
        !          20646:                                yychar = -1;
        !          20647:                                restore_text();
        !          20648:                                ++bl_level; // scope weirdness!
        !          20649:                                ++in_mem_fct;
        !          20650:                        }
        !          20651:                        inline_mem_defs
        !          20652:                        {
        !          20653:                                --in_mem_fct;
        !          20654:                                --bl_level; // scope weirdness!
        !          20655:                                if ( yychar == ID ) {
        !          20656:                                        // (yuk!) adjust lex level
        !          20657:                                        --yylval.pn->lex_level;
        !          20658:                                }
        !          20659:                                ccl->mem_list = name_unlist($<nl>2);
        !          20660:                                if ( --in_class_decl )  // nested class
        !          20661:                                        // continue to parse enclosing class
        !          20662:                                        parsing_class_members = 1;
        !          20663:                                ccl->nest_list = nested_type;
        !          20664:                                if ( nested_tn ) nested_restore();
        !          20665:                                nested_type = nested_type_vec[in_class_decl];
        !          20666:                                nested_tn = nested_tn_vec[in_class_decl];
        !          20667:                                end_cl();
        !          20668:                                declTag = 1;
        !          20669:                         //POP_SCOPE();
        !          20670:                        }
        !          20671:                |  AGGR tag 
        !          20672:                        { aggrcheck:
        !          20673:                                $<pb>$ = (Pbase)$<pn>2->tp; 
        !          20674:                                if ( $$->base == TYPE ) {
        !          20675:                                        Pname nx = $<pb>$->b_name;
        !          20676:                                        $<pb>$ = (Pbase)nx->tp;
        !          20677:                                        if ( $$->base != COBJ
        !          20678:                                        ||   strcmp(nx->string,$<pn>2->string)
        !          20679:                                        )
        !          20680:                                                error("%n of type%t redeclared as%k.",$<pn>2,$<pb>$,$<t>1);
        !          20681:                                } else if ( $$->base != COBJ )
        !          20682:                                        error("%n of type%t redeclared as%k",$<pn>2,$<pb>$,$<t>1);
        !          20683:                                check_tag();
        !          20684:                        }
        !          20685:                 | AGGR qualified_tname lt temp_inst_parms gt
        !          20686:                   { 
        !          20687:                    Pname p = parametrized_typename($<pn>2, (expr_unlist($<el>4))) ;
        !          20688:                     $<pb>$ = (Pbase)p->tp; 
        !          20689:                     check_tag(); 
        !          20690:                  }                   
        !          20691:                |  AGGR DECL_MARKER 
        !          20692:                        {
        !          20693:                                goto aggrcheck;
        !          20694:                        }
        !          20695:                ;
        !          20696: 
        !          20697: 
        !          20698: inline_mem_defs        :  /* empty */
        !          20699:                |  inline_mem_defs inline_fct_def
        !          20700:                ;
        !          20701: 
        !          20702: base_list      :  COLON base_unit_list         { $$ = $2; }
        !          20703:                |  %prec EMPTY                  { $$ = 0; }
        !          20704:                ;
        !          20705: 
        !          20706: base_unit_list :  base_unit
        !          20707:                |  base_unit_list CM base_unit
        !          20708:                        {       if ($3) { $$ = $3; $<pbc>$->next = $1; } }
        !          20709:                ;
        !          20710: 
        !          20711: base_unit      :  ttag                 { $$ = dobase(0,$<pn>1); }
        !          20712:                |  PR ttag              { $$ = dobase($<t>1,$<pn>2); }
        !          20713:                |  TYPE ttag            { $$ = dobase(0,$<pn>2,$<t>1); }
        !          20714:                |  PR TYPE ttag         { $$ = dobase($<t>1,$<pn>3,$<t>2); }
        !          20715:                |  TYPE PR ttag         { $$ = dobase($<t>2,$<pn>3,$<t>1); }
        !          20716:                ;
        !          20717: 
        !          20718: class_head     :  AGGR LC      
        !          20719:                        {//PUSH_CLASS_SCOPE(0);
        !          20720:                                parsing_class_members = 1;
        !          20721:                                $$ = start_cl($<t>1,0,0); 
        !          20722:                                nested_tn_vec[in_class_decl] = nested_tn;
        !          20723:                                nested_type_vec[in_class_decl++] = nested_type;
        !          20724:                                nested_tn = nested_type = 0;
        !          20725:                                SAVE_STATE();
        !          20726:                        }
        !          20727: 
        !          20728:                |  AGGR tag base_list LC
        !          20729:                        { //PUSH_CLASS_SCOPE($<pn>2->string);
        !          20730:                                parsing_class_members = 1;
        !          20731:                                $$ = start_cl($<t>1,$<pn>2,$<pbc>3);
        !          20732:                                nested_tn_vec[in_class_decl] = nested_tn;
        !          20733:                                nested_type_vec[in_class_decl++] = nested_type;
        !          20734:                                nested_tn = nested_type = 0;
        !          20735:                                SAVE_STATE();
        !          20736:                        }
        !          20737:                ;
        !          20738: 
        !          20739: tag            :  ID   { $$ = $1; }
        !          20740:                |  qualified_tname { $$=$1; }
        !          20741:                ;
        !          20742: 
        !          20743: ttag           :  ID   { $$ = $1; }
        !          20744:                |  tname { $$=$1; }
        !          20745:                ;
        !          20746: 
        !          20747: cl_mem_list    :  cl_mem_list cl_mem
        !          20748:                        {
        !          20749:                                if ($2) {
        !          20750:                                        if ($1)
        !          20751:                                                $<nl>1->add_list($<pn>2);
        !          20752:                                        else
        !          20753:                                                $<nl>$ = new nlist($<pn>2);
        !          20754:                                }
        !          20755:                        }
        !          20756:                |  %prec EMPTY { $$ = 0; }
        !          20757:                |  cl_mem_list TEMPLATE
        !          20758:                        {
        !          20759:                                error( "ZizedTD must be atG, notC scope" );
        !          20760:                                error('i', "cannot recover from previous error" );
        !          20761:                        }
        !          20762:                ;
        !          20763: 
        !          20764: cl_mem         :  data_dcl
        !          20765:                |  att_fct_def SM
        !          20766:                |  fct_def SM
        !          20767:                |  fct_def
        !          20768:                |  att_fct_def
        !          20769:                |  fct_dcl
        !          20770:                |  PR COLON
        !          20771:                        {       $$ = new name;
        !          20772:                                $<pn>$->base = $<t>1;
        !          20773:                        }
        !          20774:        /*XXX   |  tn_list TNAME SM
        !          20775:         *              {       Pname n = Ncopy($<pn>2);
        !          20776:         *                      n->n_qualifier = $<pn>1;
        !          20777:         *                      n->base = PR;
        !          20778:         *                      $$ = n;
        !          20779:         *              }
        !          20780:         */     |  tn_list fname SM
        !          20781:                        {       Pname n = Ncopy($<pn>2);
        !          20782:                                if (n->n_oper == TYPE) {
        !          20783:                                        error('s',"visibilityD for conversion operator");
        !          20784:                                        // n->tp = Ptype(n->n_initializer);
        !          20785:                                        n->tp = Ptype(n->cond);
        !          20786:                                        n->cond = 0;
        !          20787:                                        // n->n_initializer = 0;
        !          20788:                                        n->n_oper = 0;
        !          20789:                                        sig_name(n);
        !          20790:                                }
        !          20791:                                n->n_qualifier = $<pn>1;
        !          20792:                                n->base = PR;
        !          20793:                                $$ = n;
        !          20794:                        }
        !          20795:                ;
        !          20796: 
        !          20797: /************* declarators:    returns Pname **********************/
        !          20798: /*     a ``decl'' is used for function and data declarations,
        !          20799:                and for member declarations
        !          20800:                (it has a name)
        !          20801:        an ``arg_decl'' is used for argument declarations
        !          20802:                (it may or may not have a name)
        !          20803:        an ``cast_decl'' is used for casts
        !          20804:                (it does not have a name)
        !          20805:        a ``new_decl'' is used for type specifiers for the NEW operator
        !          20806:                (it does not have a name, and PtoF and PtoV cannot be expressed)
        !          20807: */
        !          20808: 
        !          20809: fname          :  ID
        !          20810:                        {       $$ = $<pn>1; }
        !          20811:                |  COMPL TNAME  /* qualified_tname? */
        !          20812:                        {       $$ = Ncopy($<pn>2);
        !          20813:                                $<pn>$->n_oper = DTOR;
        !          20814:                        }
        !          20815:                |  OPERATOR oper
        !          20816:                        {       $$ = new name(oper_name($2));
        !          20817:                                $<pn>$->n_oper = $<t>2;
        !          20818:                        }
        !          20819:                |  OPERATOR c_type
        !          20820:                        {       Pname n = $<pn>2;
        !          20821:                                n->string = "_type";
        !          20822:                                n->n_oper = TYPE;
        !          20823:                                n->cond = Pexpr(n->tp);
        !          20824:                                // n->n_initializer = Pexpr(n->tp);
        !          20825:                                n->tp = 0;
        !          20826:                                $$ = n;
        !          20827:                        }
        !          20828:                ;
        !          20829: 
        !          20830: oper           :  PLUS
        !          20831:                |  MINUS
        !          20832:                |  MUL
        !          20833:                |  AND
        !          20834:                |  OR
        !          20835:                |  ER
        !          20836:                |  SHIFTOP
        !          20837:                |  EQUOP
        !          20838:                |  DIVOP
        !          20839:                |  RELOP
        !          20840:                |  LT
        !          20841:                |  GT
        !          20842:                |  ANDAND
        !          20843:                |  OROR
        !          20844:                |  LP RP        {       $$ = CALL; }
        !          20845:                |  LB RB        {       $$ = DEREF; }
        !          20846:                |  NOT
        !          20847:                |  COMPL
        !          20848:                |  ICOP
        !          20849:                |  ASOP
        !          20850:                |  ASSIGN
        !          20851:                |  NEW          {       $$ = NEW; }
        !          20852:                |  DELETE       {       $$ = DELETE; }
        !          20853:                |  REF          {       $$ = REF; }
        !          20854:                |  CM           {       $$ = CM; }
        !          20855:                |  REFMUL       {       $$ = REFMUL;
        !          20856:                                        if ($<t>1 == DOT) error(".* cannot be overloaded");
        !          20857:                                }
        !          20858:                ;
        !          20859: 
        !          20860: tn_list                :  tscope
        !          20861:                /*XXX*/ {   if ( $<pn>1 != sta_name ) {
        !          20862: // error('d',"tn_list: tscope: pn1: %s", $<pn>1->string);
        !          20863:                                Ptype t = $<pn>1->tp;
        !          20864:                                while ( t->base == TYPE )
        !          20865:                                        t = Pbase(t)->b_name->tp;
        !          20866:                                Pname n = Pbase(t)->b_name;
        !          20867:                                if (NEXTTOK() == TNAME
        !          20868:                                && strcmp(n->string,yylval.pn->string)==0){
        !          20869:                                        // ctor -- change to ID to avoid
        !          20870:                                        //    parsing as type spec
        !          20871:                                        yychar = ID;
        !          20872:                                        yylval.pn = Ncopy(yylval.pn);
        !          20873:                                        yylval.pn->n_oper = TNAME;
        !          20874:                                }
        !          20875:                            }
        !          20876:                            $<pn>$ = $<pn>1;
        !          20877:                        }
        !          20878: /* YYY         |  tn_list tscope       { $<pn>$ = $<pn>1; } */
        !          20879:                |  tn_list tscope       { error('s', "CNs do not nest, use typedef x::y y_in_x"); };
        !          20880:        /*XXX   |  tn_list ID DOT       { error("CNs do not nest"); } */
        !          20881:                ;
        !          20882: 
        !          20883: qualified_tname        : tn_list TNAME
        !          20884:                        {       $<pn>$ = $<pn>2;
        !          20885:                                //xxx qualifier currently ignored...
        !          20886:                                // $<pn>$ = Ncopy( $<pn>2 );
        !          20887:                                // $<pn>$->n_oper = TNAME;
        !          20888:                                // $<pn>$->n_qualifier = $<pn>1;
        !          20889:                        }
        !          20890:                | TNAME
        !          20891:                        {       $<pn>$ = $<pn>1;
        !          20892:                        //      $<pn>$ = Ncopy( $<pn>1 );
        !          20893:                        //      $<pn>$->n_oper = TNAME;
        !          20894:                        }
        !          20895:                ;
        !          20896: 
        !          20897: fct_attributes : /* empty */
        !          20898:                        { $$ = 0; }
        !          20899:                | fct_attributes TYPE
        !          20900:                        { /* const/volatile function */
        !          20901:                                switch ( $<t>2 ) {
        !          20902:                                case VOLATILE:
        !          20903:                                        error('s',"volatile functions");
        !          20904:                                        break;
        !          20905:                                case CONST:
        !          20906:                                        $$ = ($1 | 1);
        !          20907:                                        break;
        !          20908:                                default:
        !          20909:                                        if ( NEXTTOK() != SM
        !          20910:                                        &&   yychar != COLON
        !          20911:                                        &&   yychar != LC ) {
        !          20912:                                                la_backup(yychar,yylval);
        !          20913:                                                yylval.t = $<t>2;
        !          20914:                                                la_backup(TYPE,yylval);
        !          20915:                                                yylval.t = SM;
        !          20916:                                                yychar = SM;
        !          20917:                                                error("syntax error: unexpected%k (did you forget a `;'?)",$<t>2);
        !          20918:                                        } else error("FD syntax: unexpected%k",$<t>2);
        !          20919:                                        break;
        !          20920:                                }
        !          20921:                        }
        !          20922:                ;
        !          20923: 
        !          20924: decl           :  decl arg_list
        !          20925:                        {       Freturns($2) = $<pn>1->tp;
        !          20926:                                $<pn>1->tp = $<pt>2;
        !          20927:                        }
        !          20928:                |  decl LP RP fct_attributes
        !          20929:                        { /* function with no argument */
        !          20930:                                $<pn>1->tp = new fct($<pn>1->tp,0,1);
        !          20931:                                Pfct($<pn>1->tp)->f_const = ($<i>4 & 1);
        !          20932:                        }
        !          20933:                |  tname arg_list
        !          20934:                        {       Pname n = $<pn>1;
        !          20935:                                $$ = Ncopy(n);
        !          20936:                                 //??? what if tname is qualified ???
        !          20937:                                if (ccl && strcmp(n->string,ccl->string)) n->hide();
        !          20938:                                $<pn>$->n_oper = TNAME;
        !          20939:                                Freturns($2) = $<pn>$->tp;
        !          20940:                                $<pn>$->tp = $<pt>2;
        !          20941:                        }
        !          20942:                |  decl arg_lp elist RP
        !          20943:                        /*      may be class object initializer,
        !          20944:                                class object vector initializer,
        !          20945:                                if not elist will be a CM or an ID
        !          20946:                        */
        !          20947:                        {       
        !          20948:                                $<pn>1->tp = new fct($<pn>1->tp,$<pn>3,1); 
        !          20949:                                in_arg_list = 0;
        !          20950:                                end_al($2,0);
        !          20951:                                RESTORE_STATE();
        !          20952:                         //POP_SCOPE(); // similar to end_al()
        !          20953:                        }
        !          20954:                |  tname LP MUL ID RP arg_list
        !          20955:                        {
        !          20956:                                Pptr p = new ptr( PTR, 0 );
        !          20957:                                Ptyp(p) = new basetype(TYPE,$<pn>1);
        !          20958:                                Freturns( $6 ) = Ptype(p);
        !          20959:                                $<pn>4->tp = $<pt>6;
        !          20960:                                $$ = $4;
        !          20961:                                if (DECL_TYPE == -1) DECL_TYPE = 0;
        !          20962:                        }
        !          20963:                |  tname LP elist RP
        !          20964:                        {       $$ = Ncopy($<pn>1);
        !          20965:                                $<pn>$->n_oper = TNAME;
        !          20966:                                $<pn>$->tp = new fct(0,$<pn>3,1);
        !          20967:                        } 
        !          20968:                |  tname LP RP fct_attributes
        !          20969:                        { /* function with no argument */
        !          20970:                                $$ = Ncopy($<pn>1);
        !          20971:                                $<pn>$->n_oper = TNAME;
        !          20972:                                $<pn>$->tp = new fct(0,0,1);
        !          20973:                                Pfct($<pn>1->tp)->f_const = ($<i>4 & 1);
        !          20974:                        }
        !          20975:                |  tname LP MEMPTR decl RP arg_list
        !          20976:                        {       memptrdcl($<pn>3,$<pn>1,$<pt>6,$<pn>4);
        !          20977:                                $$ = $4;
        !          20978:                        }
        !          20979:                |  fname
        !          20980:                |  ID DOT fname
        !          20981:                        {       $$ = Ncopy($<pn>3);
        !          20982:                                $<pn>$->n_qualifier = $1;
        !          20983:                                error(strict_opt?0:'w',"`.' used for qualification; please use `::' (anachronism)");
        !          20984:                        }
        !          20985:                |  tn_list fname
        !          20986:                        {       $$ = $2;
        !          20987:                                if ( $<pn>1 != sta_name ) {
        !          20988:                                        set_scope($<pn>1); 
        !          20989:                                        $<pn>$->n_qualifier = $<pn>1;
        !          20990:                                }
        !          20991:                        }
        !          20992:        /*XXX*/ |  tn_list ID DOT fname
        !          20993:                        {       $$ = Ncopy($<pn>4);
        !          20994:                                $<pn>$->n_qualifier = $2;
        !          20995:                                error(ansi_opt?0:'w',"anachronism `.' used for qualification; please use `::'");
        !          20996:                                if ( $<pn>1 != sta_name ) {
        !          20997:                                        set_scope($<pn>1); 
        !          20998:                                        $<pn>2->n_qualifier = $<pn>1;
        !          20999:                                }
        !          21000:                        }
        !          21001:        /*XXX   |  tn_list TNAME
        !          21002:         *              {
        !          21003:         *                      if ( $<pn>1 == sta_name ) 
        !          21004:         *                              error( ":: applied to CN%n", $<pn>2 );
        !          21005:         *                      $$ = Ncopy($<pn>2);
        !          21006:         *                      set_scope($<pn>1);
        !          21007:         *                      $<pn>$->n_oper = TNAME;
        !          21008:         *                      $<pn>$->n_qualifier = $<pn>1;
        !          21009:         *              }
        !          21010:         */     |  ptr decl     %prec MUL
        !          21011:                        {       Ptyp($1) = $<pn>2->tp;
        !          21012:                                $<pn>2->tp = $<pt>1;
        !          21013:                                $$ = $2;
        !          21014:                        }
        !          21015:                |  ptr tname    %prec MUL
        !          21016:                        {       $$ = Ncopy($<pn>2);
        !          21017:                                $<pn>$->n_oper = TNAME;
        !          21018:                                // cannot evaluate at this point: defer until data_dcl
        !          21019:                                if ( in_typedef ) {
        !          21020:                                        defer_check = 1;
        !          21021:                                        in_tag = $<pn>2;
        !          21022:                                }
        !          21023:                                $<pn>2->hide();
        !          21024:                                defer_check = 0;
        !          21025:                                $<pn>$->tp = $<pt>1;
        !          21026:                        }
        !          21027:                |  tname vec    %prec LB
        !          21028:                        {       $$ = Ncopy($<pn>1);
        !          21029:                                $<pn>$->n_oper = TNAME;
        !          21030:                                if ( in_typedef ) {
        !          21031:                                        defer_check = 1;
        !          21032:                                        in_tag = $<pn>1;
        !          21033:                                }
        !          21034:                                $<pn>1->hide();
        !          21035:                                defer_check = 0;
        !          21036:                                $<pn>$->tp = $<pt>2;
        !          21037:                        }
        !          21038:                |  decl vec     %prec LB        
        !          21039:                        {       Vtype($2) = $<pn>1->tp;
        !          21040:                                $<pn>1->tp = $<pt>2;
        !          21041:                        }
        !          21042: /*
        !          21043:                |  LP decl RP arg_list
        !          21044:                        {
        !          21045:                                Freturns($4) = $<pn>2->tp;
        !          21046:                                $<pn>2->tp = $<pt>4;
        !          21047:                                $$ = $2;
        !          21048:                        }
        !          21049:                |  LP decl RP vec
        !          21050:                        {       Vtype($4) = $<pn>2->tp;
        !          21051:                                $<pn>2->tp = $<pt>4;
        !          21052:                                $$ = $2;
        !          21053:                        }
        !          21054: */
        !          21055:                |  arg_lp decl RP 
        !          21056:                        { 
        !          21057:                                $$ = $2; 
        !          21058:                                in_arg_list = 0;
        !          21059:                                end_al($1,0);
        !          21060:                                RESTORE_STATE();
        !          21061:                         //POP_SCOPE(); // similar to end_al()
        !          21062:                        }
        !          21063:                ;
        !          21064: 
        !          21065: arg_decl       :  ID
        !          21066:                        {       $$ = $<pn>1; }
        !          21067:                |  ptr qualified_tname  %prec MUL
        !          21068:                        {       $$ = Ncopy($<pn>2);
        !          21069:                                $<pn>$->n_oper = TNAME;
        !          21070:                                $<pn>2->hide();
        !          21071:                                $<pn>$->tp = $<pt>1;
        !          21072:                        }
        !          21073:                |  %prec NO_ID
        !          21074:                        {       
        !          21075:                                $$ = new name; 
        !          21076:                                NOT_EXPECT_ID();
        !          21077:                        }
        !          21078:                |  ptr arg_decl         %prec MUL
        !          21079:                        {       Ptyp($1) = $<pn>2->tp;
        !          21080:                                $<pn>2->tp = (Ptype)$1;
        !          21081:                                $$ = $2;
        !          21082:                        }
        !          21083:                |  arg_decl vec         %prec LB
        !          21084:                        {       Vtype($2) = $<pn>1->tp;
        !          21085:                                $<pn>1->tp = (Ptype)$2;
        !          21086:                        }
        !          21087:                |  arg_decl arg_list
        !          21088:                        {       Freturns($2) = $<pn>1->tp;
        !          21089:                                $<pn>1->tp = (Ptype)$2;
        !          21090:                        }
        !          21091: /*
        !          21092:                |  LP arg_decl RP arg_list
        !          21093:                        {       Freturns($4) = $<pn>2->tp;
        !          21094:                                $<pn>2->tp = (Ptype)$4;
        !          21095:                                $$ = $2;
        !          21096:                        }
        !          21097:                |  LP arg_decl RP vec
        !          21098:                        {       Vtype($4) = $<pn>2->tp;
        !          21099:                                $<pn>2->tp = (Ptype)$4;
        !          21100:                                $$ = $2;
        !          21101:                        }
        !          21102: */
        !          21103:                |  arg_lp arg_decl RP   
        !          21104:                        { 
        !          21105: // error('d', "arg_lp arg_decl rp in_arg_list: %d", in_arg_list );
        !          21106:                                $$ = $2; 
        !          21107:                                in_arg_list = 0;
        !          21108:                                end_al($1,0);
        !          21109:                                RESTORE_STATE();
        !          21110:                         //POP_SCOPE(); // similar to end_al()
        !          21111:                        }
        !          21112:                ;
        !          21113: 
        !          21114: new_decl       :  %prec NO_ID
        !          21115:                        {       $$ = new name; }
        !          21116:                |  ptr new_decl         %prec MUL
        !          21117:                        {       Ptyp($1) = $<pn>2->tp;
        !          21118:                                $<pn>2->tp = (Ptype)$1;
        !          21119:                                $$ = $2;
        !          21120:                                 NOT_EXPECT_ID();
        !          21121:                        }
        !          21122:                |  new_decl vec         %prec LB
        !          21123:                        {       Vtype($2) = $<pn>1->tp;
        !          21124:                                $<pn>1->tp = (Ptype)$2;
        !          21125:                        }
        !          21126:                ;
        !          21127: 
        !          21128: cast_decl      :  %prec NO_ID { $$ = new name; }
        !          21129:                |  ptr cast_decl                        %prec MUL
        !          21130:                        {       Ptyp($1) = $<pn>2->tp;
        !          21131:                                $<pn>2->tp = (Ptype)$1;
        !          21132:                                $$ = $2;
        !          21133:                                NOT_EXPECT_ID();
        !          21134:                        }
        !          21135:                |  cast_decl vec                        %prec LB
        !          21136:                        {       Vtype($2) = $<pn>1->tp;
        !          21137:                                $<pn>1->tp = (Ptype)$2;
        !          21138:                        }
        !          21139:                |  LP cast_decl RP arg_list
        !          21140:                        {       Freturns($4) = $<pn>2->tp;
        !          21141:                                $<pn>2->tp = $<pt>4;
        !          21142:                                $$ = $2;
        !          21143:                        }
        !          21144:                |  LP cast_decl RP vec
        !          21145:                        {       Vtype($4) = $<pn>2->tp;
        !          21146:                                $<pn>2->tp = $<pt>4;
        !          21147:                                $$ = $2;
        !          21148:                        }
        !          21149:                ;
        !          21150: 
        !          21151: c_decl         :  %prec NO_ID
        !          21152:                        {       $$ = new name; }
        !          21153:                |  ptr c_decl                           %prec MUL
        !          21154:                        {       Ptyp($1) = $<pn>2->tp;
        !          21155:                                $<pn>2->tp = (Ptype)$1;
        !          21156:                                $$ = $2;
        !          21157:                        }
        !          21158:                ;
        !          21159: 
        !          21160: 
        !          21161: 
        !          21162: /***************** statements: returns Pstmt *****************/
        !          21163: stmt_list      :  /* empty */
        !          21164:                        {
        !          21165:                                $$ = 0; 
        !          21166:                        }
        !          21167:                |  stmt_list TEMPLATE
        !          21168:                        {
        !          21169:                                error( "ZizedTD must be atG, not local scope" );
        !          21170:                                error('i', "cannot recover from previous error" );
        !          21171:                        }
        !          21172:                |  stmt_list caselab_stmt
        !          21173:                        {       
        !          21174:                                if ($2)
        !          21175:                                        if ($1)
        !          21176:                                                $<sl>1->add($<ps>2);
        !          21177:                                        else {
        !          21178:                                                $<sl>$ =  new slist($<ps>2);
        !          21179:                                                stmt_seen = 1;
        !          21180:                                        }
        !          21181:                        }
        !          21182:                ;
        !          21183: caselab_stmt   :  caselablist statement
        !          21184:                        {
        !          21185:                                $$ = $2;
        !          21186:                                if ($2) stmt_seen = 1;
        !          21187:                        }
        !          21188:                ;
        !          21189: 
        !          21190: caselablist    : /* empty */
        !          21191:                        {
        !          21192:                                $$ = 0;
        !          21193:                                check_decl();
        !          21194:                        }
        !          21195:                ;
        !          21196: 
        !          21197: condition      :  LP e RP
        !          21198:                        {       $$ = $2;
        !          21199:                        /*      if ($<pe>$ == dummy) error("empty condition");*/
        !          21200:                                stmt_seen = 1;
        !          21201:                        }
        !          21202:                ;
        !          21203: 
        !          21204: block          :  LC
        !          21205:                        {//PUSH_BLOCK_SCOPE     
        !          21206:                                cd_vec[cdi] = cd;
        !          21207:                                stmt_vec[cdi] = stmt_seen;
        !          21208:                                tn_vec[cdi] = modified_tn;
        !          21209:                                lcl_blk_vec[cdi++] = local_blk;
        !          21210:                                lcl_tn_vec[cdi] = local_tn;
        !          21211:                                local_blk = 0;
        !          21212:                                local_tn = 0;
        !          21213:                                cd = 0;
        !          21214:                                stmt_seen = 0;
        !          21215:                                modified_tn = 0;
        !          21216:                        }
        !          21217:                        stmt_list RC
        !          21218:                        {       Pname n = name_unlist(cd);
        !          21219:                                Pstmt ss = stmt_unlist($<sl>3);
        !          21220:                                $$ = new block($<l>1,n,ss,$<l>4);
        !          21221:                                if ( local_tn ) local_restore();
        !          21222:                                if ( local_blk ) local_name();
        !          21223:                                if (modified_tn) restore();
        !          21224:                                cd = cd_vec[--cdi];
        !          21225:                                stmt_seen = stmt_vec[cdi];
        !          21226:                                modified_tn = tn_vec[cdi];
        !          21227:                                local_tn = lcl_tn_vec[cdi];
        !          21228:                                local_blk = lcl_blk_vec[cdi];
        !          21229:                                if (cdi < 0) error('i',"block level(%d)",cdi);
        !          21230:                                NOT_EXPECT_ID();
        !          21231:                         //POP_SCOPE(); // similar to end_al()
        !          21232:                        }
        !          21233:                |  LC RC
        !          21234:                        {       $$ = new block($<l>1,0,0,$<l>2); NOT_EXPECT_ID();}
        !          21235:                |  LC error RC
        !          21236:                        {       $$ = new block($<l>1,0,0,$<l>3); NOT_EXPECT_ID();}
        !          21237:                ;
        !          21238: 
        !          21239: simple         :  ee
        !          21240:                        {       $$ = new estmt(SM,curloc,$<pe>1,0);     }
        !          21241:                |  BREAK
        !          21242:                        {       $$ = new stmt(BREAK,$<l>1,0); }
        !          21243:                |  CONTINUE
        !          21244:                        {       $$ = new stmt(CONTINUE,$<l>1,0); }
        !          21245:                |  GOTO ID
        !          21246:                        {       $$ = new lstmt(GOTO,$<l>1,$<pn>2,0); }
        !          21247:                |  DO { stmt_seen=1; } caselab_stmt WHILE condition
        !          21248:                        {       $$ = new estmt(DO,$<l>1,$<pe>5,$<ps>3); }
        !          21249:                |  ASM LP STRING RP
        !          21250:                        {       
        !          21251:                                if (stmt_seen)
        !          21252:                                        $$ = new estmt(ASM,curloc,(Pexpr)$<s>3,0);
        !          21253:                                else {
        !          21254:                                        Pname n = new name(make_name('A'));
        !          21255:                                        n->tp = new basetype(ASM,(Pname)$<s>3);
        !          21256:                                        if (cd)
        !          21257:                                                cd->add_list(n);
        !          21258:                                        else
        !          21259:                                                cd = new nlist(n);
        !          21260:                                        $$ = 0;
        !          21261:                                }
        !          21262:                        }
        !          21263:                ;
        !          21264: 
        !          21265: sm             : {
        !          21266:                        if ( NEXTTOK() != SM ) {
        !          21267:                                error("`;' missing afterS");
        !          21268:                                la_backup(yychar,yylval);
        !          21269:                                yychar = SM;
        !          21270:                        }
        !          21271:                  } SM
        !          21272:                ;
        !          21273: 
        !          21274: statement      :  simple sm
        !          21275:                |  SM
        !          21276:                        {       $$ = new estmt(SM,$<l>1,dummy,0); }
        !          21277:                |  RETURN e SM
        !          21278:                        {       $$ = new estmt(RETURN,$<l>1,$<pe>2,0); }
        !          21279:                |  TYPE STRING block
        !          21280:                        {
        !          21281:                                error("local linkage specification");
        !          21282:                                $$ = $<pn>3;
        !          21283:                        }
        !          21284:                |  data_dcl
        !          21285:                        {       Pname n = $<pn>1;
        !          21286:                                if (n) {
        !          21287: //error('d',"adding local dcl of%n%t ll %d in_typedef%t",n,n->tp,n->lex_level,in_typedef);
        !          21288:                                        if (stmt_seen) {
        !          21289:                                                $$ = new block(n->where,n,0);
        !          21290:                                                $<ps>$->base = DCL;
        !          21291:                                        }
        !          21292:                                        else {
        !          21293:                                                if (cd)
        !          21294:                                                        cd->add_list(n);
        !          21295:                                                else
        !          21296:                                                        cd = new nlist(n);
        !          21297:                                                $$ = 0;
        !          21298:                                        }
        !          21299:                                } // if n
        !          21300:                        }
        !          21301:                |  att_fct_def
        !          21302:                        {
        !          21303:                                Pname n = $<pn>1;
        !          21304:                                error(&n->where,"%n's definition is nested (did you forget a ``}''?)",n);
        !          21305:                                if (cd)
        !          21306:                                        cd->add_list(n);
        !          21307:                                else
        !          21308:                                        cd = new nlist(n);
        !          21309:                                $$ = 0;
        !          21310:                        }
        !          21311:                |  block
        !          21312:                |  IF condition caselab_stmt
        !          21313:                        {       $$ = new ifstmt($<l>1,$<pe>2,$<ps>3,0); }
        !          21314:                |  IF condition caselab_stmt ELSE caselab_stmt
        !          21315:                        {       $$ = new ifstmt($<l>1,$<pe>2,$<ps>3,$<ps>5); }
        !          21316:                |  WHILE condition caselab_stmt
        !          21317:                        {       $$ = new estmt(WHILE,$<l>1,$<pe>2,$<ps>3); }
        !          21318:                |  FOR LP { stmt_seen=1; } caselab_stmt e SM e RP caselab_stmt
        !          21319:                        {       $$ = new forstmt($<l>1,$<ps>4,$<pe>5,$<pe>7,$<ps>9); }
        !          21320:                |  SWITCH condition caselab_stmt
        !          21321:                        {       $$ = new estmt(SWITCH,$<l>1,$<pe>2,$<ps>3); }
        !          21322:                |  ID COLON { $$ = $1; stmt_seen=1; } caselab_stmt
        !          21323:                        {       Pname n = $<pn>3;
        !          21324:                                $$ = new lstmt(LABEL,n->where,n,$<ps>4);
        !          21325:                        }
        !          21326:                |  TNAME COLON { $$ = new name($<pn>1->string); stmt_seen=1; } caselab_stmt
        !          21327:                        {       Pname n = $<pn>3;
        !          21328:                                $$ = new lstmt(LABEL,n->where,n,$<ps>4);
        !          21329:                        }
        !          21330:                |  CASE { stmt_seen=1; } e COLON caselab_stmt
        !          21331:                        {       if ($<pe>3 == dummy) error("empty case label");
        !          21332:                                $$ = new estmt(CASE,$<l>1,$<pe>3,$<ps>5);
        !          21333:                        }
        !          21334:                |  DEFAULT COLON { stmt_seen=1; } caselab_stmt
        !          21335:                        {       $$ = new stmt(DEFAULT,$<l>1,$<ps>4); }
        !          21336:                ;
        !          21337: 
        !          21338: 
        !          21339: 
        !          21340: /********************* expressions: returns Pexpr **************/
        !          21341: elist          : ex_list
        !          21342:                        {       Pexpr e = expr_unlist($<el>1);
        !          21343:                                while (e && e->e1==dummy) {
        !          21344:                                        register Pexpr ee2 = e->e2;
        !          21345:                                        if (ee2) error("EX inEL");
        !          21346:                                        delete e;
        !          21347:                                        e = ee2;
        !          21348:                                }
        !          21349:                                $$ = e;
        !          21350:                        }
        !          21351:                ;
        !          21352: 
        !          21353: ex_list                :  initializer          %prec CM
        !          21354:                        {       $<el>$ = new elist(new expr(ELIST,$<pe>1,0)); }
        !          21355:                |  ex_list CM initializer
        !          21356:                        {       $<el>1->add(new expr(ELIST,$<pe>3,0)); }
        !          21357:                ;
        !          21358: 
        !          21359: initializer    :  e                            %prec CM
        !          21360:                |  LC elist RC
        !          21361:                        {
        !          21362:                                if ( in_arg_list ) 
        !          21363:                                                error( "syntax error: IrL not permitted in AL" );
        !          21364:                                else if ( in_binit_list )
        !          21365:                                        error( "syntax error: IrL not permitted inMIr" );
        !          21366:                                else 
        !          21367:                                        init_seen = 1;
        !          21368:                                Pexpr e;
        !          21369:                                if ($2)
        !          21370:                                        e = $<pe>2;
        !          21371:                                else
        !          21372:                                        e = new expr(ELIST,dummy,0);
        !          21373:                                $$ = new expr(ILIST,e,0);
        !          21374:                        }
        !          21375:                ;
        !          21376: 
        !          21377: ee             :  ee ASSIGN ee
        !          21378:                        {       bbinop: $$ = new expr($<t>2,$<pe>1,$<pe>3); }
        !          21379:                |  ee PLUS ee   {       goto bbinop; }
        !          21380:                |  ee MINUS ee  {       goto bbinop; }
        !          21381:                |  ee MUL ee    {       goto bbinop; }
        !          21382:                |  ee AND ee    {       goto bbinop; }
        !          21383:                |  ee OR ee     {       goto bbinop; }
        !          21384:                |  ee ER ee     {       goto bbinop; }
        !          21385:                |  ee SHIFTOP ee        {       goto bbinop; }
        !          21386:                |  ee EQUOP ee  {       goto bbinop; }
        !          21387:                |  ee DIVOP ee  {       goto bbinop; }
        !          21388:                |  ee RELOP ee  {       goto bbinop; }
        !          21389:                |  ee GT ee     {       goto bbinop; }
        !          21390:                |  ee LT ee     {       goto bbinop; }
        !          21391:                |  ee ANDAND ee {       goto bbinop; }
        !          21392:                |  ee OROR ee   {       goto bbinop; }
        !          21393:                |  ee ASOP ee   {       goto bbinop; }
        !          21394:                |  ee CM ee     {       goto bbinop; }
        !          21395:                |  ee QUEST ee COLON ee
        !          21396:                        {       $$ = new qexpr($<pe>1,$<pe>3,$<pe>5); }
        !          21397:                |  DELETE term 
        !          21398:                        { $$ = new expr(DELETE,$<pe>2,0); }
        !          21399:                |  DELETE LB e RB term
        !          21400:                        {
        !          21401:                                if($<pe>3 != dummy) {
        !          21402:                                        if ( warning_opt || strict_opt )
        !          21403:                                                error(strict_opt?0:'w',"v in `delete[v]' is redundant; use `delete[] instead (anachronism)");
        !          21404:                                }
        !          21405:                                $$ = new expr(DELETE,$<pe>5,$<pe>3);
        !          21406:                        }
        !          21407:                |  MEM DELETE term 
        !          21408:                        {       $$ = new expr(GDELETE,$<pe>3,0); }
        !          21409:                |  MEM DELETE LB e RB term
        !          21410:                        {
        !          21411:                                if($<pe>4 != dummy) { 
        !          21412:                                        if ( warning_opt || strict_opt )
        !          21413:                                                error(strict_opt?0:'w',"v in `::delete[v]' is redundant; use `::delete[] instead (anachronism)");
        !          21414:                                }
        !          21415:                                $$ = new expr(DELETE,$<pe>6,$<pe>4);
        !          21416:                        }
        !          21417:                |  term
        !          21418:                ; 
        !          21419: 
        !          21420: e              :  e ASSIGN e
        !          21421:                        {       binop:  $$ = new expr($<t>2,$<pe>1,$<pe>3); }
        !          21422:                |  e PLUS e     {       goto binop; }
        !          21423:                |  e MINUS e    {       goto binop; }
        !          21424:                |  e MUL e      {       goto binop; }
        !          21425:                |  e AND e      {       goto binop; }
        !          21426:                |  e OR e       {       goto binop; }
        !          21427:                |  e ER e       {       goto binop; }
        !          21428:                |  e SHIFTOP e  {       goto binop; }
        !          21429:                |  e EQUOP e    {       goto binop; }
        !          21430:                |  e DIVOP e    {       goto binop; }
        !          21431:                |  e RELOP e    {       goto binop; }
        !          21432:                |  e LT e       {       goto binop; }
        !          21433:                |  e GT e       {       goto binop; }
        !          21434:                |  e ANDAND e   {       goto binop; }
        !          21435:                |  e OROR e     {       goto binop; }
        !          21436:                |  e ASOP e     {       goto binop; }
        !          21437:                |  e CM e       {       goto binop; }
        !          21438:                |  e QUEST e COLON e
        !          21439:                        {       $$ = new qexpr($<pe>1,$<pe>3,$<pe>5); }
        !          21440:                |  DELETE term 
        !          21441:                        {       $$ = new expr(DELETE,$<pe>2,0); }
        !          21442:                |  DELETE LB e RB term
        !          21443:                        {
        !          21444:                                if($<pe>3 != dummy) {
        !          21445:                                        if ( warning_opt || strict_opt )
        !          21446:                                                error(strict_opt?0:'w',"v in `delete[v]' is redundant; use `delete[] instead (anachronism)");
        !          21447:                                }
        !          21448:                                $$ = new expr(DELETE,$<pe>5,$<pe>3);
        !          21449:                        }
        !          21450:                |  MEM DELETE term 
        !          21451:                        {       $$ = new expr(GDELETE,$<pe>3,0); }
        !          21452:                |  MEM DELETE LB e RB term
        !          21453:                        {
        !          21454:                                if($<pe>4 != dummy) {
        !          21455:                                        if ( warning_opt || strict_opt )
        !          21456:                                                error(strict_opt?0:'w',"v in `::delete[v]' is redundant; use `::delete[] instead (anachronism)");
        !          21457:                                }
        !          21458:                                $$ = new expr(DELETE,$<pe>6,$<pe>4);
        !          21459:                        }
        !          21460:                |  term { 
        !          21461:                        init_seen = 0; 
        !          21462:                        } 
        !          21463:                |  %prec NO_EXPR
        !          21464:                        {       $$ = dummy; }
        !          21465:                ; 
        !          21466: 
        !          21467: term           :  NEW cast_type        { goto new1; }
        !          21468:                |  NEW new_type
        !          21469:                        {       new1:
        !          21470:                                Ptype t = $<pn>2->tp;
        !          21471:                                $$ = new texpr(NEW,t,0);
        !          21472:                        }
        !          21473:                |  MEM NEW cast_type    { goto new3; }
        !          21474:                |  MEM NEW new_type
        !          21475:                        {       new3:
        !          21476:                                Ptype t = $<pn>3->tp;
        !          21477:                                $$ = new texpr(GNEW,t,0);
        !          21478:                        }
        !          21479:                |  term ICOP
        !          21480:                        {       $$ = new expr($<t>2,$<pe>1,0); }
        !          21481:                |  cast_type term %prec ICOP
        !          21482:                        {       $$ = new texpr(CAST,$<pn>1->tp,$<pe>2); }
        !          21483:                |  MUL term
        !          21484:                        {       $$ = new expr(DEREF,$<pe>2,0); }
        !          21485:                |  AND term
        !          21486:                        {       $$ = new expr(ADDROF,0,$<pe>2); }
        !          21487:                |  MINUS term
        !          21488:                        {       $$ = new expr(UMINUS,0,$<pe>2); }
        !          21489:                |  PLUS term
        !          21490:                        {       $$ = new expr(UPLUS,0,$<pe>2); }
        !          21491:                |  NOT term
        !          21492:                        {       $$ = new expr(NOT,0,$<pe>2); }
        !          21493:                |  COMPL term
        !          21494:                        {       $$ = new expr(COMPL,0,$<pe>2); }
        !          21495:                |  ICOP term
        !          21496:                        {       $$ = new expr($<t>1,0,$<pe>2); }
        !          21497:                |  SIZEOF term
        !          21498:                        {       
        !          21499:                                $$ = new texpr(SIZEOF,0,$<pe>2); 
        !          21500:                                in_sizeof = 0;
        !          21501:                        }
        !          21502:                |  SIZEOF cast_type %prec SIZEOF
        !          21503:                        {       
        !          21504:                                $$ = new texpr(SIZEOF,$<pn>2->tp,0); 
        !          21505:                                in_sizeof = 0;
        !          21506:                        }
        !          21507:                |  term LB e RB
        !          21508:                        {       $$ = new expr(DEREF,$<pe>1,$<pe>3); }
        !          21509:                |  term REF prim
        !          21510:                        {       $$ = new ref(REF,$<pe>1,$<pn>3); }
        !          21511:                |  term REFMUL term
        !          21512:                        {       $$ = new expr($<t>2,$<pe>1,$<pe>3); }
        !          21513:                |  term REF qualified_tname
        !          21514:                        {       $$ = new ref(REF,$<pe>1,Ncopy($<pn>3)); }
        !          21515:                |  term DOT prim
        !          21516:                        {       $$ = new ref(DOT,$<pe>1,$<pn>3); }
        !          21517:                |  term DOT qualified_tname
        !          21518:                        {       $$ = new ref(DOT,$<pe>1,Ncopy($<pn>3)); }
        !          21519:                |  prim
        !          21520:                |  term_elist 
        !          21521:                        {
        !          21522:                        if ( init_seen )
        !          21523:                                error( "syntax error:IrL illegal within ()");
        !          21524:                        }
        !          21525: 
        !          21526:                |  term_lp e RP
        !          21527:                        {
        !          21528:                                if ( $2 == dummy )
        !          21529:                                        error("syntax error: nullE");
        !          21530:                                $$ = $2;
        !          21531:                        }
        !          21532:                |  ZERO
        !          21533:                        {       $$ = zero; }
        !          21534:                |  ICON
        !          21535:                        {       $$ = new expr(ICON,0,0);
        !          21536:                                $<pe>$->string = copy_if_need_be($<s>1);
        !          21537:                        }
        !          21538:                |  FCON
        !          21539:                        {       $$ = new expr(FCON,0,0);
        !          21540:                                $<pe>$->string = copy_if_need_be($<s>1);
        !          21541:                        }
        !          21542:                |  STRING
        !          21543:                        {       $$ = new expr(STRING,0,0);
        !          21544:                                $<pe>$->string = copy_if_need_be($<s>1);
        !          21545:                        }
        !          21546:                |  CCON
        !          21547:                        {       $$ = new expr(CCON,0,0);
        !          21548:                                $<pe>$->string = copy_if_need_be($<s>1);
        !          21549:                        }
        !          21550:                |  THIS
        !          21551:                        {       $$ = new expr(THIS,0,0); }
        !          21552:                ;
        !          21553: 
        !          21554: term_elist     : TYPE LP elist RP
        !          21555:                        {       $$ = new texpr(VALUE,tok_to_type($<t>1),$<pe>3); }
        !          21556: /*
        !          21557:                |  qualified_tname LP elist RP
        !          21558: */
        !          21559:                |  tname LP elist RP
        !          21560:                        {       $$ = new texpr(VALUE,$<pn>1->tp,$<pe>3); }
        !          21561:                 |  NEW term_lp elist RP cast_type    { goto new2; }
        !          21562:                 |  NEW term_lp elist RP new_type     /* allow separate allocation */
        !          21563:                        {       new2:
        !          21564:                                Ptype t = $<pn>5->tp;
        !          21565:                                $$=new texpr(NEW,t,0);
        !          21566:                                $<pe>$->e2 = $<pe>3;
        !          21567:                        }
        !          21568:                |  MEM NEW term_lp elist RP cast_type   { goto new4; }
        !          21569:                |  MEM NEW term_lp elist RP new_type    /* allow separate allocation */
        !          21570:                        {       new4:
        !          21571:                                Ptype t = $<pn>6->tp;
        !          21572:                                $$ = new texpr(GNEW,t,0);
        !          21573:                                $<pe>$->e2 = $<pe>4;
        !          21574:                        }
        !          21575:                |  term LP elist RP
        !          21576:                        {       
        !          21577:                                Pexpr ee = $<pe>3;
        !          21578:                                Pexpr e = $<pe>1;
        !          21579:                                if (e->base==NEW || e->base==GNEW)
        !          21580:                                        e->e1 = ee;
        !          21581:                                else
        !          21582:                                        $$ = new call(e,ee);
        !          21583:                        }
        !          21584: 
        !          21585:                ;
        !          21586: 
        !          21587: ptname         : PTNAME lt temp_inst_parms  gt
        !          21588:                  {
        !          21589:                    $<pn>$ =parametrized_typename($<pn>1,(expr_unlist($<el>3))); 
        !          21590:                 }
        !          21591:                ;
        !          21592: 
        !          21593: tscope         :  TSCOPE
        !          21594:                        {       
        !          21595:                                $<pn>$ = $<pn>1; 
        !          21596:                                curr_scope = $<pn>1;
        !          21597:                        }
        !          21598:                        |  MEM { $<pn>$ = sta_name; }
        !          21599:                |  ptname TSCOPE { $<pn>$ = $<pn>1; }
        !          21600:                ;
        !          21601: 
        !          21602: 
        !          21603: prim           :  ID
        !          21604:                        {       $$ = $<pn>1; }
        !          21605:        /*XXX*/ |  tn_list ID
        !          21606:                        {       $$ = Ncopy($<pn>2);
        !          21607:                                $<pn>$->n_qualifier = $<pn>1;
        !          21608:                        }
        !          21609:                |  OPERATOR oper
        !          21610:                        {       $$ = new name(oper_name($2));
        !          21611:                                $<pn>$->n_oper = $<t>2;
        !          21612:                        }
        !          21613:                |  tn_list OPERATOR oper
        !          21614:                        {       $$ = new name(oper_name($3));
        !          21615:                                $<pn>$->n_oper = $<t>3;
        !          21616:                                $<pn>$->n_qualifier = $<pn>1;
        !          21617:                        }
        !          21618:                |  OPERATOR c_type
        !          21619:                        {       $$ = $2;
        !          21620:                                sig_name($<pn>$);
        !          21621:                        }
        !          21622:                |  tn_list OPERATOR c_type
        !          21623:                        {       $$ = $3;
        !          21624:                                sig_name($<pn>$);
        !          21625:                                $<pn>$->n_qualifier = $<pn>1;
        !          21626:                        }
        !          21627:                |  tn_list COMPL tag    /* allow explicit call of destructor */
        !          21628:                        {       
        !          21629:                                if (strcmp($<pn>1->string,$<pn>3->string)) error("syntax error: inconsistent destructor notation");
        !          21630:                                $$ = new name(oper_name(DTOR));
        !          21631:                                $<pn>$->n_oper = DTOR;
        !          21632:                                $<pn>$->n_qualifier = $<pn>1;
        !          21633:                        }
        !          21634:                ;
        !          21635: 
        !          21636: 
        !          21637: 
        !          21638: /****************** abstract types (return type Pname) *************/
        !          21639: cast_type      :  term_lp type cast_decl RP 
        !          21640:                        { $$ = Ncast($2,$<pn>3); }
        !          21641:                ;
        !          21642: 
        !          21643: term_lp                :  LP { check_cast(); }
        !          21644:                ;
        !          21645: 
        !          21646: c_tp           :  TYPE 
        !          21647:                        {
        !          21648:                                TOK t = $<t>1;
        !          21649: 
        !          21650:                                switch (t) {
        !          21651:                                case FRIEND:
        !          21652:                                case OVERLOAD:
        !          21653:                                case REGISTER:
        !          21654:                                case STATIC:
        !          21655:                                case EXTERN:
        !          21656:                                case AUTO:
        !          21657:                                case VIRTUAL:
        !          21658:                                        error("%k in operatorT",t);
        !          21659:                                        t = INT;
        !          21660:                                        
        !          21661:                                }
        !          21662: 
        !          21663:                                $$ = new basetype(t,0);
        !          21664: 
        !          21665:                        }
        !          21666:                |  tname        { $$ = new basetype(TYPE,$<pn>1); }
        !          21667:                |  c_tp TYPE            
        !          21668:                        { 
        !          21669:                                if ( DECL_TYPE != -1 ) {
        !          21670:                                        switch ($<pb>1->base) { Pbase bt;
        !          21671:                                        case COBJ: case EOBJ:
        !          21672:                                                bt = new basetype(0,0);
        !          21673:                                                *bt = *$<pb>1;
        !          21674:                                                DEL($<pb>1);
        !          21675:                                                $<pb>1 = bt;
        !          21676:                                        }
        !          21677:                                        $$ = $<pb>1->type_adj($<t>2); 
        !          21678:                                }
        !          21679:                                DECL_TYPE = 0;
        !          21680:                        }
        !          21681:                |  c_tp tname
        !          21682:                        { 
        !          21683:                                if ( DECL_TYPE != -1 ) 
        !          21684:                                        $$ = $<pb>1->name_adj($<pn>2);
        !          21685:                                DECL_TYPE = 0;
        !          21686:                        }
        !          21687:                ;
        !          21688: 
        !          21689: c_type         :  c_tp c_decl  { $$ = Ncast($1,$<pn>2); }
        !          21690:                ;
        !          21691: 
        !          21692: new_type       :  type new_decl        { $$ = Ncast($1,$<pn>2); };
        !          21693: 
        !          21694: arg_type       :  type arg_decl
        !          21695:                        {       
        !          21696:                          //      ENTER_NAME($<pn>2);
        !          21697:                                $$ = Ndata($1,$<pn>2); 
        !          21698:                        }
        !          21699:                 |  type arg_decl ASSIGN
        !          21700:                         {
        !          21701:                         //      ENTER_NAME($<pn>2);
        !          21702:                         }
        !          21703:                    initializer
        !          21704:                         {       $$ = Ndata($1,$<pn>2);
        !          21705:                                 $<pn>$->n_initializer = $<pe>5;
        !          21706:                         }
        !          21707:                 ;
        !          21708: 
        !          21709: arg_lp         :  LP 
        !          21710:                        {//PUSH_ARG_SCOPE 
        !          21711:                                SAVE_STATE();
        !          21712:                                check_decl(); 
        !          21713:                                in_arg_list=1; 
        !          21714:                                $$ = modified_tn;
        !          21715:                                modified_tn = 0;
        !          21716:                        }
        !          21717:                ;
        !          21718: 
        !          21719: arg_list       :  arg_lp arg_type_list ellipsis_opt RP fct_attributes
        !          21720:                    {
        !          21721:                        $$ = new fct(0,name_unlist($<nl>2),$<t>3); 
        !          21722:                        if ( NEXTTOK() != COLON ) in_arg_list=0;
        !          21723:                        //in_arg_list=0;
        !          21724:                        Pfct($<pt>$)->f_const = ($<i>5 & 1);
        !          21725:                        if ( parsing_class_members
        !          21726:                        ||   (NEXTTOK()!=LC && yychar!=COLON)) {
        !          21727:                                end_al($1,1);
        !          21728:                         //POP_SCOPE(); // similar to end_al()
        !          21729:                        } else
        !          21730:                                end_al($1,0);
        !          21731:                        RESTORE_STATE();
        !          21732:                    }
        !          21733:                ;
        !          21734: 
        !          21735: arg_type_list  :  arg_type_list CM at
        !          21736:                        {
        !          21737:                                if ($3)
        !          21738:                                        if ($1)
        !          21739:                                                $<nl>1->add($<pn>3);
        !          21740:                                        else {
        !          21741:                                                error("AD syntax");
        !          21742:                                                $<nl>$ = new nlist($<pn>3); 
        !          21743:                                        }
        !          21744:                                else
        !          21745:                                        error("AD syntax");
        !          21746:                        }
        !          21747:                |  at   %prec CM
        !          21748:                        {
        !          21749:                                if ($1) $<nl>$ = new nlist($<pn>1); 
        !          21750:                        }
        !          21751:                ;
        !          21752: 
        !          21753: at             :  arg_type
        !          21754:                |  %prec EMPTY  {       $$ = 0; }
        !          21755:                ;
        !          21756: 
        !          21757: ellipsis_opt   :  /* empty */
        !          21758:                    {   $$ = 1; }
        !          21759:                |  ELLIPSIS
        !          21760:                    {   $$ = ELLIPSIS; }
        !          21761:                |  CM ELLIPSIS
        !          21762:                    {   $$ = ELLIPSIS; }
        !          21763:                ;
        !          21764: 
        !          21765: ptr            :  MUL %prec NO_ID
        !          21766:                        {
        !          21767:                        $$ = new ptr(PTR,0); 
        !          21768:                        EXPECT_ID();
        !          21769:                        }
        !          21770:                |  AND %prec NO_ID
        !          21771:                        {
        !          21772:                        $$ = new ptr(RPTR,0); 
        !          21773:                        EXPECT_ID();
        !          21774:                        }
        !          21775:                |  MUL TYPE %prec NO_ID
        !          21776:                        {       $$ = doptr(PTR,$<t>2); }
        !          21777:                |  ptr TYPE %prec NO_ID
        !          21778:                        {       
        !          21779:                                switch ( $<t>2 ) {
        !          21780:                                case CONST:
        !          21781:                                      $<pp>1->rdo = 1; break;
        !          21782:                                case VOLATILE:
        !          21783:                                     error('w',"\"volatile\" not implemented (ignored)");
        !          21784:                                     break;
        !          21785:                                default:
        !          21786:                                    error( "syntax error: *%k", $<t>2 );
        !          21787:                                }
        !          21788:                                $$ = $<pp>1; 
        !          21789:                        }
        !          21790:                |  AND TYPE %prec NO_ID
        !          21791:                        {       $$ = doptr(RPTR,$<t>2); }
        !          21792:                |  ptname MEMPTR %prec NO_ID
        !          21793:                        {       goto memptr1;  }
        !          21794:                |  MEMPTR %prec NO_ID
        !          21795:                        {
        !          21796:                        memptr1:
        !          21797:                        $$ = new ptr(PTR,0);
        !          21798:                        $<pp>$->memof = Pclass(Pbase($<pn>1->tp)->b_name->tp);
        !          21799:                        EXPECT_ID();
        !          21800:                        }
        !          21801:                |  ptname MEMPTR TYPE %prec NO_ID
        !          21802:                        {       
        !          21803:                                $<t>2 = $<t>3;
        !          21804:                                goto memptr2;  
        !          21805:                        }
        !          21806:                |  MEMPTR TYPE %prec NO_ID
        !          21807:                        {       
        !          21808:                                memptr2:
        !          21809:                                $$ = doptr(PTR,$<t>2);
        !          21810:                                $<pp>$->memof = Pclass(Pbase($<pn>1->tp)->b_name->tp);
        !          21811:                        }
        !          21812:                ;
        !          21813: 
        !          21814: vec            :  LB e RB              { $$ = new vec(0,$<pe>2!=dummy?$<pe>2:0 ); }
        !          21815:                |  NOT %prec LB         { $$ = new vec(0,0); }
        !          21816:                ;
        !          21817: 
        !          21818: %%
        !          21819: 
        !          21820: static void
        !          21821: check_tag()
        !          21822: /*
        !          21823:         Allow the case of inline/virtual/overload as 
        !          21824:         modifiers of return type of form struct/class/union x foo() 
        !          21825:         SM, COLON, LC ==> real class declaration, not return type
        !          21826: */
        !          21827: {
        !          21828:        switch ( NEXTTOK() ) {
        !          21829:        case SM: case COLON: case LC:
        !          21830:                declTag = 1;
        !          21831:                break;
        !          21832:        default:
        !          21833:                declTag = 0;
        !          21834:                break;
        !          21835:         }
        !          21836: }
        !          21837: 
        !          21838: static void
        !          21839: end_al( Plist mtn, int rst )
        !          21840: // unhide type names hidden by arg names
        !          21841: // mtn == saved modified_tn
        !          21842: {
        !          21843:        if ( rst == 0 ) {
        !          21844:                // not really an arg list, or we are entering a function def
        !          21845:                // merge modified_tn and don't restore
        !          21846:                if ( modified_tn == 0 ) modified_tn = mtn;
        !          21847:                else {
        !          21848:                        for ( Plist l = modified_tn; l->l; l = l->l ) ;
        !          21849:                        l->l = mtn;
        !          21850:                }
        !          21851:        } else {
        !          21852:                restore();
        !          21853:                modified_tn = mtn;
        !          21854:        }
        !          21855: }
        !          21856: static void
        !          21857: arg_redec( Pname fn )
        !          21858: {
        !          21859:        if ( fn==0 || fn->tp->base != FCT )
        !          21860:                error('i',"bad inline rewrite!");
        !          21861:        Pname al = Pfct(fn->tp)->argtype;
        !          21862:        Pname n = 0;
        !          21863:        for ( ;  al;  al = al->n_list ) {
        !          21864:                DB( if(Ydebug>=1)error('d',"arg_redec:  %n  %d",al,al->lex_level); );
        !          21865:                // nested function args should have lex_level >= 1
        !          21866:                if ( al->lex_level==1 && (n=ktbl->look(al->string,0)) )
        !          21867:                        n->hide();
        !          21868:                else if ( al->lex_level>1 && (n=ktbl->look(al->string,LOCAL)) )
        !          21869:                        n->hide();
        !          21870:                DB( if(Ydebug>=1)error('d',"   %n",n); );
        !          21871:        }
        !          21872: }
        !          21873: 
        !          21874: 
        !          21875: 0707071010112046011004440001630000160000010211100466055415400000700000014643hash.c/* ident "@(#)ctrans:src/hash.c     1.2" */
        !          21876: /*
        !          21877:     $Header: /usr2/odi/libmisc/RCS/hash.C,v 1.11 90/03/22 09:24:07 sam Exp $
        !          21878: 
        !          21879:     Copyright (c) 1989 by Object Design, Inc., Burlington, Mass.
        !          21880:     All rights reserved.
        !          21881: 
        !          21882: */
        !          21883: 
        !          21884: #include <stdio.h>
        !          21885: #include "hash.h" 
        !          21886: #include <osfcn.h>
        !          21887: 
        !          21888: #define EMPTY   0
        !          21889: #define VALID   1
        !          21890: #define DELETED 2
        !          21891: 
        !          21892: void default_Hash_error_handler(const char* msg)
        !          21893: {
        !          21894:   fprintf(stderr, "Fatal Hash error: %s\n", msg) ;
        !          21895:   exit(1) ;
        !          21896: }
        !          21897: 
        !          21898: Error_Proc Hash_error_handler = default_Hash_error_handler ;
        !          21899: 
        !          21900: Error_Proc set_Hash_error_handler(Error_Proc f)
        !          21901: {
        !          21902:   Error_Proc old = Hash_error_handler ;
        !          21903:   Hash_error_handler = f ;
        !          21904:   return old ;
        !          21905: }
        !          21906: 
        !          21907: void Hash::error(const char* msg)
        !          21908: {
        !          21909:   (*Hash_error_handler)(msg) ;
        !          21910: }
        !          21911: 
        !          21912: Hash::Hash(int sz= DEFAULT_INITIAL_HASH_SIZE)
        !          21913: {
        !          21914:   tab = new HashTableEntry[size = sz] ;
        !          21915:   for (int i = 0; i < size; ++i) tab[i].status = EMPTY ;
        !          21916:   entry_count = 0 ;
        !          21917: }
        !          21918: 
        !          21919: Hash::Hash(Hash& a)
        !          21920: {
        !          21921:   tab = new HashTableEntry[size = a.size] ;
        !          21922: 
        !          21923:   key_hash_function = a.key_hash_function ;
        !          21924:   key_key_equality_function = a.key_key_equality_function ;
        !          21925: 
        !          21926:   for (int i = 0; i < size; ++i) tab[i].status = EMPTY ;
        !          21927:   entry_count = 0 ;
        !          21928:   for (HashWalker p(a); p; p.advance())
        !          21929:     (*this)[p.key()] = p.get() ;
        !          21930: }
        !          21931: 
        !          21932: Hash& Hash::operator = (Hash& a)
        !          21933: {
        !          21934:   if (a.tab != tab)
        !          21935:   {
        !          21936:     clear() ;
        !          21937:     delete [size] tab ;
        !          21938:     tab = new HashTableEntry[size = a.size] ;
        !          21939:     for (int i = 0; i < size; ++i) tab[i].status = EMPTY ;
        !          21940:     entry_count = 0 ;
        !          21941:     for (HashWalker p(a); p; p.advance())
        !          21942:       (*this)[p.key()] = p.get() ;
        !          21943:   }
        !          21944:   return *this ;
        !          21945: }
        !          21946: 
        !          21947: /* 
        !          21948:  * hashing method: double hash based on high bits of hash fct,
        !          21949:  * followed by linear probe. Can't do too much better if Assoc
        !          21950:  * sizes not constrained to be prime.
        !          21951: */
        !          21952: 
        !          21953: 
        !          21954: static inline doublehashinc(unsigned int h, int s)
        !          21955: {
        !          21956:   return ((h / s) % s) >> 1 ;
        !          21957: }
        !          21958: 
        !          21959: // IWBNI we knew whether we were being called as an lvalue or rvalue.
        !          21960: // If the former, then we wouldn't have to scan through the whole
        !          21961: // table just to tell if we should rehash or not.  Sigh.
        !          21962: int& Hash::operator [](int key)
        !          21963: {
        !          21964:   unsigned int hashval = key_hash(key) ;
        !          21965:   while (1)
        !          21966:     {
        !          21967:       int bestspot = -1 ;
        !          21968:       int h = hashval % size ;
        !          21969:       for (int i = 0; i <= size; ++i)
        !          21970:        {
        !          21971:          if (tab[h].status == EMPTY)
        !          21972:            {
        !          21973:              // resize if the hash table is more than 87.5% full
        !          21974:              if (entry_count > ((size>>1)+(size>>2)+(size>>3)))
        !          21975:                // resize and insert again
        !          21976:                break ;
        !          21977:              if (bestspot < 0) bestspot = h ;
        !          21978:              tab[bestspot].key = key ;
        !          21979:              tab[bestspot].status = VALID ;
        !          21980:              ++entry_count ;
        !          21981:              return tab[bestspot].cont ;
        !          21982:            }
        !          21983:          else if (tab[h].status == DELETED)
        !          21984:            {
        !          21985:              if (bestspot < 0) bestspot = h ;
        !          21986:            }
        !          21987:          else if (key_key_eq(tab[h].key, key))
        !          21988:            return tab[h].cont ;
        !          21989:          if (i == 0)
        !          21990:            h = (h + doublehashinc(hashval, size)) % size ;
        !          21991:          else if (++h >= size)
        !          21992:            h -= size ;
        !          21993:        }
        !          21994:       resize(size << 1)  ;
        !          21995:     }
        !          21996: }
        !          21997: 
        !          21998: /* This seems convoluted, but it does whatever you want without
        !          21999:    redundant probing of the hash table. */
        !          22000: 
        !          22001: void Hash::action (int key, int val, insert_action what,
        !          22002:                   int& found, int& old_val)
        !          22003: {
        !          22004:   unsigned int hashval = key_hash(key) ;
        !          22005:   while (1)
        !          22006:     {
        !          22007:       int bestspot = -1 ;
        !          22008:       int h = hashval % size ;
        !          22009:       for (int i = 0; i <= size; ++i)
        !          22010:        {
        !          22011:          if (tab[h].status == EMPTY)
        !          22012:            {
        !          22013:              // resize if the hash table is more than 87.5% full
        !          22014:              if (entry_count > ((size>>1)+(size>>2)+(size>>3)))
        !          22015:                // resize and insert again
        !          22016:                break ;
        !          22017:              if (bestspot < 0) bestspot = h ;
        !          22018:              found = 0;
        !          22019:              if(what != probe) {
        !          22020:                tab[bestspot].key = key ;
        !          22021:                tab[bestspot].status = VALID ;
        !          22022:                ++entry_count ;
        !          22023:                tab[bestspot].cont = val;
        !          22024:              } 
        !          22025:              return;
        !          22026:            }
        !          22027:          else if (tab[h].status == DELETED)
        !          22028:            {
        !          22029:              if (bestspot < 0) bestspot = h ;
        !          22030:            }
        !          22031:          else if (key_key_eq(tab[h].key, key)) {
        !          22032:            found = 1;
        !          22033:            old_val = tab[h].cont;
        !          22034:            if(what == replace) 
        !          22035:              tab[h].cont = val;
        !          22036:            return;
        !          22037:          }
        !          22038:          if (i == 0)
        !          22039:            h = (h + doublehashinc(hashval, size)) % size ;
        !          22040:          else if (++h >= size)
        !          22041:            h -= size ;
        !          22042:        }
        !          22043:       resize(size << 1)  ;
        !          22044:     }
        !          22045: }
        !          22046: 
        !          22047: int Hash::contains(int key)
        !          22048: {
        !          22049:   unsigned int hashval = key_hash(key) ;
        !          22050:   int h = hashval % size ;
        !          22051:   for (int i = 0; i <= size; ++i)
        !          22052:   {
        !          22053:     if (tab[h].status == EMPTY)
        !          22054:       return 0 ;
        !          22055:     else if (tab[h].status == VALID && key_key_eq(tab[h].key, key))
        !          22056:       return 1 ;
        !          22057:     if (i == 0)
        !          22058:       h = (h + doublehashinc(hashval, size)) % size ;
        !          22059:     else if (++h >= size)
        !          22060:       h -= size ;
        !          22061:   }
        !          22062:   return 0 ;
        !          22063: }
        !          22064: 
        !          22065: int Hash::del(int key)
        !          22066: {
        !          22067:   unsigned int hashval = key_hash(key) ;
        !          22068:   int h = hashval % size ;
        !          22069:   for (int i = 0; i <= size; ++i)
        !          22070:   {
        !          22071:     if (tab[h].status == EMPTY)
        !          22072:       return 0 ;
        !          22073:     else if (tab[h].status == VALID && key_key_eq(tab[h].key, key))
        !          22074:     {
        !          22075:       tab[h].status = DELETED ;
        !          22076:       --entry_count ;
        !          22077:       return 1 ;
        !          22078:     }
        !          22079:     if (i == 0)
        !          22080:       h = (h + doublehashinc(hashval, size)) % size ;
        !          22081:     else if (++h >= size)
        !          22082:       h -= size ;
        !          22083:   }
        !          22084:   return 0 ;
        !          22085: }
        !          22086: 
        !          22087: void Hash::apply(intProc f)
        !          22088: {
        !          22089:   for (int i = 0; i < size; ++i)
        !          22090:     if (tab[i].status == VALID)
        !          22091:       (*f)(tab[i].cont) ;
        !          22092: }
        !          22093: 
        !          22094: void Hash::clear()
        !          22095: {
        !          22096:   for (int i = 0; i < size; ++i)
        !          22097:     tab[i].status = EMPTY ;
        !          22098:   entry_count = 0 ;
        !          22099: }
        !          22100: 
        !          22101: void Hash::resize(int newsize)
        !          22102: {
        !          22103:   if (newsize < entry_count)
        !          22104:     error("requested resize too small") ;
        !          22105:   HashTableEntry* oldtab = tab ;
        !          22106:   int oldsize = size ;
        !          22107:   tab = new HashTableEntry[size = newsize] ;
        !          22108:   for (int i = 0; i < size; ++i) 
        !          22109:     tab[i].status = EMPTY ;
        !          22110:   entry_count = 0 ;
        !          22111:   for (i = 0; i < oldsize; ++i)
        !          22112:     if (oldtab[i].status == VALID)
        !          22113:       (*this)[oldtab[i].key] = oldtab[i].cont ;
        !          22114:   delete [oldsize] oldtab ;
        !          22115: }
        !          22116: 
        !          22117: void HashWalker::reset()
        !          22118: {
        !          22119:   for (pos = 0; pos < h->size; ++pos)
        !          22120:     if (h->tab[pos].status == VALID)
        !          22121:       return ;
        !          22122:   pos = -1 ;
        !          22123: }
        !          22124: 
        !          22125: void HashWalker::advance()
        !          22126: {
        !          22127:   if (pos < 0)
        !          22128:     return ;
        !          22129:   for (pos++; pos < h->size; ++pos)
        !          22130:     if (h->tab[pos].status == VALID)
        !          22131:       return ;
        !          22132:   pos = -1 ;
        !          22133: }
        !          22134: 
        !          22135: /*
        !          22136: unsigned int foo(int bar) {return bar;}
        !          22137: int baz(int a, int b) {return a == b;}
        !          22138: 
        !          22139: main()
        !          22140: {
        !          22141:   Hash vh(10)  ;
        !          22142:   HashWalker vt(vh)  ;
        !          22143:   int i  ;
        !          22144: 
        !          22145:   vh.key_hash_function = &foo  ;
        !          22146:   vh.key_key_equality_function = baz  ;
        !          22147:   printf("Capacity=%d \n", vh.capacity()) ;
        !          22148:   for (i=0; i<500; i+= 5)
        !          22149:     {
        !          22150:       vh[i] = i * i  ;
        !          22151:     }
        !          22152:   vt.reset() ;
        !          22153:   while (vt.valid())
        !          22154:     {
        !          22155:       printf("key=%d, data=%d\t", vt.key(), vt.get());
        !          22156:       vt.advance()  ;
        !          22157:     }
        !          22158:   for (i=0; i<500; i+= 10)
        !          22159:     {
        !          22160:       vh.del (i) ;
        !          22161:       printf("After delete: %d\n", vh[i]);
        !          22162:     }
        !          22163:   printf("\n-----------------\n") ;
        !          22164:   vt.reset() ;
        !          22165:   while (vt.valid())
        !          22166:     {
        !          22167:       printf("key=%d, data=%d\t", vt.key(), vt.get());
        !          22168:       vt.advance()  ;
        !          22169:     }
        !          22170: }
        !          22171: 
        !          22172: */
        !          22173: 0707071010112046061004440001630000160000010212400466055420200000700000011465hash.h/* ident "@(#)ctrans:src/hash.h     1.2" */
        !          22174: /* Compiler interface to hash tables from odi library. 
        !          22175:        $Source: /usr3/lang/benson/work/stripped_cfront/RCS/hash.h,v $ $RCSfile: hash.h,v $
        !          22176:        $Revision: 1.1 $                $Date: 89/11/20 08:50:36 $
        !          22177:        $Author: benson $               $Locker:  $
        !          22178:        $State: Exp $
        !          22179: 
        !          22180:     $Header: /usr2/odi/objectstore.src/libos/RCS/hash.H,v 1.4 89/09/26 09:37:31 benson Exp $
        !          22181: 
        !          22182:     Copyright (c) 1989 by Object Design, Inc., Burlington, Mass.
        !          22183:     All rights reserved.
        !          22184: 
        !          22185: */
        !          22186: 
        !          22187: #ifndef _HASH_H
        !          22188: #define _HASH_H
        !          22189: 
        !          22190: #include <string.h>
        !          22191: 
        !          22192: typedef void (*Error_Proc) (const char*) ;
        !          22193: 
        !          22194: extern void default_Hash_error_handler (const char*) ;
        !          22195: extern Error_Proc Hash_error_handler ;
        !          22196: extern Error_Proc set_Hash_error_handler (Error_Proc f) ;
        !          22197: 
        !          22198: #ifndef _hash_typedefs
        !          22199: #define _hash_typedefs 1
        !          22200: typedef void (*intProc)(int) ;
        !          22201: #endif
        !          22202: 
        !          22203: #define DEFAULT_INITIAL_HASH_SIZE 100
        !          22204: 
        !          22205: struct HashTableEntry
        !          22206: {
        !          22207:   int                   key ;
        !          22208:   int                   cont ;
        !          22209:   char                  status ;
        !          22210: } ;
        !          22211: 
        !          22212: class HashWalker ;
        !          22213: 
        !          22214: class Hash
        !          22215: {
        !          22216:   friend class          HashWalker ;
        !          22217: 
        !          22218:   HashTableEntry*       tab ;
        !          22219:   int                   size ;
        !          22220:   int                   entry_count ;
        !          22221: 
        !          22222: public:
        !          22223:   unsigned int         (*key_hash_function)(int)  ;
        !          22224:    int                 (*key_key_equality_function) (int, int) ;
        !          22225: 
        !          22226:   unsigned int          key_hash(int  a) ;
        !          22227:   int                   key_key_eq(int a, int  b);    
        !          22228: 
        !          22229:                         Hash(int sz) ;
        !          22230:                         Hash(Hash& a) ;
        !          22231:                         ~Hash() ;
        !          22232: 
        !          22233:   Hash&                 operator= (Hash& a) ;
        !          22234: 
        !          22235:   int                   count() ;
        !          22236:   int                   empty() ;
        !          22237:   int                   full() ;
        !          22238:   int                   capacity() ;
        !          22239: 
        !          22240:   void                  clear() ;
        !          22241:   void                  resize(int newsize) ;
        !          22242: 
        !          22243:   enum insert_action   { probe, insert, replace };
        !          22244:   void                 action (int key, int val, insert_action what,
        !          22245:                                int& found, int& old_val);
        !          22246:   int&                  operator [] (int  k) ;
        !          22247:   int                   contains(int  key) ;
        !          22248:   int                   del(int  key) ;
        !          22249: 
        !          22250:   void                  apply (intProc f) ;
        !          22251:   void                  error(const char* msg) ;
        !          22252: } ;
        !          22253: 
        !          22254: class HashWalker
        !          22255: {
        !          22256:   Hash*     h ;
        !          22257:   int                   pos ;
        !          22258: 
        !          22259: public:
        !          22260:                         HashWalker(Hash& l) ;
        !          22261:                         ~HashWalker() ;
        !          22262: 
        !          22263:   int                   null() ;
        !          22264:   int                   valid() ;
        !          22265:                         operator void* () ;
        !          22266:   int                   operator ! () ;
        !          22267:   void                  advance() ;
        !          22268:   void                  reset() ;
        !          22269:   void                  reset(Hash& l) ;
        !          22270:   const int&            key() ;
        !          22271:   int&                  get() ;
        !          22272: } ;
        !          22273: 
        !          22274: inline unsigned int Hash::key_hash(int a)
        !          22275: {
        !          22276: #ifdef HASHFUNCTION
        !          22277:   return HASHFUNCTION(a) ;
        !          22278: #else
        !          22279:   return (*key_hash_function)(a) ;
        !          22280: #endif
        !          22281: }
        !          22282: 
        !          22283: inline int Hash::key_key_eq(int a, int b)
        !          22284: {
        !          22285: #ifdef EQUALITYFUNCTION
        !          22286:   return EQUALITYFUNCTION(a, b) ;
        !          22287: #else
        !          22288:   return (*key_key_equality_function)(a, b) ;
        !          22289: #endif
        !          22290: }
        !          22291: 
        !          22292: 
        !          22293: inline Hash::~Hash()
        !          22294: {
        !          22295:   delete [size] tab ;
        !          22296: }
        !          22297: 
        !          22298: inline int Hash::count()
        !          22299: {
        !          22300:   return entry_count ;
        !          22301: }
        !          22302: 
        !          22303: inline int Hash::empty()
        !          22304: {
        !          22305:   return entry_count == 0 ;
        !          22306: }
        !          22307: 
        !          22308: inline int Hash::full()
        !          22309: {
        !          22310:   return entry_count == size ;
        !          22311: }
        !          22312: 
        !          22313: inline int Hash::capacity()
        !          22314: {
        !          22315:   return size ;
        !          22316: }
        !          22317: inline HashWalker::HashWalker(Hash& a)
        !          22318: {
        !          22319:   h = &a ;
        !          22320:   reset() ;
        !          22321: }
        !          22322: 
        !          22323: inline void HashWalker::reset(Hash& a)
        !          22324: {
        !          22325:   h = &a ;
        !          22326:   reset() ;
        !          22327: }
        !          22328: 
        !          22329: 
        !          22330: inline HashWalker::~HashWalker() {}
        !          22331: 
        !          22332: inline int HashWalker::null()
        !          22333: {
        !          22334:   return pos < 0 ;
        !          22335: }
        !          22336: 
        !          22337: inline int HashWalker::valid()
        !          22338: {
        !          22339:   return pos >= 0 ;
        !          22340: }
        !          22341: 
        !          22342: inline HashWalker::operator void* ()
        !          22343: {
        !          22344:   return (pos < 0)? 0 : this ;
        !          22345: }
        !          22346: 
        !          22347: inline int HashWalker::operator ! ()
        !          22348: {
        !          22349:   return (pos < 0) ;
        !          22350: }
        !          22351: 
        !          22352: 
        !          22353: inline const int& HashWalker::key()
        !          22354: {
        !          22355:   if (pos < 0)
        !          22356:     h->error("operation on null Walker") ;
        !          22357:   return h->tab[pos].key ;
        !          22358: }
        !          22359: 
        !          22360: inline int& HashWalker::get()
        !          22361: {
        !          22362:   if (pos < 0)
        !          22363:     h->error("operation on null Walker") ;
        !          22364:   return h->tab[pos].cont ;
        !          22365: }
        !          22366: 
        !          22367: inline int pointer_hasheq (int a, int b)
        !          22368: {
        !          22369:     return a == b;
        !          22370: };
        !          22371: 
        !          22372: inline unsigned int pointer_hash_fcn (int x)
        !          22373: {
        !          22374:     unsigned X = (unsigned) x;
        !          22375:     return ((X << 16) | (X >> 16)) ^ x;
        !          22376: }
        !          22377: 
        !          22378: class pointer_hash : public Hash {
        !          22379:   public:
        !          22380:     pointer_hash (int sz = 0) : Hash (sz) {
        !          22381:        key_hash_function = pointer_hash_fcn;
        !          22382:        key_key_equality_function = pointer_hasheq;
        !          22383:     }
        !          22384: 
        !          22385:     pointer_hash (pointer_hash& h) : Hash (h) {};
        !          22386: };
        !          22387: 
        !          22388: inline int string_hasheq (int a, int b)
        !          22389: {
        !          22390:     return !strcmp((char *)a, (char *) b);
        !          22391: };
        !          22392: 
        !          22393: static unsigned int string_hash_fcn (int x)
        !          22394: {
        !          22395:     char * str = (char *)x;
        !          22396:     int l = strlen(str);
        !          22397:        
        !          22398:     if(x <= 4) return str[0];
        !          22399:     else {
        !          22400:        unsigned int * f4 = (unsigned int *) str;
        !          22401:        if (l < 8) return ((*f4 << 16) | (*f4 >> 16)) ^ *f4;
        !          22402:        else {
        !          22403:            unsigned int * s4 = f4 ++;
        !          22404:            return ((*f4 << 16) | (*f4 >> 16)) ^ *s4;
        !          22405:        }
        !          22406:     }
        !          22407: };
        !          22408: 
        !          22409: 
        !          22410: class string_hash : public Hash {
        !          22411:     public:
        !          22412: 
        !          22413:     string_hash (int sz = 0) : Hash (sz) {
        !          22414:        key_hash_function = string_hash_fcn;
        !          22415:        key_key_equality_function = string_hasheq;
        !          22416:     };
        !          22417: 
        !          22418:     string_hash (string_hash& h) : Hash (h) {};
        !          22419: };
        !          22420: 
        !          22421: #endif
        !          22422: 0707071010112046071004440001630000160000010210470466055420500001500000001056ios_printf.h/* ident "@(#)ctrans:src/ios_printf.h 1.2" */
        !          22423: /* Begin iostream_printf.H -- printf functions that work on ostreams.
        !          22424:    someday, perhaps, scanf functions for istreams. */
        !          22425: 
        !          22426: #include <stdarg.h>
        !          22427: #include <iostream.h>
        !          22428: 
        !          22429: int vostream_printf(const char *format, va_list argp, ostream& fp);
        !          22430: int ostream_printf(ostream& stream, const char * format ...);
        !          22431: 
        !          22432: // returns count of characters added.
        !          22433: int printf_to_string (char * string, int length, const char * format ...);
        !          22434: 
        !          22435: // returns string which came from malloc.
        !          22436: char * printf_to_alloc_string (const char * format ...);
        !          22437: 0707071010112044331004440001630000160000010202700466055403600001000000134002lalex.c/*ident    "@(#)ctrans:src/lalex.c 1.15" */
        !          22438: /**************************************************************************
        !          22439: 
        !          22440:        C++ source for cfront, the C++ compiler front-end
        !          22441:        written in the computer science research center of Bell Labs
        !          22442: 
        !          22443:        Copyright (c) 1984 AT&T, Inc. All Rights Reserved
        !          22444:        THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T, INC.
        !          22445: 
        !          22446: lalex.c:
        !          22447: 
        !          22448:        lookahead 
        !          22449: 
        !          22450: *****************************************************************************/
        !          22451: #include <stdio.h>
        !          22452: 
        !          22453: #ifdef c_plusplus
        !          22454: overload is_empty;
        !          22455: #endif
        !          22456: 
        !          22457: #include "cfront.h"
        !          22458: #include "yystype.h"
        !          22459: #include "tqueue.h"
        !          22460: #include "template.h"
        !          22461: 
        !          22462: #ifdef DBG
        !          22463: #define LDB(val,a) { if(Ldebug>=val) {a;} }
        !          22464: #else
        !          22465: #define LDB(val,a) /**/
        !          22466: #endif
        !          22467: 
        !          22468: #ifdef DBG
        !          22469: static char*
        !          22470: image( int t )
        !          22471: {
        !          22472:        if(keys[t]) return keys[t];
        !          22473:        else { static char b[20];
        !          22474:                sprintf(b,"token(%d)",t);
        !          22475:                return b;
        !          22476:        }
        !          22477: }
        !          22478: static void
        !          22479: printok( toknode* t )
        !          22480: {
        !          22481:        switch(t->tok) {
        !          22482:        default:
        !          22483:                fprintf(stderr,"\t%s",image(t->tok));
        !          22484:                break;
        !          22485:        case ID: case ICON: case CCON: case FCON: case STRING:
        !          22486:                fprintf(stderr,"ID '%s'",t->retval.s);
        !          22487:                break;
        !          22488:        case TNAME:
        !          22489:                fprintf(stderr,"TNAME '%s'",t->retval.pn->string);
        !          22490:                break;
        !          22491:        case PTNAME:
        !          22492:                fprintf(stderr,"PTNAME '%s'",t->retval.pn->string);
        !          22493:                break;
        !          22494:        case TSCOPE:
        !          22495:                fprintf(stderr,"TSCOPE '%s'::",t->retval.pn->string);
        !          22496:                break;
        !          22497:        case MEMPTR:
        !          22498:                fprintf(stderr,"MEMPTR '%s'::*",t->retval.pn->string);
        !          22499:                break;
        !          22500:        }
        !          22501:        putc(' ',stderr);
        !          22502:        t->place.put(stderr);
        !          22503:        putc('\n',stderr);
        !          22504: }
        !          22505: static void
        !          22506: showQ( char* where )
        !          22507: /*
        !          22508:        display token Q
        !          22509: */
        !          22510: {
        !          22511:        fprintf(stderr,"TOKEN Q (%s):\n",where);
        !          22512:        for (register toknode* t = front; t; t = t->next) printok(t);
        !          22513:        putc('\n',stderr);
        !          22514: }
        !          22515: #endif
        !          22516: 
        !          22517: int bl_level;
        !          22518: 
        !          22519: static int  laexpr( TOK );
        !          22520: static int  latype( TOK );
        !          22521: static int  la_decl();
        !          22522: static TOK  lookahead();
        !          22523: 
        !          22524: /* make this a toknode! */
        !          22525: static int lasttk = 0;         // one token history
        !          22526: static YYSTYPE lastval;        // yylval lasttk value 
        !          22527: 
        !          22528: int must_be_expr = 0;          // handle redundant parentheses
        !          22529: int must_be_id = 0;            // !0, TNAME => ID, i.e., int X
        !          22530: 
        !          22531: loc curloc;
        !          22532: int curr_file;
        !          22533: 
        !          22534: toknode* latok;                        // current lookahead token
        !          22535: toknode* front = 0;
        !          22536: toknode* rear  = 0;
        !          22537: 
        !          22538: const  TQCHUNK = 16;
        !          22539: 
        !          22540: void*
        !          22541: toknode::operator new(size_t)
        !          22542: {
        !          22543:        register toknode* p;
        !          22544: 
        !          22545:        if ((p=free_toks) == 0) {
        !          22546:                register toknode* q;
        !          22547:                free_toks = q = (toknode*)malloc( TQCHUNK * sizeof(toknode) );
        !          22548:                p = free_toks;
        !          22549:                for (; q != &p[TQCHUNK-1]; q->next = q+1, ++q);
        !          22550:                q->next = 0;
        !          22551:        }
        !          22552:        free_toks = p->next;
        !          22553:        return p;
        !          22554: }
        !          22555: 
        !          22556: toknode::toknode(TOK t, YYSTYPE r, loc tloc)
        !          22557: {
        !          22558:        tok = t;
        !          22559:        used = 0;
        !          22560:        retval = r;
        !          22561:        place = tloc;
        !          22562:        next = last = 0;
        !          22563: }
        !          22564: 
        !          22565: void
        !          22566: toknode::operator delete(void* vp,size_t)
        !          22567: {
        !          22568:        register toknode* p = (toknode*)vp;
        !          22569:        p->next = free_toks;
        !          22570:        free_toks = p;
        !          22571:        vp = 0;
        !          22572: }
        !          22573: 
        !          22574: #define USE_TOKEN(T,W) \
        !          22575:        LDB(2,error('d',&(T)->place,"use_token('%k','%s')",(T)->tok,W);); \
        !          22576:        if ( !(T)->used ) use_token(T);
        !          22577: 
        !          22578: Ptype
        !          22579: return_nstd_local_type( Pname n, TOK &sw )
        !          22580: { 
        !          22581:        Ptype tt;
        !          22582:        switch ( n->tp->base ) {
        !          22583:                case EOBJ:
        !          22584:                case COBJ:
        !          22585:                        tt = Pbase(n->tp)->b_name->tp;
        !          22586:                        sw = n->tp->base;
        !          22587:                        break;
        !          22588:                default:
        !          22589:                        tt = n->tpdef;
        !          22590:                        sw = NESTED; // in repr.c, prints ``typedef''
        !          22591:                        break;
        !          22592:        }
        !          22593:        return tt;
        !          22594: }
        !          22595: 
        !          22596: static Pname
        !          22597: local_nested_kludge( Pname n, Pname tn )
        !          22598: /*
        !          22599:  * for backward compatibility with 2.0
        !          22600:  * in transitional model of nested class types
        !          22601:  * 
        !          22602:  * struct T { ... };
        !          22603:  * foobar() {
        !          22604:  *     class X {
        !          22605:  *             typedef int T;
        !          22606:  *             // ...
        !          22607:  *     };
        !          22608:  *     T t;
        !          22609:  * }
        !          22610:  *
        !          22611:  * pure nested classes, choose global struct T{};
        !          22612:  * no nested classes, choose typedef int T
        !          22613:  * transitional model: choose typedef, and generate warning
        !          22614:  * BUG: local typedefs and enums do not have lex_level set
        !          22615:  */
        !          22616: {
        !          22617: // error( 'd', "local_nested_kludge: n: %n", n );
        !          22618:        for ( Pname nn = n; nn; nn = nn->n_tbl_list )
        !          22619:        {
        !          22620:                Pname local_class;
        !          22621:                TOK ntd;
        !          22622:                if ( nn->n_key != NESTED ) continue;
        !          22623:                Ptype tt = return_nstd_local_type(nn,ntd);
        !          22624:                Pclass cl = tt->in_class;
        !          22625:                while ( cl->in_class ) cl = cl->in_class;
        !          22626:                if (cl->lex_level && 
        !          22627:                        (local_class = ktbl->look(cl->string,LOCAL)))
        !          22628:                {
        !          22629:                        // same typedef at nested and non-nested scope
        !          22630:                        if (ntd == NESTED && tn && tn->tp == nn->tp )
        !          22631:                                ; 
        !          22632:                        else
        !          22633:                                error('w',"%s occurs at outer and nested localC scope; using %k %t::%s", n->string,ntd,cl,n->string);
        !          22634: 
        !          22635: /*
        !          22636:                        if ( ntd == NESTED && nn->n_dcl_printed != 2 ) {
        !          22637:                                nn->dcl_print(0);
        !          22638:                                nn->n_dcl_printed = 2;
        !          22639:                        }
        !          22640: */
        !          22641:                        return nn;
        !          22642:                }
        !          22643:        }
        !          22644:        return 0;
        !          22645: }
        !          22646: 
        !          22647: enum { one_back, two_back };
        !          22648:        
        !          22649: static void
        !          22650: use_token( toknode* T )
        !          22651: /*
        !          22652:        lookup TNAMEs here instead of in tlex()
        !          22653:        maintain block level
        !          22654: */
        !          22655: {
        !          22656:        static TOK last_tokens[2];  // TSCOPE not reduced at this point
        !          22657:        static Pname last_tname;    // tname :: id, where id is nested class
        !          22658:        static Pname tdef_name;     // typedef tname tdef_name
        !          22659:        T->used = 1;
        !          22660: 
        !          22661:        DB(if(Ldebug>=1) {
        !          22662:                error('d',&T->place,"\n*** use_token(%k )",T->tok);
        !          22663:                printok(T);
        !          22664:                error('D',&T->place,"    lasttk%k last_tname%n last tokens%k%k",lasttk,last_tname,last_tokens[one_back],last_tokens[two_back]);
        !          22665:        });
        !          22666: 
        !          22667:        switch ( T->tok ) {
        !          22668:        case ID:
        !          22669:                Pname n;
        !          22670: // error('d', &T->place, "use_token: %s", T->retval.s );
        !          22671:                if ( last_tokens[one_back] == MEM &&
        !          22672:                        last_tokens[two_back] == TNAME &&
        !          22673:                        (n=ktbl->look(T->retval.s,NESTED))) 
        !          22674:                { // TYPEDEF :: ID, nested class ctor 
        !          22675:                        if (tdef_name && tdef_name->n_key==NESTED &&
        !          22676:                                strcmp(tdef_name->string,n->string)==0)
        !          22677:                        {
        !          22678:                                T->tok = TNAME;
        !          22679:                                T->retval.pn = n;
        !          22680:                                break;
        !          22681:                        }       
        !          22682:                        else { // TNAME :: ID, where ID may be nested class
        !          22683:                        for ( Pname nn = n; nn; nn = nn->n_tbl_list )
        !          22684:                        {
        !          22685:                                TOK sw;
        !          22686:                                if ( nn->n_key != NESTED ) continue;
        !          22687:                                Ptype tt = return_nstd_local_type(nn,sw);
        !          22688:                                Pclass cl = tt->in_class;
        !          22689:                                if (strcmp(last_tname->string,cl->string)==0)
        !          22690:                                {
        !          22691:                                        T->tok = TNAME;
        !          22692:                                        T->retval.pn = nn;
        !          22693:                                        break;
        !          22694:                                }       
        !          22695:                        }
        !          22696:                        }
        !          22697:                }
        !          22698:                else
        !          22699:                if ( bl_level && 
        !          22700:                        // TNAME:: and :: cannot refer to ``local'' TNAME
        !          22701:                        last_tokens[one_back] != MEM  && 
        !          22702:                        (n=ktbl->look(T->retval.s,LOCAL)) ) 
        !          22703:                {
        !          22704:                        DB( if(Ldebug>=1)error( 'd', &T->place, "use_token: local class instance: %n", n ) );
        !          22705:                        T->tok = TNAME;
        !          22706:                        T->retval.pn = n;
        !          22707:                } 
        !          22708:                else if ( n=ktbl->look(T->retval.s,0) ) {
        !          22709:                        DB( if(Ldebug>=1)error( 'd', &T->place, "use_token:GC instance: %n", n ) );
        !          22710: // error( 'd', &T->place, "use_token:GC instance: %n %t", n, n->tp );
        !          22711: 
        !          22712:                        // X:: ?, then n cannot be a global TNAME
        !          22713:                        //      except in the case of a constructor
        !          22714:                        if (last_tokens[one_back] == MEM &&
        !          22715:                                last_tokens[two_back] == TNAME &&
        !          22716:                                strcmp(T->retval.s,last_tname->string))
        !          22717:                                        ; // do nothing; i.e., return ID
        !          22718:                        else 
        !          22719:                        if ( bl_level && n->tp->base != COBJ &&
        !          22720:                                last_tokens[one_back] == MEM &&
        !          22721:                                last_tokens[two_back] != TNAME &&
        !          22722:                                gtbl->look(T->retval.s,0))
        !          22723:                                        ; // do nothing: local typedefs & enums not implemented
        !          22724:                        else {
        !          22725:                                Pname nn = 0;
        !          22726:                                TOK ntd;
        !          22727:                                if (bl_level && (nn=ktbl->look(T->retval.s,NESTED)))
        !          22728:                                {
        !          22729:                                        (void) return_nstd_local_type(n,ntd);
        !          22730:                                        nn = local_nested_kludge(nn,ntd==NESTED?n:0);
        !          22731:                                }
        !          22732:                                T->tok = TNAME;
        !          22733:                                T->retval.pn = nn?nn:n;
        !          22734:                        }
        !          22735:                }
        !          22736: #ifdef DBG
        !          22737:                else if(Ldebug>=1)
        !          22738:                        error('d',&T->place,"use_token: id %s",T->retval.s);
        !          22739: #endif
        !          22740:                break;
        !          22741:        case LC: ++bl_level; break;
        !          22742:        case RC: --bl_level; break;
        !          22743:        }
        !          22744:        
        !          22745:        if (T->tok != COMPL || last_tokens[one_back] != MEM) {
        !          22746:                last_tokens[two_back] = last_tokens[one_back];
        !          22747:                last_tokens[one_back] = T->tok; 
        !          22748:                if (T->tok == TNAME) last_tname = T->retval.pn;
        !          22749:                if ( last_tname && 
        !          22750:                        last_tname->tp->base == TYPE )
        !          22751:                {
        !          22752:                        tdef_name = last_tname;
        !          22753:                        do
        !          22754:                                tdef_name = Pbase(tdef_name->tp)->b_name;
        !          22755:                        while ( tdef_name->tp->base == TYPE );
        !          22756:                }
        !          22757:        }
        !          22758: }
        !          22759: 
        !          22760: void
        !          22761: addtok(TOK t, YYSTYPE r, loc tloc)
        !          22762: {
        !          22763:        toknode* T = new toknode(t,r,tloc);
        !          22764:        if (front == 0)
        !          22765:                front = rear = T;
        !          22766:        else {
        !          22767:                rear->next = T;
        !          22768:                T->last = rear;
        !          22769:                rear = T;
        !          22770:        }
        !          22771: //error('d',&tloc,"addtok: %k '%s'",t,t==ID?r.s:"");
        !          22772: //showQ("addtok");
        !          22773: }
        !          22774: 
        !          22775: extern TOK
        !          22776: deltok( int noset = 0 )
        !          22777: {
        !          22778:        register toknode* T = front;
        !          22779:        USE_TOKEN(T,"deltok");
        !          22780:        register TOK tk = T->tok;
        !          22781:        if ( !noset ) { yylval = T->retval; curloc = T->place; }
        !          22782:        curr_file = curloc.file;
        !          22783:        if (front = front->next)
        !          22784:                front->last = 0;
        !          22785:        else
        !          22786:                latok = rear = 0;
        !          22787:        delete T;
        !          22788:        return tk;
        !          22789: }
        !          22790: 
        !          22791: static void
        !          22792: add_tokens()
        !          22793: /*
        !          22794:     extend lookahead token queue when depleted
        !          22795: */
        !          22796: {
        !          22797:     TOK tk = tlex();
        !          22798:     if ( tk != ID )
        !          22799:        return;
        !          22800: 
        !          22801:     while (tk == ID || tk == MEM || tk == DOT )  
        !          22802:        tk = tlex(); 
        !          22803: }
        !          22804: 
        !          22805: extern TOK
        !          22806: la_look()
        !          22807: /*
        !          22808:        peek at head of token queue
        !          22809: */
        !          22810: {
        !          22811:     LDB(1,fprintf(stderr,"\n*** la_look()"));
        !          22812:     if ( front == 0 )
        !          22813:        add_tokens();
        !          22814: 
        !          22815:     latok = front;
        !          22816:     USE_TOKEN(latok,"la_look");
        !          22817:     LDB(1,fprintf(stderr," -- %s\n",image(latok->tok)));
        !          22818:     return latok->tok;
        !          22819: }
        !          22820: 
        !          22821: #define NEXTTOK() ( (yychar==-1) ? (yychar=lalex(),yychar) : yychar )
        !          22822: void
        !          22823: check_decl()
        !          22824: /*
        !          22825:        Lookahead to direct parsing of local/arg type declarations
        !          22826:        la_decl() returns 1 if lookahead sees a declaration.
        !          22827: */
        !          22828: {
        !          22829:        TOK tk2;
        !          22830:        switch( NEXTTOK() ) {
        !          22831:        default:
        !          22832:        break;
        !          22833:        case TSCOPE: //XXX
        !          22834:                tk2 = la_look();
        !          22835:                while ( tk2 == TSCOPE ) tk2 = lookahead();
        !          22836:                if ( tk2 == TNAME ) {
        !          22837:                    toknode* t = latok;
        !          22838:                    if(t->tok!=TNAME)
        !          22839:                        error('i',&t->place,"check_decl() token scan");
        !          22840:                    tk2 = lookahead();
        !          22841:                    if ( tk2 == LP && la_decl() ) {
        !          22842:                        t->tok = DECL_MARKER; //TNAME
        !          22843:                    }
        !          22844:                }
        !          22845:                break;
        !          22846:        case TYPE: case TNAME:
        !          22847:            if ( la_look() == LP && la_decl() ) {
        !          22848:                must_be_id = 0;
        !          22849:                DECL_TYPE=yychar;
        !          22850:                yychar = DECL_MARKER;
        !          22851:            }
        !          22852:        }
        !          22853: }
        !          22854: 
        !          22855: void
        !          22856: check_cast()
        !          22857: /*
        !          22858:        Lookahead to direct parsing of cast
        !          22859:        la_cast() returns 1 if lookahead sees an ambiguous old-style C cast.
        !          22860: */
        !          22861: {
        !          22862:        TOK tk2;
        !          22863:        switch( NEXTTOK() ) {
        !          22864:        case TSCOPE: //XXX
        !          22865:                tk2 = la_look();
        !          22866:                while ( tk2 == TSCOPE ) tk2 = lookahead();
        !          22867:                if ( tk2 == TNAME ) {
        !          22868:                    toknode* t = latok;
        !          22869:                    if(t->tok!=TNAME)
        !          22870:                          error('i',&t->place,"check_cast() token scan");
        !          22871:                    tk2 = lookahead();
        !          22872:                    if ( tk2 == LP && la_decl() ) {
        !          22873:                        t->tok = DECL_MARKER;//TNAME
        !          22874:                    }
        !          22875:                }
        !          22876:                break;
        !          22877:        case TYPE: case TNAME:
        !          22878:            if ( la_look() == LP && la_cast() ) {
        !          22879:                must_be_id = 0;
        !          22880:                DECL_TYPE = yychar;
        !          22881:                yychar = DECL_MARKER;
        !          22882:            }
        !          22883:        }
        !          22884: }
        !          22885: 
        !          22886: 
        !          22887: static int
        !          22888: latype( TOK t )
        !          22889: {
        !          22890:        switch ( t ) {
        !          22891:        default: // includes friend, typedef, storage classes, etc.
        !          22892:                return 0;
        !          22893:        case CHAR: case SHORT: case INT: case LONG:
        !          22894:        case FLOAT: case DOUBLE:
        !          22895:         case UNSIGNED:
        !          22896:                return 1;
        !          22897:        }
        !          22898: }
        !          22899: 
        !          22900: static int
        !          22901: laexpr( TOK t )
        !          22902: {
        !          22903:        switch ( t ) {
        !          22904:        default: 
        !          22905:                return 0;
        !          22906:        case RETURN: case NEW: case AND: case ANDAND: case OR: case OROR:
        !          22907:        case SIZEOF: case NOT: case COMPL: case MUL: case PLUS: case MINUS: 
        !          22908:        case ER: case ASSIGN: case ASOP: case RELOP: case EQUOP: case DIVOP: 
        !          22909:        case SHIFTOP: case ICOP:
        !          22910:                return 1;
        !          22911:        }
        !          22912: }
        !          22913: 
        !          22914: static toknode *get_next_token(toknode *t) {
        !          22915:   if (! t->next)
        !          22916:     add_tokens() ;
        !          22917:   
        !          22918:   return t->next ;
        !          22919: }
        !          22920: 
        !          22921: 
        !          22922: static int template_tscope(Pname tn, toknode *lt) 
        !          22923: /* provide the looakhead for determining TSCOPE tokens when the name is a
        !          22924:  * parametrized type name; the lookahead here is non-trivial, because it
        !          22925:  * involves stepping over the template arguments. 
        !          22926:  */
        !          22927: {
        !          22928:   int nest = 0 ; // the LT has been fetched
        !          22929: 
        !          22930:   if (lt->tok != LT) error ('i', "a `<' token was expected") ;  
        !          22931: 
        !          22932:   // assume the worst, ensure that name strings are consed in the heap
        !          22933:   templp->parameters_in_progress++ ;
        !          22934:   
        !          22935:   for (toknode *t = lt;; t = get_next_token(t))    
        !          22936:     switch (t->tok) {
        !          22937:       
        !          22938:     case LT:
        !          22939:        ++nest;
        !          22940:        continue;
        !          22941:     case GT:
        !          22942:        // ***************
        !          22943:        // need to fold in awareness of x::y::z
        !          22944:        if (--nest == 0) {
        !          22945:                t = get_next_token(t);
        !          22946:                if (t->tok == MEM) {
        !          22947:                // determine whether it is a memptr
        !          22948:                        if (t->next == 0) add_tokens();
        !          22949:                        if (t->next->tok == MUL) {
        !          22950:                                t->tok = MEMPTR;
        !          22951:                                t->next = t->next->next ;
        !          22952:                } else  t->tok = TSCOPE ;
        !          22953:                t->retval.pn  = tn ;
        !          22954:                --templp->parameters_in_progress;
        !          22955:                return 1;
        !          22956:        } 
        !          22957:        else  return 0 ;
        !          22958:       }
        !          22959:       continue;
        !          22960: 
        !          22961:     case SM: case LC: case RC: // a quick exit in case of error
        !          22962:     case EOFTOK:
        !          22963:        --templp->parameters_in_progress;
        !          22964:        return 0 ;
        !          22965:       
        !          22966:     default:
        !          22967:        continue;
        !          22968:     }
        !          22969: }
        !          22970: 
        !          22971: static TOK
        !          22972: lookahead()
        !          22973: /*
        !          22974:     advance lookahead pointer, lexing at end of Q
        !          22975:     handle occurrences of TNAME and TSCOPE
        !          22976:     (should be kept up to date with lalex())
        !          22977: */
        !          22978: {
        !          22979:     TOK tk;
        !          22980:     TOK tk2;
        !          22981:     TOK prev_tk = 0;
        !          22982:     YYSTYPE lastval;
        !          22983: 
        !          22984:     if ( latok == rear ) {
        !          22985:        add_tokens();
        !          22986:        if ( latok )
        !          22987:            latok = latok->next;
        !          22988:        else
        !          22989:            latok = front;
        !          22990:     }
        !          22991:     else
        !          22992:        latok = latok->next;
        !          22993: 
        !          22994:     if ( latok->last ) {
        !          22995:        prev_tk = latok->last->tok;
        !          22996:        lastval = latok->last->retval;
        !          22997:     }
        !          22998: 
        !          22999: nexttok:
        !          23000:     USE_TOKEN(latok,"lookahead1");
        !          23001:     tk = latok->tok;
        !          23002:     if ( tk == ID || tk == TNAME ) 
        !          23003:     {
        !          23004:        if (latok->next == 0) add_tokens();
        !          23005:        USE_TOKEN(latok->next,"lookahead2");
        !          23006:        /* TOK */ tk2 = latok->next->tok;
        !          23007:        if ( tk == TNAME ) {
        !          23008:           if (tk2 == LT) {
        !          23009:              // a parametrized type name -- differentiate from TNAME 
        !          23010:              // so that it can be dealt with in the grammar. 
        !          23011:              if (template_tscope(latok->retval.pn, latok->next)) tk = PTNAME;
        !          23012:           }
        !          23013:            else  
        !          23014:           if ( tk2 == MEM || tk2 == DOT ) {
        !          23015: tscope:        
        !          23016:                tk = TSCOPE;
        !          23017: // error('d',"lookahead: tk: %k tk2: %k", tk, tk2 );
        !          23018: // XXX -- should be modified to loop and do lookup
        !          23019:                latok = latok->next;
        !          23020:                if (latok->next == 0) add_tokens();
        !          23021:                USE_TOKEN(latok->next,"lookahead3");
        !          23022:                tk2 = latok->next->tok;
        !          23023:                if ( tk2 == MUL ) {
        !          23024:                        tk = MEMPTR;
        !          23025:                        latok = latok->next;
        !          23026:                }
        !          23027:            }
        !          23028:            else if (( prev_tk == MUL && tk2 != RP )
        !          23029:                        || prev_tk == AND )
        !          23030:                {
        !          23031:                tk = ID;
        !          23032:                latok->retval.pn->hide();
        !          23033:                latok->tok = ID;
        !          23034:                latok->retval.s = latok->retval.pn->string;
        !          23035:                }
        !          23036:        }
        !          23037:        else if ( tk2 == MEM ) {
        !          23038:                // ID ::
        !          23039:        //XXX   latok = latok->next->next;
        !          23040:        //XXX   goto nexttok;
        !          23041:                goto tscope; // treat as tscope
        !          23042:        }
        !          23043: 
        !          23044:        if ( tk == ID &&
        !          23045:                ( tk2 == ID ||
        !          23046:                ( prev_tk == ID && ( tk2 == COLON || tk2 == LC )))) {
        !          23047:                        // ID ID
        !          23048:                        latok = latok->next;
        !          23049:                        goto nexttok;
        !          23050:                        }
        !          23051:     }
        !          23052: 
        !          23053:        if ( tk == ID ) {
        !          23054:                Pname nstd = ktbl->look(latok->retval.s,NESTED);
        !          23055:                if (nstd && (must_be_id == 0 ||
        !          23056:                        must_be_id && prev_tk == LP)) {
        !          23057: extern Pname check_for_nested(Pname,TOK,YYSTYPE,TOK); // use this in lalex, too
        !          23058:                                Pname n = check_for_nested(nstd,prev_tk,lastval,tk2);
        !          23059:                                if ( n ) {
        !          23060:                                        tk = latok->tok = TNAME;
        !          23061:                                        latok->retval.pn = n;
        !          23062:                                }
        !          23063:                }
        !          23064:        }
        !          23065: 
        !          23066:     return tk;
        !          23067: }
        !          23068: 
        !          23069: static Pname mem_sel = 0;
        !          23070: 
        !          23071: static Pname
        !          23072: do_local_class( Pname n, int lex_level ) 
        !          23073: { /*
        !          23074:    * modify to ``do_local_type:
        !          23075:    *   do local types: enums and typedefs
        !          23076:    */
        !          23077:        Pname nn = n;
        !          23078:        if ( n->tp ) { // already a TNAME
        !          23079:                Pclass cl = n->tp->base==COBJ ? Pclass(Pbase(n->tp)->b_name->tp) : 0;
        !          23080:                if ( n->lex_level != lex_level || (cl && cl->lcl) ) {
        !          23081:                        local_hide( n );
        !          23082:                        nn = new name( n->string );
        !          23083:                        nn->lex_level = lex_level>=0?lex_level:0;
        !          23084:                }
        !          23085:                else 
        !          23086:                if ( lex_level == n->lex_level && cl->defined ) {
        !          23087:                        error( "localC %n redefined", n );
        !          23088:                        return n;
        !          23089:                }
        !          23090:        }
        !          23091: 
        !          23092:        nn = nn->tname( lastval.t );
        !          23093:        modified_tn = modified_tn->l;
        !          23094:        nn->n_key = LOCAL;
        !          23095:        local_class = new name_list( nn, local_class );
        !          23096:        local_blk = new name_list( nn, local_blk );
        !          23097: 
        !          23098: // error('d', "do_local_class: nn %n tp %t", nn, Pclass(Pbase(nn->tp)->b_name->tp));
        !          23099:        return nn;
        !          23100: }
        !          23101: 
        !          23102: static char*
        !          23103: make_nested_name( char *s, Pclass cl )
        !          23104: { // Q<cnt>_<class_names><space><null>
        !          23105:        const nested_depth = 9;
        !          23106:        char *str_arr[nested_depth];
        !          23107:        int  size_arr[nested_depth];
        !          23108:        int cnt = 2;
        !          23109:        int size = 4; // Q,<cnt>,<_>,<null>
        !          23110: 
        !          23111:        str_arr[0] = s; str_arr[1] = cl->string; 
        !          23112: 
        !          23113:        size += size_arr[0] = strlen(s); 
        !          23114:        size += size_arr[1] = cl->strlen?cl->strlen:strlen(cl->string);
        !          23115: 
        !          23116:        for (Pclass nc = cl->in_class; nc; nc = nc->in_class ) {
        !          23117:                if (cnt > nested_depth-1) error('s',"nested depth class beyond %d unsupported",nested_depth);
        !          23118:                size += size_arr[cnt] = nc->strlen?nc->strlen:strlen(nc->string);
        !          23119:                str_arr[cnt++] = nc->string; 
        !          23120:        }
        !          23121: 
        !          23122:        for ( int i=0; i<cnt; i++ ) // <nnn><string>
        !          23123:                size += size_arr[i]>99?3:size_arr[i]<10?1:2;
        !          23124: 
        !          23125: //error('d', "make_nested_name( %s, %t ) cnt: %d size: %d", s, cl, cnt, size );
        !          23126:        char *result = new char[size];
        !          23127:        sprintf(result, "Q%d_", cnt );
        !          23128:        size = 3;
        !          23129:        for ( i=cnt; i; i-- ) {
        !          23130:                sprintf(result+size,"%d%s", size_arr[i-1], str_arr[i-1]);
        !          23131:                size += size_arr[i-1] + (size_arr[i-1]>99?3:size_arr[i-1]<10?1:2);
        !          23132:        }
        !          23133: 
        !          23134: //error('d', "size: %d ", size );
        !          23135:        result[size] = '\0';
        !          23136: //error('d', "make_nested_name result: %s", result );
        !          23137:        return result;
        !          23138: }
        !          23139: 
        !          23140: int is_empty( Pclass cl, bit const_chk )
        !          23141: { /*   for nested class check, empty means *no* members
        !          23142:    *    for const object check, means no *data* members
        !          23143:    */
        !          23144: 
        !          23145: // error('d',"%t->is_empty: max: %d real_size: %d", cl, cl->memtbl->max(),cl->real_size );
        !          23146: 
        !          23147:        int mbr_cnt = cl->memtbl->max();
        !          23148:        if ( mbr_cnt == 0 ) return 1;
        !          23149: 
        !          23150:        if ( cl->baselist == 0 && cl->real_size!=1 )
        !          23151:                return 0;
        !          23152: 
        !          23153:        // empty class to turn on transitional nested class scope
        !          23154:        if ( const_chk == 0 && 
        !          23155:                ( cl->baselist != 0 || mbr_cnt > 1 )) return 0;
        !          23156: 
        !          23157:        int i = 1;
        !          23158:        for (Pname nn=cl->memtbl->get_mem(i); nn; nn=cl->memtbl->get_mem(++i)) {
        !          23159:                if (nn->base==NAME && 
        !          23160:                        nn->n_union==0 && 
        !          23161:                        nn->tp->base!=FCT && 
        !          23162:                        nn->tp->base!=OVERLOAD && 
        !          23163:                        nn->tp->base!=CLASS && 
        !          23164:                        nn->tp->base!=ENUM && 
        !          23165:                        nn->tp->base!=EOBJ && 
        !          23166:                        nn->n_stclass != STATIC) 
        !          23167:                        {
        !          23168:                                if ( nn->string[0]=='_' &&
        !          23169:                                        nn->string[1]=='_' &&
        !          23170:                                        nn->string[2]=='W' )
        !          23171:                                                return 1;
        !          23172:                                else return 0;
        !          23173:                        }
        !          23174:        }
        !          23175: 
        !          23176:        return 1; // if here, no data members encountered
        !          23177: }
        !          23178: 
        !          23179: static int
        !          23180: is_empty( Penum en )
        !          23181: { // is this an empty enum ??
        !          23182: 
        !          23183: // error('d', "%t no_of_enumerators: %d", en, en->no_of_enumerators);
        !          23184:        if ( en->no_of_enumerators != 0 )
        !          23185:                return 0;
        !          23186: 
        !          23187:        return 1;
        !          23188: }
        !          23189: 
        !          23190: static Pname
        !          23191: check_nested_type( Pname nm )
        !          23192: {
        !          23193: // error('d', "check nested type: %n ccl: %t", nm, ccl );
        !          23194: 
        !          23195:        Pname nx, n = ktbl->look(nm->string, NESTED);
        !          23196:        if ( n == 0 || n == nm ) return nm;
        !          23197: 
        !          23198:        int cnt = 1;
        !          23199:        for (nx = n; n; n=n->n_tbl_list ) 
        !          23200:                if (n->n_key == NESTED) ++cnt;
        !          23201: 
        !          23202:        if ( cnt > 1 ) {
        !          23203:                error( "ambiguous nested type %s (%d instances), use x::y syntax", nm->string, cnt );
        !          23204:                error( 'i', "cannot recover from previous errors" );
        !          23205:        }
        !          23206:        else { 
        !          23207:                TOK ntk;
        !          23208:                Ptype tt = return_nstd_local_type(nx,ntk);
        !          23209:                error('w', "use %t:: to access nested %k %s (anachronism)", tt->in_class, ntk, nx->string);
        !          23210:        }
        !          23211:        return nx;
        !          23212: }
        !          23213: 
        !          23214: static int
        !          23215: in_local_class( Pclass cl )
        !          23216: {
        !          23217:        if ( cl->lex_level )
        !          23218:                return 1;
        !          23219:        if ( cl->in_class )
        !          23220:                return in_local_class( cl->in_class );
        !          23221:        return 0;
        !          23222: }
        !          23223: 
        !          23224: Pname
        !          23225: do_nested_type( Pname n ) 
        !          23226: {
        !          23227:        Pname nn = n;
        !          23228:        char *str = 0;
        !          23229: 
        !          23230: // error('d', "do_nested_type: %s in_typedef: %d ccl: %t", n->string, in_typedef, ccl );
        !          23231:        if ( in_typedef && ccl->string[0]=='_'
        !          23232:        &&  ccl->string[1]=='_'
        !          23233:        &&  ccl->string[2]=='C') return n;
        !          23234: 
        !          23235:        if ( n->tp ) 
        !          23236:         { // already a TNAME :
        !          23237:          // hide existing instance, encode new instance
        !          23238:          /*
        !          23239:           * need handle the anomaly:
        !          23240:           * class x;
        !          23241:           * x *p;
        !          23242:           * class y {
        !          23243:           *    class x{ ... }; // oops
        !          23244:           * };
        !          23245:           */
        !          23246:                if (n->tp->base==COBJ) {
        !          23247:                        Pclass cl = Pclass(Pbase(n->tp)->b_name->tp);
        !          23248:                        if (cl->defined == 0 && lasttk == AGGR) {
        !          23249:                                error('w',"forwardD ofC%n resolved to nested%t::%s",n,ccl,n->string);
        !          23250:                                cl->lcl = new char[9];
        !          23251:                                strcpy(cl->lcl,"FUDGE007"); // license to hack
        !          23252:                                n->lex_level=Pbase(n->tp)->b_name->lex_level=0;
        !          23253:                                return n;
        !          23254:                        }
        !          23255:                } 
        !          23256:                else if (n->tp->base==EOBJ) { // watch out for enum x;
        !          23257:                        Penum en = Penum(Pbase(n->tp)->b_name->tp);
        !          23258:                        if (en->defined == 0 && lasttk == ENUM) return n;
        !          23259:                }
        !          23260: 
        !          23261:                nested_hide( n );
        !          23262:                nn = new name( n->string );
        !          23263:                str = make_nested_name( n->string, ccl );
        !          23264:        }
        !          23265:        else
        !          23266:        // make sure we haven't already seen a nested instance
        !          23267:        // if so, for transition, this needs to be an error
        !          23268:        if (ktbl->look( n->string, NESTED ))
        !          23269:                error("multiple type %s nestings (to do this define an empty class/enum %s {};)",n->string,n->string); 
        !          23270:        if ( in_typedef ) {
        !          23271:                if (strcmp(ccl->string, nn->string)==0) { // class x { typedef T x;
        !          23272:                        error( "nested Tdef %s redefines immediately enclosing class", nn->string );
        !          23273:                        error( 'i', "cannot recover from previous errors" );
        !          23274:                }
        !          23275: 
        !          23276:                // make sure there isn't an identifier at global scope being defined
        !          23277:                // by a nested typedef -- previously an error; keep it so for transition
        !          23278:                Pname tn;
        !          23279:                if ( n->tp == 0 && in_local_class(ccl)==0 &&
        !          23280:                      (tn=gtbl->look(n->string,0))) {
        !          23281:                        error( "nested Tdef %s redefinesG %n", n->string, tn );
        !          23282:                        error( 'i', "cannot recover from previous errors" );
        !          23283:                }
        !          23284: 
        !          23285:                nn->tpdef = new type;
        !          23286:                nn->tpdef->nested_sig = str;
        !          23287:                nn->tpdef->in_class = ccl;
        !          23288:                nn->tpdef->lex_level = NESTED;
        !          23289:                PERM(nn->tpdef);
        !          23290:        }
        !          23291:        else {
        !          23292:                nn = nn->tname( lastval.t );
        !          23293:                Pname tn = Pbase(nn->tp)->b_name;
        !          23294:                Ptype tt = tn->tp;
        !          23295:                if ( tt->defined && tt->in_class == ccl) {
        !          23296:                        error( "nested %t redefines immediately enclosing class", nn->string );
        !          23297:                        error( 'i', "cannot recover from previous errors" );
        !          23298:                }
        !          23299:                tt->nested_sig = str;
        !          23300:                modified_tn = modified_tn->l;
        !          23301:                nn->lex_level = tn->lex_level = 0;
        !          23302:                nested_type = new name_list( nn, nested_type );
        !          23303:        }
        !          23304:        nn->n_key = NESTED;
        !          23305:        return nn;
        !          23306: }
        !          23307: 
        !          23308: static Pname dtor_seen;
        !          23309: static int in_expr;
        !          23310: extern int in_sizeof;
        !          23311: 
        !          23312: extern TOK
        !          23313: lalex()
        !          23314: /*  return next token to grammar  */
        !          23315: {
        !          23316:     register TOK tk;
        !          23317:     if ( front == 0 )
        !          23318:        add_tokens();           // extend lookahead queue
        !          23319:     LDB(1,fprintf(stderr,"\n*** lalex()\n");showQ("before"));
        !          23320: 
        !          23321: gettok:
        !          23322:     tk = deltok();
        !          23323: // error('d',&curloc,"lalex: just got %k '%s' in_typedef: %d",tk,tk==ID?yylval.s:tk==TNAME?yylval.pn->string:"", in_typedef);
        !          23324: 
        !          23325:     if ( tk == ID || tk == TNAME ) 
        !          23326:     {
        !          23327:        TOK tk2 = la_look();
        !          23328:        int lex_level = bl_level - in_class_decl - (tk2 == LC );
        !          23329: 
        !          23330:        if ( tk == TNAME )
        !          23331:        {
        !          23332: //error('d', "lalex tname %n;   lasttk: %k tk2: %k", yylval.pn, lasttk, tk2);
        !          23333: //error('d', "    must_be_id: %d must_be_expr %d  decl_type %d",must_be_id,must_be_expr,DECL_TYPE);
        !          23334: //error('d', "    bl_level: %d parsing_members %d",bl_level,parsing_class_members);
        !          23335:            if ( tk2 == LP 
        !          23336:                && (bl_level == 0 || parsing_class_members) 
        !          23337:                && ( laexpr(lasttk) == 0 ) 
        !          23338:                && must_be_expr == 0
        !          23339:                && DECL_TYPE == 0 ) {
        !          23340:                        if (la_decl()) {
        !          23341:                                must_be_id = 0;
        !          23342:                                DECL_TYPE = tk;
        !          23343:                                tk = DECL_MARKER;
        !          23344:                                goto ret;
        !          23345:                        }
        !          23346:            }
        !          23347: 
        !          23348:            // note: *** can handle local typedefs here, too!
        !          23349:            if ( in_typedef && 
        !          23350:                        in_typedef->base != 0 && 
        !          23351:                        ccl && in_mem_fct == 0 &&
        !          23352:                        (tk2 == SM || tk2 == RP || tk2 == LB))
        !          23353:                                yylval.pn = do_nested_type(yylval.pn);
        !          23354:        
        !          23355:            if ( lasttk == AGGR || lasttk == ENUM ) {
        !          23356:                if ( tk2 == LC || tk2 == COLON ) { // class definition  
        !          23357:                        if ( lex_level 
        !          23358:                                && (in_class_decl==0 || in_mem_fct)
        !          23359:                                && lasttk != ENUM )  // temporary
        !          23360:                                        yylval.pn = do_local_class( yylval.pn, lex_level );
        !          23361:                        else 
        !          23362:                        if ( in_class_decl && ccl )
        !          23363:                                yylval.pn = do_nested_type( yylval.pn );
        !          23364:                }
        !          23365:            } 
        !          23366: 
        !          23367:           if (tk2 == LT) {
        !          23368:              // a parametrized type name
        !          23369:              if (template_tscope(yylval.pn,latok)) 
        !          23370:                        tk = PTNAME ;
        !          23371:           } else  
        !          23372:           if ( tk2 == MEM || (tk2 == DOT && mem_sel == 0 )) {  
        !          23373:                if (tk2==DOT)
        !          23374:                        error(strict_opt?0:'w',"``.'' used for qualification; please use ``::'' (anachronism)");
        !          23375: crunch:
        !          23376:                tk = TSCOPE;
        !          23377:                {//XXX -- should be modified to do lookup and del at each ::
        !          23378:                  while ( (tk2 = lookahead()) == TSCOPE ) ;
        !          23379:                  if ( tk2 == TNAME ) {
        !          23380:                        tk2 = lookahead();
        !          23381:                        if ( tk2 == LP 
        !          23382:                        && (bl_level == 0 || parsing_class_members) 
        !          23383:                        && ( laexpr(lasttk) == 0 ) 
        !          23384:                        && must_be_expr == 0
        !          23385:                        && DECL_TYPE == 0 ) {
        !          23386:                                if (la_decl()) {
        !          23387:                                        must_be_id = 0;
        !          23388:                                        //DECL_TYPE = tk;//???
        !          23389:                                        DECL_TYPE = TNAME;
        !          23390:                                        //front should be ::
        !          23391:                                        front->tok = TSCOPE;
        !          23392:                                        front->retval.pn = yylval.pn;
        !          23393:                                        yylval.pn = 0;
        !          23394:                                        tk = DECL_MARKER;
        !          23395:                                        goto ret;
        !          23396:                                }
        !          23397:                        }
        !          23398:                  }
        !          23399:                }
        !          23400:                tk2 = deltok(1);
        !          23401:                tk2 = la_look();
        !          23402:                if ( tk2 == MUL ) {
        !          23403:                        tk = MEMPTR;
        !          23404:                        tk2 = deltok(1);
        !          23405:                }
        !          23406:            }
        !          23407:            // Have a TNAME.  Check to be sure.
        !          23408:            else if ( must_be_id ){
        !          23409: //error('d',"lalex: must_be_id: <tname %n> <%k>",yylval.pn,tk2);
        !          23410:                if ( in_class_decl 
        !          23411:                        && lasttk == TYPE 
        !          23412:                        && tk2 == LP
        !          23413:                        && strcmp(yylval.pn->string,ccl->string) == 0 )
        !          23414:                        error("%nK with returnT", yylval.pn);
        !          23415: 
        !          23416:                else if ( lasttk == TYPE && lastval.t == OVERLOAD
        !          23417:                          && ( tk2 == SM || tk2 == LP ) )
        !          23418:                        { 
        !          23419:                        tk = ID;
        !          23420:                        yylval.pn->hide();
        !          23421:                        yylval.pn = new name( yylval.pn->string );
        !          23422:                        yylval.pn->n_oper = TNAME;
        !          23423:                        }
        !          23424:                else if ( lasttk == OPERATOR ||
        !          23425:                        in_typedef && yylval.pn->n_key == NESTED)
        !          23426:                                must_be_id = 0;
        !          23427:                else if ( lasttk != TSCOPE // watch out for X::X
        !          23428:                     || lastval.pn != yylval.pn 
        !          23429:                     || (in_typedef && 
        !          23430:                                in_typedef->check( yylval.pn->tp,0) == 0 )) 
        !          23431:                {
        !          23432:                        tk = ID;
        !          23433:                        if ( in_typedef && (lasttk == MUL || lasttk == REF)) {
        !          23434:                                defer_check = 1;
        !          23435:                                in_tag = yylval.pn;
        !          23436:                        }
        !          23437: 
        !          23438:                        if ( lasttk == MEM && yylval.pn->lex_level ) {
        !          23439:                                Pname nn = gtbl->look( yylval.pn->string, 0 );
        !          23440:                                if (nn == 0 )
        !          23441:                                        error( "%k%s undeclared", lasttk, yylval.pn->string);
        !          23442:                                else
        !          23443:                                        yylval.pn = nn;
        !          23444:                        }
        !          23445:                        else {
        !          23446: // error('d',"lalex: else: lasttk: %k", lasttk );
        !          23447:                                if (lasttk!=DOT && lasttk!=REF
        !          23448:                                &&  lasttk!=TSCOPE && lasttk != GOTO ) {
        !          23449:                                    // handle typedefs in basetype::check
        !          23450:                                    //    when type is available
        !          23451:                                    if (!in_typedef) {
        !          23452: // error('d',"\"%s\" line %d: hiding%n",__FILE__,__LINE__,yylval.pn);
        !          23453:                                        yylval.pn->hide();
        !          23454:                                    }
        !          23455:                                    yylval.pn = new name(yylval.pn->string);
        !          23456:                                    yylval.pn->n_oper = TNAME;
        !          23457:                                }
        !          23458:                        }
        !          23459:                        if ( defer_check ) defer_check = 0;
        !          23460:                }
        !          23461:            } // must_be_id
        !          23462: 
        !          23463:            if ( in_class_decl &&
        !          23464:                ccl->lex_level &&
        !          23465:                yylval.pn->lex_level != 0 && 
        !          23466:                yylval.pn->tp && 
        !          23467:                (yylval.pn->tp->base != COBJ && yylval.pn->tp->base != EOBJ)) 
        !          23468:            {
        !          23469:                Pname n = gtbl->look( yylval.pn->string,0);
        !          23470:                if ( in_mem_fct ) {
        !          23471:                     if (n && n->base == TNAME ) {
        !          23472:                        error('w', "local typedef %n(%t) is not in scope of local class %s members; usingG (%t)", yylval.pn, yylval.pn->tp, ccl->string, n->tp );
        !          23473:                        yylval.pn = n;
        !          23474:                    } else
        !          23475:                        error( "local typedef %sis not in scope of inline member function of local class %s", yylval.pn->string, ccl->string);
        !          23476:                }
        !          23477:            }
        !          23478: 
        !          23479:            // if we still have a TNAME, make sure have the right TNAME
        !          23480:            // possibility of ananchronistic reference to nested type
        !          23481:            Ptype nbt = yylval.pn->tp;
        !          23482:            if (tk == TNAME && curr_scope == 0 && nbt && // Y y; not X::Y y;
        !          23483:                (nbt->base == EOBJ || nbt->base == COBJ))
        !          23484:            {
        !          23485:                Ptype t = Pbase(nbt)->b_name->tp;
        !          23486:                if ( ccl && t->in_class &&
        !          23487:                        strcmp(t->in_class->string, ccl->string)) 
        !          23488:                {
        !          23489:                        switch( nbt->base ) {
        !          23490:                                case COBJ:
        !          23491:                                        if (is_empty(Pclass(t)))
        !          23492:                                                yylval.pn = check_nested_type( yylval.pn );
        !          23493:                                        break;
        !          23494:                                case EOBJ:
        !          23495:                                        if (is_empty(Penum(t)))
        !          23496:                                                yylval.pn = check_nested_type( yylval.pn );
        !          23497:                                        break;
        !          23498:                        };
        !          23499:                }
        !          23500:            }
        !          23501:         }
        !          23502:        else 
        !          23503:         { // tk == ID 
        !          23504:                char *s = yylval.s;
        !          23505:                Pname n = ktbl->look( s, HIDDEN );
        !          23506:                Pname nstd = ktbl->look( s, NESTED );
        !          23507: 
        !          23508:                // inside a class definition, ccl, that is nested 
        !          23509:                // s is a nested class name, and is the name of ccl
        !          23510:                if (ccl && ccl->in_class && nstd && 
        !          23511:                        strcmp(s, ccl->string)==0)
        !          23512:                {
        !          23513:                        for (Pname nn=nstd; nn; nn=nn->n_tbl_list) {
        !          23514:                                Ptype tt = (nn->tp->base==COBJ || nn->tp->base==EOBJ)
        !          23515:                                                ? Pbase(nn->tp)->b_name->tp : nn->tpdef;
        !          23516:                                Pclass cl = tt->in_class; 
        !          23517:                                if ( nn->n_key != NESTED ) continue;
        !          23518:                                if (strcmp(ccl->in_class->string,cl->string) == 0) {
        !          23519:                                        tk = TNAME;
        !          23520:                                        yylval.pn = nn;
        !          23521:                                        n = nstd = nn;
        !          23522:                                        }
        !          23523:                        }
        !          23524:                }
        !          23525: 
        !          23526:                if (tk2 == MEM) {
        !          23527:                    // ID ::
        !          23528:                    if (n) {
        !          23529:                        yylval.pn = n;
        !          23530:                /*XXX*/ goto crunch;
        !          23531:                    } 
        !          23532:                    else
        !          23533:                    if (nstd &&
        !          23534:                        nstd->n_tbl_list==0)
        !          23535:                    {
        !          23536:                        yylval.pn = nstd;
        !          23537:                        tk = TSCOPE;
        !          23538:                        tk2 = deltok(1);
        !          23539:                        tk2 = la_look();
        !          23540:                        if (tk2 == MUL ) {
        !          23541:                                tk = MEMPTR;
        !          23542:                                tk2 = deltok(1);
        !          23543:                        }
        !          23544:                    }
        !          23545:                    else {
        !          23546:                        error( "%s:: %sis not aTN", s, s ); 
        !          23547:                        tk2 = deltok(1);
        !          23548:                        goto gettok;
        !          23549:                    }
        !          23550:                } 
        !          23551:                else  // transitional kludge
        !          23552:                if ( n && nstd && n == nstd )  
        !          23553:                        ; // null statement
        !          23554: 
        !          23555:                // Have an ID. Check last token to be sure.
        !          23556:                else if (lasttk==ENUM || lasttk==AGGR &&
        !          23557:                                // template <class id, class id>
        !          23558:                                (tk2 != GT && tk2 != CM)) 
        !          23559:                        {
        !          23560:                        int fd = tk2!=LC && tk2!=COLON;
        !          23561:                        tk = TNAME;
        !          23562:                        if ( nstd ) { 
        !          23563:                                // in transitional model, need flag this as error
        !          23564:                                if ( fd == 0 ) { // real definition
        !          23565:                                        if ( ccl == 0 )
        !          23566:                                                error("nested andG%k %s(to do this placeG%k %s {}; first)",lasttk==ENUM?lasttk:CLASS, s, lasttk==ENUM?lasttk:CLASS, s); 
        !          23567:                                        else
        !          23568:                                                error("multiple nested%k %s(to do this placeG%k %s {}; first)",lasttk==ENUM?lasttk:CLASS, s, lasttk==ENUM?lasttk:CLASS,s); 
        !          23569:                                        error( 'i', "cannot recover from previous errors" );
        !          23570:                                }
        !          23571:                        }
        !          23572:                        else 
        !          23573:                        // new tag, define it
        !          23574:                        if (n==0 || 
        !          23575:                                (n->n_template_arg == template_type_formal))
        !          23576:                        {
        !          23577: // error('d', "ccl: %t fd: %d, in_mem_fct: %d, in_class_decl: %d", ccl, fd, in_mem_fct, in_class_decl);
        !          23578:                                n = new name( s );
        !          23579:                                if ( fd )  // struct X*, etc.
        !          23580:                                        n->lex_level=0; 
        !          23581:                                else
        !          23582:                                        n->lex_level=lex_level>=0?lex_level:0;
        !          23583: 
        !          23584:                                if ( ccl && fd == 0 && 
        !          23585:                                        in_class_decl && 
        !          23586:                        (bl_level == ccl->lex_level + in_class_decl + 1))
        !          23587:                                                n = do_nested_type( n );
        !          23588:                                else
        !          23589:                                // note: ***** modify to handle local typedef
        !          23590:                                // note: ***** add local enums
        !          23591:                                if ( n->lex_level &&
        !          23592:                                        lasttk != ENUM ) // temporary
        !          23593:                                                n = do_local_class( n, n->lex_level );
        !          23594:                                else {
        !          23595:                                        n = n->tname( lastval.t );
        !          23596:                                        modified_tn = modified_tn->l;
        !          23597:                                        if (fd && gtbl->look(n->string,0)) statStat = n;
        !          23598:                                }
        !          23599:                        }
        !          23600:                        else {
        !          23601:                                if (n->tp->base!=COBJ && n->tp->base!=EOBJ) {
        !          23602:                                        error( 'i', "hidden%n:%t",n,n->tp );
        !          23603:                                        goto gettok;
        !          23604:                                }
        !          23605: 
        !          23606:                                if ( tk2 == LC || tk2 == COLON ) { 
        !          23607:                                        // class declared and hidden but not yet defined
        !          23608:                                        // may have ctor defined which invalidates hiding
        !          23609:                                        statStat = n;
        !          23610:                                        n->n_key = 0; // inside class definition it cannot be hidden
        !          23611:                                }
        !          23612:                        }
        !          23613:                        yylval.pn = nstd?nstd:n; 
        !          23614:                }
        !          23615:                else {
        !          23616:                        tk = ID;
        !          23617:                        yylval.pn = new name( s );
        !          23618:                }
        !          23619: 
        !          23620:                if ( tk == ID ) 
        !          23621:                {
        !          23622:                    switch ( tk2 ) {
        !          23623:                    case ID: case TNAME: case AGGR: case ENUM:
        !          23624:                    {
        !          23625:                        Pname n = 0; 
        !          23626: 
        !          23627:                        if ((curr_scope||ccl) && nstd) {
        !          23628:                        // within class scope in which nested class is visible
        !          23629:                        // curr_scope == set by TSCOPE, X::foo() { ... }
        !          23630:                        // ccl == parsing class definition ``ccl''
        !          23631: 
        !          23632:                                char *str = curr_scope?curr_scope->string:ccl->string;
        !          23633:                                for (Pname nn=nstd; nn; nn=nn->n_tbl_list) {
        !          23634:                                        Ptype tt = (nn->tp->base==COBJ || nn->tp->base==EOBJ)
        !          23635:                                                        ? Pbase(nn->tp)->b_name->tp : nn->tpdef;
        !          23636:                                        Pclass cl = tt->in_class; 
        !          23637:                                        if ( nn->n_key != NESTED ) continue;
        !          23638:                                        if ( strcmp(str,cl->string) == 0){      
        !          23639:                                                tk = TNAME;
        !          23640:                                                yylval.pn = nn;
        !          23641:                                                if (lasttk == TYPE && 
        !          23642:                                                        lastval.t == TYPEDEF )
        !          23643:                                                                in_typedef = yylval.pn->tp;
        !          23644:                                                break;
        !          23645:                                        }
        !          23646:                                }
        !          23647:                        }
        !          23648:                        if (tk == TNAME) break; // found nested class
        !          23649: 
        !          23650:                        n = ktbl->look( s, HIDDEN ); 
        !          23651:                        if ( n ) {
        !          23652:                                Pname nn = n;
        !          23653:                                switch ( n->tp->base ) {
        !          23654:                                        default:
        !          23655:                                                error("typedef %sis not visible in this scope", s );
        !          23656:                                                break;
        !          23657:                                        case COBJ:
        !          23658:                                                if (is_empty(Pclass(Pbase(n->tp)->b_name->tp)))
        !          23659:                                                        n = check_nested_type( nn );
        !          23660:                                                if (nn == n)
        !          23661:                                                        error("%sis hidden: use struct %s%s", s,s,front->retval.s);
        !          23662:                                                break;
        !          23663:                                        case EOBJ:
        !          23664:                                                if (is_empty(Penum(Pbase(n->tp)->b_name->tp)))
        !          23665:                                                        n = check_nested_type( nn );
        !          23666:                                                if (nn == n)
        !          23667:                                                        error("%sis hidden: use enum %s%s", s,s,front->retval.s);
        !          23668:                                                break;
        !          23669:                                };
        !          23670:                                tk = TNAME;
        !          23671:                                yylval.pn = n;
        !          23672:                        }
        !          23673:                        else  
        !          23674:                        if (n=ktbl->look(s,NESTED)) 
        !          23675:                        {
        !          23676:                                TOK ntk;
        !          23677:                                bit ok = 0;
        !          23678:                                Ptype tt = return_nstd_local_type(n,ntk);
        !          23679:                                Pclass cl = tt->in_class; 
        !          23680:                                if (ccl) {
        !          23681:                                        // x::y unncessary with in_class,
        !          23682:                                        // a derived class of in_class
        !          23683:                                        // or classes enclosing in_class
        !          23684:                                        if (ccl==cl || ccl->has_base(cl))
        !          23685:                                                ok++;
        !          23686:                                        else {
        !          23687:                                        for (Pclass eccl=ccl->in_class;eccl; eccl=eccl->in_class)
        !          23688:                                                if ( eccl == cl ) { ok++; break; }
        !          23689:                                        }
        !          23690:                                }
        !          23691:                                if (!ok)
        !          23692:                                        error('w', "use %t:: to access nested %k %s (anachronism)", cl, ntk, n->string );
        !          23693:                                tk = TNAME;
        !          23694:                                yylval.pn = n;
        !          23695:                        }
        !          23696:                        else { // probably a typo
        !          23697:                            if ( tk2 == ID )
        !          23698:                                error("%s%s: %sis not aTN", s,front->retval.s,s);
        !          23699:                            else if ( tk2 == TNAME )
        !          23700:                                error("%s%s: %sis not aTN", s,front->retval.pn->string,s);
        !          23701:                            else 
        !          23702:                                error("%s%k: %sis not aTN", s,front->retval.t,s);
        !          23703:                            goto gettok;
        !          23704:                        }
        !          23705:                         break;
        !          23706:                    }
        !          23707:                    case DOT: case REF:
        !          23708:                         mem_sel = yylval.pn;
        !          23709:                         break;
        !          23710:                    default:
        !          23711:                        if ( lasttk == TNAME && tk2 == LC )  
        !          23712:                        {
        !          23713:                                error("T%s %k: %s is unexpected", s, tk2, s );
        !          23714:                                goto gettok;
        !          23715:                        }
        !          23716:                        
        !          23717:                        // have an ID.  lets just make sure it should not be a TNAME
        !          23718:                        if (curr_scope||ccl||nstd) {
        !          23719:                                if (ccl && in_typedef && 
        !          23720:                                        in_typedef->base != 0 &&  
        !          23721:                                        in_mem_fct == 0 &&
        !          23722:                                        (tk2 == SM || tk2 == RP || tk2 == LB)) 
        !          23723:                                        {
        !          23724:                                                yylval.pn = do_nested_type( yylval.pn );
        !          23725:                                                tk = TNAME;
        !          23726:                                        }
        !          23727:                                else
        !          23728:                                if (nstd && must_be_id == 0 && in_expr == 0) {
        !          23729: // error('d',"nstd: %n must_be_id 0 have id tk2: %k lasttk: %k",nstd,tk2,lasttk);
        !          23730: // error('d',"nstd: in_expr %d lex_level %d",in_expr,lex_level);
        !          23731:                                        Pclass xcl = curr_scope?Pclass(Pbase(curr_scope->tp)->b_name->tp):(ccl?ccl:0);
        !          23732:                                        for (Pname nn=nstd; nn; nn=nn->n_tbl_list) {
        !          23733:                                                TOK ntk;
        !          23734:                                                bit ok = 0;
        !          23735:                                                Ptype tt = return_nstd_local_type(nn,ntk);
        !          23736:                                                Pclass cl = tt->in_class; 
        !          23737: // error('d',"xcl: %t ccl: %t", xcl, ccl );
        !          23738:                                                if ( xcl ) {
        !          23739:                                                        if (xcl==cl || xcl->has_base(cl) || ccl == cl)
        !          23740:                                                                ok++;
        !          23741:                                                        else {
        !          23742:                                                        for (Pclass eccl=xcl->in_class;eccl;eccl=eccl->in_class)
        !          23743:                                                                if ( eccl == cl ) { ok++; break; }
        !          23744:                                                        }
        !          23745:                                                }
        !          23746:                                                        
        !          23747:                                                if (nn == nstd)
        !          23748:                                                {
        !          23749:                                                if (
        !          23750:                                                    // special case: foo(X,
        !          23751:                                                    // in_arg_list not set until **after** X is handled
        !          23752:                                                    ((in_arg_list || lasttk==LP) &&  // foo(nestedX
        !          23753:                                                        (tk2==CM || tk2==ASSIGN || 
        !          23754:                                                                (tk2==RP && lasttk!=MUL && lasttk!=REF))) 
        !          23755:                                                    || // class x : public nestedX
        !          23756:                                                        (tk2==LC && (lasttk==PR || lasttk==VIRTUAL))
        !          23757:                                                    || // nestedX [*&]
        !          23758:                                                        (tk2 == MUL || tk2==AND)
        !          23759:                                                    || (lasttk==LP && tk2==RP)
        !          23760:                                                    || (lasttk==TSCOPE && lastval.pn == nn) 
        !          23761:                                                    || (lasttk==COMPL && dtor_seen == nn) 
        !          23762:                                                    || (lasttk==TYPE && lastval.t == TYPEDEF)
        !          23763:                                                     || lasttk == OPERATOR
        !          23764:                                                    || lasttk == NEW || in_sizeof )
        !          23765:                                                {  // must be type name, and it must be nested: 
        !          23766:                                                        if ( nstd->n_tbl_list == 0 ) { // only one: ok
        !          23767:                                                                if (lasttk != TSCOPE && !ok )
        !          23768:                                                                        error('w', "use %t:: to access nested %k %s (anachronism)", cl, ntk, nn->string);
        !          23769:                                                                break;
        !          23770:                                                        }
        !          23771:                                                        else {
        !          23772:                                                                if (lasttk != TSCOPE && lasttk != TYPE && !ok){
        !          23773:                                                                        error("ambiguous nested type %s, use %t::%s",nn->string,xcl,nn->string);
        !          23774:                                                                        error( 'i', "cannot recover from previous errors" );
        !          23775:                                                                }
        !          23776:                                                        }
        !          23777:                                                }
        !          23778: 
        !          23779:                                            }
        !          23780:                                                if ( nn->n_key != NESTED ) continue;
        !          23781:                                                if (xcl && 
        !          23782:                                                        strcmp(xcl->string,cl->string) == 0) break;
        !          23783:                                        } // end: for nn = nstd
        !          23784: 
        !          23785:                                        if (nn) {
        !          23786:                                                tk = TNAME;
        !          23787:                                                yylval.pn = nn;
        !          23788:                                                if (lasttk == TYPE && 
        !          23789:                                                        lastval.t == TYPEDEF )
        !          23790:                                                                in_typedef = yylval.pn->tp;
        !          23791:                                        }
        !          23792:                                }  // end: if (nstd)
        !          23793:                        } // end: if (curr_scope||ccl)
        !          23794:                         break;
        !          23795:                    } // end: switch tk2
        !          23796:                } // end: if (tk == ID)
        !          23797:            }
        !          23798: 
        !          23799: // error('d',"testing for in_expr: in_expr: %d tk: %k", in_expr, tk );
        !          23800: // error('d',"testing for in_expr: tk2: %k lasttk: %k", tk2, lasttk );
        !          23801:            if (lex_level && tk==ID && tk2==LP &&
        !          23802:                        (lasttk==LC || lasttk==RC || lasttk==RP ||
        !          23803:                        lasttk == ASSIGN || lasttk == SM))
        !          23804:                                in_expr = 1;
        !          23805:            else in_expr = 0;
        !          23806:        
        !          23807:        }
        !          23808:         if ( tk == TNAME || ( tk == TYPE && latype(yylval.t) )
        !          23809: // XXX     || tk == TSCOPE || tk == MEM 
        !          23810:           || tk == REF || tk == DOT || tk == GOTO 
        !          23811:           || tk == MEMPTR )
        !          23812:           // TNAME cannot immediately follow a type name,
        !          23813:           // scope operator, right curly, selection, or goto
        !          23814:                must_be_id = 1;
        !          23815:        else
        !          23816:                must_be_id = 0;
        !          23817: 
        !          23818:         switch ( tk ) {
        !          23819:            case SM:
        !          23820:                mem_sel = 0; // no break
        !          23821:                in_expr = 0;
        !          23822:            case RP: case RC: must_be_expr = 0; break;
        !          23823:            case COLON: 
        !          23824:                if  (lasttk == RP || 
        !          23825:                    (lasttk == TYPE && lastval.t == CONST)) 
        !          23826:                        must_be_expr = 1;
        !          23827:                break;
        !          23828:            case SIZEOF:
        !          23829:                in_sizeof = 1;
        !          23830:                break;
        !          23831:        };
        !          23832: ret:
        !          23833:     if ( tk == COMPL && lasttk == TSCOPE )
        !          23834:         dtor_seen = lastval.pn;
        !          23835:     else dtor_seen = 0;
        !          23836:     lasttk = tk;
        !          23837:     lastval = yylval;
        !          23838:     LDB(1,showQ("after");
        !          23839:        fprintf(stderr,"returning '%s'",image(tk));
        !          23840:        if ( tk==ID || tk==TNAME ) fprintf(stderr," -- '%s'",yylval.pn->string);
        !          23841:        fprintf(stderr,"\n");
        !          23842:     );
        !          23843: // error('d',"returning tk: %k dtor_seen: %n", tk,dtor_seen );
        !          23844:     return tk;
        !          23845: }
        !          23846: 
        !          23847: extern void
        !          23848: la_backup( TOK t, YYSTYPE r )
        !          23849: /*
        !          23850:     called by parser to push token back on front of queue
        !          23851: */
        !          23852: {
        !          23853:     LDB(1,fprintf(stderr,"\n*** la_backup( '%s', ...)\n",image(t)));
        !          23854:     if ( t == ID ) { Pname n = r.pn; r.s = n->string; DEL(n); }
        !          23855:     register toknode* T = new toknode(t,r,curloc);
        !          23856:     if (front) {
        !          23857:        front->last = T;
        !          23858:        T->next = front;
        !          23859:        T->last = 0;
        !          23860:        front = T;
        !          23861:     } else
        !          23862:        front = rear = T;
        !          23863:     lasttk = 0;
        !          23864: }
        !          23865: 
        !          23866: extern int
        !          23867: la_sctype( TOK t )
        !          23868: {
        !          23869: //error('d',&latok->place,"la_sctype(%k ) -- latok ==%k",t,latok->tok);
        !          23870:        if ( t != latok->tok && t != TSCOPE && t != MEMPTR )
        !          23871:                error( 'i', &latok->place, "la_sctype, lalex.c" );
        !          23872: 
        !          23873:        switch( latok->retval.t ) {
        !          23874:                case TYPEDEF:
        !          23875:                case EXTERN:
        !          23876:                case STATIC:
        !          23877:                case AUTO:
        !          23878:                case REGISTER:
        !          23879:                case OVERLOAD:
        !          23880:                case INLINE:
        !          23881:                case FRIEND:
        !          23882:                case CONST:
        !          23883:                case VOLATILE:
        !          23884:                        return 1; 
        !          23885:                default:
        !          23886:                        return 0; 
        !          23887:        }
        !          23888: }
        !          23889: 
        !          23890: extern int
        !          23891: la_cast()
        !          23892: /*
        !          23893:        called in reduction of term_lp to check for ambiguous prefix-style cast
        !          23894:        if result is 1, caller inserts DECL_MARKER to force reduction of cast
        !          23895: */
        !          23896: {
        !          23897:        // yychar already designates TYPE or TNAME
        !          23898:        // LP must start the lookahead queue!
        !          23899:        LDB(1,fprintf(stderr,"\n*** la_cast()\n"););
        !          23900:        int tk, tk2 = latok->tok;
        !          23901: 
        !          23902:        for ( ; ; ) {
        !          23903:            tk = tk2;
        !          23904:            tk2 = lookahead();
        !          23905: 
        !          23906:            switch( tk ) {
        !          23907:            case LP:
        !          23908:                if ( tk2 == MUL || tk2 == AND ||
        !          23909:                        tk2 == TSCOPE || tk2 == MEMPTR )
        !          23910:                    // T ( * ...
        !          23911:                    // T ( C ::* ...
        !          23912:                    continue;
        !          23913:                else
        !          23914:                    // T ( exp )
        !          23915:                    return 0;
        !          23916:            case MUL: case AND:
        !          23917:                //if ( tk2 == SCTYPE )
        !          23918:                if ( la_sctype( tk2 ) )
        !          23919:                    // T ( * const ...
        !          23920:                    // T ( * volatile ...
        !          23921:                    tk2 = lookahead();
        !          23922:                continue;
        !          23923:            case MEMPTR:
        !          23924:                if ( tk2 == RP ) continue;
        !          23925:                break;
        !          23926:            case TSCOPE:
        !          23927:                if ( tk2 == MUL )
        !          23928:                    // T ( C :: * ...
        !          23929:                    continue;
        !          23930:                else
        !          23931:                    // T ( exp )
        !          23932:                    return 0;
        !          23933:            case RP: case LB:
        !          23934:                // T (*)()
        !          23935:                // T (*[])()
        !          23936:                return 1;
        !          23937:            }
        !          23938: 
        !          23939:            return 0;
        !          23940:        }
        !          23941: }
        !          23942: 
        !          23943: static int
        !          23944: la_decl()
        !          23945: /*
        !          23946:        handles ambiguities
        !          23947:                type (*x) ()
        !          23948:                type (*x) []
        !          23949:        at start of arg list / statement
        !          23950:        return val == 1 if lookahead finds a declaration
        !          23951:                (used for error messages only)
        !          23952:        if declaration is "ambiguous" (i.e., can't be recognized with
        !          23953:                1-symbol lookahead), insert DECL_MARKER to force reduction
        !          23954:                of "type"
        !          23955: */
        !          23956: {
        !          23957:        
        !          23958:        // LP must start the lookahead queue!
        !          23959:        LDB(1,fprintf(stderr,"\n*** la_decl()\n"););
        !          23960:        int tk, tk2 = latok->tok;
        !          23961:        int paren = 0;
        !          23962:        int ptr = 0;
        !          23963: 
        !          23964:        for ( ; ; ) {
        !          23965: 
        !          23966:            tk = tk2;
        !          23967:            tk2 = lookahead();
        !          23968: 
        !          23969: // fprintf(stderr,"\nla_decl:tk:%d %s tk2: %d %s", tk, keys[tk], tk2, keys[tk2]);
        !          23970:            switch( tk ) {
        !          23971:            case LP:
        !          23972:                if ( tk2 == MUL || tk2 == AND || tk2 == TSCOPE ) {
        !          23973:                    // T ( * ...
        !          23974:                    ++paren;
        !          23975:                    ptr = 1;
        !          23976:                    continue;
        !          23977:                } else
        !          23978:                if ( tk2 == MEMPTR ) {
        !          23979:                // T ( C ::*  ...
        !          23980:                        return 1;
        !          23981:                } else 
        !          23982:                // possible redundant parens
        !          23983:                if ( tk2 == ID && lookahead() == RP ) {
        !          23984:                        TOK tp = lookahead();
        !          23985: // error( 'd', "tp %k tk: %k tk2: %k", tp, tk, tk2 );
        !          23986: // error( 'd', "bl_level: %d, in_class_decl: %d", bl_level,in_class_decl );
        !          23987:                        if ( tp == SM || tp == CM || tp == ASSIGN )
        !          23988:                        {
        !          23989:                                // member initialization list
        !          23990:                                if ( tp != SM && in_arg_list == 0 ) return 1;
        !          23991:                        }
        !          23992:                        else 
        !          23993:                        if ( tp == RP && (bl_level-in_class_decl==0))
        !          23994:                                return 1;
        !          23995:                        if ( tp != LP ) 
        !          23996:                                return 0;
        !          23997:                        latok=latok->last; // restore lookahead
        !          23998:                        ++paren;
        !          23999:                        continue;
        !          24000:                        }
        !          24001:                else
        !          24002:                    // T ( exp )
        !          24003:                    return 0;
        !          24004:            case MUL: case AND:
        !          24005:                //if ( tk2 == SCTYPE )
        !          24006:                if ( la_sctype( tk2 ))
        !          24007:                    // T ( * const ...
        !          24008:                    // T ( * volatile ...
        !          24009:                    return 1;
        !          24010:                else {
        !          24011:                    ptr = 0;
        !          24012:                    continue;
        !          24013:                }
        !          24014:            case MEMPTR:
        !          24015:                // T ( C :: * ...
        !          24016:                return 1;
        !          24017:            case TSCOPE:
        !          24018:                if ( tk2 == MUL ) //??tk SHOULD HAVE TRANSLATED TO MEMPTR!!
        !          24019:                    // T ( C :: * ...
        !          24020:                    return 1;
        !          24021:                else if ( ptr )
        !          24022:                    // T ( exp )
        !          24023:                    return 0;
        !          24024:                else if ( tk2 == ID || tk2 == OPERATOR )
        !          24025:                    // T ( * C :: id ...
        !          24026:                    continue;
        !          24027:                else
        !          24028:                    // error
        !          24029:                    return 0;
        !          24030:            }
        !          24031: 
        !          24032:            break;
        !          24033:        }
        !          24034: 
        !          24035:        if ( tk == RP || tk == LB )
        !          24036:            // T (*)()
        !          24037:            // T (*[])()
        !          24038:            return 1;
        !          24039: 
        !          24040:        if ( tk != ID && tk != OPERATOR )
        !          24041:            // T ( exp )
        !          24042:            return 0;
        !          24043: 
        !          24044:        if ( tk == OPERATOR )
        !          24045:            switch ( tk2 ) {
        !          24046:            case PLUS: case MINUS: case MUL: case REFMUL:
        !          24047:             case AND: case OR: case ER: case SHIFTOP: case EQUOP: 
        !          24048:            case DIVOP: case RELOP: case ANDAND: case OROR: 
        !          24049:            case NOT: case COMPL: case ICOP: case ASSIGN: 
        !          24050:             case ASOP: case NEW: case GNEW: case DELETE:
        !          24051:                // OPERATOR oper
        !          24052:                tk2 = lookahead();
        !          24053:                break;
        !          24054:            case LP:
        !          24055:                // OPERATOR ()
        !          24056:                tk2 = lookahead();
        !          24057:                if ( tk2 == RP ) {
        !          24058:                    tk2 = lookahead();
        !          24059:                    break;
        !          24060:                } else
        !          24061:                    return 0;
        !          24062:            case LB:
        !          24063:                // OPERATOR []
        !          24064:                tk2 = lookahead();
        !          24065:                if ( tk2 == LB ) {
        !          24066:                    tk2 = lookahead();
        !          24067:                    break;
        !          24068:                } else
        !          24069:                    return 0;
        !          24070:            default:    // illegal operator
        !          24071:                return 0;
        !          24072:            }
        !          24073: 
        !          24074:        int allow_lp = 1;
        !          24075:        int allow_rp = 1;
        !          24076:        for ( ; ; ) {
        !          24077:            tk = tk2;
        !          24078:            tk2 = lookahead();
        !          24079: 
        !          24080: // fprintf(stderr,"\nla_decl2:tk:%d %s tk2: %d %s", tk, keys[tk], tk2, keys[tk2]);
        !          24081:            switch( tk ) {
        !          24082:            case LP:
        !          24083:                if ( !allow_lp )
        !          24084:                    // T ( * id [ exp ] ( ...
        !          24085:                    return 0;
        !          24086: 
        !          24087:                // Current lookahead will be a decl if
        !          24088:                // the next lookahead is an arg decl
        !          24089:                if ( tk2 == RP || tk2 == ENUM || tk2==AGGR 
        !          24090:                        || tk2==ELLIPSIS || la_sctype( tk2 )) 
        !          24091:                    // T ( * id ()
        !          24092:                    // T ( * id ) ()
        !          24093:                    return 1;
        !          24094: 
        !          24095:                if ( tk2 == TYPE || tk2 == TNAME ) {
        !          24096:                    // T ( * id ) ( T2 ...
        !          24097:                    if ( lookahead() == LP && !la_decl() )
        !          24098:                        return 0;
        !          24099:                    return 1;
        !          24100:                }
        !          24101: 
        !          24102:                return 0;
        !          24103:            case LB:
        !          24104:                 if ( tk2 == RB || lookahead() == RB )
        !          24105:                    // T ( * id [] ...
        !          24106:                    return 1;
        !          24107:                else {
        !          24108:                    // T ( * id [ exp ] ...
        !          24109:                    allow_lp = 0;
        !          24110:                    allow_rp = 1;
        !          24111:                    while ( lookahead() != RB );
        !          24112:                    tk2 = lookahead();
        !          24113:                    continue;
        !          24114:                }
        !          24115:            case RP:
        !          24116: // error ('d', "rp: allow_rp: %d paren: %d", allow_rp, paren );
        !          24117:                if ( !allow_rp || !paren )
        !          24118:                    // T ( * id ) )
        !          24119:                    return 0;
        !          24120: // permit redundant parentheses
        !          24121:                else 
        !          24122:                if ( tk2 == SM || tk2 == CM || tk2 == ASSIGN )
        !          24123:                        return 1;
        !          24124:                else
        !          24125:                if ( tk2 == RP && (bl_level-in_class_decl == 0))
        !          24126:                        return 1;
        !          24127:                else
        !          24128:                {
        !          24129:                    // T ( * id ) ...
        !          24130:                    allow_lp = 1;
        !          24131:                    allow_rp = 0;
        !          24132:                    --paren;
        !          24133:                    continue;
        !          24134:                }
        !          24135:            default:
        !          24136:                return 0;
        !          24137:            }
        !          24138:        }
        !          24139: }
        !          24140: 
        !          24141: 
        !          24142: 
        !          24143: /*
        !          24144: **     PROCESSING OF INLINE MEMBER FUNCTIONS
        !          24145: */
        !          24146: static int la_snarf();
        !          24147: 
        !          24148: extern toknode*
        !          24149: save_text()
        !          24150: /*
        !          24151:        save text of inline def on q of class
        !          24152: */
        !          24153: {
        !          24154:        // Q should contain at least the tokens < FDEF, X ... >
        !          24155:        // where X is either LC or COLON (start of ftn)
        !          24156:        LDB(2,fprintf(stderr,"save_text()"));
        !          24157:        LDB(3,fprintf(stderr,"front: %s",image(front->tok)));
        !          24158:        LDB(3,fprintf(stderr,"front->next: %s",image(front->next->tok)));
        !          24159:        latok = front->next;
        !          24160:        if ( la_snarf() ) {
        !          24161:                // append this set of tokens to
        !          24162:                // inline tokenq for class
        !          24163:                toknode* t = front; // FDEF
        !          24164:                if ( ccl->c_funqf == 0 )
        !          24165:                        ccl->c_funqf = front;
        !          24166:                else {
        !          24167:                        ccl->c_funqr->next = front;
        !          24168:                        front->last = ccl->c_funqr;
        !          24169:                }
        !          24170:                ccl->c_funqr = latok;
        !          24171:                front = latok->next;
        !          24172:                latok->next = 0;
        !          24173:                if (front)  front->last = 0;
        !          24174:                return t;
        !          24175:        }
        !          24176:        return 0;
        !          24177: }
        !          24178: 
        !          24179: 
        !          24180: extern void
        !          24181: restore_text()
        !          24182: /*
        !          24183:        restore tokens for member inlines onto token q
        !          24184: */
        !          24185: {
        !          24186:        LDB(2,fprintf(stderr,"restore_text()"));
        !          24187:        if (ccl->c_funqf == 0)  // no inlines on Q
        !          24188:                return;
        !          24189:        LDB(3,fprintf(stderr,"  Q present: %d,%d",ccl->c_funqf,ccl->c_funqr));
        !          24190:        LDB(3,fprintf(stderr,"  front==%s",image(ccl->c_funqf->tok)));
        !          24191:        LDB(3,fprintf(stderr,"  rear ==%s",image(ccl->c_funqr->tok)));
        !          24192:        ccl->c_funqr->next = front;
        !          24193:        if (front)  front->last = ccl->c_funqr;
        !          24194:        front = ccl->c_funqf;
        !          24195:        ccl->c_funqf = ccl->c_funqr = 0;
        !          24196: }
        !          24197: 
        !          24198: 
        !          24199: static void
        !          24200: del_tokens( toknode* marker )
        !          24201: /*
        !          24202:     delete tokens from marker to latok, not inclusive
        !          24203: */
        !          24204: {
        !          24205:     if ( marker == 0 || marker == latok || marker->next == 0 )
        !          24206:        error('i', "bad token queue");
        !          24207: 
        !          24208:     LDB(2,fprintf(stderr,"del_tokens: %s..%s\n",image(marker->tok),image(latok->tok)));
        !          24209: 
        !          24210:     register toknode* tt = marker->next;
        !          24211:     if ( tt == latok ) return;
        !          24212:     marker->next = latok;
        !          24213:     latok->last->next = 0;
        !          24214:     latok->last = marker;
        !          24215:     register toknode* tx = tt;
        !          24216:     do {
        !          24217:        LDB(3,fprintf(stderr,"  deleting %s\n",image(tt->tok)));
        !          24218:        tx = tx->next;
        !          24219:        delete tt;
        !          24220:        tt = tx;
        !          24221:     } while ( tx );
        !          24222: }
        !          24223: 
        !          24224: 
        !          24225: static int
        !          24226: la_snarf()
        !          24227: /*
        !          24228:        scan function def without processing declarations
        !          24229: */
        !          24230: {
        !          24231:        LDB(2,fprintf(stderr,"la_snarf()"));
        !          24232:        loc *L = &latok->place;
        !          24233:        //DBPLACE(1,L.l,L.f);
        !          24234:        int parens = 0;
        !          24235:        int paren_error = 0;
        !          24236:        toknode* marker = latok;
        !          24237:        switch ( latok->tok ) {
        !          24238:        default:
        !          24239:                error('i', L, "bad token Q snarfing function: %d", latok->tok);
        !          24240:        case COLON:
        !          24241:                break;
        !          24242:        case LC:
        !          24243:                --bl_level;
        !          24244:                goto eatf;
        !          24245:        }
        !          24246:        LDB(2,fprintf(stderr,"\"eat\" member initializers"));
        !          24247:        for (;;) {
        !          24248:                if (latok->next == 0) add_tokens();
        !          24249:                switch ( (latok=latok->next)->tok ) {
        !          24250:                case LP:
        !          24251:                        ++parens;
        !          24252:                default:
        !          24253:                        LDB(3,fprintf(stderr,"...%s",image(latok->tok)));
        !          24254:                        continue;
        !          24255:                case RP:
        !          24256:                        if ( (--parens < 0) && (paren_error++ == 0) )
        !          24257:                                error(0,&latok->place,"unbalanced ()");
        !          24258:                        continue;
        !          24259:                case LC:
        !          24260:                case RC:
        !          24261:                        if ( parens <= 0 )
        !          24262:                                goto eatf;
        !          24263:                        continue;
        !          24264:                case SM:
        !          24265:                        if ( parens <= 0 ) {
        !          24266:                                error(0, L, "illegal bit field");
        !          24267:                                del_tokens( front );
        !          24268:                                delete front;
        !          24269:                                front = latok;
        !          24270:                                front->last = 0;
        !          24271:                                return 0;
        !          24272:                        }
        !          24273:                        continue;
        !          24274:                case EOFTOK:
        !          24275:                        error('i',&latok->place,"unexpected end of file");
        !          24276:                } // switch
        !          24277:        } // for
        !          24278: 
        !          24279:        eatf:
        !          24280:        int level = 1;
        !          24281:        for (;;) {
        !          24282:                if (latok->next == 0) add_tokens();
        !          24283:                switch ( (latok=latok->next)->tok ) {
        !          24284:                case LC:
        !          24285:                        ++level;
        !          24286:                default:
        !          24287:                        LDB(3,fprintf(stderr,"...%s",image(latok->tok)));
        !          24288:                        continue;
        !          24289:                case RC:
        !          24290:                        LDB(3,fprintf(stderr,"...RC"));
        !          24291:                        if (--level <= 0) {
        !          24292:                                if (level < 0) {
        !          24293:                                        error(0,&latok->place,"unexpected '}'");
        !          24294:                                        goto bad;
        !          24295:                                }
        !          24296:                                return 1;
        !          24297:                        }
        !          24298:                        break;
        !          24299:                case EOFTOK:
        !          24300:                        error('e', &latok->place, "unbalanced {}");
        !          24301:                        goto bad;
        !          24302:                } // switch
        !          24303:        } // for
        !          24304:        bad:
        !          24305:                del_tokens( marker );
        !          24306:                marker->tok = SM;
        !          24307:                return 0;
        !          24308: }
        !          24309: 
        !          24310: Pname check_for_nested( Pname nstd, TOK lasttk, YYSTYPE lastval, TOK tk2)
        !          24311: {
        !          24312: // error('d',"nstd: %n must_be_id 0 tk2: %k lasttk: %d",nstd,tk2,lasttk);
        !          24313:        TOK tk = ID;
        !          24314:        Pclass xcl = curr_scope?Pclass(Pbase(curr_scope->tp)->b_name->tp):(ccl?ccl:0);
        !          24315: 
        !          24316:        for (Pname nn=nstd; nn; nn=nn->n_tbl_list) {
        !          24317:                TOK ntk;
        !          24318:                bit ok = 0;
        !          24319:                Ptype tt = return_nstd_local_type(nn,ntk);
        !          24320:                Pclass cl = tt->in_class; 
        !          24321:                if ( xcl ) {
        !          24322:                        if (xcl==cl || xcl->has_base(cl))
        !          24323:                                ok++;
        !          24324:                        else {
        !          24325:                                for (Pclass eccl=xcl->in_class;eccl;eccl=eccl->in_class)
        !          24326:                                if ( eccl == cl ) { ok++; break; }
        !          24327:                        }
        !          24328:                }
        !          24329:                                                        
        !          24330:                if (nn == nstd)
        !          24331:                {
        !          24332:                        if ( ((in_arg_list || lasttk==LP) &&  // foo(nestedX
        !          24333:                                (tk2==CM || tk2==ASSIGN || tk2==RP)) 
        !          24334:                            || (tk2==LC && (lasttk==PR || lasttk==VIRTUAL))
        !          24335:                            || (tk2 == MUL || tk2==AND)
        !          24336:                            || (lasttk==LP && tk2==RP)
        !          24337:                            || (lasttk==TSCOPE && lastval.pn == nn) 
        !          24338:                            || (lasttk==COMPL && dtor_seen == nn) 
        !          24339:                            || (lasttk==TYPE && lastval.t == TYPEDEF)
        !          24340:                            || lasttk == NEW || in_sizeof )
        !          24341:                        {  
        !          24342:                                if ( nstd->n_tbl_list == 0 ) { // only one: ok
        !          24343:                                        break;
        !          24344:                                } else {
        !          24345:                                        if (lasttk != TSCOPE && !ok){
        !          24346:                                                error("ambiguous nested type %s, use X::%s",nn->string,nn->string);
        !          24347:                                                error( 'i', "cannot recover from previous errors" );
        !          24348:                                        }
        !          24349:                                }
        !          24350:                        }
        !          24351:                }
        !          24352:                if ( nn->n_key != NESTED ) continue;
        !          24353:                if (xcl && strcmp(xcl->string,cl->string) == 0) break;
        !          24354:        } // end: for nn = nstd
        !          24355:        return nn;
        !          24356: }
        !          24357: 
        !          24358: 0707071010112044341004440001630000160000010203200466055404200000600000066146lex.c/*ident      "@(#)ctrans:src/lex.c   1.4" */
        !          24359: /***************************************************************************
        !          24360: 
        !          24361:        C++ source for cfront, the C++ compiler front-end
        !          24362:        written in the computer science research center of Bell Labs
        !          24363: 
        !          24364:        Copyright (c) 1984 AT&T, Inc. All Rights Reserved
        !          24365:        THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T, INC.
        !          24366: 
        !          24367: lex.c:
        !          24368:        lexical analyser based on pcc's and cpre's scanners
        !          24369:        modified to handle classes:
        !          24370:        new keywords:   class
        !          24371:                        public
        !          24372:                        call
        !          24373:                        etc.
        !          24374:        names are not entered in the symbol table by lex()
        !          24375:        names can be of arbitrary length
        !          24376:        error() is used to report errors
        !          24377:        {} and () must match
        !          24378:        numeric constants are not converted into internal representation
        !          24379:        but stored as strings
        !          24380: 
        !          24381: ****************************************************************************/
        !          24382: 
        !          24383: #include "cfront.h"
        !          24384: #include "yystype.h"
        !          24385: #include "size.h"
        !          24386: #include "tqueue.h"
        !          24387: #include "template.h"
        !          24388: 
        !          24389: # define  CCTRANS(x) x
        !          24390: #define copy_if_need_be(s)  ((templp->in_progress || templp->parameters_in_progress) ? strdup(s) : (s))
        !          24391: 
        !          24392:        /* lexical actions */
        !          24393: 
        !          24394: #define A_ERR  0               /* illegal character */
        !          24395: #define A_LET  1               /* saw a letter */
        !          24396: #define A_DIG  2               /* saw a digit */
        !          24397: #define A_1C   3               /* return a single character */
        !          24398: #define A_STR  4               /* string */
        !          24399: #define A_CC   5               /* character constant */
        !          24400: #define A_BCD  6               /* GCOS BCD constant */
        !          24401: #define A_SL   7               /* saw a / */
        !          24402: #define A_DOT  8               /* saw a . */
        !          24403: #define A_2C   9               /* possible two character symbol */
        !          24404: #define A_WS   10              /* whitespace (not \n) */
        !          24405: #define A_NL   11              /* \n */
        !          24406: #define A_LC   12              /* { */
        !          24407: #define A_RC   13              /* } */
        !          24408: #define A_L    14              /* ( */
        !          24409: #define A_R    15              /* ) */
        !          24410: #define A_EOF  16
        !          24411: #define A_ASS  17
        !          24412: #define A_LT   18
        !          24413: #define A_GT   19              /* > */
        !          24414: #define A_ER   20
        !          24415: #define A_OR   21
        !          24416: #define A_AND  22
        !          24417: #define A_MOD  23
        !          24418: #define A_NOT  24
        !          24419: #define A_MIN  25
        !          24420: #define A_MUL  26
        !          24421: #define A_PL   27
        !          24422: #define A_COL  28              /* : */
        !          24423: #define A_SHARP        29              /* # */
        !          24424: #define A_DOLL  30              /* $ */
        !          24425: 
        !          24426:        /* character classes */
        !          24427: 
        !          24428: # define LEXLET 01
        !          24429: # define LEXDIG 02
        !          24430: /* no LEXOCT because 8 and 9 used to be octal digits */
        !          24431: # define LEXHEX 010
        !          24432: # define LEXWS 020
        !          24433: # define LEXDOT 040
        !          24434: 
        !          24435: const FIRSTCHUNK = 8*1024-8;
        !          24436: const BUFCHUNK = 4*1024-8;
        !          24437: 
        !          24438:        /* text buffer */
        !          24439: static char inbuf[FIRSTCHUNK/*TBUFSZ*/];
        !          24440: static char* txtmax = &inbuf[FIRSTCHUNK/*TBUFSZ*/-1];
        !          24441: static char* txtstart = 0;
        !          24442: static char* txtfree = 0;
        !          24443: 
        !          24444: static struct buf* bufhead;
        !          24445: static buf* freebuf;
        !          24446: //static bufs;
        !          24447: 
        !          24448: struct buf {
        !          24449:        buf* next;
        !          24450:        char chars[BUFCHUNK];
        !          24451: //     buf() { next=bufhead; bufhead=this; }
        !          24452: };
        !          24453: 
        !          24454: new_buf(char c)
        !          24455: {
        !          24456: //fprintf(stderr,"new_buf %d\n",bufs++);
        !          24457:        buf* pbuf;
        !          24458:        if (freebuf) {
        !          24459:                pbuf = freebuf;
        !          24460:                freebuf = freebuf->next;
        !          24461:        }
        !          24462:        else
        !          24463:                pbuf = new buf; // allocate and register new chunk
        !          24464:        pbuf->next = bufhead;
        !          24465:        bufhead = pbuf;
        !          24466: 
        !          24467:        if (BUFCHUNK < txtmax-txtstart) error('l',"lexical token too long");
        !          24468: 
        !          24469:        // copy current token:
        !          24470:        char* p = txtstart;
        !          24471:        txtstart = txtfree = &pbuf->chars[0];
        !          24472:        while (p<txtmax) *txtfree++ = *p++;
        !          24473:        *txtfree++=c;
        !          24474:        txtmax = &pbuf->chars[BUFCHUNK-1];
        !          24475:        return 0;
        !          24476: }
        !          24477: 
        !          24478: 
        !          24479: #define pch(c) ((txtmax<=txtfree)?new_buf(c):(*txtfree++=c))
        !          24480: #define start_txt()    txtstart = txtfree
        !          24481: #define del_txt()      txtfree = txtstart
        !          24482: 
        !          24483: static int Nfile;// = 1;
        !          24484: static char* file_name[MAXFILE*4];     // source file names
        !          24485:                                        // file_name[0] == src_file_name
        !          24486:                                        // file_name[0] == 0 means stdin
        !          24487: static short file_stack[MAXFILE];      // stack of file name indices
        !          24488: static int tcurr_file;                 // current index in file_stack
        !          24489:                                        // that is current #include nest level
        !          24490: 
        !          24491: Linkage linkage = linkage_default; // linkage is default C++   
        !          24492: const LINKMAX = 10;
        !          24493: static Linkage lvec[LINKMAX] = { linkage_default };
        !          24494: static int lcount = 0;
        !          24495: 
        !          24496: void set_linkage(char* p)
        !          24497: {
        !          24498:        if (p==0 || *p == 0) {  // resume previous linkage
        !          24499:                if (lcount>0) linkage = lvec[--lcount];
        !          24500:        }
        !          24501:        else {
        !          24502:                if (LINKMAX<=++lcount) {
        !          24503:                        error('l',"linkage directive nested too deep");
        !          24504:                        --lcount;
        !          24505:                } else if (strcmp(p,"C")==0)
        !          24506:                        lvec[lcount] = linkage = linkage_C;
        !          24507:                else if (strcmp(p,"C++")==0)
        !          24508:                        lvec[lcount] = linkage = linkage_Cplusplus;
        !          24509:                else {
        !          24510:                        error("%s linkage",p);
        !          24511:                        --lcount;
        !          24512:                }
        !          24513:        }
        !          24514: }
        !          24515: 
        !          24516: static struct loc tloc;
        !          24517: FILE * out_file = stdout;
        !          24518: FILE * in_file = stdin;
        !          24519: Ptable ktbl;
        !          24520: Ptable keyword_table;
        !          24521: 
        !          24522: static int p_level = 0;                /* number of unmatched ``(''s */
        !          24523: static int b_level = 0;                /* number of unmatched ``{''s */
        !          24524: 
        !          24525: # ifdef ibm
        !          24526: 
        !          24527: # define CSMASK 0377
        !          24528: # define CSSZ 256
        !          24529: 
        !          24530: # else
        !          24531: 
        !          24532: # define CSMASK 0177
        !          24533: # define CSSZ 128
        !          24534: 
        !          24535: # endif
        !          24536: 
        !          24537: static short lxmask[CSSZ+1];
        !          24538: 
        !          24539: int saved = 0; /* putback character, avoid ungetchar */
        !          24540: static int lxtitle();
        !          24541: 
        !          24542: // overload rt;
        !          24543: inline YYSTYPE rt(char* x) { YYSTYPE y; y.s  = x;        return y; }
        !          24544: inline YYSTYPE rt(int   x) { YYSTYPE y; y.t  = x;        return y; }
        !          24545: inline YYSTYPE rt(loc   x) { YYSTYPE y; y.l  = x;        return y; }
        !          24546: inline YYSTYPE rt(void* x) { YYSTYPE y; y.pn = Pname(x); return y; }
        !          24547: 
        !          24548: #define get(c)         (c=getc(in_file))
        !          24549: #define unget(c)       ungetc(c,in_file)
        !          24550: 
        !          24551: #define reti(a,b)      { addtok(a, rt(b), tloc);          return a; }
        !          24552: #define retn(a,b)      { addtok(a, rt((Pnode)b), tloc);   return a; }
        !          24553: #define rets(a,b)      { addtok(a, rt(b), tloc);          return a; }
        !          24554: #define retl(a)                { addtok(a, rt(tloc), tloc);       return a; }
        !          24555: 
        !          24556: // keys[] holds the external form for tokens with fixed representation 
        !          24557: // illegal tokens and those with variable representation have 0 entries
        !          24558: char* keys[MAXTOK+1];
        !          24559: 
        !          24560: static void 
        !          24561: new_key(char* s, TOK toknum, TOK yyclass)
        !          24562: /*
        !          24563:   make "s" a new keyword with the representation (token) "toknum"
        !          24564:   "yyclass" is the yacc token (for example new_key("int",INT,TYPE); )
        !          24565:   "yyclass==0" means yyclass=toknum;
        !          24566: */
        !          24567: {
        !          24568:        Pname n = new name(s);
        !          24569: 
        !          24570:        keys[(toknum==LOC)?yyclass:toknum] = s;
        !          24571:        n = new name(s);
        !          24572:        Pname nn = keyword_table->insert(n,0);
        !          24573:        // if (Nold) error('i',"keyword %sD twice",s);
        !          24574:        nn->base = toknum;
        !          24575:        nn->syn_class = (yyclass) ? yyclass : toknum;
        !          24576:        delete n;
        !          24577: }
        !          24578: 
        !          24579: const int keyword_count = 67;
        !          24580: static void 
        !          24581: ktbl_init()
        !          24582: /*
        !          24583:        enter keywords into keyword table for use by lex()
        !          24584:        and into keyword representation table used for output
        !          24585:  
        !          24586:         ktbl is only for types. We put nothing in it. 
        !          24587:        keyword_table is for user-defined reserved words 
        !          24588: */
        !          24589: {
        !          24590:        ktbl = new table(KTBLSIZE,0,0);
        !          24591:        keyword_table = new table(keyword_count,0,0);
        !          24592: 
        !          24593:        new_key("asm",ASM,0);
        !          24594:        new_key("auto",AUTO,TYPE);
        !          24595:        new_key("break",LOC,BREAK);
        !          24596:        new_key("case",LOC,CASE);
        !          24597:        new_key("continue",LOC,CONTINUE);
        !          24598:        new_key("char",CHAR,TYPE);
        !          24599:        new_key("do",LOC,DO);
        !          24600:        new_key("double",DOUBLE,TYPE);
        !          24601:        new_key("default",LOC,DEFAULT);
        !          24602:        new_key("enum",ENUM,0);
        !          24603:        new_key("else",LOC,ELSE);
        !          24604:        new_key("extern",EXTERN,TYPE);
        !          24605:        new_key("float",FLOAT,TYPE);
        !          24606:        new_key("for",LOC,FOR);
        !          24607:        new_key("goto",LOC,GOTO);
        !          24608:        new_key("catch",CATCH,CATCH);
        !          24609:        new_key("try",TRY,TRY);
        !          24610:        new_key("if",LOC,IF);
        !          24611:        new_key("int",INT,TYPE);
        !          24612:        new_key("long",LONG,TYPE);
        !          24613:        new_key("return",LOC,RETURN);
        !          24614:        new_key("register",REGISTER,TYPE);
        !          24615:        new_key("static",STATIC,TYPE);
        !          24616:        new_key("struct",STRUCT,AGGR);
        !          24617:        new_key("sizeof",SIZEOF,0);
        !          24618:        new_key("short",SHORT,TYPE);
        !          24619:        new_key("switch",LOC,SWITCH);
        !          24620:        new_key("typedef",TYPEDEF,TYPE);
        !          24621:        new_key("unsigned",UNSIGNED,TYPE);
        !          24622:        new_key("union",UNION,AGGR);
        !          24623:        new_key("void",VOID,TYPE);
        !          24624:        new_key("while",LOC,WHILE);
        !          24625: 
        !          24626:        new_key("class",CLASS,AGGR);
        !          24627:        new_key("const",CONST,TYPE);
        !          24628:        new_key("delete",LOC,DELETE);
        !          24629:        new_key("friend",FRIEND,TYPE);
        !          24630:        new_key("inline",INLINE,TYPE);
        !          24631:        new_key("new",NEW,0);
        !          24632:        new_key("operator",OPERATOR,0);
        !          24633:        new_key("overload",OVERLOAD,TYPE);
        !          24634:        new_key("private",PRIVATE,PR);
        !          24635:        new_key("protected",PROTECTED,PR);
        !          24636:        new_key("public",PUBLIC,PR);
        !          24637:        new_key("signed",SIGNED,TYPE);
        !          24638:        new_key("template",TEMPLATE,0);
        !          24639:        new_key("this",THIS,0);
        !          24640:        new_key("virtual",VIRTUAL,TYPE);
        !          24641:        new_key("volatile",VOLATILE,TYPE);
        !          24642: 
        !          24643:        new_key("__statement", STATEMENT, 0) ;
        !          24644:        new_key("__expression", EXPRESSION, 0) ;
        !          24645:        new_key("__template_test", TEMPLATE_TEST, 0) ;
        !          24646: }
        !          24647: 
        !          24648: loc last_line;
        !          24649: loc noloc = { 0, 0 };
        !          24650: 
        !          24651: void loc::putline()
        !          24652: {
        !          24653:        if (file==0 && line==0) return;
        !          24654: //   fix, Nfile, not MAXFILE; Nfile == MAXFILE*4
        !          24655: //     if (0<=file && file<MAXFILE) {
        !          24656:        if ( 0<=file && file <= Nfile ) {
        !          24657:                char* f = file_name[file];
        !          24658:                if (f==0) f = src_file_name;
        !          24659:                fprintf(out_file,line_format,line,f);
        !          24660:                last_line = *this;
        !          24661:        }
        !          24662: }
        !          24663: 
        !          24664: void loc::put(FILE* p)
        !          24665: {
        !          24666: //    fix, Nfile, not MAXFILE; Nfile == MAXFILE*4
        !          24667: //     if (0<=file && file<MAXFILE) {
        !          24668:        if ( 0<=file && file <= Nfile ) {
        !          24669:                char* f = file_name[file];
        !          24670:                if (f==0) f = src_file_name;
        !          24671:                fprintf(p,"\"%s\", line %d: ",f,line);
        !          24672:        }
        !          24673: }
        !          24674: 
        !          24675: void lxenter(register char* s, short m)
        !          24676: /* enter a mask into lxmask */
        !          24677: {
        !          24678:        register c;
        !          24679: 
        !          24680:        while( c= *s++ ) lxmask[c+1] |= m;
        !          24681: 
        !          24682: }
        !          24683: 
        !          24684: 
        !          24685: void lxget(register c, register m)
        !          24686: /*
        !          24687:        put 'c' back then scan for members of character class 'm'
        !          24688:        terminate the string read with \0
        !          24689:        txtfree points to the character position after that \0
        !          24690: */
        !          24691: {
        !          24692:        pch(c);
        !          24693:        while ( (get(c), lxmask[c+1]&m) ) pch(c);
        !          24694:        unget(c);
        !          24695:        pch('\0');
        !          24696: }
        !          24697: 
        !          24698: struct LXDOPE {
        !          24699:        short lxch;     /* the character */
        !          24700:        short lxact;    /* the action to be performed */
        !          24701:        TOK   lxtok;    /* the token number to be returned */
        !          24702: } lxdope[] = {
        !          24703: #ifdef apollo
        !          24704:        '@',    A_ERR,  0,      /* illegal characters go here... */
        !          24705: #else
        !          24706:          '$',    A_DOLL, 0,
        !          24707: //       '$',    A_ERR,  0,      /* illegal characters go here... */
        !          24708: #endif
        !          24709:        '_',    A_LET,  0,      /* letters point here */
        !          24710:        '0',    A_DIG,  0,      /* digits point here */
        !          24711:        ' ',    A_WS,   0,      /* whitespace goes here */
        !          24712:        '\n',   A_NL,   0,
        !          24713:        '"',    A_STR,  0,      /* character string */
        !          24714:        '\'',   A_CC,   0,      /* ASCII character constant */
        !          24715:        '`',    A_BCD,  0,      /* 'foreign' character constant, e.g. BCD */
        !          24716:        '(',    A_L,    LP,
        !          24717:        ')',    A_R,    RP,
        !          24718:        '{',    A_LC,   LC,
        !          24719:        '}',    A_RC,   RC,
        !          24720:        '[',    A_1C,   LB,
        !          24721:        ']',    A_1C,   RB,
        !          24722:        '*',    A_MUL,  MUL,
        !          24723:        '?',    A_1C,   QUEST,
        !          24724:        ':',    A_COL,  COLON,
        !          24725:        '+',    A_PL,   PLUS,
        !          24726:        '-',    A_MIN,  MINUS,
        !          24727:        '/',    A_SL,   DIV,
        !          24728:        '%',    A_MOD,  MOD,
        !          24729:        '&',    A_AND,  AND,
        !          24730:        '|',    A_OR,   OR,
        !          24731:        '^',    A_ER,   ER,
        !          24732:        '!',    A_NOT,  NOT,
        !          24733:        '~',    A_1C,   COMPL,
        !          24734:        ',',    A_1C,   CM,
        !          24735:        ';',    A_1C,   SM,
        !          24736:        '.',    A_DOT,  DOT,
        !          24737:        '<',    A_LT,   LT,
        !          24738:        '>',    A_GT,   GT,
        !          24739:        '=',    A_ASS,  ASSIGN,
        !          24740:        '#',    A_SHARP, 0,
        !          24741:        EOF,    A_EOF,  EOFTOK
        !          24742:        };
        !          24743: /* note: EOF is used as sentinel, so must be <=0 and last entry in table */
        !          24744: 
        !          24745: static struct LXDOPE *lxcp[CSSZ+1];
        !          24746: 
        !          24747: void 
        !          24748: lex_init()
        !          24749: {
        !          24750:        register struct LXDOPE *p;
        !          24751:        register i;
        !          24752:        register char *cp;
        !          24753:        /* set up character classes */
        !          24754: 
        !          24755:        /* first clear lexmask */
        !          24756:        for(i=0; i<=CSSZ; i++) lxmask[i] = 0;
        !          24757: 
        !          24758: #ifdef apollo
        !          24759:        lxenter( "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_$", LEXLET );
        !          24760: #else
        !          24761:        lxenter( "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_", LEXLET );
        !          24762: #endif
        !          24763:        lxenter( "0123456789", LEXDIG );
        !          24764:        lxenter( "0123456789abcdefABCDEF", LEXHEX );
        !          24765:                /* \013 should become \v someday; \013 is OK for ASCII and EBCDIC */
        !          24766:        lxenter( " \t\r\b\f\013", LEXWS );
        !          24767:        lxmask['.'+1] |= LEXDOT;
        !          24768: 
        !          24769:        /* make lxcp point to appropriate lxdope entry for each character */
        !          24770: 
        !          24771:        /* initialize error entries */
        !          24772: 
        !          24773:        for( i= 0; i<=CSSZ; ++i ) lxcp[i] = lxdope;
        !          24774: 
        !          24775:        /* make unique entries */
        !          24776: 
        !          24777:        for( p=lxdope; ; ++p ) {
        !          24778:                lxcp[p->lxch+1] = p;
        !          24779:                if( p->lxch < 0 ) break;
        !          24780:        }
        !          24781: 
        !          24782:        /* handle letters, digits, and whitespace */
        !          24783:        /* by convention, first, second, and third places */
        !          24784: 
        !          24785:        cp = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
        !          24786:        while( *cp ) lxcp[*cp++ + 1] = &lxdope[1];
        !          24787:        cp = "123456789";
        !          24788:        while( *cp ) lxcp[*cp++ + 1] = &lxdope[2];
        !          24789:        cp = "\t\b\r\f\013";
        !          24790:        while( *cp ) lxcp[*cp++ + 1] = &lxdope[3];
        !          24791: 
        !          24792:        file_name[0] = src_file_name;
        !          24793:        // set both curloc and tloc so curloc is valid at program startup
        !          24794: //     curloc.file = tloc.file = 0;
        !          24795:        curloc.line = tloc.line = 1;
        !          24796: 
        !          24797:        ktbl_init();
        !          24798:        lex_clear();
        !          24799:        saved = lxtitle();
        !          24800: }
        !          24801: 
        !          24802: void lex_clear()
        !          24803: {
        !          24804:        // delete extra buffers:
        !          24805:        buf* p = bufhead;       
        !          24806:        bufhead = 0;
        !          24807: //if (p) {
        !          24808: //fprintf(stderr,"lex_clear\n");
        !          24809: //bufs=0;
        !          24810: //}
        !          24811:        while (p) {
        !          24812:                buf* pp = p;
        !          24813:                p = p->next;
        !          24814:                pp->next = freebuf;
        !          24815:                freebuf = pp;
        !          24816:        }
        !          24817: 
        !          24818:        // re-set to static buffer:
        !          24819:        txtstart = txtfree = inbuf;
        !          24820:        txtmax = &inbuf[FIRSTCHUNK/*TBUFSZ*/-1];
        !          24821: }
        !          24822: 
        !          24823: int int_val(char hex)
        !          24824: {
        !          24825:        switch (hex) {
        !          24826:        case '0': case '1': case '2': case '3': case '4':
        !          24827:        case '5': case '6': case '7': case '8': case '9':
        !          24828:                return hex-'0';
        !          24829:        case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
        !          24830:                return hex-'a'+10;
        !          24831:        case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
        !          24832:                return hex-'A'+10;
        !          24833:        }
        !          24834: }
        !          24835: 
        !          24836: void hex_to_oct()
        !          24837: /*
        !          24838:        \x has been seen on input (in char const or string) and \ printed
        !          24839:        read the following hexadecimal integer and replace it with an octal
        !          24840: */
        !          24841: {
        !          24842:        int i = 0;
        !          24843:        int c;
        !          24844:        get(c);
        !          24845:        if (lxmask[c+1] & LEXHEX) {
        !          24846:                i = int_val(c);
        !          24847:                get(c);                                 // try for two
        !          24848:                if (lxmask[c+1] & LEXHEX) {
        !          24849:                        i = (i<<4) + int_val(c);
        !          24850:                        get(c);                         // try for three
        !          24851:                        if (lxmask[c+1] & LEXHEX)
        !          24852:                                i = (i<<4) + int_val(c);
        !          24853:                        else
        !          24854:                                unget(c);
        !          24855:                }
        !          24856:                else
        !          24857:                        unget(c);
        !          24858:        }
        !          24859:        else {
        !          24860:                error("hexadecimal digitE after \\x");
        !          24861:                unget(c);
        !          24862:        }
        !          24863: 
        !          24864: //     if (0377 < i) error('l',"hexadecimal constant too large");
        !          24865:        i &= 0377;
        !          24866: 
        !          24867:        pch(('0'+(i>>6)));
        !          24868:        pch(('0'+((i&070)>>3)));
        !          24869:        pch(('0'+(i&7)));
        !          24870: }
        !          24871: 
        !          24872: 
        !          24873: char * chconst()
        !          24874: /*
        !          24875:        read a character constant into inbuf
        !          24876: */
        !          24877: {
        !          24878:        register c;
        !          24879:        int nch = 0;
        !          24880: 
        !          24881:        pch('\'');
        !          24882: 
        !          24883:        for(;;) {
        !          24884:                char* p;
        !          24885:                char cc = 0;
        !          24886: 
        !          24887:                switch (get(c)) {
        !          24888:                case '\'':
        !          24889:                        goto ex;
        !          24890:                case EOF:
        !          24891:                        error("eof in char constant");
        !          24892:                        goto ex;
        !          24893:                case '\n':
        !          24894:                        error("newline in char constant");
        !          24895:                        goto ex;
        !          24896:                case '\\':
        !          24897:                        if (SZ_INT == nch++) error('l',"char constant too long");
        !          24898:                        pch(c);
        !          24899:                        switch (get(c)){
        !          24900:                        case '\n':
        !          24901:                                ++tloc.line;
        !          24902:                        default:
        !          24903:                                pch(c);
        !          24904:                                break;
        !          24905:                        case '4': case '5': case '6': case '7': // octal
        !          24906:                                p = txtfree;
        !          24907:                                cc = c-4;
        !          24908:                        case '0': case '1': case '2': case '3':
        !          24909:                                pch(c);
        !          24910:                                get(c);  /* try for 2 */
        !          24911:                                if( lxmask[c+1] & LEXDIG && c<'8'){
        !          24912:                                        pch(c);
        !          24913:                                        get(c);  /* try for 3 */
        !          24914:                                        if (lxmask[c+1] & LEXDIG && c<'8') {
        !          24915:                                                if (cc) *p = cc; // zap high bit
        !          24916:                                                pch(c);
        !          24917:                                        }
        !          24918:                                        else
        !          24919:                                                unget(c);
        !          24920:                                }
        !          24921:                                else
        !          24922:                                        unget(c);
        !          24923:                                break;
        !          24924:                        case 'x':       // hexadecimal
        !          24925:                                hex_to_oct();
        !          24926:                                break;
        !          24927:                        };
        !          24928:                        break;
        !          24929:                default:
        !          24930:                        if (SZ_INT == nch++) error('l',"char constant too long");
        !          24931:                        pch(c);
        !          24932:                }
        !          24933:        }
        !          24934: ex:
        !          24935:        if(nch==0)
        !          24936:                error("empty char constant");
        !          24937:        pch('\'');
        !          24938:        pch('\0');
        !          24939:        return txtstart;
        !          24940: }
        !          24941: 
        !          24942: void lxcom()
        !          24943: /* process a "block comment" */
        !          24944: {
        !          24945:        register c;
        !          24946: 
        !          24947:        for(;;)
        !          24948:        switch (get(c)) {
        !          24949:        case EOF:
        !          24950:                error('w',"eof in comment");
        !          24951:                return;
        !          24952:        case '\n':
        !          24953:                tloc.line++;
        !          24954: //             Nline++;
        !          24955:                break;
        !          24956:        case '*':
        !          24957:                if (get(c) == '/') return;
        !          24958:                unget(c);
        !          24959:                break;
        !          24960:        case '/':
        !          24961:                if (get(c) == '*') error('w',"``/*'' in comment");
        !          24962:                unget(c);
        !          24963:                break;
        !          24964:        }
        !          24965: }
        !          24966: 
        !          24967: 
        !          24968: void linecom()
        !          24969: // process a "line comment"
        !          24970: {
        !          24971:        register c;
        !          24972: 
        !          24973:        get(c);
        !          24974: #ifdef DBG
        !          24975:        if ( c=='@' && get(c)=='!' ) {
        !          24976:                while ( get(c) != '\n' && c != EOF ) pch(c);
        !          24977:                pch('\0');
        !          24978:                process_debug_flags(txtstart);
        !          24979:                del_txt();
        !          24980:        }
        !          24981: #endif
        !          24982:        for(;;get(c))
        !          24983:        switch (c) {
        !          24984:        case EOF:
        !          24985:                error('w',"eof in comment");
        !          24986:                return;
        !          24987:        case '\n':
        !          24988:                tloc.line++;
        !          24989: //             Nline++;
        !          24990:                saved = lxtitle();
        !          24991:                return;
        !          24992:        }
        !          24993: }
        !          24994: 
        !          24995: char eat_whitespace()
        !          24996: {
        !          24997: 
        !          24998:        for(;;) {
        !          24999:                register c = get(c);
        !          25000:        lx:
        !          25001: 
        !          25002:                switch (c) {
        !          25003:                case EOF:
        !          25004:                        error('w',"unexpected comment");
        !          25005:                        return EOF;
        !          25006:                case '/':
        !          25007:                        switch (get(c)) {
        !          25008:                        case '*':
        !          25009:                                lxcom();
        !          25010:                                break;
        !          25011:                        case '/':
        !          25012:                                linecom();
        !          25013:                                break;
        !          25014:                        default:
        !          25015:                                unget(c);
        !          25016:                                return '/';
        !          25017:                        }
        !          25018:                        break;
        !          25019:                case '\n':
        !          25020:                        ++tloc.line;
        !          25021:                        c = lxtitle();
        !          25022:                        goto lx;
        !          25023:                case ' ':
        !          25024:                case '\t':
        !          25025:                        break;
        !          25026:                default:
        !          25027:                        return c;               
        !          25028:                }
        !          25029:        }       
        !          25030: }
        !          25031: 
        !          25032: void get_string()
        !          25033: {
        !          25034:        int lxchar;
        !          25035: 
        !          25036:        for(;;)
        !          25037:        switch (get(lxchar)) {
        !          25038:        case '\\':
        !          25039:                pch('\\');
        !          25040:                switch (get(lxchar)){
        !          25041:                case '\n':
        !          25042:                        ++tloc.line;
        !          25043:                default:
        !          25044:                        pch(lxchar);
        !          25045:                        break;
        !          25046:                case 'x':       // hexadecimal
        !          25047:                        hex_to_oct();
        !          25048:                        break;
        !          25049:                };
        !          25050:                break;
        !          25051:        case '"':
        !          25052:         {       char* p = txtstart;     // eat_whitespace() moves txtstart
        !          25053:                 if ((lxchar = eat_whitespace()) == '"') {
        !          25054:                         // string catenation, break with
        !          25055:                         // newline to avoid merging characters
        !          25056:                         // (e.g. "\xAB" "C")
        !          25057:                         pch('\\');
        !          25058:                         pch('\n');
        !          25059: 
        !          25060:                         continue;       // eat '\"' and carry on
        !          25061:                 };
        !          25062: 
        !          25063:                 txtstart = p;
        !          25064:                unget(lxchar);
        !          25065:                pch(0);
        !          25066:                return;
        !          25067:         }
        !          25068:        case '\n':
        !          25069:                error("newline in string");
        !          25070:                pch(0);
        !          25071:                return;
        !          25072:        case EOF:
        !          25073:                error("eof in string");
        !          25074:                pch(0);
        !          25075:                return;
        !          25076:        default:
        !          25077:                pch(lxchar);
        !          25078:        }
        !          25079: }
        !          25080: 
        !          25081: TOK tlex()
        !          25082: {
        !          25083:        TOK ret;
        !          25084:        Pname n;
        !          25085: 
        !          25086: //     Ntoken++;
        !          25087: 
        !          25088:        for(;;) {
        !          25089:                register lxchar;
        !          25090:                register struct LXDOPE *p;
        !          25091: 
        !          25092:                start_txt();
        !          25093: 
        !          25094:                if (saved) {
        !          25095:                        lxchar = saved;
        !          25096:                        saved = 0;
        !          25097:                }
        !          25098:                else
        !          25099:                        get(lxchar);
        !          25100: 
        !          25101:                if (lxchar+1 >= CSSZ )
        !          25102:                 error( "illegal input character encountered: %d", lxchar );
        !          25103: 
        !          25104:                switch( (p=lxcp[lxchar+1])->lxact ){
        !          25105: 
        !          25106:                case A_1C:      // eat up a single character, and return an opcode 
        !          25107:                        reti(p->lxtok,p->lxtok);
        !          25108: 
        !          25109:                case A_EOF:
        !          25110:                        if (p_level || b_level+lcount)
        !          25111:                                error("'%s' missing at end of input",(b_level+lcount) ? "}" : ")");
        !          25112:                
        !          25113:                        reti(EOFTOK,0);
        !          25114: 
        !          25115:                case A_SHARP:
        !          25116:                        // cope with header file not ended with '\n'
        !          25117:                        unget('#');
        !          25118:                        saved = lxtitle();
        !          25119:                        continue;
        !          25120: 
        !          25121:                case A_ERR:
        !          25122:                {       if (' '<=lxchar && lxchar<='~') // ASCII printable
        !          25123:                                error("illegal character '%c' (ignored)",lxchar);
        !          25124:                        else
        !          25125:                                error("illegal character '0%o' (ignored)",lxchar);
        !          25126:                        continue;
        !          25127:                }
        !          25128: 
        !          25129:                case A_DOLL:
        !          25130:                 { // lex a name of the for $id for template tree formals
        !          25131:                        Pname fn ;
        !          25132:                         lxget( lxchar, LEXLET|LEXDIG ) ;
        !          25133: 
        !          25134:                         if (!templp->in_progress ||  !txtstart[1]) {
        !          25135:                           // no name string immediately follows, treat it                                  
        !          25136:                           // like an illegal character
        !          25137:                           error("illegal character '0%o' (ignored)",lxchar);                               
        !          25138:                           continue;
        !          25139:                         }  
        !          25140: 
        !          25141:                         txtstart++ ;
        !          25142:                         if(fn=templ_compilation::tree_parameter(txtstart)) {                              
        !          25143:                                switch (fn->n_template_arg) {
        !          25144:                                        case template_expr_tree_formal:
        !          25145:                                        // retain the $ in the name
        !          25146:                                                retn(ID, strdup(--txtstart)) ;
        !          25147: 
        !          25148:                                        case template_stmt_tree_formal:
        !          25149:                                                retn(SM_PARAM, fn) ;
        !          25150:                                }  
        !          25151:                         }  
        !          25152:                         error("%s wasn't a statement or expression formal", txtstart);
        !          25153:                         rets(ID, copy_if_need_be(txtstart));
        !          25154:                 }
        !          25155: 
        !          25156:                case A_LET:     // collect an identifier and check for keyword
        !          25157:                {
        !          25158:                        char ll;
        !          25159:                        switch (ll = lxchar) {
        !          25160:                //      case 'l':
        !          25161:                        case 'L':
        !          25162:                                switch (get(lxchar)) {
        !          25163:                                case '\'':
        !          25164:                                        error('s',"wide character constant");
        !          25165:                                        unget(lxchar);
        !          25166:                                        continue;
        !          25167:                                case '"':
        !          25168:                                        error('s',"wide character string");
        !          25169:                                        unget(lxchar);
        !          25170:                                        continue;
        !          25171:                                }
        !          25172:                                unget(lxchar);
        !          25173:                                lxchar = ll;
        !          25174:                        }
        !          25175:                }
        !          25176: 
        !          25177:                        lxget( lxchar, LEXLET|LEXDIG );
        !          25178:                         /* look for a keyword or a global type */
        !          25179:                        if ((n = keyword_table->look(txtstart,0))  /* keyword */
        !          25180:                                || (n = ktbl->look(txtstart, 0)))  /* local type */
        !          25181:                        {
        !          25182:                                TOK x;
        !          25183:                                del_txt();
        !          25184:                                switch (x=n->base) {
        !          25185:                                case TNAME:
        !          25186:                                        rets(ID,n->string);
        !          25187:                                case LOC:
        !          25188:                                        retl(n->syn_class);
        !          25189:                                case EXTERN:
        !          25190:                                        if ((lxchar = eat_whitespace()) == '\"') {
        !          25191:                                                // linkage directive
        !          25192:                                                get_string();
        !          25193:                                                rets(LINKAGE,txtstart);
        !          25194:                                        }
        !          25195:                                        unget(lxchar);
        !          25196:                                        reti(TYPE,EXTERN);
        !          25197:                                case CATCH:
        !          25198:                                // case TEMPLATE:
        !          25199:                                        error('s',"%k",n->syn_class);
        !          25200:                                        continue;
        !          25201:                                case TRY:
        !          25202:                                {
        !          25203:                                        static int warn_try;
        !          25204:                                        if (!warn_try) { 
        !          25205:                                                Pname n = keyword_table->look("try",0);
        !          25206:                                                n->n_key = DEFAULT;
        !          25207:                                                error('w',&tloc,"%k is a future reserved keyword",n->syn_class);
        !          25208:                                                warn_try++;
        !          25209:                                        }
        !          25210:                                        rets(ID,n->string);
        !          25211:                                }
        !          25212:                                default:
        !          25213:                                        reti(n->syn_class,x);
        !          25214:                                }
        !          25215:                        }
        !          25216:                        // rets(ID,txtstart);
        !          25217:                         rets(ID, copy_if_need_be(txtstart)) ;
        !          25218: 
        !          25219:                case A_DIG:
        !          25220: 
        !          25221:                        ret = ICON;
        !          25222: 
        !          25223:                        if (lxchar=='0') {
        !          25224:                                int pkchar;
        !          25225:                                get(pkchar);
        !          25226:                                if(pkchar=='x' || pkchar=='X') {        // hex
        !          25227:                                        pch(lxchar);
        !          25228:                                        lxget(pkchar,LEXHEX);
        !          25229:                                        txtfree--;
        !          25230:                                        if (txtfree-txtstart<3) // minimum "0Xd\0"
        !          25231:                                                error("hex digitX after \"0x\"");
        !          25232:                                        get(lxchar);
        !          25233:                                        goto getsuffix;
        !          25234:                                }
        !          25235:                                unget(pkchar);
        !          25236:                        }
        !          25237: 
        !          25238:                        lxget(lxchar,LEXDIG);
        !          25239:                        txtfree--;
        !          25240: 
        !          25241:                        if (get(lxchar) == '.') {
        !          25242:                getfp:
        !          25243:                                lxget('.', LEXDIG );
        !          25244:                                txtfree--;
        !          25245:                                ret = FCON;
        !          25246:                                get(lxchar);
        !          25247:                        };
        !          25248:                
        !          25249:                        if (lxchar=='e' || lxchar=='E') {
        !          25250:                                pch(lxchar);
        !          25251:                                get(lxchar);
        !          25252:                                if(lxchar=='-' || lxchar=='+') {
        !          25253:                                        pch(lxchar);
        !          25254:                                        get(lxchar);
        !          25255:                                }
        !          25256:                                if (lxmask[lxchar+1] & LEXDIG) {
        !          25257:                                        lxget( lxchar, LEXDIG );
        !          25258:                                        txtfree--;
        !          25259:                                        get(lxchar);
        !          25260:                                }
        !          25261:                                else
        !          25262:                                        error("missing exponent digits?");
        !          25263:                                ret = FCON;
        !          25264:                        };
        !          25265: 
        !          25266:                        if(*txtstart=='0' && ret==ICON) {
        !          25267:                                char *bch = txtstart;
        !          25268:                                while (++bch <= txtfree) {
        !          25269:                                        if(*bch=='8' || *bch=='9')
        !          25270:                                                error("%c used as octal digit",*bch);
        !          25271:                                }
        !          25272:                        }
        !          25273: 
        !          25274:                getsuffix:
        !          25275:                        switch (lxchar) {
        !          25276:                        case 'f':
        !          25277:                        case 'F':
        !          25278:                                if (ret==ICON)
        !          25279:                                        error("%c suffix for integer constant",lxchar);
        !          25280:                                else
        !          25281:                                        pch(lxchar);
        !          25282:                                break;
        !          25283:                        case 'u':
        !          25284:                        case 'U':
        !          25285:                                if (ret==FCON) {
        !          25286:                                        error("%c suffix for floating constant",lxchar);
        !          25287:                                        break;
        !          25288:                                }
        !          25289:                                pch(lxchar);
        !          25290:                                switch(get(lxchar)) {
        !          25291:                                case 'l':
        !          25292:                                case 'L':
        !          25293:                                        pch(lxchar);
        !          25294:                                        break;
        !          25295:                                default:
        !          25296:                                        saved=lxchar;
        !          25297:                                        break;
        !          25298:                                }
        !          25299:                                break;
        !          25300:                        case 'l':
        !          25301:                        case 'L':
        !          25302:                                pch(lxchar);
        !          25303:                                if (ret==FCON) {
        !          25304:                                        break;
        !          25305:                                }
        !          25306:                                switch(get(lxchar)) {
        !          25307:                                case 'u':
        !          25308:                                case 'U':
        !          25309:                                        pch(lxchar);
        !          25310:                                        break;
        !          25311:                                default:
        !          25312:                                        saved=lxchar;
        !          25313:                                        break;
        !          25314:                                }
        !          25315:                                break;
        !          25316:                        default:
        !          25317:                                saved = lxchar;
        !          25318:                                break;
        !          25319:                        };
        !          25320: 
        !          25321:                        if(*txtstart=='0' && txtfree-txtstart==1)
        !          25322:                                reti(ZERO,0);   // plain zero
        !          25323: 
        !          25324:                        pch(0);
        !          25325:                        rets(ret,txtstart);
        !          25326: 
        !          25327: 
        !          25328:                case A_DOT:
        !          25329:                        switch (get(lxchar)) {
        !          25330:                        case '.':       // look for ellipsis
        !          25331:                                if (get(lxchar) != '.') {
        !          25332:                                        error("token .. ?");
        !          25333:                                        saved = lxchar;
        !          25334:                                }
        !          25335:                                reti(ELLIPSIS,0);
        !          25336:                        case '*':
        !          25337:                                reti (REFMUL,DOT);
        !          25338:                        }
        !          25339: 
        !          25340:                        if (lxmask[lxchar+1] & LEXDIG){// look for floating constant
        !          25341:                                unget(lxchar);
        !          25342:                                goto getfp;
        !          25343:                        }
        !          25344:                        saved = lxchar;
        !          25345:                        reti(DOT,0);
        !          25346: 
        !          25347:                case A_STR:
        !          25348:                        /* save string constant in buffer */
        !          25349:                        get_string();
        !          25350:                        rets(STRING,txtstart);
        !          25351: 
        !          25352:                case A_CC:
        !          25353:                        /* character constant */
        !          25354:                        rets(CCON,chconst());
        !          25355: 
        !          25356:                case A_BCD:
        !          25357:                        {
        !          25358:                                register i;
        !          25359:                                int j;
        !          25360:        
        !          25361:                                pch('`');
        !          25362:        
        !          25363:                                for (i=0; i<7; ++i) {
        !          25364:                                        pch(get(j));
        !          25365:                                        if (j == '`' ) break;
        !          25366:                                }
        !          25367:                                pch(0);
        !          25368:                                if (6<i)
        !          25369:                                        error('l',"bcd constant exceeds 6 characters" );
        !          25370:                                rets(CCON,txtstart);
        !          25371:                        }
        !          25372: 
        !          25373:                case A_SL:      /* / */
        !          25374:                        switch (get(lxchar))  {
        !          25375:                        case '*':
        !          25376:                                lxcom();
        !          25377:                                break;
        !          25378:                        case '/':
        !          25379:                                linecom();
        !          25380:                                break;
        !          25381:                        case '=':
        !          25382:                                reti(ASOP,ASDIV);
        !          25383:                        default:
        !          25384:                                saved = lxchar;
        !          25385:                                reti(DIVOP,DIV);
        !          25386:                        }
        !          25387: 
        !          25388:                case A_WS:
        !          25389:                        continue;
        !          25390: 
        !          25391:                case A_NL:
        !          25392:                        ++tloc.line;
        !          25393: //                     Nline++;
        !          25394:                        saved = lxtitle();
        !          25395:                        continue;
        !          25396: 
        !          25397:                case A_LC:
        !          25398:                        if (BLMAX <= b_level++) {
        !          25399:                                error('l',"blocks too deeply nested");
        !          25400:                                ext(3);
        !          25401:                        }
        !          25402:                        retl(LC);
        !          25403: 
        !          25404:                case A_RC:
        !          25405:                        if (lcount+b_level-- <= 0) {
        !          25406:                                error("unexpected '}'");
        !          25407:                                b_level = 0;
        !          25408:                        }
        !          25409:                        retl(RC);
        !          25410: 
        !          25411:                case A_L:
        !          25412:                        p_level++;
        !          25413:                        reti(LP,0);
        !          25414: 
        !          25415:                case A_R:
        !          25416:                        if (p_level-- <= 0) {
        !          25417:                                error("unexpected ')'");
        !          25418:                                p_level = 0;
        !          25419:                        }
        !          25420:                        reti(RP,0);
        !          25421: 
        !          25422:                case A_ASS:
        !          25423:                        switch (get(lxchar)) {
        !          25424:                        case '=':
        !          25425:                                reti(EQUOP,EQ);
        !          25426:                        default:
        !          25427:                                saved = lxchar;
        !          25428:                                reti(ASSIGN,ASSIGN);
        !          25429:                        }
        !          25430: 
        !          25431:                case A_COL:
        !          25432:                        switch (get(lxchar)) {
        !          25433:                        case ':':
        !          25434:                                reti(MEM,0);
        !          25435:                        case '=':
        !          25436:                                error("':=' is not a c++ operator");
        !          25437:                                reti(ASSIGN,ASSIGN);
        !          25438:                        default:
        !          25439:                                saved = lxchar;
        !          25440:                                reti(COLON,COLON);
        !          25441:                        }
        !          25442:                case A_NOT:
        !          25443:                        switch (get(lxchar)) {
        !          25444:                        case '=':
        !          25445:                                reti(EQUOP,NE);
        !          25446:                        default:
        !          25447:                                saved = lxchar;
        !          25448:                                reti(NOT,NOT);
        !          25449:                        }
        !          25450:                case A_GT:
        !          25451:                        switch(get(lxchar)) {
        !          25452:                        case '>':
        !          25453:                                switch (get(lxchar)) {
        !          25454:                                case '=':
        !          25455:                                        reti(ASOP,ASRS);
        !          25456:                                        break;
        !          25457:                                default:
        !          25458:                                        saved = lxchar;
        !          25459:                                        reti(SHIFTOP,RS);
        !          25460:                                }
        !          25461:                        case '=':
        !          25462:                                reti(RELOP,GE);
        !          25463:                        default:
        !          25464:                                saved = lxchar;
        !          25465:                                reti(GT,GT);
        !          25466:                        }
        !          25467:                case A_LT:
        !          25468:                        switch (get(lxchar)) {
        !          25469:                        case '<':
        !          25470:                                switch (get(lxchar)) {
        !          25471:                                case '=':
        !          25472:                                        reti(ASOP,ASLS);
        !          25473:                                default:
        !          25474:                                        saved = lxchar;
        !          25475:                                        reti(SHIFTOP,LS);
        !          25476:                                }
        !          25477:                        case '=':
        !          25478:                                reti(RELOP,LE);
        !          25479:                        default:
        !          25480:                                saved = lxchar;
        !          25481:                                reti(LT,LT);
        !          25482:                        }
        !          25483:                case A_AND:
        !          25484:                        switch (get(lxchar)) {
        !          25485:                        case '&':
        !          25486:                                reti(ANDAND,ANDAND);
        !          25487:                        case '=':
        !          25488:                                reti(ASOP,ASAND);
        !          25489:                        default:
        !          25490:                                saved = lxchar;
        !          25491:                                reti(AND,AND);
        !          25492:                        }
        !          25493:                case A_OR:
        !          25494:                        switch (get(lxchar)) {
        !          25495:                        case '|':
        !          25496:                                reti(OROR,OROR);
        !          25497:                        case '=':
        !          25498:                                reti(ASOP,ASOR);
        !          25499:                        default:
        !          25500:                                saved = lxchar;
        !          25501:                                reti(OR,OR);
        !          25502:                        }
        !          25503:                case A_ER:
        !          25504:                        switch (get(lxchar)) {
        !          25505:                        case '=':
        !          25506:                                reti(ASOP,ASER);
        !          25507:                        default:
        !          25508:                                saved = lxchar;
        !          25509:                                reti(ER,ER);
        !          25510:                        }
        !          25511:                case A_PL:
        !          25512:                        switch (get(lxchar)) {
        !          25513:                        case '=':
        !          25514:                                reti(ASOP,ASPLUS);
        !          25515:                        case '+':
        !          25516:                                reti(ICOP,INCR);
        !          25517:                        default:
        !          25518:                                saved = lxchar;
        !          25519:                                reti(PLUS,PLUS);
        !          25520:                        }
        !          25521:                case A_MIN:
        !          25522:                        switch (get(lxchar)) {
        !          25523:                        case '=':
        !          25524:                                reti(ASOP,ASMINUS);
        !          25525:                        case '-':
        !          25526:                                reti(ICOP,DECR);
        !          25527:                        case '>':
        !          25528:                                if (get(lxchar) == '*')
        !          25529:                                        {reti(REFMUL,REF);}
        !          25530:                                else
        !          25531:                                        saved = lxchar;
        !          25532:                                reti(REF,REF);
        !          25533:                        default:
        !          25534:                                saved = lxchar;
        !          25535:                                reti(MINUS,MINUS);
        !          25536:                        }
        !          25537:                case A_MUL:
        !          25538:                        switch (get(lxchar)) {
        !          25539:                        case '=':
        !          25540:                                reti(ASOP,ASMUL);
        !          25541:                        case '/':
        !          25542:                                error('w',"*/ not as end of comment");
        !          25543:                        default:
        !          25544:                                saved = lxchar;
        !          25545:                                reti(MUL,MUL);
        !          25546:                        }
        !          25547:                case A_MOD:
        !          25548:                        switch (get(lxchar)) {
        !          25549:                        case '=':
        !          25550:                                reti(ASOP,ASMOD);
        !          25551:                        default:
        !          25552:                                saved = lxchar;
        !          25553:                                reti(DIVOP,MOD);
        !          25554:                        }
        !          25555:                default:
        !          25556:                        {error('i',"lex act==%d getc()->%d",p,lxchar);}
        !          25557: 
        !          25558:                }
        !          25559: 
        !          25560:                error('i',"lex, main switch");
        !          25561:        }
        !          25562: 
        !          25563: }
        !          25564: 
        !          25565: int lxtitle()
        !          25566: /*
        !          25567:        called after a newline; set linenumber and file name
        !          25568: */
        !          25569: {
        !          25570:        register c;
        !          25571: 
        !          25572:        for(;;)
        !          25573:        switch ( get(c) ) {
        !          25574:        default:                // e.g. not '\n', not '#'
        !          25575:                return c;
        !          25576:        case '\n':
        !          25577:                tloc.line++;
        !          25578: //             Nline++;
        !          25579:        ll:
        !          25580:                break;
        !          25581:        case '#':       /* # lineno "filename" */
        !          25582:        {       int cl = tloc.line;
        !          25583:                tloc.line = 0;
        !          25584:                for(;;) 
        !          25585:                switch (get(c)) {
        !          25586:                case '"':
        !          25587:                        start_txt();
        !          25588:                        for(;;)
        !          25589:                        switch (get(c)) {
        !          25590:                        case '"':
        !          25591:                                pch('\0');
        !          25592: 
        !          25593:                                while (get(c) != '\n') ;  // skip to eol.. ignore anything more
        !          25594: 
        !          25595:                                if (*txtstart) {        // stack file name
        !          25596:                                        char* fn;
        !          25597:                                        if (tcurr_file == 0){
        !          25598:                                                if (( fn = file_name[0]) 
        !          25599:                                                        && (strcmp(txtstart,fn)!=0)){  // 1st include
        !          25600:                                                        if (MAXFILE*4<++Nfile) error('i',"fileN buffer overflow");
        !          25601:                                                        if (MAXFILE<++tcurr_file) error('i',"fileN stack overflow");
        !          25602:                                                        file_stack[tcurr_file] = Nfile;
        !          25603:                                                
        !          25604:                                                        char* p1 = new char[txtfree-txtstart];
        !          25605:                                                        (void) strcpy(p1,txtstart);
        !          25606:                                                        file_name[Nfile] = p1;
        !          25607:        //                                              Nstr++;
        !          25608:                                                }
        !          25609:                                                else { //&& line is dummy #line "input.c"
        !          25610:                                                        // ignore
        !          25611:                                                }
        !          25612: //&& dead, dead, dead                  goto push;
        !          25613:                                        }
        !          25614:                                        else if ( (fn=file_name[file_stack[tcurr_file]])
        !          25615:                                        && (strcmp(txtstart,fn)==0) ) {
        !          25616:                                                //new line, same file: ignore
        !          25617:                                        }
        !          25618:                                        else if ( (fn=file_name[file_stack[tcurr_file-1]])
        !          25619:                                        && (strcmp(txtstart,fn)==0) ) {
        !          25620:                                                // previous file: pop
        !          25621:                                                tcurr_file--;
        !          25622:                                        }
        !          25623:                                        else {  // new file name: push
        !          25624: //&&                           push:
        !          25625:                                                if (MAXFILE*4<Nfile++) error('i',"fileN buffer overflow");
        !          25626:                                                if (MAXFILE<tcurr_file++) error('i',"fileN stack overflow");
        !          25627:                                                file_stack[tcurr_file] = Nfile;
        !          25628:                                                char* p = new char[txtfree-txtstart];
        !          25629:                                                (void) strcpy(p,txtstart);
        !          25630:                                                file_name[Nfile] = p;
        !          25631: //                                             Nstr++;
        !          25632:                                        }
        !          25633:                                }
        !          25634:                                else {  // no name .. back to the original .c file: ""
        !          25635:                                        tcurr_file = 0;
        !          25636:                                }
        !          25637:                                del_txt();
        !          25638:                                tloc.file = file_stack[tcurr_file];
        !          25639:                                goto ll;
        !          25640:                        case '\n':
        !          25641:                                error("unexpected end of line on '# line'");
        !          25642:                        default:
        !          25643:                                pch(c);
        !          25644:                        }
        !          25645:                case ' ':
        !          25646:                        break;
        !          25647: 
        !          25648:                case '0':
        !          25649:                case '1':
        !          25650:                case '2':
        !          25651:                case '3':
        !          25652:                case '4':
        !          25653:                case '5':
        !          25654:                case '6':
        !          25655:                case '7':
        !          25656:                case '8':
        !          25657:                case '9':
        !          25658:                        tloc.line = tloc.line*10+c-'0'; 
        !          25659:                        break;
        !          25660: 
        !          25661:                case 'l':       // look for "#line ..." and then ignore "line"
        !          25662:                        if (get(c)=='i' && get(c)=='n' && get(c)=='e') break;
        !          25663:                case '\n':
        !          25664:                         tloc.putline();
        !          25665:                         goto ll;
        !          25666: 
        !          25667:                default: // pass #rubbish through
        !          25668:                        tloc.line = cl;
        !          25669:                        pch('#');
        !          25670:                        pch(c);
        !          25671:                        while (get(c) != '\n') pch(c);
        !          25672:                        pch('\0');
        !          25673:                        fprintf(out_file,"\n%s\n",txtstart);
        !          25674:                        start_txt();
        !          25675:                        tloc.line++;
        !          25676: //                     Nline++;
        !          25677:                        goto ll;
        !          25678:                }
        !          25679:        }
        !          25680:        }
        !          25681: }
        !          25682: 0707071010112044351004440001630000160000010204200466055404600000700000046311main.c/*ident     "@(#)ctrans:src/main.c  1.9" */
        !          25683: /***********************************************************************
        !          25684: 
        !          25685:        C++ source for cfront, the C++ compiler front-end
        !          25686:        written in the computer science research center of Bell Labs
        !          25687: 
        !          25688:        Copyright (c) 1984 AT&T, Inc. All Rights Reserved
        !          25689:        THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T, INC.
        !          25690: 
        !          25691: main.c:
        !          25692: 
        !          25693:        Initialize global environment
        !          25694:        Read argument line
        !          25695:        Start compilation
        !          25696:        Clean up and exit
        !          25697: 
        !          25698: **************************************************************************/
        !          25699: 
        !          25700: #ifdef __cplusplus
        !          25701: #include <stdlib.h>
        !          25702: #endif
        !          25703: 
        !          25704: #include <ctype.h>
        !          25705: #include <string.h>
        !          25706: #include <libc.h>
        !          25707: #include <osfcn.h>
        !          25708: #include <fstream.h>
        !          25709: #include "size.h"
        !          25710: #include "cfront.h"
        !          25711: #include "tree_dump.h"
        !          25712: #include "template.h"
        !          25713: #include "hash.h"
        !          25714: 
        !          25715: char* prog_name = "<<AT&T C++ Translator <(3.0)(PT)> 08/08/90>>";
        !          25716: char* src_file_name = "";
        !          25717: char* line_format = "\n# %d \"%s\"\n";
        !          25718: 
        !          25719: int dump_tree;
        !          25720: int tree_dump_brief = 0;
        !          25721: dcn_arg dump_tree_arg;
        !          25722: 
        !          25723: #ifdef unix
        !          25724: #include <signal.h>
        !          25725: 
        !          25726: static void core_dump(int = 0)
        !          25727: {
        !          25728:        if (error_count)
        !          25729:                fprintf(stderr,"sorry, cannot recover from previous error\n");
        !          25730:        else 
        !          25731:                error('i',"bus error (or something nasty like that)");
        !          25732:        ext(99);
        !          25733: }
        !          25734: #endif
        !          25735: 
        !          25736: Plist isf_list;
        !          25737: Pstmt st_ilist;
        !          25738: Pstmt st_dlist;
        !          25739: Ptable sti_tbl;
        !          25740: Ptable std_tbl;
        !          25741: Plist stat_mem_list;
        !          25742: 
        !          25743: int vtbl_opt = -1;     // how to deal with vtbls:
        !          25744:                        // -1 static and defined
        !          25745:                        // 0 external and supposed to be defined elsewhere
        !          25746:                        // 1 external and defined
        !          25747: int debug_opt;
        !          25748: int gplus_opt;         // -g to cc, overrides print optimization 
        !          25749: int ansi_opt;
        !          25750: int strict_opt;                // disallow features from the anachronism section
        !          25751:                        // of the manual
        !          25752: int warning_opt;       // produce more warnings if set
        !          25753: bit stmtno = 0;
        !          25754: 
        !          25755: extern simpl_init();
        !          25756: extern typ_init();
        !          25757: extern syn_init();
        !          25758: extern lex_init();
        !          25759: extern error_init();
        !          25760: 
        !          25761: char *st_name(char*);  // generates names of static ctor, dtor callers, ptbl_vec
        !          25762: Pname def_name;                // first definition in file
        !          25763: Pname pdef_name;       // used with ptbl_vec if function is first definition
        !          25764: 
        !          25765: int syn_count = 0; // to set conditional breakpoints to find particular expressions  
        !          25766: Hash *dumper_node_hash_table;
        !          25767:   
        !          25768: void static
        !          25769: clean_dumper_hash_table() {
        !          25770:        if(!dumper_node_hash_table) 
        !          25771:                return;
        !          25772:        else {
        !          25773:                HashWalker hi(*dumper_node_hash_table);
        !          25774:                while(hi.valid ()) {
        !          25775:                        struct node& n = *(struct node*) hi.key();
        !          25776:                if(n.permanent == 0 || n.permanent == 3) /* flush deleted nodes */          
        !          25777:                        dumper_node_hash_table->del(hi.key());
        !          25778:                hi.advance();                              
        !          25779:                }                 
        !          25780:        }     
        !          25781: }     
        !          25782:    
        !          25783: void run()
        !          25784: /*
        !          25785:        run the appropriate stages
        !          25786: */
        !          25787: {
        !          25788:        Pname n;
        !          25789:        templp = new templ_compilation;  // canonical instance
        !          25790:                                         
        !          25791: 
        !          25792:        if(dump_tree) {
        !          25793:                dumper_node_hash_table =
        !          25794:                        dump_tree_arg.nodes_seen_hash = new pointer_hash (10000);
        !          25795:                dump_tree_arg.verbose = dt_recursive_1;
        !          25796:        }    
        !          25797: 
        !          25798:        while (n=syn()) {
        !          25799:                if (n == Pname(1)) continue;
        !          25800:                if (n->n_list) PERM(n->tp);
        !          25801: 
        !          25802:                DB( if(Rdebug>=1) error('d',"run: syn(): '%s'", n->string););
        !          25803:                 templp->instantiate_ref_templ();
        !          25804: 
        !          25805:                for (Pname nx, nn=n; nn; nn=nx) {
        !          25806:                        Pname rr;
        !          25807:                        ++syn_count;
        !          25808:                        nx = nn->n_list;
        !          25809:                        nn->n_list = 0;
        !          25810: 
        !          25811:                        DB( if(Rdebug>=1) error('d',"run: dcl(): %n, base: %k",nn,nn->base););
        !          25812: 
        !          25813:                        if ((rr=nn->dcl(gtbl,EXTERN))==0
        !          25814:                        || nn->base==0
        !          25815:                        || error_count) continue;
        !          25816: 
        !          25817:                        DB( if(Rdebug>=1) error('d',"run: simpl(): %n",nn););
        !          25818: 
        !          25819:                        nn->simpl();
        !          25820: 
        !          25821:                        if (error_count) {
        !          25822:                                if(dump_tree) {
        !          25823:                                        display_cfront_node (dump_tree_arg, nn);
        !          25824:                                        *dump_tree_arg.output_stream << "---------------------------\n\n";
        !          25825:                                }
        !          25826:                                continue;
        !          25827:                        }
        !          25828: 
        !          25829:                        DB( if(Rdebug>=1) error('d',"run:print(): %n (%k) tp %t",nn,nn->base,nn->tp););
        !          25830: 
        !          25831:                        if (nn->base == TNAME)
        !          25832:                                nn->dcl_print(0);
        !          25833:                        else {
        !          25834:                                Ptype t = nn->tp;
        !          25835:                        llxx:
        !          25836:                                switch (t->base) {
        !          25837:                                case TYPE:
        !          25838:                                        t = Pbase(t)->b_name->tp; goto llxx;
        !          25839:                                case CLASS:
        !          25840:                                        DB( if(Rdebug>=1) fprintf(stderr," -- class\n"););
        !          25841:                                        if (vtbl_opt==1 || gplus_opt) n->dcl_print(0);
        !          25842:                                        break;
        !          25843:                                case ENUM:
        !          25844:                                        DB( if(Rdebug>=1) fprintf(stderr," -- enum\n"););
        !          25845:                                        Penum(n->tp)->dcl_print(0);
        !          25846:                                        break;
        !          25847:                                case FCT:
        !          25848:                                        DB( if(Rdebug>=1) error('d'," -- fct%n inline %d body %d",nn,Pfct(t)->f_inline,Pfct(t)->body););
        !          25849:                                        if (Pfct(t)->body==0
        !          25850:                                        || (debug_opt==0 && Pfct(t)->f_inline && ((n->n_table!=gtbl) || strcmp(nn->string,"main")))
        !          25851:                                        || Pfct(t)->f_imeasure && Pfct(t)->f_inline==0) break;
        !          25852:                                        DB( if(Rdebug>=1) error('d',"rr %n inline %d body %d",rr,Pfct(rr->tp)->f_inline,Pfct(rr->tp)->body););
        !          25853:                                        rr->dcl_print(0);
        !          25854:                                        break;
        !          25855:        
        !          25856:                                default:
        !          25857:                                        DB( if(Rdebug>=1) error('d'," -- %n tpbase: %k",nn,nn->tp->base););
        !          25858:                                        // print class def, if appropriate
        !          25859:                                        // can't use tsizeof() since this may
        !          25860:                                        // print an error if class isn't defined
        !          25861:                                        { for(Ptype tx = t;;) {
        !          25862:                                                switch ( tx->base ) {
        !          25863:                                                case VEC:
        !          25864:                                                    tx=Pvec(tx)->typ;
        !          25865:                                                    continue;
        !          25866:                                                case TYPE: case COBJ:
        !          25867:                                                    tx=Pbase(tx)->b_name->tp;
        !          25868:                                                    continue;
        !          25869:                                                }
        !          25870:                                                Pclass cl = Pclass(tx);
        !          25871:                                                if ( cl->base == CLASS
        !          25872:                                                &&  (cl->defined&(DEFINED|SIMPLIFIED))
        !          25873:                                                &&   cl->c_body==1 )
        !          25874:                                                        cl->dcl_print(0);
        !          25875:                                                break;
        !          25876:                                          }
        !          25877:                                        }
        !          25878:                                        nn->dcl_print(0);
        !          25879:                                }
        !          25880:                        }
        !          25881: 
        !          25882:                        if(dump_tree) {
        !          25883:                                display_cfront_node (dump_tree_arg, nn);
        !          25884:                                *dump_tree_arg.output_stream << "---------------------------\n\n";
        !          25885:                        }
        !          25886: 
        !          25887:                        if (error_count) continue;
        !          25888: 
        !          25889:                        DB( if(Rdebug>=1) error('d',"run: cleanup"););
        !          25890:                        switch (nn->tp->base) { // clean up
        !          25891:                        default:
        !          25892:                        {       
        !          25893:                                Pexpr i = nn->n_initializer;
        !          25894:                                DB( if(Rdebug>=1) error('d',"default nn %n i %d",nn,i););
        !          25895:                                if (i && i!=Pexpr(1)) {
        !          25896:                                        DEL(i);
        !          25897:                                        nn->n_initializer = 0;
        !          25898:                                        if (def_name==0 && rr->n_scope != STATIC) { 
        !          25899:                                                def_name = rr;
        !          25900:                                                if (pdef_name == 0) ptbl_init(0);
        !          25901:                                        }
        !          25902:                                }
        !          25903:                                break;
        !          25904:                        }
        !          25905: 
        !          25906:                        case FCT:
        !          25907:                        {       
        !          25908:                                Pfct f = Pfct(nn->tp);
        !          25909:                                DB( if(Rdebug>=1) error('d', "function nn: %n local_class: %d %d", nn, local_class, f->local_class ););
        !          25910:                                if (f->body
        !          25911:                                && f->f_inline==0
        !          25912:                                && f->f_imeasure==0) {
        !          25913:                                         if ( local_class = f->local_class )  { 
        !          25914:                                                delete_local();
        !          25915:                                                local_class = 0;
        !          25916:                                        }
        !          25917: 
        !          25918:                                         if (ansi_opt && f->f_this) {
        !          25919:                                                 f->f_this->n_table = 0;
        !          25920:                                                 for (Pname n=f->f_this->n_list; n; n=n->n_list)
        !          25921:                                                         n->n_table = 0;
        !          25922:                                         }
        !          25923: 
        !          25924:                                        DEL(f->body);
        !          25925:                                        if (def_name==0) { 
        !          25926:                                                def_name = rr;
        !          25927:                                                if (pdef_name == 0) ptbl_init(0);
        !          25928:                                        }
        !          25929:                                }
        !          25930:                                break;
        !          25931:                        }
        !          25932: 
        !          25933:                        case CLASS:
        !          25934:                        {       Pclass cl = Pclass(nn->tp);
        !          25935:                                for (Pname px, p=cl->mem_list; p; p=px) {
        !          25936:                                    px = p->n_list;
        !          25937:                                    if (p->tp) {
        !          25938:                                        switch (p->tp->base) {
        !          25939:                                        case FCT:
        !          25940:                                        {       Pfct f = (Pfct)p->tp;
        !          25941:                                                if (f->body) {
        !          25942:                                                        if (f->f_inline==0
        !          25943:                                                        && f->f_imeasure==0) {
        !          25944:                                                                if ( local_class = f->local_class ) {
        !          25945:                                                                        delete_local();
        !          25946:                                                                        local_class = 0;
        !          25947:                                                                }
        !          25948:                                                                DEL(f->body);
        !          25949:                                                                f->body = 0;
        !          25950:                                                        }
        !          25951:                                                }
        !          25952:                                        }
        !          25953:                                        case CLASS:
        !          25954:                                        case ENUM:
        !          25955:                                                break;
        !          25956:                                        case COBJ:
        !          25957:                                        case EOBJ:
        !          25958:                                                DEL(p);
        !          25959:                                                break;
        !          25960:                                        default:
        !          25961:                                                delete p;
        !          25962:                                        }
        !          25963:                                    } else {
        !          25964:                                        delete p;
        !          25965:                                    }
        !          25966:                                } // for
        !          25967:                                cl->mem_list = 0;
        !          25968:                                cl->permanent = 3;
        !          25969:                                break;
        !          25970:                        }
        !          25971:                        }
        !          25972:                        DEL(nn);
        !          25973:                }
        !          25974:                lex_clear();
        !          25975:                if (dump_tree) clean_dumper_hash_table();
        !          25976:        }
        !          25977:        templp->end_of_compilation() ;
        !          25978: 
        !          25979:        switch (no_of_undcl) {
        !          25980:        case 1:         {error('w',"undeclaredF%n called",undcl);}
        !          25981:        case 0:         break;
        !          25982:        default:        {error('w',"%d undeclaredFs called; for example%n",no_of_undcl,undcl);}
        !          25983:        }
        !          25984: 
        !          25985:        switch (no_of_badcall) {
        !          25986:        case 1:         {error('w',"%n declaredWoutAs calledWAs",badcall);}
        !          25987:        case 0:         break;
        !          25988:        default:        {error('w',"%d Fs declaredWoutAs calledWAs; for example%n",no_of_badcall,badcall);}
        !          25989:        }
        !          25990: 
        !          25991:        if (error_count) return;
        !          25992: 
        !          25993:        int i = 1;
        !          25994:        for (Pname m=gtbl->get_mem(i); m; m=gtbl->get_mem(++i)) {
        !          25995:                if (m->base==TNAME
        !          25996:                || m->n_sto==EXTERN
        !          25997:                || m->n_stclass == ENUM) continue;
        !          25998: 
        !          25999:                Ptype t = m->tp;
        !          26000:                if (t == 0) continue;
        !          26001:                switch (t->base) {
        !          26002:                case CLASS:
        !          26003:                case ENUM:
        !          26004:                case OVERLOAD:  continue;
        !          26005:                case COBJ:
        !          26006:                //case ANON:
        !          26007:                case VEC:       break;
        !          26008:                case FCT:
        !          26009:                                if (Pfct(t)->f_inline || Pfct(t)->body==0) continue;
        !          26010:                }
        !          26011: 
        !          26012: //error('d',&m->where,"%n %d %d %s",m,m->n_addr_taken,m->n_used,m->n_sto==STATIC?"static":"");
        !          26013: //xxx doesn't check anon union members as their use bits are set differently
        !          26014:                if (m->n_addr_taken==0
        !          26015:                && m->n_used==0
        !          26016:                && m->n_sto == STATIC) { // (static or anon?)
        !          26017:                        for(;;) {
        !          26018: //error('d',&m->where,"  %t tconst(): %d",t,t->tconst());
        !          26019:                                if(t->base==TYPE) {
        !          26020:                                        if(t->tconst()) break;
        !          26021:                                        t=Pbase(t)->b_name->tp;
        !          26022:                                } else if(t->base==VEC) {
        !          26023:                                        t=Pvec(t)->typ;
        !          26024:                                } else {
        !          26025:                                    if ( t->tconst() == 0 ) {
        !          26026: //error('d',"m%n tp%t t%t",m,m->tp,t);
        !          26027:                                        if ( t->base != COBJ )
        !          26028:                                                error('w',&m->where,"%n defined but not used",m);
        !          26029:                                        else { Pclass cl;
        !          26030:                                            cl = Pclass(Pbase(t)->b_name->tp);
        !          26031:                                            if ( cl->has_ctor()==0 )
        !          26032:                                                if ( cl->csu == ANON )
        !          26033:                                                 ; //error('w',&m->where,"anonymous union defined but not used");
        !          26034:                                                else
        !          26035:                                                    error('w',&m->where,"%n defined but not used",m);
        !          26036:                                        }
        !          26037:                                    } // if const
        !          26038:                                    break;
        !          26039:                                }
        !          26040:                        } // for
        !          26041:                } // if static and not used
        !          26042:        }
        !          26043: 
        !          26044:         Pname ctor = 0;
        !          26045:        Pname dtor = 0;
        !          26046:        --curloc.line;
        !          26047: 
        !          26048:        if (st_ilist) { //      make an "init" function;
        !          26049:                        //      it calls all constructors for static objects
        !          26050:                DB( if(Rdebug>=1) error('d',"make sti"); );
        !          26051:                Pname n = new name( st_name("__sti__") );
        !          26052:                Pfct f = new fct(void_type,0,1);
        !          26053:                n->tp = f;
        !          26054:                f->body = new block(st_ilist->where,0,st_ilist);
        !          26055:        //      f->body->s = st_ilist;
        !          26056:                f->body->memtbl = sti_tbl;
        !          26057:                n->n_sto = EXTERN;
        !          26058:                // assignments here are really initializations:
        !          26059:                ignore_const++;
        !          26060:                f->f_linkage = linkage_C;
        !          26061:                f->sign();
        !          26062:                (void) n->dcl(gtbl,EXTERN);
        !          26063:                ignore_const--;
        !          26064:                n->simpl();
        !          26065:                n->dcl_print(0);
        !          26066:                ctor = n;
        !          26067:        }
        !          26068: 
        !          26069:        if (st_dlist) { //      make a "done" function;
        !          26070:                        //      it calls all destructors for static objects
        !          26071:                DB( if(Rdebug>=1) error('d',"make std"); );
        !          26072:                Pname n = new name( st_name("__std__") );
        !          26073:                Pfct f = new fct(void_type,0,1);
        !          26074:                n->tp = f;
        !          26075:                f->body = new block(st_dlist->where,0,st_dlist);
        !          26076:        //      f->body->s = st_dlist;
        !          26077:                f->body->memtbl = std_tbl;
        !          26078:                n->n_sto = EXTERN;
        !          26079:                f->f_linkage = linkage_C;
        !          26080:                f->sign();
        !          26081:                (void) n->dcl(gtbl,EXTERN);
        !          26082:                n->simpl();
        !          26083:                n->dcl_print(0);
        !          26084:                dtor = n;
        !          26085:        }
        !          26086: 
        !          26087: #ifdef PATCH
        !          26088:                /*For fast load: make a static "__link" */
        !          26089:        if (ctor || dtor)
        !          26090:        {
        !          26091:                printf("static struct __linkl { struct __linkl * next;\n");
        !          26092:                if ( ansi_opt )
        !          26093:                        printf("void (*ctor)(); void (*dtor)(); } __link = \n");
        !          26094:                else
        !          26095:                        printf("char (*ctor)(); char (*dtor)(); } __link = \n");
        !          26096:        //      printf("{ (struct __linkl *)0, %s, %s };\n",
        !          26097:        //              ctor_name ? ctor_name : "0",
        !          26098:        //              dtor_name ? dtor_name : "0");
        !          26099:                putstring("{ (struct __linkl *)0, ");
        !          26100:                if (ctor) ctor->print(); else putch('0');
        !          26101:                putch(',');
        !          26102:                if (dtor) dtor->print(); else putch('0');
        !          26103:                putstring("};\n");
        !          26104:        }
        !          26105: #endif
        !          26106: 
        !          26107:         DB( if(Rdebug>=1) error( 'd', "run: vlist: %d", vlist ); );
        !          26108:         do {
        !          26109:                for (vl* v = vlist; v; v = v->next) v->cl->really_print(v->vt);
        !          26110:                vlist = 0;
        !          26111: 
        !          26112:                for (Plist l=isf_list; l; l=l->l) {
        !          26113:                        Pname n = l->f;
        !          26114:                        Pfct f = Pfct(n->tp);
        !          26115: DB( if(Rdebug>=1)error('d',"isf %n %t f %d addr %d",n,f,f,n->n_addr_taken); );
        !          26116:                        if (f->base == OVERLOAD) {
        !          26117:                                n = Pgen(f)->fct_list->f;       // first fct
        !          26118:                                f = Pfct(n->tp);
        !          26119:                        }
        !          26120: 
        !          26121:                        if (debug_opt==0 && 
        !          26122:                                n->n_addr_taken) {
        !          26123:                                f->f_inline = 0;
        !          26124:                                if (n->n_dcl_printed<2) {
        !          26125:                                        if (warning_opt)
        !          26126:                                                error('w',"out-of-line copy of %n created",n);
        !          26127:                                        n->dcl_print(0);
        !          26128:                                }
        !          26129:                        }
        !          26130:                }
        !          26131:        } while (vlist);
        !          26132: 
        !          26133:        if (strict_opt == 0) { // define static members 
        !          26134:                // patch for SysV VAX -g linkage botch
        !          26135:                for (Plist l=stat_mem_list; l; l=l->l) {
        !          26136:                        Pname n = l->f;
        !          26137: // error('d',"stat mem %n %d %d ",n,n->n_initializer,n->n_evaluated);
        !          26138:                        if (n->n_initializer==0 && n->n_evaluated==0) {
        !          26139:                                Ptype t = n->tp;
        !          26140:                                n->n_sto = 0;
        !          26141:                                Pname cn = t->is_cl_obj();
        !          26142:                                if (cn==0) cn = cl_obj_vec;
        !          26143:                                if (cn) (void) t->tsizeof();    // be sure to print class
        !          26144:                                if ((cn && Pclass(cn->tp)->has_ctor())
        !          26145:                                || t->is_ref())
        !          26146:                                        ; // force explicit definition
        !          26147:                                else
        !          26148:                                        n->dcl_print(0);
        !          26149:                        }
        !          26150:                }
        !          26151:        }
        !          26152: 
        !          26153:        i = 1;
        !          26154:        for (Pname nm=ptbl->get_mem(i); nm; nm=ptbl->get_mem(++i))  {
        !          26155:                DB( if(Rdebug>=1) error('d',"ptbl anme %s string2 %s key:%k",nm->string==0?"???":nm->string2,nm->string2==0?"???":nm->string2,nm->n_key); );
        !          26156:                if ( nm->n_key == 0 ) { // ptbl used in file, generate definition
        !          26157:                        int str1 = (*src_file_name)?strlen(src_file_name)+2:0; // +2 for __
        !          26158:                        int str2 = strlen(nm->string2) - str1;
        !          26159:                        char *ps = new char[ str2 + 1 ];
        !          26160:                        strncpy( ps, nm->string2, str2 ); // grab vtbl name
        !          26161:                        ps[str2]='\0';
        !          26162:                        ps[2] = 'v';
        !          26163:                        fprintf(out_file,"extern struct __mptr %s[];\n",ps);
        !          26164:                        // fprintf(out_file,"struct __mptr* %s = %s;\n",nm->string2,ps);
        !          26165:                        ptbl_add_pair(nm->string2,ps);
        !          26166:                        delete ps;
        !          26167:                }
        !          26168:        }
        !          26169: 
        !          26170:        ptbl_init(1);
        !          26171:        curloc.putline();
        !          26172:        fprintf(out_file,"\n/* the end */\n");
        !          26173: }
        !          26174: 
        !          26175: 
        !          26176: #ifdef DBG
        !          26177: int Adebug = 0;
        !          26178: int Ddebug = 0;
        !          26179: int Edebug = 0;
        !          26180: int Ldebug = 0;
        !          26181: int Mdebug = 0;
        !          26182: int Ndebug = 0;
        !          26183: int Pdebug = 0;
        !          26184: int Rdebug = 0;
        !          26185: int Sdebug = 0;
        !          26186: int Tdebug = 0;
        !          26187: //Ydebug == yydebug initialized in y.tab.c
        !          26188: void
        !          26189: process_debug_flags( char* p )
        !          26190: {
        !          26191:        // arg to +Dxxx or debugging comments //@!xxx
        !          26192:        // format of xxx == sequence of any combination of
        !          26193:        //      +flags  --  increment flags (default)
        !          26194:        //      -flags  --  decrement flags
        !          26195:        //      0flags  --  unset flags
        !          26196:        // where flags are single chars
        !          26197:        int incr = 1;
        !          26198:        char c;
        !          26199:        fprintf(stderr,"\n*** processing debugging flags '%s'\n",p);
        !          26200:        while ( c = *p++ ) {
        !          26201:                switch ( c ) {
        !          26202:                case '+': incr =  1; break;
        !          26203:                case '-': incr = -1; break;
        !          26204:                case '0': incr =  0; break;
        !          26205:                case ' ': break;
        !          26206:                // flags...
        !          26207:                case 'A': if(incr==0) Adebug=0; else Adebug+=incr; break;
        !          26208:                case 'D': if(incr==0) Ddebug=0; else Ddebug+=incr; break;
        !          26209:                case 'E': if(incr==0) Edebug=0; else Edebug+=incr; break;
        !          26210:                case 'L': if(incr==0) Ldebug=0; else Ldebug+=incr; break;
        !          26211:                case 'M': if(incr==0) Mdebug=0; else Mdebug+=incr; break;
        !          26212:                case 'N': if(incr==0) Ndebug=0; else Ndebug+=incr; break;
        !          26213:                case 'P': if(incr==0) Pdebug=0; else Pdebug+=incr; break;
        !          26214:                case 'R': if(incr==0) Rdebug=0; else Rdebug+=incr; break;
        !          26215:                case 'S': if(incr==0) Sdebug=0; else Sdebug+=incr; break;
        !          26216:                case 'T': if(incr==0) Tdebug=0; else Tdebug+=incr; break;
        !          26217:                case 'Y': if(incr==0) Ydebug=0; else Ydebug+=incr; break;
        !          26218:                default: error('w',"unknown debugging flag '%c'",c);
        !          26219:                }
        !          26220:        }
        !          26221: }
        !          26222: #endif /*DBG*/
        !          26223: 
        !          26224: int no_of_undcl, no_of_badcall;
        !          26225: Pname undcl, badcall;
        !          26226: 
        !          26227: void pt_option(char * ostr) 
        !          26228: { // options +O[BTo] for PT
        !          26229:     ostr ++;                   /* skip the O */
        !          26230:     switch(*ostr) {
        !          26231:       default:
        !          26232:        fprintf(stderr, "cfront: argument syntax: invalidZizedTs option (+O[BTo].");
        !          26233:        exit(11);
        !          26234:     case 'B':
        !          26235:        tree_dump_brief = 1;
        !          26236:     case 'T':
        !          26237:        dump_tree = 1;
        !          26238:        if(0 == *(ostr + 1) || strcmp (ostr, "T-") == 0)
        !          26239:            dump_tree_arg.output_stream = (ostream*)&cout;
        !          26240:        else {
        !          26241:            dump_tree_arg.output_stream
        !          26242:                = new ofstream (ostr+1, ios::out);
        !          26243:            if(dump_tree_arg.output_stream->fail()) {
        !          26244:                perror ("cfront");
        !          26245:                fprintf (stderr, "Failed to open %s\n", ostr + 1);
        !          26246:                exit (11);
        !          26247:            }
        !          26248:        }
        !          26249:        break;
        !          26250:       case 'o':
        !          26251:        out_file = fopen (ostr+1, "w");
        !          26252:        if(out_file == NULL) {
        !          26253:            perror ("cfront");
        !          26254:            fprintf(stderr, "Failed to open %s\n", ostr+1);
        !          26255:            exit(11);
        !          26256:        }
        !          26257:        break;
        !          26258:     }
        !          26259: }
        !          26260: 
        !          26261: main(int argc, char* argv[])
        !          26262: /*
        !          26263:        read options, initialize, and run
        !          26264: */
        !          26265: {
        !          26266:        register char * cp;
        !          26267:        char* afile = "";
        !          26268: #ifdef unix
        !          26269: 
        !          26270: #ifdef COMPLETE_SIG_PF
        !          26271:         signal(SIGILL,core_dump);
        !          26272:         signal(SIGIOT,core_dump);
        !          26273:         signal(SIGEMT,core_dump);
        !          26274:         signal(SIGFPE,core_dump);
        !          26275:         signal(SIGBUS,core_dump);
        !          26276:         signal(SIGSEGV,core_dump);
        !          26277: #else
        !          26278:        typedef void (*ST)(int ...);    // trick to circumvent problems with old
        !          26279:        ST sick = ST(&signal);          // (or C) versions <signal.h>
        !          26280:        (*sick)(SIGILL,core_dump);
        !          26281:        (*sick)(SIGIOT,core_dump);
        !          26282:        (*sick)(SIGEMT,core_dump);
        !          26283:        (*sick)(SIGFPE,core_dump);
        !          26284:        (*sick)(SIGBUS,core_dump);
        !          26285:        (*sick)(SIGSEGV,core_dump);
        !          26286: 
        !          26287: #endif
        !          26288: #endif
        !          26289: 
        !          26290: // SUM: not needed
        !          26291: // #ifdef apollo
        !          26292: //     set_sbrk_size(1000000); // resets free store size
        !          26293: //#else
        !          26294: #ifndef apollo
        !          26295:        //(void) malloc(0);     // suppress cashing in V8 malloc
        !          26296: #endif
        !          26297: 
        !          26298:        error_init();
        !          26299: 
        !          26300:        for (int i=1; i<argc; ++i) {
        !          26301:                switch (*(cp=argv[i])) {
        !          26302:                case '+':
        !          26303:                        while (*++cp) {
        !          26304:                                switch(*cp) {
        !          26305:                                case 'O':   
        !          26306:                                        pt_option(cp);
        !          26307:                                        goto xx;
        !          26308:                                case 'f':
        !          26309:                                        src_file_name = cp+1;
        !          26310:                                        goto xx;
        !          26311:                                case 'x':       // read cross compilation table
        !          26312:                                        if (read_align(afile = cp+1)) {
        !          26313:                                                fprintf(stderr,"bad size-table (option +x)\n");
        !          26314:                                                exit(11);
        !          26315:                                        }
        !          26316:                                        goto xx;
        !          26317:                                case 'e':
        !          26318:                                        switch (*++cp) {
        !          26319:                                        case '0':
        !          26320:                                        case '1': 
        !          26321:                                                vtbl_opt = *cp-'0';
        !          26322:                                                break;
        !          26323:                                        default:
        !          26324:                                                fprintf(stderr,"bad +e option\n");
        !          26325:                                                exit(11);
        !          26326:                                        }
        !          26327:                                        break;
        !          26328:                                case 'd':
        !          26329:                                        debug_opt = 1;
        !          26330:                                        break;
        !          26331:                                case 'g':
        !          26332:                                        gplus_opt = 1;
        !          26333:                                        break;
        !          26334:                                case 'D':
        !          26335: #ifdef DBG
        !          26336:                                        process_debug_flags(++cp);
        !          26337: #else
        !          26338:                                        error('w',"cfront not compiled for debugging -- +D%s ignored",++cp);
        !          26339: #endif
        !          26340:                                        goto xx;
        !          26341:                                case 'w':
        !          26342:                                        warning_opt = 1;
        !          26343:                                        break;
        !          26344:                                case 'a':
        !          26345:                                        switch (*++cp) {
        !          26346:                                        case '0':
        !          26347:                                        case '1': 
        !          26348:                                                ansi_opt = *cp-'0';
        !          26349:                                                break;
        !          26350:                                        default:
        !          26351:                                                fprintf(stderr,"bad +a option\n");
        !          26352:                                                exit(11);
        !          26353:                                        }
        !          26354:                                        break;
        !          26355:                                case 'p':
        !          26356:                                        strict_opt = 1;
        !          26357:                                        break;
        !          26358:                                case 'L':
        !          26359:                                        line_format = "\n#line %d \"%s\"\n";
        !          26360:                                        break;
        !          26361:                                default:
        !          26362:                                        fprintf(stderr,"%s: unexpected option: +%c ignored\n",prog_name,*cp);
        !          26363: 
        !          26364:                                }
        !          26365:                        }
        !          26366:                xx:
        !          26367:                        break;
        !          26368:                default:
        !          26369:                        fprintf(stderr,"%s: bad argument \"%s\"\n",prog_name,cp);
        !          26370:                        exit(11);
        !          26371:                }
        !          26372:        }
        !          26373: 
        !          26374: 
        !          26375:        fprintf(out_file,line_format+1,1,src_file_name); // strips leading \n
        !          26376:        fprintf(out_file,"\n/* %s */\n",prog_name);
        !          26377:        if (*src_file_name) fprintf(out_file,"/* < %s > */\n",src_file_name);
        !          26378: 
        !          26379: //     if (Nspy) {
        !          26380: //             start_time = time(0);
        !          26381: //             print_align(afile);
        !          26382: //     }
        !          26383:        fflush(stderr);
        !          26384:        otbl_init();
        !          26385:        lex_init();
        !          26386:        syn_init();
        !          26387:        typ_init();
        !          26388:        simpl_init();
        !          26389:        scan_started = 1;
        !          26390:        curloc.putline();
        !          26391:        if ((BI_IN_BYTE==0) && (SZ_INT==0) && (SZ_WPTR==0))
        !          26392:                error("no size/alignment values - use +x of provide #ifdef in size.h");
        !          26393:        run();
        !          26394:        if(dump_tree) {
        !          26395:                ostream_printf(*dump_tree_arg.output_stream, "------------ GTBL ------------\n\n");
        !          26396:                display_cfront_node (dump_tree_arg, ktbl);
        !          26397:                ostream_printf(*dump_tree_arg.output_stream, "------------ KTBL ------------\n\n");
        !          26398:                display_cfront_node (dump_tree_arg, ktbl);
        !          26399:        }                                              
        !          26400: 
        !          26401: //     if (Nspy) {
        !          26402: //             stop_time = time(0);
        !          26403: //             spy(src_file_name);
        !          26404: //     }
        !          26405:        exit( (0<=error_count && error_count<127) ? error_count : 127);
        !          26406: }
        !          26407: 
        !          26408: char* st_name(char* pref)
        !          26409: /*
        !          26410:        make name "pref|source_file_name|_" or "pref|source_file_name|_"
        !          26411:        where non alphanumeric characters are replaced with '_'
        !          26412:        and add def_name at end to ensure uniqueness
        !          26413: */
        !          26414: {
        !          26415:        int prefl = strlen(pref);
        !          26416:        int strl = prefl + 2;   // trailing '_' and 0
        !          26417:        if (*src_file_name) strl += strlen(src_file_name);
        !          26418:        char* defs;
        !          26419:        int defl;
        !          26420:        if (def_name) {
        !          26421:                defs = def_name->string;
        !          26422:                defl = strlen(defs)+1;  // '_'
        !          26423:        }
        !          26424:        else {
        !          26425:                defs = 0;
        !          26426:                defl = 0;
        !          26427:        }
        !          26428:        char* name = new char[strl+defl];
        !          26429:        strcpy(name,pref);
        !          26430:        if (*src_file_name) strcpy(name+prefl,src_file_name);
        !          26431:        name[strl-2] = '_';
        !          26432:        name[strl-1] = 0;
        !          26433: //     char *p = name;
        !          26434: //     while ( *++p ) if (!isalpha(*p) && !isdigit(*p)) *p = '_';
        !          26435:        for (char* p = name; *p; p++) if (!isalpha(*p) && !isdigit(*p)) *p = '_';
        !          26436:        if (defs) {
        !          26437:                strcpy(name+strl-1,defs);       // after the '_'
        !          26438:                name[strl+defl-2] = '_';
        !          26439:                name[strl+defl-1] = 0;
        !          26440:        }
        !          26441: #ifdef DENSE
        !          26442:        void chop(char*);
        !          26443:        chop(name);
        !          26444: #endif
        !          26445: 
        !          26446:        return name;
        !          26447: }
        !          26448: 0707071010112041141004440001630000160000010112640466055427400001100000007532makefile#ident    "@(#)ctrans:src/makefile        1.3"
        !          26449: ###############################################################################
        !          26450: #                      Copyright (c) 1984 AT&T
        !          26451: #                        All Rights Reserved   
        !          26452: #
        !          26453: #      THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T
        !          26454: #      
        !          26455: #      The copyright notice above does not evidence any        
        !          26456: #      actual or intended publication of such source code.
        !          26457: #
        !          26458: ###############################################################################
        !          26459: CC     =       CC
        !          26460: 
        !          26461: #The ANSI_OUT option has been replaced by the +a1 and +a0 compilation options
        !          26462: 
        !          26463: #for systems which only recognize identifiers of up to 31 characters
        !          26464: #setting DENSE to -DDENSE causes cfront to generate internal names
        !          26465: #of 31 characters or less 
        !          26466: DENSE=
        !          26467: 
        !          26468: # The use of RETBUG is nolonger needed with version 2.0 and has been removed.
        !          26469: # RETBUG was used in 1.* Translator versions to circumvent a C compiler bug.
        !          26470: 
        !          26471: CCFLAGS=-O
        !          26472: 
        !          26473: # top level makefile modifies the following
        !          26474: MPMACRO        = PATCH
        !          26475: MPFILE = patch
        !          26476: 
        !          26477: OFILES =       alloc.o dcl.o dcl2.o dcl3.o dcl4.o del.o \
        !          26478:                discrim.o doprint.o error.o expand.o \
        !          26479:                expr.o expr2.o expr3.o find.o hash.o lalex.o lex.o main.o \
        !          26480:                norm.o norm2.o print.o print2.o print_self.o repr.o simpl.o \
        !          26481:                simpl2.o size.o table.o template.o tree_copy.o tree_dump.o \
        !          26482:                tree_walk.o typ.o typ2.o y.tab.o 
        !          26483: 
        !          26484: cfront:        $(OFILES)
        !          26485:        $(CC)   -o cfront $(CCFLAGS) $(OFILES)
        !          26486: 
        !          26487: $(OFILES):     cfront.h token.h typedef.h
        !          26488: 
        !          26489: y.tab.c:       gram.y 
        !          26490:        yacc gram.y
        !          26491: 
        !          26492: alloc.o:       alloc.c
        !          26493:        $(CC) $(CCFLAGS) -c alloc.c 
        !          26494: 
        !          26495: dcl.o: dcl.c size.h
        !          26496:        $(CC) $(CCFLAGS) -c dcl.c 
        !          26497: 
        !          26498: dcl2.o:        dcl2.c size.h
        !          26499:        $(CC) $(CCFLAGS) -c dcl2.c 
        !          26500: 
        !          26501: dcl3.o:        dcl3.c size.h
        !          26502:        $(CC) $(CCFLAGS) -c dcl3.c 
        !          26503: 
        !          26504: dcl4.o:        dcl4.c size.h
        !          26505:        $(CC) $(CCFLAGS) -c dcl4.c 
        !          26506: 
        !          26507: del.o: del.c
        !          26508:        $(CC) $(CCFLAGS) -c del.c 
        !          26509: 
        !          26510: discrim.o:     discrim.c cfront.h
        !          26511:        $(CC) $(CCFLAGS) -c discrim.c
        !          26512: 
        !          26513: doprint.o:     doprint.c
        !          26514:        $(CC) $(CCFLAGS) -c doprint.c
        !          26515: 
        !          26516: error.o:       error.c size.h
        !          26517:        $(CC) $(CCFLAGS) -c error.c 
        !          26518: 
        !          26519: expand.o:      expand.c
        !          26520:        $(CC) $(CCFLAGS) -c expand.c 
        !          26521: 
        !          26522: expr.o:        expr.c size.h
        !          26523:        $(CC) $(CCFLAGS) -c expr.c 
        !          26524: 
        !          26525: expr2.o:       expr2.c size.h
        !          26526:        $(CC) $(CCFLAGS) -c expr2.c 
        !          26527: 
        !          26528: expr3.o:       expr3.c size.h
        !          26529:        $(CC) $(CCFLAGS) -c expr3.c 
        !          26530: 
        !          26531: find.o:        find.c 
        !          26532:        $(CC) $(CCFLAGS) -c find.c 
        !          26533: 
        !          26534: hash.o: hash.c hash.h
        !          26535:        $(CC) $(CCFLAGS) -c hash.c 
        !          26536: 
        !          26537: lalex.o:lalex.c yystype.h tqueue.h 
        !          26538:        $(CC) $(CCFLAGS) -c lalex.c
        !          26539: 
        !          26540: lex.o: lex.c size.h tqueue.h yystype.h
        !          26541:        $(CC) $(CCFLAGS) -c lex.c 
        !          26542: 
        !          26543: # main depends on this makefile to force recompilation
        !          26544: # when going from patch to munch
        !          26545: main.o:        main.c makefile
        !          26546:        $(CC) -D$(MPMACRO) $(DENSE) $(CCFLAGS) -c main.c 
        !          26547: 
        !          26548: norm.o:        norm.c size.h
        !          26549:        $(CC) $(CCFLAGS) -c norm.c 
        !          26550: 
        !          26551: norm2.o:       norm2.c size.h
        !          26552:        $(CC) $(CCFLAGS) -c norm2.c 
        !          26553: 
        !          26554: print.o:       print.c
        !          26555:        $(CC) $(CCFLAGS) -c print.c 
        !          26556: 
        !          26557: print2.o:      print2.c
        !          26558:        $(CC) $(DENSE) $(CCFLAGS) -c print2.c 
        !          26559: 
        !          26560: print_self.o:   print_self.c
        !          26561:        $(CC) $(CCFLAGS) -c print_self.c 
        !          26562: 
        !          26563: repr.o:        repr.c
        !          26564:        $(CC) $(CCFLAGS) -c repr.c 
        !          26565: 
        !          26566: simpl.o:       simpl.c size.h
        !          26567:        $(CC) $(CCFLAGS) -c simpl.c 
        !          26568: 
        !          26569: simpl2.o:      simpl2.c size.h
        !          26570:        $(CC) $(CCFLAGS) -c simpl2.c 
        !          26571: 
        !          26572: size.o:        size.c size.h
        !          26573:        $(CC) $(CCFLAGS) -c size.c 
        !          26574: 
        !          26575: table.o:       table.c
        !          26576:        $(CC) $(CCFLAGS) -c table.c 
        !          26577: 
        !          26578: template.o: template.c
        !          26579:        $(CC) $(CCFLAGS) -c template.c 
        !          26580: 
        !          26581: tree_copy.o: tree_copy.c
        !          26582:        $(CC) $(CCFLAGS) -c tree_copy.c 
        !          26583: 
        !          26584: tree_dump.o:    tree_dump.c cfront.h
        !          26585:        $(CC) $(CCFLAGS) -c tree_dump.c
        !          26586: 
        !          26587: tree_walk.o: tree_walk.c
        !          26588:        $(CC) $(CCFLAGS) -c tree_walk.c 
        !          26589: 
        !          26590: typ.o: typ.c size.h
        !          26591:        $(CC) $(CCFLAGS) -c typ.c 
        !          26592: 
        !          26593: typ2.o:        typ2.c size.h
        !          26594:        $(CC) $(CCFLAGS) -c typ2.c 
        !          26595: 
        !          26596: y.tab.o:       y.tab.c size.h 
        !          26597:        $(CC) -DGRAM $(CCFLAGS) -c y.tab.c 
        !          26598: 
        !          26599: cpio:  
        !          26600:        ls alloc.c dcl.c dcl2.c dcl3.c dcl4.c del.c discrim.c doprint.c \
        !          26601:                error.c expand.c expr.c expr2.c expr3.c find.c hash.c \
        !          26602:                lalex.c lex.c main.c norm.c norm2.c print.c print2.c \
        !          26603:                print_self.c repr.c simpl.c simpl2.c size.c table.c \
        !          26604:                template.c tree_copy.c tree_dump.c tree_walk.c typ.c typ2.c \
        !          26605:                gram.y \
        !          26606:                cfront.h token.h size.h tqueue.h typedef.h yystype.h \
        !          26607:                hash.h ios_printf.h node_classes.h print_self.h \
        !          26608:                template.h token_names.h tree_copy.h tree_dump.h tree_walk.h \
        !          26609:                makefile | cpio -oc > cfront.cpio
        !          26610: 
        !          26611: 0707071010112046101004440001630000160000010212500466055421000001700000012215node_classes.h/* ident "@(#)ctrans:src/node_classes.h     1.2" */
        !          26612: /* 
        !          26613:  * node_classes.h 
        !          26614:  */
        !          26615: 
        !          26616: #ifndef _node_classes
        !          26617: #define _node_classes
        !          26618: 
        !          26619: enum discriminator_error {
        !          26620:     discrim_none_valid = 0,
        !          26621:     discrim_bad_index = -1,
        !          26622:     discrim_inconsistent_node = -2,
        !          26623: };
        !          26624: 
        !          26625: enum node_class {
        !          26626:     nc_unused = 0,
        !          26627:     nc_eof = 1,
        !          26628:     nc_virt = 2,
        !          26629:     nc_nlist = 3,
        !          26630:     nc_gen = 4,
        !          26631:     nc_vec = 5,
        !          26632:     nc_ptr = 6,
        !          26633:     nc_fct = 7,
        !          26634:     nc_table = 8,
        !          26635:     nc_basetype = 9,
        !          26636:     nc_name = 10,
        !          26637:     nc_expr = 11,
        !          26638:     nc_stmt = 12,
        !          26639:     nc_enumdef = 13,
        !          26640:     nc_classdef = 14,
        !          26641:     nc_baseclass = 15,
        !          26642:     nc_iline = 16,
        !          26643:     nc_ia = 17,
        !          26644: };
        !          26645:     
        !          26646: /* 
        !          26647:        searching this is slower than a directly indexed array,
        !          26648:        but this is more maintainable. We can speed it up later. 
        !          26649: */
        !          26650: 
        !          26651: #ifdef DEFINE_TOKEN_CLASS_TABLE
        !          26652: struct token_class {
        !          26653:     TOK token;
        !          26654:     node_class nclass;
        !          26655: } token_classes[] = {
        !          26656:     { EOFTOK, nc_eof },
        !          26657:     { ASM, nc_stmt },
        !          26658:     { AUTO, nc_basetype },
        !          26659:     { BREAK, nc_stmt },
        !          26660:     { CASE, nc_stmt },
        !          26661:     { CHAR, nc_basetype },
        !          26662:     { CLASS, nc_classdef },
        !          26663:     { CONTINUE, nc_stmt },
        !          26664:     { DEFAULT, nc_stmt },
        !          26665:     { DELETE, nc_expr },
        !          26666:     { DO, nc_stmt },
        !          26667:     { DOUBLE, nc_basetype },
        !          26668:     { ELSE, nc_stmt },
        !          26669:     { ENUM, nc_enumdef },
        !          26670:     { EXTERN, nc_basetype },
        !          26671:     { FLOAT, nc_basetype },
        !          26672:     { FOR, nc_stmt },
        !          26673:     { FORTRAN, nc_unused },
        !          26674:     { FRIEND, nc_basetype },
        !          26675:     { GOTO, nc_stmt },
        !          26676:     { IF, nc_stmt },
        !          26677:     { INT, nc_basetype },
        !          26678:     { LONG, nc_basetype },
        !          26679:     { NEW, nc_expr },
        !          26680:     { OPERATOR, nc_fct },
        !          26681:     { RETURN, nc_stmt },
        !          26682:     { PUBLIC, nc_name },
        !          26683:     { CONST, nc_basetype },
        !          26684:     { REGISTER, nc_basetype },
        !          26685:     { RETURN, nc_stmt },
        !          26686:     { SHORT, nc_basetype },
        !          26687:     { SIZEOF, nc_expr },
        !          26688:     { STATIC, nc_basetype },
        !          26689:     { STRUCT, nc_unused },
        !          26690:     { SWITCH, nc_stmt },
        !          26691:     { THIS, nc_expr },
        !          26692:     { TYPEDEF, nc_basetype },
        !          26693:     { UNION, nc_unused },
        !          26694:     { UNSIGNED, nc_basetype },
        !          26695:     { VOID, nc_basetype },
        !          26696:     { WHILE, nc_stmt },
        !          26697:     { LP, nc_unused },
        !          26698:     { RP, nc_unused },
        !          26699:     { LB, nc_unused },
        !          26700:     { RB, nc_unused },
        !          26701:     { REF, nc_expr },
        !          26702:     { DOT, nc_expr },
        !          26703:     { NOT, nc_expr },
        !          26704:     { COMPL, nc_expr },
        !          26705:     { INCR, nc_expr },
        !          26706:     { DECR, nc_expr },
        !          26707:     { MUL, nc_expr },
        !          26708:     { DIV, nc_expr },
        !          26709:     { AND, nc_expr },
        !          26710:     { MOD, nc_expr },
        !          26711:     { PLUS, nc_expr },
        !          26712:     { MINUS, nc_expr },
        !          26713:     { LS, nc_expr },
        !          26714:     { RS, nc_expr },
        !          26715:     { LT, nc_expr },
        !          26716:     { LE, nc_expr },
        !          26717:     { GT, nc_expr },
        !          26718:     { GE, nc_expr },
        !          26719:     { EQ, nc_expr },
        !          26720:     { NE, nc_expr },
        !          26721:     { ER, nc_expr },
        !          26722:     { OR, nc_expr },
        !          26723:     { ANDAND, nc_expr },
        !          26724:     { OROR, nc_expr },
        !          26725:     { QUEST, nc_expr },
        !          26726:     { COLON, nc_unused },
        !          26727:     { ASSIGN, nc_expr },
        !          26728:     { CM, nc_expr },
        !          26729:     { SM, nc_stmt },
        !          26730:     { SM_PARAM, nc_stmt },
        !          26731:     { LC, nc_unused },
        !          26732:     { RC, nc_unused },
        !          26733:     { INLINE, nc_fct },
        !          26734:     { OVERLOAD, nc_gen },
        !          26735:     { VIRTUAL, nc_fct },       /* but might be a basecl */
        !          26736:     { COERCE, nc_unused },
        !          26737:     { PROTECTED, nc_name },
        !          26738:     { ID, nc_unused },
        !          26739:     { STRING, nc_expr },
        !          26740:     { ICON, nc_expr },
        !          26741:     { FCON, nc_expr },
        !          26742:     { CCON, nc_expr },
        !          26743:     { NAME, nc_name },         /* but might be basecl */
        !          26744:     { ZERO, nc_expr },
        !          26745:     { ASOP, nc_expr },
        !          26746:     { RELOP, nc_expr },
        !          26747:     { EQUOP, nc_expr },
        !          26748:     { DIVOP, nc_expr },
        !          26749:     { SHIFTOP, nc_expr },
        !          26750:     { ICOP, nc_expr },
        !          26751:     { UNOP, nc_expr },
        !          26752:     { TYPE, nc_basetype },
        !          26753:     { UMINUS, nc_expr },
        !          26754:     { FCT, nc_fct },
        !          26755:     { CALL, nc_expr },
        !          26756:     { VEC, nc_vec },
        !          26757:     { DEREF, nc_expr },
        !          26758:     { ADDROF, nc_expr },
        !          26759:     { CAST, nc_expr },
        !          26760:     { FIELD, nc_basetype },
        !          26761:     { LABEL, nc_stmt },
        !          26762:     { BLOCK, nc_stmt },
        !          26763:     { DCL, nc_stmt },
        !          26764:     { COBJ, nc_basetype },
        !          26765:     { EOBJ, nc_basetype },
        !          26766:     { TNAME, nc_name },
        !          26767:     { ILIST, nc_expr },
        !          26768:     { PTR, nc_ptr },
        !          26769:     { ASPLUS, nc_expr },
        !          26770:     { ASMINUS, nc_expr },
        !          26771:     { ASMUL, nc_expr },
        !          26772:     { ASDIV, nc_expr },
        !          26773:     { ASMOD, nc_expr },
        !          26774:     { ASAND, nc_expr },
        !          26775:     { ASOR, nc_expr },
        !          26776:     { ASER, nc_expr },
        !          26777:     { ASLS, nc_expr },
        !          26778:     { ASRS, nc_expr },    
        !          26779:     { ARG, nc_basetype },
        !          26780:     { ZTYPE, nc_basetype },
        !          26781:     { ARGT, nc_basetype },
        !          26782:     { ELIST, nc_expr },
        !          26783:     { ANY, nc_basetype },
        !          26784:     { TABLE, nc_table },
        !          26785:     { LOC, nc_unused },
        !          26786:     { DUMMY, nc_expr },
        !          26787:     { G_ADDROF, nc_expr },
        !          26788:     { G_CALL, nc_expr },
        !          26789:     { G_CM, nc_expr },
        !          26790:     { IVAL, nc_expr },
        !          26791:     { ELLIPSIS, nc_unused },
        !          26792:     { AGGR, nc_unused },
        !          26793:     { RPTR, nc_ptr },
        !          26794:     { HIDDEN, nc_unused },
        !          26795:     { MEM, nc_expr },
        !          26796:     { CTOR, nc_unused },
        !          26797:     { DTOR, nc_unused },
        !          26798:     { CONST_PTR, nc_ptr },
        !          26799:     { CONST_RPTR, nc_ptr },
        !          26800:     { TEXT, nc_expr },
        !          26801:     { PAIR, nc_stmt },
        !          26802:     { ANON, nc_unused },
        !          26803:     { ICALL, nc_expr },
        !          26804:     { ANAME, nc_expr },
        !          26805:     { VOLATILE, nc_basetype },
        !          26806:     { SIGNED, nc_basetype },
        !          26807:     { UPLUS, nc_expr },
        !          26808:     { MEMPTR, nc_unused },
        !          26809:     { PRIVATE, nc_name },
        !          26810:     { PR, nc_unused },
        !          26811:     { MDOT, nc_expr },
        !          26812:     { TSCOPE, nc_unused },
        !          26813:     { DECL_MARKER, nc_unused },
        !          26814:     { REFMUL, nc_expr },
        !          26815:     { LDOUBLE, nc_basetype },
        !          26816:     { LINKAGE, nc_unused },
        !          26817:     { LOCAL, nc_basetype },
        !          26818:     { GNEW, nc_expr },
        !          26819:     { TEMPLATE, nc_unused },
        !          26820:     { STAT_INIT, nc_unused },
        !          26821:     { CATCH, nc_unused },
        !          26822:     { GDELETE, nc_expr },
        !          26823:     { XVIRT, nc_virt },
        !          26824:     { XNLIST, nc_nlist },
        !          26825:     { XILINE, nc_iline },
        !          26826:     { XIA, nc_ia },
        !          26827:     { VALUE, nc_expr },
        !          26828:     { XDELETED_NODE, nc_unused },
        !          26829: };
        !          26830: #endif
        !          26831: 
        !          26832: node_class classify_node (Pnode, int&);
        !          26833: node_class classify_node (Pnode);
        !          26834: 
        !          26835: #endif
        !          26836: 0707071010112044361004440001630000160000010204500466055405300000700000120447norm.c/*ident     "@(#)ctrans:src/norm.c  1.10" */
        !          26837: /************************************************************************
        !          26838: 
        !          26839:        C++ source for cfront, the C++ compiler front-end
        !          26840:        written in the computer science research center of Bell Labs
        !          26841: 
        !          26842:        Copyright (c) 1984 AT&T, Inc. All Rights Reserved
        !          26843:        THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T, INC.
        !          26844: 
        !          26845: norm.c:
        !          26846: 
        !          26847:        "normalization" handles problems which could have been handled
        !          26848:        by the syntax analyser; but has not been done. The idea is
        !          26849:        to simplify the grammar and the actions accociated with it,
        !          26850:        and to get a more robust error handling
        !          26851: 
        !          26852: ****************************************************************************/
        !          26853: #ifdef c_plusplus
        !          26854: overload nested_hide;
        !          26855: #endif
        !          26856: 
        !          26857: #include "cfront.h"
        !          26858: #include "size.h"
        !          26859: #include "template.h"
        !          26860: 
        !          26861: extern Pname do_nested_type(Pname);
        !          26862: extern int is_anon(char*);
        !          26863: 
        !          26864: Pname sta_name = 0;
        !          26865: 
        !          26866: void syn_init()
        !          26867: {
        !          26868:        any_type = new basetype(ANY,0);
        !          26869:        PERM(any_type); any_type->defined = DEFINED;
        !          26870:        dummy = new expr(DUMMY,0,0);
        !          26871:        PERM(dummy);
        !          26872:        dummy->tp = any_type;
        !          26873:        zero = new expr(ZERO,0,0);
        !          26874:        PERM(zero);
        !          26875:        sta_name = new name;
        !          26876:        PERM(sta_name);
        !          26877: //     Gtbl = new table(GTBLSIZE,0,0); //SYM
        !          26878: //     Ctbl = Gtbl; //SYM
        !          26879: }
        !          26880: 
        !          26881: int stcount;
        !          26882: 
        !          26883: char* make_name(TOK c)
        !          26884: {
        !          26885:        char* s = new char[8];  // as it happens: fits in two words
        !          26886: 
        !          26887:        if (10000 <= ++stcount) error('i',"too many generatedNs");
        !          26888: 
        !          26889:        sprintf(s,"__%c%d",c,stcount);
        !          26890:        return s;
        !          26891: }
        !          26892: 
        !          26893: Pbase basetype::type_adj(TOK t)
        !          26894: {
        !          26895: DB(if(Ndebug>=1)error('d',"'%k'->type_adj(%k) --%t b_xname%n",base,t,this,b_xname););
        !          26896:        if (b_xname) {
        !          26897:                if (base)
        !          26898:                        error("badBT:%n%k",b_xname,t);
        !          26899:                else {
        !          26900:                        base = TYPE;
        !          26901:                        b_name = b_xname;
        !          26902:                }
        !          26903:                b_xname = 0;
        !          26904:        }
        !          26905: 
        !          26906:        switch (t) {
        !          26907:        case TYPEDEF:   b_typedef = 1;  break;
        !          26908:        case INLINE:    b_inline = 1;   break;
        !          26909:        case VIRTUAL:   b_virtual = 1;  break;
        !          26910:        case CONST:     if (b_const) error('w',"two const declarators");
        !          26911:                        b_const = 1;    break;
        !          26912:        case UNSIGNED:  b_unsigned = 1; break;
        !          26913:        case SHORT:     b_short = 1;    break;
        !          26914:        case LONG:      if (b_long) error('w',"two long declarators");
        !          26915:                        if (base == DOUBLE)
        !          26916:                                base = LDOUBLE;
        !          26917:                        else
        !          26918:                                b_long = 1;
        !          26919:                        break;
        !          26920:        case FRIEND:
        !          26921:        case OVERLOAD:
        !          26922:        case EXTERN:
        !          26923:        case STATIC:
        !          26924:        case AUTO:
        !          26925:        case REGISTER:
        !          26926:                if (b_sto)
        !          26927:                        error("badBT:%k%k",b_sto,t);
        !          26928:                else
        !          26929:                        b_sto = t;
        !          26930:                break;
        !          26931:        case DOUBLE:
        !          26932:                if (b_long) {
        !          26933:                        t = LDOUBLE;
        !          26934:                        b_long = 0;
        !          26935:                }
        !          26936:                // no break
        !          26937:        case VOID:
        !          26938:        case CHAR:
        !          26939:        case INT:
        !          26940:        case FLOAT:
        !          26941:                if (base)
        !          26942:                        error("badBT:%k%k",base,t);
        !          26943:                else
        !          26944:                        base = t; 
        !          26945:                break;
        !          26946:        case SIGNED:
        !          26947:        case VOLATILE:
        !          26948:                error('w',"\"%k\" not implemented (ignored)",t);
        !          26949:                break;
        !          26950:        default:
        !          26951:                error('i',"BT::type_adj(%k)",t);
        !          26952:        }
        !          26953:        return this;
        !          26954: }
        !          26955: 
        !          26956: Pbase basetype::name_adj(Pname n)
        !          26957: {
        !          26958: DB(if(Ndebug>=1)error('d',"'%k'->name_adj(%n) --%t b_xname%n",base,n,this,b_xname));
        !          26959:        if (b_xname) {
        !          26960:                if (base)
        !          26961:                        error("badBT:%n%n",b_xname,n);
        !          26962:                else {
        !          26963:                        base = TYPE;
        !          26964:                        b_name = b_xname;
        !          26965:                }
        !          26966:                b_xname = 0;
        !          26967:        }
        !          26968: 
        !          26969:        if ( base==0 
        !          26970:                && n->base == TNAME 
        !          26971:                && ( n->tp->base!=COBJ || in_arg_list )) {
        !          26972:                        base = TYPE;
        !          26973:                        b_name = n;
        !          26974:        }
        !          26975:        else
        !          26976:                b_xname = n;
        !          26977: 
        !          26978:        return this;
        !          26979: }
        !          26980: 
        !          26981: static TOK type_set( Pbase b )
        !          26982: {
        !          26983:        TOK t = 0;
        !          26984: 
        !          26985:        if ( b->b_long ) t = LONG;
        !          26986:        else if ( b->b_short ) t = SHORT;
        !          26987:        else if ( b->b_unsigned ) t = UNSIGNED;
        !          26988:        else if ( b->b_inline ) t = INLINE;
        !          26989:        else if ( b->b_virtual ) t = VIRTUAL;
        !          26990:        else if ( b->b_sto == OVERLOAD ) t = OVERLOAD;
        !          26991:        return t;
        !          26992: }
        !          26993: 
        !          26994: int declTag = 1;
        !          26995: 
        !          26996: Pbase basetype::base_adj(Pbase b)
        !          26997: {
        !          26998: DB(if(Ndebug>=1)error('d',"'%k'->base_adj(%t) --%t b_xname%n",base,b,this,b_xname));
        !          26999:        Pname bn = b->b_name;
        !          27000: 
        !          27001:        switch (base) {
        !          27002:        case COBJ:
        !          27003:        case EOBJ:
        !          27004:                error("NX after%k%n",base,b_name);
        !          27005:                return this;
        !          27006:        }
        !          27007: 
        !          27008:        TOK t;
        !          27009:        if (base) {
        !          27010:                if (b_name)
        !          27011:                        error("badBT:%k%n%k%n",base,b_name,b->base,bn);
        !          27012:                else
        !          27013:                        error("badBT:%k%k%n",base,b->base,bn);
        !          27014:        }
        !          27015:        else if ( t = type_set(this)) {
        !          27016:                if (b_name)
        !          27017:                        error("badBT:%k%n%k%n",t,b_name,b->base,bn);
        !          27018:                else {
        !          27019:                         if ( declTag++ && (t!= INLINE)) error("badBT:%k%k%n",t,b->base,bn);
        !          27020:                        base=b->base; b_name = bn;
        !          27021: // error('d',"base_adj: t: %k", t );
        !          27022:                }
        !          27023:        }
        !          27024:        else {
        !          27025:                base = b->base;
        !          27026:                b_name = bn;
        !          27027:                b_table = b->b_table;
        !          27028:        }
        !          27029: 
        !          27030:        if ( b->base == COBJ ) {
        !          27031:                Pclass cl = Pclass(bn->tp);
        !          27032:                if ( cl->in_class && 
        !          27033:                        bn->tpdef &&
        !          27034:                        bn->tpdef->lex_level == NESTED ) 
        !          27035:                { // peculiar case: class x { typedef class bn {} _bn; ... 
        !          27036:                  // bn has been half dealt with in do_nested_type ...
        !          27037:                        Pname n = new name(bn->string);
        !          27038:                        n->tp = b;
        !          27039:                        Pname nn = ktbl->insert(n, NESTED); //SYM
        !          27040:                        nn->tpdef = bn->tpdef;
        !          27041:                        nn->tpdef->lex_level = nn->lex_level = 0;
        !          27042:                        bn->tpdef = 0;
        !          27043:                }
        !          27044:        }
        !          27045: 
        !          27046:        return this;
        !          27047: }
        !          27048: 
        !          27049: Pbase basetype::check(Pname n)
        !          27050: /*
        !          27051:        "n" is the first name to be declared using "this"
        !          27052:        check the consistency of "this"
        !          27053:        and use "b_xname" for "n->string" if possible and needed
        !          27054: */
        !          27055: {
        !          27056:        b_inline = 0;
        !          27057:        b_virtual = 0;
        !          27058: //error('d',"basetype::check(%n) base %k b_xname %n",n,base,b_xname);
        !          27059: 
        !          27060:        if (b_xname && (n->tp || n->string)) {
        !          27061:                if (base)
        !          27062:                        error("badBT:%k%n",base,b_xname);
        !          27063:                else {
        !          27064:                        base = TYPE;
        !          27065:                        b_name = b_xname;
        !          27066:                }
        !          27067:                b_xname = 0;
        !          27068:        }
        !          27069: 
        !          27070:        if (b_xname) {
        !          27071:                if (n->string)
        !          27072:                        error("twoNs inD:%n%n",b_xname,n);
        !          27073:                else {
        !          27074:                        n->string = b_xname->string;
        !          27075:                        b_xname->hide();
        !          27076:                }
        !          27077:                b_xname = 0;
        !          27078:        }
        !          27079: 
        !          27080:        if (ccl==0
        !          27081:        && n
        !          27082:        && n->n_oper==TNAME
        !          27083:        && n->n_qualifier==0
        !          27084:        && n->string) { // hide type name
        !          27085:                Pname nx = ktbl->look(n->string,0); //SYM
        !          27086:                if (nx) nx->hide();
        !          27087:        }
        !          27088: 
        !          27089:        int defa = 0;
        !          27090:        switch (base) {
        !          27091:        case 0:
        !          27092:                defa = 1;
        !          27093:                base = INT;
        !          27094:                break;
        !          27095:        case EOBJ:
        !          27096:        case COBJ:
        !          27097:                if (b_name->base == TNAME) error('i',"TN%n inCO %p",b_name,this);
        !          27098:        }
        !          27099: 
        !          27100:        if (b_long || b_short) {
        !          27101:                TOK sl = (b_short) ? SHORT : LONG;
        !          27102:                if (b_long && b_short) error("badBT:long short%k%n",base,n);
        !          27103:                if (base != INT)
        !          27104:                        error("badBT:%k%k%n",sl,base,n);
        !          27105:                else
        !          27106:                        base = sl;
        !          27107:                b_short = b_long = 0;
        !          27108:        }
        !          27109: 
        !          27110:        if (b_typedef && b_sto) error("badBT:Tdef%k%n",b_sto,n);
        !          27111:        b_typedef = b_sto = 0; 
        !          27112: 
        !          27113:        if (b_linkage) {
        !          27114:                if (1 <= bl_level) error("local linkage directive");
        !          27115:        }
        !          27116: 
        !          27117:        if (Pfctvec_type == 0) return this;
        !          27118: 
        !          27119:        if (b_const) {
        !          27120:                if (b_unsigned) {
        !          27121:                        switch (base) {
        !          27122:                        default:
        !          27123:                                error("badBT: unsigned const %k%n",base,n);
        !          27124:                                b_unsigned = 0;
        !          27125:                        case LONG:
        !          27126:                        case SHORT:
        !          27127:                        case INT:
        !          27128:                        case CHAR:
        !          27129:                                return this;
        !          27130:                        }
        !          27131:                }
        !          27132:                return this;
        !          27133:        }
        !          27134:        else if (b_unsigned) {
        !          27135:                switch (base) {
        !          27136:                case LONG:
        !          27137:                        delete this;
        !          27138:                        return ulong_type;
        !          27139:                case SHORT:
        !          27140:                        delete this;
        !          27141:                        return ushort_type;
        !          27142:                case INT:
        !          27143:                        delete this;
        !          27144:                        return uint_type;
        !          27145:                case CHAR:
        !          27146:                        delete this;
        !          27147:                        return uchar_type;
        !          27148:                default:
        !          27149:                        error("badBT: unsigned%k%n",base,n);
        !          27150:                        b_unsigned = 0;
        !          27151:                        return this;
        !          27152:                }
        !          27153:        }
        !          27154:        else {
        !          27155:                switch (base) {
        !          27156:                case LONG:
        !          27157:                        delete this;
        !          27158:                        return long_type;
        !          27159:                case SHORT:
        !          27160:                        delete this;
        !          27161:                        return short_type;
        !          27162:                case INT:
        !          27163:                         if (this==int_type || this==defa_type) return this;
        !          27164:                 //      if (this != int_type)
        !          27165:                                 delete this;
        !          27166:                         if (defa) return defa_type;
        !          27167:                         return int_type;
        !          27168:                case CHAR:
        !          27169:                        delete this;
        !          27170:                        return char_type;
        !          27171:                case VOID:
        !          27172:                        delete this;
        !          27173:                        return void_type;
        !          27174:                case TYPE:
        !          27175:                        /* use a single base saved in the keyword */
        !          27176:                        if (b_name->n_qualifier) {
        !          27177:                                Pbase rv = Pbase(b_name->n_qualifier);
        !          27178:                                delete this;
        !          27179:                                return rv;
        !          27180:                        }
        !          27181:                        else {
        !          27182:                                PERM(this);
        !          27183:                                b_name->n_qualifier = (Pname)this;
        !          27184:                                return this;
        !          27185:                        }
        !          27186:                default:
        !          27187:                        return this;
        !          27188:                }
        !          27189:        }
        !          27190: }
        !          27191: 
        !          27192: Pname basetype::aggr()
        !          27193: /*
        !          27194:        "type SM" seen e.g.     struct s {};
        !          27195:                                class x;
        !          27196:                                enum e;
        !          27197:                                int tname;
        !          27198:                                friend cname;
        !          27199:                                friend class x;
        !          27200:                                int;
        !          27201:                                
        !          27202:                                typedef int i; // where i is tname
        !          27203: 
        !          27204:        convert
        !          27205:                union { ... };
        !          27206:        into
        !          27207:                union name { ... } name ;
        !          27208: */
        !          27209: {
        !          27210: DB(if(Ndebug>=1)error('d',"'%k'->aggr() --%t b_xname%n ccl%t",base,this,b_xname,ccl));
        !          27211:        if (b_xname) {
        !          27212:                if (base) {
        !          27213:                        Pname n = new name(b_xname->string);
        !          27214:                /*SYM?*/if (ccl && b_xname->tpdef)
        !          27215:                /*SYM?*/        n->tpdef = b_xname->tpdef;
        !          27216:                         b_xname->hide();
        !          27217:                         b_xname = 0;
        !          27218:                        return n->normalize(this,0,0);
        !          27219:                }
        !          27220:                else {
        !          27221:                        base = TYPE;
        !          27222:                        b_name = b_xname;
        !          27223:                        b_xname = 0;
        !          27224:                }
        !          27225:        }
        !          27226: 
        !          27227:        switch (base) {
        !          27228:        case COBJ:
        !          27229:        {       Pclass cl = Pclass(b_name->tp);
        !          27230:                char* s = cl->string;
        !          27231:        /*SYM?*/if (b_name->base == TNAME) error('i',"TN%n inCO",b_name);
        !          27232:                if (b_const) error("const%k%n",cl->csu,b_name);
        !          27233: 
        !          27234:                if (cl->c_body == 2) {  /* body seen */
        !          27235:                        if (s[0]=='_' && s[1]=='_' && s[2]=='C') {
        !          27236:                                char* ss = new char[8]; // max size of generated name is 7 chars, see make_name()
        !          27237:                                Pname obj = new name(ss);
        !          27238:                                strcpy(ss,s);
        !          27239:                                if (cl->csu == UNION) {
        !          27240:                                        ss[2] = 'O';
        !          27241:                                        cl->csu = ANON;
        !          27242:                                        return obj->normalize(this,0,0);
        !          27243:                                }
        !          27244:                                error('w',"unusable%k ignored",cl->csu);
        !          27245:                        }
        !          27246:                        if ( b_sto == FRIEND )
        !          27247:                                error("friend%k%n{...}",cl->csu,b_name);
        !          27248:                        cl->c_body = 1;
        !          27249:                        return b_name;
        !          27250:                }
        !          27251:                else {  /* really a typedef for cfront only: class x; */
        !          27252:                        if (b_sto == FRIEND) goto frr;
        !          27253:                        if (ansi_opt) printf("struct %s;\n",s);
        !          27254:                        return 0;
        !          27255:                }
        !          27256:        }
        !          27257: 
        !          27258:        case EOBJ:
        !          27259:        {       Penum en = Penum(b_name->tp);
        !          27260:        /*SYM?*/if (b_name->base == TNAME) error('i',"TN%n in enumO",b_name);
        !          27261:                if (b_const) error("const enum%n",b_name);
        !          27262:                if (en->e_body == 2) {
        !          27263:                        en->e_body = 1;
        !          27264:                        return b_name;
        !          27265:                }
        !          27266:                else {
        !          27267:                        error("forwardD of enum%n", b_name);
        !          27268:                        en->e_type = int_type;
        !          27269:                }
        !          27270:                return 0;
        !          27271:        }
        !          27272: 
        !          27273:        case 0:
        !          27274:        {       Pname n = new name(make_name('D'));
        !          27275:                n->tp = defa_type;
        !          27276:                error("NX inDL");
        !          27277:                return n;
        !          27278:        }       
        !          27279:        default:
        !          27280:                if (b_typedef) error('w',"illegalTdef ignored");
        !          27281: 
        !          27282:                if (b_sto == FRIEND && b_name ) {
        !          27283:                frr:
        !          27284:                        Pname fr = ktbl->look(b_name->string,0); //SYM
        !          27285:                        if (fr == 0) error('i',"cannot find friend%n",b_name);
        !          27286:                        Pname n = new name(b_name->string);
        !          27287:                        n->n_sto = FRIEND;
        !          27288:                        // If it is a parameterized type, use the instantiation 
        !          27289:                        // type, not the general type.
        !          27290:                        if ((fr->tp->base == COBJ) && 
        !          27291:                            (Pclass(Pbase(fr->tp)->b_name->tp)->class_base ==
        !          27292:                                template_class))
        !          27293:                        {
        !          27294:                            if (base == COBJ) 
        !          27295:                                n->tp = this;
        !          27296:                            else 
        !          27297:                            if ((base == TYPE) &&
        !          27298:                                (Pbase(this)->b_name->base == TNAME) &&
        !          27299:                                (Pbase(this)->b_name->tp->base == COBJ))
        !          27300:                                        n->tp = Pbase(this)->b_name->tp;
        !          27301:                            else 
        !          27302:                                error('i', "basetype wasn't a COBJ");
        !          27303:                        }
        !          27304:                        else n->tp = fr->tp;
        !          27305:                        return n;
        !          27306:                }
        !          27307:                else {
        !          27308:                        Pname n = new name(make_name('D'));
        !          27309:                        n->tp = defa_type;
        !          27310:                        error('w',"NX inDL");
        !          27311:                        return n;
        !          27312:                }
        !          27313:        }
        !          27314: }
        !          27315: 
        !          27316: void local_name() //SYM -- to be removed
        !          27317: { /* need to provide an additional temporary name
        !          27318:    * to handle case of
        !          27319:    * f() {
        !          27320:    *    { class x{...}; }
        !          27321:    *    { class x{...}; }
        !          27322:    * }
        !          27323:    * generate name after closing } of block
        !          27324:    * to distinquish between separate blocks at same lexical level 
        !          27325:    */
        !          27326:        for (Plist l=local_blk; l; l=l->l) {
        !          27327:                Pname n = l->f;
        !          27328:                if ( n->tp == 0 ) error( 'i', "no tp yet: #0 local_name" );
        !          27329:                if ( Pbase(n->tp)->b_name == 0 ) error( 'i', "no tp yet: #1 local_name" );
        !          27330:                Pname bn = Pbase(n->tp)->b_name;
        !          27331:                if ( bn->tp == 0 ) error( 'i', "no tp yet#2: local_name" );
        !          27332:                Pclass cl = Pclass(bn->tp);
        !          27333:                 cl->lcl = make_name( 'L' );
        !          27334: // error( 'd', "local_name(): %n bn: %n: cl : %s nof: %d", n, bn, cl->string, cc->nof );
        !          27335:         }
        !          27336: }
        !          27337: 
        !          27338: void local_restore() //SYM -- to be removed
        !          27339: {
        !          27340:        for (Plist l=local_tn; l; l=l->l) {
        !          27341:                Pname n = l->f;
        !          27342: // error('d',"local_restore: n %n %t %d bl_level: %d", n, n->tp, n->lex_level, bl_level );
        !          27343:                n->n_key = (n->lex_level==0) ? 0 
        !          27344:                        : (n->lex_level && n->lex_level<=bl_level) ? LOCAL : HIDDEN;
        !          27345:        }
        !          27346: }
        !          27347: 
        !          27348: void local_hide( Pname n ) //SYM -- to be removed
        !          27349: {
        !          27350: // error('d',"local_hide(%n )",n);
        !          27351: 
        !          27352:    if ( n->base != TNAME ) return; 
        !          27353:    if ( n->n_key == 0 ) {
        !          27354:         local_tn = new name_list( n, local_tn );
        !          27355:         n->n_key = HIDDEN;
        !          27356: // error( 'd', "local_hide(): %n n_key: %d", n, n->n_key );
        !          27357:    }
        !          27358: }
        !          27359: 
        !          27360: void 
        !          27361: nested_restore() //SYM -- to be removed
        !          27362: {
        !          27363:        for (Plist l = nested_type; l; l=l->l)
        !          27364:        {
        !          27365:                Pname n = l->f;
        !          27366:                n->n_key = NESTED;
        !          27367:        }
        !          27368:                
        !          27369:        for (l=nested_tn; l; l=l->l) {
        !          27370:                Pname n = l->f;
        !          27371:                Ptype tp = n->tp;
        !          27372: // error('d',"nested_restore: n %n %t %d bl_level: %d", n, n->tp, n->lex_level, bl_level );
        !          27373: // error('d'," --- n_key %k", n->n_key );
        !          27374: 
        !          27375:                if ( tp->in_class ) 
        !          27376:                        n->n_key = NESTED;
        !          27377:                else
        !          27378:                if ( tp->lex_level )
        !          27379:                        n->n_key = LOCAL;
        !          27380:                else 
        !          27381:                        n->n_key = 0;
        !          27382: // error('d'," --- n_key %k", n->n_key );
        !          27383:        }
        !          27384: }
        !          27385: 
        !          27386: void 
        !          27387: nested_hide( Pname n ) //SYM -- to be removed
        !          27388: {
        !          27389: // error('d',"nested_hide(%n )",n);
        !          27390: 
        !          27391:    if ( n->base != TNAME ) return; 
        !          27392:    if ( n->n_key == 0 ) {
        !          27393:         nested_tn = new name_list( n, nested_tn );
        !          27394:         n->n_key = HIDDEN;
        !          27395: // error( 'd', "nested_hide(): %n n_key: %d", n, n->n_key );
        !          27396:    }
        !          27397: }
        !          27398: 
        !          27399: static void 
        !          27400: nested_hide( Plist l ) //SYM -- to be removed
        !          27401: {
        !          27402: // error('d',"nested_hide( list )");
        !          27403: 
        !          27404:        for (; l; l=l->l) {
        !          27405:                Pname nn = l->f;
        !          27406:                Pname n = ktbl->look(nn->string,0);
        !          27407: // error('d',"nested_hide %n %t", n, n->tp, n->n_key);
        !          27408:                if (n==0) continue;
        !          27409: 
        !          27410:                if ( n->base != TNAME ) 
        !          27411:                        error('i', "nested_hide: %n not a type name (%t)", n, n->tp );
        !          27412:                if ( n->n_key == 0 ) {
        !          27413:                        nested_tn = new name_list( n, nested_tn );
        !          27414:                        n->n_key = HIDDEN;
        !          27415: // error( 'd', "nested_hide(list): %n n_key: %d", n, n->n_key );
        !          27416: //             nn->n_key = 0;
        !          27417:                }
        !          27418:        }
        !          27419: }
        !          27420: 
        !          27421: int defer_check = 0;
        !          27422: Pname statStat = 0;
        !          27423: 
        !          27424: void name::hide()
        !          27425: /*
        !          27426:        hide "this": that is, "this" should not be a keyword in this scope
        !          27427: */
        !          27428: {
        !          27429:        if (base != TNAME) return;
        !          27430: // error('d',"'%n '->hide() -- %t lex_level %d bl_level %d",this,tp,lex_level,::bl_level);
        !          27431:        if (n_key == 0) {
        !          27432:                 if (lex_level == bl_level && in_arg_list == 0) {
        !          27433:                        if (tp->base != COBJ) { 
        !          27434:                                if ( !in_typedef ) 
        !          27435:                                     error("%n redefined: typedef and identifier", this);
        !          27436:                                else if ( in_typedef->base 
        !          27437:                                                && tp->base != type_set(Pbase(in_typedef)) 
        !          27438:                                                && in_typedef->check(tp,0) ) {
        !          27439:                                                        if ( defer_check == 0 )
        !          27440:                                                                error("%n redefined: previous: %t now: %t", this, tp, in_typedef);
        !          27441:                                } 
        !          27442:                        } 
        !          27443:                        else {
        !          27444: //error('d',"in_typedef%t %d tp%t %d",in_typedef,in_typedef,tp,tp);
        !          27445: //error('d',"in_typedef%k tp%k",in_typedef->base,tp->base);
        !          27446:                                if ( in_typedef && in_typedef->base
        !          27447:                                &&   in_typedef->check(tp, 0) ) {
        !          27448:                                        if ( defer_check == 0 )
        !          27449:                                                error( "%n redefined: previous: %t now: %t", this, tp, in_typedef);
        !          27450:                                }
        !          27451:                                else {
        !          27452:                                        Pname nn = Pbase(tp)->b_name;
        !          27453:                                        Pclass cl = Pclass( nn->tp );
        !          27454:                                        // check for 'typedef class X X;'
        !          27455:                                        //       and 'typedef X X;'
        !          27456:                                        if ( in_typedef )
        !          27457:                                            while ( in_typedef->base == TYPE )
        !          27458:                                                in_typedef = Pbase(in_typedef)->b_name->tp;
        !          27459:                                        if ( in_typedef
        !          27460:                                        &&   in_typedef->base==COBJ
        !          27461:                                        &&   Pbase(in_typedef)->b_name->tp==cl )
        !          27462:                                                in_typedef = tp;
        !          27463:                                        else if ( cl->has_ctor() )
        !          27464:                                                error( "%n redefined: both aCNWK and %s", this, in_typedef?"a type name":"an identifier" );
        !          27465:                                }
        !          27466:                        }
        !          27467: 
        !          27468:                 }
        !          27469: // error( 'd', "%n::hide", this );
        !          27470:                modified_tn = new name_list(this,modified_tn);
        !          27471:                n_key = HIDDEN;
        !          27472:        }
        !          27473: }
        !          27474: 
        !          27475: static Pname Ntncheck; // ensure TNAMES hidden within class scopes
        !          27476: static int notReally = 0;
        !          27477: 
        !          27478: void set_scope(Pname tn) //SYM -- to be shrunk
        !          27479: /* enter the scope of class tn after seeing "tn::f" */
        !          27480: {
        !          27481: // error( 'd', "set_scope: %n %t %d", tn, tn->tp, tn->tp->base );
        !          27482: // error( 'd', "set_scope: %d", notReally );
        !          27483: 
        !          27484:        Pbase b = Pbase(tn->tp);
        !          27485:        while ( b->base == TYPE )  b=Pbase(b->b_name->tp);  // typedef class X T
        !          27486:        if (b->base != COBJ) return; // error caught elsewhere
        !          27487: 
        !          27488:        Pclass cl = Pclass(b->b_name->tp);
        !          27489:        char *str = cl->string;
        !          27490: 
        !          27491:        if ( cl->nest_list && notReally == 0 ) { 
        !          27492:                nested_type = cl->nest_list; 
        !          27493:                nested_hide(cl->nest_list); 
        !          27494:        }
        !          27495: 
        !          27496:        Pname ntn = Ntncheck;
        !          27497:        if( notReally == 0 )
        !          27498:            while ( ntn && ntn->tp->base == TYPE ) ntn = Pbase(ntn->tp)->b_name;
        !          27499: 
        !          27500:        if ( notReally || ntn == 0 || strcmp( str,ntn->string )) {
        !          27501:                if ( cl->baselist ) {
        !          27502:                    Pname nb = new name, nbc = new name;
        !          27503:                    nb->tp = new basetype(COBJ,0);
        !          27504:                    Pbase(nb->tp)->b_name = nbc;
        !          27505:                    for (Pbcl bx, bb=cl->baselist;  bb;  bb = bb->next) {
        !          27506:                        bx = bb->next;
        !          27507:                        if ( bb->bclass != 0 ) {
        !          27508:                                nbc->tp = bb->bclass;
        !          27509:                                notReally++; set_scope(nb); notReally--;
        !          27510:                        }
        !          27511:                    }
        !          27512:                    DEL(nbc); /*DEL(nb->tp);*/ DEL(nb);
        !          27513:                }
        !          27514: 
        !          27515:                int i = 1;
        !          27516:                Pname n = 0;
        !          27517:                Plist ll = 0;
        !          27518:                if (b->parametrized_class()) {
        !          27519:                  for (Pname nn = cl->mem_list; nn; nn = nn->n_list)
        !          27520:                    switch (nn->base) {
        !          27521:                    case PUBLIC: case PRIVATE: case PROTECTED:
        !          27522:                        continue;
        !          27523:                    default:
        !          27524:                        if (nn->tp->base == CLASS) continue;
        !          27525:                        if (nn->tp->base == ENUM) continue;
        !          27526:                        if ((nn->base == NAME) &&
        !          27527:                            ((nn->n_oper == TNAME) && (nn->tp->base == FCT)) ||
        !          27528:                            (nn->n_oper == CTOR) ||
        !          27529:                            (nn->n_oper == DTOR)) continue ;
        !          27530:                        n = ktbl->look( nn->string, 0 );
        !          27531:                        if (n) ll = new name_list( n, ll );
        !          27532:                    }
        !          27533:                } // if b->parametrized_class()
        !          27534:                else
        !          27535:                for (Pname nn=cl->memtbl->get_mem(i); nn; nn=cl->memtbl->get_mem(++i) ) {
        !          27536:                        if (nn->base == TNAME || nn->base == PUBLIC) continue;
        !          27537:                        if (nn->tp->base == CLASS) continue;
        !          27538:                        if (nn->tp->base == ENUM) continue;
        !          27539:                        n = ktbl->look( nn->string, 0 );
        !          27540:                        if (n) ll = new name_list( n, ll );
        !          27541:                }
        !          27542: 
        !          27543:                if ( ll ) cl->tn_list = ll;
        !          27544:                if (notReally == 0) Ntncheck = tn; 
        !          27545:        }
        !          27546:        
        !          27547:        for (Plist l=cl->tn_list; l; l=l->l) {
        !          27548:                Pname n = l->f;
        !          27549:                n->n_key = (n->lex_level) ? 0 : HIDDEN;
        !          27550:                modified_tn = new name_list(n,modified_tn);
        !          27551:        }
        !          27552: }
        !          27553: 
        !          27554: void restore() //SYM -- to be removed
        !          27555: {
        !          27556:        for (Plist l=modified_tn; l; l=l->l) {
        !          27557:                Pname n = l->f;
        !          27558: // error('d',"restore: n %n %t %d bl_level: %d", n, n->tp, n->lex_level, bl_level );
        !          27559: //fprintf(stderr," -- n_key %d\n",n->n_key);
        !          27560:                n->n_key = (n->lex_level==0 || (n->lex_level && n->lex_level<=bl_level)) ? 0 : HIDDEN;
        !          27561: //fprintf(stderr," -- n_key %d\n",n->n_key);
        !          27562:                if ( n->lex_level == 0 
        !          27563:                        && (n->tp->base == COBJ || n->tp->base == EOBJ)) {
        !          27564:                        Pname nn = gtbl->look( n->string, 0 );
        !          27565:                        if ( nn ) n->n_key = HIDDEN;
        !          27566:                }
        !          27567: //fprintf(stderr," -- n_key %d\n",n->n_key);
        !          27568:        }
        !          27569: }
        !          27570: 
        !          27571: Pbase start_cl(TOK t, Pname c, Pbcl b)
        !          27572: {
        !          27573:         int mk_local = 0;
        !          27574:        DB(if(Ndebug>=1)error('d',"start_cl(%k,%d,%d)",t,c,b););
        !          27575:        if (c == 0) {
        !          27576:            c = new name(make_name('C'));
        !          27577:            c->lex_level -= in_class_decl + 1;
        !          27578:            if ( in_typedef && c->lex_level ) 
        !          27579:                 mk_local = 1;
        !          27580:            else c->lex_level = 0;
        !          27581:        }
        !          27582: 
        !          27583:        for ( Pclass tc = ccl; tc; tc = tc->in_class ) {
        !          27584:            if ( tc->lex_level == c->lex_level // c not local to mem ftn of tc
        !          27585:            &&   strcmp( tc->string, c->string) == 0) {
        !          27586:                error( "C %s redefined", c->string );
        !          27587:                error('i', "can't recover from previous errors");
        !          27588:             }
        !          27589:        }
        !          27590: 
        !          27591:        Pname n = c->tname(t);                  /* t ignored */
        !          27592: 
        !          27593:         if (templp->in_progress && (c->lex_level == 0))
        !          27594:         // bring the template in scope
        !          27595:                templp->introduce_class_templ(n);
        !          27596: 
        !          27597: // typedef struct {} x;
        !          27598:        if ( mk_local ) {
        !          27599:            n->n_key  = LOCAL;
        !          27600:            extern Plist local_blk, local_class; // place in cfront.h
        !          27601:            local_class = new name_list( n, local_class );
        !          27602:            local_blk = new name_list( n, local_blk );
        !          27603:            modified_tn = modified_tn->l;
        !          27604:        }
        !          27605: 
        !          27606:        n->where = curloc;
        !          27607:        Pbase bt = Pbase(n->tp);                /* COBJ */
        !          27608:        if (bt->base != COBJ) {
        !          27609:                error("twoDs of%n:%t andC",n,bt);
        !          27610:                error('i', "can't recover from previous errors");
        !          27611:        }
        !          27612: 
        !          27613:        Pclass occl = ccl;
        !          27614:        ccl = Pclass(bt->b_name->tp);           /* CLASS */
        !          27615:        if (ccl->defined) ccl->defined |= IN_ERROR;
        !          27616:        ccl->defined |= DEF_SEEN;
        !          27617: 
        !          27618: // error('d', "start_cl: %n ccl->in_class: %t lex_level: %d", n, ccl->in_class, n->lex_level );
        !          27619: 
        !          27620:        if (ccl->in_class = occl) {
        !          27621:                occl->tn_list = modified_tn;    // save  mod-list
        !          27622:                modified_tn = 0;
        !          27623:        }
        !          27624:        
        !          27625:        Ntncheck = 0;  // zero it out with each new class declaration
        !          27626:        ccl->string = n->string;
        !          27627:        ccl->csu = t;
        !          27628: 
        !          27629:        if (b) {        // list of base classes
        !          27630:                for (Pbcl bx, bb=b, l=0; bb; bb = bx) {
        !          27631:                        bx = bb->next;
        !          27632:                        bb->next = 0;
        !          27633: 
        !          27634:                        if ( bb->bclass
        !          27635:                        &&   strcmp(ccl->string,bb->bclass->string)==0 )
        !          27636:                                error(&n->where,"%nderived from itself",n);
        !          27637:                        else if (l == 0)
        !          27638:                                l = bb;
        !          27639:                        else {  // append and check for duplicates
        !          27640:                                for (Pbcl ll = l;;) {
        !          27641:                                         if (bb->bclass && ll->bclass==bb->bclass) {
        !          27642:                                                error("%s has %s asB twice",ccl->string,bb->bclass->string);
        !          27643:                                                break;
        !          27644:                                        }
        !          27645: 
        !          27646:                                        if (ll->next)
        !          27647:                                                ll = ll->next;
        !          27648:                                        else {
        !          27649:                                                bb->next = l;
        !          27650:                                                l = bb;
        !          27651:                                                break;
        !          27652:                                        }
        !          27653:                                }
        !          27654:                        }
        !          27655:                }
        !          27656: 
        !          27657:                ccl->baselist = l;
        !          27658:                notReally++; set_scope(n); notReally--;
        !          27659:        }
        !          27660:        return bt;      
        !          27661: }
        !          27662: 
        !          27663: void end_cl()
        !          27664: {
        !          27665:        Pclass occl = ccl->in_class;
        !          27666:        Plist ol = occl ? occl->tn_list : 0;    // saved modified name list
        !          27667:        ccl->c_body = 2;
        !          27668: 
        !          27669:        if (modified_tn) {      // export nested class names to outer scope:
        !          27670:                Plist local = 0;
        !          27671:                for (Plist l=modified_tn, nl=0; l; l=nl) {
        !          27672:                        nl = l->l;
        !          27673:                        Pname n = l->f;
        !          27674: 
        !          27675:                        // in a pure implementation, no longer do this
        !          27676:                        if (ktbl->look(n->string,0)) {
        !          27677:                                // add it to enclosing class's modified name list
        !          27678:                                l->l = ol;
        !          27679:                                ol = l;
        !          27680:                        }
        !          27681:                        else {  // retain it in this class's modified name list
        !          27682:                                l->l = local;
        !          27683:                                local = l;
        !          27684:                        }
        !          27685:                }
        !          27686:                if (ccl->tn_list = modified_tn = local) restore();
        !          27687:        }
        !          27688:        modified_tn = ol;       // restore mod-list (possibly modified)
        !          27689: /*
        !          27690: if ( occl ) {
        !          27691: Pname n = ktbl->look(ccl->string,NESTED);
        !          27692: for (;n; n=n->n_tbl_list) {
        !          27693: Ptype tt = Pbase(n->tp)->b_name->tp;
        !          27694: // error('d',"end_cl: ccl: %t occl: %t in_class: %t", ccl, occl, tt->in_class);
        !          27695: if (strcmp(tt->in_class->string, occl->string) == 0) {
        !          27696:        n->n_key = 0;
        !          27697:        }
        !          27698: } 
        !          27699: }
        !          27700: */
        !          27701:        ccl = occl;
        !          27702: }
        !          27703: 
        !          27704: Pbase end_enum(Pname n, nlist* b)
        !          27705: {
        !          27706: // error( 'd', "end_enum: %n ccl: %t", n , ccl ); 
        !          27707:        if (n == 0) n = new name(make_name('E'));
        !          27708:        n = n->tname(ENUM);
        !          27709:        Pbase bt = (Pbase)n->tp;
        !          27710:        if (bt->base != EOBJ) {
        !          27711:                error("twoDs of%n:%t and enum",n,bt);
        !          27712:                error('i', "can't recover from previous errors");
        !          27713:        }
        !          27714:        Penum en = (Penum)bt->b_name->tp;
        !          27715:        en->e_body = 2;
        !          27716:        en->mem = name_unlist(b);
        !          27717:        if (en->defined) {
        !          27718:                // shouldn't be necessary anymore with nested types
        !          27719:                // if ( in_class_decl )
        !          27720:                //      error("%n redefined, enum tag not local to class", n);
        !          27721:                en->defined |= IN_ERROR;
        !          27722:         }
        !          27723:        en->defined |= DEF_SEEN;
        !          27724:        en->in_class = ccl;
        !          27725:        if (ccl && (bl_level==ccl->lex_level + in_class_decl) && is_anon(n->string))
        !          27726:                n=do_nested_type(n);
        !          27727:        return bt;
        !          27728: }
        !          27729: 
        !          27730: extern Ptype return_nstd_local_type(Pname,TOK&);
        !          27731: Pname name::tdef()
        !          27732: /*
        !          27733:        typedef "this"
        !          27734: */
        !          27735: {
        !          27736:        DB(if(Ndebug>=1) {
        !          27737:           error('d',&where,"'%n'->tdef()%t in_typedef %d",this,tp,in_typedef);
        !          27738:           error('d',&where,"   lex_level %d tpdef%t",lex_level,tpdef);
        !          27739:        });
        !          27740:         int anon_cl = 0;
        !          27741:         if (n_qualifier) {
        !          27742:                 error("QdN in typedef",this);
        !          27743:                 n_qualifier = 0;
        !          27744:         }
        !          27745: 
        !          27746:        Pname n;
        !          27747:        if ( tpdef && tpdef->in_class ) { // nested typedef
        !          27748: // error('d', "*****%s->tdef: %d ccl: %t", string, tpdef, ccl );
        !          27749:                n = ktbl->insert(this,NESTED);
        !          27750:                n->tpdef = tpdef;
        !          27751:                n->tpdef->lex_level = n->lex_level = 0;
        !          27752:                nested_type = new name_list( n, nested_type );
        !          27753:        }
        !          27754:        else {
        !          27755:                Pname nn = ktbl->look(string,NESTED);
        !          27756:                if ( nn ) {
        !          27757:                        TOK ntk = 0; // set by return_nstd...
        !          27758:                        Ptype tt = return_nstd_local_type(nn,ntk);
        !          27759:                        error("nested%k%t::%s seen beforeGTdef %s (to do this placeG definition first)",ntk, tt->in_class, string, string);
        !          27760:                        error( 'i', "cannot recover from previous errors" );
        !          27761:                }
        !          27762:                lex_level = bl_level - in_class_decl;
        !          27763:                n = ktbl->insert(this,0);
        !          27764:        }
        !          27765: 
        !          27766:        if (tp == 0) error('i',"Tdef%n tp==0",this);
        !          27767:        n->base = base = TNAME;
        !          27768:        PERM(n);
        !          27769:        PERM(tp);
        !          27770: 
        !          27771:        if (tp->base == COBJ || tp->base == EOBJ ) 
        !          27772:        {       // typedef struct/enum { } s; => struct/enum s {};
        !          27773:                Pname b = Pbase(tp)->b_name;
        !          27774:                if (b->string[0] == '_' && b->string[1] == '_' ) 
        !          27775:                        switch ( tp->base ) {
        !          27776:                                case COBJ: {
        !          27777:                                        if (b->string[2] == 'C') {
        !          27778:                                                Pclass cl = Pclass(b->tp);
        !          27779:                                                b->string = n->string;
        !          27780:                                                cl->string = n->string;
        !          27781:                                                cl->strlen = strlen(cl->string);
        !          27782:                                                if ( lex_level ) {
        !          27783:                                                        anon_cl = 1;
        !          27784:                                                        n->n_key = LOCAL;
        !          27785:                                                }
        !          27786:                                        }
        !          27787:                                        break;
        !          27788:                                }
        !          27789:                                case EOBJ: {
        !          27790:                                        if (b->string[2] == 'E') {
        !          27791:                                                Penum en = Penum(b->tp);
        !          27792:                                                b->string = n->string;
        !          27793:                                                en->string = n->string;
        !          27794:                                                en->strlen = strlen(en->string);
        !          27795:                                        }       
        !          27796:                                }
        !          27797:                        }
        !          27798:        }
        !          27799: 
        !          27800:        if ( anon_cl == 0 )
        !          27801:                modified_tn = new name_list(n,modified_tn);
        !          27802:        DB(if(Ndebug>=1) {
        !          27803:           error('d',&where,">>'%n'->tdef()%t returning",this,tp);
        !          27804:           error('d',&where,"   lex_level %d tpdef%t",lex_level,tpdef);
        !          27805:        });
        !          27806:        return n;
        !          27807: }
        !          27808: 
        !          27809: Pname name::tname(TOK csu)
        !          27810: /*
        !          27811:        "csu" "this" seen, return typedef'd name for "this"
        !          27812:        return  (TNAME,x)
        !          27813:        x:      (COBJ,y)
        !          27814:        y:      (NAME,z)
        !          27815:        z:      (CLASS,ae);
        !          27816: */
        !          27817: {
        !          27818: //error('d',"'%n'::tname(%k)",this,csu);
        !          27819:        switch (base) {
        !          27820:        case TNAME:
        !          27821:                return this;
        !          27822:        case NAME:
        !          27823:        {       Pname tn = ktbl->insert(this,0);
        !          27824:                Pname on = new name;
        !          27825:                tn->base = TNAME;
        !          27826:                tn->lex_level = lex_level;
        !          27827:                modified_tn = new name_list(tn,modified_tn);
        !          27828:                tn->n_list = n_list = 0;
        !          27829:                string = tn->string;
        !          27830:                *on = *this;
        !          27831:                switch (csu) {
        !          27832:                case ENUM:
        !          27833:                        tn->tp = new basetype(EOBJ,on);
        !          27834:                        on->tp = new enumdef(0);
        !          27835:                        Penum(on->tp)->string = tn->string;
        !          27836:                        break;
        !          27837:                case CLASS:
        !          27838:                case STRUCT:
        !          27839:                case UNION:
        !          27840:                        on->tp =  new classdef(csu);
        !          27841:                        Pclass(on->tp)->string = tn->string;
        !          27842:                        Pclass(on->tp)->lex_level = lex_level;
        !          27843:                        tn->tp = new basetype(COBJ,on);
        !          27844:                        Pbase(tn->tp)->b_table = Pclass(on->tp)->memtbl;
        !          27845:                        break;
        !          27846:                default:
        !          27847:                        error('i',&where,"illegal csu%k for%n in name::tname()",csu,this);
        !          27848:                }
        !          27849:                PERM(tn);
        !          27850:                PERM(tn->tp);
        !          27851:                PERM(on);
        !          27852:                PERM(on->tp);
        !          27853:                return tn;
        !          27854:        }
        !          27855:        default:
        !          27856:                error('i',"tname(%s %d %k)",string,this,base);
        !          27857:        } 
        !          27858: }
        !          27859: 
        !          27860: int co_hack;
        !          27861: Pname name::normalize(Pbase b, Pblock bl, bit Cast)
        !          27862: /*
        !          27863:        if (bl) : a function definition (check that it really is a type
        !          27864: 
        !          27865:        if (Cast) : no name string
        !          27866: 
        !          27867:        for each name on the name list
        !          27868:        invert the declarator list(s) and attatch basetype
        !          27869:        watch out for class object initializers
        !          27870: 
        !          27871:        convert
        !          27872:                struct s { int a; } a;
        !          27873:        into
        !          27874:                struct s { int a; }; struct s a;
        !          27875: */
        !          27876: {
        !          27877:        Pname n;
        !          27878:        Pname nn;
        !          27879:        TOK stc;
        !          27880:        bit tpdf;
        !          27881:        bit inli;
        !          27882:        bit virt;
        !          27883:        char * lnkg;
        !          27884:        DB( if(Ndebug>=1) {
        !          27885:            error('d',"'%n'::normalize(b%t, bl %d, cast %d)",this,b,bl,Cast);
        !          27886:            error('d',"    tp%k - lex_level %d - bl_level %d",tp?tp->base:0,lex_level,bl_level);
        !          27887:        });
        !          27888:        if (b) {
        !          27889:                stc = b->b_sto;
        !          27890:                tpdf = b->b_typedef;
        !          27891:                inli = b->b_inline;
        !          27892:                virt = b->b_virtual;
        !          27893:                lnkg = b->b_linkage;
        !          27894:        }
        !          27895:        else {
        !          27896:                stc = 0;
        !          27897:                tpdf = 0;
        !          27898:                inli = 0;
        !          27899:                virt = 0;
        !          27900:                lnkg = 0;
        !          27901:        }
        !          27902: 
        !          27903:        if (inli && stc==EXTERN)  {
        !          27904:                error("both extern and inline");
        !          27905:                inli = 0;
        !          27906:        }
        !          27907: 
        !          27908:        if ( stc==STATIC && tp && 
        !          27909:                tp->base == FCT 
        !          27910:                && Pfct(tp)->f_const ) 
        !          27911:                        error( "%n staticMF cannot be const", this ); 
        !          27912: 
        !          27913:        if (stc==FRIEND && tp==0) {
        !          27914:                /*      friend x;
        !          27915:                        must be handled during syntax analysis to cope with
        !          27916:                                class x { friend y; y* p; };
        !          27917:                        "y" is not local to "x":
        !          27918:                                class x { friend y; ... }; y* p;
        !          27919:                        is legal
        !          27920: 
        !          27921:                        examples:
        !          27922:                                
        !          27923:                                typedef void    SIG_TYP(int);
        !          27924:                                class x {
        !          27925:                                        friend class y;
        !          27926:                                        friend z;
        !          27927:                                        friend x;               // dumb
        !          27928:                                        friend int i;           // error
        !          27929:                                        friend SIG_TYP sigFunc; // subtle
        !          27930:                                        friend int f();
        !          27931:                                        friend g(int);
        !          27932:                                };
        !          27933:                */
        !          27934:                if (b && (b->base || b->b_name || b->b_xname)) goto ccc;
        !          27935: 
        !          27936:                if (n_list) {
        !          27937:                        error("L of friends");
        !          27938:                        n_list = 0;
        !          27939:                }
        !          27940: 
        !          27941:                if (!Cast) {
        !          27942:                        Pname nn = gtbl->look( string, 0 );
        !          27943:                        if ( nn ) {
        !          27944:                                if (nn->tp->base == FCT) 
        !          27945:                                        error("friendF must include signature:%n", this ); 
        !          27946:                                else
        !          27947:                                        error("illegal friendD:%n", this );
        !          27948:                        }
        !          27949:                }
        !          27950: 
        !          27951: //error( 'd', "%n ll: %d", ccl, ccl->lex_level );
        !          27952:                lex_level = ccl->lex_level;
        !          27953:                Pname nx = tname(CLASS);
        !          27954:                modified_tn = modified_tn->l;   /* global */
        !          27955:                n_sto = FRIEND;
        !          27956:                tp = nx->tp;
        !          27957:                return this;
        !          27958:        }
        !          27959: ccc:
        !          27960:        if (tp                          // FUDGE: fix the bad grammar
        !          27961:        && tp->base==FCT
        !          27962:        && (n_oper==TNAME || Pfct(tp)->returns)) {
        !          27963:                Pfct f = Pfct(tp);
        !          27964:                Pfct f2 = Pfct(f->returns);
        !          27965: 
        !          27966:                if (f2) {
        !          27967:                        Ptype pt;
        !          27968:                        Ptype t = f2;
        !          27969:                lxlx:
        !          27970:                        switch (t->base) {
        !          27971:                        case PTR:       // x(* p)(args) ?
        !          27972:                        case VEC:       // x(* p[10])(args) ?
        !          27973:                                if (pt = Pptr(t)->typ) {
        !          27974:                                        if (pt->base == TYPE) {
        !          27975:                                                Pptr(t)->typ = 0;
        !          27976:                                                b = Pbase(pt);
        !          27977:                                        //      stc = b->b_sto;
        !          27978:                                        //      tpdf = b->b_typedef;
        !          27979:                                        //      inli = b->b_inline;
        !          27980:                                        //      virt = b->b_virtual;
        !          27981:                                        }
        !          27982:                                        else {
        !          27983:                                                t = pt;
        !          27984:                                                goto lxlx;
        !          27985:                                        }
        !          27986:                                }
        !          27987:                                goto zse1;
        !          27988:                        case FCT:
        !          27989:                        {//     Pexpr e = f2->argtype;
        !          27990:                                Pexpr e = Pfct(f)->argtype;
        !          27991:                                if  (e && e->base==ELIST) { // get the real name; fix its type
        !          27992:                                        if (e->e2 || e->e1->base!=DEREF) goto zse1;
        !          27993:                                        Pexpr ee = e->e1;
        !          27994:                                        Ptype t = 0;
        !          27995:                                        Ptype tpx;
        !          27996:                                ldld:
        !          27997:                                        switch (ee->base) {
        !          27998:                                        case DEREF:
        !          27999:                                        {       Ptype tt = (ee->e2) ? Ptype(new vec(0,ee->e2)) : Ptype (new ptr(PTR,0));
        !          28000:                                                if (t)
        !          28001:                                                        Pptr(t)->typ = tt;
        !          28002:                                                else
        !          28003:                                                        tpx = tt;
        !          28004:                                                t = tt;
        !          28005:                                                ee = ee->e1;
        !          28006:                                                goto ldld;
        !          28007:                                        }
        !          28008:                                        case NAME:
        !          28009:                                        {       Pname rn = Pname(ee);
        !          28010:                                                b = new basetype(TYPE,ktbl->look(string,0));
        !          28011:                                                f->returns = tpx;
        !          28012:                                                n_oper = 0;
        !          28013:                                                string = rn->string;
        !          28014:                                                base = NAME;
        !          28015:                                        }
        !          28016:                                        }
        !          28017:                                }
        !          28018:                        }
        !          28019:                        }
        !          28020:                }
        !          28021:        }
        !          28022: 
        !          28023: zse1:
        !          28024:        if (b == 0) {
        !          28025:                error("BTX for %s",string);
        !          28026:                b = Pbase(defa_type);
        !          28027:        }
        !          28028:        
        !          28029:        if (Cast) string = "";
        !          28030:        b = b->check(this);
        !          28031: 
        !          28032:        switch (b->base) {      //      separate class definitions
        !          28033:                                //      from object and function type declarations
        !          28034:        case COBJ:
        !          28035:                nn = b->b_name;
        !          28036:                if (Pclass(nn->tp)->c_body==2) {        /* first occurrence */
        !          28037:                        if ( stc == FRIEND ) {
        !          28038:                            Pclass cl = Pclass(nn->tp);
        !          28039:                            if ( cl->csu == ANON )
        !          28040:                                error( &nn->where, "friend anonymous union");
        !          28041:                            else
        !          28042:                                error( &nn->where, "%k%n defined in friendD",cl->csu,nn);
        !          28043:                        }
        !          28044:                        if (tp && tp->base==FCT && co_hack == 0) {
        !          28045:                                error(&this->where,"%k%n defined as returnT for%n (did you forget a ';' after '}' ?)",Pclass(nn->tp)->csu,nn,this);
        !          28046:                                nn = this;
        !          28047:                                break;
        !          28048:                        }
        !          28049:                        nn->n_list = this;
        !          28050:                        Pclass(nn->tp)->c_body = 1;     /* other occurences */
        !          28051:                }
        !          28052:                else
        !          28053:                        nn = this;
        !          28054:                break;
        !          28055:        case EOBJ:
        !          28056:                nn = b->b_name;
        !          28057:                if (Penum(nn->tp)->e_body==2) {
        !          28058:                        if (tp && tp->base==FCT) {
        !          28059:                                error(&this->where,"enum%n defined as returnT for%n (did you forget a ';'?)",nn,this);
        !          28060:                                nn = this;
        !          28061:                                break;
        !          28062:                        }
        !          28063:                        nn->n_list = this;
        !          28064:                        Penum(nn->tp)->e_body = 1;
        !          28065:                }
        !          28066:                else {
        !          28067:                        Penum en = Penum(nn->tp);
        !          28068:                        if ( en->defined == 0 ) 
        !          28069:                                error( "forwardD of enum%n", nn );
        !          28070:                        en->e_type = int_type; 
        !          28071:                        nn = this;
        !          28072:                }
        !          28073:                break;
        !          28074:        default:
        !          28075:                nn = this;
        !          28076:        }
        !          28077: 
        !          28078: //error('d',&where,"name::normalize: nn%n ll %d   nn %d this %d",nn,nn->lex_level,nn,this);
        !          28079:        Pname nx; 
        !          28080:        for (n=this; n; n=nx) {
        !          28081:                Ptype t = n->tp;
        !          28082:                nx = n->n_list;
        !          28083:                n->n_sto = stc;
        !          28084: 
        !          28085:                if (n->base == TNAME) error('i',"redefinition ofTN%n",n);
        !          28086: 
        !          28087:                if (t == 0) {
        !          28088:                        if (bl == 0)
        !          28089:                                n->tp = t = b;
        !          28090:                        else {
        !          28091:                                if ( n->base == NAME && n->n_oper )
        !          28092:                                        error(&n->where,"illegalD of %n",n);
        !          28093:                                else
        !          28094:                                        error(&n->where,"body of nonF%n",n);
        !          28095:                                t = new fct(0,0,0);
        !          28096:                        }
        !          28097:                }
        !          28098: 
        !          28099:                switch (t->base) {
        !          28100:                case PTR:
        !          28101:                case RPTR:
        !          28102:                        n->tp = Pptr(t)->normalize(b);
        !          28103:                        break;
        !          28104:                case VEC:
        !          28105:                        n->tp = Pvec(t)->normalize(b);
        !          28106:                        break;
        !          28107:                case FCT:
        !          28108:                        n->tp = Pfct(t)->normalize(b);
        !          28109:                        break;
        !          28110:                case FIELD:
        !          28111:                        if (n->string == 0) n->string = make_name('F');
        !          28112:                        n->tp = t;
        !          28113:                        Pbase tb = b;
        !          28114: // error('d', "field t %k tb %k", t->base, tb->base );
        !          28115:                flatten:
        !          28116:                        switch (tb->base) {
        !          28117:                        case TYPE:   /* chase typedefs */
        !          28118:                                tb = (Pbase)tb->b_name->tp;
        !          28119:                                goto flatten;
        !          28120:                        case CHAR:
        !          28121:                        case SHORT:
        !          28122:                        case EOBJ:
        !          28123:                        case INT:
        !          28124: //  typedef const unsigned cu_int;
        !          28125: //     struct x { x(); cu_int b1: 2; }
        !          28126: 
        !          28127:                                Pbase(t)->b_fieldtype = (b->b_unsigned||tb->b_unsigned) ? uint_type : int_type;
        !          28128:                //              goto iii;
        !          28129:                //      case CHAR:
        !          28130:                //              Pbase(t)->b_fieldtype = (b->b_unsigned) ? uchar_type : char_type;
        !          28131:                //              goto iii;
        !          28132:                //      case SHORT:
        !          28133:                //              Pbase(t)->b_fieldtype = (b->b_unsigned) ? ushort_type : short_type;
        !          28134:                //              goto iii;
        !          28135:                //      iii:
        !          28136:                                Pbase(t)->b_unsigned = b->b_unsigned?b->b_unsigned:tb->b_unsigned;
        !          28137:                                Pbase(t)->b_const = b->b_const?b->b_const:tb->b_const;
        !          28138:                                break;
        !          28139:                        default:
        !          28140:                                error("non-int field");
        !          28141:                                n->tp = defa_type;
        !          28142:                        }
        !          28143:                        break;
        !          28144:                }
        !          28145: 
        !          28146:                Pfct f = Pfct(n->tp);
        !          28147: 
        !          28148:                if (f->base != FCT) {
        !          28149:                        if (bl) {
        !          28150:                                error("body for nonF%n",n);
        !          28151:                                n->tp = f = new fct(defa_type,0,0);
        !          28152:                                continue;
        !          28153:                        }
        !          28154:                        if (inli) error("inline nonF%n",n);
        !          28155:                        if (virt) error("virtual nonF%n",n);
        !          28156:                                
        !          28157:                        if (tpdf) {
        !          28158: // error('d', "%n->normalize: ccl: %t", this, ccl );
        !          28159:                                if (ccl && n->tpdef &&
        !          28160:                                        (n->tpdef->lex_level == NESTED ||
        !          28161:                                                n->tpdef->lex_level == LOCAL))
        !          28162:                                        ; // using this field for nested/local type info
        !          28163:                                else
        !          28164:                                if (n->n_initializer) {
        !          28165:                                        error("Ir forTdefN%n",n);
        !          28166:                                        n->n_initializer = 0;
        !          28167:                                }
        !          28168:                                n->tdef();
        !          28169:                                // because do_nested_type can't call tdef()
        !          28170:                                if ( n->n_key == NESTED )
        !          28171:                                        modified_tn = modified_tn->l;
        !          28172:                        }
        !          28173:                        continue;
        !          28174:                }
        !          28175: 
        !          28176:                if ( lnkg ) set_linkage(lnkg);
        !          28177:                f->f_linkage = linkage;
        !          28178:                if ( lnkg ) set_linkage(0);
        !          28179:                // wait and call f->sign() after args are checked
        !          28180: 
        !          28181:                f->f_inline = inli;
        !          28182:                extern int vcounter;
        !          28183:                 f->f_virtual = virt?(vcounter++,VTOK):0;
        !          28184: 
        !          28185:                if (tpdf) {
        !          28186:                        if (f->body = bl) error("Tdef%n { ... }",n);
        !          28187:                        if (n->n_qualifier) {
        !          28188:                                // typedef T x::f(args);
        !          28189:                                // a pointer to member fucntion:
        !          28190:                                // equivalent to typedef T x::(f)(args);
        !          28191:                                f->memof = Pclass(Pbase(n->n_qualifier->tp)->b_name->tp);
        !          28192:                                n->n_qualifier = 0;
        !          28193:                        }
        !          28194:                        n->tdef();
        !          28195:                        // because do_nested_type can't call tdef()
        !          28196:                        if ( n->n_key == NESTED )
        !          28197:                                modified_tn = modified_tn->l;
        !          28198:                        continue;
        !          28199:                }
        !          28200: 
        !          28201:                if (f->body = bl) continue;
        !          28202: 
        !          28203:                /*
        !          28204:                        Check function declarations.
        !          28205:                        Look for class object instantiations
        !          28206:                        The real ambiguity:             ; class x fo();
        !          28207:                                is interpreted as an extern function
        !          28208:                                declaration NOT a class object with an
        !          28209:                                empty initializer
        !          28210:                */
        !          28211:                {       Pname cn = f->returns->is_cl_obj();
        !          28212:                         Ptype template_formal_type ;
        !          28213:                        bit clob = (cn || cl_obj_vec);
        !          28214: 
        !          28215:                        if (f->argtype) { /* check argument/initializer list */
        !          28216:                                Pname nn;
        !          28217: 
        !          28218:                                for (nn=f->argtype; nn; nn=nn->n_list) {
        !          28219:                                        if (nn->base != NAME) {
        !          28220:                                                if (!clob) {
        !          28221:                                                        if ((f->returns->base == TYPE) &&
        !          28222:                                                            (Pbase(f->returns)->b_name->n_template_arg == template_type_formal))                                    
        !          28223:                                                 {
        !          28224:                                                 // T x(var); wher T is a template formal
        !          28225:                                                 // it could be a class when instantiated
        !          28226:                                                 // wait until then to issue error message
        !          28227:                                                                template_formal_type = f->returns;
        !          28228:                                                                Pname nnn = Pbase(f->returns)->b_name;
        !          28229:                                                                        nnn->n_template_formal_must_be_class = 1;
        !          28230:                                                                goto is_obj;
        !          28231:                                                         }
        !          28232:                                                        error(&n->where,"ATX for%n",n);
        !          28233:                                                        goto zzz;
        !          28234:                                                }
        !          28235:                                                goto is_obj;
        !          28236:                                        }
        !          28237:                                        //if (nn->string) {
        !          28238:                                        //      error("AN%n inD of%n",nn,n);
        !          28239:                                        //      nn->string = 0;
        !          28240:                                        //}
        !          28241:                                        if (nn->tp) goto ok;
        !          28242:                                }
        !          28243:                                if (!clob) {
        !          28244:                                        error("FALX");
        !          28245:                                        goto zzz;
        !          28246:                                }
        !          28247:                is_obj:
        !          28248:                                /* it was an initializer: expand to constructor */
        !          28249:                                n->tp = f->returns;
        !          28250:                                if (f->argtype->base != ELIST) f->f_args = f->argtype = (Pname)new expr(ELIST,(Pexpr)f->argtype,0);
        !          28251:                                if ( n->n_initializer ) {
        !          28252:                                        error(&n->where,"twoIrs for%n",n);
        !          28253:                                        DEL( ((Pexpr)f->argtype) );
        !          28254:                                        f->argtype = 0;
        !          28255:                                } else
        !          28256:                                        // n->n_initializer = new texpr(VALUE,cn->tp,(Pexpr)f->argtype);
        !          28257:                                         n->n_initializer = new texpr(VALUE, cn ? cn->tp : template_formal_type, (Pexpr)f->argtype);
        !          28258:                                goto ok;
        !          28259:                        zzz:
        !          28260:                                if (f->argtype) {
        !          28261:                                        DEL(Pexpr(f->argtype));
        !          28262:                                        f->argtype = 0;
        !          28263:                                        f->nargs = 0;
        !          28264:                                        f->nargs_known = 1;
        !          28265:                                }
        !          28266:                        }
        !          28267:                        else {  /* T a(); => function declaration */
        !          28268: /*
        !          28269:                                if (clob) {
        !          28270:                                        DEL(n->tp);
        !          28271:                                        n->tp = f->returns;
        !          28272:                                }
        !          28273: */
        !          28274:                        }
        !          28275:                ok:
        !          28276:                        ;
        !          28277:                }
        !          28278:        }
        !          28279:        return nn;
        !          28280: }
        !          28281: 
        !          28282: Ptype vec::normalize(Ptype vecof)
        !          28283: {
        !          28284:        Ptype t = typ;
        !          28285:        typ = vecof;
        !          28286: 
        !          28287:        while(vecof->base == TYPE)
        !          28288:                vecof = Pbase(vecof)->b_name->tp;
        !          28289:                
        !          28290:        switch (vecof->base) {
        !          28291:        case RPTR:
        !          28292:                        error("array ofRs");
        !          28293:                        break;
        !          28294:        case FCT:
        !          28295:                        error("array ofFs");
        !          28296:                        break;
        !          28297:        default:
        !          28298:                        break;
        !          28299:        }
        !          28300: 
        !          28301:        if (t == 0) return this;
        !          28302: 
        !          28303:        switch (t->base) {
        !          28304:        case PTR:
        !          28305:        case RPTR:      return Pptr(t)->normalize(this);
        !          28306:        case VEC:       return Pvec(t)->normalize(this);
        !          28307:        case FCT:       return Pfct(t)->normalize(this);
        !          28308:        default:        error('i',"bad arrayT(%d)",t->base);
        !          28309:        }
        !          28310: 
        !          28311: }
        !          28312: 
        !          28313: Ptype ptr::normalize(Ptype ptrto)
        !          28314: {
        !          28315: //     if (this == 0) error('i',"0->ptr.normalize()");
        !          28316:        Ptype t = typ;
        !          28317:        typ = ptrto;
        !          28318: 
        !          28319:        int bc = 0;
        !          28320:        while (ptrto->base == TYPE) {
        !          28321:                bc += Pbase(ptrto)->b_const;
        !          28322:                ptrto = Pbase(ptrto)->b_name->tp;
        !          28323:        }
        !          28324: 
        !          28325:        switch (ptrto->base) {
        !          28326:        case FCT:
        !          28327:                if (memof)
        !          28328:                        if (Pfct(ptrto)->memof) {
        !          28329:                                if (memof != Pfct(ptrto)->memof) error("P toMF mismatch: %s and %s",memof->string, Pfct(ptrto)->memof->string);
        !          28330:                        }
        !          28331:                        else
        !          28332:                                Pfct(ptrto)->memof = memof;
        !          28333:                else
        !          28334:                        memof = Pfct(ptrto)->memof;
        !          28335:                break;
        !          28336:        case RPTR:
        !          28337:                switch (base) {
        !          28338:                case PTR:       error("P toR"); break;
        !          28339:                case RPTR:      error("R toR"); break;
        !          28340:                }
        !          28341:        }
        !          28342: 
        !          28343:        if (t == 0) {
        !          28344:                Pbase b = Pbase(ptrto);
        !          28345:                if (Pfctvec_type
        !          28346:                && rdo==0
        !          28347:                && b->b_unsigned==0
        !          28348:                && b->b_const==0
        !          28349:                && bc == 0
        !          28350:                && memof==0
        !          28351:                && base==PTR) {
        !          28352:                        switch (b->base) {
        !          28353:                        case INT:       delete this;    return Pint_type;
        !          28354:                        case CHAR:      delete this;    return Pchar_type;
        !          28355:                        case VOID:      delete this;    return Pvoid_type;
        !          28356:                        }
        !          28357:                }
        !          28358:                if (base==RPTR && b->base==VOID) error("void& is not a validT");
        !          28359:                return this;
        !          28360:        }
        !          28361: 
        !          28362:        switch (t->base) {
        !          28363:        case PTR:
        !          28364:        case RPTR:      return Pptr(t)->normalize(this);
        !          28365:        case VEC:       return Pvec(t)->normalize(this);
        !          28366:        case FCT:       return Pfct(t)->normalize(this);
        !          28367:        default:        error('i',"badPT(%k)",t->base);
        !          28368:        }
        !          28369: }
        !          28370: 
        !          28371: Ptype fct::normalize(Ptype ret)
        !          28372: /*
        !          28373:        normalize return type
        !          28374: */
        !          28375: {
        !          28376:        register Ptype t = returns;
        !          28377:        returns = ret;
        !          28378: 
        !          28379:        if (argtype && argtype->base==NAME && argtype->n_qualifier) {
        !          28380:                error("syntax: ANX");
        !          28381:                argtype = 0;
        !          28382:                nargs = 0;
        !          28383:                nargs_known = 0;
        !          28384:        }
        !          28385: 
        !          28386:        while(ret->base == TYPE)
        !          28387:                ret = Pbase(ret)->b_name->tp;
        !          28388: 
        !          28389:        switch(ret->base) {
        !          28390:        case VEC:
        !          28391:                error("F returning array");
        !          28392:                break;
        !          28393:        case FCT:
        !          28394:                error("F returningF");
        !          28395:                returns = ret = t?t:int_type;
        !          28396:                break;
        !          28397:        default:
        !          28398:                break;
        !          28399:        }
        !          28400: 
        !          28401:        if (t == 0) return this;
        !          28402: 
        !          28403:        switch (t->base) {
        !          28404:        case PTR:
        !          28405:        case RPTR:      return Pptr(t)->normalize(this);
        !          28406:        case VEC:       return Pvec(t)->normalize(this);
        !          28407:        case FCT:       return Pfct(t)->normalize(this);
        !          28408:        default:        error('i',"badFT:%k",t->base);
        !          28409:        }
        !          28410: }
        !          28411: 
        !          28412: void fct::argdcl(Pname dcl, Pname fn)
        !          28413: /*
        !          28414:        sort out the argument types for old syntax:
        !          28415:                        f(a,b) int a; char b; { ... }
        !          28416:        beware of
        !          28417:                        f(a) struct s { int a; }; struct s a;
        !          28418: */
        !          28419: {
        !          28420:        Pname n;
        !          28421: /*fprintf(stderr,"%d argtype %d %d dcl %d %d\n",this, argtype, argtype?argtype->base:0, dcl, dcl?dcl->base:0); fflush(stderr);*/
        !          28422:        switch (base) {
        !          28423:        case FCT:       break;
        !          28424:        case ANY:       return;
        !          28425:        default:        error('i',"fct::argdcl(%d)",base);
        !          28426:        }
        !          28427: 
        !          28428:        if (argtype) {
        !          28429:                switch (argtype->base) {
        !          28430:                case NAME:
        !          28431:                        if (dcl) error("badF definition syntax");
        !          28432:                        for (n=argtype; n; n=n->n_list) {
        !          28433:                                if (n->string == 0) n->string = make_name('A');
        !          28434:                        }
        !          28435:                        return;
        !          28436:                case ELIST:     // expression list:     f(a,b,c) int a; ... { ... }
        !          28437:                                // scan the elist and build a NAME list
        !          28438:                {
        !          28439:                        Pname tail = 0;
        !          28440:                        n = 0;
        !          28441: 
        !          28442:                        error(strict_opt?0:'w',&fn->where,"old style definition of%n (anachronism)",fn);
        !          28443: 
        !          28444:                        for (Pexpr e=Pexpr(argtype); e; e=e->e2) {
        !          28445:                                Pexpr id = e->e1;
        !          28446:                                if (id->base != NAME) {
        !          28447:                                        error("NX inAL");
        !          28448:                                        argtype = 0;
        !          28449:                                        dcl = 0;
        !          28450:                                        break;
        !          28451:                                }
        !          28452:                                Pname nn = new name(id->string);
        !          28453:                                if (n)
        !          28454:                                        tail = tail->n_list = nn;
        !          28455:                                else
        !          28456:                                        tail = n = nn;
        !          28457:                        }
        !          28458:                        f_args = argtype = n;
        !          28459:                        break;
        !          28460:                }
        !          28461:                default:
        !          28462:                        error("ALX(%d)",argtype->base);
        !          28463:                        argtype = 0;
        !          28464:                        dcl = 0;
        !          28465:                }
        !          28466:        }
        !          28467:        else if(nargs_known == ELLIPSIS) {
        !          28468:                return;
        !          28469:        }
        !          28470:        else {
        !          28471:                nargs_known = 1;
        !          28472:                nargs = 0;
        !          28473:                if (dcl) error("ADL forFWoutAs");
        !          28474:                return;
        !          28475:        }
        !          28476: 
        !          28477: //     nargs_known = 0;
        !          28478: 
        !          28479:        if (dcl) {
        !          28480:                Pname d;
        !          28481:                Pname dx;
        !          28482:                /*      for each  argument name see if its type is specified
        !          28483:                        in the declaration list otherwise give it the default type
        !          28484:                */
        !          28485: 
        !          28486:                for (n=argtype; n; n=n->n_list) {
        !          28487:                        char* s = n->string;
        !          28488:                        if (s == 0) {
        !          28489:                                error("AN missing inF definition");
        !          28490:                                n->string = s = make_name('A');
        !          28491:                        }
        !          28492:                        else if (n->tp) error("twoTs forA %s",n->string);
        !          28493: 
        !          28494:                        for (d=dcl; d; d=d->n_list) {
        !          28495:                                if (strcmp(s,d->string) == 0) {
        !          28496:                                        if (d->tp->base == VOID) {
        !          28497:                                                error("voidA%n",d);
        !          28498:                                                d->tp = any_type;
        !          28499:                                        }
        !          28500:                                        n->tp = d->tp;
        !          28501:                                        n->n_sto = d->n_sto;
        !          28502:                                        d->tp = 0;      // now merged into argtype
        !          28503:                                        goto xx;
        !          28504:                                }
        !          28505:                        }
        !          28506:                        n->tp = defa_type;
        !          28507:                xx:;
        !          28508:                        if (n->tp == 0) error('i',"noT for %s",n->string);
        !          28509:                }
        !          28510:        
        !          28511:                /*      now scan the declaration list for "unused declarations"
        !          28512:                        and delete it
        !          28513:                */
        !          28514:                for (d=dcl; d; d=dx) {
        !          28515:                        dx = d->n_list;
        !          28516:                        if (d->tp) {    /* not merged with argtype list */
        !          28517:                                /*if (d->base == TNAME)  ??? */
        !          28518:                                switch (d->tp->base) {
        !          28519:                                case CLASS:
        !          28520:                                case ENUM:
        !          28521:                                        /* WARNING: this will reverse the order of
        !          28522:                                           class and enum declarations
        !          28523:                                        */
        !          28524:                                        d->n_list = argtype;
        !          28525:                                        f_args = argtype = d;
        !          28526:                                        break;
        !          28527:                                default:
        !          28528:                                         error("%n inADL not inAL",d);
        !          28529:                                }
        !          28530:                        }
        !          28531:                }
        !          28532:        }
        !          28533: 
        !          28534:        /* add default argument types if necessary */
        !          28535:        for (n=argtype; n; n=n->n_list) {
        !          28536:                if (n->tp == 0) n->tp = defa_type;
        !          28537:                nargs++;
        !          28538:        }
        !          28539: }
        !          28540: 
        !          28541: Pname cl_obj_vec;      /* set if is_cl_obj() found a array of class objects */
        !          28542: Pname eobj;            /* set if is_cl_obj() found an enum */
        !          28543: 
        !          28544: Pname type::is_cl_obj()
        !          28545: /*
        !          28546:        returns this->b_name if this is a class object
        !          28547:        returns 0 and sets cl_obj_vec to this->b_name
        !          28548:                if this is a array of class objects
        !          28549:        returns 0 and sets eobj to this->b_name
        !          28550:                if this is an enum object
        !          28551:        else returns 0
        !          28552: */
        !          28553: {
        !          28554:        bit v = 0;
        !          28555:        register Ptype t = this;
        !          28556: 
        !          28557:        if (t == 0) return 0;
        !          28558:        eobj = 0;
        !          28559:        cl_obj_vec = 0;
        !          28560: xx:
        !          28561:        switch (t->base) {
        !          28562:        case TYPE:
        !          28563:                t = Pbase(t)->b_name->tp;
        !          28564:                goto xx;
        !          28565: 
        !          28566:        case COBJ:
        !          28567:                if (v) {
        !          28568:                        cl_obj_vec = Pbase(t)->b_name;
        !          28569:                        return 0;
        !          28570:                }
        !          28571:                else
        !          28572:                        return Pbase(t)->b_name;
        !          28573: 
        !          28574:        case VEC:
        !          28575:                t = Pvec(t)->typ;
        !          28576:                v=1;
        !          28577:                goto xx;
        !          28578: 
        !          28579:        case EOBJ:
        !          28580:                eobj = Pbase(t)->b_name;
        !          28581:        default:        
        !          28582:                return 0;
        !          28583:        }
        !          28584: }
        !          28585: 
        !          28586: /*
        !          28587: static Pname
        !          28588: lookup(char* s, Pclass cl)
        !          28589: {
        !          28590:        Pbcl bc = 0;
        !          28591:        Pname n = cl->memtbl->look(s,0);
        !          28592:        if ( n ) return n;
        !          28593:        Pname n2 = 0;
        !          28594:        for (Pbcl b=cl->baselist; b; b=b->next) {
        !          28595:                n = b->bclass->lookup(s,cl);
        !          28596:                if ( n == 0 ) continue;
        !          28597:                if ( n2 ) { // clash?
        !          28598:                }
        !          28599:                n2 = n;
        !          28600:        }
        !          28601: }
        !          28602: */
        !          28603: 0707071010112044371004440001630000160000010205100466055405600001000000011657norm2.c/*ident    "@(#)ctrans:src/norm2.c 1.4" */
        !          28604: /************************************************************************
        !          28605: 
        !          28606:        C++ source for cfront, the C++ compiler front-end
        !          28607:        written in the computer science research center of Bell Labs
        !          28608: 
        !          28609:        Copyright (c) 1984 AT&T, Inc. All Rights Reserved
        !          28610:        THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T, INC.
        !          28611: 
        !          28612: norm2.c:
        !          28613: 
        !          28614:        "normalization" handles problems which could have been handled
        !          28615:        by the syntax analyser; but has not been done. The idea is
        !          28616:        to simplify the grammar and the actions associated with it,
        !          28617:        and to get a more robust error handling
        !          28618: 
        !          28619: ****************************************************************************/
        !          28620: 
        !          28621: #include "cfront.h"
        !          28622: #include "size.h"
        !          28623: 
        !          28624: #ifdef DBG
        !          28625: long node_id = 0;
        !          28626: #define DBCHECK() if(node::allocated) error('i',"allocated node (id %d, base%k) on free list! (src: \"%s\", %d",node::id,node::base,__FILE__,__LINE__);
        !          28627: #else
        !          28628: #define DBCHECK() /**/
        !          28629: #endif
        !          28630: 
        !          28631: fct::fct(Ptype t, Pname arg, TOK known)
        !          28632: {
        !          28633:        base = FCT;
        !          28634:        nargs_known = known;
        !          28635:        returns = t;
        !          28636:        argtype = arg; 
        !          28637:        DBID();
        !          28638: 
        !          28639:        if (arg==0 || arg->base==ELIST) return;
        !          28640: //error('d',"fct::fct %d sig %d",this,f_signature);
        !          28641:        register Pname n;
        !          28642:        Pname pn = 0;
        !          28643:        for (n=arg; n; pn=n,n=n->n_list) {
        !          28644:                if( n->n_sto==EXTERN ) error("externA");
        !          28645:                if( n->n_sto==STATIC ) error("static used forA%n",arg);
        !          28646:  
        !          28647:                switch (n->tp->base) {
        !          28648:                case VOID:
        !          28649:                        argtype = 0;
        !          28650:                        nargs_known = 1;
        !          28651:                        if(n->n_initializer)
        !          28652:                                error("voidFA");
        !          28653:                        else if (n->string)
        !          28654:                                error("voidFA%n",n);
        !          28655:                        else if (nargs || n->n_list) {
        !          28656:                                error("voidFA");
        !          28657:                                nargs_known = 0;
        !          28658:                        }
        !          28659:                        nargs = 0;
        !          28660:                        break;
        !          28661:                case CLASS:
        !          28662:                case ENUM:
        !          28663:                        error("%k defined inAL (will not be in scope at point of call)",n->tp->base);
        !          28664:                        if (n == argtype)
        !          28665:                                argtype = n->n_list;
        !          28666:                        else
        !          28667:                                pn->n_list = n->n_list;
        !          28668:                        break;
        !          28669:                default:
        !          28670:                        nargs++;
        !          28671:                }
        !          28672:        }
        !          28673: }
        !          28674: 
        !          28675: expr::expr(TOK ba, Pexpr a, Pexpr b)
        !          28676: {
        !          28677:        DBCHECK();
        !          28678: 
        !          28679:        base = ba;
        !          28680:        e1 = a;
        !          28681:        e2 = b;
        !          28682:        DBID();
        !          28683: }
        !          28684: 
        !          28685: stmt::stmt(TOK ba, loc ll, Pstmt a)
        !          28686: {
        !          28687:        DBCHECK();
        !          28688: 
        !          28689:        base = ba;
        !          28690:        where = ll;
        !          28691:        s=a;
        !          28692:        DBID();
        !          28693: }
        !          28694: 
        !          28695: classdef::classdef(TOK b)
        !          28696: {
        !          28697:        base = CLASS;
        !          28698:        csu = b;
        !          28699:        memtbl = new table(CTBLSIZE,0,0);
        !          28700:        DBID();
        !          28701: }
        !          28702: 
        !          28703: classdef::~classdef()
        !          28704: {
        !          28705:        delete memtbl;
        !          28706: }
        !          28707: 
        !          28708: basetype::basetype(TOK b, Pname n)
        !          28709: {
        !          28710:        switch (b) {
        !          28711:        case 0:                         break;
        !          28712:        case TYPEDEF:   b_typedef = 1;  break;
        !          28713:        case INLINE:    b_inline = 1;   break;
        !          28714:        case VIRTUAL:   b_virtual = 1;  break;
        !          28715:        case CONST:     b_const = 1;    break;
        !          28716:        case UNSIGNED:  b_unsigned = 1; break;
        !          28717:        case FRIEND:
        !          28718:        case OVERLOAD:
        !          28719:        case EXTERN:
        !          28720:        case STATIC:
        !          28721:        case AUTO:
        !          28722:        case REGISTER:  b_sto = b;      break;
        !          28723:        case SHORT:     b_short = 1;    break;
        !          28724:        case LONG:      b_long = 1;     break;
        !          28725:        case ANY:
        !          28726:        case ZTYPE:
        !          28727:        case VOID:
        !          28728:        case CHAR:
        !          28729:        case INT:
        !          28730:        case FLOAT:
        !          28731:        case LDOUBLE:
        !          28732:        case DOUBLE:    base = b;       break;
        !          28733:        case TYPE:
        !          28734:        case COBJ:
        !          28735:        case EOBJ:
        !          28736:        case FIELD:
        !          28737:        case ASM:
        !          28738:                base = b;
        !          28739:                b_name = n;
        !          28740:                break;
        !          28741:        case SIGNED:
        !          28742:        case VOLATILE:
        !          28743:                error('w',"\"%k\" not implemented (ignored)",b);
        !          28744:                break;
        !          28745:        default:
        !          28746:                error('i',"badBT:%k",b);
        !          28747:        }
        !          28748:        DBID();
        !          28749: }
        !          28750: 
        !          28751: name::name(char* s) : expr(NAME,0,0)
        !          28752: {
        !          28753:        // DBCHECK() called in expr::expr()
        !          28754:        string = s;
        !          28755:        where = curloc;
        !          28756:        lex_level = bl_level;
        !          28757: }
        !          28758: 
        !          28759: nlist::nlist(Pname n)
        !          28760: {
        !          28761:        head = n;
        !          28762:        for (Pname nn=n; nn->n_list; nn=nn->n_list);
        !          28763:        tail = nn;
        !          28764: }
        !          28765: 
        !          28766: void nlist::add_list(Pname n)
        !          28767: {
        !          28768:        if (n->tp && (n->tp->defined & IN_ERROR)) return;
        !          28769: 
        !          28770:        tail->n_list = n;
        !          28771:        for (Pname nn=n; nn->n_list; nn=nn->n_list);
        !          28772:        tail = nn;
        !          28773: }
        !          28774: 
        !          28775: Pname name_unlist(Pnlist l)
        !          28776: {
        !          28777:        if (l == 0) return 0;
        !          28778:        Pname n = l->head;
        !          28779: 
        !          28780:        delete l;
        !          28781:        return n;
        !          28782: }
        !          28783: 
        !          28784: Pstmt stmt_unlist(Pslist l)
        !          28785: {
        !          28786:        if (l == 0) return 0;
        !          28787:        Pstmt s = l->head;
        !          28788: //     NFl++;
        !          28789: 
        !          28790:        delete l;
        !          28791:        return s;
        !          28792: }
        !          28793: 
        !          28794: Pexpr expr_unlist(Pelist l)
        !          28795: {
        !          28796:        if (l == 0) return 0;
        !          28797:        Pexpr e = l->head;
        !          28798: //     NFl++;
        !          28799: 
        !          28800:        delete l;
        !          28801:        return e;
        !          28802: }
        !          28803: 
        !          28804: void sig_name(Pname n)
        !          28805: {
        !          28806:        static char buf[256];
        !          28807:        buf[0] = '_';
        !          28808:        buf[1] = '_';
        !          28809:        buf[2] = 'o';
        !          28810:        buf[3] = 'p';
        !          28811:        char* p = n->tp->signature(buf+4);
        !          28812:        if (255 < p-buf) error('i',"sig_name():N buffer overflow");
        !          28813:        char *s = new char [ p - buf + 1 ];
        !          28814:        strcpy(s,buf);
        !          28815:        n->string = s;
        !          28816:        n->tp = 0;
        !          28817: }
        !          28818: 
        !          28819: Ptype tok_to_type(TOK b)
        !          28820: {
        !          28821:        Ptype t;
        !          28822:        switch (b) {
        !          28823:        case CHAR:      t = char_type; break;
        !          28824:        case SHORT:     t = short_type; break;
        !          28825:        case LONG:      t = long_type; break;
        !          28826:        case UNSIGNED:  t = uint_type; break;
        !          28827:        case FLOAT:     t = float_type; break;
        !          28828:        case DOUBLE:    t = double_type; break;
        !          28829:        case LDOUBLE:   t = ldouble_type; break;
        !          28830:        case VOID:      t = void_type; break;
        !          28831:        default:        error("illegalK:%k",b);
        !          28832:        case INT:       t = int_type;
        !          28833:        }
        !          28834:        return t;
        !          28835: }
        !          28836: 
        !          28837: Pbase defa_type;
        !          28838: Pbase moe_type;
        !          28839: Pexpr dummy;
        !          28840: Pexpr zero;
        !          28841: 
        !          28842: Pclass ccl;
        !          28843: Plist modified_tn = 0;
        !          28844: 
        !          28845: Plist local_tn = 0;
        !          28846: Plist local_blk = 0;
        !          28847: Plist local_class = 0;
        !          28848: 
        !          28849: Plist nested_tn = 0;
        !          28850: Plist nested_type = 0;
        !          28851: 
        !          28852: void memptrdcl(Pname bn, Pname tn, Ptype ft, Pname n)
        !          28853: {
        !          28854:        Pptr p = new ptr(PTR,0);
        !          28855:        p->memof = Pclass(Pbase(bn->tp)->b_name->tp);
        !          28856:        Pbase b = new basetype(TYPE,tn);
        !          28857:        PERM(p);
        !          28858:        Pfct f = Pfct(ft);
        !          28859:        Ptype t = n->tp;
        !          28860:        if (t) {
        !          28861:                p->typ = t;
        !          28862:        ltlt:
        !          28863:                switch (t->base) {
        !          28864:                case PTR:
        !          28865:                case RPTR:
        !          28866:                case VEC:
        !          28867:                        if (Pptr(t)->typ == 0) {
        !          28868:                                Pptr(t)->typ = b;
        !          28869:                                break;
        !          28870:                        }
        !          28871:                        t = Pptr(t)->typ;
        !          28872:                        goto ltlt;
        !          28873:                default:
        !          28874:                        error('s',"P toMFT too complicated");
        !          28875:                }
        !          28876:        }
        !          28877:        else
        !          28878:        p->typ = b;     
        !          28879:        f->returns = p;
        !          28880:        n->tp = f;
        !          28881: }
        !          28882: 0707071010112044401004440001630000160000010205200466055406200001000000061331print.c/*ident    "@(#)ctrans:src/print.c 1.3" */
        !          28883: /**************************************************************************
        !          28884: 
        !          28885:        C++ source for cfront, the C++ compiler front-end
        !          28886:        written in the computer science research center of Bell Labs
        !          28887: 
        !          28888:        Copyright (c) 1984 AT&T, Inc. All rights Reserved
        !          28889:        THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T, INC.
        !          28890: 
        !          28891: print.c:
        !          28892: 
        !          28893:        print statements and expressions
        !          28894: 
        !          28895: ****************************************************************************/
        !          28896: 
        !          28897: #include "cfront.h"
        !          28898: 
        !          28899: static int addrof_cm ;
        !          28900: extern void puttok(TOK);
        !          28901: 
        !          28902: /*
        !          28903: void cprint(Pexpr e)
        !          28904: {
        !          28905:        if (e == 0) return;
        !          28906: //error('d',"%k %n %t",e->base,e->base==NAME?e:0,e->tp);
        !          28907: //     if ((e->base==NAME || e->base==ANAME)
        !          28908: //     && Pname(e)->n_evaluated==0) {
        !          28909:                Ptype t = e->tp;
        !          28910:                while (t->base == TYPE) t = Pbase(t)->b_name->tp;
        !          28911:                if (t->base == EOBJ) fprintf(out_file,"(int)");
        !          28912: //     }
        !          28913:         
        !          28914:         Eprint(e);
        !          28915: }
        !          28916: */
        !          28917: #define cprint(e) if (e) Eprint(e)
        !          28918: #define eprint(e) if (e) Eprint(e)
        !          28919: 
        !          28920: void Eprint(Pexpr e)
        !          28921: {
        !          28922:        switch (e->base) {
        !          28923:        case REF:
        !          28924:                if (Pref(e)->mem && Pref(e)->mem->tp && Pref(e)->mem->tp->base == FCT) {
        !          28925:                        //  suppress ``this'' in ``this->f''
        !          28926:                        Pref(e)->mem->print();
        !          28927:                        break;
        !          28928:                }
        !          28929:        case NAME:
        !          28930:        case MDOT:
        !          28931:        case ID:
        !          28932:        case ZERO:
        !          28933:        case ICON:
        !          28934:        case CCON:
        !          28935:        case FCON:
        !          28936:        case STRING:
        !          28937:        case IVAL:
        !          28938:        case TEXT:
        !          28939:        case CM:
        !          28940:        case G_CM:
        !          28941:        case ELIST:
        !          28942:        case COLON:
        !          28943:        case ILIST:
        !          28944:        case DOT:
        !          28945:        case THIS:
        !          28946:        case CALL:
        !          28947:        case G_CALL:
        !          28948:        case ICALL:
        !          28949:        case ANAME:
        !          28950:                e->print();
        !          28951:        case DUMMY:
        !          28952:                break;
        !          28953:        default:
        !          28954:                putch('(');
        !          28955:                e->print();
        !          28956:                putch(')');
        !          28957:        }
        !          28958: }
        !          28959: 
        !          28960: void expr::print()
        !          28961: {
        !          28962:        if (this == 0) error('i',"0->E::print()");
        !          28963:        if (this==e1 || this==e2) error('i',"(%p%k)->E::print(%p %p)",this,base,e1,e2);
        !          28964: // error('d',"(%d %k)->expr::print(%d %d)",this,base,e1,e2);
        !          28965: 
        !          28966:        switch (base) {
        !          28967:        case MDOT:
        !          28968:        {
        !          28969: // error('d',"mdot %s i1 %d %t",string2,i1,mem->tp);
        !          28970:        int not_allocated = 0;
        !          28971:                switch (i1) {
        !          28972:                case 0:
        !          28973:                        putcat('O',string2);
        !          28974:                        puttok(DOT);    // use sub-object directly
        !          28975:                        mem->print();
        !          28976:                        break;
        !          28977:                case 1:
        !          28978:                        putcat('P',string2);
        !          28979:                        puttok(REF);    // use through pointer
        !          28980:                        mem->print();
        !          28981:                        break;
        !          28982:                case 2:
        !          28983:                        if (mem->tp->is_ptr_or_ref()==0) {
        !          28984:                                mem->print();
        !          28985:                                puttok(DOT);
        !          28986:                                putcat('O',string2);
        !          28987:                        }
        !          28988:                        else
        !          28989:                        {
        !          28990:                        putch('(');     // REF turns pointer into object: add &
        !          28991:                        putch('&');     // ``this'' is a pointer
        !          28992:                        putch('(');
        !          28993:                        eprint(mem);//mem->print();
        !          28994:                        puttok(REF);    // call sub-object directly
        !          28995:                        putcat('O',string2);
        !          28996:                        putch(')');
        !          28997:                        putch(')');
        !          28998:                        }
        !          28999:                        break;
        !          29000:                case 5:
        !          29001:                        not_allocated = 1;
        !          29002:                        // no break;    
        !          29003:                case 3:
        !          29004:                    if (mem->tp->is_ptr_or_ref()==0) {
        !          29005:                        putch('(');     // Px is a pointer (T*) turn it back to a T
        !          29006:                        putch('*');     // *Px
        !          29007:                        putch('(');
        !          29008:                        eprint(mem);//mem->print();
        !          29009:                        puttok(DOT);    //  call through pointer
        !          29010:                        putcat('P',string2);
        !          29011:                        putch(')');
        !          29012:                        putch(')');
        !          29013:                    }
        !          29014:                    else {
        !          29015: //                     eprint(mem);    // <<< mem->print()
        !          29016:                        if (not_allocated) {
        !          29017:                                putch('(');
        !          29018:                                mem->print();
        !          29019:                                if ( mem->base == NAME ) 
        !          29020:                                        puttok(REF);
        !          29021:                                else puttok(DOT);
        !          29022:                                putcat('O',string4);
        !          29023:                                putch(')');
        !          29024:                        }
        !          29025:                        else eprint(mem);
        !          29026:                        if (mem->base == NAME && not_allocated)
        !          29027:                                puttok(DOT);
        !          29028:                        else puttok(REF);       //  call through pointer
        !          29029:                        putcat('P',string2);
        !          29030:                    }
        !          29031:                    break;
        !          29032:                case 9: // vtbl entry:  (p->_vtbl).f, (p->_vtbl).i, (p->_vtbl).d
        !          29033:                        // or memptr: mp.f, mp.i, mp.d
        !          29034:                        eprint(mem);
        !          29035:                        putch('.');
        !          29036:                        putstring(string2);
        !          29037:                } // end switch(i1)
        !          29038:                break;
        !          29039:        } // end MDOT
        !          29040: 
        !          29041:        case NAME:
        !          29042:        {       Pname n = Pname(this);
        !          29043:                 if (n->n_evaluated
        !          29044:         //      && n->tp->base!=EOBJ    // this output enumerators
        !          29045:                 && n->n_scope!=ARG) {
        !          29046:                         Ptype t = tp;
        !          29047:                        while (t->base == TYPE) t = Pbase(t)->b_name->tp;
        !          29048:                         if (t->base == EOBJ) t = Penum(Pbase(t)->b_name->tp)->e_type;
        !          29049:                         if (t->base!=INT || t->is_unsigned()) {
        !          29050:                                putstring("((");
        !          29051:                                bit oc = Cast;
        !          29052:                                Cast = 1;
        !          29053:                                 t->print();
        !          29054:                                Cast = oc;
        !          29055:                                fprintf(out_file,")%d)",n->n_val);
        !          29056:                        }
        !          29057:                        else
        !          29058:                                fprintf(out_file,"%d",n->n_val);
        !          29059:                }
        !          29060:                else
        !          29061:                        n->print();
        !          29062:                break;
        !          29063:        }
        !          29064:        case ANAME:
        !          29065:                if (curr_icall) {       // in expansion: look it up
        !          29066:                        Pname n = Pname(this);
        !          29067:                        int argno = int(n->n_val);
        !          29068: 
        !          29069:                        for (Pin il=curr_icall; il; il=il->i_next)
        !          29070:                                if (n->n_table == il->i_table) goto aok;
        !          29071:                        goto bok;
        !          29072:                aok:
        !          29073:                        if (n = il->i_args[argno].local) {
        !          29074:                                n->print();
        !          29075:                        }
        !          29076:                        else {
        !          29077:                                Pexpr ee = il->i_args[argno].arg;
        !          29078:                                Ptype t = il->i_args[argno].tp;
        !          29079:                                if (ee==0 || ee==this) error('i',"%p->E::print(A %p)",this,ee);
        !          29080:                                if (ee->tp==0
        !          29081:                                || (t!=ee->tp
        !          29082:                                        && t->check(ee->tp,0)
        !          29083:                                        && t->is_cl_obj()==0
        !          29084:                                //      && eobj==0)
        !          29085:                                        )
        !          29086:                                ) {
        !          29087:                                        putstring("((");
        !          29088:                                        bit oc = Cast;
        !          29089:                                        Cast = 1;
        !          29090:                                        t->print();
        !          29091:                                        Cast = oc;
        !          29092:                                        putch(')');
        !          29093:                                        // eprint(ee);
        !          29094:                                //      if (ee->base == CAST) {
        !          29095:                                //              eprint(ee->e1);
        !          29096:                                //      }
        !          29097:                                //      else
        !          29098:                                                eprint(ee);
        !          29099:                                        putch(')');
        !          29100:                                }
        !          29101:                                else
        !          29102:                                        eprint(ee);
        !          29103:                        }
        !          29104:                }
        !          29105:                else {
        !          29106:                bok:    /* in body: print it: */
        !          29107:                        Pname(this)->print();
        !          29108:                }
        !          29109:                break;
        !          29110: 
        !          29111:        case ICALL:
        !          29112:        {       il->i_next = curr_icall;
        !          29113:                curr_icall = il;
        !          29114: //error('d',"icall %n",il->fct_name);
        !          29115:                if (il == 0) error('i',"E::print: iline missing");
        !          29116:                Pexpr a0 = il->i_args[0].arg;
        !          29117:                int val = QUEST;
        !          29118:                if (il->fct_name->n_oper != CTOR) goto dumb;
        !          29119: 
        !          29120:                /*
        !          29121:                        find the value of "this"
        !          29122:                        if the argument is a "this" NOT assigned to
        !          29123:                        by the programmer, it was initialized
        !          29124:                */
        !          29125:                switch (a0->base) {
        !          29126:                case ZERO:
        !          29127:                        val = 0;
        !          29128:                        break;
        !          29129:                case ADDROF:
        !          29130:                case G_ADDROF:
        !          29131:                        val = 1;
        !          29132:                        break;
        !          29133:                case CAST:
        !          29134:                        if (a0->e1->base == ANAME || a0->e1->base == NAME) {
        !          29135:                                Pname a = (Pname)a0->e1;
        !          29136:                                if (a->n_assigned_to == FUDGE111) val = FUDGE111;
        !          29137:                        }
        !          29138:                }
        !          29139:                if (val==QUEST) goto dumb;
        !          29140:                /*
        !          29141:                        now find the test:  "(this==0) ? _new(sizeof(X)) : 0"
        !          29142: 
        !          29143:                        e1 is a comma expression,
        !          29144:                        the test is either the first sub-expression
        !          29145:                                or the first sub-expression after the assignments
        !          29146:                                        initializing temporary variables
        !          29147:                 */
        !          29148:        dumb:
        !          29149:                eprint(e1);
        !          29150:                if (e2) Pstmt(e2)->print();
        !          29151:                curr_icall = il->i_next;
        !          29152:                break;
        !          29153:        }
        !          29154:        case REF:
        !          29155:        case DOT:
        !          29156:                eprint(e1);
        !          29157:                puttok(base);
        !          29158:                if (mem == 0) {
        !          29159:                        fprintf(out_file,"MEM0");
        !          29160:                        break;
        !          29161:                }
        !          29162:                if (mem->base == NAME)
        !          29163:                        Pname(mem)->print();
        !          29164:                else
        !          29165:                        mem->print();
        !          29166:                break;
        !          29167: 
        !          29168:        case MEMPTR:
        !          29169:                error("P toMF not called");
        !          29170:                break;
        !          29171: 
        !          29172:        case VALUE:
        !          29173:                tp2->print();
        !          29174:                puttok(LP);
        !          29175: 
        !          29176: //             if (e2) {
        !          29177: //                     putstring(" &");
        !          29178: //                     e2->print();
        !          29179: //                     putstring(", ");
        !          29180: //             }
        !          29181:                if (e1) e1->print();
        !          29182:                puttok(RP);
        !          29183:                break;
        !          29184: 
        !          29185:        case SIZEOF:
        !          29186:                puttok(SIZEOF);
        !          29187:                if (e1 && e1!=dummy) {
        !          29188:                        eprint(e1);
        !          29189:                }
        !          29190:                else if (tp2) {
        !          29191:                        putch('(');
        !          29192:                        if (tp2->base == CLASS) {
        !          29193:                                Pclass cl = Pclass(tp2);
        !          29194:                                putstring((cl->csu == UNION)?"union ":"struct ");
        !          29195:                                char *str = 0;
        !          29196:                                // nested local class does not encode name
        !          29197:                                if ( cl->lex_level && cl->nested_sig == 0 ) 
        !          29198:                                        str = make_local_name( cl );
        !          29199:                                putstring(str?str:(cl->nested_sig?cl->nested_sig:cl->string));
        !          29200:                                delete str;
        !          29201:                        }
        !          29202:                        else
        !          29203:                                tp2->print();
        !          29204:                        putch(')');
        !          29205:                }
        !          29206:                break;
        !          29207: 
        !          29208: /*
        !          29209: // always turned into function calls:
        !          29210:         case NEW:
        !          29211:         case GNEW:
        !          29212: // error('d',"print new %d tp2 %t e1 %d e2 %d",base,tp2,e1,e2);
        !          29213:                puttok(NEW);
        !          29214:                tp2->print();
        !          29215:                if (e1) {
        !          29216:                        putch('(');
        !          29217:                        e1->print();
        !          29218:                        putch(')');
        !          29219:                }
        !          29220:                break;
        !          29221: 
        !          29222:        case DELETE:
        !          29223:         case GDELETE:
        !          29224: //error('d',"print delete");
        !          29225:                puttok(DELETE);
        !          29226:                e1->print();
        !          29227:                break;
        !          29228: */
        !          29229:        case CAST:
        !          29230:                putch('(');
        !          29231: //error('d',"print cast %t",tp2);
        !          29232:                if (tp2->base != VOID && tp2->memptr() == 0 ) {
        !          29233:                         // when VOID is represented as CHAR not everything
        !          29234:                         // can be cast to VOID
        !          29235:                        putch('(');
        !          29236:                        bit oc = Cast;
        !          29237:                        Cast = 1;
        !          29238:                        tp2->print();
        !          29239:                        Cast = oc;
        !          29240:                        putch(')');     
        !          29241:                }
        !          29242:                eprint(e1);
        !          29243:                putch(')');
        !          29244:                break;
        !          29245: 
        !          29246:        case ICON:
        !          29247:        case FCON:
        !          29248:        case CCON:
        !          29249:        case ID:
        !          29250:                if (string) putst(string);
        !          29251:                break;
        !          29252: 
        !          29253:        case STRING:
        !          29254:                 // avoid printing very long lines
        !          29255:                 ntok += 4;
        !          29256:                fprintf(out_file,"\"%s\"",string);
        !          29257:                break;
        !          29258: 
        !          29259:        case THIS:
        !          29260:        case ZERO:
        !          29261:                putstring("0 ");
        !          29262:                break;
        !          29263: 
        !          29264:        case IVAL:
        !          29265:                fprintf(out_file,"%d",i1);
        !          29266:                break;
        !          29267: 
        !          29268:        case TEXT:
        !          29269:        {
        !          29270:                int oo = vtbl_opt;      // make `simulated static' name
        !          29271:                vtbl_opt = -1;  
        !          29272:                char* s = vtbl_name(string,string2);
        !          29273:                vtbl_opt = oo;
        !          29274:                s[2] = 'p';     // pointer, not tbl itself
        !          29275:                 char* t = ptbl_lookup(s);
        !          29276:                 fprintf(out_file, " %s",t);
        !          29277:                delete t;
        !          29278: 
        !          29279:                char *str = 0;
        !          29280:                if ( string ) { 
        !          29281:                        str = new char[ strlen(string) + strlen(string2) + 1 ];
        !          29282:                        strcpy( str, string );
        !          29283:                        strcat( str, string2 );
        !          29284:                }
        !          29285: 
        !          29286:                if ( ptbl->look( str?str:string2, 0 ) == 0 &&
        !          29287:                     ptbl->look( str?str:string2, HIDDEN ) == 0 ) {
        !          29288:                        Pname nn = ptbl->insert(new name(str?str:string2),0);
        !          29289:                        nn->string2 = new char[strlen(s)+1];
        !          29290:                        strcpy(nn->string2,s);
        !          29291:                }
        !          29292: 
        !          29293:                delete str;
        !          29294:                delete s;
        !          29295:        }
        !          29296:                // no break;
        !          29297: 
        !          29298:        case DUMMY:
        !          29299:                break;
        !          29300: 
        !          29301:        case G_CALL:
        !          29302:        case CALL:
        !          29303:        {       Pname fn = fct_name;
        !          29304:                Pname at;
        !          29305:                int m_ptr = 0;
        !          29306: 
        !          29307:                if (fn) {
        !          29308:                        Pfct f = Pfct(fn->tp);
        !          29309: 
        !          29310:                        if (f->base==OVERLOAD) {        // overloaded after call
        !          29311:                                fct_name = fn = Pgen(f)->fct_list->f;
        !          29312:                                f = Pfct(fn->tp);
        !          29313:                        }
        !          29314: 
        !          29315:                        fn->print();
        !          29316:                        at = f->f_args;
        !          29317:                }
        !          29318:                else {
        !          29319:                        Pfct f = Pfct(e1->tp);
        !          29320: 
        !          29321:                        if (f) {        // pointer to fct
        !          29322:                                Pexpr exex = e1;
        !          29323:                                if ( exex->base == DEREF ) {
        !          29324:                                        exex = exex->e1;
        !          29325:                                        while ( exex->base == CAST )
        !          29326:                                                        exex = exex->e1;
        !          29327:                                        if ( exex->base == MDOT )
        !          29328:                                                        m_ptr = 1;
        !          29329:                                }
        !          29330: 
        !          29331:                                if (f->base == OVERLOAD) { // overloaded after call
        !          29332:                                        fct_name = fn = Pgen(f)->fct_list->f;
        !          29333:                                        f = Pfct(fn->tp);
        !          29334:                                }
        !          29335: 
        !          29336:                                while (f->base == TYPE) f = Pfct(Pbase(f)->b_name->tp);
        !          29337:                                if (f->base == PTR) {
        !          29338:                                        putstring("(*");
        !          29339:                                        e1->print();
        !          29340:                                        putch(')');
        !          29341:                                        f = Pfct(Pptr(f)->typ);
        !          29342:                                        while (f->base == TYPE) f = Pfct(Pbase(f)->b_name->tp);
        !          29343:                                }
        !          29344:                                else
        !          29345:                                        eprint(e1);
        !          29346: 
        !          29347:                        //      at = (f->f_result) ? f->f_result : f->argtype;
        !          29348:                                at = f->f_args;
        !          29349:                        }
        !          29350:                        else {  // virtual: argtype encoded
        !          29351:                                // f_this already linked to f_result and/or argtype
        !          29352:                                at = (e1->base==QUEST) ? Pname(e1->e1->tp2) : Pname(e1->tp2);
        !          29353:                                eprint(e1);
        !          29354:                        }
        !          29355:                }
        !          29356: 
        !          29357:                puttok(LP);
        !          29358: 
        !          29359:                if (e2) {
        !          29360:                        if (at) {
        !          29361:                                Pexpr e = e2;
        !          29362:                                while (at) {
        !          29363:                                        Pexpr ex;
        !          29364:                                        Ptype t = at->tp;
        !          29365: 
        !          29366:                                        if (t == 0) error('i',"T ofA missing for%n",fn);
        !          29367:                                        if (e == 0) error('i',"%tA missing for%n",t,fn);
        !          29368:                                        if (e->base == ELIST) {
        !          29369:                                                ex = e->e1;
        !          29370:                                                e =  e->e2;
        !          29371:                                        }
        !          29372:                                        else
        !          29373:                                                ex = e;
        !          29374: 
        !          29375:                                        if (ex == 0) error('i',"A ofT%t missing",t);
        !          29376:                                        if (t!=ex->tp
        !          29377:                                        && ex->tp
        !          29378:                                        && t->check(ex->tp,0)
        !          29379:                                        && t->is_cl_obj()==0
        !          29380:                                        && eobj==0
        !          29381:                                        && m_ptr == 0
        !          29382:                                        && (t->is_ptr()==0 || Mptr==0)) {
        !          29383:                                                putch('(');
        !          29384:                                                bit oc = Cast;
        !          29385:                                                Cast = 1;
        !          29386:                                                t->print();
        !          29387:                                                Cast = oc;
        !          29388:                                                putch(')');
        !          29389: #ifdef sun
        !          29390: if (ex->base == DIV) { // defend against perverse SUN cc bug
        !          29391:        putstring("(0+");
        !          29392:        eprint(ex);
        !          29393:        putch(')');
        !          29394: }
        !          29395: else
        !          29396: #endif
        !          29397:                                                // eprint(ex);
        !          29398:                                        //      if (ex->base==CAST) {
        !          29399:                                        //              eprint(ex->e1);
        !          29400:                                        //      }
        !          29401:                                        //      else
        !          29402:                                                        eprint(ex);
        !          29403:                                        }
        !          29404:                                        else
        !          29405:                                                ex->print();
        !          29406: 
        !          29407:                                        // if m_ptr is set, then don't advance at
        !          29408:                                        // at does not know about generated `this'
        !          29409:                                        if ( m_ptr ) {
        !          29410:                                                m_ptr = 0;
        !          29411:                                                if (at) puttok(CM);
        !          29412:                                                continue;
        !          29413:                                        }
        !          29414: 
        !          29415:                                        at = at->n_list;
        !          29416:                                        if (at) puttok(CM);
        !          29417:                                }
        !          29418:                                if (e) {
        !          29419:                                        puttok(CM);
        !          29420:                                        e->print();
        !          29421:                                }                
        !          29422:                        }
        !          29423:                        else
        !          29424:                                e2->print();
        !          29425:                }
        !          29426:                puttok(RP);
        !          29427:                break;
        !          29428:        }
        !          29429: 
        !          29430:        case ASSIGN:
        !          29431:                if (e1->base==ANAME && Pname(e1)->n_assigned_to==FUDGE111) {
        !          29432:                // suppress assignment to "this" that has been optimized away
        !          29433:                        Pname n = Pname(e1);
        !          29434:                        int argno = int(n->n_val);
        !          29435:                        for (Pin il=curr_icall; il; il=il->i_next)
        !          29436:                                if (il->i_table == n->n_table) goto akk;
        !          29437:                        goto bkk;
        !          29438:                akk:
        !          29439:                        if (il->i_args[argno].local == 0) {
        !          29440:                                e2->print();
        !          29441:                                break;
        !          29442:                        }
        !          29443:                }
        !          29444:                //no break
        !          29445:        case EQ:
        !          29446:        case NE:
        !          29447:        case GT:
        !          29448:        case GE:
        !          29449:        case LE:
        !          29450:        case LT:
        !          29451:        bkk:
        !          29452:        {       Ptype t1 = e1->tp;
        !          29453:                Ptype t2 = e2->tp;
        !          29454: 
        !          29455:                 if (base!=ASSIGN) {
        !          29456:                        cprint(e1);
        !          29457:                }
        !          29458:                else
        !          29459:                        eprint(e1);
        !          29460:                puttok(base);
        !          29461: 
        !          29462:                if (t1 && t1!=t2 && e2->base!=ZERO) {
        !          29463:                        // cast, but beware of int!=long etc.
        !          29464:                cmp:
        !          29465:                        switch (t1->base) {
        !          29466:                        case TYPE:
        !          29467:                                t1 = Pbase(t1)->b_name->tp;
        !          29468:                                goto cmp;
        !          29469:                        default:
        !          29470:                         //        if (e2->base==NAME
        !          29471:                         //        && Pname(e2)->n_evaluated==0
        !          29472:                         //        && e2->tp->base==EOBJ)
        !          29473:                         //                fprintf(out_file,"(int)");
        !          29474:                                 break;
        !          29475:                     //    case EOBJ:
        !          29476:                     //           if (base==ASSIGN) goto cst;
        !          29477:                     //          break;
        !          29478:                        case PTR:
        !          29479:                        case RPTR:
        !          29480:                        case VEC:
        !          29481:                                if (t2)
        !          29482:                                        while ( t2->base == TYPE ) 
        !          29483:                                                t2 = Pbase(t2)->b_name->tp;
        !          29484: 
        !          29485:                                if (e2->tp==0
        !          29486:                                || (Pptr(t1)->typ!=Pptr(t2)->typ && t1->check(t2,0))) {
        !          29487:                    //     cst:
        !          29488:                                        putch('(');
        !          29489:                                        bit oc = Cast;
        !          29490:                                        Cast = 1;
        !          29491:                                        e1->tp->print();
        !          29492:                                        Cast = oc;
        !          29493:                                        putch(')');     
        !          29494:                                }
        !          29495:                        }
        !          29496:                }
        !          29497: 
        !          29498:                eprint(e2);
        !          29499:                break;
        !          29500:        }
        !          29501: 
        !          29502:        case DEREF:
        !          29503:                if (e2) {
        !          29504: 
        !          29505:                        eprint(e1);
        !          29506:                        putch('[');
        !          29507:                        cprint(e2);
        !          29508:                        putch(']');
        !          29509:                }
        !          29510:                else {
        !          29511:                         putch('(');
        !          29512:                        putch('*');
        !          29513:                        eprint(e1);
        !          29514:                         putch(')');
        !          29515:                }
        !          29516:                break;
        !          29517: 
        !          29518:        case ILIST:
        !          29519:                puttok(LC);
        !          29520:                if (e1) e1->print();
        !          29521:                if (e2) {       // member pointer initiliazers
        !          29522:                        puttok(CM);
        !          29523:                        e2->print();
        !          29524:                }
        !          29525:                puttok(RC);
        !          29526:                break;
        !          29527: 
        !          29528:        case ELIST:
        !          29529:        {       Pexpr e = this;
        !          29530:                for(;;) {
        !          29531:                        if (e->base == ELIST) {
        !          29532:                                e->e1->print();
        !          29533:                                if (e = e->e2) {
        !          29534:                                        puttok(CM);
        !          29535:                                }
        !          29536:                                else
        !          29537:                                        return;
        !          29538:                        }
        !          29539:                        else {
        !          29540:                                e->print();
        !          29541:                                return;
        !          29542:                        }
        !          29543:                }
        !          29544:        }
        !          29545: 
        !          29546:        case QUEST:
        !          29547:        {       // look for (&a == 0) etc.
        !          29548:                Neval = 0;
        !          29549:                binary_val = 1;
        !          29550:                long i = cond->eval();
        !          29551:                binary_val = 0;
        !          29552:                if (Neval == 0)
        !          29553:                        (i?e1:e2)->print();
        !          29554:                else {
        !          29555:                        eprint(cond);
        !          29556:                        putch('?');
        !          29557:                        cprint(e1);
        !          29558:                        putch(':');
        !          29559:                        cprint(e2);
        !          29560:                }
        !          29561:                break;
        !          29562:        }
        !          29563: 
        !          29564:        case CM:        // do &(a,b) => (a,&b) for previously checked inlines
        !          29565:        case G_CM:
        !          29566:                puttok(LP);
        !          29567:                switch (e1->base) {
        !          29568:                case ZERO:
        !          29569:                case IVAL:
        !          29570:                case ICON:
        !          29571:                case NAME:
        !          29572:                case MDOT:
        !          29573:                case DOT:
        !          29574:                case REF:
        !          29575:                case FCON:
        !          29576:                // case FVAL:
        !          29577:                case STRING:
        !          29578:                        goto le2;       // suppress constant a: &(a,b) => (&b)
        !          29579:                default:
        !          29580:                        {       int oo = addrof_cm;     // &(a,b) does not affect a
        !          29581:                                addrof_cm = 0;
        !          29582:                                eprint(e1);
        !          29583:                                addrof_cm = oo;
        !          29584:                        }
        !          29585:                        puttok(CM);
        !          29586:                le2:
        !          29587:                        if (addrof_cm) {
        !          29588:                                switch (e2->base) {
        !          29589:                                case CAST:
        !          29590:                                        if (e2->e2)
        !          29591:                                        switch (e2->e2->base) {
        !          29592:                                        case CM:
        !          29593:                                        case G_CM:
        !          29594:                                        case ICALL:     goto ec;
        !          29595:                                        }
        !          29596:                                case NAME:
        !          29597:                                case MDOT:
        !          29598:                                case DOT:
        !          29599:                                case DEREF:
        !          29600:                                case REF:
        !          29601:                                case ANAME:
        !          29602:                                        puttok(ADDROF);
        !          29603:                                        addrof_cm--;
        !          29604:                                        eprint(e2);
        !          29605:                                        addrof_cm++;
        !          29606:                                        break;
        !          29607:                                case ICALL:
        !          29608:                //              case CALL:
        !          29609:                                case CM:
        !          29610:                                case G_CM:
        !          29611:                                ec:
        !          29612:                                        eprint(e2);
        !          29613:                                        break;
        !          29614:                                case G_CALL:
        !          29615:                                        /* & ( e, ctor() ) with temporary optimized away */
        !          29616:                                        if (e2->fct_name
        !          29617:                                        && e2->fct_name->n_oper==CTOR) {
        !          29618:                                                addrof_cm--;
        !          29619:                                                eprint(e2);
        !          29620:                                                addrof_cm++;
        !          29621:                                                break;
        !          29622:                                        }
        !          29623:                                default:
        !          29624:                                        error('i',"& inlineF call (%k)",e2->base);
        !          29625:                                }
        !          29626:                        }
        !          29627:                        else
        !          29628:                        //      e2->print();
        !          29629:                                eprint(e2);
        !          29630:                        puttok(RP);
        !          29631:                }
        !          29632:                break;
        !          29633: 
        !          29634:        case UPLUS: // only preserved for ansi_opt==1
        !          29635:        case UMINUS:
        !          29636:        case NOT:
        !          29637:        case COMPL:
        !          29638:         //      puttok(base);
        !          29639:         //      eprint(e2);
        !          29640:         //      break;
        !          29641:                 goto op2;
        !          29642:        case ADDROF:
        !          29643:        case G_ADDROF:
        !          29644:                switch (e2->base) {     // & *e1 or &e1[e2]
        !          29645:                case DEREF:
        !          29646:                        if (e2->e2 == 0) {      // &*e == e
        !          29647:                                e2->e1->print();
        !          29648:                                return;
        !          29649:                        }
        !          29650:                        break;
        !          29651:                case ICALL:
        !          29652:                        addrof_cm++;    // assumes inline expanded into ,-expression
        !          29653:                        eprint(e2);
        !          29654:                        addrof_cm--;
        !          29655:                        return;
        !          29656:                case ASSIGN:            // &(a=b)       ??? works on many cc s
        !          29657:                        eprint(e2);     // make sure it breaks!
        !          29658:                        return;
        !          29659:                case NAME: {
        !          29660:                        Pname n = Pname(e2);
        !          29661:                        if(n->n_evaluated) {
        !          29662:                                n->n_evaluated=0;
        !          29663:                                puttok(ADDROF);
        !          29664:                                eprint(e2);
        !          29665:                                n->n_evaluated=1;
        !          29666:                                return;
        !          29667:                        }
        !          29668:                        break;
        !          29669:                        }
        !          29670:                }
        !          29671: 
        !          29672:                // suppress cc warning on &fct
        !          29673:                if (e2->tp==0 || e2->tp->base!=FCT) puttok(ADDROF);
        !          29674: 
        !          29675:                eprint(e2);
        !          29676:                break;
        !          29677: 
        !          29678:        case PLUS:
        !          29679:        case MINUS:
        !          29680:        case MUL:
        !          29681:        case DIV:
        !          29682:        case MOD:
        !          29683:        case LS:
        !          29684:        case RS:
        !          29685:        case AND:
        !          29686:        case OR:
        !          29687:        case ER:
        !          29688:        case ANDAND:
        !          29689:        case OROR:
        !          29690:         case DECR:
        !          29691:         case INCR:
        !          29692:                 cprint(e1);
        !          29693:         op2:
        !          29694:                puttok(base);
        !          29695:                cprint(e2);
        !          29696:                 break;
        !          29697:        case ASOR:
        !          29698:        case ASER:
        !          29699:        case ASAND:
        !          29700:        case ASPLUS:
        !          29701:        case ASMINUS:
        !          29702:        case ASMUL:
        !          29703:        case ASMOD:
        !          29704:        case ASDIV:
        !          29705:        case ASLS:
        !          29706:        case ASRS:
        !          29707:                 eprint(e1);
        !          29708:                 goto op2;
        !          29709: 
        !          29710:        default:
        !          29711:                error('i',"%p->E::print%k",this,base);
        !          29712:        //      fprintf(out_file," EEE(%d) ",base);
        !          29713:        }
        !          29714: }
        !          29715: 
        !          29716: Pexpr aval(Pname a)
        !          29717: {
        !          29718:        int argno = int(a->n_val);
        !          29719:        Pin il;
        !          29720:        for (il=curr_icall; il; il=il->i_next)
        !          29721:                if (il->i_table == a->n_table) goto aok;
        !          29722:        return 0;
        !          29723: aok:
        !          29724:        Pexpr aa = il->i_args[argno].arg;
        !          29725: ll:
        !          29726:        switch (aa->base) {
        !          29727:        case CAST:      aa = aa->e1; goto ll;
        !          29728:        case ANAME:     return aval(Pname(aa));
        !          29729:        default:        return aa;
        !          29730:        }
        !          29731: }
        !          29732: 
        !          29733: #define putcond()      putch('('); e->print(); putch(')')
        !          29734: 
        !          29735: static loc csloc = { 0, 0 }; // loc of last stmt with line!=0
        !          29736: 
        !          29737: void stmt::print()
        !          29738: {
        !          29739: //error('d',"S::print %d:%k s %d s_list %d",this,base,s,s_list);
        !          29740:        if (where.line == 0) {
        !          29741:            if (csloc.line) csloc.putline();
        !          29742:        } else {
        !          29743:            csloc = where;
        !          29744:            if (where.line!=last_line.line)
        !          29745:                if (last_ll = where.line)
        !          29746:                        where.putline();
        !          29747:                else
        !          29748:                        last_line.putline();
        !          29749:        }
        !          29750: 
        !          29751:        if (memtbl && base!=BLOCK) { /* also print declarations of temporaries */
        !          29752:                puttok(LC);
        !          29753:                Ptable tbl = memtbl;
        !          29754:                memtbl = 0;
        !          29755:                int i;
        !          29756:                int bl = 1;
        !          29757:                for (Pname n=tbl->get_mem(i=1); n; n=tbl->get_mem(++i)){
        !          29758:                        if (n->tp == any_type) continue;
        !          29759:                        /* avoid double declarartion of temporaries from inlines */
        !          29760:                        char* s = n->string;
        !          29761:                        if (s[0]!='_' || s[1]!='_' || s[2]!='X') {
        !          29762:                                n->dcl_print(0);
        !          29763:                                bl = 0;
        !          29764:                        }
        !          29765:                        Pname cn;
        !          29766:                        if (bl
        !          29767:                        && (cn=n->tp->is_cl_obj())
        !          29768:                        && Pclass(cn->tp)->has_dtor()) bl = 0;
        !          29769:                }
        !          29770:                if ( last_ll==0 && (last_ll = where.line) )
        !          29771:                        where.putline();
        !          29772:                if (bl) {
        !          29773:                        Pstmt sl = s_list;
        !          29774:                        s_list = 0;
        !          29775:                        print();
        !          29776:                        memtbl = tbl;
        !          29777:                        puttok(RC);
        !          29778:                        if (sl) {
        !          29779:                                s_list = sl;
        !          29780:                                sl->print();
        !          29781:                        }
        !          29782:                }
        !          29783:                else {
        !          29784:                        print();
        !          29785:                        memtbl = tbl;
        !          29786:                        puttok(RC);
        !          29787:                }
        !          29788:                return;
        !          29789:        }
        !          29790: 
        !          29791:        switch (base) {
        !          29792:        default:
        !          29793:                error('i',"S::print(base=%k)",base);
        !          29794: 
        !          29795:        case ASM:
        !          29796:                fprintf(out_file,"asm(\"%s\");\n",(char*)e);
        !          29797:                break;
        !          29798: 
        !          29799:        case DCL:
        !          29800:                d->dcl_print(SM);
        !          29801:                break;
        !          29802: 
        !          29803:        case BREAK:
        !          29804:        case CONTINUE:
        !          29805:                puttok(base);
        !          29806:                puttok(SM);
        !          29807:                break;
        !          29808: 
        !          29809:        case DEFAULT:
        !          29810:                puttok(base);
        !          29811:                //puttok(COLON);
        !          29812:                putch(':');
        !          29813:                s->print();
        !          29814:                break;
        !          29815: 
        !          29816:        case SM:
        !          29817:                if (e) {
        !          29818:                        e->print();
        !          29819:                        if (e->base==ICALL && e->e2) break;     /* a block: no SM */
        !          29820:                }
        !          29821:                puttok(SM);
        !          29822:                break;
        !          29823: 
        !          29824:        case WHILE:
        !          29825:                puttok(WHILE);
        !          29826:                putcond();
        !          29827:                if (s->s_list) {
        !          29828:                        puttok(LC);
        !          29829:                        s->print();
        !          29830:                        puttok(RC);
        !          29831:                }
        !          29832:                else
        !          29833:                        s->print();
        !          29834:                break;
        !          29835: 
        !          29836:        case DO:
        !          29837:                puttok(DO);
        !          29838:                s->print();
        !          29839:                puttok(WHILE);
        !          29840:                putcond();
        !          29841:                puttok(SM);
        !          29842:                break;
        !          29843: 
        !          29844:        case SWITCH:
        !          29845:                puttok(SWITCH);
        !          29846:                putcond();
        !          29847:                s->print();
        !          29848:                break;
        !          29849: 
        !          29850:        case RETURN:
        !          29851:                {
        !          29852:                puttok(RETURN);
        !          29853:                if (e) {
        !          29854: //error('d',"print return rt %t etp %t",ret_tp,e->tp);
        !          29855:                        if (ret_tp && ret_tp!=e->tp) {
        !          29856:                                Ptype tt = ret_tp;
        !          29857:                        gook:
        !          29858:                                switch (tt->base) {
        !          29859:                                case TYPE:
        !          29860:                                        tt = Pbase(tt)->b_name->tp;
        !          29861:                                        goto gook;
        !          29862:                                case COBJ:
        !          29863:                                        break;  // cannot cast to struct
        !          29864:                                case RPTR:
        !          29865:                                case PTR:
        !          29866:                                        if (Pptr(tt)->typ==Pptr(e->tp)->typ) break;
        !          29867:                                        if (Pptr(tt)->memof) break;
        !          29868:                                default:
        !          29869:                                        if (e->tp==0 || ret_tp->check(e->tp,0)) {
        !          29870:                                                int oc = Cast;
        !          29871:                                                putch('(');
        !          29872:                                                Cast = 1;
        !          29873:                                                ret_tp->print();
        !          29874:                                                Cast = oc;
        !          29875:                                                putch(')');
        !          29876:                                        }
        !          29877:                                }
        !          29878:                        }
        !          29879:                        eprint(e);
        !          29880:                }
        !          29881:                puttok(SM);
        !          29882:                }
        !          29883:                while (s_list && s_list->base==SM) s_list = s_list->s_list; // FUDGE!!
        !          29884:                break;
        !          29885: 
        !          29886:        case CASE:
        !          29887:                puttok(CASE);
        !          29888:                eprint(e);
        !          29889:                putch(':');
        !          29890:                s->print();
        !          29891:                break;
        !          29892: 
        !          29893:        case GOTO:
        !          29894:                puttok(GOTO);
        !          29895:                d->print();
        !          29896:                puttok(SM);
        !          29897:                break;
        !          29898: 
        !          29899:        case LABEL:
        !          29900:                d->print();
        !          29901:                putch(':');
        !          29902:                s->print();
        !          29903:                break;
        !          29904: 
        !          29905:        case IF:
        !          29906:        {       int val = QUEST;
        !          29907:                if (e->base == ANAME) {
        !          29908:                        Pname a = Pname(e);
        !          29909:                        Pexpr arg = aval(a);
        !          29910: //error('d',"arg %d%k %d (%d)",arg,arg?arg->base:0,arg?arg->base:0,arg?arg->e1:0);
        !          29911:                        if (arg)
        !          29912:                                switch (arg->base) {
        !          29913:                                case ZERO:      val = 0; break;
        !          29914:                                case ADDROF:
        !          29915:                                case G_ADDROF:  val = 1; break;
        !          29916:                                case IVAL:      val = arg->i1!=0;
        !          29917:                        }
        !          29918:                }
        !          29919: //error('d',"val %d",val);
        !          29920:                switch (val) {
        !          29921:                case 1:
        !          29922:                        s->print();
        !          29923:                        break;
        !          29924:                case 0:
        !          29925:                        if (else_stmt)
        !          29926:                                else_stmt->print();
        !          29927:                        else
        !          29928:                                puttok(SM);     /* null statement */
        !          29929:                        break;
        !          29930:                default:
        !          29931:                        puttok(IF);
        !          29932:                        putcond();
        !          29933:                        if (s->s_list) {
        !          29934:                                puttok(LC);
        !          29935:                                s->print();
        !          29936:                                puttok(RC);
        !          29937:                        }
        !          29938:                        else
        !          29939:                                s->print();
        !          29940:                        if (else_stmt) {
        !          29941:                                if (else_stmt->where.line == 0) {
        !          29942:                                    if (csloc.line) csloc.putline();
        !          29943:                                } else {
        !          29944:                                    csloc = else_stmt->where;
        !          29945:                                    if (else_stmt->where.line!=last_line.line)
        !          29946:                                        if (last_ll = else_stmt->where.line)
        !          29947:                                                else_stmt->where.putline();
        !          29948:                                        else
        !          29949:                                                last_line.putline();
        !          29950:                                }
        !          29951:                                puttok(ELSE);
        !          29952:                                if (else_stmt->s_list) {
        !          29953:                                        puttok(LC);
        !          29954:                                        else_stmt->print();
        !          29955:                                        puttok(RC);
        !          29956:                                }
        !          29957:                                else
        !          29958:                                        else_stmt->print();
        !          29959:                        }
        !          29960:                }
        !          29961:                break;
        !          29962:        }
        !          29963: 
        !          29964:        case FOR:
        !          29965:        {
        !          29966:        //      int fi = for_init && ((for_init->base!=SM || for_init->memtbl || for_init->s_list);
        !          29967:                int fi = 0;     // is the initializer statement an expression?
        !          29968:                if (for_init) {
        !          29969:                        fi = 1;
        !          29970:                        if (for_init->memtbl==0 && for_init->s_list==0)
        !          29971:                                if (for_init->base==SM)
        !          29972:                                        if (for_init->e->base!=ICALL || for_init->e->e1)
        !          29973:                                                fi = 0;
        !          29974:                }
        !          29975: //error('d',"for(; %d%k; %d%k)",e,e->base,e2,e2->base);
        !          29976:                if (fi) {
        !          29977:                        puttok(LC);
        !          29978:                        for_init->print();
        !          29979:                }
        !          29980:                putstring("for(");
        !          29981:                if (fi==0 && for_init) for_init->e->print();
        !          29982:                putch(';');     // to avoid newline: not puttok(SM)
        !          29983:                if (e) e->print();
        !          29984:                putch(';');
        !          29985:                if (e2) e2->print();
        !          29986:                puttok(RP);
        !          29987:                s->print();
        !          29988:                if (fi) puttok(RC);
        !          29989:                break;
        !          29990:        }
        !          29991: 
        !          29992:        case PAIR:
        !          29993:                if (s&&s2) {
        !          29994:                        puttok(LC);
        !          29995:                        s->print();
        !          29996:                        s2->print();
        !          29997:                        puttok(RC);
        !          29998:                }
        !          29999:                else {
        !          30000:                        if (s) s->print();
        !          30001:                        if (s2) s2->print();
        !          30002:                }
        !          30003:                break;
        !          30004: 
        !          30005:        case BLOCK:
        !          30006:                puttok(LC);
        !          30007: //error('d',"block %d d %d memtbl %d own_tbl %d",this,d,memtbl,own_tbl);
        !          30008:                if (d) d->dcl_print(SM);
        !          30009:                if (memtbl && own_tbl) {
        !          30010:                        Pname n;
        !          30011:                        int i;
        !          30012:                        for (n=memtbl->get_mem(i=1); n; n=memtbl->get_mem(++i)) {
        !          30013:                                if (n->tp && n->n_union==0 && n->tp!=any_type)
        !          30014:                                        switch (n->n_scope) {
        !          30015:                                        case ARGT:
        !          30016:                                        case ARG:
        !          30017:                                                break;
        !          30018:                                        default:
        !          30019: // error('d', "n: %s %k n_key: %k", n->string, n->base, n->n_key);
        !          30020:                                                if ( n->base == TNAME && n->n_key == NESTED ) 
        !          30021:                                                        continue; // printed from nested class
        !          30022:                                                n->dcl_print(0);
        !          30023:                                        }
        !          30024:                        }
        !          30025:                        if (last_ll==0 && s && (last_ll=s->where.line))
        !          30026:                                s->where.putline();
        !          30027:                }
        !          30028:                if (s) s->print();
        !          30029:                if (where2.line == 0) {
        !          30030:                    if (csloc.line) csloc.putline();
        !          30031:                } else {
        !          30032:                    csloc = where2;
        !          30033:                    if (where2.line!=last_line.line)
        !          30034:                        if (last_ll = where2.line)
        !          30035:                                where2.putline();
        !          30036:                        else
        !          30037:                                last_line.putline();
        !          30038:                }
        !          30039:                putstring("}\n");
        !          30040:                if (last_ll && where.line) last_line.line++;
        !          30041:        }
        !          30042: 
        !          30043:        if (s_list) s_list->print();
        !          30044: }
        !          30045: 
        !          30046: /*
        !          30047: void table::dcl_print(TOK s, TOK pub)
        !          30048: 
        !          30049: //     print the declarations of the entries in the order they were inserted
        !          30050: //     ignore labels (tp==0)
        !          30051: 
        !          30052: {
        !          30053:        register Pname* np;
        !          30054:        register int i;
        !          30055: 
        !          30056:        if (this == 0) return;
        !          30057: 
        !          30058:        np = entries;
        !          30059:        for (i=1; i<free_slot; i++) {
        !          30060:                register Pname n = np[i];
        !          30061:                switch (s) {
        !          30062:                case 0:
        !          30063:                        n->dcl_print(0);
        !          30064:                        break;
        !          30065:                case EQ:
        !          30066:                        if (n->tp && n->n_scope == pub) n->dcl_print(0);
        !          30067:                        break;
        !          30068:                case NE:
        !          30069:                        if (n->tp && n->n_scope != pub) n->dcl_print(0);
        !          30070:                        break;
        !          30071:                }
        !          30072:        }
        !          30073: }
        !          30074: */
        !          30075: 
        !          30076: struct ptbl_rec {
        !          30077:       char* pname;
        !          30078:       char* vname;
        !          30079:       ptbl_rec* next;
        !          30080: };
        !          30081: 
        !          30082: static char* ptbl_name;
        !          30083: static ptbl_rec* ptbl_rec_lookup_head = 0;
        !          30084: static ptbl_rec* ptbl_rec_pair_head = 0;
        !          30085: 
        !          30086: void ptbl_init(int flag)
        !          30087: {
        !          30088:       if (!flag) {
        !          30089:              char *p = st_name( "__ptbl_vec__" );      
        !          30090:               ptbl_name = new char[strlen(p)+1];
        !          30091:               strcpy(ptbl_name, p);                         
        !          30092:               delete p;
        !          30093:               fprintf(out_file, "extern struct __mptr* %s[];\n", ptbl_name);
        !          30094:                if (last_ll) last_line.line++;
        !          30095:       }
        !          30096:       else {
        !          30097:               ptbl_rec *r, *p = ptbl_rec_lookup_head;
        !          30098:              if ( p == 0 ) return; // don't generate an empty object
        !          30099:               fprintf(out_file, "struct __mptr* %s[] = {\n", ptbl_name);
        !          30100:                if (last_ll) last_line.line++;
        !          30101:               int i = 0;
        !          30102:               while (p != 0) {
        !          30103:                       r = ptbl_rec_pair_head;
        !          30104:                       while (r && strcmp(r->pname, p->pname))
        !          30105:                               r = r->next;
        !          30106:                       fprintf(out_file, "%s,\n", r->vname);
        !          30107:                        if (last_ll) last_line.line++;
        !          30108:                       p = p->next;
        !          30109:               }
        !          30110:               // fprintf(out_file, "0\n};\n");
        !          30111:               fprintf(out_file, "\n};\n");
        !          30112:                if (last_ll) last_line.line += 2;
        !          30113:       }
        !          30114: }
        !          30115: 
        !          30116: char* ptbl_lookup(char *name)
        !          30117: {
        !          30118:       ptbl_rec *r, *s, *p = ptbl_rec_lookup_head;
        !          30119:       int i = 0;
        !          30120: 
        !          30121:       while (p && strcmp(name, p->pname)) {
        !          30122:               r = p;
        !          30123:               p = p->next;
        !          30124:               i++;
        !          30125:       }
        !          30126: 
        !          30127:       if (p == 0) {
        !          30128:               s = new ptbl_rec;
        !          30129:               s->pname = new char[strlen(name) + 1];
        !          30130:               s->vname = 0;
        !          30131:               s->next = 0;
        !          30132:               strcpy(s->pname, name);
        !          30133:               if (ptbl_rec_lookup_head == 0) 
        !          30134:                       ptbl_rec_lookup_head = s;
        !          30135:               else r->next = s;
        !          30136:       }
        !          30137: 
        !          30138:       char *pp = new char[ strlen(ptbl_name) + 10 ];   
        !          30139:       sprintf(pp, "%s[%d]", ptbl_name, i);
        !          30140:       return(pp);
        !          30141: }
        !          30142: 
        !          30143: void ptbl_add_pair(char* ptbl, char* vtbl)
        !          30144: {
        !          30145: // error('d', "ptbl_add_pair: ptbl: %s, vtbl: %s", ptbl, vtbl );
        !          30146:       ptbl_rec *p = new ptbl_rec;
        !          30147: 
        !          30148:       p->pname = new char[strlen(ptbl) + 1];
        !          30149:       strcpy(p->pname, ptbl);
        !          30150:       p->vname = new char[strlen(vtbl) + 1];
        !          30151: 
        !          30152:       strcpy(p->vname, vtbl);
        !          30153:       p->next = ptbl_rec_pair_head;
        !          30154: 
        !          30155:       ptbl_rec_pair_head = p;
        !          30156: }
        !          30157: 0707071010112044411004440001630000160000010205600466055406600001100000140076print2.c/*ident   "@(#)ctrans:src/print2.c        1.4" */
        !          30158: /**************************************************************************
        !          30159: 
        !          30160:        C++ source for cfront, the C++ compiler front-end
        !          30161:        written in the computer science research center of Bell Labs
        !          30162: 
        !          30163:        Copyright (c) 1984 AT&T, Inc. All Rights Reserved
        !          30164:        THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T, INC.
        !          30165: 
        !          30166: print2.c:
        !          30167: 
        !          30168:        print names and declarations
        !          30169: 
        !          30170: ****************************************************************************/
        !          30171: 
        !          30172: #include "cfront.h"
        !          30173: #include "template.h"
        !          30174: 
        !          30175: bit Cast;
        !          30176: int last_ll = 1;
        !          30177: Pin curr_icall;
        !          30178: char emode;
        !          30179: int ntok;
        !          30180: 
        !          30181: static int MAIN;       // fudge to get _main() called by main()
        !          30182: 
        !          30183: #define eprint(e) if (e) Eprint(e)
        !          30184: 
        !          30185: #ifdef DENSE
        !          30186: void chop(char*);
        !          30187: #endif
        !          30188: 
        !          30189: void puttok(TOK t)
        !          30190: /*
        !          30191:        print the output representation of "t"
        !          30192: */
        !          30193: {
        !          30194: //     if (t<=0 || MAXTOK<t) error("illegal token %d",t);
        !          30195: //     char* s = keys[t];
        !          30196: //     if (s == 0) error("V representation token %d",t);
        !          30197: 
        !          30198:        putstring(keys[t]);
        !          30199: 
        !          30200:        if (12<ntok++) {
        !          30201:                ntok = 0;
        !          30202:                last_line.putline();
        !          30203:        }
        !          30204:        else if (t == SM) {
        !          30205:                ntok = 0;
        !          30206:                putch('\n');
        !          30207:                if (last_ll) last_line.line++;
        !          30208:        }
        !          30209:        else
        !          30210:                putch(' ');
        !          30211: }
        !          30212: 
        !          30213: #define MX     20
        !          30214: #define NTBUF  10
        !          30215: class dcl_buf {
        !          30216:        /*
        !          30217:                buffer for assembling declaration (or cast)
        !          30218:                left contains CONST_PTR => *CONST
        !          30219:                             CONST_RPTR => &CONST
        !          30220:                                PTR     => *
        !          30221:                                RPTR    => &
        !          30222:                                LP      => (
        !          30223:                right contains  RP      => )
        !          30224:                                VEC     => [ rnode ]
        !          30225:                                FCT     => ( rnode )
        !          30226:                                FIELD   => : rnode
        !          30227:        */
        !          30228:        Pbase b;
        !          30229:        Pname n;
        !          30230:        TOK left[MX], right[MX];
        !          30231:        Pnode   rnode[MX];
        !          30232:        Pclass  lnode[MX];
        !          30233:        int li, ri;
        !          30234: public:
        !          30235:        void    init(Pname nn)          { b=0; n=nn; li=ri=0; }
        !          30236:        void    base(Pbase bb)          { b = bb; }
        !          30237:        void    front(TOK t)            { left[++li] = t; }
        !          30238:        void    front(Pclass c)         { left[++li] = MEMPTR; lnode[li] = c; }
        !          30239:        void    back(TOK t, Pnode nod)  { right[++ri] = t; rnode[ri] = nod; }
        !          30240:        void    paran()                 { front(LP); back(RP,0); }
        !          30241:        void    put();
        !          30242: } *tbufvec[NTBUF] = {0}, *tbuf = 0;
        !          30243: 
        !          30244: int freetbuf = 0;
        !          30245: 
        !          30246: void dcl_buf::put()
        !          30247: {
        !          30248:        int i;
        !          30249:        Pfct ff = 0;
        !          30250: 
        !          30251:        if (MX<=li || MX<=ri) error('i',"T buffer overflow");
        !          30252:        if (b == 0) error('i',"noBT%s",Cast?" in cast":"");
        !          30253: 
        !          30254:        if (n && n->n_sto && n->n_sto!=REGISTER) puttok(n->n_sto);
        !          30255: 
        !          30256:        b->dcl_print();
        !          30257:        
        !          30258:        for( ; li; li--) {
        !          30259:                switch (left[li]) {
        !          30260:                case LP:
        !          30261:                        putch('(');
        !          30262:                        break;
        !          30263:                case PTR:
        !          30264:                        putch('*');
        !          30265:                        break;
        !          30266:                case RPTR:
        !          30267:                        if (emode)
        !          30268:                                putch('&');
        !          30269:                        else
        !          30270:                                putch('*');
        !          30271:                        break;
        !          30272:                case CONST_PTR:
        !          30273:                        if (emode)
        !          30274:                                putstring("*const ");
        !          30275:                        else
        !          30276:                                putch('*');
        !          30277:                        break;
        !          30278:                case CONST_RPTR:
        !          30279:                        if (emode)
        !          30280:                                putstring("&const ");
        !          30281:                        else
        !          30282:                                putch('*');
        !          30283:                        break;
        !          30284:                case MEMPTR:
        !          30285:                        if (lnode[li]) fprintf(out_file,"%s::",lnode[li]->string);
        !          30286:                }
        !          30287:        }
        !          30288: 
        !          30289:        if (n) n->print();
        !          30290: 
        !          30291:        for(i=1; i<=ri; i++) {
        !          30292:                switch (right[i]) {
        !          30293:                case RP:
        !          30294:                        putch(')');
        !          30295:                        break;
        !          30296:                case VEC:
        !          30297:                        putch('[');
        !          30298:                        {       Pvec v = (Pvec) rnode[i];
        !          30299:                                Pexpr d = v->dim;
        !          30300:                                int s = v->size;
        !          30301:                                if (d) d->print();
        !          30302:                                if (s) fprintf(out_file,"%d",s);
        !          30303:                        }
        !          30304:                        putch(']');
        !          30305:                        break;
        !          30306:                case FCT:       // beware of function returning pointer to
        !          30307:                                // function expressed witout typedef
        !          30308:                {       Pfct f = Pfct(rnode[i]);
        !          30309:                        if (f->body) ff = f;
        !          30310:                        f->dcl_print();
        !          30311:                        break;
        !          30312:                }
        !          30313:                case FIELD:
        !          30314:                 {       Pbase f = (Pbase) rnode[i];
        !          30315:                         Pexpr d = (Pexpr)f->b_name;
        !          30316:                         int s = f->b_bits;
        !          30317:                         putch(':');
        !          30318:                         if (d)
        !          30319:                                 d->print();
        !          30320:                         else if (s)
        !          30321:                                 fprintf(out_file,"%d",s);
        !          30322:                         else
        !          30323:                                 puttok(ZERO);
        !          30324:                         break;
        !          30325:                 }
        !          30326:                }
        !          30327:        }
        !          30328: void print_body(Pfct);
        !          30329:        if (ff && emode==0) print_body(ff);
        !          30330: }
        !          30331: 
        !          30332: static Pexpr mk_zero_init( Ptype tt, Pname obname, Pname currname )
        !          30333: /*
        !          30334:        creates 0 initializer for defined objects
        !          30335:        side effect: generates right nesting level for {}
        !          30336: */
        !          30337: {
        !          30338: zaq:
        !          30339:        switch (tt->base) {
        !          30340:        case TYPE:
        !          30341:                tt = Pbase(tt)->b_name->tp; goto zaq;
        !          30342:        case VEC: // type a[size]; => type a[size] = {0};
        !          30343:        {
        !          30344:                if ( obname == currname ) {
        !          30345:                //xxx initializing vectors blows up the size of some programs
        !          30346:                        return 0;
        !          30347:                } else {
        !          30348:                        Pexpr i = mk_zero_init(Pvec(tt)->typ,obname,currname);
        !          30349:                        if ( i == 0 ) return 0;
        !          30350:                        return new expr( ILIST, i, 0 );
        !          30351:                }
        !          30352:        }
        !          30353:        case COBJ: // "X a;" == "X a = {0};"
        !          30354:        {
        !          30355:                Pclass cl = Pclass(Pbase(tt)->b_name->tp);
        !          30356:                if ( !ansi_opt && (cl->csu == ANON || cl->csu == UNION) ) {
        !          30357:                    if ( warning_opt ) {
        !          30358:                        // ridiculous handstands to avoid printing
        !          30359:                        // compiler generated names in warning
        !          30360:                        Ptype tn = obname->tp;
        !          30361:                        for(;;) if(tn->base==VEC) tn=Pvec(tn)->typ; else break;
        !          30362:                        if ( obname == currname && tt == tn ) {
        !          30363:                            if ( cl->string[0]=='_' && cl->string[1]=='_' )
        !          30364:                                error('w',&obname->where,"cannot generate zeroIr for%n ofT union; toI, compile with +a1 or insert non-union object as first member",obname);
        !          30365:                            else
        !          30366:                                error('w',&obname->where,"cannot generate zeroIr for%n ofT%t; toI, compile with +a1 or insert non-union object as first member",obname,obname->tp);
        !          30367:                        } else { Pclass cx;
        !          30368:                            if ( tn->base == COBJ
        !          30369:                            &&   (cx=(Pclass)Pbase(tn)->b_name->tp,
        !          30370:                                  cx->string[0]=='_' && cx->string[1]=='_') )
        !          30371:                                error('w',&obname->where,"cannot generate zeroIr for%n (union or aggregate with union as first element); toI, compile with +a1 or insert non-union object as first member",obname);
        !          30372:                            else
        !          30373:                                error('w',&obname->where,"cannot generate zeroIr for%n ofT%t (union or aggregate with union as first element); toI, compile with +a1 or insert non-union object as first member",obname,obname->tp);
        !          30374:                        }
        !          30375:                    } // if warning_opt
        !          30376:                    return 0;
        !          30377:                }
        !          30378:                Pbcl l = cl->baselist;
        !          30379:                while ( l ) {
        !          30380:                        if ( l->base == NAME ) cl = l->bclass;
        !          30381:                        else return new expr(ILIST,zero,0);
        !          30382:                        l = cl->baselist;
        !          30383:                }
        !          30384:                int i = 1;
        !          30385:                Pname nn = cl->memtbl->get_mem(i);
        !          30386:                for ( ;  nn;  nn = cl->memtbl->get_mem(++i) ) {
        !          30387:                        Ptype tx = nn->tp;
        !          30388:                        while ( tx->base == TYPE ) tx = Pbase(tx)->b_name->tp;
        !          30389:                        if (nn->base==NAME
        !          30390:                        && nn->n_union==0
        !          30391:                        && tx->base!=FCT
        !          30392:                        && tx->base!=OVERLOAD
        !          30393:                        && tx->base!=CLASS
        !          30394:                        && tx->base!=ENUM
        !          30395:                        && nn->n_stclass != STATIC) {
        !          30396:                                Pexpr i = mk_zero_init(tx,obname,nn);
        !          30397:                                if ( i == 0 ) return 0;
        !          30398:                                return new expr(ILIST,i,0);
        !          30399:                        }
        !          30400:                }
        !          30401:                return 0;
        !          30402:        }
        !          30403:        case PTR:
        !          30404:                if (tt->memptr()) {
        !          30405:                        Pexpr i = new expr(ELIST,zero,zero);
        !          30406:                        return new expr(ILIST,i,zero);
        !          30407:                }
        !          30408:                // no break
        !          30409:        case RPTR:
        !          30410:        case CHAR:
        !          30411:        case SHORT:
        !          30412:        case INT:
        !          30413:        case EOBJ:
        !          30414:        case LONG:
        !          30415:        case FLOAT:
        !          30416:        case DOUBLE:
        !          30417:        case LDOUBLE:   // "int a;" == "int a = 0;"
        !          30418:        case FIELD:
        !          30419:        case ANY:
        !          30420:                return zero;
        !          30421:        }
        !          30422:        return 0;
        !          30423: }
        !          30424: 
        !          30425: void name::dcl_print(TOK list)
        !          30426: /*
        !          30427:        Print the declaration for a name (list==0) or a name list (list!=0):
        !          30428:                For each name
        !          30429:                (1) print storage class
        !          30430:                (2) print base type
        !          30431:                (3) print the name with its declarators
        !          30432:        Avoid (illegal) repetition of basetypes which are class or enum declarations
        !          30433:        (A name list may contain names with different base types)
        !          30434:        list == SM :    terminator SM
        !          30435:        list == 0:      single declaration with terminator SM
        !          30436:        list == CM :    separator CM
        !          30437: */
        !          30438: {
        !          30439:        if (error_count) return;
        !          30440: 
        !          30441:        for (Pname n=this; n; n=n->n_list) {
        !          30442:                Ptype t = n->tp;
        !          30443:                int sm = 0;
        !          30444: 
        !          30445: // error('d',"%s->dcl_print() tp %t sto %k",n->string,t,n->n_sto);
        !          30446:                if (t == 0) error('i',"N::dcl_print(%n)T missing",n);
        !          30447: 
        !          30448:                if (n->n_stclass==ENUM) if (list) continue; else return;
        !          30449: 
        !          30450:                if (n->where.line!=last_line.line || n->where.file!=last_line.file)
        !          30451: //fprintf(stderr,"%s ",n->string?n->string:"<0>"); n->where.put(stderr); fprintf(stderr,"  last "); last_line.put(stderr); putc('\n',stderr);
        !          30452:                        if (last_ll = n->where.line)
        !          30453:                                n->where.putline();
        !          30454:                        else
        !          30455:                                last_line.putline();
        !          30456:        
        !          30457:                int tc = Pbase(t)->b_const;
        !          30458:                for (Ptype tt = t; tt->base==TYPE; tt = Pbase(tt)->b_name->tp)
        !          30459:                        tc |= Pbase(tt)->b_const;
        !          30460:  
        !          30461:                switch (t->base) {
        !          30462:                case CLASS:
        !          30463: //fprintf(stderr,"class %s->dcl_print()\n",n->string);
        !          30464:                        if (n->base != TNAME) {
        !          30465:                                Pclass(t)->dcl_print(n);
        !          30466:                                sm = 1;
        !          30467:                        }
        !          30468:                        break;
        !          30469: 
        !          30470:                case ENUM:
        !          30471:                         Penum(t)->dcl_print(0);
        !          30472:                        sm = 1;
        !          30473:                        break;
        !          30474: 
        !          30475:                case FCT:
        !          30476:                {       Pfct f = Pfct(t);
        !          30477: 
        !          30478:                        if (n->base == TNAME) puttok(TYPEDEF);
        !          30479: 
        !          30480: // error('d',"fct %n->dcl_print() printed %d body %d defined %d",n,n->n_dcl_printed,f->body,f->defined);
        !          30481: // error('d',"n %d tbl %d tp %t inline %d",n,n->n_table,n->tp,f->f_inline);
        !          30482:                        if (n->n_dcl_printed==2 // definition already printed
        !          30483:                        || (n->n_dcl_printed==1 && f->body==0)
        !          30484:                                                // declaration already printed
        !          30485:                        ) {
        !          30486:                                // don't print again
        !          30487:                                sm = 1; // no SM
        !          30488:                                break;
        !          30489:                        }
        !          30490: 
        !          30491:                        if (f->f_result == 0) make_res(f);
        !          30492: 
        !          30493:                        if (f->body && n->n_sto==EXTERN) n->n_sto = 0;
        !          30494: 
        !          30495:                        if (f->f_inline && ((n->n_table!=gtbl) || strcmp(n->string,"main"))) {
        !          30496:                                if (debug_opt)  {
        !          30497: //error('d',"f %t defined %d inline %d",f,f->defined,f->f_inline);
        !          30498:                                        if (f->defined&DEFINED
        !          30499:                                        && f->defined&SIMPLIFIED
        !          30500:                                        && f->f_inline!=ITOR)
        !          30501:                                                goto prnt_def;
        !          30502:                                        else if (n->n_dcl_printed==0)
        !          30503:                                                goto prnt_dcl;
        !          30504:                                        else {
        !          30505:                                                sm = 1;
        !          30506:                                                break;
        !          30507:                                        }
        !          30508:                                }
        !          30509:                                if (f->f_virtual || n->n_addr_taken) {
        !          30510:                                prnt_dcl:
        !          30511: //error('d',"prnt_dcl %d %n %k",n,n,n->n_sto);
        !          30512:                                        TOK st = n->n_sto;
        !          30513:                                        Pblock b = f->body;
        !          30514:                                        f->body = 0;
        !          30515:                                        t->dcl_print(n);
        !          30516:                                        n->n_dcl_printed = 1;
        !          30517:                                        n->n_sto = st;
        !          30518:                                        f->body = b;
        !          30519:                                        break;
        !          30520:                                }
        !          30521:                                else
        !          30522:                                        sm = 1; // no SM
        !          30523:                        }
        !          30524:                        else if ((f->defined&DEFINED)==0
        !          30525:                                || (f->defined&SIMPLIFIED)==0)
        !          30526:                                goto prnt_dcl;
        !          30527:                        else if (n->n_table==gtbl && strcmp(n->string,"main")==0) {
        !          30528:                                if (f->f_inline) {
        !          30529:                                        if (warning_opt) {
        !          30530:                                                error('w',"main() cannot be inlined");
        !          30531:                                                error('w',"out-of-line copy of main() created");
        !          30532:                                        }
        !          30533:                                        n->n_sto=0;
        !          30534:                                }
        !          30535:                                MAIN = 1;
        !          30536:                                gtbl->look("main",0)->use();
        !          30537:                                f->f_signature = 0;
        !          30538:                                t->dcl_print(n);
        !          30539:                                n->n_dcl_printed = f->body?2:1;
        !          30540:                                MAIN = 0;
        !          30541:                        }
        !          30542:                        else {
        !          30543:                        prnt_def:
        !          30544: // error('d',"prnt_def %n %k %d %k",n,n->n_oper,n,n->n_sto);
        !          30545:                                if (n->n_oper==CTOR || n->n_oper==DTOR) {
        !          30546:                                        Pclass cl = Pclass(n->n_table->t_name->tp);
        !          30547:                                        if (cl->c_body == 3) cl->print_all_vtbls(cl);
        !          30548:                                }
        !          30549: 
        !          30550:                                if ( n->n_sto == STATIC && 
        !          30551:                                        pdef_name == 0 && def_name == 0 ) {
        !          30552: // error('d', "printing ptbl_vec without first definition" );
        !          30553:                                                pdef_name = n;
        !          30554:                                                ptbl_init(0);
        !          30555:                                }
        !          30556:                                t->dcl_print(n);
        !          30557:                                n->n_dcl_printed = f->body?2:1;
        !          30558:                        }
        !          30559:                        if (f->body) sm = 1;
        !          30560:                        break;
        !          30561:                }
        !          30562: 
        !          30563:                case OVERLOAD:
        !          30564:                {
        !          30565:                        for (Plist gl=Pgen(t)->fct_list; gl; gl=gl->l) {
        !          30566:                                Pname nn = gl->f;
        !          30567:                                nn->dcl_print(0);
        !          30568:                                sm = 1;
        !          30569:                        }
        !          30570:                        break;
        !          30571:                }
        !          30572: 
        !          30573:                case ASM:
        !          30574:                        fprintf(out_file,"asm(\"%s\")\n",(char*)Pbase(t)->b_name);
        !          30575:                        break;
        !          30576: 
        !          30577:                case INT:
        !          30578:                case EOBJ:
        !          30579:                case CHAR:
        !          30580:                case LONG:
        !          30581:                case SHORT:
        !          30582:                tcx:
        !          30583:                        // do not allocate space for constants unless necessary
        !          30584:                        if (tc
        !          30585:                        && n->n_sto!=EXTERN     // extern const one;
        !          30586:                                                // const one = 1;
        !          30587:                                                // allocates storage
        !          30588:                        && (n->n_scope==EXTERN  // FUDGE const one = 1;
        !          30589:                                                // is treated as static
        !          30590:                                                // need loader support
        !          30591:                                || n->n_scope==STATIC
        !          30592:                                || n->n_scope==FCT)
        !          30593:                        ) {
        !          30594:                                if (n->n_evaluated && n->n_addr_taken==0) {
        !          30595:                                        sm = 1; /* no ; */
        !          30596:                                        break;
        !          30597:                                }
        !          30598:                        }
        !          30599:                        tc = 0;
        !          30600:                        // no break;
        !          30601: 
        !          30602:                default:
        !          30603:                {
        !          30604: /*     
        !          30605: //  don't print local instance of const
        !          30606:                        if ( n->n_dcl_printed == 3 ) {
        !          30607:                                sm = 1;
        !          30608:                                break;
        !          30609:                        }
        !          30610: */
        !          30611:                        Pexpr i = n->n_initializer;
        !          30612:                        if (n->base == TNAME && n->n_key == NESTED) i = 0;
        !          30613:                        if (tc) {
        !          30614:                                switch (tt->base) {
        !          30615:                                case CHAR:
        !          30616:                                case SHORT:
        !          30617:                                case INT:
        !          30618:                                case LONG:
        !          30619:                                case EOBJ:
        !          30620:                                        goto tcx;
        !          30621:                                }
        !          30622:                        }
        !          30623: 
        !          30624:                        if (n->base == TNAME) {
        !          30625:                                /* Always print template formals, even when they have the same 
        !          30626:                         * formal name, since the instantiation name is different. This 
        !          30627:                         * fix should not be required when the copy mechanism is in place. */
        !          30628:                                if (! n_template_arg)
        !          30629:                                        for (Pname tn=ktbl->look(n->string,HIDDEN); tn; tn=tn->n_tbl_list) 
        !          30630:                                                if (tn && tn->lex_level && t==tn->tp) return;
        !          30631:                                puttok(TYPEDEF);
        !          30632:                        }
        !          30633: 
        !          30634:                        if (n->n_stclass == REGISTER) {
        !          30635:                                // (imperfect) check against member functions
        !          30636:                                // register s a; a.f() illegal
        !          30637:                                Pname cln = n->tp->is_cl_obj();
        !          30638:                                if (cln) {
        !          30639:                                        Pclass cl = Pclass(cln->tp);
        !          30640:                                        if (cl->csu!=CLASS
        !          30641:                                        && cl->baselist==0
        !          30642:                                        && cl->has_itor()==0
        !          30643:                                        && cl->virt_count==0) puttok(REGISTER);
        !          30644:                                }
        !          30645:                                else
        !          30646:                                        puttok(REGISTER);
        !          30647:                        }
        !          30648: 
        !          30649:                        if (i) {
        !          30650:                                if (n->n_sto==EXTERN && n->n_stclass==STATIC) {
        !          30651:                                        n->n_initializer = 0;
        !          30652:                                        t->dcl_print(n);
        !          30653:                                        puttok(SM);
        !          30654:                                        n->n_initializer = i;
        !          30655:                                        n->n_sto = 0;
        !          30656:                                        t->dcl_print(n);
        !          30657:                                        n->n_sto = EXTERN;
        !          30658:                                }
        !          30659:                                else
        !          30660:                                        t->dcl_print(n);
        !          30661:                                if(n->n_table) {
        !          30662:                                        Pname nn = n->n_table->look(n->string,0);
        !          30663:                                        if(nn)
        !          30664:                                                nn->n_dcl_printed = 1;
        !          30665:                                        else
        !          30666:                                                n->n_dcl_printed = 1;
        !          30667:                                }
        !          30668:                                else
        !          30669:                                        n->n_dcl_printed = 1;
        !          30670:                        }
        !          30671:                        else if (n->n_evaluated && Pbase(t)->b_const) {
        !          30672:                                if (n->n_sto==EXTERN && n->n_stclass==STATIC) {
        !          30673:                                        int v = n->n_evaluated;
        !          30674:                                        n->n_evaluated = 0;
        !          30675:                                        t->dcl_print(n);
        !          30676:                                        puttok(SM);
        !          30677:                                        if (n->where.line!=last_line.line || n->where.file!=last_line.file)
        !          30678:                                                if (last_ll = n->where.line)
        !          30679:                                                        n->where.putline();
        !          30680:                                                else
        !          30681:                                                        last_line.putline();
        !          30682:                                        n->n_evaluated = v;
        !          30683:                                        n->n_sto = 0;
        !          30684:                                        t->dcl_print(n);
        !          30685:                                        n->n_sto = EXTERN;
        !          30686:                                }
        !          30687:                                else
        !          30688:                                        t->dcl_print(n);
        !          30689:                                if(n->n_table) {
        !          30690:                                        Pname nn = n->n_table->look(n->string,0);
        !          30691:                                        if(nn)
        !          30692:                                                nn->n_dcl_printed = 1;
        !          30693:                                        else
        !          30694:                                                n->n_dcl_printed = 1;
        !          30695:                                }
        !          30696:                                else
        !          30697:                                        n->n_dcl_printed = 1;
        !          30698:                        }
        !          30699:                        else {
        !          30700: //error('d',"%n sto %k val %d stc %k",n,n->n_sto,n->n_val,n_stclass);
        !          30701:                                if ((n->n_sto==0 || (n->n_val && n->n_evaluated==0))
        !          30702:                                 && n_stclass==STATIC
        !          30703:                                && n->n_sto!=STATIC
        !          30704:                                 && n->n_table==gtbl) {
        !          30705:                                         if (n->n_val && n->n_evaluated==0) { 
        !          30706:                                                 // extern x = f();
        !          30707:                                                 // generate int x = 0;       
        !          30708:                                                 // plus dynamic initialization
        !          30709:                                                 n->n_sto = 0;
        !          30710:                                         }
        !          30711: 
        !          30712:                                        n->n_initializer = i = mk_zero_init(t,n,n);
        !          30713:                                }
        !          30714:                                t->dcl_print(n);
        !          30715:                                if(n->n_table) {
        !          30716:                                        Pname nn = n->n_table->look(n->string,0);
        !          30717:                                        if(nn)
        !          30718:                                                nn->n_dcl_printed = 1;
        !          30719:                                        else
        !          30720:                                                n->n_dcl_printed = 1;
        !          30721:                                }
        !          30722:                                else
        !          30723:                                        n->n_dcl_printed = 1;
        !          30724:                        }
        !          30725: 
        !          30726:                        if (n->n_scope!=ARG) {
        !          30727:                                if (i) {
        !          30728:                                        puttok(ASSIGN);
        !          30729: 
        !          30730:                                        Pexpr i2 = i;
        !          30731:                                        while (i2->base == CAST) i2 = i2->e1;
        !          30732:                                        if (i2->base == ILIST) i = i2;
        !          30733:                                        if (t!=i->tp
        !          30734:                                        && i->base!=ZERO
        !          30735:                                        && i->base!=ILIST /*&& i->tp!=Pchar_type*/) {
        !          30736:                                                Ptype t1 = n->tp;
        !          30737:                                        cmp:
        !          30738:                                                switch (t1->base) {
        !          30739:                                                case TYPE:      
        !          30740:                                                        t1 = Pbase(t1)->b_name->tp;
        !          30741:                                                        goto cmp;
        !          30742:                                                default:
        !          30743:                                                        i->print();
        !          30744:                                                        break;
        !          30745:                                        //      case EOBJ:
        !          30746:                                        //              goto cst;
        !          30747:                                                case VEC:
        !          30748:                                                        if (Pvec(t1)->typ->base==CHAR) {
        !          30749:                                                                i->print();
        !          30750:                                                                break;
        !          30751:                                                        }
        !          30752:                                                        // no break
        !          30753:                                                case PTR:
        !          30754:                                                case RPTR:
        !          30755:                                                        if (i->tp==0 || n->tp->check(i->tp,0)) {
        !          30756:                                           //      cst:
        !          30757:                                                                putch('(');
        !          30758:                                                                bit oc = Cast;
        !          30759:                                                                Cast = 1;
        !          30760:                                                                t->print();
        !          30761:                                                                Cast = oc;
        !          30762:                                                                putch(')');
        !          30763:                                                        }
        !          30764:                                                        eprint(i);
        !          30765:                                                }
        !          30766:                                        }
        !          30767:                                        else {
        !          30768:                                                if (i==zero) {
        !          30769:                                                        while (t->base == TYPE) t = Pbase(t)->b_name->tp;
        !          30770:                                        //              if (t->base == EOBJ) {
        !          30771:                                        //                      putch('(');
        !          30772:                                        //                      bit oc = Cast;
        !          30773:                                        //                      Cast = 1;
        !          30774:                                        //                      t->print();
        !          30775:                                        //                      Cast = oc;
        !          30776:                                        //                      putch(')');
        !          30777:                                        //              }
        !          30778:                                                }
        !          30779:                                                eprint(i);
        !          30780:                                                
        !          30781:                                        //      i->print();
        !          30782:                                        }
        !          30783:                                }
        !          30784:                                else if (n->n_evaluated) {
        !          30785:                                        puttok(ASSIGN);
        !          30786:                                        if (n->tp->base!=INT || n->tp->is_unsigned()) {
        !          30787:                                                putstring("((");
        !          30788:                                                bit oc = Cast;
        !          30789:                                                Cast = 1;
        !          30790:                                                n->tp->print();
        !          30791:                                                Cast = oc;
        !          30792:                                                fprintf(out_file,")%d)",n->n_val);
        !          30793:                                        }
        !          30794:                                        else
        !          30795:                                                fprintf(out_file,"%d",n->n_val);
        !          30796:                                }
        !          30797:                        }
        !          30798:                }
        !          30799:                }
        !          30800: 
        !          30801:                switch (list) {
        !          30802:                case SM:
        !          30803:                        if (sm==0) puttok(SM);
        !          30804:                        break;
        !          30805:                case 0:
        !          30806:                        if (sm==0) puttok(SM);
        !          30807:                        return;
        !          30808:                case CM:
        !          30809:                        if (n->n_list) puttok(CM);
        !          30810:                        break;
        !          30811:                }
        !          30812:        }
        !          30813: } 
        !          30814: 
        !          30815: char *local_sign( Ptype pt )
        !          30816: { // get function signature for local class
        !          30817:        char buf[1024];
        !          30818:        char* bb = pt->signature(buf);
        !          30819:        int ll = bb-buf;
        !          30820:        if (1023 < ll) error('i',"local class N buffer overflow");
        !          30821:        char *p = new char[ll+1];
        !          30822:        strcpy(p,buf);
        !          30823:        return p;
        !          30824: }
        !          30825: 
        !          30826: void enumdef::dcl_print(Pname cln)
        !          30827: /*
        !          30828: */
        !          30829: {
        !          30830:        // note: ***** modify to handle local enums 
        !          30831: // error('d', "%t::dcl_print(%n) in_class: %t nested_sig: %s", this, cln, in_class, nested_sig );
        !          30832:        char* s = nested_sig?nested_sig:(cln ? cln->string:0);
        !          30833:        if ( nested_sig )
        !          30834:                fprintf(out_file,"enum __%s { ",nested_sig);
        !          30835:        else fprintf(out_file,"enum %s { ",string);
        !          30836: 
        !          30837:        for (Pname px, p=mem; p; p=px) {
        !          30838:                px = p->n_list;
        !          30839:                if (s) {
        !          30840:                        if (p->n_evaluated)
        !          30841:                                fprintf(out_file,"%s__%s = %d",p->string,s,p->n_val);
        !          30842:                        else
        !          30843:                                fprintf(out_file,"%s__%s",p->string,s);
        !          30844:                }
        !          30845:                else {
        !          30846:                        if (p->n_evaluated)
        !          30847:                                fprintf(out_file,"%s = %d",p->string,p->n_val);
        !          30848:                        else
        !          30849:                                fprintf(out_file,"%s",p->string);
        !          30850:                }
        !          30851:                if (px) puttok(CM);
        !          30852:                p->n_initializer = 0;
        !          30853:                delete p;
        !          30854:        }
        !          30855:        mem = 0;
        !          30856:        puttok(RC);
        !          30857:        puttok(SM);
        !          30858: }
        !          30859: 
        !          30860: void name::print()
        !          30861: { // print just the name itself
        !          30862:        if (this == 0) error('i',"0->N::print()");
        !          30863:        if (string == 0) {
        !          30864:                if (emode) putch('?');
        !          30865:                return;
        !          30866:        }
        !          30867: 
        !          30868: // error( 'd', "%s->name::print(), base: %k", string, base );
        !          30869:        switch (base) {
        !          30870:        case TNAME:
        !          30871:                if (n_key == NESTED && tpdef &&
        !          30872:                        tpdef->nested_sig) {
        !          30873:                        if ( emode == 0 ) {
        !          30874:                                putstring( " __" );
        !          30875:                                putst(tpdef->nested_sig);
        !          30876:                        }
        !          30877:                        else {
        !          30878:                                putst(tpdef->in_class->string);
        !          30879:                                putstring( "::" );
        !          30880:                                putst(string);
        !          30881:                        }
        !          30882:                        return;
        !          30883:                }
        !          30884: 
        !          30885:                if (emode && tp) {
        !          30886:                        if (n_template_arg_string) {
        !          30887:                                tp->dcl_print(0); return;
        !          30888:                        } else
        !          30889:                        if(tp->base == COBJ) {
        !          30890:                                Pclass cl = Pclass(Pbase(tp)->b_name->tp);
        !          30891:                                if(cl && cl->base == CLASS && 
        !          30892:                                  (cl->class_base == instantiated_template_class)) {
        !          30893:                                        Ptclass(cl)->inst->print_pretty_name(); return;
        !          30894:                                }
        !          30895:                        }
        !          30896:                }
        !          30897: 
        !          30898:                putst(n_template_arg_string ? n_template_arg_string : string);
        !          30899:                return;
        !          30900: 
        !          30901:        case MDOT:
        !          30902:                Pexpr(this)->print();
        !          30903:                return;
        !          30904:        }
        !          30905: 
        !          30906:        if (emode) {
        !          30907:                Ptable tbl;
        !          30908:                char* cs = 0;
        !          30909:                bit f = 0;
        !          30910:                if (tp) {
        !          30911:                        switch (tp->base) {
        !          30912:                        case OVERLOAD:
        !          30913:                        case FCT:
        !          30914:                                f = 1;
        !          30915:                        default:
        !          30916:                                if (tbl=n_table) {
        !          30917:                                        if (tbl == gtbl) {
        !          30918:                                                if (f == 0) putstring("::");
        !          30919:                                        }
        !          30920:                                        else {
        !          30921:                                                if (tbl->t_name) {
        !          30922:                                                        Ptclass pc = Ptclass(tbl->t_name->tp);
        !          30923:                                                        cs = tbl->t_name->string;
        !          30924:                                                        if ((pc->base == CLASS)  && 
        !          30925:                                                                (pc->class_base == instantiated_template_class))
        !          30926:                                                                        pc->inst->print_pretty_name();
        !          30927:                                                        else fprintf(out_file,"%s",cs);
        !          30928:                                                        fprintf (out_file, "::") ;
        !          30929:                                                }
        !          30930:                                        }
        !          30931:                                }
        !          30932: 
        !          30933:                                if (n_scope==ARG && strcmp(string,"this")==0) {
        !          30934:                                        // tell which "this" it is
        !          30935:                                        Ptype tt = Pptr(tp)->typ;
        !          30936:                                        Pname cn = Pbase(tt)->b_name;
        !          30937:                                        fprintf(out_file,"%s::",cn->string);
        !          30938:                                }
        !          30939: 
        !          30940:                        case CLASS:
        !          30941:                        case ENUM:
        !          30942:                //      case TYPE:
        !          30943:                                break;
        !          30944:                        }
        !          30945:                nop:
        !          30946:                        switch (n_oper) {
        !          30947:                        case TYPE:
        !          30948:                                putstring("operator ");
        !          30949:                                if (tp) Pfct(tp)->returns->dcl_print(0);
        !          30950:                                break;
        !          30951:                        case 0:
        !          30952:                                putstring(string);
        !          30953:                                break;
        !          30954:                        case DTOR:
        !          30955:                                putch('~');
        !          30956:                        case CTOR:
        !          30957:                                if (cs) {
        !          30958:                                        if(tbl->t_name) {
        !          30959:                                                Ptclass pc = Ptclass(tbl->t_name->tp);
        !          30960:                                                if ((pc->base == CLASS) && 
        !          30961:                                                        (pc->class_base == instantiated_template_class))
        !          30962:                                                                pc->inst->print_pretty_name();
        !          30963:                                                else putstring(cs);
        !          30964:                                        }
        !          30965:                                }
        !          30966:                                else {
        !          30967:                                        if (string)
        !          30968:                                                fprintf(out_file,"%s()", n_template_arg_string 
        !          30969:                                                        ? n_template_arg_string : string);
        !          30970:                                        else putstring("constructor");
        !          30971:                                        f = 0;
        !          30972:                                }
        !          30973:                                break;
        !          30974:                        case TNAME:
        !          30975:                                putstring(string);
        !          30976:                                break;
        !          30977:                        default:
        !          30978:                                putstring("operator ");
        !          30979:                                putstring(keys[n_oper]);
        !          30980:                                break;
        !          30981:                        }
        !          30982:                        if (f) putstring("()");
        !          30983:                }
        !          30984:                else {
        !          30985:                        if (n_oper) goto nop;
        !          30986:                        if (string) 
        !          30987:                                putstring(n_template_arg_string 
        !          30988:                                        ? n_template_arg_string : string);
        !          30989:                }
        !          30990:                return;
        !          30991:        }
        !          30992:        
        !          30993:        char* sig = 0;
        !          30994:        Pclass cl = 0;
        !          30995:        Penum en = 0;
        !          30996:        int i = n_union;
        !          30997: 
        !          30998:        if (tp) {
        !          30999:                Ptable tbl;
        !          31000: 
        !          31001:                switch (tp->base) {
        !          31002:                default:
        !          31003:                        if (tbl=n_table) {      // global or member
        !          31004:                                Pname tn;
        !          31005:                                if (tbl == gtbl) {
        !          31006:                                        // if (i) fprintf(out_file,"__O%d.",i);
        !          31007:                                        if ( i ) {
        !          31008:                                                if (n_anon) 
        !          31009:                                                fprintf(out_file,"__O%d.%s.", i, n_anon );
        !          31010:                                        else fprintf(out_file,"__O%d.",i);
        !          31011:                                        }
        !          31012:                                        break;
        !          31013:                                }
        !          31014: 
        !          31015:                                if (tn=tbl->t_name) { 
        !          31016:                                        cl = Pclass(tn->tp);
        !          31017:                                        if (i) { 
        !          31018:                                                if (cl->string[0]=='_'  
        !          31019:                                                    && cl->string[1]=='_'
        !          31020:                                                    && cl->string[2]=='C' ) {
        !          31021:                                                        if (n_anon)
        !          31022:                                                                fprintf(out_file,"__O%d.%s.", i, n_anon );
        !          31023:                                                        else fprintf(out_file,"__O%d.",i);
        !          31024:                                                }
        !          31025:                                                else
        !          31026:                                                if ( cl->nested_sig ) 
        !          31027:                                                        fprintf(out_file,"__O%d__%s.",i,cl->nested_sig);
        !          31028:                                                else
        !          31029:                                                if ( cl->lex_level ) {
        !          31030:                                                        char *str = make_local_name(cl,1);
        !          31031:                                                        fprintf(out_file,"__O%d%s.",i,str);
        !          31032:                                                        delete str;
        !          31033:                                                }
        !          31034:                                                else fprintf(out_file,"__O%d__%d%s.",i,cl->strlen,cl->string);
        !          31035:                                                cl = 0;
        !          31036:                                        }
        !          31037:                                        else 
        !          31038:                                        if (cl->string[0]=='_'
        !          31039:                                                && cl->string[1]=='_'
        !          31040:                                                && cl->string[2]=='C'
        !          31041:                                                && n_stclass != STATIC )
        !          31042:                                                        cl = 0;
        !          31043:                                        break;
        !          31044:                                }
        !          31045:                        }
        !          31046: 
        !          31047:                        switch (n_stclass) {    // local variable
        !          31048:                        case STATIC:
        !          31049:                        case EXTERN:
        !          31050:                                if (i)
        !          31051:                                        fprintf(out_file,"__O%d.",i);
        !          31052:                                else if (n_sto==STATIC && tp->base!=FCT) {
        !          31053:                                        if (lex_level == 0)
        !          31054:                                                putstring("__S");
        !          31055:                                        else
        !          31056:                                                fprintf(out_file,"__%d",lex_level);
        !          31057:                                }
        !          31058:                                break;
        !          31059:                        default:
        !          31060:                                // encode with lexical level UNLESS ``special''
        !          31061:                                // e.g. __builtin
        !          31062:                                if (string[0]!='_' || string[1]!='_' || string[2] != 'C' ) {
        !          31063:                                        if (i)
        !          31064:                                        {
        !          31065:                                                if (n_anon)
        !          31066:                                                    fprintf(out_file,"__%d__O%d.%s.",lex_level-1,i,n_anon);
        !          31067:                                                else fprintf(out_file,"__%d__O%d.",lex_level-1,i);
        !          31068:                                        }
        !          31069:                                        else
        !          31070:                                                fprintf(out_file,"__%d",lex_level);
        !          31071:                                }
        !          31072:                        }
        !          31073:                        break;
        !          31074:                case CLASS:
        !          31075:                case ENUM:
        !          31076:                        if (tp->in_class && tp->nested_sig) en = Penum(tp);
        !          31077:                        break;
        !          31078:                }
        !          31079: 
        !          31080:                if (tp->base==FCT) {
        !          31081:                        sig = Pfct(tp)->f_signature;
        !          31082:                        if (sig && sig[0]==0) sig = 0;
        !          31083:                }
        !          31084:        }
        !          31085: 
        !          31086:        if (string) {
        !          31087: #ifdef DENSE
        !          31088:                int i = strlen(string);
        !          31089:                if (cl) i += cl->strlen+4;      // __dd<class name>
        !          31090:                if (sig) {
        !          31091:                        if (cl == 0) i += 2;
        !          31092:                        i += strlen(sig);
        !          31093:                }
        !          31094: 
        !          31095:                if (31<i) {
        !          31096:                        char buf[256];
        !          31097:                        if (cl && sig)
        !          31098:                                sprintf(buf,"%s__%d%s%s",string,cl->strlen,cl->string,sig);
        !          31099:                        else if (cl)
        !          31100:                                sprintf(buf,"%s__%d%s",string,cl->strlen,cl->string);
        !          31101:                        else if (sig)
        !          31102:                                sprintf(buf,"%s__%s",string,sig);
        !          31103:                        else 
        !          31104:                                sprintf(buf,"%s",string);
        !          31105:                        chop(buf);
        !          31106:                        fprintf(out_file,"%s ",buf);
        !          31107:                        return;
        !          31108:                }
        !          31109: #endif
        !          31110: 
        !          31111:                if ( en )
        !          31112:                        fprintf(out_file,"__%s", en->nested_sig);
        !          31113:                else 
        !          31114:                        putstring(n_template_arg_string 
        !          31115:                                ? n_template_arg_string : string);
        !          31116: 
        !          31117:                if ( cl ) {
        !          31118:                        if ( cl->nested_sig )
        !          31119:                                fprintf(out_file,"__%s",cl->nested_sig);
        !          31120:                        else
        !          31121:                        if ( cl->lex_level ) {
        !          31122:                                char *str = make_local_name( cl, 1 );
        !          31123:                                putstring( str );
        !          31124:                                delete str;
        !          31125:                        }
        !          31126:                        else fprintf(out_file,"__%d%s",cl->strlen,cl->string);
        !          31127:                }
        !          31128: 
        !          31129:                if (sig) {
        !          31130:                        if (cl == 0) putstring("__");
        !          31131:                        putstring(sig);
        !          31132:                }
        !          31133:                putch(' ');
        !          31134:        }
        !          31135: }
        !          31136: 
        !          31137: #ifdef DENSE
        !          31138: void chop(char* buf)
        !          31139: {
        !          31140:        static char alpha[] = "_0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
        !          31141:        static const asz = sizeof(alpha)-1;
        !          31142:        int hash = 0;
        !          31143:        char* p = &buf[29];
        !          31144:                        
        !          31145:        while (*p) {
        !          31146:                hash <<= 1;
        !          31147:                if (hash & (1<<12)) {
        !          31148:                        hash &= ~(1<<12);
        !          31149:                        hash++;
        !          31150:                }
        !          31151:                hash ^= *p++;
        !          31152:        }
        !          31153: 
        !          31154:        buf[29] = alpha[(int)(hash%asz)];
        !          31155:        buf[30] = alpha[(int)((hash/asz)%asz)];
        !          31156:        buf[31] = 0;
        !          31157: }
        !          31158: #endif
        !          31159: 
        !          31160: void type::print()
        !          31161: {
        !          31162:        switch (base) {
        !          31163:        case PTR:
        !          31164:        case RPTR:
        !          31165:        case VEC:
        !          31166:                Pptr(this)->dcl_print(0);
        !          31167:                break;
        !          31168:        case FCT:
        !          31169:                Pfct(this)->dcl_print();
        !          31170:                break;
        !          31171: //     case VEC:
        !          31172: //             Pvec(this)->dcl_print(0);
        !          31173: //             break;
        !          31174:        case CLASS:
        !          31175:        case ENUM:
        !          31176:                if (emode)
        !          31177:                        fprintf(out_file,"%k",base);
        !          31178:                else
        !          31179:                //      error('i',"%p->T::print(%k %s)",this,base,Pclass(this)->string);        
        !          31180:                        fprintf(out_file,"struct %s *",Pclass(this)->string);
        !          31181:                break;
        !          31182:        case TYPE:
        !          31183:                if (Cast||Pbase(this)->b_name->lex_level) {
        !          31184:                        Pbase(this)->b_name->tp->print();
        !          31185:                        break;
        !          31186:                }
        !          31187:                // no break
        !          31188:        default:
        !          31189:                Pbase(this)->dcl_print();
        !          31190:        }
        !          31191: }
        !          31192: 
        !          31193: char* type::signature(register char* p)
        !          31194: /*
        !          31195:        take a signature suitable for argument types for overloaded
        !          31196:        function names
        !          31197: */
        !          31198: {
        !          31199:        Ptype t = this;
        !          31200:        int pp = 0;     // pointer to
        !          31201: 
        !          31202: xx:
        !          31203: //error('d',"xx(%d) %d %k",this,t,t->base);
        !          31204: 
        !          31205:        // first unroll typedefs and handle derived types:
        !          31206: 
        !          31207:        switch (t->base) {
        !          31208:        case TYPE:
        !          31209:                if (Pbase(t)->b_const) *p++ = 'C';
        !          31210:                t = Pbase(t)->b_name->tp;
        !          31211:                goto xx;
        !          31212: 
        !          31213:        case VEC:
        !          31214:                if (pp && Pvec(t)->size) {           // A<size>_
        !          31215:                        *p++ = 'A';
        !          31216:                        sprintf(p,"%d\0",Pvec(t)->size); // don't trust
        !          31217:                                                         // sprintf return value
        !          31218:                        while (*++p);
        !          31219:                        *p++ = '_';
        !          31220:                }
        !          31221:                else
        !          31222:                        *p++ = 'P';
        !          31223:                t = Pvec(t)->typ;
        !          31224:                pp = 1;
        !          31225:                goto xx;
        !          31226: 
        !          31227:        case PTR:
        !          31228:                if (Pptr(t)->rdo) *p++ = 'C';           // *const
        !          31229:                if (Pptr(t)->memof) {                   // M<size><classname>
        !          31230:                        Pclass cl = Pptr(t)->memof;
        !          31231:                        register char* s = cl->string;
        !          31232:                        int d = cl->strlen;
        !          31233:                        if (d==0) cl->strlen = d = strlen(s);
        !          31234:                        *p++ = 'M';
        !          31235:                        if (d/10) *p++ = '0'+d/10;
        !          31236:                        *p++ = '0'+ d%10;       // assume <100 char
        !          31237:                        while (*p++ = *s++);
        !          31238:                        --p;                            // not the '\0'
        !          31239:                }
        !          31240:                else
        !          31241:                        *p++ = 'P';
        !          31242:                t = Pptr(t)->typ;
        !          31243:                pp = 1;
        !          31244:                goto xx;
        !          31245: 
        !          31246:        case RPTR:
        !          31247:                *p++ = 'R';
        !          31248:                t = Pptr(t)->typ;
        !          31249:                pp = 1;
        !          31250:                goto xx;
        !          31251: 
        !          31252:        case FCT:
        !          31253:        {       Pfct f = Pfct(t);
        !          31254:                Pname n = f->argtype;
        !          31255: 
        !          31256:                if (f->f_const) *p++ = 'C';     // constant member function
        !          31257:                if (f->f_static) *p++ = 'S';    // static member function
        !          31258:        //      if (f->memof && f->f_this==0) *p++ = 'S';       //SSS static member function
        !          31259:                *p++ = 'F';
        !          31260:                if (n == 0)
        !          31261:                        *p++ = 'v';     // VOID, that is f() == f(void)
        !          31262:                else
        !          31263:        for ( ; n; n=n->n_list) {       // print argument encoding
        !          31264:                                        // check if argtype is the same
        !          31265:                                        // as previously seen argtype
        !          31266:                int i = 0;
        !          31267:                for (Pname nn=f->argtype; n!=nn; nn=nn->n_list) {
        !          31268:                        i++;
        !          31269:                        if (nn->tp==n->tp || nn->tp->check(n->tp,0)==0) {
        !          31270:                                // typeof (n) == typeof(arg i)
        !          31271:                                int x = 1;      // try for a run after n
        !          31272:                                Pname nnn = n;
        !          31273:                                while ((nnn=nnn->n_list) && x<9) {
        !          31274:                                        if (nnn->tp==n->tp
        !          31275:                                        || nnn->tp->check(n->tp,0)==0) {
        !          31276:                                                x++;
        !          31277:                                                n = nnn;
        !          31278:                                        }
        !          31279:                                        else
        !          31280:                                                break;
        !          31281:                                }
        !          31282: 
        !          31283:                                if (x == 1)             // Ti
        !          31284:                                        *p++ = 'T';
        !          31285:                                else {                  // Nxi
        !          31286:                                        *p++ = 'N';
        !          31287:                                        *p++ = '0'+x;
        !          31288:                                }
        !          31289:        
        !          31290:                                // assume <100 arguments
        !          31291:                                if (9<i) *p++ = '0'+i/10;
        !          31292:                                *p++ = '0'+i%10;
        !          31293:                                goto zk;
        !          31294:                        }       
        !          31295:                }
        !          31296: 
        !          31297:                // ``normal'' case print argument type signature
        !          31298:        //      if (n->n_xref) *p++ = 'R';
        !          31299:                p = n->tp->signature(p);
        !          31300:                zk:;
        !          31301:        }
        !          31302: 
        !          31303:                if (f->nargs_known == ELLIPSIS) *p++ = 'e';
        !          31304: 
        !          31305:                if (pp) {               // '_' result type
        !          31306:                        *p++ = '_';
        !          31307:                        p = f->returns->signature(p);
        !          31308:                }
        !          31309: 
        !          31310:                *p = 0;
        !          31311:                return p;
        !          31312:        }
        !          31313:        }
        !          31314: 
        !          31315:        // base type modifiers:
        !          31316: 
        !          31317:        if ( Pbase(t)->b_const )        *p++ = 'C';
        !          31318: //     if ( Pbase(t)->b_signed )       *p++ = 'S';
        !          31319:        if ( Pbase(t)->b_unsigned )     *p++ = 'U';
        !          31320: //     if ( Pbase(t)->b_volatile )     *p++ = 'V';
        !          31321: 
        !          31322: 
        !          31323:        // now base types:
        !          31324: 
        !          31325:        register char *s, *ns = 0;;
        !          31326:        int d;
        !          31327:        Pclass cl;
        !          31328: //lll:
        !          31329:        switch (t->base) {
        !          31330: //     case TNAME:     t = Pbase(t)->b_name->tp; goto lll;
        !          31331:        case ANY:                       break;
        !          31332:        case ZTYPE:                     break;
        !          31333:        case VOID:      *p++ = 'v';     break;
        !          31334:        case CHAR:      *p++ = 'c';     break;
        !          31335:        case SHORT:     *p++ = 's';     break;
        !          31336: //     case EOBJ:
        !          31337:        case INT:       *p++ = 'i';     break;
        !          31338:        case LONG:      *p++ = 'l';     break;
        !          31339:        case FLOAT:     *p++ = 'f';     break;
        !          31340:        case DOUBLE:    *p++ = 'd';     break;
        !          31341:        case LDOUBLE:   *p++ = 'r';     break;
        !          31342:        case EOBJ:
        !          31343: //             *p++ = 'i';
        !          31344: //             break;
        !          31345:        {       Penum en = Penum(Pbase(t)->b_name->tp);
        !          31346:        //      t = en->e_type;
        !          31347:        //      goto lll;
        !          31348:                ns = en->nested_sig; 
        !          31349:                s = en->string;
        !          31350:                d = en->strlen;
        !          31351:                if (d==0) en->strlen = d = strlen(s);
        !          31352:                goto pppp;
        !          31353:        }
        !          31354: 
        !          31355:        case COBJ:
        !          31356:        {       cl = Pclass(Pbase(t)->b_name->tp);
        !          31357:                ns = cl->nested_sig;
        !          31358:                s = cl->string;
        !          31359:                d = cl->strlen;
        !          31360:                if (d==0) cl->strlen = d = strlen(s);
        !          31361:        pppp:
        !          31362:                if ( ns == 0 ) {
        !          31363:                        if (d/10) *p++ = '0'+d/10;
        !          31364:                        *p++ = '0'+ d%10;       // assume less that 99 characters
        !          31365:                }
        !          31366:                else s = ns;
        !          31367: 
        !          31368:                while (*p++ = *s++);
        !          31369:                --p;
        !          31370:                break;
        !          31371:        }
        !          31372:        case FIELD:
        !          31373:        default:
        !          31374:                error('i',"signature of %k",t->base);
        !          31375:        }
        !          31376: 
        !          31377:        *p = 0;
        !          31378:        return p;
        !          31379: }
        !          31380: 
        !          31381: void basetype::dcl_print()
        !          31382: {
        !          31383:        Pname nn;
        !          31384:        Pclass cl;
        !          31385: 
        !          31386:        if (emode) {
        !          31387:                if (b_virtual) puttok(VIRTUAL);
        !          31388:                if (b_inline) puttok(INLINE);
        !          31389:        }
        !          31390:        if(ansi_opt || emode)
        !          31391:                if (b_const) puttok(CONST);
        !          31392:        if (b_unsigned) puttok(UNSIGNED);
        !          31393: 
        !          31394:        switch (base) {
        !          31395:        case ANY:
        !          31396:                if (emode)
        !          31397:                        putstring("any ");
        !          31398:                else
        !          31399:                        putstring("int ");
        !          31400:                break;
        !          31401: 
        !          31402:        case ZTYPE:
        !          31403:                if (emode)
        !          31404:                        putstring("zero ");
        !          31405:                else
        !          31406:                        putstring("int ");
        !          31407:                break;
        !          31408: 
        !          31409:        case VOID:
        !          31410:                 if (emode==0 && ansi_opt==0) {
        !          31411:                         // silly trick to bypass BSD C compiler bug
        !          31412:                         // void* (*)() dosn't work there
        !          31413:                         // note simpl.c knows that VOID -> CHAR grep for VCVC
        !          31414:                         puttok(CHAR);
        !          31415:                        break;
        !          31416:                 } 
        !          31417:        case CHAR:
        !          31418:        case SHORT:
        !          31419:        case INT:
        !          31420:        case LONG:
        !          31421:        case FLOAT:
        !          31422:        case DOUBLE:
        !          31423:         case LDOUBLE:
        !          31424:                puttok(base);
        !          31425:                break;
        !          31426: 
        !          31427:        case EOBJ:
        !          31428:                nn = b_name;
        !          31429:        eob:
        !          31430:                if (emode == 0)
        !          31431:                //      puttok(INT);
        !          31432:                        Penum(nn->tp)->e_type->dcl_print();
        !          31433:                else {
        !          31434:                         puttok(ENUM);
        !          31435:                         nn->print();
        !          31436:                }
        !          31437:                 break;
        !          31438: 
        !          31439:        case COBJ:
        !          31440:                nn = b_name;
        !          31441:        cob:
        !          31442:                cl = Pclass(nn->tp);
        !          31443:                if (emode && (cl->base == CLASS)  &&
        !          31444:                        (cl->class_base == instantiated_template_class)) {
        !          31445:                                Ptclass(cl)->inst->print_pretty_name();
        !          31446:                                break;
        !          31447:                } else
        !          31448:                if (cl && (cl->csu==UNION || cl->csu==ANON))
        !          31449:                        puttok(UNION);
        !          31450:                else puttok(STRUCT);
        !          31451:                { 
        !          31452:                        char* s = 0;
        !          31453:                        if ( cl && cl->nested_sig )
        !          31454:                                fprintf(out_file," __%s ",cl->nested_sig);
        !          31455:                        else {
        !          31456:                                if ( cl && cl->lex_level )
        !          31457:                                        s = make_local_name( cl );
        !          31458:                                putst(s?s:nn->string);
        !          31459:                                delete s;
        !          31460:                        }
        !          31461:                }
        !          31462:                break;
        !          31463: 
        !          31464:        case TYPE:
        !          31465:                if (emode == 0) {
        !          31466:                        switch (b_name->tp->base) {
        !          31467:                        case COBJ:
        !          31468:                                nn = Pbase(b_name->tp)->b_name;
        !          31469:                                goto cob;
        !          31470:                        case EOBJ:
        !          31471:                                nn = Pbase(b_name->tp)->b_name;
        !          31472:                                goto eob;
        !          31473:                        }
        !          31474:                }
        !          31475:                b_name->print();
        !          31476:                break;
        !          31477: 
        !          31478:        default:
        !          31479:                if (emode) {
        !          31480:                        if (0<base && base<=MAXTOK && keys[base])
        !          31481:                                fprintf(out_file," %s",keys[base]);
        !          31482:                        else
        !          31483:                                putch('?');
        !          31484:                }
        !          31485:                else
        !          31486:                        error('i',"%p->BT::dcl_print(%d)",this,base);
        !          31487:        }
        !          31488: }
        !          31489: Pbase memptr_type;
        !          31490: 
        !          31491: void type::dcl_print(Pname n)
        !          31492: /*
        !          31493:        "this" type is the type of "n". Print the declaration
        !          31494: */
        !          31495: {
        !          31496: //error('d',"%p::dcl_print(%n)",this,n);
        !          31497:        Ptype t = this;
        !          31498:        Pptr p;
        !          31499:        TOK pre = 0;
        !          31500: 
        !          31501:        if (t == 0) error('i',"0->dcl_print()");
        !          31502:        if (n && n->tp!=t) error('i',"not %n'sT (%p)",n,t);
        !          31503: 
        !          31504:        if (base == OVERLOAD) {
        !          31505:                for (Plist gl=Pgen(this)->fct_list; gl; gl=gl->l) {
        !          31506:                        Pname nn = gl->f;
        !          31507:                        nn->tp->dcl_print(nn);
        !          31508:                        if (gl->l) puttok(SM);
        !          31509:                }
        !          31510:                return;
        !          31511:        }
        !          31512: 
        !          31513:        tbuf = tbufvec[freetbuf];
        !          31514:        if (tbuf == 0) {
        !          31515:                if (freetbuf == NTBUF-1) error('i',"AT nesting overflow");
        !          31516:                tbufvec[freetbuf] = tbuf = new class dcl_buf;
        !          31517:        }
        !          31518:        freetbuf++;
        !          31519:        if ( base==FIELD && Pbase(this)->b_bits == 0 )
        !          31520:                tbuf->init(0);// some compilers can't handle mangled names here
        !          31521:        else
        !          31522:                tbuf->init(n);
        !          31523:        if (n && n->n_xref) tbuf->front(PTR);
        !          31524: 
        !          31525:        while (t) {
        !          31526:                TOK k;
        !          31527: 
        !          31528:                switch (t->base) {
        !          31529:                case PTR:
        !          31530:                        p = Pptr(t);
        !          31531:                        k = (p->rdo) ? CONST_PTR : PTR;
        !          31532:                        goto ppp;
        !          31533:                case RPTR:
        !          31534:                        p = Pptr(t);
        !          31535:                        k = (p->rdo) ? CONST_RPTR : RPTR;
        !          31536:                ppp:
        !          31537:                        if (p->memof) {
        !          31538:                                if (emode) {
        !          31539:                                        tbuf->front(k);
        !          31540:                                        tbuf->front(p->memof);
        !          31541:                                }
        !          31542:                                else {
        !          31543:                                        t = p->typ;
        !          31544:                                        while (t->base==TYPE) t = Pbase(t)->b_name->tp;
        !          31545:                                        if (t->base == FCT) {
        !          31546:                                                tbuf->base(mptr_type);
        !          31547:                                                goto zaq;
        !          31548:                                        }
        !          31549:                                        else
        !          31550:                                                tbuf->front(k);
        !          31551:                                }
        !          31552:                        }
        !          31553:                        else
        !          31554:                                tbuf->front(k);
        !          31555:                        pre = PTR;
        !          31556:                        t = p->typ;
        !          31557:                        break;
        !          31558:                case VEC:
        !          31559:                {       Pvec v = Pvec(t);
        !          31560:                        if (Cast && pre != PTR && pre != VEC) { // for Macintosh: ptr to array uses [] notation
        !          31561:                                tbuf->front(PTR);
        !          31562:                                pre = PTR;
        !          31563:                        }
        !          31564:                        else {
        !          31565:                                if (pre == PTR) tbuf->paran();
        !          31566:                                tbuf->back(VEC,v);
        !          31567:                                pre = VEC;
        !          31568:                        }
        !          31569:                        t = v->typ;
        !          31570:                        break;
        !          31571:                }
        !          31572: 
        !          31573:                case FCT:
        !          31574:                {       Pfct f = Pfct(t);
        !          31575:                        if (pre == PTR)
        !          31576:                                tbuf->paran();
        !          31577:                        else if (emode && f->memof && n==0)
        !          31578:                                tbuf->front(f->memof);
        !          31579:                        tbuf->back(FCT,f);
        !          31580:                        pre = FCT;
        !          31581:                        t = (f->s_returns) ? f->s_returns : f->returns;
        !          31582:                        break;
        !          31583:                }
        !          31584:                case FIELD:
        !          31585:                        tbuf->back(FIELD,t);
        !          31586:                        tbuf->base( Pbase(Pbase(t)->b_fieldtype) );
        !          31587:                        t = 0;
        !          31588:                        break;
        !          31589:                case 0:
        !          31590:                        if(!emode)error('i',"noBT(B=0)");
        !          31591:                        goto dobase;
        !          31592:                case TYPE:
        !          31593:                        if (Cast||Pbase(t)->b_name->lex_level) { // unravel type in case it contains vectors
        !          31594:                                t = Pbase(t)->b_name->tp;
        !          31595:                                break;
        !          31596:                        }
        !          31597:                default: // the base has been reached
        !          31598:                dobase:
        !          31599:                        if (emode) {
        !          31600:                                char* s;
        !          31601:                                for (Ptype tt = t; tt->base==TYPE; tt=Pbase(tt)->b_name->tp);
        !          31602:                                switch (tt->base) {
        !          31603:                                case CLASS:
        !          31604:                                        s = Pclass(tt)->string;
        !          31605:                                         if (Ptclass(this)->class_base == instantiated_template_class ||
        !          31606:                                             Ptclass(this)->class_base == uninstantiated_template_class) {
        !          31607:                                                Ptclass(this)->inst->print_pretty_name();
        !          31608:                                                --freetbuf;
        !          31609:                                                return;
        !          31610:                                         }
        !          31611:                                        if (s[0]=='_' &&s[1]=='_' && s[2]=='C') s="class";
        !          31612:                                        goto fret;
        !          31613:                                case ENUM:
        !          31614:                                        s = "enum";
        !          31615:                                        goto fret;
        !          31616:                                case OVERLOAD:
        !          31617:                                        s = "overloaded";
        !          31618:                                fret:
        !          31619:                                        putstring(s);
        !          31620:                                        freetbuf--;
        !          31621:                                        return;
        !          31622:                                }
        !          31623:                        }
        !          31624: 
        !          31625:                        tbuf->base( Pbase(t) );
        !          31626:                        goto zaq;
        !          31627:                } // switch
        !          31628:        } // while
        !          31629: zaq:
        !          31630:        tbuf->put();
        !          31631:        freetbuf--;
        !          31632: }
        !          31633: 
        !          31634: void fct::dcl_print()
        !          31635: {
        !          31636:        Pname nn;
        !          31637: //error('d',"fct::dcl_print()");
        !          31638:        if (emode) {
        !          31639:                putch('(');
        !          31640:                for (nn=argtype; nn;) {
        !          31641:                        nn->tp->dcl_print(0);
        !          31642:                        if (nn=nn->n_list) puttok(CM); else break;
        !          31643:                }
        !          31644:                switch (nargs_known) {
        !          31645:                case 0:         //      putst("?"); break;
        !          31646:                case ELLIPSIS:  puttok(ELLIPSIS); break;
        !          31647:                }
        !          31648:                putch(')');
        !          31649:                if (f_const) puttok(CONST);     
        !          31650:                if (f_static) puttok(STATIC);   // wrong place for ``static''
        !          31651:                return;
        !          31652:        }
        !          31653: 
        !          31654:        Pname at = f_args;
        !          31655:        putch('(');
        !          31656: 
        !          31657:        if (ansi_opt) {
        !          31658:                // print typed arguments:
        !          31659:                at = (f_this) ? f_this : (f_result) ? f_result : argtype; 
        !          31660:                // WNG -- note:  at = f_args had 0 value with ansi_opt set
        !          31661:                //               mystery fix added here
        !          31662:                if (at == 0) {
        !          31663:                        if (nargs_known == ELLIPSIS) {
        !          31664:                                putch(')');
        !          31665:                                return;
        !          31666:                        }
        !          31667:                        puttok(VOID);
        !          31668:                }
        !          31669:                else if (body && Cast==0)
        !          31670:                        at->dcl_print(CM);      // print argument type and name
        !          31671:                else {
        !          31672:                        for (nn=at; nn;) {
        !          31673:                        //      nn->tp->dcl_print(0);   // print argument type
        !          31674:                                nn->tp->dcl_print(nn);  // print argument type
        !          31675:                                                        // (there may not be a name)
        !          31676:                                if (nn=nn->n_list) puttok(CM); else break;
        !          31677:                        }
        !          31678:                }
        !          31679:                if (nargs_known == ELLIPSIS) putstring(",...");
        !          31680:                putch(')');
        !          31681:        }
        !          31682:        else {
        !          31683:                // print argument names followed by argument type declarations:
        !          31684:                if (body && Cast==0) {
        !          31685:                        for (nn=at; nn;) {
        !          31686:                                nn->print();
        !          31687:                                if (nn=nn->n_list) puttok(CM); else break;
        !          31688:                        }
        !          31689: #ifdef mips
        !          31690:                        if (nargs_known == ELLIPSIS)
        !          31691:                                putstring(", va_alist");
        !          31692: #endif
        !          31693: #ifdef sparc
        !          31694:                         if (nargs_known == ELLIPSIS)
        !          31695:                                 putstring(", __builtin_va_alist");
        !          31696: #endif
        !          31697:                        putch(')');
        !          31698:                }
        !          31699:                else
        !          31700:                        putch(')');
        !          31701:        }
        !          31702: }
        !          31703: 
        !          31704: void print_body(Pfct f)
        !          31705: {
        !          31706:        if (Cast==0) {
        !          31707:                
        !          31708:                if (ansi_opt==0 && f->f_args) {
        !          31709:                        f->f_args->dcl_print(SM);
        !          31710:                        if ( last_ll==0 && (last_ll = f->body->where.line) )
        !          31711:                                f->body->where.putline();
        !          31712:                }
        !          31713: 
        !          31714:                if (MAIN) {
        !          31715:                        putstring("{ _main(); ");       // call constructors
        !          31716:                        f->body->print();
        !          31717:                        puttok(RC);
        !          31718:                }
        !          31719:                else 
        !          31720:                        f->body->print();
        !          31721:        }
        !          31722: }
        !          31723: 
        !          31724: Pbcl shared_seen;
        !          31725: 
        !          31726: void classdef::print_members()
        !          31727: {
        !          31728:        int i;
        !          31729:        
        !          31730:        Pbcl l = baselist;
        !          31731: // error('d',"%t->print_members()",this);
        !          31732:        if (l) {
        !          31733:                if (l->base == NAME) {
        !          31734:                        l->bclass->print_members();     // first base only
        !          31735:                        // pad to ensure alignment:
        !          31736:                        int boff = l->bclass->real_size;
        !          31737:                        int ba = l->bclass->align();
        !          31738:                        int xtra = boff%ba;
        !          31739:                        int waste = (xtra) ? ba-xtra : 0;       // padding
        !          31740: //error('d',"%s: size % align %d waste %d",string,boff,ba,waste);
        !          31741:                        if (waste) {
        !          31742:                                // waste it to protect against structure
        !          31743:                                // assignments to the base class
        !          31744:                                char* s = make_name('W');
        !          31745:                                fprintf(out_file,"char %s[%d];\n",s,waste);
        !          31746:                                delete s;
        !          31747:                        }
        !          31748:                        l = l->next;
        !          31749:                }
        !          31750: 
        !          31751:                for (; l; l=l->next)
        !          31752:                /*      for second base etc. one must allocate as an object
        !          31753:                        (rather than a list of members) to ensure proper alignment
        !          31754:                        for shared base allocate a pointer
        !          31755:                        size, alignment, & offset handled in cassdef::dcl()
        !          31756:                */
        !          31757:                        if (l->base == NAME) {
        !          31758:                                Pclass bcl = l->bclass;
        !          31759:                                char *str =  0;
        !          31760:                                char *cs = bcl->nested_sig?bcl->nested_sig:bcl->string;
        !          31761:                                if (bcl->lex_level && 
        !          31762:                                        bcl->nested_sig==0) 
        !          31763:                                                str=make_local_name(bcl);
        !          31764:                                puttok(STRUCT);
        !          31765:                                putst(str?str:cs);
        !          31766:                                putcat('O',bcl->string); // leave as unencoded
        !          31767:                                puttok(SM);
        !          31768:                                delete str;
        !          31769:                        }
        !          31770:        }
        !          31771: 
        !          31772:        // Sam: A class or an enum type declared within a class can hide a
        !          31773:        // member with the same name, so make sure that it gets printed by
        !          31774:        // traversing the n_tbl_list to get at these names.
        !          31775:        for (Pname nn=memtbl->get_mem(i=1); nn; nn=memtbl->get_mem(++i)) {
        !          31776:          do { if (nn->base==NAME
        !          31777:                && nn->n_union==0
        !          31778:                && nn->tp->base!=FCT
        !          31779:                && nn->tp->base!=OVERLOAD
        !          31780:                && nn->tp->base!=CLASS
        !          31781:                && nn->tp->base!=ENUM
        !          31782:                && nn->n_stclass != STATIC) {
        !          31783:                //      if (nn->tp->base==FIELD && Pbase(nn->tp)->b_bits==0) continue;
        !          31784:                        Pexpr i = nn->n_initializer;
        !          31785:                        nn->n_initializer = 0;
        !          31786:                        nn->dcl_print(0);
        !          31787:                        nn->n_initializer = i;
        !          31788:                }
        !          31789:          } while ((nn->base == NAME) &&
        !          31790:                 ((nn->tp->base!=CLASS) || (nn->tp->base!=ENUM)) &&
        !          31791:                 (nn = nn->n_tbl_list)) ;
        !          31792:        }
        !          31793: 
        !          31794:        for (l=baselist; l; l=l->next)
        !          31795:                if (l->base==VIRTUAL && l->ptr_offset) {
        !          31796:                        Pclass bcl = l->bclass;
        !          31797:                                char* str =  0;
        !          31798:                        char *cs = bcl->nested_sig?bcl->nested_sig:bcl->string;
        !          31799:                        if (bcl->lex_level && 
        !          31800:                                bcl->nested_sig==0) 
        !          31801:                                        str=make_local_name(bcl);
        !          31802:                        puttok(STRUCT);
        !          31803:                        putst(str?str:cs);
        !          31804:                        putch('*');
        !          31805:                        putcat('P',bcl->string); // leave unencoded
        !          31806:                        puttok(SM);
        !          31807:                        delete str;
        !          31808:                }
        !          31809: }
        !          31810: 
        !          31811: // void classdef::print_vtbl(Pvirt vtab)
        !          31812: // {
        !          31813: // error('d',"%s->print_vtbl(%s) vtbl_opt %d",string,vtab->string,vtbl_opt);
        !          31814: // error('d',"print_vtbl: lex_level: %d", lex_level );
        !          31815: // 
        !          31816: //     switch (vtbl_opt) {
        !          31817: //     case -1:
        !          31818: //     case 1:
        !          31819: //             vlist = new vl(this,vtab,vlist);
        !          31820: //     }
        !          31821: //
        !          31822: //     int oo = vtbl_opt;      // make `simulated static' name
        !          31823: //     vtbl_opt = -1;
        !          31824: //      char* str =  lex_level ? make_local_name(this) : 0;
        !          31825: //      char* s = vtbl_name(vtab->string,str?str:string);
        !          31826: //     vtbl_opt = oo;
        !          31827: //     fprintf(out_file,"extern struct __mptr %s[];\n",s);
        !          31828: //     s[2] = 'p';     // pointer, not tbl itself
        !          31829: //     fprintf(out_file,"extern struct __mptr* %s;\n",s);
        !          31830: //
        !          31831: //       delete s;
        !          31832: //     delete str;
        !          31833: // }
        !          31834: 
        !          31835: vl* vlist;
        !          31836: 
        !          31837: void really_really_print(Pclass cl, Pvirt vtab, char* s, char* ss);
        !          31838: 
        !          31839: int p2(Pname nn, Ptype t, Pclass cl, Pvirt vtab, char* s)
        !          31840: {
        !          31841:        int init;
        !          31842: 
        !          31843:        if (t->base == FCT) {
        !          31844:                Pfct f = Pfct(t);
        !          31845: 
        !          31846: //error('d',"p2 %n init %d inline %d virtual %d",nn,nn->n_initializer,f->f_inline,f->f_virtual);
        !          31847: //error('d',"p2 %s expr %d imeasure %d body %d",s,f->f_expr,f->f_imeasure,f->body);
        !          31848: //error('d',"sto %k",nn->n_sto);
        !          31849:                if (nn->n_initializer
        !          31850:                || nn->n_sto==STATIC
        !          31851:                || f->f_inline
        !          31852:                || f->f_imeasure
        !          31853:                || f->f_virtual==0) return 0;
        !          31854:                init = f->body!=0;
        !          31855:        }
        !          31856:        else
        !          31857:                init = nn->n_initializer!=0;
        !          31858: 
        !          31859:        int oo = vtbl_opt;
        !          31860:        vtbl_opt = 1;   // make sure the name is universal
        !          31861:        char *cs = cl->nested_sig?cl->nested_sig:cl->string;
        !          31862:         char* sstr = (cl->lex_level&&cl->nested_sig==0)? make_local_name(cl) : 0;
        !          31863:         char* ss = vtbl_name(vtab->string,sstr?sstr:cs);
        !          31864: 
        !          31865:        if (init) {     // unique definition here
        !          31866:                really_really_print(cl,vtab,ss,s);
        !          31867:        }
        !          31868:        else {  // unique definition elsewhere
        !          31869:                char *vstr = 0;
        !          31870:                if ( vtab && vtab->string ) {
        !          31871:                        vstr = new char[strlen(vtab->string)+cl->strlen+1];
        !          31872:                        strcpy( vstr, vtab->string );
        !          31873:                        strcat( vstr, cl->string );
        !          31874:                }
        !          31875:                Pname nn;
        !          31876:                if (nn=ptbl->look(vstr?vstr:cl->string,0)) { // use of ptbl in file
        !          31877:                        fprintf(out_file,"extern struct __mptr %s[];\n",ss);
        !          31878:                        s[2] = 'p';
        !          31879:                        // fprintf(out_file,"struct __mptr* %s = ",s);
        !          31880:                        // fprintf(out_file,"%s;\n",ss);
        !          31881:                        ptbl_add_pair(s, ss);
        !          31882:                        nn->n_key=HIDDEN; 
        !          31883:                }
        !          31884:                delete vstr;
        !          31885:        }
        !          31886:        vtbl_opt = oo;
        !          31887: 
        !          31888:        delete ss;
        !          31889:        delete sstr;
        !          31890: 
        !          31891:        return 1;
        !          31892: }
        !          31893: 
        !          31894: void classdef::really_print(Pvirt vtab)
        !          31895: {
        !          31896: // error('d',"really_print %t %d",this,vtbl_opt);
        !          31897:        int oo = vtbl_opt;      // make `simulated static' name
        !          31898:        vtbl_opt = -1;
        !          31899:        char *cs = nested_sig?nested_sig:string;
        !          31900:         char* str = (lex_level&&nested_sig==0) ? make_local_name(this) : 0;
        !          31901:         char* s = vtbl_name(vtab->string,str?str:cs);
        !          31902: // error('d', "really_print: %s, vtab: %s, s: %s", string, vtab->string, s );
        !          31903:        vtbl_opt = oo;
        !          31904: 
        !          31905:        // see if needed
        !          31906:        int i;
        !          31907:        for (Pname nn=memtbl->get_mem(i=1); nn; nn=memtbl->get_mem(++i) ) {
        !          31908:                Ptype t = nn->tp;
        !          31909:        zse:
        !          31910:                if (t)
        !          31911:                switch (t->base) {
        !          31912:                case TYPE:
        !          31913:                        t = Pbase(t)->b_name->tp;
        !          31914:                        goto zse;
        !          31915: /*
        !          31916:                case COBJ:
        !          31917:                        if (nn->n_sto == EXTERN)
        !          31918:                        {       Pclass cl = Pclass(Pbase(t)->b_name->tp);
        !          31919:                                if (cl->has_ctor()) {
        !          31920:                                        p2(nn,t,this,vtab,s);
        !          31921:                                        return;
        !          31922:                                }
        !          31923:                        }
        !          31924:                        break;
        !          31925: */
        !          31926:                case FCT:
        !          31927:                        if (p2(nn,t,this,vtab,s))
        !          31928:                                goto xyzzy;
        !          31929:                        break;
        !          31930: 
        !          31931:                case OVERLOAD:
        !          31932:                {       for (Plist gl=Pgen(t)->fct_list; gl; gl=gl->l)
        !          31933:                                if (p2(gl->f,gl->f->tp,this,vtab,s))
        !          31934:                                        goto xyzzy;
        !          31935:                }
        !          31936:                }
        !          31937:        }
        !          31938: 
        !          31939:         { // must be initialized var in block to permit goto
        !          31940:        char* ss = vtbl_name(vtab->string,str?str:cs);
        !          31941: // error('d', "really_print: %s, vtab: %s, ss: %s", cs, vtab->string, s );
        !          31942: 
        !          31943:        if (vtbl_opt)
        !          31944:                really_really_print(this,vtab,ss,s);
        !          31945:        else {
        !          31946:                char *vstr = 0;
        !          31947:                if ( vtab && vtab->string ) {
        !          31948:                        vstr = new char[::strlen(vtab->string)+strlen+1];
        !          31949:                        strcpy( vstr, vtab->string );
        !          31950:                        strcat( vstr, string );
        !          31951:                }
        !          31952:                Pname nn;
        !          31953:                if (nn=ptbl->look(vstr?vstr:string,0)) { // use of ptbl in file
        !          31954:                        fprintf(out_file,"extern struct __mptr %s[];\n",ss);
        !          31955:                        s[2] = 'p';
        !          31956:                        // fprintf(out_file,"struct __mptr* %s = ",s);
        !          31957:                        // fprintf(out_file,"%s;\n",ss);
        !          31958:                        ptbl_add_pair(s, ss);
        !          31959:                        nn->n_key=HIDDEN; 
        !          31960:                }
        !          31961:                delete vstr;
        !          31962:        }
        !          31963:        delete ss;
        !          31964:        }
        !          31965: xyzzy:
        !          31966:        delete s;
        !          31967:        delete str;
        !          31968: }
        !          31969: 
        !          31970: void really_really_print(Pclass cl, Pvirt vtab, char* s, char* ss)
        !          31971: {
        !          31972: // error('d',"really %s %s",s, ss);
        !          31973:        // make sure function is declared before using
        !          31974:        // it in vtbl initializer
        !          31975:        Pname nn;
        !          31976:        int i;
        !          31977:        for (i=0; nn = vtab->virt_init[i].n; i++) {
        !          31978:                Pfct f = Pfct(nn->tp);
        !          31979:                 if (nn->n_initializer) {       // pure virtual
        !          31980:                        static pv;
        !          31981:                        if (pv == 0) {  // VCVC void->char assumed
        !          31982:                                fprintf(out_file,"char __pure_virtual_called();\n");
        !          31983:                                pv = 1;
        !          31984:                        }
        !          31985:                        continue;
        !          31986:                }
        !          31987:                if (f->base != FCT) error('i',"vtbl %n",nn);
        !          31988: //extern void expand_dtor(Pclass cl);
        !          31989: //             if (f->f_inline == IDTOR) expand_dtor(f->memof);
        !          31990: 
        !          31991:                if (nn->n_dcl_printed==0 /*|| f->f_inline*/) {
        !          31992:                        if (f->f_inline && vtbl_opt) puttok(STATIC);
        !          31993:                        if (f->f_result == 0) make_res(f);
        !          31994:                        Ptype r = f->s_returns ? f->s_returns : f->returns;
        !          31995:                        r->print();
        !          31996:                        nn->print();
        !          31997:                        putstring("()");
        !          31998:                        puttok(SM);
        !          31999:                        nn->n_dcl_printed = 1;
        !          32000:                }
        !          32001:        }
        !          32002: 
        !          32003: //     if (vtbl_opt == -1) puttok(STATIC);
        !          32004: 
        !          32005: 
        !          32006:         fprintf(out_file,"struct __mptr %s[] = {0,0,0,\n",s);
        !          32007: 
        !          32008:        Pname n;
        !          32009:        for (i=0; n=vtab->virt_init[i].n; i++) {
        !          32010:                if (n->n_initializer)
        !          32011:                        putstring("0,0,(__vptp)__pure_virtual_called,\n");
        !          32012:                else {
        !          32013:                        fprintf(out_file,"%d,0,(__vptp)",-vtab->virt_init[i].offset);
        !          32014:                        n->print();
        !          32015:                        n->n_addr_taken = 1;
        !          32016:                        putstring(",\n");
        !          32017:                }
        !          32018:        }
        !          32019:        putstring("0,0,0};\n");
        !          32020: 
        !          32021:        ss[2] = 'p';
        !          32022:         // fprintf(out_file,"struct __mptr* %s = ",ss);
        !          32023:        s[2] = 'v';
        !          32024:         // fprintf(out_file,"%s;\n",s);
        !          32025:        ptbl_add_pair(ss,s);
        !          32026: 
        !          32027:         Pname nm;
        !          32028:        char *cstr = 0;
        !          32029:        char *vstr = 0;
        !          32030:        char *cs = cl->nested_sig?cl->nested_sig:cl->string;
        !          32031:        if (cl->lex_level && cl->nested_sig==0) cstr = make_local_name( cl );
        !          32032:        if ( vtab && vtab->string ) {
        !          32033:                vstr = new char[strlen(vtab->string)+(cstr?strlen(cstr):strlen(cs))+1];
        !          32034:                strcpy( vstr, vtab->string );
        !          32035:                strcat( vstr, cstr?cstr:cs );
        !          32036:        }
        !          32037: 
        !          32038:        if ( vstr == 0 ) vstr = cstr;
        !          32039:        if ( nm = ptbl->look(vstr?vstr:cl->string,0) ) 
        !          32040:                nm->n_key = HIDDEN;
        !          32041:        else 
        !          32042:        if ( ptbl->look(vstr?vstr:cl->string,HIDDEN) == 0 )
        !          32043:                ptbl->insert(new name(vstr?vstr:cl->string),HIDDEN);
        !          32044:         if (cstr == vstr) delete cstr;
        !          32045:         else {
        !          32046:                 delete cstr;
        !          32047:                 delete vstr;
        !          32048:         }
        !          32049: 
        !          32050: //error('d',"really-> %s",s);
        !          32051: }
        !          32052: 
        !          32053: #include <ctype.h>
        !          32054: char* vtbl_name(char* s1, char* s2)
        !          32055: {
        !          32056:        char* s3 = (vtbl_opt == -1 && *src_file_name) ? src_file_name : 0;
        !          32057:                // if vtbl_opt == -1 fake a static (there are no portable
        !          32058:                // way of doing a forward declaration of a static in C)
        !          32059:        int ll = s1 ? strlen(s1) : 0;
        !          32060:        int ll2 = strlen(s2);
        !          32061:        int ll3 = s3 ? strlen(s3) : 0;
        !          32062:         int sz = (ll+ll2+ll3+20)/32+1;  // avoid fragmentation
        !          32063: 
        !          32064:         sz *= 32;
        !          32065: // error('d',"vtbl_name(%s,%s,%s) %d",s1?s1:"",s2,s3?s3:"",sz);
        !          32066:         char* buf = new char[sz];
        !          32067:        if (s3) {
        !          32068:                if (s1)
        !          32069:                        sprintf(buf,"__vtbl__%d%s__%d%s__%s",ll,s1,ll2,s2,s3);
        !          32070:                else
        !          32071:                        sprintf(buf,"__vtbl__%d%s__%s",ll2,s2,s3);
        !          32072:        }
        !          32073:        else if (s1)
        !          32074:                sprintf(buf,"__vtbl__%d%s__%d%s",ll,s1,ll2,s2);
        !          32075:        else
        !          32076:                sprintf(buf,"__vtbl__%d%s",ll2,s2);
        !          32077: 
        !          32078:        if (vtbl_opt == -1) {
        !          32079:                for (char* p = buf+ll2+11; *p; p++)
        !          32080:                        if (!isalpha(*p) && !isdigit(*p)) *p = '_';
        !          32081:        }
        !          32082: #ifdef DENSE
        !          32083:        chop(buf);
        !          32084: #endif
        !          32085:        return buf;
        !          32086: }
        !          32087: 
        !          32088: void classdef::print_all_vtbls(Pclass bcl)
        !          32089: {
        !          32090: //error('d',"%t->print_all_vtbls(%t) vlt %d bl %d",this,bcl,virt_list,baselist);
        !          32091: 
        !          32092:        for (Pvirt blist = bcl->virt_list; blist; blist = blist->next) {
        !          32093:                if (this != blist->vclass) continue;
        !          32094:                if (blist->printed) continue;
        !          32095:         //      if (blist->string==0 && find_vptr(this)==0) {        //BSopt
        !          32096:         //              continue;
        !          32097:         //      }
        !          32098:        //      print_vtbl(blist);
        !          32099:                vlist = new vl(this,blist,vlist);
        !          32100:                blist->printed = 1;
        !          32101:        }
        !          32102: 
        !          32103:        for (Pbcl b = bcl->baselist; b; b = b->next)
        !          32104:                print_all_vtbls(b->bclass);
        !          32105: 
        !          32106:        if (this==bcl) c_body = 0;
        !          32107: }
        !          32108: 
        !          32109: extern Pclass current_instantiation;
        !          32110: void classdef::dcl_print(Pname)
        !          32111: { 
        !          32112: //error('d',"%t->classdef::dcl_print() -- c_body==%d defined==0%o",this,c_body,defined);
        !          32113:        defined |= REF_SEEN;
        !          32114: // ensure template instantiations are printed exactly once.
        !          32115:         if (class_base != vanilla_class && current_instantiation != this) return;
        !          32116: 
        !          32117:        if (c_body==0 || c_body==3 || (defined&DEFINED)==0) return;
        !          32118:        c_body = 3;
        !          32119: 
        !          32120:        int i;
        !          32121:        for (Pname nn=memtbl->get_mem(i=1); nn; nn=memtbl->get_mem(++i) ) {
        !          32122:                if (nn->base==NAME
        !          32123:                && nn->n_union==0
        !          32124:                && nn->tp->base==CLASS
        !          32125:                && Pclass(nn->tp)->c_body==1)
        !          32126:                        Pclass(nn->tp)->dcl_print(nn);
        !          32127:                else if (nn->base == TNAME && Pbase(nn->tp)->base != COBJ)
        !          32128:                        nn->dcl_print(0);
        !          32129:                 else if (nn->tp && nn->tp->base == ENUM) {
        !          32130:                        if(nn->n_union==0) Penum(nn->tp)->dcl_print(nn);
        !          32131:                }
        !          32132:        }
        !          32133: 
        !          32134:        TOK lvl = in_class ? NESTED : lex_level ? LOCAL : 0;
        !          32135:        Pname n = ktbl->look(string,lvl);
        !          32136:        if (n==0) n = ktbl->look(string,HIDDEN);
        !          32137: 
        !          32138:        if (n) {
        !          32139:                if (n->where.line!=last_line.line
        !          32140:                || n->where.file!=last_line.file)
        !          32141:                        if (last_ll = n->where.line)
        !          32142:                                n->where.putline();
        !          32143:                        else
        !          32144:                                last_line.putline();
        !          32145:        }
        !          32146: 
        !          32147:        TOK c = csu==CLASS ? STRUCT : csu;
        !          32148:        puttok(c);
        !          32149: //     if (string[0]!='_' || string[1]!='_' || string[2]!='C')
        !          32150: 
        !          32151:         char *str = 0;
        !          32152:        if ( lex_level && nested_sig == 0) str = make_local_name( this );
        !          32153:        if ( nested_sig ) putstring( " __" );
        !          32154:        putst(str?str:(nested_sig?nested_sig:string));
        !          32155: 
        !          32156:        int sm = 0;
        !          32157:        int sz = tsizeof();
        !          32158:        int dvirt = 0;
        !          32159: 
        !          32160:        if ( nested_sig )
        !          32161:                fprintf(out_file,"{\t/* sizeof __%s == %d */\n",nested_sig,obj_size);
        !          32162:        else
        !          32163:                fprintf(out_file,"{\t/* sizeof %s == %d */\n",str?str:string,obj_size);
        !          32164:        if ( last_ll ) last_line.line++;
        !          32165:        delete str;
        !          32166: 
        !          32167:        print_members();
        !          32168:        for (Pbcl b = baselist; b; b = b->next) {       // declare virtual classes
        !          32169:                if (b->base != VIRTUAL) continue;
        !          32170:                Pclass bcl = b->bclass;
        !          32171:                dvirt += bcl->virt_count;
        !          32172: //error('d',"%t in %t %d",b->bclass,this,b->allocated);
        !          32173:                if (b->allocated==0) continue;
        !          32174:                char* str =  0;
        !          32175:                if (bcl->lex_level) str = make_local_name(bcl);
        !          32176:                puttok(STRUCT);                 // struct bcl Obcl;
        !          32177:                putst(str?str:bcl->string);
        !          32178:                putcat('O',bcl->string); // leave unencoded
        !          32179:                puttok(SM);
        !          32180:                delete str;
        !          32181:        }
        !          32182:        putstring("};\n");
        !          32183:        if ( last_ll ) last_line.line++;
        !          32184: 
        !          32185:        for (nn=memtbl->get_mem(i=1); nn; nn=memtbl->get_mem(++i) ) {
        !          32186:                if (nn->base==NAME && nn->n_union==0) {
        !          32187:                        Ptype t = nn->tp;
        !          32188:                        switch (t->base) {
        !          32189:                        case FCT:
        !          32190:                        case OVERLOAD:
        !          32191:                                break;
        !          32192:                        default:
        !          32193:                                if (nn->n_stclass == STATIC) {
        !          32194:                                        TOK b = nn->n_sto;
        !          32195: //error('d',"print nn %n tp %t b %k eval %d",nn,nn->tp,b,nn->n_evaluated);
        !          32196:                                /*
        !          32197:                                        Pname cn;
        !          32198:                                        TOK bb = ((cn=nn->tp->is_cl_obj())
        !          32199:                                        && Pclass(cn->tp)->has_ctor())==0
        !          32200:                                                ?0:b; // force explicit initialization
        !          32201:                                        nn->n_sto = (nn->n_evaluated) ? STATIC : bb;
        !          32202:                                */
        !          32203:                                        nn->n_sto = (nn->n_evaluated) ? STATIC : b;
        !          32204:                                        nn->dcl_print(0);
        !          32205:                                        nn->n_sto = b;
        !          32206:                                }
        !          32207:                        }
        !          32208:                }
        !          32209:        }
        !          32210:        if (vtbl_opt != -1) print_all_vtbls(this);      // force declaration
        !          32211: //error('d',"dcl_print -> ");
        !          32212: }
        !          32213: 
        !          32214: 
        !          32215: char *
        !          32216: make_local_name( Pclass cl, int ln ) 
        !          32217: {
        !          32218:     char *buf; 
        !          32219:     if ( cl->in_fct == 0 ) error( 'i', "localC %s missingFN", cl->string ); 
        !          32220:     char *fsig = Pfct(cl->in_fct->tp)->f_signature;
        !          32221:     if ( fsig == 0 ) fsig = local_sign( cl->in_fct->tp );
        !          32222:     char *fs = cl->in_fct->string;
        !          32223:     int class_len=cl->strlen+strlen(fsig)+strlen(fs)+strlen(cl->lcl)+4;
        !          32224:     int sz = (class_len+20)/32+1; // from vtbl_name()
        !          32225: 
        !          32226:     if ( Pfct(cl->in_fct->tp)->memof == 0 ) {
        !          32227:         sz *= 32;
        !          32228:         buf = new char[ sz ];
        !          32229: // error('d', "make_local_name: sz: %d", sz );
        !          32230: 
        !          32231:          if (ln) 
        !          32232:              sprintf(buf, "__%d%s__%s__%s%s", class_len, cl->string, fs, fsig, cl->lcl);
        !          32233:         else
        !          32234:              sprintf(buf, "%s__%s__%s%s", cl->string, fs, fsig, cl->lcl);
        !          32235:     }
        !          32236:     else 
        !          32237:     {
        !          32238:         char *cs = Pclass(Pfct(cl->in_fct->tp)->memof)->string;
        !          32239:         int len = Pclass(Pfct(cl->in_fct->tp)->memof)->strlen;
        !          32240:         if ( len < 10 )
        !          32241:             ++class_len;
        !          32242:        else 
        !          32243:         if ( len > 99 )
        !          32244:             class_len += 3;
        !          32245:        else class_len += 2;
        !          32246:        class_len += len;
        !          32247:         sz = (class_len+20)/32+1; 
        !          32248:        sz *= 32;
        !          32249:         buf = new char[ sz ];
        !          32250: // error('d', "make_local_name: sz: %d", sz );
        !          32251: 
        !          32252:        if ( ln )
        !          32253:              sprintf(buf, "__%d%s__%s__%d%s%s%s",class_len,cl->string,fs,len,cs,fsig,cl->lcl);
        !          32254:         else sprintf(buf, "%s__%s__%d%s%s%s",cl->string,fs,len,cs,fsig,cl->lcl);
        !          32255:     }
        !          32256: 
        !          32257: #ifdef DENSE
        !          32258:     chop( buf );
        !          32259: #endif
        !          32260: 
        !          32261:     return buf;
        !          32262: }
        !          32263: 
        !          32264: 0707071010112046021004440001630000160000010210070466055415700001500000001262print_self.c/* ident "@(#)ctrans:src/print_self.c 1.2" */
        !          32265: /* print_self_default.C -- bailout versions of print_self and format_self */
        !          32266: /*
        !          32267:        $Source: /usr2/odi/lib.src/RCS/print_self_default.C,v $ $RCSfile: print_self_default.C,v $
        !          32268:        $Revision: 1.4 $                $Date: 89/09/19 11:49:58 $
        !          32269:        $Author: benson $               $Locker:  $
        !          32270:        $State: Exp $
        !          32271: */
        !          32272: 
        !          32273: #include "print_self.h"
        !          32274: 
        !          32275: int ostream_printf (ostream&, const char * ...);
        !          32276: 
        !          32277: int _Print_self::print_self (ostream& stream) const
        !          32278: {
        !          32279:     return ostream_printf (stream, "<%s at 0x%p>", 
        !          32280:                           this->type_name(), (void *) this);
        !          32281: }
        !          32282: 
        !          32283: int _Print_self::format_self (ostream& stream) const
        !          32284: {
        !          32285:     return ostream_printf (stream, "<%s at 0x%p>", 
        !          32286:                           this->type_name(), (void *) this);
        !          32287: }
        !          32288: 0707071010112046111004440001630000160000010211170466055421300001500000001261print_self.h/* ident "@(#)ctrans:src/print_self.h 1.2" */
        !          32289: /* print_self.H -- base class for objects that want to support
        !          32290:    the 'official' print self for \T in printf. */
        !          32291: 
        !          32292: /*
        !          32293:     $Header: /usr2/odi/include/RCS/print_self.H,v 1.4 89/09/19 11:49:19 benson Exp $
        !          32294: 
        !          32295:     Copyright (c) 1989 by Object Design, Inc., Burlington, Mass.
        !          32296:     All rights reserved.
        !          32297: 
        !          32298: */
        !          32299: 
        !          32300: #ifndef _PRINT_SELF_CLASS
        !          32301: #define _PRINT_SELF_CLASS
        !          32302: #include <iostream.h>
        !          32303: 
        !          32304: class _Print_self {
        !          32305:   public:
        !          32306:     virtual char * type_name () const { return "OBJECT"; }
        !          32307:     virtual int print_self (ostream&) const; // returns count of characters printed.
        !          32308:     virtual int format_self (ostream&) const; // returns count of characters printed.
        !          32309: };
        !          32310: #endif
        !          32311: 0707071010112044421004440001630000160000010206300466055407100000700000010531repr.c/*ident     "@(#)ctrans:src/repr.c  1.4" */
        !          32312: /**************************************************************************
        !          32313: 
        !          32314:         C++ source for cfront, the C++ compiler front-end
        !          32315:         written in the computer science research center of Bell Labs
        !          32316: 
        !          32317:         Copyright (c) 1984 AT&T, Inc. All Rights Reserved
        !          32318:         THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T, INC.
        !          32319: 
        !          32320: repr.c:
        !          32321: 
        !          32322: *****************************************************************************/
        !          32323: 
        !          32324: #include "cfront.h"
        !          32325: 
        !          32326: char* oper_name(TOK op)
        !          32327: /*
        !          32328:        return the string representation of operator "op"
        !          32329: */
        !          32330: {
        !          32331:        switch (op) {
        !          32332:        default:        error('i',"oper_name(%k)",op);
        !          32333:        case GNEW:
        !          32334:        case NEW:       return "__nw";
        !          32335:        case GDELETE:
        !          32336:        case DELETE:    return "__dl";
        !          32337:        case MUL:       return "__ml";
        !          32338:        case DIV:       return "__dv";
        !          32339:        case MOD:       return "__md";
        !          32340:        case UPLUS:
        !          32341:        case PLUS:      return "__pl";
        !          32342:        case MINUS:
        !          32343:        case UMINUS:    return "__mi";
        !          32344:        case LS:        return "__ls";
        !          32345:        case RS:        return "__rs";
        !          32346:        case EQ:        return "__eq";
        !          32347:        case NE:        return "__ne";
        !          32348:        case LT:        return "__lt";
        !          32349:        case GT:        return "__gt";
        !          32350:        case LE:        return "__le";
        !          32351:        case GE:        return "__ge";
        !          32352:        case AND:
        !          32353:        case ADDROF:    return "__ad";
        !          32354:        case OR:        return "__or";
        !          32355:        case ER:        return "__er";
        !          32356:        case ANDAND:    return "__aa";
        !          32357:        case OROR:      return "__oo";
        !          32358:        case NOT:       return "__nt";
        !          32359:        case COMPL:     return "__co";
        !          32360:        case INCR:      return "__pp";
        !          32361:        case DECR:      return "__mm";
        !          32362:        case CALL:      return "__cl";
        !          32363:        case DEREF:     return "__vc";
        !          32364:        case ASSIGN:    return "__as";
        !          32365:        case REF:       return "__rf";
        !          32366:        case ASPLUS:    return "__apl";
        !          32367:        case ASMINUS:   return "__ami";
        !          32368:        case ASMUL:     return "__amu";
        !          32369:        case ASDIV:     return "__adv";
        !          32370:        case ASMOD:     return "__amd";
        !          32371:        case ASLS:      return "__als";
        !          32372:        case ASRS:      return "__ars";
        !          32373:        case ASAND:     return "__aad";
        !          32374:        case ASOR:      return "__aor";
        !          32375:        case ASER:      return "__aer";
        !          32376:        case CTOR:      return "__ct";
        !          32377:        case DTOR:      return "__dt";
        !          32378: //     operator T              "__op"<signature of T>
        !          32379: //     case SIZEOF:    return "sizeof";
        !          32380:        case CM:        return "__cm";
        !          32381:        case REFMUL:    return "__rm";
        !          32382: // library functions:
        !          32383: //                             "_vec_delete"
        !          32384: //                             "_vec_new"
        !          32385: //                             "_main"
        !          32386:        }
        !          32387: }
        !          32388: 
        !          32389: #define new_op(ss,v) keys[v]=ss
        !          32390: 
        !          32391: void otbl_init()
        !          32392: /*
        !          32393:        operator representation table
        !          32394: */
        !          32395: {
        !          32396:        new_op("->",REF);
        !          32397:        new_op("." ,DOT);
        !          32398:        new_op(".* or ->*" ,REFMUL);
        !          32399:        new_op("mdot" ,REFMUL);
        !          32400:        new_op("!" ,NOT);
        !          32401:        new_op("~" ,COMPL);
        !          32402:        new_op("++",INCR);
        !          32403:        new_op("--",DECR);
        !          32404:        new_op("*" ,MUL);
        !          32405:        new_op("&" ,AND);
        !          32406:        new_op("&" ,ADDROF);
        !          32407:        new_op("&" ,G_ADDROF);
        !          32408:        new_op("/" ,DIV);
        !          32409:        new_op("%" ,MOD);
        !          32410:        new_op("+" ,PLUS);
        !          32411:        new_op("+" ,UPLUS);
        !          32412:        new_op("-" ,MINUS);
        !          32413:        new_op("-" ,UMINUS);
        !          32414:        new_op("<<",LS);
        !          32415:        new_op(">>",RS);
        !          32416:        new_op("<" ,LT);
        !          32417:        new_op(">" ,GT);
        !          32418:        new_op("<=",LE);
        !          32419:        new_op(">=",GE);
        !          32420:        new_op("==",EQ);
        !          32421:        new_op("!=",NE);
        !          32422:        new_op("^" ,ER);
        !          32423:        new_op("|" ,OR);
        !          32424:        new_op("&&",ANDAND);
        !          32425:        new_op("||",OROR);
        !          32426:        new_op("?:" ,QUEST);
        !          32427: //     new_op(":" ,COLON);
        !          32428:        new_op("=" ,ASSIGN);
        !          32429:        new_op("," ,CM);
        !          32430:        new_op("," ,G_CM);
        !          32431: 
        !          32432:        new_op(";" ,SM);
        !          32433:        new_op("{" ,LC);
        !          32434:        new_op("}" ,RC);
        !          32435:        new_op("(" ,LP);
        !          32436:        new_op(")" ,RP);
        !          32437:        new_op("[" ,LB);
        !          32438:        new_op("]" ,RB);
        !          32439: 
        !          32440:        new_op("+=",ASPLUS);
        !          32441:        new_op("-=",ASMINUS);
        !          32442:        new_op("*=",ASMUL);
        !          32443:        new_op("/=",ASDIV);
        !          32444:        new_op("%=",ASMOD);
        !          32445:        new_op("&=",ASAND);
        !          32446:        new_op("|=",ASOR);
        !          32447:        new_op("^=",ASER);
        !          32448:        new_op(">>=",ASRS);
        !          32449:        new_op("<<=",ASLS);
        !          32450: 
        !          32451: //     new_op("sizeof",SIZEOF);
        !          32452: //     new_op("new",NEW);
        !          32453: //     new_op("delete",DELETE);
        !          32454: 
        !          32455:        new_op("0" ,ZERO);
        !          32456:        new_op("[]" ,DEREF);
        !          32457:        new_op("expression list", ELIST);
        !          32458:        new_op("initializer list", ILIST);
        !          32459:        new_op("static initializer", STAT_INIT);
        !          32460:        new_op("()", CALL);
        !          32461:        new_op("generated function call",G_CALL);
        !          32462:        new_op("inline function call",ICALL);
        !          32463:        new_op("cast",CAST);
        !          32464:        new_op("inline argument",ANAME);
        !          32465:        new_op("text",TEXT);
        !          32466:        new_op(".*",MEMPTR);
        !          32467: 
        !          32468:        new_op("class type", COBJ);
        !          32469:        new_op("enum type", EOBJ);
        !          32470:        new_op("union", ANON);
        !          32471: 
        !          32472:        new_op("function",FCT);
        !          32473:        new_op("pointer",PTR);
        !          32474:        new_op("reference",RPTR);
        !          32475:        new_op("array",VEC);
        !          32476:        new_op("identifier",ID);
        !          32477:        new_op("name",NAME);
        !          32478:        new_op("...",ELLIPSIS);
        !          32479:        new_op("::",MEM);
        !          32480:        new_op("type name",TYPE);
        !          32481:        new_op("tname",TNAME);
        !          32482:        new_op("{}",BLOCK);
        !          32483:        new_op("pair",PAIR);
        !          32484:        new_op("declaration",DCL);
        !          32485:        new_op("character constant",CCON);
        !          32486:        new_op("integer constant",ICON);
        !          32487:        new_op("float constant",FCON);
        !          32488:        new_op("integer value",IVAL);
        !          32489:        new_op("string",STRING);
        !          32490:        new_op("label",LABEL);
        !          32491:        new_op("'class', 'struct', or 'union'",AGGR);
        !          32492:        new_op(" argument",ARG);
        !          32493:        new_op(" empty expression",DUMMY);
        !          32494:        new_op(" ::new",GNEW);
        !          32495:        new_op(" constructor call",VALUE);
        !          32496:        new_op(" ::delete",GDELETE);
        !          32497:        new_op(ansi_opt?" long double":" double",LDOUBLE);
        !          32498:        new_op(" typedef",NESTED); // did not want to introduce new TOKEN
        !          32499: }
        !          32500: 0707071010112044431004440001630000160000010206400466055407500001000000067265simpl.c/*ident    "@(#)ctrans:src/simpl.c 1.3" */
        !          32501: /******************************************************************
        !          32502: 
        !          32503:        C++ source for cfront, the C++ compiler front-end
        !          32504:        written in the computer science research center of Bell Labs
        !          32505: 
        !          32506:        Copyright (c) 1984 AT&T, Inc. All rights Reserved
        !          32507:        THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T, INC.
        !          32508: 
        !          32509: simpl.c:
        !          32510: 
        !          32511:        simplify the typechecked function
        !          32512:        remove:         classes:
        !          32513:                                class fct-calls
        !          32514:                                operators
        !          32515:                                value constructors and destructors
        !          32516:                        new and delete operators (replace with function calls)
        !          32517:                        initializers            (turn them into statements)
        !          32518:                        constant expressions            (evaluate them)
        !          32519:                        inline functions                (expand the calls)
        !          32520:                        enums                           (make const ints)
        !          32521:                        unreachable code                (delete it)
        !          32522:        make implicit coersions explicit
        !          32523: 
        !          32524:        in general you cannot simplify something twice
        !          32525: 
        !          32526: *******************************************************************/
        !          32527: 
        !          32528: #include "cfront.h"
        !          32529: 
        !          32530: Pname new_fct;
        !          32531: Pname del_fct;
        !          32532: Pname vec_new_fct;
        !          32533: Pname vec_del_fct;
        !          32534: 
        !          32535: Pstmt del_list;
        !          32536: Pstmt break_del_list;
        !          32537: Pstmt continue_del_list;
        !          32538: 
        !          32539: //bit not_inl; // is the current function an inline?
        !          32540: Pname curr_fct;        // current function
        !          32541: Pexpr init_list;
        !          32542: Pexpr one;
        !          32543: 
        !          32544: Ptype Pfct_type;
        !          32545: Ptype Pvptr_type;
        !          32546: Pbase mptr_type;
        !          32547: Ptype size_t_type;
        !          32548: 
        !          32549: Pstmt trim_tail(Pstmt tt);
        !          32550: Pname find_vptr(Pclass);
        !          32551: char *get_classname(char*);
        !          32552: char *drop_classname(char*);
        !          32553: loc no_where;  // 0,0
        !          32554: 
        !          32555: int imeasure;  // a counter trying to measure the complexity of a function
        !          32556:                // body to try to avoid expanding ``monster'' inlines.
        !          32557: 
        !          32558: static Pclass topclass;
        !          32559: 
        !          32560: void simpl_init()
        !          32561: {
        !          32562:        char* ns = oper_name(NEW);
        !          32563:        char* ds = oper_name(DELETE);
        !          32564: 
        !          32565:        size_t_type = Pvoid_type->tsizeof()>uint_type->tsizeof()?ulong_type:uint_type;
        !          32566: 
        !          32567:        Pname nw = new name(ns);
        !          32568:        nw->n_oper = NEW;
        !          32569:        Pname a = new name;
        !          32570:        a->tp = size_t_type;
        !          32571:        nw->tp = new fct(Pvoid_type,a,1);
        !          32572:        new_fct = nw->dcl(gtbl,EXTERN); // void* operator new(long);
        !          32573:        delete nw;
        !          32574:  //    new_fct->use();
        !          32575: 
        !          32576:        Pname dl = new name(ds);
        !          32577:        dl->n_oper = DELETE;
        !          32578:        a = new name;
        !          32579:        a->tp = Pvoid_type;
        !          32580:        dl->tp = new fct(void_type,a,1);
        !          32581:        del_fct = dl->dcl(gtbl,EXTERN);
        !          32582:        delete dl;
        !          32583:  //    del_fct->use();
        !          32584: 
        !          32585: 
        !          32586:        Pname vn = new name("__vec_new");
        !          32587:        Pname vd = new name("__vec_delete");
        !          32588: 
        !          32589:        a = new name;
        !          32590:        a->tp = Pvoid_type;
        !          32591:        Pname al = a;
        !          32592:        a = new name;
        !          32593:        a->tp = int_type;
        !          32594:        a->n_list = al;
        !          32595:        al = a;
        !          32596:        a = new name;
        !          32597:        a->tp = int_type;
        !          32598:        a->n_list = al;
        !          32599:        al = a;
        !          32600:        a = new name;   
        !          32601:        a->tp = Pvoid_type;
        !          32602:        a->n_list = al;
        !          32603:        al = a;                         /* (Pvoid, int, int, Pvoid) */
        !          32604: 
        !          32605:        vec_new_fct = gtbl->insert(vn,0);
        !          32606:        delete vn;
        !          32607:        vec_new_fct->tp = new fct(Pvoid_type,al,1);
        !          32608:        Pfct(vec_new_fct->tp)->f_linkage = linkage_C;
        !          32609:        vec_new_fct->n_scope = EXTERN;
        !          32610:        PERM(vec_new_fct);
        !          32611:        PERM(vec_new_fct->tp);
        !          32612:        vec_new_fct->use();
        !          32613:        vec_new_fct->dcl_print(0);
        !          32614: 
        !          32615:        a = new name;
        !          32616:        a->tp = int_type;
        !          32617:        al = a;
        !          32618:        a = new name;
        !          32619:        a->tp = int_type;
        !          32620:        a->n_list = al;
        !          32621:        al = a;
        !          32622:        a = new name;
        !          32623:        a->tp = Pvoid_type;
        !          32624:        a->n_list = al;
        !          32625:        al = a;
        !          32626:        a = new name;
        !          32627:        a->tp = int_type;
        !          32628:        a->n_list = al;
        !          32629:        al = a;
        !          32630:        a = new name;
        !          32631:        a->tp = int_type;
        !          32632:        a->n_list = al;
        !          32633:        al = a;
        !          32634:        a = new name;   
        !          32635:        a->tp = Pvoid_type;
        !          32636:        a->n_list = al;
        !          32637:        al = a;                         /* (Pvoid, int, int, Pvoid, int, int) */
        !          32638: 
        !          32639:        vec_del_fct = gtbl->insert(vd,0);
        !          32640:        delete vd;
        !          32641:        vec_del_fct->tp = new fct(void_type,al,1);
        !          32642:        Pfct(vec_del_fct->tp)->f_linkage = linkage_C;
        !          32643:        vec_del_fct->n_scope = EXTERN;
        !          32644:        PERM(vec_del_fct);
        !          32645:        PERM(vec_del_fct->tp);
        !          32646:        vec_del_fct->use();
        !          32647:        vec_del_fct->dcl_print(0);
        !          32648: 
        !          32649:        one = new ival(1);
        !          32650:        one->tp = int_type;
        !          32651:        PERM(one);
        !          32652:        
        !          32653:        Pfct_type = new fct(int_type,0,1);      // int (*)()
        !          32654:        Pfct_type = Pfct_type->addrof();
        !          32655:        PERM(Pfct_type);
        !          32656: 
        !          32657:        putstring("typedef int (*__vptp)();\n");
        !          32658:        putstring("struct __mptr {short d; short i; __vptp f; };\n");
        !          32659:        Pname b = new name("__mptr");
        !          32660:         b->tp = new classdef(STRUCT);
        !          32661:         b->tp->defined = 1;
        !          32662:         Pclass(b->tp)->obj_size = 8;
        !          32663:        mptr_type = new basetype(COBJ,b);
        !          32664:        PERM(mptr_type);
        !          32665: 
        !          32666:        Pvptr_type = mptr_type->addrof();
        !          32667:        PERM(Pvptr_type);
        !          32668: }
        !          32669: 
        !          32670: Ptable scope;          /* current scope for simpl() */
        !          32671: Pname expand_fn;       /* name of function being expanded or 0 */
        !          32672: Ptable expand_tbl;     /* scope for inline function variables */
        !          32673: 
        !          32674: Pname classdef::has_oper(TOK op)
        !          32675: {
        !          32676:        Pexpr n = find_name(oper_name(op),0);
        !          32677:        if (n == 0) return 0;
        !          32678: 
        !          32679:        while (n->base==REF || n->base==MDOT) {
        !          32680:                Pexpr e = Pexpr(n);
        !          32681:                n = Pname(n->mem);
        !          32682:                delete e;
        !          32683:        }
        !          32684:        if (n->tp->base==FCT && Pname(n)->n_dcl_printed==0) Pname(n)->dcl_print(0);
        !          32685:        return Pname(n);
        !          32686: }
        !          32687: 
        !          32688: int is_expr(Pstmt s)
        !          32689: /*
        !          32690:        is this statement simple enough to be converted into an expression for
        !          32691:        inline expansion?
        !          32692: */
        !          32693: {
        !          32694:        int i = 0;
        !          32695:        while (s->base == BLOCK) {
        !          32696:                if (s->s == 0) return 1;
        !          32697:                s = s->s;
        !          32698:        }
        !          32699:        for (Pstmt ss = s; ss; ss = ss->s_list) {
        !          32700: //error('d',"ss %k",ss->base);
        !          32701:                switch (ss->base) {
        !          32702:                case BLOCK:
        !          32703:                        if (Pblock(ss)->memtbl || is_expr(ss->s)==0) return 0;
        !          32704:                case SM:
        !          32705:                        if (ss->e && ss->e->base==ICALL) {
        !          32706:                                Pname fn = ss->e->il->fct_name;
        !          32707:                                Pfct f = Pfct(fn->tp);
        !          32708:                                if (f->f_expr == 0) return 0;
        !          32709:                        }
        !          32710:                        break;
        !          32711:                case IF:
        !          32712:                        if (is_expr(ss->s)==0) return 0;
        !          32713:                        if (ss->else_stmt && is_expr(ss->else_stmt)==0) return 0;
        !          32714:                        break;
        !          32715:                default:
        !          32716:                        return 0;
        !          32717:                }
        !          32718:                i++;
        !          32719:        }
        !          32720:        return i;
        !          32721: }
        !          32722: 
        !          32723: int no_of_returns;
        !          32724: 
        !          32725: void name::simpl()
        !          32726: {
        !          32727: //error('d',"name::simpl%n %d %k",this,tp->base,tp->base);
        !          32728:        if (base == PUBLIC) return;
        !          32729: 
        !          32730:        if (tp == 0) error('i',"%n->N::simple(tp==0)",this);
        !          32731: 
        !          32732:        switch (tp->base) {
        !          32733:        case 0:
        !          32734:                error('i',"%n->N::simpl(tp->B==0)",this);
        !          32735: 
        !          32736:        case TYPE:
        !          32737:        case VEC:
        !          32738:        case PTR:
        !          32739:        {
        !          32740:                Ptype t = tp;
        !          32741:        xx:
        !          32742:                switch (t->base) {
        !          32743:                case TYPE:      t = Pbase(t)->b_name->tp;       goto xx;
        !          32744:                case VEC:       t = Pvec(t)->typ;               goto xx;
        !          32745:                case PTR:       t = Pptr(t)->typ;               goto xx;
        !          32746:                case FCT:       break;
        !          32747:                }
        !          32748:                break;
        !          32749:        }
        !          32750: 
        !          32751:        case OVERLOAD:
        !          32752:        {       for (Plist gl = Pgen(tp)->fct_list; gl; gl=gl->l) gl->f->simpl();
        !          32753:                break;
        !          32754:        }
        !          32755: 
        !          32756:        case FCT:
        !          32757:        {       Pfct f = Pfct(tp);
        !          32758:                Pname n;
        !          32759:                Pname th = f->f_this;
        !          32760: 
        !          32761:                if (th) {
        !          32762:                        // Make "this" a register if it is used more than twice:
        !          32763:                        if (th->n_addr_taken) error("&this");
        !          32764:                        th->n_stclass = (2 < th->n_used) ? REGISTER : AUTO;
        !          32765:                        if (warning_opt
        !          32766:                        && th->n_assigned_to
        !          32767:                        && th->n_assigned_to!=FUDGE111)
        !          32768:                                error('w',&where,"assignment to this (anachronism)");
        !          32769:                }
        !          32770: 
        !          32771:                if (tp->defined & (SIMPLIFIED | ~DEFINED) ) return;
        !          32772: 
        !          32773:                for (n=f->f_args; n; n=n->n_list) n->simpl();
        !          32774: 
        !          32775:                if (f->body) {
        !          32776:                        Ptable oscope = scope;
        !          32777:                        Pname ocurr = curr_fct;
        !          32778:                        int oim = imeasure;
        !          32779:                        scope = f->body->memtbl;
        !          32780: //error('d',"body");
        !          32781:                        if (scope == 0) error('i',"%n memtbl missing",this);
        !          32782:                        curr_fct = this;
        !          32783:                        f->simpl();
        !          32784:                        if (f->f_inline==0 || debug_opt)
        !          32785:                                f->f_imeasure = 0;      // not a converted inline
        !          32786:                        else {
        !          32787:        
        !          32788:                                if (warning_opt && f->f_virtual)
        !          32789:                                        error('w',"virtual function %n cannot be inlined",this);
        !          32790:                                // first check if the function is too large to
        !          32791:                                // be worth inlining
        !          32792:                                if (12<f->f_imeasure) { // cut-over point:
        !          32793:                                                        // about 12 assignments
        !          32794:                                                        // f->f_imeasure indicates
        !          32795: 
        !          32796:                                        if (warning_opt) {
        !          32797:                                                error('w',"%n too large for inlining",this);
        !          32798:                                        }
        !          32799:                                        f->f_inline = 0;// a converted inline
        !          32800: //error('d',"don't inline%n %d %d %d",this,this,f,f->f_imeasure);
        !          32801:                                        scope = oscope;
        !          32802:                                        tp->defined |= SIMPLIFIED;
        !          32803:                                        return;
        !          32804:                                }
        !          32805:                                int i = 0;
        !          32806:                                for (n=f->f_args; n; n=n->n_list) {
        !          32807:                                        n->base = ANAME;
        !          32808:                                        n->n_val = i++;
        !          32809:        // ??                           if (n->n_table != scope) error('i',"aname scope: %d %n %d %d\n",n,n,n->n_table,scope);
        !          32810:                                }
        !          32811:                                expand_tbl = (f->returns->base!=VOID || n_oper==CTOR) ? scope : 0;
        !          32812:                                expand_fn = this;
        !          32813: 
        !          32814:                                if (expand_tbl) {
        !          32815:                                genlab:
        !          32816:                                                // value returning: generate expr
        !          32817:                                                // the body still holds the memtbl
        !          32818:                                        Pexpr ee = Pexpr(f->body->expand());
        !          32819:                                        Ptype t = 0;
        !          32820:                                        if (f->s_returns) {
        !          32821:                                                if (ee->tp!=f->s_returns) t = f->s_returns;
        !          32822:                                        }
        !          32823:                                        else if (ee->tp!=f->returns)
        !          32824:                                                t = f->returns;
        !          32825:                                        // VCVC assumes VOID is output as CHAR:
        !          32826:                                        if (t && t==void_type)
        !          32827:                                                ee = new expr(CM,ee,new cast(char_type,zero));
        !          32828:                                        f->f_expr = (ee->base==CM) ? ee : new expr(CM,zero,ee);
        !          32829:                                        // print.c assumes expansion into comma expression
        !          32830:                                }
        !          32831:                                else {
        !          32832:                                        if (is_expr(f->body)) {
        !          32833:                                                // can generate expr: do
        !          32834:                                                expand_tbl = scope;
        !          32835:                                                goto genlab;
        !          32836:                                        }
        !          32837:                                        // not value return: can generate block
        !          32838:                                        f->f_expr = 0;
        !          32839:                                        f->body = Pblock(f->body->expand());
        !          32840:                                }
        !          32841:                                expand_fn = 0;
        !          32842:                                expand_tbl = 0;
        !          32843:                        }
        !          32844:                        scope = oscope;
        !          32845:                        curr_fct = ocurr;
        !          32846:                        imeasure = oim;
        !          32847:                }
        !          32848:                break;
        !          32849:        }
        !          32850: 
        !          32851:        case CLASS:
        !          32852:                Pclass(tp)->simpl();
        !          32853:        }
        !          32854: 
        !          32855: //     if (n_initializer) n_initializer->simpl();
        !          32856:         if (n_key != NESTED && n_initializer) n_initializer->simpl();
        !          32857:        tp->defined |= SIMPLIFIED;
        !          32858: }
        !          32859: 
        !          32860: Pexpr call_ctor(Ptable tbl, Pexpr p, Pexpr ctor, Pexpr args, int d, Pexpr vb_args)
        !          32861: {
        !          32862:        Pexpr ee = new ref(d,p,ctor);
        !          32863:        if (p==0 || tbl==0) ee->tp = ctor->tp;
        !          32864: //error('d',"call_ctor(tbl %d, p %d, %n, args %d)",tbl,p,ctor,args);
        !          32865:        if (args && args->base!=ELIST) args = new expr(ELIST,args,0);
        !          32866:        ee = new expr(G_CALL,ee,args);
        !          32867:        Pname n = Pname(ctor);
        !          32868:        while (n->base == MDOT) n = Pname(n->mem);
        !          32869:        if (n->tp->base == FCT) ee->fct_name = n;
        !          32870:        if (tbl)
        !          32871:                ee = ee->typ(tbl);
        !          32872:        else if (n->tp->base == FCT)
        !          32873:                ee->tp = Pfct(n->tp)->s_returns;
        !          32874:        if (ee->tp == any_type) return ee;
        !          32875:        args = ee->e2;
        !          32876: 
        !          32877:        if (vb_args == 0) {             // attach zero vbase arguments
        !          32878:                Pfct f = Pfct(ee->fct_name->tp);        // not n->fct_name
        !          32879:                for (Pname nn = f->f_args->n_list; nn && nn!=f->argtype; nn=nn->n_list)
        !          32880:                        args = new expr(ELIST,zero,args);
        !          32881:        }
        !          32882:        else {                          // attach vbase arguments
        !          32883:                if (args) {
        !          32884:                        for (Pexpr d = vb_args; d->e2; d=d->e2);
        !          32885:                        d->e2 = args;
        !          32886:                }
        !          32887:                args = vb_args;
        !          32888:        }
        !          32889: 
        !          32890:        ee->e2 = args;
        !          32891:        return ee;
        !          32892: }
        !          32893: 
        !          32894: Pexpr call_dtor(Pexpr p, Pexpr dtor, Pexpr arg, int d, Pexpr vb_args)
        !          32895: {
        !          32896: // error('d',"call dtor %k %n %t vb_args %d",d,dtor,dtor->tp,vb_args);
        !          32897:        Pexpr r = new ref(d,p,dtor);
        !          32898: 
        !          32899:        if (arg && vb_args) 
        !          32900:                arg = new ival(3);
        !          32901:        else if (vb_args) 
        !          32902:                arg = new ival(2);
        !          32903:        else if (arg==0)
        !          32904:                arg = zero;
        !          32905:        if (arg->tp == 0) arg->tp = int_type;
        !          32906: 
        !          32907:        Pexpr aa = new expr(ELIST,arg,0); // argument controlling deallocation
        !          32908:                                          // 2: destroy vbases
        !          32909:                                          // 1: dealllocate, 0: don't
        !          32910: 
        !          32911:        Pfct f = Pfct(dtor->tp);                // attach virtual base arguments
        !          32912: //     for (Pname nn = f->f_args->n_list; nn && nn->n_list; nn=nn->n_list) {
        !          32913: //             Pexpr xx = vb_args ? new cast(nn->tp,one) : zero;
        !          32914: //             aa = new expr(ELIST,xx,aa);
        !          32915: //     }
        !          32916: 
        !          32917: 
        !          32918:        Pexpr ee = new call(r,aa);
        !          32919:        while (dtor->base == MDOT) dtor = dtor->mem;
        !          32920:        if (d == REF)   // could be virtual
        !          32921:                ee->fct_name = Pname(dtor);
        !          32922:        else {  // virtual suppressed, store fct name 
        !          32923:                r->n_initializer = dtor;
        !          32924:                ee->fct_name = 0;
        !          32925:        }
        !          32926:        ee->base = G_CALL;
        !          32927:        ee->tp = void_type;
        !          32928: 
        !          32929:         if (f->memof->c_body == 1) f->memof->dcl_print(0);
        !          32930:        if (Pname(dtor)->n_dcl_printed==0) Pname(dtor)->dcl_print(0);
        !          32931: 
        !          32932:        return ee;
        !          32933: }
        !          32934: 
        !          32935: //extern int new_used; // pre-define new and delete only if the user didn't
        !          32936: 
        !          32937: Pstmt fct::dtor_simpl(Pclass cl, Pexpr th)
        !          32938: {
        !          32939:        Pstmt dtail = 0;
        !          32940: //error('d',"simpl_dtor(%t) a %d",cl,f_args);
        !          32941: //     if (new_used == 0) new_init();
        !          32942: 
        !          32943:        Pname fa = new name("__free");  // fake argument for dtor
        !          32944:        fa->tp = int_type;
        !          32945:        Pname free_arg = fa->dcl(body->memtbl,ARG);
        !          32946:        free_arg->where = no_where;
        !          32947:        delete fa;
        !          32948:        Pname a = f_args;
        !          32949:        if (a==0 || a->n_list==0) error('i',"__freeA missing in destructor for %t",cl);
        !          32950:        Pname p = 0;
        !          32951:        for(;;p=a,a=a->n_list) {        // replace nameless fake argument
        !          32952: //error('d',"a %d %t",a,a->tp);
        !          32953:                if (a->n_list == 0) {
        !          32954:                //      a->n_list = free_arg;
        !          32955:                        DEL(p->n_list);
        !          32956:                        p->n_list = free_arg;
        !          32957:                        break;
        !          32958:                }
        !          32959:        } 
        !          32960: 
        !          32961:        // generate calls to destructors for all members of class cl:
        !          32962:        Ptable tbl = cl->memtbl;
        !          32963:        int i = 1;
        !          32964:        for (Pname m=tbl->get_mem(i); m; m=tbl->get_mem(++i) ) {
        !          32965: 
        !          32966:                if (m->n_stclass == STATIC || m->base == PUBLIC) continue;
        !          32967: 
        !          32968:                Ptype t = m->tp;
        !          32969:                Pexpr ee = 0;
        !          32970:                Pname cn;
        !          32971:                Pname dtor;
        !          32972: 
        !          32973:                if (cn = t->is_cl_obj()) {
        !          32974:                        Pclass cl = (Pclass)cn->tp;
        !          32975:                        if (dtor = cl->has_dtor()) {    // dtor(this,0,ones);
        !          32976:                                ee = new ref(REF,th,m);
        !          32977:                                ee->tp = m->tp;
        !          32978:                                ee = call_dtor(ee,dtor,0,DOT,one);
        !          32979:                                check_visibility(dtor,0,Pclass(dtor->n_table->t_name->tp),tbl,curr_fct);
        !          32980:                        }
        !          32981:                }
        !          32982:                else if (cl_obj_vec) {
        !          32983:                        Pclass cl = Pclass(cl_obj_vec->tp);
        !          32984:                        if (dtor = cl->has_dtor()) {
        !          32985:        Pfct f = Pfct(dtor->tp);
        !          32986:        int i = 0;
        !          32987:        for (Pname nn = f->f_args->n_list; nn && nn->n_list; nn=nn->n_list) i++;
        !          32988: //error('d',"dtor %n i %d",dtor,i);
        !          32989:                                ee = new ref(REF,th,m);
        !          32990:                                ee->tp = m->tp;
        !          32991:                                ee = cdvec(vec_del_fct,ee,cl,dtor,0,new ival(i));
        !          32992:                                check_visibility(dtor,0,Pclass(dtor->n_table->t_name->tp),tbl,curr_fct);
        !          32993:                        }
        !          32994:                }
        !          32995: 
        !          32996:                if (ee) {
        !          32997:                        Pstmt es = new estmt(SM,curloc,ee,0);
        !          32998:                        // reverse order of destructors for members
        !          32999:                        es->s_list = del_list;
        !          33000:                        del_list = es;
        !          33001:                        if (dtail == 0) dtail = es;
        !          33002:                }
        !          33003:        }
        !          33004: 
        !          33005: 
        !          33006:        Pexpr ee = 0;
        !          33007:        // look for bases with destructors:
        !          33008:        // generate: dtor(base,0);
        !          33009: 
        !          33010:        Pbcl b = 0;     // get dtors in order with virtual bases last
        !          33011:        Pbcl t = 0;
        !          33012:        for (Pbcl l = cl->baselist; l; l=l->next) {
        !          33013:                if (l->base != VIRTUAL) {
        !          33014:                        Pbcl x = new basecl(l->bclass,0);
        !          33015:                        if (t == 0)
        !          33016:                                b  = x;
        !          33017:                        else
        !          33018:                                t->next = x;
        !          33019:                        t = x;
        !          33020:                        x->base = l->base;
        !          33021:                        x->obj_offset = l->obj_offset;
        !          33022:                }
        !          33023:        }
        !          33024:        for (l = cl->baselist; l; l=l->next) {
        !          33025:                if (l->base == VIRTUAL) {
        !          33026:                        b = new basecl(l->bclass,b);
        !          33027:                        b->base = l->base;
        !          33028:                        b->obj_offset = l->obj_offset;
        !          33029:                }
        !          33030:        }
        !          33031:        Pexpr ve = 0;
        !          33032: 
        !          33033:        for (; b; b=l) {
        !          33034:                Pclass bcl = b->bclass;
        !          33035:                l = b->next;
        !          33036:                Pname dtor = bcl->has_dtor();
        !          33037: 
        !          33038:                if (dtor) { 
        !          33039:                        Pexpr val = rptr(bcl->this_type,th,b->obj_offset);
        !          33040:                        val = val->contents();
        !          33041:                        Pexpr e = call_dtor(val,dtor);
        !          33042:                        if (b->base == VIRTUAL) {
        !          33043:                                // if (x) this->x.dtor(); where x is a vbase
        !          33044:                                for (Pname dd = f_this->n_list; dd!=argtype; dd=dd->n_list) 
        !          33045:                                if (strcmp(dd->string,bcl->string)==0) break;
        !          33046: 
        !          33047:                                if (ansi_opt) { // q?void:int would be an error
        !          33048:                                        e = new expr(G_CM,e,zero);
        !          33049:                                        e->tp = zero_type;
        !          33050:                                }
        !          33051:                                e = new expr(QUEST,e,zero);
        !          33052:                                Pexpr two = new ival(2);
        !          33053:                                two->tp = int_type;
        !          33054:                                e->cond = new expr (AND,free_arg,two);//dd;
        !          33055:                        }
        !          33056:                        ee = ee ? new expr(CM,e,ee) : e;
        !          33057:                }
        !          33058:                delete b;
        !          33059:        }
        !          33060: 
        !          33061:        Pstmt es = ee ? new estmt(SM,curloc,ee,0) : 0;
        !          33062: 
        !          33063:        ee = new expr(ELIST,th,0);      // free storage
        !          33064:        Pname n = new name(oper_name(DELETE));
        !          33065:        Pexpr del = find_name(n,cl,scope,CALL,curr_fct);
        !          33066:        if (del->tp->base==OVERLOAD || Pfct(del->tp)->nargs==2) {
        !          33067:                Pexpr ss = new texpr(SIZEOF,cl,0);
        !          33068:                ss->tp = uint_type;
        !          33069:                ee->e2 = new expr(ELIST,ss,0);
        !          33070:        }
        !          33071:        ee = new call(del,ee);
        !          33072:        ee->tp = ee->call_fct(scope);
        !          33073: 
        !          33074:        Pstmt ess = new estmt(SM,curloc,ee,0);
        !          33075:        ess = new ifstmt(curloc,new expr(AND,free_arg,one),ess,0);
        !          33076:        if (es)
        !          33077:                es->s_list = ess;
        !          33078:        else
        !          33079:                es = ess;
        !          33080: 
        !          33081:        free_arg->use();
        !          33082:        Pname(th)->use();
        !          33083: 
        !          33084:        if (dtail)
        !          33085:                dtail->s_list = es;
        !          33086:        else
        !          33087:                del_list = es;
        !          33088: 
        !          33089:        del_list = new ifstmt(curloc,th,del_list,0);
        !          33090:        if (del_list) del_list->simpl();
        !          33091:        return dtail;
        !          33092: }
        !          33093: 
        !          33094: 
        !          33095: Pclass find_vbase_ptr(Pclass cl, Pclass vbase)
        !          33096: {
        !          33097:        for (Pbcl bb = cl->baselist; bb; bb = bb->next) {
        !          33098:                if (bb->base==VIRTUAL) {
        !          33099:                        if (bb->bclass==vbase && bb->ptr_offset) return cl;
        !          33100:                }
        !          33101:                else {
        !          33102:                        Pclass f = find_vbase_ptr(bb->bclass,vbase);
        !          33103:                        if (f) return f;
        !          33104:                }
        !          33105:        }
        !          33106:        return 0;
        !          33107: }
        !          33108: 
        !          33109: Pclass second_base(Pclass cl, Pclass base)
        !          33110: {
        !          33111: //error('d',"second_base(%t,%t)",cl,base);
        !          33112:        for (Pbcl b = cl->baselist; b && b->base==NAME; b = b->next) {
        !          33113:                if (b->bclass==base) {
        !          33114:                        if (b==cl->baselist) return 0;
        !          33115:                        return base;
        !          33116:                }
        !          33117:                Pclass bb = second_base(b->bclass,base);
        !          33118:                if (bb == Pclass(-1)) continue; // not found
        !          33119:                if (bb) {
        !          33120:                        if (b!=cl->baselist) error('s',"C hierarchy too complicated");
        !          33121:                        return bb;      // second base of b->bclass
        !          33122:                }
        !          33123:                if (b==cl->baselist) return 0;
        !          33124:                return b->bclass;       // b->bclass is second base
        !          33125:        }
        !          33126:        return Pclass(-1);
        !          33127: }
        !          33128: 
        !          33129: //Pclass topclass;
        !          33130: 
        !          33131: Pexpr classdef::get_vptr_exp(char *s)
        !          33132: {
        !          33133: //error('d',"%t::get_vptr_exp(%s)",this,s?s:"0");
        !          33134:        if (c_body == 1) dcl_print(0);
        !          33135:        if (c_body == 3) print_all_vtbls(this);
        !          33136:        if (s == 0) return find_vptr(this);
        !          33137:        Pbcl b = get_base(get_classname(s));
        !          33138:        Pexpr vp = b->bclass->get_vptr_exp(drop_classname(s));
        !          33139:        if (b==baselist && b->base!=VIRTUAL) return vp;
        !          33140:        vp = new mdot(b->bclass->string,vp);
        !          33141:        if (c_body == 1) b->bclass->dcl_print(0);
        !          33142:        if (c_body == 3) b->bclass->print_all_vtbls(b->bclass);
        !          33143:        if (b->base == VIRTUAL) {
        !          33144:                vp->i1 = 1;
        !          33145:                if (b->ptr_offset == 0) { // pointer to base in intermediate base
        !          33146:                        Pclass bb = find_vbase_ptr(this,b->bclass);
        !          33147:                        Pclass sb = second_base(topclass,bb);
        !          33148: //error('d',"mdot %t %t : %d %t ",topclass,bb,sb,sb==Pclass(-1)?0:sb);
        !          33149:                        if (sb && sb!=Pclass(-1)) vp = new mdot(sb->string,vp);
        !          33150:                }
        !          33151:        }
        !          33152:        return vp;
        !          33153: }
        !          33154: 
        !          33155: int fct::ctor_simpl(Pclass cl, Pexpr th)
        !          33156: {
        !          33157:        Ptable tbl = cl->memtbl;
        !          33158: 
        !          33159:        int ass_count = 0;
        !          33160:        init_list = 0;
        !          33161: //error('d',"ctor_simpl %t: %t",cl,this);
        !          33162:        /*
        !          33163:                initialization order:
        !          33164:                (1)     virtual base pointers and virtual bases
        !          33165:                                (they may be used in non-virtual bases)
        !          33166:                (2)     non-virtual bases
        !          33167:                (3)     virtual function pointers
        !          33168:                (4)     members
        !          33169:        */
        !          33170: 
        !          33171:        // initialize virtual base pointers and virtual base objects
        !          33172:        for (Pbcl l = cl->baselist; l; l=l->next) {
        !          33173:                Pexpr i = l->init;
        !          33174:                if (l->base != VIRTUAL) continue;
        !          33175:                l->init = 0;
        !          33176: //error('d',"simpl virtual base %t i %d ",l->bclass,i);
        !          33177: 
        !          33178:                // assign virtual OP to virtual base AP
        !          33179:                Pclass bc = l->bclass;
        !          33180:                Pexpr dp = 0;
        !          33181: 
        !          33182:                // dd = pointer argument for this base;
        !          33183:                // non-zero if already initialized
        !          33184:                for (Pname dd = f_this->n_list; dd!=argtype; dd=dd->n_list) 
        !          33185:                        if (strcmp(dd->string,bc->string)==0) break;
        !          33186: 
        !          33187:                // initialize virtual base object
        !          33188: //error('d',"bc %t dd %n offset %d init %d",bc,dd,l->obj_offset,l->init);
        !          33189:                // => bc_arg = (bc*)((char*)this+offset)
        !          33190:                int off = l->obj_offset;
        !          33191:                Pexpr val = rptr(bc->this_type,th,off);
        !          33192:                dp = new expr(ASSIGN,dd,val);
        !          33193:                dd->assign();
        !          33194: 
        !          33195:                // => bc::bc()
        !          33196:                if (i)  {
        !          33197:                        switch (i->base) {
        !          33198:                        case ASSIGN:
        !          33199:                        case CM:
        !          33200:                                break;
        !          33201:                        case CALL:
        !          33202:                        case G_CALL:
        !          33203:                        {       Pcall cc = Pcall(i);
        !          33204:                                Pname bn = cc->fct_name;
        !          33205:                                ass_count = Pfct(bn->tp)->f_this->n_assigned_to;
        !          33206:                                cc->simpl();
        !          33207:                                break;
        !          33208:                        }
        !          33209:                        default:
        !          33210:                                error('i',"badBCIr %k",i->base);
        !          33211:                        }
        !          33212:                        dp = new expr(CM,dp,i);
        !          33213:                }
        !          33214: 
        !          33215:                // => (bc_arg==0)?dp:bc_arg
        !          33216:                for (Pname a = f_args->n_list; a; a = a->n_list)
        !          33217:                        if (strcmp(bc->string,a->string)==0) {
        !          33218:                                dp = new expr(QUEST,dp,a);
        !          33219:                                dp->cond = new expr(EQ,a,zero);
        !          33220:                                break;
        !          33221:                        }
        !          33222: 
        !          33223:                //      Pname dpp = find_vbase_ptr(bc,cl);
        !          33224:                for (Pbcl ll=cl->baselist; ll; ll=ll->next) {
        !          33225:                        if (ll->bclass==bc && ll->ptr_offset) {
        !          33226:                                // make sure that the delegate_arg is needed
        !          33227:                                // here and not just in a base
        !          33228: 
        !          33229:                                // this->Pd = (bc_arg==0)?dp:bc_arg
        !          33230:                                Pexpr dpp = new mdot(bc->string,th);
        !          33231:                                dpp->i1 = 3;
        !          33232:                                dp = new expr(ASSIGN,dpp,dp);
        !          33233: //error('d',"dpp %n",dpp);
        !          33234:                                break;
        !          33235:                        }
        !          33236:                }
        !          33237: 
        !          33238:                // reverse init order
        !          33239:                if (dp) init_list = init_list ? new expr(CM,dp,init_list) : dp;
        !          33240:        }
        !          33241: 
        !          33242:        //      generate: this=base::base(args) (non-virtual bases)
        !          33243: {      
        !          33244:        for (Pbcl l = cl->baselist; l; l=l->next) {
        !          33245:                Pexpr i = l->init;
        !          33246:                if (i==0 || l->base==VIRTUAL) continue;
        !          33247: //error('d',"simpl base %t i %d ",l->bclass,i);
        !          33248:                l->init = 0;
        !          33249:        
        !          33250:                switch (i->base) {
        !          33251:                case ASSIGN:
        !          33252:                case CM:
        !          33253:                        break;
        !          33254:                case CALL:
        !          33255:                case G_CALL:
        !          33256:                {       Pcall cc = Pcall(i);
        !          33257:                        Pname bn = cc->fct_name;
        !          33258:                        ass_count = Pfct(bn->tp)->f_this->n_assigned_to;
        !          33259:                        cc->simpl();
        !          33260:                        // assign to ``this'' only from only base
        !          33261:                        if (l==cl->baselist && cl->baselist->next==0) i = new expr(ASSIGN,th,cc);
        !          33262:                        break;
        !          33263:                }
        !          33264:                default:
        !          33265:                        error('i',"badBCIr %k",i->base);
        !          33266:                }
        !          33267: 
        !          33268:                init_list = init_list ? new expr(G_CM,init_list,i) : i;
        !          33269:        }
        !          33270: }
        !          33271: 
        !          33272:        // initialize the vptrs that are updated by this class
        !          33273:        for (Pvirt blist = cl->virt_list; blist; blist = blist->next) {
        !          33274:        //      if (blist->string==0 && find_vptr(cl)==0) {     //opt
        !          33275: //error('d',"!!!vptr init %s in %s",blist->string,cl->string);
        !          33276:        //              continue;
        !          33277:        //      }
        !          33278: //error('d',"vptr init %s in %s",blist->string,cl->string);
        !          33279:                topclass = cl;
        !          33280:                Pexpr vp = cl->get_vptr_exp(blist->string);
        !          33281: 
        !          33282:                 char *str = 0;
        !          33283:                char *cs = cl->nested_sig?cl->nested_sig:cl->string;
        !          33284:                 if (cl->lex_level && cl->nested_sig==0) str = make_local_name( cl );
        !          33285:                 Pexpr vtbl = new text_expr(blist->string,str?str:cs);
        !          33286:                 //Pexpr vtbl = new text_expr(blist->string,cl->string);      
        !          33287:                 //      vtbl = new cast(Pvptr_type,vtbl);
        !          33288: 
        !          33289:                Pexpr ee = new ref(REF,th,vp);
        !          33290:                ee->tp = vp->tp;
        !          33291:                ee = new expr(ASSIGN,ee,vtbl);
        !          33292:                init_list = init_list ? new expr(CM,init_list,ee) : ee;
        !          33293:        }
        !          33294: 
        !          33295:        // initialize members in declaration order:
        !          33296:        int i;
        !          33297:        for (Pname m=tbl->get_mem(i=1); m; m=tbl->get_mem(++i) ) {
        !          33298:                Ptype t = m->tp;
        !          33299:                Pname cn;
        !          33300:                Pname ctor;
        !          33301:                if (t == 0) continue;
        !          33302: 
        !          33303:                switch (t->base) {
        !          33304:                case FCT:
        !          33305:                case OVERLOAD:
        !          33306:                case CLASS:
        !          33307:                case ENUM:
        !          33308:                        continue;
        !          33309:                }
        !          33310: 
        !          33311:                switch (m->n_stclass) {
        !          33312:                case STATIC:
        !          33313:                case ENUM:
        !          33314:                        continue;
        !          33315:                }
        !          33316: 
        !          33317:                if (m->base == PUBLIC) continue;
        !          33318: 
        !          33319:                Pexpr ee = m->n_initializer;
        !          33320:                if (ee) m->n_initializer = 0;   // from fct must not persist until next fct
        !          33321: //error('d',"simpl m %n ee %d",m,ee);
        !          33322:                if (ee) {
        !          33323:                        // init of non-class mem
        !          33324:                        // set in fct::mem_init()
        !          33325:                }
        !          33326:                else if (cn=t->is_cl_obj()) {   // try for default
        !          33327:                        Pclass cl = Pclass(cn->tp);
        !          33328:                        if (ctor = cl->has_ictor()) {
        !          33329:                                Pexpr r = new ref(REF,th,m);
        !          33330:                                ee = call_ctor(tbl,r,ctor,0,DOT);
        !          33331:        check_visibility(ctor,0,Pclass(ctor->n_table->t_name->tp),tbl,curr_fct);
        !          33332:                        }
        !          33333:                        else if (cl->has_ctor()) {
        !          33334:                                error("M%n needsIr (no defaultK forC %s)",m,cl->string);
        !          33335:                        }
        !          33336:                }
        !          33337:                else if (cl_obj_vec) {
        !          33338:                        Pclass cl = Pclass(cl_obj_vec->tp);
        !          33339:                        if (ctor = cl->has_ictor()) { // _new_vec(vec,noe,sz,ctor);
        !          33340:                                Pexpr mm = new ref(REF,th,m);
        !          33341:                                mm->tp = m->tp;
        !          33342:                                ee = cdvec(vec_new_fct,mm,cl,ctor,-1,0);
        !          33343:        check_visibility(ctor,0,Pclass(ctor->n_table->t_name->tp),tbl,curr_fct);
        !          33344:                        }
        !          33345:                        else if (cl->has_ctor()) {
        !          33346:                                error("M%n[] needsIr (no defaultK forC %s)",m,cl->string);
        !          33347:                        }
        !          33348:                }
        !          33349:                else if (t->is_ref()) {
        !          33350:                        error("RM%n needsIr",m);
        !          33351:                }
        !          33352:                else if (t->tconst() && vec_const==0) {
        !          33353:                        error("constM%n needsIr",m);
        !          33354:                }
        !          33355:        
        !          33356:                if (ee) {
        !          33357:                        ee->simpl();
        !          33358:                        init_list = init_list ? new expr(CM,init_list,ee) : ee;
        !          33359:                }
        !          33360:        } // for m
        !          33361: //error('d',"ctor->");
        !          33362:        return ass_count;
        !          33363: }
        !          33364: 
        !          33365: void fct::simpl()
        !          33366: /*
        !          33367:        call only for the function definition (body != 0)
        !          33368: 
        !          33369:        simplify argument initializers, and base class initializer, if any
        !          33370:        then simplify the body, if any
        !          33371: 
        !          33372:        for constructor:call allocator if this==0 and this not assigned to
        !          33373:                        (auto and static objects call constructor with this!=0,
        !          33374:                        the new operator generates calls with this==0)
        !          33375:                        call base & member constructors
        !          33376:        for destructor: call deallocator (no effect if this==0)
        !          33377:                        case base & member destructors
        !          33378: 
        !          33379:        for arguments and function return values look for class objects
        !          33380:        that must be passed by constructor X(X&).
        !          33381: 
        !          33382:        Allocate temporaries for class object expressions, and see if
        !          33383:        class object return values can be passed as pointers.
        !          33384: 
        !          33385:        call constructor and destructor for local class variables.
        !          33386: */
        !          33387: {
        !          33388:        Pexpr th = f_this;
        !          33389:        Ptable tbl = body->memtbl;
        !          33390:        Pstmt ss = 0;
        !          33391:        Pstmt tail;
        !          33392:        Pclass cl = th ? Pclass(Pbase(Pptr(th->tp)->typ)->b_name->tp) : 0;
        !          33393:        Pstmt dtail = 0;
        !          33394: 
        !          33395:        Pname ocurr_fct = curr_fct;
        !          33396:        int oret = no_of_returns;
        !          33397:        int oim = imeasure;
        !          33398: 
        !          33399: //error('d',"fct::simpl %n %t",curr_fct,this);
        !          33400: //     not_inl = f_inline==0;
        !          33401:        del_list = 0;
        !          33402:        continue_del_list = 0;
        !          33403:        break_del_list = 0;
        !          33404:        scope = tbl;
        !          33405:        if (scope == 0) error('i',"F::simpl()");
        !          33406:        int ass_count = 0;
        !          33407:        imeasure = 0;
        !          33408:        no_of_returns = 0;
        !          33409: 
        !          33410:        cc->stack();
        !          33411:        cc->nof = curr_fct;
        !          33412:        cc->ftbl = tbl;
        !          33413: 
        !          33414: //      modification for local classes defined within inline functions
        !          33415: // error( 'd', "simpl local_class: %d", local_class );
        !          33416:        for ( Plist l = local_class; l; l = l->l ) {
        !          33417:                Pname n = l->f; 
        !          33418:                Pclass cl = Pclass(Pbase(n->tp)->b_name->tp);
        !          33419:                if ( cl->in_fct == 0 ) cl->in_fct = cc->nof;
        !          33420:                if ( cl->lcl == 0 ) cl->lcl = make_name( 'L' );
        !          33421:                if ( cl->c_body == 1 ) cl->dcl_print(0);
        !          33422:        }
        !          33423: 
        !          33424:        Pfct(cc->nof->tp)->local_class = local_class; 
        !          33425:        local_class = 0;
        !          33426: // error( 'd', "simpl nof: %n %d local_class: %d", cc->nof, cc->nof, Pfct(cc->nof->tp)->local_class );
        !          33427: 
        !          33428:        switch (curr_fct->n_scope) {
        !          33429:        case 0:
        !          33430:        case PUBLIC:
        !          33431:                cc->not = curr_fct->n_table->t_name;
        !          33432:                cc->cot = Pclass(cc->not->tp);
        !          33433:                cc->tot = cc->cot->this_type;
        !          33434:        }
        !          33435: 
        !          33436:        switch (curr_fct->n_oper) {
        !          33437:        case  DTOR:
        !          33438:                dtail = dtor_simpl(cl,th);
        !          33439:                break;
        !          33440:        case CTOR:
        !          33441:                ass_count = ctor_simpl(cl,th);
        !          33442:        }
        !          33443: 
        !          33444:        tail = body->simpl();
        !          33445: 
        !          33446:        if (returns->base!=VOID || f_result) {  // return must have been seen
        !          33447:                if (no_of_returns) {            // could be OK
        !          33448:                        Pstmt tt = (tail->base==RETURN || tail->base==LABEL) ? tail : trim_tail(tail);
        !          33449: 
        !          33450:                        switch (tt->base) {
        !          33451:                        case RETURN:
        !          33452:                        case GOTO:
        !          33453:                                del_list = 0;   // no need for del_list
        !          33454:                                break;
        !          33455:                        case SM:
        !          33456:                                if (tt->e)
        !          33457:                                        switch (tt->e->base) {
        !          33458:                                        case ICALL:
        !          33459:                                        case G_CALL:
        !          33460:                                                goto chicken;
        !          33461:                                        }
        !          33462:                        default:
        !          33463:                                if (warning_opt || strcmp(curr_fct->string,"main"))     
        !          33464:                                        error('w',"maybe no value returned from%n",curr_fct);
        !          33465:                        case IF:
        !          33466:                        case SWITCH:
        !          33467:                        case DO:
        !          33468:                        case WHILE:
        !          33469:                        case FOR:
        !          33470:                        case LABEL:
        !          33471:                        chicken:                // don't dare write a warning
        !          33472:                                break;
        !          33473:                        }
        !          33474:                }
        !          33475:                else {  // must be an error
        !          33476:                        // but we don't dare complain about main()
        !          33477:                //      if (strcmp(curr_fct->string,"main"))
        !          33478:                //              error(Pfct(curr_fct->tp)->returns->is_cl_obj()?0:'w',"no value returned from%n",curr_fct);
        !          33479:                //      else if (warning_opt)   
        !          33480:                //              error('w',"no value returned from%n",curr_fct);
        !          33481:                        if (Pfct(curr_fct->tp)->f_inline
        !          33482:                        && Pfct(curr_fct->tp)->returns!=void_type
        !          33483:                        && Pfct(curr_fct->tp)->returns->is_cl_obj())
        !          33484:                                // can cause code generation errors if allowed
        !          33485:                                error("no value returned from%n",curr_fct);
        !          33486:                        else if (warning_opt || strcmp(curr_fct->string,"main"))        
        !          33487:                                error('w',"no value returned from%n",curr_fct);
        !          33488:                }
        !          33489:                if (del_list) goto zaq;
        !          33490:        }
        !          33491:        else if (del_list) {    // return may not have been seen
        !          33492:        zaq:
        !          33493:                if (tail)
        !          33494:                        tail->s_list = del_list;
        !          33495:                else
        !          33496:                        body->s = del_list;
        !          33497:                tail = dtail;
        !          33498:        }
        !          33499: 
        !          33500:        if (curr_fct->n_oper == DTOR) { // body => if (this == 0) body
        !          33501: 
        !          33502: // reset the vptrs that were set by this class
        !          33503:        for (Pvirt blist = cl->virt_list; blist; blist = blist->next) {
        !          33504: //error('d',"vptr init %s in %s",blist->string,cl->string);
        !          33505:                topclass = cl;
        !          33506:                Pexpr vp = cl->get_vptr_exp(blist->string);
        !          33507: 
        !          33508:                 char *str = 0;
        !          33509:                char *cs = cl->nested_sig?cl->nested_sig:cl->string;
        !          33510:                 if (cl->lex_level && cl->nested_sig==0) str = make_local_name(cl);
        !          33511:                 Pexpr vtbl = new text_expr(blist->string,str?str:cs);
        !          33512: 
        !          33513:                Pexpr ee = new ref(REF,th,vp);
        !          33514:                ee->tp = vp->tp;
        !          33515:                ee = new expr(ASSIGN,ee,vtbl);
        !          33516:                Pstmt es = new estmt(SM,curloc,ee,0);
        !          33517:                es->s_list = body->s;
        !          33518:                body->s = es;
        !          33519:        }
        !          33520: 
        !          33521:                body->s = new ifstmt(body->where,th,body->s,0);
        !          33522:        }
        !          33523: 
        !          33524:        if (curr_fct->n_oper == CTOR) {
        !          33525: 
        !          33526:                loc temploc=body->where;
        !          33527:                Pstmt tempss=body->s;
        !          33528:                while (tempss) {
        !          33529:                        temploc=tempss->where;
        !          33530:                        tempss=tempss->s_list;
        !          33531:                }
        !          33532:                
        !          33533:                if  (Pname(th)->n_assigned_to == 0) {
        !          33534:                /* generate:
        !          33535:                        if (this || (this=_new( sizeof(class cl) ))) {
        !          33536:                                init_list ;
        !          33537:                                body;
        !          33538:                        }
        !          33539:                */
        !          33540:                        Pname(th)->n_assigned_to = ass_count ? ass_count : FUDGE111;
        !          33541:                        Pexpr sz = new texpr(SIZEOF,cl,0);
        !          33542:                        (void) cl->tsizeof();
        !          33543:                        sz->tp = uint_type;
        !          33544:                        Pexpr ee = new expr(ELIST,sz,0);
        !          33545:                                Pname n = new name(oper_name(NEW));
        !          33546:                                Pexpr p = find_name(n,cl,scope,CALL,curr_fct);
        !          33547: //error('d',"in ctor %n call %n",curr_fct,p);
        !          33548:                                ee = new call(p,ee);
        !          33549:                                (void) ee->call_fct(cl->memtbl);
        !          33550:                        ee->simpl();
        !          33551:                        ee = new expr(ASSIGN,th,ee);
        !          33552:                        ee = new expr(OROR,th,ee);
        !          33553:                        /*ifs->simpl();
        !          33554:                                do not simplify
        !          33555:                                or "this = " will cause an extra call of base::base
        !          33556:                        */
        !          33557:                        if (init_list) {
        !          33558:                                Pstmt es = new estmt(SM,body->where,init_list,0);
        !          33559:                                es->s_list = body->s;
        !          33560:                                body->s = es;
        !          33561:                        //      if (tail == 0) tail = es;
        !          33562:                        }
        !          33563:                        else if (body->s == 0)
        !          33564:                                body->s = new estmt(SM,body->where,0,0);
        !          33565:                        else if(tail->base==RETURN) {
        !          33566:                                if(body->s == tail) {
        !          33567:                                        delete body->s;
        !          33568:                                        body->s = new estmt(SM,body->where,0,0);
        !          33569:                                }
        !          33570:                                else {
        !          33571:                                        Pstmt pr = body->s;
        !          33572:                                        while(pr->s_list != tail)
        !          33573:                                                pr = pr->s_list;
        !          33574:                                        delete pr->s_list;
        !          33575:                                        pr->s_list = 0;
        !          33576:                                }
        !          33577:                        }
        !          33578: 
        !          33579:                        ifstmt* ifs = new ifstmt(body->where,ee,body->s,0);
        !          33580:                        body->s = ifs;
        !          33581:                //      if (tail == 0) 
        !          33582:                        tail = ifs;
        !          33583:                }
        !          33584:                // generate: body; return this;
        !          33585:                Pstmt st = new estmt(RETURN,temploc,th,0);
        !          33586:                if (tail)
        !          33587:                        tail->s_list = st;
        !          33588:                else
        !          33589:                        body->s = st;
        !          33590:                tail = st;
        !          33591:        }
        !          33592:        f_imeasure = imeasure;
        !          33593:        curr_fct = ocurr_fct;
        !          33594:        no_of_returns = oret;
        !          33595:        imeasure = oim;
        !          33596:        cc->unstack();
        !          33597: }
        !          33598: 
        !          33599: 
        !          33600: void classdef::simpl()
        !          33601: {
        !          33602:        int i;
        !          33603: //error('d',"classdef::simpl %s %d",string,defined&SIMPLIFIED);
        !          33604: 
        !          33605:        if (defined&SIMPLIFIED) return;
        !          33606: 
        !          33607:        Pclass oc = in_class;
        !          33608:        in_class = this;
        !          33609: 
        !          33610:        for (Pname m=memtbl->get_mem(i=1); m; m=memtbl->get_mem(++i) ) {
        !          33611:                Pexpr i = m->n_initializer;
        !          33612:                m->n_initializer = 0;
        !          33613:                m->simpl();
        !          33614:                m->n_initializer = i;
        !          33615:        }
        !          33616: 
        !          33617:        in_class = oc;
        !          33618: 
        !          33619:        for (Plist fl=friend_list; fl; fl=fl->l) {      // simplify friends
        !          33620:                Pname p = fl->f;
        !          33621:                switch (p->tp->base) {
        !          33622:                case FCT:
        !          33623:                case OVERLOAD:
        !          33624:                        p->simpl();
        !          33625:                }
        !          33626:        }
        !          33627: 
        !          33628:        defined |= SIMPLIFIED;
        !          33629: }
        !          33630: 0707071010112045111004440001630000160000010207100466055410100001100000140465simpl2.c/*ident   "@(#)ctrans:src/simpl2.c        1.5" */
        !          33631: /******************************************************************
        !          33632: 
        !          33633:        C++ source for cfront, the C++ compiler front-end
        !          33634:        written in the computer science research center of Bell Labs
        !          33635: 
        !          33636:        Copyright (c) 1984 AT&T, Inc. All rights Reserved
        !          33637:        THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T, INC.
        !          33638: 
        !          33639: simpl2.c:
        !          33640: 
        !          33641:        simplify the typechecked function
        !          33642:        remove:         classes:
        !          33643:                                class fct-calls
        !          33644:                                operators
        !          33645:                                value constructors and destructors
        !          33646:                        new and delete operators (replace with function calls)
        !          33647:                        initializers            (turn them into statements)
        !          33648:                        constant expressions            (evaluate them)
        !          33649:                        inline functions                (expand the calls)
        !          33650:                        enums                           (make const ints)
        !          33651:                        unreachable code                (delete it)
        !          33652:        make implicit coersions explicit
        !          33653: 
        !          33654:        in general you cannot simplify something twice
        !          33655: 
        !          33656: *******************************************************************/
        !          33657: 
        !          33658: #include "cfront.h"
        !          33659: #include "size.h"
        !          33660: #include <ctype.h>
        !          33661: 
        !          33662: extern Pname Ntmp;
        !          33663: Pname find_vptr(Pclass);
        !          33664: 
        !          33665: extern int no_of_returns;
        !          33666: 
        !          33667: extern Pname new_fct;
        !          33668: //extern Pname del_fct;
        !          33669: 
        !          33670: extern Pstmt del_list;
        !          33671: extern Pstmt break_del_list;
        !          33672: extern Pstmt continue_del_list;
        !          33673: 
        !          33674: extern Pname curr_fct; // current function
        !          33675: extern Pexpr init_list;
        !          33676: extern int imeasure;
        !          33677: 
        !          33678: Pexpr cdvec(Pname f, Pexpr vec, Pclass cl, Pname cd, int tail, Pexpr i, Pexpr vec2)
        !          33679: /*
        !          33680:        generate a call to construct or destroy the elements of a vector
        !          33681: */
        !          33682: {
        !          33683:        Pexpr sz = new texpr(SIZEOF,cl,0);      // sizeof elem
        !          33684:        sz->tp = uint_type;
        !          33685:        (void) cl->tsizeof();
        !          33686:                                        
        !          33687:        Pexpr esz = new texpr(SIZEOF,cl,0);     // noe = sizeof(vec)/sizeof(elem)
        !          33688:        esz->tp = int_type;
        !          33689: 
        !          33690: Pexpr noe;
        !          33691: if (vec2) noe = new texpr(SIZEOF,vec2->tp,0);
        !          33692: else noe = new texpr(SIZEOF,vec->tp,0);
        !          33693: 
        !          33694:        // Pexpr noe = new texpr(SIZEOF,vec->tp,0);
        !          33695:        noe->tp = int_type;
        !          33696:        noe = new expr(DIV,noe,esz);
        !          33697:        noe->tp = uint_type;
        !          33698: // error('d',"cdvec tail %d i %d",tail,i);
        !          33699: //     Pexpr arg = (0<=tail) ? new expr(ELIST,zero,0) : 0;     // 0 or 1 for dtors
        !          33700:        Pexpr arg = (i) ? new expr(ELIST,i,0) : 0;
        !          33701:        arg = (0<=tail) ? new expr(ELIST,zero,arg) : arg;       // 0 or 1 for dtors
        !          33702:        arg = new expr(ELIST,cd,arg);           // constructor or destructor
        !          33703:        cd->lval(ADDROF);                       // cd->take_addr();
        !          33704: 
        !          33705:        arg = new expr(ELIST,sz,arg);
        !          33706:        arg = new expr(ELIST,noe,arg);
        !          33707:        arg = new expr(ELIST,vec,arg);
        !          33708: 
        !          33709:        arg = new call(f,arg);
        !          33710:        arg->base = G_CALL;
        !          33711:        arg->fct_name = f;
        !          33712: 
        !          33713:        return arg;
        !          33714: }
        !          33715: 
        !          33716: /*
        !          33717: int new_used;  // pre-define new and delete only if the user didn't
        !          33718: 
        !          33719: void new_init()
        !          33720: {
        !          33721:        char* ns = oper_name(NEW);
        !          33722:        char* ds = oper_name(DELETE);
        !          33723: 
        !          33724:        new_used = 1;
        !          33725: 
        !          33726:        new_fct = gtbl->look(ns,0);
        !          33727:        del_fct = gtbl->look(ds,0);
        !          33728: 
        !          33729:        if (new_fct && !del_fct)
        !          33730:                error('w',"%n defined but not operator delete()",new_fct);
        !          33731:        if (del_fct && !new_fct)
        !          33732:                error('w',"%n defined but not operator new()",del_fct);
        !          33733: 
        !          33734:         if (Pfct(new_fct->tp)->body==0) new_fct->dcl_print(0);
        !          33735:         if (Pfct(del_fct->tp)->body==0) del_fct->dcl_print(0);
        !          33736: }
        !          33737: */
        !          33738: Pstmt trim_tail(Pstmt tt)
        !          33739: /*
        !          33740:        strip off statements after RETURN etc.
        !          33741:        NOT general: used for stripping off spurious destructor calls
        !          33742: */
        !          33743: {
        !          33744:        if (tt == 0) return 0;
        !          33745: 
        !          33746:        while (tt->s_list) {
        !          33747:                Pstmt tpx;
        !          33748:                switch (tt->base) {
        !          33749:                case PAIR:
        !          33750:                        tpx = trim_tail(tt->s2);
        !          33751:                        goto tpxl;
        !          33752:                case BLOCK:
        !          33753:                        tpx = trim_tail(tt->s);
        !          33754:                tpxl:
        !          33755:                        if (tpx == 0) return 0;
        !          33756: 
        !          33757:                        switch (tpx->base) {
        !          33758:                        case SM:
        !          33759:                                break;
        !          33760:                        case CONTINUE:
        !          33761:                        case BREAK:
        !          33762:                        case GOTO:
        !          33763:                        case RETURN:
        !          33764:                                if (tt->s_list->base != LABEL) tt->s_list = 0;
        !          33765:                        default:
        !          33766:                                return tpx;
        !          33767:                        }
        !          33768:                default:
        !          33769:                        if (tt = tt->s_list) break;
        !          33770:                        return 0;
        !          33771:                case RETURN:
        !          33772:                        if (tt->s_list->base != LABEL) tt->s_list = 0;
        !          33773:                        return tt;
        !          33774:                }
        !          33775:        }
        !          33776: 
        !          33777:        switch (tt->base) {
        !          33778:        case PAIR:      return trim_tail(tt->s2);
        !          33779: //     case LABEL:     return trim_tail(tt->s);
        !          33780:        case BLOCK:     if (tt->s) return trim_tail(tt->s);
        !          33781:        default:        return tt;
        !          33782:        }
        !          33783: }
        !          33784: 
        !          33785: extern Ptype Pfct_type;
        !          33786: 
        !          33787: Pexpr mptr_assign(Pexpr n, Pexpr in)
        !          33788: {
        !          33789:        Pexpr i1;
        !          33790:        Pexpr i2;
        !          33791:        Pexpr i3;
        !          33792: 
        !          33793:        if ( n->base == NAME ) 
        !          33794:                Pname(n)->use();
        !          33795: 
        !          33796:        if (in->base == NAME) {
        !          33797:                i1 = new mdot("d",in);
        !          33798:                i1->i1 = 9;
        !          33799:                i2 = new mdot("i",in);
        !          33800:                i2->i1 = 9;
        !          33801:                i3 = new mdot("f",in);
        !          33802:                i3->i1 = 9;
        !          33803:        }
        !          33804:        else {
        !          33805:                i1 = in->e1->e1;
        !          33806:                i2 = in->e1->e2;
        !          33807:                i3 = in->e2;
        !          33808:        }
        !          33809:        Pexpr nd = new mdot("d",n);
        !          33810:        nd->i1 = 9;
        !          33811:        Pexpr e1 = new expr(ASSIGN,nd,i1);
        !          33812: 
        !          33813:        Pexpr ni = new mdot("i",n);
        !          33814:        ni->i1 = 9;
        !          33815:        Pexpr e2 = new expr(ASSIGN,ni,i2);
        !          33816: 
        !          33817:        Pexpr nf = new mdot("f",n);
        !          33818:        nf->i1 = 9;
        !          33819: //     Pexpr ii = in->e2; //new cast(Pfct_type,in->e2);
        !          33820:        Pexpr e3 = new expr(ASSIGN,nf,i3);
        !          33821: 
        !          33822:        Pexpr ee = new expr(CM,e2,e3);
        !          33823:        return new expr(CM,e1,ee);
        !          33824: }
        !          33825: 
        !          33826: Pstmt block::simpl()
        !          33827: {
        !          33828:        int i;
        !          33829:        Pname n;
        !          33830:        Pstmt ss=0, sst=0;
        !          33831:        Pstmt dd=0, ddt=0;
        !          33832:        Pstmt stail;
        !          33833:        Ptable old_scope = scope;
        !          33834:        DB( if(Sdebug>=1)
        !          33835:                error('d',"%d->block::simple() own_tbl %d  memtbl %d  curr_fct%n",this,own_tbl,memtbl,curr_fct);
        !          33836:        );
        !          33837:        if (own_tbl == 0) {
        !          33838:                ss = (s) ? s->simpl() : 0;
        !          33839:                return ss;
        !          33840:        }
        !          33841: 
        !          33842:        scope = memtbl;
        !          33843:        if (scope->init_stat == 0) scope->init_stat = 1; /* table is simplified. */
        !          33844: 
        !          33845:        for (n=scope->get_mem(i=1); n; n=scope->get_mem(++i)) {
        !          33846:                Pstmt st = 0;
        !          33847:                Pname cln;
        !          33848:                Pexpr in = n->n_initializer;
        !          33849: // error('d',"local %k %n in %k %t",n->n_sto,n,in?in->base:0,in?in->tp:0);
        !          33850:                if (in || n->n_evaluated) {
        !          33851:                        scope->init_stat = 2; /* initializer in this scope */
        !          33852:                        if (n->n_sto == EXTERN) {
        !          33853:                                error(&n->where,"Id local extern%n",n);
        !          33854:                                continue;
        !          33855:                        }
        !          33856:                }
        !          33857: 
        !          33858:                switch (n->n_scope) {
        !          33859:                case ARG:
        !          33860:                case 0:
        !          33861:                case PUBLIC:
        !          33862:                         continue;
        !          33863:                }
        !          33864: 
        !          33865:                if (n->n_stclass == STATIC) { // local static class object
        !          33866:                        /* initialization of local static objects; 
        !          33867:                         * set up first pass switch
        !          33868:                         *     temp_switch ? 0 
        !          33869:                         *       : (stat_obj=init_expr, temp_switch=1);
        !          33870:                         *
        !          33871:                         * ARGS: temporary class object in init_expr with dtor
        !          33872:                         *       must call dtor once in std function
        !          33873:                         */
        !          33874: 
        !          33875:                        if ((in==0 && n->n_scope==ARGS) ||
        !          33876:                                (in && in->base==STAT_INIT)) 
        !          33877:                        {
        !          33878:                                Pname cn;
        !          33879:                                Pname x;
        !          33880:                                Ptype ct;
        !          33881:                                int vec_seen = 0;
        !          33882: 
        !          33883:                                cn = n->tp->is_cl_obj();
        !          33884:                                if ( cn == 0 ) { ++vec_seen; cn = cl_obj_vec; }
        !          33885: 
        !          33886:                                if ( cn ) {
        !          33887:                                        ct = new ptr(PTR,vec_seen?Pvec(n->tp)->typ:n->tp);
        !          33888:                                        x = make_tmp('F', ct, gtbl );
        !          33889:                                        x->n_initializer = zero;
        !          33890:                                }
        !          33891:                                else
        !          33892:                                        x = make_tmp('F',int_type,scope);
        !          33893: 
        !          33894:                                x->n_sto = n->n_stclass = STATIC;
        !          33895:                                
        !          33896:                                if (in) {
        !          33897:                                        if (in->e2)
        !          33898:                                                in->base = ASSIGN;
        !          33899:                                        else in = in->e1;
        !          33900:                                }
        !          33901: 
        !          33902:                                Pexpr set;
        !          33903:                                if ( cn ) {
        !          33904:                                        x->dcl_print(0);
        !          33905:                                        Pclass cl = Pclass(cn->tp);
        !          33906:                                        Pname dtor = cl->has_dtor();
        !          33907: 
        !          33908:                                        Pexpr cc;
        !          33909:                                        if ( dtor ) {
        !          33910:                                                if ( vec_seen == 0 ) {
        !          33911:                                                        Pexpr eee = new expr(DEREF, x, 0 );
        !          33912:                                                        Pexpr c = call_dtor(eee,dtor,0,DOT,one);
        !          33913:                                                        c->tp = any_type;
        !          33914:                                                        cc = new expr( QUEST, c, zero );
        !          33915:                                                        cc->cond = x;
        !          33916:                                                }
        !          33917:                                                else cc = cdvec(vec_del_fct,x,cl,dtor,0,zero,n);
        !          33918:                                                cc->tp = any_type; // arghh!
        !          33919: 
        !          33920:                                                Pstmt dls = new estmt( SM, n->where, cc, 0 );
        !          33921:                                                if ( st_dlist ) dls->s_list = st_dlist;
        !          33922:                                                st_dlist = dls;
        !          33923:                                        }
        !          33924: 
        !          33925:                                        Pexpr xe;
        !          33926:                                        if (cn) {
        !          33927:                                                if ( vec_seen == 0 )
        !          33928:                                                        xe = new expr( G_ADDROF, 0, n );
        !          33929:                                                else {
        !          33930:                                                        Pexpr ee = new expr( DEREF, n, zero );
        !          33931:                                                        xe = new expr( G_ADDROF, 0, ee );
        !          33932:                                                }
        !          33933:                                        }
        !          33934: 
        !          33935:                                        set = new expr(ASSIGN,x,xe);
        !          33936:                                        set->tp = ct;
        !          33937:                                }
        !          33938:                                else {
        !          33939:                                        set = new expr(ASSIGN,x,one);
        !          33940:                                        set->tp = int_type;
        !          33941:                                }
        !          33942: 
        !          33943:                                // set pointer to static object and continue
        !          33944:                                // sorry for goto, but beats rewriting code
        !          33945:                                if ( n->n_scope == ARGS && in == 0 ) {
        !          33946:                                        set = new expr( QUEST, zero, set );
        !          33947:                                        set->cond = x;
        !          33948:                                        st = new estmt(SM,n->where,set,0);
        !          33949:                                        goto init_stat3;
        !          33950:                                }
        !          33951: 
        !          33952:                                in = new expr(G_CM,in,set);
        !          33953:                                in = new expr(STAT_INIT,zero,in);
        !          33954:                                in->cond = x;
        !          33955:                        }
        !          33956:                        else
        !          33957:                                continue;
        !          33958:                }
        !          33959: 
        !          33960:                if ( in ) {
        !          33961:                        if ((in->base == ILIST && in->e2 == 0) ||
        !          33962:                            (in->base == STRING && n->tp->base == VEC))
        !          33963:                                if (ansi_opt==0) {
        !          33964:                                        error('s',&n->where,"initialization of%n (automatic aggregate)",n);
        !          33965:                                        continue;
        !          33966:                                }
        !          33967:                }    
        !          33968: 
        !          33969:                if (n->tp == 0) continue; /* label */
        !          33970:                if (n->n_evaluated) continue;
        !          33971: 
        !          33972:                /* construction and destruction of temporaries is handled locally */
        !          33973:                {       char* s = n->string;
        !          33974:                        register char c3 = s[4];
        !          33975:                        if (s[0]=='_' && s[1]=='_' && s[2]=='D' && isdigit(c3)) continue;
        !          33976:                }
        !          33977: 
        !          33978:                if ( cln=n->tp->is_cl_obj() ) {
        !          33979:                        Pclass cl = Pclass(cln->tp);
        !          33980:                        Pname d = cl->has_dtor();
        !          33981: 
        !          33982:                        if ( n->n_stclass == STATIC   // local static class object
        !          33983:                                && in && in->base==STAT_INIT )  
        !          33984:                                        goto stat_init;
        !          33985: 
        !          33986:                        if (d) {                        // n->cl.dtor(0);
        !          33987:                                Pexpr dl = call_dtor(n,d,0,DOT,one);
        !          33988:                        //      Pstmt dls = new estmt(SM,n->where,dl,0);
        !          33989:                                Pstmt dls = new estmt(SM,no_where,dl,0);
        !          33990:                                if (dd) {
        !          33991:                                        dls->s_list = dd;
        !          33992:                                        dd = dls;
        !          33993:                                }
        !          33994:                                else
        !          33995:                                        ddt = dd = dls;
        !          33996:                        }
        !          33997: 
        !          33998: //  error('d',"%n: in %d",n,in?in->base:0);
        !          33999:                        if (in) {
        !          34000:                                switch (in->base) {
        !          34001:                                case DEREF:             // *constructor?
        !          34002:                                        if (in->e1->base == G_CALL) {
        !          34003:                                                Pname fn = in->e1->fct_name;
        !          34004:                                                if (fn==0 || fn->n_oper!=CTOR) goto ddd;
        !          34005:                                                st = new estmt(SM,n->where,in->e1,0);
        !          34006:                                                n->n_initializer = 0;
        !          34007:                                                break;
        !          34008:                                        }
        !          34009:                                        goto ddd;
        !          34010:                                case STAT_INIT:
        !          34011: stat_init:
        !          34012: // error('d', "block::simpl: case #1 stat_init : n: %n", n );
        !          34013:                                        in->base = QUEST;
        !          34014:                                        st = new estmt(SM,n->where,in,0);
        !          34015:                                        n->n_initializer = 0;
        !          34016:                                        break;
        !          34017:                                case G_CM:
        !          34018:                                        st = new estmt(SM,n->where,in->e1,0);
        !          34019:                                        n->n_initializer = 0;
        !          34020:                                        break;
        !          34021:                                case ASSIGN:            // assignment to "n"?
        !          34022:                                        if (in->e1 == n) {
        !          34023:                                                st = new estmt(SM,n->where,in,0);
        !          34024:                                                n->n_initializer = 0;
        !          34025:                                                break;
        !          34026:                                        }
        !          34027:                                default:
        !          34028:                                        goto ddd;
        !          34029:                                }
        !          34030:                        }
        !          34031:                }
        !          34032:                else if (cl_obj_vec) {
        !          34033:                        Pclass cl = Pclass(cl_obj_vec->tp);
        !          34034:                        Pname d = cl->has_dtor();
        !          34035:                        Pname c = cl->has_ictor();
        !          34036:                        n->n_initializer = 0;
        !          34037: 
        !          34038:                        if ( n->n_stclass == STATIC   // local static class object
        !          34039:                                && in && in->base==STAT_INIT )  
        !          34040:                                        goto stat_init2;
        !          34041: 
        !          34042:                        if (c) {        //  _vec_new(vec,noe,sz,ctor);
        !          34043:                                if (in==0 || in->base==ILIST) {
        !          34044:                                        Pexpr a = cdvec(vec_new_fct,n,cl,c,-1,0);
        !          34045:                                        st = new estmt(SM,n->where,a,0);
        !          34046:                                }
        !          34047:                                else 
        !          34048:                                        st = new estmt(SM,n->where,in,0);
        !          34049:                        }
        !          34050:                        // no default ctor but provided all elements with argument
        !          34051:                        else if ( in ) st = new estmt(SM,n->where,in,0);
        !          34052: 
        !          34053:                        
        !          34054:                        if (d) {        //  __vec_delete(vec,noe,sz,dtor,0);
        !          34055:                                Pfct f = Pfct(d->tp);
        !          34056:                                int i = 0;
        !          34057:                                for (Pname nn = f->f_args->n_list; 
        !          34058:                                        nn && nn->n_list; nn=nn->n_list) i++;
        !          34059:                                Pexpr a = cdvec(vec_del_fct,n,cl,d,0,new ival(i));
        !          34060:                        //      Pstmt dls = new estmt(SM,n->where,a,0);
        !          34061:                                Pstmt dls = new estmt(SM,no_where,a,0);
        !          34062:                                if (dd) {
        !          34063:                                        dls->s_list = dd;
        !          34064:                                        dd = dls;
        !          34065:                                }
        !          34066:                                else
        !          34067:                                        ddt = dd = dls;
        !          34068:                        }
        !          34069:                }
        !          34070:                else if (in) {
        !          34071:                        switch (in->base) {
        !          34072:                        case ILIST:
        !          34073:                                switch (n->n_scope) {
        !          34074:                                case FCT:
        !          34075:                                        if (in->e2) { // pointer to member
        !          34076:                                                Pexpr ee = mptr_assign(n,in);
        !          34077:                                                st = new estmt(SM,n->where,ee,0);
        !          34078:                                                n->n_initializer = 0;
        !          34079:                                                break;
        !          34080:                                        }
        !          34081:                                case ARG:
        !          34082:                                        if (ansi_opt == 0) error('s',"Ir list for localV%n",n); 
        !          34083:                                }
        !          34084:                                break;
        !          34085:                        case STAT_INIT:
        !          34086: stat_init2:
        !          34087: // error('d', "block::simpl: case #2 stat_init : n: %n", n );
        !          34088:                                in->base = QUEST;
        !          34089:                                st = new estmt(SM,n->where,in,0);
        !          34090:                                n->n_initializer = 0;
        !          34091:                                break;
        !          34092:                        case STRING:
        !          34093:                                if (n->tp->base==VEC) break; /* BUG char vec only */
        !          34094:                        default:
        !          34095:                        ddd:
        !          34096:                        {       Pexpr ee = new expr(ASSIGN,n,in);
        !          34097:                                st = new estmt(SM,n->where,ee,0);
        !          34098:                                n->n_initializer = 0;
        !          34099:                        }
        !          34100:                        }
        !          34101:                }
        !          34102: 
        !          34103: init_stat3:    if (st) {
        !          34104:                        if (ss)
        !          34105:                                sst->s_list = st;
        !          34106:                        else
        !          34107:                                ss = st;
        !          34108:                        sst = st;
        !          34109:                }
        !          34110:        }
        !          34111: 
        !          34112:        if (dd) {
        !          34113:                Pstmt od = del_list;
        !          34114:                Pstmt obd = break_del_list;
        !          34115:                Pstmt ocd = continue_del_list;
        !          34116: 
        !          34117:                dd->simpl();
        !          34118:                del_list = (od) ? Pstmt(new pair(curloc,dd,od)) : dd;
        !          34119:                break_del_list = (break_del_list&&obd) ? Pstmt(new pair(curloc,dd,obd)) : dd;
        !          34120:                continue_del_list = (continue_del_list&&ocd) ? Pstmt(new pair(curloc,dd,ocd)) : dd;
        !          34121: 
        !          34122:                stail  = s ? s->simpl() : 0;
        !          34123: 
        !          34124:                Pfct f = Pfct(curr_fct->tp);
        !          34125:                if (this!=f->body
        !          34126:                || f->returns->base==VOID
        !          34127:                || (f->returns->base!=VOID && no_of_returns==0 ) // you have been warned!
        !          34128:                || strcmp(curr_fct->string,"main")==0 ) {
        !          34129:                // not dropping through the bottom of a value returning function
        !          34130:                        if (stail) {
        !          34131:                                Pstmt tt = (stail->base==RETURN || stail->base==LABEL) ? stail : trim_tail(stail);
        !          34132:                                if (tt && tt->base != RETURN) stail->s_list = dd;
        !          34133:                        }
        !          34134:                        else
        !          34135:                                s = dd;
        !          34136:                        stail = ddt;
        !          34137:                }
        !          34138: 
        !          34139:                del_list = od;
        !          34140:                continue_del_list = ocd;
        !          34141:                break_del_list = obd;
        !          34142:        }
        !          34143:        else
        !          34144:                stail  = s ? s->simpl() : 0;
        !          34145: 
        !          34146:        if (ss) {       /* place constructor calls */
        !          34147:                ss->simpl();
        !          34148:                sst->s_list = s;
        !          34149:                s = ss;
        !          34150:                if (stail == 0) stail = sst;
        !          34151:        }
        !          34152:        
        !          34153:        scope = old_scope;
        !          34154: 
        !          34155:        return stail;
        !          34156: }
        !          34157: 
        !          34158: int no_sizeof;
        !          34159: 
        !          34160: void expr::simpl()
        !          34161: {
        !          34162:        DB(if(Sdebug>=2){
        !          34163:                error('d',"%d->expr::simpl() %k",this,this?base:0);
        !          34164:                if(Sdebug>=3) display_expr(this);
        !          34165:        });
        !          34166:        if (this==0 || permanent==2) return;    // already expanded
        !          34167:        static TOK obase = 0;
        !          34168: 
        !          34169:        switch (base) {
        !          34170:        case MDOT:
        !          34171:                obase = base;
        !          34172:                mem->simpl();
        !          34173:                obase = 0;
        !          34174:                // no break
        !          34175: 
        !          34176:        case ICALL:     // already expanded
        !          34177:                return;
        !          34178: 
        !          34179:        case G_ADDROF:
        !          34180:        case ADDROF:
        !          34181: // error('d',"simpl & %k",e2->base);
        !          34182: 
        !          34183:                e2->simpl();
        !          34184:                switch (e2->base) {
        !          34185:                case DOT:
        !          34186:                case REF:
        !          34187:                {       Pref r = Pref(e2);
        !          34188:                        Pname m = Pname(r->mem);
        !          34189:                        while (m->base == MDOT) m = Pname(m->mem);
        !          34190:                        if (m->n_stclass == STATIC) {   // & static member
        !          34191:                                Pexpr x;
        !          34192:                        delp:
        !          34193:                                x = e2;
        !          34194:                                e2 = m;
        !          34195:                                r->mem = 0;
        !          34196:                                DEL(x);
        !          34197:                        }
        !          34198:                        else if (m->tp->base == FCT) {  // & member fct
        !          34199:                                Pfct f = Pfct(m->tp);
        !          34200:                                if (f->f_virtual) {     // &p->f ==> p->vtbl[fi].f
        !          34201:                                        int index = f->f_virtual;
        !          34202:                                        Pexpr ie = index ? new ival(index):0;
        !          34203:                                        if (ie) ie->tp = int_type;
        !          34204:                                        Pname cn = m->n_table->t_name;
        !          34205:                                        Pname vp = find_vptr(Pclass(cn->tp));
        !          34206:                                        r->mem = vp;
        !          34207: 
        !          34208:                                        if ( obase == MDOT ) {
        !          34209:                                                base = DEREF;
        !          34210:                                                e1 = e2;
        !          34211:                                                e2 = ie;
        !          34212:                                        }
        !          34213:                                        else { // support old style &b.vf
        !          34214:                                                base = MDOT;
        !          34215:                                                mem = new expr(DEREF,e2,ie);
        !          34216:                                                string2 = "f";
        !          34217:                                                i1 = 9;
        !          34218:                                        }
        !          34219:                                }
        !          34220:                                else {
        !          34221:                                        goto delp;
        !          34222:                                }
        !          34223:                        }
        !          34224:                        break;
        !          34225:                }
        !          34226:                }
        !          34227:                break;
        !          34228:        
        !          34229:        case ANDAND:
        !          34230:        case OROR:
        !          34231:                Ntmp = 0;
        !          34232:                // no break
        !          34233: 
        !          34234:        default:
        !          34235:                if (e1) e1->simpl();
        !          34236:                if (e2) e2->simpl();
        !          34237:                break;
        !          34238: 
        !          34239:        case CM:
        !          34240:        case G_CM:
        !          34241:        {       
        !          34242:                Pname n = 0;
        !          34243:                e1->simpl();
        !          34244:                e2->simpl();
        !          34245:                if (e1->base==ICALL && e1->e1==0) n = e1->il->fct_name;
        !          34246:                if (e2->base==ICALL && e2->e1==0) n = e2->il->fct_name;
        !          34247:                if (n) error('s',"cannot expand inline void%n called in commaE",n);
        !          34248:                // no break
        !          34249:        }
        !          34250:        case NAME:
        !          34251:        case DUMMY:
        !          34252:        case ICON:
        !          34253:        case FCON:
        !          34254:        case CCON:
        !          34255:        case IVAL:
        !          34256:        // case FVAL:
        !          34257:        // case LVAL:
        !          34258:        case STRING:
        !          34259:        case ZERO:
        !          34260:        case ILIST:
        !          34261: //     case MDOT:
        !          34262:                return;
        !          34263: /*
        !          34264:        case SIZEOF:
        !          34265:                base = IVAL;
        !          34266:                i1 = tp2->tsizeof();
        !          34267:                tp2 = 0;        // can't DEL(tp2)
        !          34268:                break;
        !          34269: */
        !          34270:        case SIZEOF:
        !          34271:                if (e1) e1->simpl();
        !          34272:                return;
        !          34273: 
        !          34274:        case G_CALL:
        !          34275:        case CALL:
        !          34276:                Pcall(this)->simpl();
        !          34277:                break;
        !          34278: 
        !          34279:        case NEW:
        !          34280:        case GNEW:
        !          34281:                simpl_new();
        !          34282:                return;
        !          34283: 
        !          34284:        case DELETE:
        !          34285:        case GDELETE:
        !          34286:                simpl_delete();
        !          34287:                break;
        !          34288: 
        !          34289:        case QUEST:
        !          34290:                cond->simpl();
        !          34291:                Ntmp = 0;
        !          34292:                e2->simpl();
        !          34293:                // no break
        !          34294: 
        !          34295:        case CAST:
        !          34296:        case REF:
        !          34297:                e1->simpl();
        !          34298:                break;
        !          34299: 
        !          34300:        case DOT:
        !          34301:                e1->simpl();
        !          34302:                switch (e1->base) {
        !          34303:                case CM:
        !          34304:                case G_CM:
        !          34305:                 {      // &( , name). => ( ... , &name)->
        !          34306:                        Pexpr ex = e1;
        !          34307:                        cfr:
        !          34308:                        switch (ex->e2->base) {
        !          34309:                        case NAME:
        !          34310:                                base = REF;
        !          34311:                                ex->e2 = ex->e2->address();
        !          34312:                                break;
        !          34313:                        case CM:
        !          34314:                        case G_CM:
        !          34315:                                ex = ex->e2;
        !          34316:                                goto cfr;
        !          34317:                        }
        !          34318:                }
        !          34319:                }
        !          34320:                break;
        !          34321: 
        !          34322:        case ASSIGN:
        !          34323:        {       
        !          34324:                Pfct f = 0; 
        !          34325:                Pexpr th = 0;
        !          34326:                if ( curr_fct ) {
        !          34327:                        f = Pfct(curr_fct->tp);
        !          34328:                        th = f->f_this;
        !          34329:                }
        !          34330: 
        !          34331:                imeasure++;
        !          34332:                if (e1) e1->simpl();
        !          34333:                if (e2) {
        !          34334:                        Pexpr c = e2;
        !          34335:                        c->simpl();
        !          34336:                        while (c->base == CAST) c = c->e1;
        !          34337:                        if (c->base == ILIST) e2 = c;
        !          34338: 
        !          34339:                        if (e2->base == ILIST) {        // pointer to member assignment
        !          34340:                                Pexpr ee = mptr_assign(e1,e2);
        !          34341:                                Pexpr eee = new expr(CM,ee->e2,e1);
        !          34342:                                e1 = ee->e1;
        !          34343:                                e2 = eee;
        !          34344:                                base = CM;
        !          34345:                                delete ee;
        !          34346:                        }
        !          34347:                }
        !          34348: 
        !          34349:                if (th && th==e1 && curr_fct->n_oper==CTOR && init_list) {
        !          34350:                        // this=e2 => (this=e2,init_list)
        !          34351:                        Pclass cl = Pclass(Pbase(Pptr(th->tp)->typ)->b_name->tp);
        !          34352:                        if (cl->c_body == 1) cl->dcl_print(0);
        !          34353:                        imeasure++;
        !          34354:                        base = CM;
        !          34355:                        e1 = new expr(ASSIGN,e1,e2);
        !          34356:                        e2 = init_list;
        !          34357:                        if (warning_opt)        // timid
        !          34358:                                error('w',"assignment to ``this'' inK: try defining%t::operator new() instead",f->memof);
        !          34359:                }
        !          34360:                break;
        !          34361:        }
        !          34362:        }
        !          34363: 
        !          34364:        switch (base) {
        !          34365:        case QUEST:
        !          34366:        case ANDAND:
        !          34367:        case OROR:
        !          34368:                if (Ntmp) error('s',"temporary ofC%n with destructor needed in%kE",Ntmp,base);
        !          34369:                // no break;
        !          34370:        default:
        !          34371:                Ntmp = 0;
        !          34372:        }
        !          34373:        
        !          34374:        if (tp==int_type || tp==defa_type) {
        !          34375:                Neval = 0;
        !          34376:                no_sizeof = 1;  // do not convert sizeof's to ints
        !          34377:                long i = eval();
        !          34378:                no_sizeof = 0;
        !          34379:                if (Neval == 0) {
        !          34380:                        base = IVAL;
        !          34381:                        i1 = i;
        !          34382:                }
        !          34383:        }
        !          34384: 
        !          34385: }
        !          34386: 
        !          34387: Pexpr vptr_entry(Pexpr pp, Pexpr ie, Pclass cl)
        !          34388: {
        !          34389:        Pptr ttemp = pp->tp->is_ptr_or_ref();
        !          34390: 
        !          34391:         if (ttemp) {
        !          34392:                Ptype pt = ttemp->typ;  // check if cast pp = (base*)pp
        !          34393:                Pclass pc = Pclass(pt->is_cl_obj()->tp); // is needed
        !          34394:                if (pc!=cl) pp = new cast(cl,pp);
        !          34395:         }
        !          34396:        Pname vp = find_vptr(cl);
        !          34397:        if (vp == 0) error('i',"can't find vptr");
        !          34398:        Pexpr vptr = new ref(REF,pp,vp);        // pp->vptr
        !          34399:        return new expr(DEREF,vptr,ie); // pp->vptr[i]
        !          34400: }
        !          34401: 
        !          34402: Pexpr new_this(Pexpr pp, Pexpr ee)
        !          34403: {
        !          34404: //error('d',"new this");
        !          34405:        Pexpr dee =  new mdot("d",ee);          // pp->vptr[i].d
        !          34406:        dee->i1 = 9;
        !          34407:        Pexpr nthis = new cast(Pchar_type,pp);
        !          34408:        nthis = new expr(PLUS,nthis,dee);       // ((char*)pp)+delta
        !          34409:        Ptype ct = pp->tp;
        !          34410:        if (pp->base==NAME && Pname(pp)->n_xref) ct = pp->tp->addrof();
        !          34411:        return new cast(ct,nthis);
        !          34412: }
        !          34413: 
        !          34414: Pcall vcall(Pexpr pp, Pexpr ie, Pfct f, Pclass cl, Pexpr args)
        !          34415: /*
        !          34416:        generate a call of the virtual function with the index ``ie''
        !          34417:        and type "f" in class ``cl'' for the object pointed to by ``pp''
        !          34418: 
        !          34419:        multiple inheritance virtual call:
        !          34420: 
        !          34421:        p->f(x) is resolved like this
        !          34422:        pp = p;                 // avoid side effects
        !          34423:        pp = p.base_object;     // often: pp = p;
        !          34424:                                // done when the name was resolved
        !          34425:        i = index(f);
        !          34426:        entry = pp->_vtbl[i-1];
        !          34427:        pp = (T*)(((char*)pp)+entry.d)
        !          34428:        (*(ftype)entry.f)(pp,x)
        !          34429: */
        !          34430: {
        !          34431: //error('d',"vcall %t",cl);
        !          34432:        if (cl->c_body==1) cl->dcl_print(0);    // look for first use of cl
        !          34433:                
        !          34434:        imeasure+=6;
        !          34435:        Pexpr ee = vptr_entry(pp,ie,cl);
        !          34436: 
        !          34437:        Pexpr fee = new mdot("f",ee);
        !          34438:        fee->i1 = 9;
        !          34439:        Ptype pft = f->addrof();
        !          34440:        fee = new cast(pft,fee);                // (T)pp->vptr[i].f
        !          34441:        Pexpr r = new expr(DEREF,fee,0);        // *(T)pp->vptr[i].f
        !          34442:                                                // e1->tp must be 0, means "argtype encoded"
        !          34443:        r->tp2 = Ptype(f->f_this);              // encode argtype
        !          34444: 
        !          34445:        Pexpr nthis = new_this(pp,ee);
        !          34446: 
        !          34447:        args = new expr(ELIST,nthis,args);
        !          34448:        args->simpl();
        !          34449: 
        !          34450:        Pcall c = new call(r,args);
        !          34451:        c->tp = f->returns;
        !          34452:        return c;
        !          34453: }
        !          34454: 
        !          34455: void call::simpl()
        !          34456: /*
        !          34457:        fix member function calls:
        !          34458:                p->f(x) becomes f(p,x)
        !          34459:                o.f(x)  becomes f(&o,x)
        !          34460:        or if f is virtual:
        !          34461:                p->f(x) is resolved like this
        !          34462:                        pp = p;
        !          34463:                        i = index(f);
        !          34464:                        entry = pp->_vtbl[i-1];
        !          34465:                        pp = (T*)(((char*)pp)+entry.i)
        !          34466:                        (*entry.f)(pp,x)
        !          34467:        replace calls to inline functions by the expanded code
        !          34468: */
        !          34469: {
        !          34470:        Pname fn = fct_name;
        !          34471: //error('d',"%d call::simpl() fn %n %d e1 %d",this,fn,fn,e1);
        !          34472:        Pfct f = fn ? Pfct(fn->tp) : 0;
        !          34473: 
        !          34474:        if (fn == 0) e1->simpl();
        !          34475: 
        !          34476:        if (f) {
        !          34477:                switch(f->base) {
        !          34478:                case ANY:
        !          34479:                        return;
        !          34480:                case OVERLOAD:
        !          34481:                        fct_name = fn = Pgen(f)->fct_list->f;
        !          34482:                        f = Pfct(fn->tp);
        !          34483:                }
        !          34484:        }
        !          34485: 
        !          34486:        switch (e1->base) {
        !          34487:        case MEMPTR:    // (p ->* q)(args)
        !          34488:        {       
        !          34489:                Pexpr p = e1->e1;
        !          34490:                Pexpr q = e1->e2;
        !          34491:                Pclass cl = Pclass(e1->tp2);
        !          34492:                Pfct f = Pfct(q->tp->deref());
        !          34493: 
        !          34494:                if (e2) e2->simpl();
        !          34495: 
        !          34496:                if (f->f_this == 0) {   // might not know about ``this'' yet
        !          34497:                        if (f->memof == 0) error('i',"memof missing");
        !          34498:                        Pname tt = new name("this");
        !          34499:                        tt->n_scope = ARG;
        !          34500:                        tt->tp = f->memof->this_type;
        !          34501:                        PERM(tt);
        !          34502:                //      f->f_this = f->f_args = tt;
        !          34503:                        tt->n_list = f->argtype;
        !          34504:                //      f->f_this = tt;
        !          34505:                        tt->n_list = f->f_result ? f->f_result : f->argtype;
        !          34506:                        f->f_this = f->f_args = tt;
        !          34507:                }
        !          34508: //error('d',"f_this %d",f->f_this);    
        !          34509: extern has_virt(Pclass);
        !          34510: 
        !          34511:                // beware of sideeffects:
        !          34512:                nin = 1;
        !          34513:                if (q->not_simple()) error('s',"2nd operand of .* too complicated");
        !          34514:                nin = 0;
        !          34515: 
        !          34516:                Pexpr qq = new mdot("f",q);     // the function: (*(right type)q.f)
        !          34517:                qq->i1 = 9;
        !          34518:                qq = new cast(f->addrof(),qq);
        !          34519:                Pexpr nc = new expr(DEREF,qq,0);
        !          34520:                nc->tp2 = Ptype(f->f_this);     // encode argtype
        !          34521: 
        !          34522:                Pexpr nthis = new_this(p,q);    // arguments: (p+q.d,args)
        !          34523:                Pexpr args = new expr(ELIST,nthis,e2);
        !          34524:                imeasure+=3;
        !          34525: 
        !          34526:                if (has_virt(cl) == 0) {        // no virtuals: simple
        !          34527:                        if (cl->defined == 0) 
        !          34528:                                error("call throughP toMF before definition ofC %t",cl);
        !          34529: //error('d',"no virt");
        !          34530:                        // (p ->* q)(args) => (*q.f)(p+q.d,args)
        !          34531:                        e1 = nc;
        !          34532:                        e2 = args;
        !          34533:                        return;
        !          34534:                }
        !          34535:                
        !          34536:                if (find_vptr(cl) == 0) {       // must be a call to a second base
        !          34537:                                                // that we cannot handle yet
        !          34538:                                                // it is OK not to to generate
        !          34539:                                                // a virtual call since a
        !          34540:                                                // `sorry' will have been generated
        !          34541:                                                // at the point of initialization
        !          34542:                        e1 = nc;
        !          34543:                        e2 = args;
        !          34544:                        return;
        !          34545: 
        !          34546:                }
        !          34547:                // beware of sideeffects:
        !          34548:                nin = 1;
        !          34549:                if (p->not_simple()) error('s',"1st operand of .* too complicated");
        !          34550:                nin = 0;
        !          34551: 
        !          34552:                Pexpr c = new mdot("i",q);      // condition (q.i<0)
        !          34553:                c->i1 = 9;
        !          34554:                c = new expr(LT,c,zero);
        !          34555:                
        !          34556:                Pexpr ie = new mdot("i",q);
        !          34557:                ie->i1 = 9;
        !          34558: 
        !          34559:                base = QUEST;
        !          34560:                e1 = new call(nc,args);
        !          34561:                e2 = vcall(p,ie,f,cl,e2);
        !          34562:                cond = c;
        !          34563:                return;
        !          34564:        }
        !          34565:        case DOT:
        !          34566:                // if e1 is an object and not just a reference
        !          34567:                // the vtbl need not be used
        !          34568:        case REF:
        !          34569:        {       Pref r = Pref(e1);
        !          34570:                Pexpr a1 = r->e1;
        !          34571:                int obj = r->n_initializer!=0;  // if B::f don't use vcall
        !          34572: 
        !          34573:                if (obj == 0) { // don't use vcall if we have an object
        !          34574:                                // (not a pointer or a reference)
        !          34575:                        if (e1->base==DOT && a1->base!=DEREF) obj = 1;
        !          34576:                }
        !          34577: 
        !          34578: //error('d',"fct_name %n f %d %d obj %d",fct_name,f,f->f_virtual,obj);
        !          34579:                if (f && obj==0 && f->f_virtual) {
        !          34580:                        Pexpr a11 = 0;
        !          34581: 
        !          34582:                        switch(a1->base) {      // see if temporary might be needed
        !          34583:                        case NAME:
        !          34584:                        case MDOT:
        !          34585:                                a11 = a1;
        !          34586:                                break;
        !          34587:                        case REF:
        !          34588:                        case DOT:
        !          34589:                                if (a1->e1->base==NAME
        !          34590:                                || ((a1->e1->base==DOT || a1->e1->base==REF) && a1->e1->e1->base==NAME)) a11 = a1;
        !          34591:                                break;
        !          34592:                        case ADDROF:
        !          34593:                        case G_ADDROF:
        !          34594:                                if (a1->e2->base == NAME
        !          34595:                                || ((a1->e2->base==DOT || a1->e2->base==REF) && a1->e2->e1->base==NAME)) a11 = a1;
        !          34596:                                break;
        !          34597:                        case CAST:
        !          34598:                                switch (a1->e1->base) {
        !          34599:                                case NAME:
        !          34600:                                case MDOT:
        !          34601:                                        a11 = a1;
        !          34602:                                }
        !          34603:                        }
        !          34604: 
        !          34605: //                     if( a1->base==REF && fn->n_oper==DTOR ){
        !          34606: //                             a11 = a1;
        !          34607: //                             goto zsw;
        !          34608: //                     }
        !          34609: //
        !          34610:                        if (e1->base == DOT) {
        !          34611: //                     zsw:
        !          34612:                                if (a11) a11 = a11->address();
        !          34613:                                a1 = a1->address();
        !          34614:                        }
        !          34615:                        
        !          34616:                        if (a11 == 0) { // temporary (maybe) needed
        !          34617:                                        // e->f() => (t=e,t->f(t))
        !          34618:                                if (a1->base==NAME)
        !          34619:                                        a11 = a1;       // &*name has become name
        !          34620:                                else {
        !          34621:                                        Pname nx = new name(make_name('K'));
        !          34622:                                        nx->tp = a1->tp;
        !          34623:                                        Pname n = nx->dcl(scope,ARG); // no init!
        !          34624:                                        delete nx;
        !          34625:                                        Pname cln = a1->tp->is_cl_obj();
        !          34626:                                        if (cln) {
        !          34627:                                                Pclass cl = Pclass(cln->tp);
        !          34628:                                                if (Ntmp==0 && cl->has_dtor()) Ntmp = cln;
        !          34629:                                                if (cl->has_itor()) n->n_xref = 1;
        !          34630:                                        }
        !          34631:                                        n->n_scope = FCT;
        !          34632:                                        n->assign();
        !          34633:                                        a11 = n;
        !          34634:                                        a1 = new expr(ASSIGN,n,a1);
        !          34635:                                        a1->tp = n->tp;
        !          34636:                                        a1->simpl();
        !          34637:                                        Pcall cc = new call(0,0);
        !          34638:                                        *cc = *this;
        !          34639:                                        base = CM;
        !          34640:                                        e1 = a1;
        !          34641:                                        e2 = cc;
        !          34642:                                        this = cc;
        !          34643:                                }
        !          34644:                        }
        !          34645: 
        !          34646:                        int i = f->f_virtual;
        !          34647:                        Pexpr ie = i?new ival(i):0;     // index
        !          34648:                        Pname cn = fn->n_table->t_name;
        !          34649:                        if (fn
        !          34650:                        && fn->n_initializer
        !          34651:                        && cc->nof
        !          34652:                        && cc->nof->n_oper==CTOR
        !          34653:                        && Pfct(cc->nof->tp)->memof->c_abstract
        !          34654:                        && strcmp(Pfct(cc->nof->tp)->memof->string, cn->string) == 0 ) {
        !          34655:                                // permit x::x( x& xx ) { xx.pvf(); }
        !          34656:                                Pexpr ee = e1->e1;
        !          34657:                                while ( ee && ee->base != NAME ) ee = ee->e1;
        !          34658:                                if ( ee && strcmp( ee->string, "this" )==0)
        !          34659:                                        error("call of pure virtualF%n inK%n",fn,cc->nof);
        !          34660:                        }
        !          34661:                        Pcall vc = vcall(a11,ie,f,Pclass(cn->tp),e2);
        !          34662:                        *this = *vc;
        !          34663:                        return; 
        !          34664:                }
        !          34665:        
        !          34666:                Ptype tt = r->mem->tp;
        !          34667:        llp:
        !          34668: //error('d',"llp %t",tt);
        !          34669:                switch (tt->base) {
        !          34670:                // default:     // pointer to function: (n->ptr_mem)(args); do nothing
        !          34671:                case TYPE:
        !          34672:                        tt = Pbase(tt)->b_name->tp;
        !          34673:                        goto llp;
        !          34674:                case OVERLOAD:  // n->fctmem(args);
        !          34675:                case FCT:
        !          34676:                        if (fct_name==0) {
        !          34677:                                // reconstitute fn destroyed to suppress "virtual" 
        !          34678:                                fct_name = fn = Pname(e1->n_initializer);
        !          34679:                                f = Pfct(fn->tp);
        !          34680:                        }
        !          34681: 
        !          34682:                        if (e1->base == DOT) a1 = a1->address();
        !          34683:                        e2 = new expr(ELIST,a1,e2);
        !          34684:                        e1 = r->mem;
        !          34685:                }
        !          34686:        }
        !          34687:        }
        !          34688: 
        !          34689:        if (e2) e2->simpl();
        !          34690: //error('d',"fn %n inl %d imes %d",fn,f->f_inline,f->f_imeasure);
        !          34691:        if (fn && f->f_inline && debug_opt==0) {
        !          34692:                imeasure += f->f_imeasure;
        !          34693:                Pclass cl = f->memof;
        !          34694:                if (cl && cl->c_body) cl->dcl_print(0);
        !          34695:                Ptable oscope = scope;
        !          34696:                Pexpr ee = f->expand(fn,scope,e2);
        !          34697:                scope = oscope;
        !          34698:                if (ee) *Pexpr(this) = *ee;
        !          34699:        }
        !          34700:        else if (fn && f->f_inline==0 && f->f_imeasure) {
        !          34701:                extern void uninline(Pname fn);
        !          34702:                uninline(fn);
        !          34703:                imeasure += 3;
        !          34704:        }
        !          34705:        else if (fn && debug_opt && f->f_inline==ITOR) {
        !          34706:                extern void expand_itor(Pclass);
        !          34707:                expand_itor(f->memof);
        !          34708:        }
        !          34709:        else
        !          34710:                imeasure += 3;
        !          34711: }
        !          34712: 
        !          34713: void uninline(Pname fn)
        !          34714:        // inline turned static
        !          34715: {
        !          34716:        Pfct f = Pfct(fn->tp);
        !          34717: //error('d',"uninline %n %d %d",fn,f->body,f->f_expr);
        !          34718: 
        !          34719:        if (warning_opt) {
        !          34720:                error('w',"%n too complex for inlining",fn);
        !          34721:                error('w',"out-of-line copy of %n created",fn);
        !          34722:        }
        !          34723:        f->f_imeasure = 0;      // now it really is just static
        !          34724: 
        !          34725:        Pstmt s = f->body->s;
        !          34726: //     for (s = f->body->s; s; s=s->s_list)
        !          34727: //error('d',"start %d %k",s->e,s->e->base);
        !          34728: //      s = f->body->s;
        !          34729:        while (s) {
        !          34730: //error('d',"s   %k %d %k",s->base,s->e,s->e->base);
        !          34731:                if (s->base == SM) {
        !          34732:                        // turn comma expression into statement list
        !          34733:                        Pexpr e = s->e;
        !          34734:                        if (e)
        !          34735:                                switch (e->base) {
        !          34736:                                case CM:
        !          34737:                                case G_CM:
        !          34738:                                {       Pstmt ss = new estmt(SM,no_where,e->e2,0);
        !          34739:                                        s->e = e->e1;
        !          34740:                                        ss->s_list = s->s_list;
        !          34741:                                        s->s_list = ss;
        !          34742:                                        delete e;
        !          34743:                                        continue;
        !          34744:                                }
        !          34745:                                }               
        !          34746:                }
        !          34747:                s = s->s_list;
        !          34748:        }
        !          34749: //     for (s = f->body->s; s; s=s->s_list)
        !          34750: //error('d',"echo %k %d %k",s->base,s->e,s->e->base);
        !          34751: 
        !          34752:        fn->dcl_print(0);
        !          34753: }
        !          34754: 
        !          34755: /*
        !          34756: void ccheck(Pexpr e)
        !          34757: 
        !          34758:         Is there a conditional in this expression? (not perfect)
        !          34759: 
        !          34760: {
        !          34761: //error('d',"ccheck(e %k)",e,e?e->base,0);
        !          34762:        if (e)
        !          34763:        switch (e->base) {
        !          34764:        case QUEST:
        !          34765:        case ANDAND:
        !          34766:        case OROR:
        !          34767:                error('s',"E too complicated: uses%k and needs temporary ofCW destructor",e->base);
        !          34768:                break;
        !          34769:        case LT:
        !          34770:        case LE:
        !          34771:        case GT:
        !          34772:        case GE:
        !          34773:        case EQ:
        !          34774:        case NE:
        !          34775:        case ASSIGN:
        !          34776:        case ASPLUS:
        !          34777:        case ASMINUS:
        !          34778:        case G_CM:
        !          34779:        case CM:
        !          34780:        case PLUS:
        !          34781:        case MINUS:
        !          34782:        case MUL:
        !          34783:        case DIV:
        !          34784:        case OR:
        !          34785:        case ER:
        !          34786:        case AND:
        !          34787:        case G_CALL:
        !          34788:        case CALL:
        !          34789:        case ELIST:
        !          34790:        case DEREF:
        !          34791:                ccheck(e->e1);
        !          34792:        case NOT:
        !          34793:        case COMPL:
        !          34794:        case CAST:
        !          34795:        case ADDROF:
        !          34796:        case G_ADDROF:
        !          34797:                ccheck(e->e2);
        !          34798:                break;
        !          34799:        case ICALL:     // check inlined arguments
        !          34800:        {       Pin il = e->il;
        !          34801:                for (int i = 0; il->args[i].arg && i<il->i_slots; i++) ccheck(il->args[i].arg);
        !          34802:        }
        !          34803:        }
        !          34804: }
        !          34805: */
        !          34806: 
        !          34807: void temp_in_cond(Pexpr ee, Pstmt ss, Ptable tbl)
        !          34808: /*
        !          34809:        insert destructor calls 'ss' into condition 'ee'
        !          34810:        ee => (Qnn = ee, dtors, Qnn)
        !          34811: */
        !          34812: {
        !          34813: //error('d',"temp_in_cond");
        !          34814: //     ccheck(ee);
        !          34815:        while (ee->base==CM || ee->base==G_CM) ee = ee->e2;
        !          34816:        Ptype ct = ee->tp;
        !          34817:        Pname n = new name(make_name('Q'));     // int Qnn;
        !          34818:        n->tp = ct;
        !          34819:        Pname tmp = n->dcl(tbl,ARG);
        !          34820:        delete n;
        !          34821:        tmp->n_scope = FCT;
        !          34822: 
        !          34823:        Pexpr v = new expr(0,0,0);
        !          34824:        *v = *ee;
        !          34825:        PERM(ct);
        !          34826:        v = new cast(ct,v);
        !          34827: 
        !          34828:        tmp->n_assigned_to = 1;
        !          34829:        Pexpr c = new expr(ASSIGN,tmp,v);       // Qnn = ee
        !          34830:        c->tp = ct;
        !          34831:        ee->base = CM;
        !          34832:        ee->e1 = c;
        !          34833: 
        !          34834:        Pexpr ex = 0;                           // add dtors at end
        !          34835: 
        !          34836:        for (Pstmt sx = ss; sx; sx = sx->s_list) {
        !          34837:                if (ex) {
        !          34838:                        ex = new expr(CM,ex,sx->e);
        !          34839:                        ex->tp = sx->e->tp;
        !          34840:                }
        !          34841:                else
        !          34842:                        ex = sx->e;
        !          34843:        }
        !          34844:        ee->e2 = new expr(CM,ex,tmp);   // add Qnn at end
        !          34845:        ee->e2->tp = ct;
        !          34846: }
        !          34847: 
        !          34848: bit not_safe(Pexpr e)
        !          34849: {
        !          34850: 
        !          34851:        switch (e->base) {
        !          34852:        default:
        !          34853:                return 1;
        !          34854: /*
        !          34855:        case CALL:
        !          34856:        case G_CALL:
        !          34857:        case DOT:
        !          34858:        case REF:
        !          34859:        case ANAME:
        !          34860:                return 1;
        !          34861: */
        !          34862:        case NAME:
        !          34863:                // if the name is automatic and has a destructor it is not safe
        !          34864:                // to destroy it before returning an expression depending on it
        !          34865:        {       Pname n = Pname(e);
        !          34866:                if (n->n_table!=gtbl && n->n_table->t_name==0) {
        !          34867:                        Pname cn = n->tp->is_cl_obj();
        !          34868:                        if (cn && Pclass(cn->tp)->has_dtor()) return 1;
        !          34869:                }
        !          34870:        }
        !          34871:        case IVAL:
        !          34872:        case ICON:
        !          34873:        case CCON:
        !          34874:        case FCON:
        !          34875:        case STRING:
        !          34876:                return 0;
        !          34877:        case NOT:
        !          34878:        case COMPL:
        !          34879:        case ADDROF:
        !          34880:        case G_ADDROF:
        !          34881:                return not_safe(e->e2);
        !          34882:        case DEREF:
        !          34883:        //      return not_safe(e->e1) || e->e2?not_safe(e->e2):0;
        !          34884:        {       int i = not_safe(e->e1);
        !          34885:                if (i) return i;
        !          34886:                if (e->e2) return not_safe(e->e2);
        !          34887:                return 0;
        !          34888:        }
        !          34889:        case CM:
        !          34890:        case PLUS:
        !          34891:        case MINUS:
        !          34892:        case MUL:
        !          34893:        case DIV:
        !          34894:        case MOD:
        !          34895:        case ASSIGN:
        !          34896:        case ASPLUS:
        !          34897:        case ASMINUS:
        !          34898:        case ASMUL:
        !          34899:        case ASDIV:
        !          34900:        case OR:
        !          34901:        case AND:
        !          34902:        case OROR:
        !          34903:        case ANDAND:
        !          34904:        case LT:
        !          34905:        case LE:
        !          34906:        case GT:
        !          34907:        case GE:
        !          34908:        case EQ:
        !          34909:        case NE:
        !          34910:                return not_safe(e->e1) || not_safe(e->e2);
        !          34911:        case QUEST:
        !          34912:                return not_safe(e->cond) || not_safe(e->e1) || not_safe(e->e2);
        !          34913:        }
        !          34914: }
        !          34915:                
        !          34916:        
        !          34917: Pexpr curr_expr;       /* to protect against an inline being expanded twice
        !          34918:                           in a simple expression keep track of expressions
        !          34919:                           being simplified
        !          34920:                        */
        !          34921: Pstmt stmt::simpl()
        !          34922: /*
        !          34923:        return a pointer to the last statement in the list, or 0
        !          34924: */
        !          34925: {
        !          34926:        if (this == 0) error('i',"0->S::simpl()");
        !          34927:        DB( if(Sdebug>=1){
        !          34928:                error('d',"%d->stmt::simpl():  %k",this,base);
        !          34929:                if(Sdebug>=2) display_stmt(this);
        !          34930:        });
        !          34931:        //Pstmt ostmt = Cstmt;
        !          34932:        //if ( where.line ) Cstmt = this;
        !          34933: 
        !          34934:        stmtno++;
        !          34935:        curr_expr = e;
        !          34936: //error('d',"stmt::simpl %k s_list %d",base,s_list);
        !          34937: 
        !          34938:        switch (base) {
        !          34939:        default:
        !          34940:                error('i',"S::simpl(%k)",base);
        !          34941: 
        !          34942:        case ASM:
        !          34943:                break;
        !          34944: 
        !          34945:        case BREAK:
        !          34946:                if (break_del_list) {   // break => { _dtor()s; break; }
        !          34947:                        Pstmt bs = new stmt(base,where,0);
        !          34948:                        Pstmt dl = break_del_list->copy();
        !          34949:                        base = BLOCK;
        !          34950:                        s = new pair(where,dl,bs);
        !          34951:                }
        !          34952:                break;
        !          34953: 
        !          34954:        case CONTINUE:
        !          34955:                if (continue_del_list) { // continue => { _dtor()s; continue; }
        !          34956:                        Pstmt bs = new stmt(base,where,0);
        !          34957:                        Pstmt dl = continue_del_list->copy();
        !          34958:                        base = BLOCK;
        !          34959:                        s = new pair(where,dl,bs);
        !          34960:                }
        !          34961:                break;
        !          34962: 
        !          34963:        case DEFAULT:
        !          34964:                s->simpl();
        !          34965:                break;
        !          34966: 
        !          34967:        case SM:
        !          34968:                if (e) {
        !          34969:                        if (e->base == DEREF) e = e->e1;
        !          34970:                        e->simpl();
        !          34971:                        if (e->base == DEREF) e = e->e1;
        !          34972:                }
        !          34973:                break;
        !          34974: 
        !          34975:        case RETURN:
        !          34976:        {       /*      return x;
        !          34977:                        =>
        !          34978:                                { dtor()s; return x; }
        !          34979:                        OR (returning an X where X(X&) is defined) =>
        !          34980:                                { ctor(_result,x); _dtor()s; return; }
        !          34981:                        OR (where x needs temporaries)
        !          34982:                        OR (where x might involve an object to be destroyed) =>
        !          34983:                                { _result = x; _dtor()s;  return _result; }
        !          34984:                        return;         =>
        !          34985:                                { _dtor()s; return; }
        !          34986:                        OR (in constructors) =>
        !          34987:                                { _dtor()s; return _this; }
        !          34988:                */
        !          34989:                Pstmt sx = this;
        !          34990:                Pexpr ex = e;
        !          34991: 
        !          34992:                no_of_returns++;
        !          34993: 
        !          34994:                Pstmt dl = (del_list) ? del_list->copy() : 0;
        !          34995:                Pfct f = Pfct(curr_fct->tp);
        !          34996: 
        !          34997:                if (e == 0) e = dummy;
        !          34998:                if (e==dummy && curr_fct->n_oper==CTOR) e = f->f_this;
        !          34999: 
        !          35000: 
        !          35001:                //      need to generate a temporary for mptr return
        !          35002:                Pexpr tt = e;
        !          35003:                while ( tt->base == CAST )
        !          35004:                        tt = tt->e1;
        !          35005:                if ( tt->base == ILIST )
        !          35006:                        e = tt;
        !          35007: 
        !          35008:                if (e->base == ILIST) {
        !          35009:                        extern Pbase mptr_type;
        !          35010:                        extern Ptype Pvptr_type;
        !          35011:                        Pexpr mptr_assign(Pexpr, Pexpr);
        !          35012:                        // memptr constant
        !          35013:                        // return({1,2,f}) ==> memptr t; return((t={1,2,f},&t))
        !          35014: 
        !          35015:                        Ptable ftbl = Pfct(curr_fct->tp)->body->memtbl;
        !          35016:                        Pname temp = make_tmp('A',mptr_type,ftbl);
        !          35017: 
        !          35018:                        // placed in mptr_assign()
        !          35019:                        // temp->use(); // necessary for inlines to force declaration
        !          35020: 
        !          35021:                        e = mptr_assign(temp,e);
        !          35022:                        e = new expr(G_CM,e,temp);
        !          35023:                        e->tp = mptr_type;
        !          35024:                }
        !          35025: 
        !          35026:                if (f->f_result) {      // ctor(_result,x); dtors; return;
        !          35027:                        if (e->base == G_CM) e = replace_temp(e,f->f_result);
        !          35028:                        e->simpl();
        !          35029:                        Pstmt cs = new estmt(SM,where,e,0);
        !          35030:                        if (dl) cs = new pair(where,cs,dl);
        !          35031:                        base = PAIR;
        !          35032:                        s = cs;
        !          35033:                        s2 = new estmt(RETURN,where,0,0);
        !          35034: //#ifdef RETBUG
        !          35035: //                     s2->empty = 1; // fudge to bypass C bug (see print.c)
        !          35036: //                     s2->ret_tp = ret_tp;
        !          35037: //#endif
        !          35038:                }
        !          35039:                else {                  // dtors; return e;
        !          35040:                        e->simpl();
        !          35041:                        if (dl) {
        !          35042:                                if (e!=dummy && not_safe(e)) {
        !          35043:                                // { _result = x; _dtor()s;  return _result; }
        !          35044:                                        Ptable ftbl = Pfct(curr_fct->tp)->body->memtbl;
        !          35045:                                        
        !          35046:                                        Pname r = ftbl->look("_result",0);
        !          35047:                                        if (r == 0) {
        !          35048:                                                r = new name("_result");
        !          35049:                                                r->tp = ret_tp;
        !          35050:                                                Pname rn = r->dcl(ftbl,ARG);
        !          35051:                                                rn->n_scope = FCT;
        !          35052:                                                rn->where = no_where;
        !          35053:                                                rn->assign();
        !          35054:                                                delete r;
        !          35055:                                                r = rn;
        !          35056:                                        }
        !          35057:                                        Pexpr as = new expr(ASSIGN,r,e);
        !          35058:                                        as->tp = ret_tp;        // wrong if = overloaded, but then X(X&) ought to have been used 
        !          35059:                                        Pstmt cs = new estmt(SM,where,as,0);
        !          35060:                                        cs = new pair(where,cs,dl);
        !          35061:                                        base = PAIR;
        !          35062:                                        s = cs;
        !          35063:                                        s2 = new estmt(RETURN,where,r,0);
        !          35064:                                //      s2->ret_tp = ret_tp;
        !          35065:                                }
        !          35066:                                else { // { _dtor()s;  return x; }
        !          35067:                                        base = PAIR;
        !          35068:                                        s = dl;
        !          35069:                                        s2 = new estmt(RETURN,where,e,0);
        !          35070:                                }
        !          35071:                                  s2->ret_tp = ret_tp;
        !          35072:                        }
        !          35073:                }
        !          35074: 
        !          35075: //             if (sx->memtbl) {
        !          35076: //                     int i;
        !          35077: //                     for (Pname n=sx->memtbl->get_mem(i=1); n; n=sx->memtbl->get_mem(++i)) {
        !          35078: //                             Pname cn = n->tp->is_cl_obj();
        !          35079: //                             if (cn && Pclass(cn->tp)->has_dtor()) {
        !          35080: //                                     ccheck(ex);
        !          35081: //                                     break;
        !          35082: //                             }
        !          35083: //                     }
        !          35084: //             }
        !          35085:                break;
        !          35086:        }
        !          35087: 
        !          35088:        case WHILE:
        !          35089:        case DO:
        !          35090:                e->simpl();
        !          35091:                {       Pstmt obl = break_del_list;
        !          35092:                        Pstmt ocl = continue_del_list;
        !          35093:                        break_del_list = 0;
        !          35094:                        continue_del_list = 0;
        !          35095:                        s->simpl();
        !          35096:                        break_del_list = obl;
        !          35097:                        continue_del_list = ocl;
        !          35098:                }
        !          35099:                break;
        !          35100: 
        !          35101:        case SWITCH:
        !          35102:                e->simpl();
        !          35103:                {       Pstmt obl = break_del_list;
        !          35104:                        break_del_list = 0;
        !          35105:                        s->simpl();
        !          35106:                        break_del_list = obl;
        !          35107:                }
        !          35108:                switch (s->base) {
        !          35109:                case DEFAULT:
        !          35110:                case LABEL:
        !          35111:                case CASE:
        !          35112:                        break;
        !          35113:                case BLOCK:
        !          35114:                        if (s->s)
        !          35115:                        switch (s->s->base) {
        !          35116:                        case BREAK:     // to cope with #define Case break; case
        !          35117:                        case CASE:
        !          35118:                        case LABEL:
        !          35119:                        case DEFAULT:
        !          35120:                                break;
        !          35121:                        default:
        !          35122:                                goto df;
        !          35123:                        }
        !          35124:                        break;
        !          35125:                default:
        !          35126:                df:
        !          35127:                        error(&s->where,"S orIdE not reached: (case label missing?)");
        !          35128:                }
        !          35129:                break;
        !          35130: 
        !          35131:        case CASE:
        !          35132:                e->simpl();
        !          35133:                s->simpl();
        !          35134:                break;
        !          35135: 
        !          35136:        case LABEL:
        !          35137:                if (del_list) error('s',"label in blockW destructors");
        !          35138:                s->simpl();
        !          35139:                break;
        !          35140: 
        !          35141:        case GOTO:
        !          35142:                /*      If the goto is going to a different (effective) scope,
        !          35143:                        then it is necessary to activate all relevant destructors
        !          35144:                        on the way out of nested scopes, and issue errors if there
        !          35145:                        are any constructors on the way into the target.
        !          35146: 
        !          35147:                        Only bother if the goto and label have different effective
        !          35148:                        scopes. (If mem table of goto == mem table of label, then
        !          35149:                        they're in the same scope for all practical purposes.
        !          35150:                */
        !          35151:                {
        !          35152:                Pname n = scope->look( d->string, LABEL );
        !          35153:                if (n == 0) error('i',&where,"label%n missing",d);
        !          35154:                if(n->n_realscope!=scope && n->n_assigned_to) {
        !          35155: 
        !          35156:                        /*      Find the root of the smallest subtree containing
        !          35157:                                the path of the goto.  This algorithm is quadratic
        !          35158:                                only if the goto is to an inner or unrelated scope.
        !          35159:                        */
        !          35160: 
        !          35161:                        Ptable r = 0;
        !          35162: 
        !          35163:                        for(Ptable q=n->n_realscope; q!=gtbl; q=q->next) {
        !          35164:                                for( Ptable p = scope; p != gtbl; p = p->next ) {
        !          35165:                                        if( p==q ) {
        !          35166:                                                r = p;  // found root of subtree!
        !          35167:                                                goto xyzzy;
        !          35168:                                        }
        !          35169:                                }
        !          35170:                        }
        !          35171: 
        !          35172: xyzzy:                 if( r==0 ) error( 'i',&where,"finding root of subtree" );
        !          35173: 
        !          35174:                        /* At this point, r = root of subtree, n->n_realscope
        !          35175:                         * = mem table of label, and scope = mem table of goto. */
        !          35176: 
        !          35177:                        /* Climb the tree from the label mem table to the table
        !          35178:                         * preceding the root of the subtree, looking for
        !          35179:                         * initializers and ctors.  If the mem table "belongs"
        !          35180:                         * to an unsimplified block(s), the n_initializer field
        !          35181:                         * indicates presence of initializer, otherwise initializer
        !          35182:                         * information is recorded in the init_stat field of
        !          35183:                         * mem table. */
        !          35184: 
        !          35185:                        for( Ptable p=n->n_realscope; p!=r; p=p->next )
        !          35186:                                if( p->init_stat == 2 ) {
        !          35187:                                        error(&where,"goto%n pastDWIr",d);
        !          35188:                                        goto plugh; /* avoid multiple error msgs */
        !          35189:                                }
        !          35190:                                else if( p->init_stat == 0 ) {
        !          35191:                                        int i;
        !          35192:                                        for(Pname nn=p->get_mem(i=1);nn;nn=p->get_mem(++i))
        !          35193:                                                if(nn->n_initializer||nn->n_evaluated){
        !          35194:                                                        error(&nn->where,"goto%n pastId%n",d,nn);
        !          35195:                                                        goto plugh;
        !          35196:                                                }
        !          35197:                                }
        !          35198: plugh:
        !          35199: 
        !          35200:                        /* Proceed in a similar manner from the point of the goto,
        !          35201:                         * generating the code to activate dtors before the goto. */
        !          35202:                        /* There is a bug in this code.  If there are class objects
        !          35203:                         * of the same name and type in (of course) different mem
        !          35204:                         * tables on the path to the root of the subtree from the
        !          35205:                         * goto, then the innermost object's dtor will be activated
        !          35206:                         * more than once. */
        !          35207: 
        !          35208:                        {
        !          35209:                        Pstmt dd = 0, ddt = 0;
        !          35210: 
        !          35211:                        for( Ptable p=scope; p!=r; p=p->next ) {
        !          35212:                                int i;
        !          35213:                                for(Pname n=p->get_mem(i=1);n;n=p->get_mem(++i)) {
        !          35214:                Pname cln;
        !          35215:                if (n->tp == 0) continue; /* label */
        !          35216: 
        !          35217:                if ( cln=n->tp->is_cl_obj() ) {
        !          35218:                        Pclass cl = (Pclass)cln->tp;
        !          35219:                        Pname d = cl->has_dtor();
        !          35220: 
        !          35221:                        if (d) {        /* n->cl::~cl(0); */
        !          35222:                                Pexpr dl = call_dtor(n,d,0,DOT,one);
        !          35223:                                Pstmt dls = new estmt(SM,n->where,dl,0);
        !          35224:                                if (dd)
        !          35225:                                        ddt->s_list = dls;
        !          35226:                                else
        !          35227:                                        dd = dls;
        !          35228:                                ddt = dls;
        !          35229:                        }
        !          35230: 
        !          35231:                }
        !          35232:                else if (cl_obj_vec) {
        !          35233:                        Pclass cl = (Pclass)cl_obj_vec->tp;
        !          35234:                //      Pname c = cl->has_ictor();
        !          35235:                        Pname d = cl->has_dtor();
        !          35236: 
        !          35237:                        if (d) {        //  __vec_delete(vec,noe,sz,dtor,0);
        !          35238:                                Pfct f = Pfct(d->tp);
        !          35239:                                int i = 0;
        !          35240:                                for (Pname nn = f->f_args->n_list; 
        !          35241:                                        nn && nn->n_list; nn=nn->n_list) i++;
        !          35242:                                Pexpr a = cdvec(vec_del_fct,n,cl,d,0,new ival(i));
        !          35243:                                Pstmt dls = new estmt(SM,n->where,a,0);
        !          35244:                                if (dd)
        !          35245:                                        ddt->s_list = dls;
        !          35246:                                else
        !          35247:                                        dd = dls;
        !          35248:                                ddt = dls;
        !          35249:                        }
        !          35250:                }
        !          35251:                                } /* end mem table scan */
        !          35252:                        } /* end dtor loop */
        !          35253: 
        !          35254:                        /* "activate" the list of dtors obtained. */
        !          35255: 
        !          35256:                        if( dd ) {
        !          35257:                                dd->simpl();
        !          35258:                                Pstmt bs = new stmt( base, where, 0 );
        !          35259:                                *bs = *this;
        !          35260:                                base = PAIR;
        !          35261:                                s = dd;
        !          35262:                                s2 = bs;
        !          35263:                        }
        !          35264:                        }
        !          35265:                } /* end special case for non-local goto */
        !          35266:                }
        !          35267:                break;
        !          35268: 
        !          35269:        case IF:
        !          35270:                e->simpl();
        !          35271:                s->simpl();
        !          35272:                if (else_stmt) else_stmt->simpl();
        !          35273:                break;
        !          35274: 
        !          35275:        case FOR:       // "for (s;e;e2) s2; => "s; for(;e,e2) s2"
        !          35276:                if (for_init) for_init->simpl();
        !          35277:                if (e) {
        !          35278:                        curr_expr = e;
        !          35279:                        e->simpl();
        !          35280:                }
        !          35281:                if (e2) {
        !          35282:                        curr_expr = e2;
        !          35283:                        e2->simpl();
        !          35284:                        if (e2->base==ICALL)
        !          35285:                                if (e2->e1 == 0) error('s',"cannot expand inline void%n called in forE", e2->il->fct_name);
        !          35286:                }
        !          35287:                {       Pstmt obl = break_del_list;
        !          35288:                        Pstmt ocl = continue_del_list;
        !          35289:                        break_del_list = 0;
        !          35290:                        continue_del_list = 0;
        !          35291:                        s->simpl();
        !          35292:                        break_del_list = obl;
        !          35293:                        continue_del_list = ocl;
        !          35294:                }
        !          35295:                break;
        !          35296: 
        !          35297:        case BLOCK:
        !          35298:                Pblock(this)->simpl();
        !          35299:                break;
        !          35300: 
        !          35301:        case PAIR:
        !          35302:                break;
        !          35303:        }
        !          35304: 
        !          35305:        /*if (s) s->simpl();*/
        !          35306: //error('d',"base %k memtbl %d",base,memtbl);
        !          35307:        if (base!=BLOCK && memtbl) {
        !          35308:                Pstmt t1 = (s_list) ? s_list->simpl() : 0;
        !          35309:                Pstmt tpx = t1 ? t1 : this;
        !          35310: 
        !          35311:                Pstmt ss = 0;
        !          35312:                Pname cln;      // used for warnings
        !          35313:                int i;
        !          35314:                Pname tn = memtbl->get_mem(i=1);
        !          35315:                for (; tn; tn=memtbl->get_mem(++i)) {
        !          35316:                        if (cln = tn->tp->is_cl_obj()) {
        !          35317:                                Pname d = Pclass(cln->tp)->has_dtor();
        !          35318:                                if (d) {        /* n->cl::~cl(0); */
        !          35319:                                        Pexpr dl = call_dtor(tn,d,0,DOT,one);
        !          35320:                                        Pstmt dls = new estmt(SM,tn->where,dl,0);
        !          35321:                                        dls->s_list = ss;
        !          35322:                                        ss = dls;
        !          35323:                                }
        !          35324:                        }
        !          35325:                }
        !          35326: 
        !          35327:                if (ss) {
        !          35328:                        Pstmt t2 = ss->simpl();
        !          35329: 
        !          35330:                        switch (base) {
        !          35331:                        case IF:
        !          35332:                        case WHILE:
        !          35333:                        case DO:
        !          35334:                        case SWITCH:
        !          35335:                                temp_in_cond(e,ss,memtbl);
        !          35336:                                break;
        !          35337: 
        !          35338:                        case PAIR:      // can hide a return
        !          35339:                        {       Pstmt ts = s2;
        !          35340:                                while (ts->base==PAIR) ts = ts->s2;
        !          35341:                                if (ts->base == RETURN) {       // sordid
        !          35342:                                        this = ts;
        !          35343:                                        goto retu;
        !          35344:                                }
        !          35345:                                goto def;
        !          35346:                        }
        !          35347:                        case RETURN:
        !          35348:                        retu:
        !          35349:                        {       
        !          35350:                                if (e == 0) {
        !          35351:                                        // return; dtors; => dtors; return;
        !          35352:                                        Pstmt rs = new estmt(RETURN,where,0,0);
        !          35353:                                        //rs->empty = empty;    // BSD fudge
        !          35354:                                        rs->ret_tp = ret_tp;
        !          35355:                                        base = PAIR;
        !          35356:                                        s = ss;
        !          35357:                                        s2 = rs;
        !          35358:                                        //Cstmt = ostmt;
        !          35359:                                        return t1 ? t1 : rs;
        !          35360:                                }
        !          35361: 
        !          35362:                                Pname cln = e->tp->is_cl_obj();
        !          35363:                                if (cln==0
        !          35364:                                || Pclass(cln->tp)->has_oper(ASSIGN)==0) {
        !          35365:                                        //  ... return e; dtors; =>
        !          35366:                                        //  ... X r; ... r = e; dtors; return r;
        !          35367:                                        Pname rv = new name("_rresult"); // NOT "_result"
        !          35368:                                        rv->tp = ret_tp /* e->tp */;
        !          35369:                                        if (memtbl == 0) memtbl = new table(4,0,0);
        !          35370:                                        Pname n = rv->dcl(memtbl,ARG);
        !          35371:                                        n->where = no_where;
        !          35372:                                        n->n_scope = FCT;
        !          35373:                                        n->n_assigned_to = 1;
        !          35374:                                        delete rv;
        !          35375:                                        Pstmt rs = new estmt(RETURN,where,n,0);
        !          35376:                                        rs->ret_tp = ret_tp;
        !          35377:                                        base = SM;
        !          35378:                                        e = new expr(ASSIGN,n,e);
        !          35379:                                        e->tp = n->tp;
        !          35380:                                        Pstmt ps = new pair(where,ss,rs);
        !          35381:                                        ps->s_list = s_list;
        !          35382:                                        s_list = ps;
        !          35383:                                        //Cstmt = ostmt;
        !          35384:                                        return t1 ? t1 : rs;
        !          35385:                                }
        !          35386:                        }
        !          35387:                                
        !          35388:                        case FOR:       // don't know which expression the temp comes from
        !          35389:                                error('s',&where,"E in %kS needs temporary ofC%nW destructor",base,cln);
        !          35390:                                break;
        !          35391: 
        !          35392:                        case SM:        // place dtors after all "converted" DCLs
        !          35393:                                if (t1) {
        !          35394: //                                     ccheck(e);
        !          35395:                                        for (Pstmt ttt, tt=this;
        !          35396:                                                (ttt=tt->s_list) && ttt->base==SM;
        !          35397:                                                tt = ttt) ;
        !          35398:                                        t2->s_list = ttt;
        !          35399:                                        tt->s_list = ss;
        !          35400:                                        //Cstmt = ostmt;
        !          35401:                                        return t1!=tt ? t1 : t2;
        !          35402:                                }
        !          35403:                        default:
        !          35404:                        def:
        !          35405: //                             if (e) ccheck(e);
        !          35406:                                if (t1) {       // t1 == tail of statment list
        !          35407:                                        t2->s_list = s_list;
        !          35408:                                        s_list = ss;
        !          35409:                                        //Cstmt = ostmt;
        !          35410:                                        return t1;
        !          35411:                                }
        !          35412:                                s_list = ss;
        !          35413:                                //Cstmt = ostmt;
        !          35414:                                return t2;
        !          35415:                        }
        !          35416:                }
        !          35417:                //Cstmt = ostmt;
        !          35418:                return (t1) ? t1 : this;
        !          35419:        }
        !          35420: 
        !          35421:        //Cstmt = ostmt;
        !          35422:        return (s_list) ? s_list->simpl() : this;
        !          35423: }
        !          35424: 
        !          35425: Pstmt stmt::copy()
        !          35426: // now handles dtors in the expression of an IF stmt
        !          35427: // not general!
        !          35428: {
        !          35429:        Pstmt ns = new stmt(0,curloc,0);
        !          35430: 
        !          35431:        *ns = *this;
        !          35432:        if (s) ns->s = s->copy();
        !          35433:        if (s_list) ns->s_list = s_list->copy();
        !          35434: 
        !          35435:        switch (base) {
        !          35436:        case PAIR:
        !          35437:                ns->s2 = s2->copy();
        !          35438:                break;
        !          35439:        }
        !          35440: 
        !          35441:        return ns;
        !          35442: }
        !          35443: 
        !          35444: Pname overFound = 0;
        !          35445: 
        !          35446: static Pexpr 
        !          35447: mk_new_with_args( Pexpr pe, Ptype tt, Pclass cl, Pexpr vec = 0 ) 
        !          35448: { // allocate using operator new(sizeof(cl),args1)
        !          35449:        Pexpr p;
        !          35450:        Pexpr args = pe->e2;
        !          35451: 
        !          35452:        // Pexpr ce = new texpr(SIZEOF,tt,0);
        !          35453:        Pexpr ce;
        !          35454:        if (vec) 
        !          35455:                ce = vec;
        !          35456:        else ce = new texpr(SIZEOF,tt,0);
        !          35457: 
        !          35458:        (void) tt->tsizeof();
        !          35459:        ce->tp = size_t_type;
        !          35460:        args = new expr(ELIST,ce,args);
        !          35461:        char* s = oper_name(NEW);
        !          35462:        Pname n = new name(s);
        !          35463:        if (pe->base == GNEW)   // ::new
        !          35464:                p = gtbl->look(s,0);
        !          35465:        else 
        !          35466:                p = find_name(n,cl,scope,CALL,curr_fct);
        !          35467:        p = new call(p,args);
        !          35468:        overFound=0; // set in call_fct
        !          35469:        (void) p->call_fct(cl->memtbl);
        !          35470:        if (overFound && overFound->n_scope != EXTERN) 
        !          35471:                check_visibility(overFound,0,cl,cc->ftbl,cc->nof);
        !          35472:        overFound=0;
        !          35473:        return p;
        !          35474: }
        !          35475: 
        !          35476: void expr::simpl_new()
        !          35477: /*
        !          35478:        change NEW or GNEW node to CALL node
        !          35479: */
        !          35480: {
        !          35481:        Pname cln;
        !          35482:        Pname ctor;
        !          35483:        int sz = 1;
        !          35484: //     int esz;
        !          35485:        Pexpr var_expr = 0;
        !          35486:        Pexpr const_expr = 0;
        !          35487:        Ptype tt = tp2;
        !          35488:        Pexpr arg;
        !          35489:        Pexpr szof;
        !          35490:        Pname nf;
        !          35491:        Pexpr init = e1;
        !          35492: 
        !          35493:        if (init && init->base) init = 0;       // only non-ctor init
        !          35494: // error('d',"simpl_new %k e1 %k e2 %k init %k",base, e1?e1->base:0,e2?e2->base:0,init?init->base:0);
        !          35495: 
        !          35496:        if ((cln=tt->is_cl_obj()) && init == 0) {
        !          35497:                Pclass cl = Pclass(cln->tp);
        !          35498:                Pexpr p;
        !          35499:                ctor=cl->has_ctor();
        !          35500: // error('d',"cl %t ctor %n",cl, ctor);
        !          35501:                if (e2          // placement
        !          35502:                    || ctor==0  // no constructor
        !          35503:                    || ctor->n_table!=cl->memtbl // inherited constructor??? 
        !          35504:                    || (base==GNEW && cl->has_oper(NEW)) )
        !          35505:                        p = mk_new_with_args( this, tt, cl ); // new(sizeof(cl),args1)
        !          35506:                else {
        !          35507:                        p = zero;       // 0->ctor(args)
        !          35508:                        // check visibility anyway...
        !          35509:                        (void)mk_new_with_args(this,tt,cl);
        !          35510:                }
        !          35511: 
        !          35512:                if (ctor) {
        !          35513:                        Pexpr c = e1;   // ctor call generated in expr::typ
        !          35514:                        Ptype ttt = tp;
        !          35515:                        c->e1->e1 = p;  // p->ctor
        !          35516:                        c->simpl();
        !          35517:                        *this = *c;
        !          35518:                        tp = ttt;
        !          35519:                        delete c;
        !          35520:                }
        !          35521:                else {          // (tp)new(args)
        !          35522:                        base = CAST;
        !          35523:                        tp2 = tp;
        !          35524:                        e1 = p;
        !          35525:                        e2 = 0;
        !          35526:                        simpl();
        !          35527:                }
        !          35528:                return;
        !          35529:        } else if ( cln ) {
        !          35530:                Pclass cl = Pclass(cln->tp);
        !          35531:                // check visibility anyway...
        !          35532:                (void)mk_new_with_args(this,tt,cl);
        !          35533:        }
        !          35534:        
        !          35535:        Pclass covn = 0;
        !          35536:        if (cl_obj_vec) {
        !          35537:                covn = Pclass(cl_obj_vec->tp);
        !          35538:                ctor = covn->has_ictor();
        !          35539:                if (ctor == 0) {
        !          35540:                        if (covn->has_ctor()) error("new %s[], no defaultK",covn->string);
        !          35541:                        cl_obj_vec = 0;
        !          35542:                }
        !          35543:        }
        !          35544: 
        !          35545: xxx:
        !          35546: //error('d',"xxx %t",tt);
        !          35547:        switch (tt->base) {
        !          35548:        case TYPE:
        !          35549:                tt = Pbase(tt)->b_name->tp;
        !          35550:                goto xxx;
        !          35551: 
        !          35552:        default:
        !          35553:                (void) tt->tsizeof();
        !          35554:                szof = new texpr(SIZEOF,tt,0);
        !          35555:                szof->tp = uint_type;
        !          35556:                break;
        !          35557: 
        !          35558:        case VEC:
        !          35559:        {       Pvec v = Pvec(tt);
        !          35560: //error('d',"v %d %d",v->size,v->dim);
        !          35561:                if (v->size)
        !          35562:                        sz *= v->size;
        !          35563:                else if (v->dim) 
        !          35564:                        var_expr = v->dim;
        !          35565:                else
        !          35566:                        sz = 0;
        !          35567:                tt = v->typ;
        !          35568:                goto xxx;
        !          35569:        }
        !          35570:        }
        !          35571: 
        !          35572:        if (cl_obj_vec) { // _vec_new(0,no_of_elements,element_size,ctor)
        !          35573:                const_expr = new ival(sz);
        !          35574:                Pexpr noe = (var_expr) ? (sz!=1) ? new expr(MUL,const_expr,var_expr) : var_expr : const_expr;
        !          35575:                const_expr = szof;
        !          35576:                const_expr->tp = uint_type;
        !          35577:                base = CALL;
        !          35578:                arg = new expr(ELIST,ctor,0);
        !          35579:                /*ctor->take_addr();*/
        !          35580:                ctor->lval(ADDROF);
        !          35581:                Pexpr sub=0;
        !          35582:                if (e2 && e2->e1 &&
        !          35583:                        e2->e1->tp &&
        !          35584:                        e2->e1->tp->base != PTR ) 
        !          35585:                { // new(size_t, args)
        !          35586:                        Pexpr vec_sz = new expr(MUL, noe, const_expr);
        !          35587:                        sub = mk_new_with_args( this, tt, covn, vec_sz );
        !          35588:                }
        !          35589:                arg = new expr(ELIST,const_expr,arg);
        !          35590:                arg = new expr(ELIST,noe,arg);
        !          35591:                // arg = new expr(ELIST,e2?e2:zero,arg);        // may be preallocated
        !          35592:                arg = new expr(ELIST,e2?(sub?sub:e2):zero,arg); // may be preallocated
        !          35593:                base = CAST;
        !          35594:                tp2 = tp;
        !          35595:                e1 = new expr(G_CALL,vec_new_fct,arg);
        !          35596:                e1->fct_name = vec_new_fct;
        !          35597:                e1->tp = Pfct(vec_new_fct->tp)->returns;
        !          35598:                simpl();
        !          35599:                return;
        !          35600:        }
        !          35601: 
        !          35602:        /* call _new(element_size*no_of_elements) */
        !          35603: //error('d',"sz %d var %d",sz,var_expr);
        !          35604:        if (sz == 1)
        !          35605:                arg = (var_expr) ? new expr(MUL,szof,var_expr) : szof;
        !          35606:        else {
        !          35607:                const_expr = new ival(sz);
        !          35608:                const_expr->tp = uint_type;
        !          35609:                const_expr = new expr(MUL,const_expr,szof);
        !          35610:                const_expr->tp = uint_type;
        !          35611:                arg = (var_expr) ? new expr(MUL,const_expr,var_expr) : const_expr;
        !          35612:        }
        !          35613: 
        !          35614:        arg->tp = uint_type;
        !          35615:        base = CAST;
        !          35616:        tp2 = tp;
        !          35617:        arg = new expr(ELIST,arg,e2);
        !          35618:        nf = gtbl->look(oper_name(NEW),0);      // always global,
        !          35619:                                                // all class object handled above
        !          35620:        e1 = new expr(G_CALL,nf,arg);
        !          35621:        (void) e1->call_fct(gtbl);
        !          35622:        simpl();
        !          35623: 
        !          35624:        if (init) {     // alloc(sz) => (p=alloc(sz),*p=init,p);
        !          35625:                Pexpr p = init->e1;
        !          35626:                Pexpr ee = new expr(0,0,0);
        !          35627:                *ee = *this;    
        !          35628:                ee = new expr(ASSIGN,p,ee);     // ee: p = alloc(sz);
        !          35629:                init->base = ASSIGN;
        !          35630:                init->e1 = p->contents();       // init: *p = init_val
        !          35631:                ee = new expr(CM,ee,init);
        !          35632:                ee->simpl(); 
        !          35633:                base = CM;
        !          35634:                e1 = ee;
        !          35635:                e2 = p;
        !          35636:        }
        !          35637: }
        !          35638: 
        !          35639: void expr::simpl_delete()
        !          35640: /*
        !          35641:        delete p => _delete(p);
        !          35642:                    or  cl::~cl(p,1);
        !          35643:        delete[s]p => _delete(p);
        !          35644:                        or vec_del_fct(p,vec_sz,elem_sz,~cl,1);
        !          35645: */              
        !          35646: {
        !          35647:        for (Ptype tt = e1->tp; tt->base==TYPE; tt=Pbase(tt)->b_name->tp);
        !          35648:        tt = Pptr(tt)->typ;
        !          35649: //error('d',"simpl_delete() %t",e1->tp);
        !          35650:        Pname cln = tt->is_cl_obj();
        !          35651:        Pname n;
        !          35652:        Pclass cl;
        !          35653: 
        !          35654:        if (cln) {
        !          35655:                cl = Pclass(cln->tp);
        !          35656:                if ((cl->defined&DEFINED) == 0) error('w',"delete%t (%t not defined)",cl,cl);
        !          35657:        }
        !          35658:        else
        !          35659:                cl = 0;
        !          35660: 
        !          35661:        if (cl && (n=cl->has_dtor())) { // ~cl() might be virtual
        !          35662:                //xxx check for private/protected op delete
        !          35663:                {
        !          35664:                        Pexpr ee = new expr(ELIST,e1,0);
        !          35665:                        char* s = oper_name(DELETE);
        !          35666:                        Pname n;
        !          35667: //error('d',"%s( %k )",s,e1->base);
        !          35668:                        if (base!=GDELETE) {
        !          35669:                                n = new name(s);
        !          35670:                                n = (Pname)find_name(n,cl,scope,CALL,curr_fct);
        !          35671: //error('d',"found%n  %t",n,n->tp);
        !          35672:                                if (n->tp->base==OVERLOAD
        !          35673:                                ||  Pfct(n->tp)->nargs==2) {
        !          35674:                                        Pexpr ss = new texpr(SIZEOF,cl,0);
        !          35675:                                        ss->tp = size_t_type;
        !          35676:                                        ee->e2 = new expr(ELIST,ss,0);
        !          35677:                                }
        !          35678:                        }
        !          35679:                        else
        !          35680:                                n = gtbl->look(s,0);
        !          35681: //error('d',"found%n  %t",n,n->tp);
        !          35682:                        ee = new call(n,ee);
        !          35683:                        ee->base = G_CALL;
        !          35684: //error('d',"delete..."); display_expr(ee);
        !          35685: // following commented out to avoid typ::checking problems
        !          35686:                        //overFound=0; // set in call_fct
        !          35687:                        //(void) ee->call_fct(cl->memtbl);
        !          35688:                        //if (overFound && overFound->n_scope != EXTERN) 
        !          35689:                                //check_visibility(overFound,0,cl,cc->ftbl,cc->nof);
        !          35690:                        //overFound=0;
        !          35691:                }
        !          35692: 
        !          35693: //if ( base!=GDELETE ) (void) cl->has_oper(DELETE);
        !          35694: 
        !          35695:                if(base==GDELETE && e2==0 || Pfct(n->tp)->f_virtual) {  // may need temp
        !          35696:                        nin=1;
        !          35697:                        int needtemp = e1->not_simple();
        !          35698:                        nin=0;
        !          35699:                        if(needtemp) {
        !          35700:                                // convert:     delete [e2] e1
        !          35701:                                // to:  (T=e1), delete [e2] T
        !          35702:                                // where T is a new temporary.
        !          35703:                                Pname tnx = new name(make_name('K'));
        !          35704:                                tnx->tp = e1->tp;
        !          35705:                                Pname tn = tnx->dcl(scope,FCT);
        !          35706:                                delete tnx;
        !          35707:                                tn->assign();
        !          35708:                                e1 = new expr(ASSIGN,tn,e1);
        !          35709:                                e2 = new expr(base,tn,e2);
        !          35710:                                base=CM;
        !          35711: 
        !          35712:                                simpl();
        !          35713:                                return;
        !          35714:                        }
        !          35715:                }
        !          35716:                Pexpr r = e1;
        !          35717:        
        !          35718:                // handle delete p, where p has a private destructor
        !          35719:                if (n->n_scope != PUBLIC) check_visibility(n,0,cl,cc->ftbl,cc->nof);
        !          35720: //error('d',"e2 %d %k",e2,base);
        !          35721:                if (e2 == 0) {          // e1->cl::~cl(1)
        !          35722:                        Pexpr ee = call_dtor(r,n,base==GDELETE?0:one,REF,one);
        !          35723:                        if (Pfct(n->tp)->f_virtual) {
        !          35724:                                if (ansi_opt) { // q?void:int would be an error
        !          35725:                                        ee = new expr(G_CM,ee,zero);
        !          35726:                                        ee->tp = zero_type;
        !          35727:                                }
        !          35728:                                ee = new expr(QUEST,ee,zero);
        !          35729:                                ee->tp = ee->e1->tp;
        !          35730:                                ee->cond = r;
        !          35731:                        }
        !          35732:                        if (base == GDELETE) {
        !          35733:                                char* s = oper_name(DELETE);
        !          35734:                                Pexpr p = gtbl->look(s,0);
        !          35735:                                e2 = new call(p,new expr(ELIST,e1,0));
        !          35736:                                base = CM;
        !          35737:                                e1 = ee;
        !          35738:                        }
        !          35739:                        else {
        !          35740:                                *this = *ee;
        !          35741:                                delete ee;
        !          35742:                        }
        !          35743:                        simpl();
        !          35744:                        return;
        !          35745:                }
        !          35746:                else {          // del_cl_vec(e1,e2,elem_size,~cl,1);
        !          35747:                        Pexpr sz = new texpr(SIZEOF,tt,0);
        !          35748:                        (void)tt->tsizeof();
        !          35749:                        Pfct f = Pfct(n->tp);
        !          35750:                        int i = 0;
        !          35751:                        Pname nn = f->f_args->n_list;
        !          35752:                        for (; nn && nn->n_list; nn=nn->n_list) i++;
        !          35753: //error('d',"n %n i %d",n,i);
        !          35754:                        Pexpr arg = new ival(i);
        !          35755:                        sz->tp = uint_type;
        !          35756:                //      Pexpr arg = one;
        !          35757:                        arg = new expr(ELIST,one,arg);
        !          35758:                        if (Pfct(n->tp)->f_virtual) {
        !          35759:                                Pexpr a = new ref(REF,e1,n);
        !          35760:                                a = a->address();
        !          35761:                                a = new mdot( "f", a );
        !          35762:                                a->i1 = 9;
        !          35763:                                arg = new expr(ELIST,a,arg);
        !          35764:                        }
        !          35765:                        else {
        !          35766:                                arg = new expr(ELIST,n,arg);
        !          35767:                                n->lval(ADDROF);        // n->take_addr();
        !          35768:                        }
        !          35769: 
        !          35770:                        arg = new expr(ELIST,sz,arg);
        !          35771:                        if (e2->base==DUMMY) {
        !          35772:                                e2 = new ival(-1);      // handle `delete[]p'
        !          35773:                        }
        !          35774: 
        !          35775:                        arg = new expr(ELIST,e2,arg);
        !          35776:                        arg = new expr(ELIST,e1,arg);
        !          35777:                        Pexpr ee = new expr(G_CALL,vec_del_fct,arg);
        !          35778:                        ee->fct_name = vec_del_fct;
        !          35779:                        ee->tp = tp;
        !          35780:        //              if (ansi_opt) { // q?void:int would be an error
        !          35781:        //                      ee = new expr(G_CM,ee,zero);
        !          35782:        //                      ee->tp = zero_type;
        !          35783:        //              }
        !          35784:        //              ee = new expr(QUEST,ee,zero);
        !          35785:        //              ee->tp = tp;
        !          35786:        //              ee->cond = r;
        !          35787:                        *this = *ee;
        !          35788:                        simpl();
        !          35789:                        return;
        !          35790:                }
        !          35791:        }
        !          35792:        else if (cl_obj_vec) {
        !          35793:                error("delete array of arrays");
        !          35794:        }
        !          35795:        else {                                  // _delete(e1)
        !          35796:                Pexpr ee = new expr(ELIST,e1,0);
        !          35797:                char* s = oper_name(DELETE);
        !          35798:                if (cl && base!=GDELETE) {
        !          35799:                        Pname n = new name(s);
        !          35800:                        e1 = find_name(n,cl,scope,CALL,curr_fct);
        !          35801:                        if (e1->tp->base==OVERLOAD || Pfct(e1->tp)->nargs==2) {
        !          35802:                                Pexpr ss = new texpr(SIZEOF,cl,0);
        !          35803:                                ss->tp = size_t_type;
        !          35804:                                ee->e2 = new expr(ELIST,ss,0);
        !          35805:                        }
        !          35806:                }
        !          35807:                else
        !          35808:                        e1 = gtbl->look(s,0);
        !          35809:                base = G_CALL;
        !          35810:                e2 = ee;
        !          35811:                overFound=0; // set in call_fct
        !          35812:                (void) call_fct(scope);
        !          35813:                if (overFound && overFound->n_scope != EXTERN) 
        !          35814:                        check_visibility(overFound,0,cl,cc->ftbl,cc->nof);
        !          35815:                overFound=0;
        !          35816:        }
        !          35817: 
        !          35818:        Pcall(this)->simpl();
        !          35819: }
        !          35820: 0707071010112045371004440001630000160000010207600466055410400000700000013461size.c/*ident     "@(#)ctrans:src/size.c  1.3" */
        !          35821: /*********************************************************************
        !          35822: 
        !          35823:        C++ source for cfront, the C++ compiler front-end
        !          35824:        written in the computer science research center of Bell Labs
        !          35825: 
        !          35826:        Copyright (c) 1984 AT&T, Inc. All rigths Reserved
        !          35827:        THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T, INC.
        !          35828: 
        !          35829: size.c:
        !          35830: 
        !          35831:        initialize alignment and sizeof "constants"
        !          35832: 
        !          35833: **********************************************************************/
        !          35834: 
        !          35835: #include "cfront.h"
        !          35836: #include "size.h"
        !          35837: 
        !          35838: int BI_IN_WORD = DBI_IN_WORD;
        !          35839: int BI_IN_BYTE = DBI_IN_BYTE;
        !          35840: int SZ_CHAR = DSZ_CHAR;
        !          35841: int AL_CHAR = DAL_CHAR;
        !          35842: int SZ_SHORT = DSZ_SHORT;
        !          35843: int AL_SHORT = DAL_SHORT;
        !          35844: int SZ_INT = DSZ_INT;
        !          35845: int AL_INT = DAL_INT;
        !          35846: int SZ_LONG = DSZ_LONG;
        !          35847: int AL_LONG = DAL_LONG;
        !          35848: int SZ_FLOAT = DSZ_FLOAT;
        !          35849: int AL_FLOAT = DAL_FLOAT;
        !          35850: int SZ_DOUBLE = DSZ_DOUBLE;
        !          35851: int AL_DOUBLE = DAL_DOUBLE;
        !          35852: int SZ_LDOUBLE = DSZ_LDOUBLE;
        !          35853: int AL_LDOUBLE = DAL_LDOUBLE;
        !          35854: int SZ_STRUCT = DSZ_STRUCT;
        !          35855: int AL_STRUCT = DAL_STRUCT;
        !          35856: //int SZ_FRAME = DSZ_FRAME;
        !          35857: //int AL_FRAME = DAL_FRAME;
        !          35858: int SZ_WORD = DSZ_WORD;
        !          35859: int SZ_WPTR = DSZ_WPTR;
        !          35860: int AL_WPTR = DAL_WPTR;
        !          35861: int SZ_BPTR = DSZ_BPTR;
        !          35862: int AL_BPTR = DAL_BPTR;
        !          35863: //int SZ_TOP = DSZ_TOP;
        !          35864: //int SZ_BOTTOM = DSZ_BOTTOM;
        !          35865: char* LARGEST_INT = DLARGEST_INT;
        !          35866: int F_SENSITIVE = DF_SENSITIVE;
        !          35867: int F_OPTIMIZED =  DF_OPTIMIZED;
        !          35868: 
        !          35869: int arg1 = 0;
        !          35870: 
        !          35871: int get_line(FILE* fp)
        !          35872: {
        !          35873:        char s[32];
        !          35874:        char s2[32];
        !          35875: 
        !          35876:        if (fscanf(fp,"%s %s",s2,s) == EOF) return 0;
        !          35877: 
        !          35878:        if (strcmp("DLARGEST_INT",s) == 0) { 
        !          35879:                if (fscanf(fp," %s",s2)==EOF) return 0;
        !          35880: //// get rid of quotes
        !          35881:                for(int i=0;i<=strlen(s2)+1;i++)
        !          35882:                        if (s2[i]== '"') {
        !          35883:                                for (int j=i;j<=strlen(s2)+1;j++)
        !          35884:                                        s2[j]=s2[j+1];
        !          35885:                        }
        !          35886:                }
        !          35887:        else 
        !          35888:                if (fscanf(fp,"%d ",&arg1) == EOF) return 0;
        !          35889: 
        !          35890:        if (strcmp("DSZ_CHAR",s) == 0) {
        !          35891:                SZ_CHAR = arg1;
        !          35892:                return 1;
        !          35893:        }
        !          35894: 
        !          35895:        if (strcmp("DAL_CHAR",s) == 0) {
        !          35896:                AL_CHAR = arg1;
        !          35897:                return 1;
        !          35898:        }
        !          35899: 
        !          35900:        if (strcmp("DSZ_SHORT",s) == 0) {
        !          35901:                SZ_SHORT = arg1;
        !          35902:                return 1;
        !          35903:        }
        !          35904:        
        !          35905:        if (strcmp("DAL_SHORT",s) == 0) {
        !          35906:                AL_SHORT = arg1;
        !          35907:                return 1;
        !          35908:        }
        !          35909: 
        !          35910:        if (strcmp("DSZ_INT",s) == 0) {
        !          35911:                SZ_INT = arg1;
        !          35912:                return 1;
        !          35913:        }
        !          35914: 
        !          35915:        if (strcmp("DAL_INT",s) == 0) {
        !          35916:                AL_INT=arg1;
        !          35917:                return 1;
        !          35918:        }
        !          35919: 
        !          35920:        if (strcmp("DLARGEST_INT",s) == 0) {
        !          35921:                LARGEST_INT = new char[strlen(s2)+1];
        !          35922:                strcpy(LARGEST_INT,s2);
        !          35923:                return 1;
        !          35924:        }
        !          35925: 
        !          35926:        if (strcmp("DSZ_LONG",s) == 0) {
        !          35927:                SZ_LONG = arg1;
        !          35928:                return 1;
        !          35929:        }
        !          35930: 
        !          35931:        if (strcmp("DAL_LONG",s) == 0) {
        !          35932:                AL_LONG = arg1;
        !          35933:                return 1;
        !          35934:        }
        !          35935: 
        !          35936:        if (strcmp("DSZ_FLOAT",s) == 0) {
        !          35937:                SZ_FLOAT = arg1;
        !          35938:                return 1;
        !          35939:        }
        !          35940: 
        !          35941:        if (strcmp("DAL_FLOAT",s) == 0) {
        !          35942:                AL_FLOAT = arg1;
        !          35943:                return 1;
        !          35944:        }
        !          35945: 
        !          35946:        if (strcmp("DSZ_DOUBLE",s) == 0) {
        !          35947:                SZ_DOUBLE = arg1;
        !          35948:                return 1;
        !          35949:        }
        !          35950: 
        !          35951:        if (strcmp("DAL_DOUBLE",s) == 0) {
        !          35952:                AL_DOUBLE = arg1;
        !          35953:                return 1;
        !          35954:        }
        !          35955:        
        !          35956:        if (strcmp("DSZ_LDOUBLE",s) == 0) {
        !          35957:                SZ_LDOUBLE = arg1;
        !          35958:                return 1;
        !          35959:        }
        !          35960: 
        !          35961:        if (strcmp("DAL_LDOUBLE",s) == 0) {
        !          35962:                AL_LDOUBLE = arg1;
        !          35963:                return 1;
        !          35964:        }
        !          35965: 
        !          35966:        if (strcmp("DBI_IN_BYTE",s) == 0) {
        !          35967:                BI_IN_BYTE = arg1;
        !          35968:                return 1;
        !          35969:        }
        !          35970: 
        !          35971:        if (strcmp("DBI_IN_WORD",s) == 0) {
        !          35972:                BI_IN_WORD= arg1;
        !          35973:                return 1;
        !          35974:        }
        !          35975: 
        !          35976:        if (strcmp("DSZ_STRUCT",s) == 0) {
        !          35977:                SZ_STRUCT = arg1;
        !          35978:                return 1;
        !          35979:        }
        !          35980: 
        !          35981:        if (strcmp("DAL_STRUCT",s) == 0) {
        !          35982:                AL_STRUCT = arg1;
        !          35983:                return 1;
        !          35984:        }
        !          35985: 
        !          35986:        if (strcmp("DF_SENSITIVE",s) == 0) {
        !          35987:                F_SENSITIVE = arg1;
        !          35988:                return 1;
        !          35989:        }
        !          35990: 
        !          35991:        if (strcmp("DF_OPTIMIZED",s) == 0) {
        !          35992:                F_OPTIMIZED = arg1;
        !          35993:                return 1;
        !          35994:        }
        !          35995: 
        !          35996:        if (strcmp("frame",s) == 0) {
        !          35997: //             SZ_FRAME = arg1;
        !          35998: //             AL_FRAME = arg2;
        !          35999:                return 1;
        !          36000:        }
        !          36001: 
        !          36002:        if (strcmp("DSZ_WORD",s) == 0) {
        !          36003:                SZ_WORD = arg1;
        !          36004:                return 1;
        !          36005:        }
        !          36006: 
        !          36007:        if (strcmp("DSZ_WPTR",s) == 0) {
        !          36008:                SZ_WPTR = arg1;
        !          36009:                return 1;
        !          36010:        }
        !          36011: 
        !          36012:        if (strcmp("DAL_WPTR",s) == 0) {
        !          36013:                AL_WPTR = arg1;
        !          36014:                return 1;
        !          36015:        }
        !          36016: 
        !          36017:        if (strcmp("DSZ_BPTR",s) == 0) {
        !          36018:                SZ_BPTR = arg1;
        !          36019:                return 1;
        !          36020:        }
        !          36021: 
        !          36022:        if (strcmp("DAL_BPTR",s) == 0) {
        !          36023:                AL_BPTR = arg1;
        !          36024:                return 1;
        !          36025:        }
        !          36026: 
        !          36027:        if (strcmp("top",s) == 0) {
        !          36028: //             SZ_TOP = arg1;
        !          36029: //             SZ_BOTTOM = arg2;
        !          36030:                return 1;
        !          36031:        }
        !          36032:        return 0;
        !          36033: }
        !          36034: 
        !          36035: int read_align(char* f)
        !          36036: {
        !          36037:        char* p = f;
        !          36038:        if (*p == 0) {
        !          36039:                fprintf(stderr,"size/align file missing\n");
        !          36040:                ext(1);
        !          36041:        }
        !          36042:        FILE* fp = fopen(f,"r");
        !          36043:        if (fp == 0) return 1;
        !          36044:        while (get_line(fp)) ;
        !          36045:        return 0;
        !          36046: }
        !          36047: /*
        !          36048: print_align(char* s)
        !          36049: {
        !          36050:        fprintf(stderr,"%s sizes and alignments\n\n",s);
        !          36051: 
        !          36052:        fprintf(stderr,"        size    align   largest\n");
        !          36053:        fprintf(stderr,"char    %d      %d\n",SZ_CHAR,AL_CHAR);
        !          36054:        fprintf(stderr,"short   %d      %d\n",SZ_SHORT,AL_SHORT);
        !          36055:        fprintf(stderr,"int     %d      %d      %s\n",SZ_INT,AL_INT,LARGEST_INT);
        !          36056:        fprintf(stderr,"long    %d      %d\n",SZ_LONG,AL_LONG);
        !          36057:        fprintf(stderr,"float   %d      %d\n",SZ_FLOAT,AL_FLOAT);
        !          36058:        fprintf(stderr,"double  %d      %d\n",SZ_DOUBLE,AL_DOUBLE);
        !          36059:        fprintf(stderr,"ldouble %d      %d\n",SZ_LDOUBLE,AL_LDOUBLE);
        !          36060:        fprintf(stderr,"bptr    %d      %d\n",SZ_BPTR,AL_BPTR);
        !          36061:        fprintf(stderr,"wptr    %d      %d\n",SZ_WPTR,AL_WPTR);
        !          36062:        fprintf(stderr,"struct  %d      %d\n",SZ_STRUCT,AL_STRUCT);
        !          36063:        fprintf(stderr,"struct2 %d      %d\n",F_SENSITIVE,F_OPTIMIZED);
        !          36064: //     fprintf(stderr,"frame   %d      %d\n",SZ_FRAME,AL_FRAME);
        !          36065: 
        !          36066:        fprintf(stderr,"%d bits in a byte, %d bits in a word, %d bytes in a word\n",
        !          36067:                        BI_IN_BYTE, BI_IN_WORD, SZ_WORD);
        !          36068:        return 1;
        !          36069: }
        !          36070: */
        !          36071: 
        !          36072: int c_strlen(const char* s)
        !          36073: /*
        !          36074:        return sizeof(s) with escapes processed
        !          36075:        sizeof("") == 1         the terminating 0
        !          36076:        sizeof("a") == 2
        !          36077:        sizeof("\0x") == 3      0 x 0
        !          36078:        sizeof("\012") == 2     '\012'
        !          36079:        sizeof("\01")           '\001'
        !          36080:        sizeof("\x") == 2       \ ignored
        !          36081: 
        !          36082: */
        !          36083: {
        !          36084:        int i = 1;
        !          36085:         for (const char* p = s; *p; i++,p++) {
        !          36086:                if (*p == '\\') {                                       // '\?
        !          36087:                        switch (*++p) {
        !          36088:                        case '0':
        !          36089:                                switch (p[1]) {         // '\01' or '\012'
        !          36090:                                case '0': case '1': case '2': case '3':
        !          36091:                                case '4': case '5': case '6': case '7':
        !          36092:                                        break;
        !          36093:                                default:
        !          36094:                                        continue;       // '\0'
        !          36095:                                }
        !          36096:                                /* no break */
        !          36097:                        case '1': case '2': case '3':
        !          36098:                        case '4': case '5': case '6': case '7':         // '\123'
        !          36099:                                switch (*++p) {
        !          36100:                                case '0': case '1': case '2': case '3':
        !          36101:                                case '4': case '5': case '6': case '7':
        !          36102:                                        switch (*++p) {
        !          36103:                                        case '0': case '1': case '2': case '3':
        !          36104:                                        case '4': case '5': case '6': case '7':
        !          36105:                                                break;
        !          36106:                                        default:
        !          36107:                                                --p;
        !          36108:                                        }
        !          36109:                                        break;
        !          36110:                                default:
        !          36111:                                        --p;
        !          36112:                                        break;
        !          36113:                                }
        !          36114:                                break;
        !          36115:                        case '\n':                      // \newline doesn't count
        !          36116:                                i--;
        !          36117:                                break;
        !          36118:                        }
        !          36119:                }
        !          36120:        }
        !          36121:        return i;
        !          36122: }
        !          36123: 0707071010112045661004440001630000160000010207700466055411000000700000020157size.h/*ident     "@(#)ctrans:src/size.h  1.2" */
        !          36124: /*************************************************************************
        !          36125: 
        !          36126:        C++ source for cfront, the C++ compiler front-end
        !          36127:        written in the computer science research center of Bell Labs
        !          36128: 
        !          36129:        Copyright (c) 1984 AT&T, Inc. All rigths Reserved
        !          36130:        THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T, INC.
        !          36131: 
        !          36132: size.h:
        !          36133:        sizes and alignments used to calculate sizeofs
        !          36134: 
        !          36135:        table and butffer sizes
        !          36136: 
        !          36137: ***************************************************************************/
        !          36138: #ifndef GRAM
        !          36139: extern BI_IN_WORD;
        !          36140: extern BI_IN_BYTE;
        !          36141:                                /*      byte sizes */
        !          36142: extern SZ_CHAR;
        !          36143: extern AL_CHAR;
        !          36144: 
        !          36145: extern SZ_SHORT;
        !          36146: extern AL_SHORT;
        !          36147: 
        !          36148: extern SZ_INT;
        !          36149: extern AL_INT;
        !          36150: 
        !          36151: extern SZ_LONG;
        !          36152: extern AL_LONG;
        !          36153: 
        !          36154: extern SZ_FLOAT;
        !          36155: extern AL_FLOAT;
        !          36156: 
        !          36157: extern SZ_DOUBLE;
        !          36158: extern AL_DOUBLE;
        !          36159: 
        !          36160: extern SZ_LDOUBLE;
        !          36161: extern AL_LDOUBLE;
        !          36162: 
        !          36163: extern SZ_STRUCT;      /* minimum struct size */
        !          36164: extern AL_STRUCT;
        !          36165: 
        !          36166: //extern SZ_FRAME;
        !          36167: //extern AL_FRAME;
        !          36168: 
        !          36169: extern SZ_WORD;
        !          36170: 
        !          36171: extern SZ_WPTR;
        !          36172: extern AL_WPTR;
        !          36173: 
        !          36174: extern SZ_BPTR;
        !          36175: extern AL_BPTR;        
        !          36176: 
        !          36177: //extern SZ_TOP;
        !          36178: //extern SZ_BOTTOM;
        !          36179: 
        !          36180: extern char* LARGEST_INT;
        !          36181: extern int F_SENSITIVE;        // is field alignment sensitive to the type of the field?
        !          36182: extern int F_OPTIMIZED;        // can the compiler fit a small int field into a char?
        !          36183: #endif
        !          36184:                                // default sizes:
        !          36185:        // Note: #if doesn't work on all systems
        !          36186: #ifdef u3b
        !          36187: #define Abbb
        !          36188: #endif
        !          36189: #ifdef u3b2
        !          36190: #define Abbb
        !          36191: #endif
        !          36192: #ifdef u3b5
        !          36193: #define Abbb
        !          36194: #endif
        !          36195: #ifdef u3b15
        !          36196: #define Abbb
        !          36197: #endif
        !          36198: #ifdef pyr
        !          36199: #define Abbb
        !          36200: #endif
        !          36201: 
        !          36202: 
        !          36203: #ifdef alliant
        !          36204: #define Am68
        !          36205: #endif
        !          36206: #ifdef apollo
        !          36207: #define Am68
        !          36208: #endif
        !          36209: #if defined(sun2) || defined(mc68010)
        !          36210: #define Am68
        !          36211: #endif
        !          36212: #if defined(sun3) || defined(mc68020)
        !          36213: #define Am68
        !          36214: #endif
        !          36215: #if defined(mc68k) || defined(hp9000s200) || defined(hp9000s300)
        !          36216: #define Am68
        !          36217: #endif
        !          36218: 
        !          36219: #ifdef iAPX286
        !          36220: #ifdef LARGE
        !          36221: #define Ai286l
        !          36222: #endif
        !          36223: #endif
        !          36224: 
        !          36225: #ifdef Abbb
        !          36226:                                /* AT&T 3Bs */
        !          36227: #define DBI_IN_WORD 32
        !          36228: #define DBI_IN_BYTE 8
        !          36229: #define DSZ_CHAR 1
        !          36230: #define DAL_CHAR 1
        !          36231: #define DSZ_SHORT 2
        !          36232: #define DAL_SHORT 2
        !          36233: #define DSZ_INT 4
        !          36234: #define DAL_INT 4
        !          36235: #define DSZ_LONG 4
        !          36236: #define DAL_LONG 4
        !          36237: #define DSZ_FLOAT 4
        !          36238: #define DAL_FLOAT 4
        !          36239: #define DSZ_DOUBLE 8
        !          36240: #define DAL_DOUBLE 4
        !          36241: #define DSZ_LDOUBLE 8
        !          36242: #define DAL_LDOUBLE 4
        !          36243: #define DSZ_STRUCT 4
        !          36244: #define DAL_STRUCT 4
        !          36245: //#define DSZ_FRAME 4
        !          36246: //#define DAL_FRAME 4
        !          36247: #define DSZ_WORD 4
        !          36248: #define DSZ_WPTR 4
        !          36249: #define DAL_WPTR 4
        !          36250: #define DSZ_BPTR 4
        !          36251: #define DAL_BPTR 4
        !          36252: //#define DSZ_TOP 0
        !          36253: //#define DSZ_BOTTOM 0
        !          36254: #define DLARGEST_INT "2147483647"      /* 2**31 - 1 */
        !          36255: #define DF_SENSITIVE 0
        !          36256: #define DF_OPTIMIZED 1
        !          36257: #else
        !          36258: #ifdef Am68
        !          36259:                                /* most M68K boxes */
        !          36260: #if defined(hp9000s200) || defined(hp9000s300)
        !          36261: #define DBI_IN_WORD 32 
        !          36262: #else
        !          36263: #define DBI_IN_WORD 16
        !          36264: #endif
        !          36265: #define DBI_IN_BYTE 8
        !          36266: #define DSZ_CHAR 1
        !          36267: #define DAL_CHAR 1
        !          36268: #define DSZ_SHORT 2
        !          36269: #define DAL_SHORT 2
        !          36270: #define DSZ_INT 4
        !          36271: #define DAL_INT 2
        !          36272: #define DSZ_LONG 4
        !          36273: #define DAL_LONG 2
        !          36274: #define DSZ_FLOAT 4
        !          36275: #define DAL_FLOAT 2
        !          36276: #define DSZ_DOUBLE 8
        !          36277: #define DAL_DOUBLE 2
        !          36278: #define DSZ_LDOUBLE 8
        !          36279: #define DAL_LDOUBLE 2
        !          36280: #define DSZ_STRUCT 2
        !          36281: #define DAL_STRUCT 2
        !          36282: //#define DSZ_FRAME 4
        !          36283: //#define DAL_FRAME 4
        !          36284: #define DSZ_WORD 2
        !          36285: #define DSZ_WPTR 4
        !          36286: #define DAL_WPTR 2
        !          36287: #define DSZ_BPTR 4
        !          36288: #define DAL_BPTR 2
        !          36289: //#define DSZ_TOP 0
        !          36290: //#define DSZ_BOTTOM 0
        !          36291: #define DLARGEST_INT "2147483647"      /* 2**31 - 1 */
        !          36292: #define DF_SENSITIVE 0
        !          36293: #define DF_OPTIMIZED 1
        !          36294: #else
        !          36295: #ifdef Ai286l
        !          36296:                                /* Intel 80286 large model */
        !          36297: #define DBI_IN_WORD 16
        !          36298: #define DBI_IN_BYTE 8
        !          36299: #define DSZ_CHAR 1
        !          36300: #define DAL_CHAR 1
        !          36301: #define DSZ_SHORT 2
        !          36302: #define DAL_SHORT 2
        !          36303: #define DSZ_INT 2
        !          36304: #define DAL_INT 2
        !          36305: #define DSZ_LONG 4
        !          36306: #define DAL_LONG 2
        !          36307: #define DSZ_FLOAT 4
        !          36308: #define DAL_FLOAT 2
        !          36309: #define DSZ_DOUBLE 8
        !          36310: #define DAL_DOUBLE 2
        !          36311: #define DSZ_LDOUBLE 8
        !          36312: #define DAL_LDOUBLE 2
        !          36313: #define DSZ_STRUCT 2
        !          36314: #define DAL_STRUCT 2
        !          36315: //#define DSZ_FRAME 4
        !          36316: //#define DAL_FRAME 4
        !          36317: #define DSZ_WORD 2
        !          36318: #define DSZ_WPTR 4
        !          36319: #define DAL_WPTR 2
        !          36320: #define DSZ_BPTR 4
        !          36321: #define DAL_BPTR 2
        !          36322: //#define DSZ_TOP 0
        !          36323: //#define DSZ_BOTTOM 0
        !          36324: #define DLARGEST_INT "32767"   /* 2**15 - 1 */
        !          36325: #define DF_SENSITIVE 0
        !          36326: #define DF_OPTIMIZED 1
        !          36327: #else
        !          36328: #if defined(uts) || defined(hp9000s800) || defined(sun4) || defined(sparc)
        !          36329:                                /* Amdahl running UTS, HP RISC */
        !          36330: #define DBI_IN_WORD 32
        !          36331: #define DBI_IN_BYTE 8
        !          36332: #define DSZ_CHAR 1
        !          36333: #define DAL_CHAR 1
        !          36334: #define DSZ_SHORT 2
        !          36335: #define DAL_SHORT 2
        !          36336: #define DSZ_INT 4
        !          36337: #define DAL_INT 4
        !          36338: #define DSZ_LONG 4
        !          36339: #define DAL_LONG 4
        !          36340: #define DSZ_FLOAT 4
        !          36341: #define DAL_FLOAT 4
        !          36342: #define DSZ_DOUBLE 8
        !          36343: #define DAL_DOUBLE 8
        !          36344: #define DSZ_LDOUBLE 8
        !          36345: #define DAL_LDOUBLE 8
        !          36346: #define DSZ_STRUCT 1
        !          36347: #define DAL_STRUCT 1
        !          36348: #define DSZ_WORD 4
        !          36349: #define DSZ_WPTR 4
        !          36350: #define DAL_WPTR 4
        !          36351: #define DSZ_BPTR 4
        !          36352: #define DAL_BPTR 4
        !          36353: #define DLARGEST_INT "2147483647"      /* 2**31 - 1 */
        !          36354: #if defined(uts)
        !          36355: #define DF_SENSITIVE 1
        !          36356: #else
        !          36357: #define DF_SENSITIVE 0
        !          36358: #endif
        !          36359: #define DF_OPTIMIZED 1
        !          36360: #else
        !          36361: #ifdef hpux 
        !          36362:                                 /* hp */
        !          36363: #define DBI_IN_WORD 32
        !          36364: #define DBI_IN_BYTE 8
        !          36365: #define DSZ_CHAR 1
        !          36366: #define DAL_CHAR 1
        !          36367: #define DSZ_SHORT 2
        !          36368: #define DAL_SHORT 2
        !          36369: #define DSZ_INT 4
        !          36370: #define DAL_INT 4
        !          36371: #define DSZ_LONG 4
        !          36372: #define DAL_LONG 4
        !          36373: #define DSZ_FLOAT 4
        !          36374: #define DAL_FLOAT 4
        !          36375: #define DSZ_DOUBLE 8
        !          36376: #define DAL_DOUBLE 8 
        !          36377: #define DSZ_LDOUBLE 8
        !          36378: #define DAL_LDOUBLE 8
        !          36379: #define DSZ_STRUCT 1 
        !          36380: #define DAL_STRUCT 1 
        !          36381: #define DSZ_WORD 4
        !          36382: #define DSZ_WPTR 4
        !          36383: #define DAL_WPTR 4
        !          36384: #define DSZ_BPTR 4
        !          36385: #define DAL_BPTR 4
        !          36386: #define DLARGEST_INT "2147483647"       /* 2**31 - 1 */
        !          36387: #define DF_SENSITIVE 1 
        !          36388: #define DF_OPTIMIZED 1
        !          36389: #else
        !          36390: #if defined(vax) || defined(ibm032) || defined(i386)
        !          36391:                                /* VAX, IBM 32, Intel 386 */
        !          36392: #define DBI_IN_WORD 32
        !          36393: #define DBI_IN_BYTE 8
        !          36394: #define DSZ_CHAR 1
        !          36395: #define DAL_CHAR 1
        !          36396: #define DSZ_SHORT 2
        !          36397: #define DAL_SHORT 2
        !          36398: #define DSZ_INT 4
        !          36399: #define DAL_INT 4
        !          36400: #define DSZ_LONG 4
        !          36401: #define DAL_LONG 4
        !          36402: #define DSZ_FLOAT 4
        !          36403: #define DAL_FLOAT 4
        !          36404: #define DSZ_DOUBLE 8
        !          36405: #define DAL_DOUBLE 4
        !          36406: #define DSZ_LDOUBLE 8
        !          36407: #define DAL_LDOUBLE 4
        !          36408: #define DSZ_STRUCT 1
        !          36409: #define DAL_STRUCT 1
        !          36410: //#define DSZ_FRAME 4
        !          36411: //#define DAL_FRAME 4
        !          36412: #define DSZ_WORD 4
        !          36413: #define DSZ_WPTR 4
        !          36414: #define DAL_WPTR 4
        !          36415: #define DSZ_BPTR 4
        !          36416: #define DAL_BPTR 4
        !          36417: //#define DSZ_TOP 0
        !          36418: //#define DSZ_BOTTOM 0
        !          36419: #define DLARGEST_INT "2147483647"      /* 2**31 - 1 */
        !          36420: #define DF_SENSITIVE 0
        !          36421: #define DF_OPTIMIZED 1
        !          36422: #else
        !          36423: #ifdef mc300
        !          36424: #define DBI_IN_WORD 32
        !          36425: #define DBI_IN_BYTE 8
        !          36426: #define DSZ_CHAR 1
        !          36427: #define DAL_CHAR 1
        !          36428: #define DSZ_SHORT 2
        !          36429: #define DAL_SHORT 2
        !          36430: #define DSZ_INT 4
        !          36431: #define DAL_INT 4
        !          36432: #define DSZ_LONG 4
        !          36433: #define DAL_LONG 4
        !          36434: #define DSZ_FLOAT 4
        !          36435: #define DAL_FLOAT 4
        !          36436: #define DSZ_DOUBLE 8
        !          36437: #define DAL_DOUBLE 4
        !          36438: #define DSZ_LDOUBLE 8
        !          36439: #define DAL_LDOUBLE 4
        !          36440: #define DSZ_STRUCT 2
        !          36441: #define DAL_STRUCT 2
        !          36442: //#define DSZ_FRAME 4
        !          36443: //#define DAL_FRAME 4
        !          36444: #define DSZ_WORD 4
        !          36445: #define DSZ_WPTR 4
        !          36446: #define DAL_WPTR 4
        !          36447: #define DSZ_BPTR 4
        !          36448: #define DAL_BPTR 4
        !          36449: //#define DSZ_TOP 0
        !          36450: //#define DSZ_BOTTOM 0
        !          36451: #define DLARGEST_INT "2147483647"       /* 2**31 - 1 */
        !          36452: #define DF_SENSITIVE 0
        !          36453: #define DF_OPTIMIZED 1
        !          36454: #else
        !          36455: #ifdef mips
        !          36456: #define DBI_IN_BYTE 8
        !          36457: #define DBI_IN_WORD 32
        !          36458: #define DSZ_WORD 4
        !          36459: #define DSZ_CHAR 1
        !          36460: #define DAL_CHAR 1
        !          36461: #define DSZ_SHORT 2
        !          36462: #define DAL_SHORT 2
        !          36463: #define DSZ_INT 4
        !          36464: #define DAL_INT 4
        !          36465: #define DLARGEST_INT "2147483647"
        !          36466: #define DSZ_LONG 4
        !          36467: #define DAL_LONG 4
        !          36468: #define DSZ_FLOAT 4
        !          36469: #define DAL_FLOAT 4
        !          36470: #define DSZ_DOUBLE 8
        !          36471: #define DAL_DOUBLE 8
        !          36472: #define DSZ_LDOUBLE 8 
        !          36473: #define DAL_LDOUBLE 8 
        !          36474: #define DSZ_BPTR 4
        !          36475: #define DAL_BPTR 4
        !          36476: #define DSZ_WPTR 4
        !          36477: #define DAL_WPTR 4
        !          36478: #define DSZ_STRUCT 1
        !          36479: #define DAL_STRUCT 1
        !          36480: #define DF_SENSITIVE 0
        !          36481: #define DF_OPTIMIZED 1
        !          36482: #else
        !          36483:                                /* defaults: 0 => error */
        !          36484: #define DBI_IN_WORD 0
        !          36485: #define DBI_IN_BYTE 0
        !          36486: #define DSZ_CHAR 1
        !          36487: #define DAL_CHAR 1
        !          36488: #define DSZ_SHORT 0
        !          36489: #define DAL_SHORT 0
        !          36490: #define DSZ_INT 0
        !          36491: #define DAL_INT 0
        !          36492: #define DSZ_LONG 0
        !          36493: #define DAL_LONG 0
        !          36494: #define DSZ_FLOAT 0
        !          36495: #define DAL_FLOAT 0
        !          36496: #define DSZ_DOUBLE 0
        !          36497: #define DAL_DOUBLE 0
        !          36498: #define DSZ_LDOUBLE 0
        !          36499: #define DAL_LDOUBLE 0
        !          36500: #define DSZ_STRUCT 0
        !          36501: #define DAL_STRUCT 0
        !          36502: #define DSZ_WORD 0
        !          36503: #define DSZ_WPTR 0
        !          36504: #define DAL_WPTR 0
        !          36505: #define DSZ_BPTR 0
        !          36506: #define DAL_BPTR 0
        !          36507: #define DLARGEST_INT "0"
        !          36508: #define DF_SENSITIVE 0
        !          36509: #define DF_OPTIMIZED 0
        !          36510: #endif
        !          36511: #endif
        !          36512: #endif
        !          36513: #endif
        !          36514: #endif
        !          36515: #endif
        !          36516: #endif
        !          36517: #endif
        !          36518: 
        !          36519: #define KTBLSIZE       123     /*      initial keyword table size */
        !          36520: #define GTBLSIZE       257     /*      initial global name table size */
        !          36521: #define CTBLSIZE       12      /*      initial class table size */
        !          36522: #define TBLSIZE                20      /*      initial block table size */
        !          36523: #define BLMAX          50      /*      max block nesting */
        !          36524: #define MAXFILE                127     /*      max include file nesting */
        !          36525: #define MAXERR         13      /* maximum number of errors before terminating */
        !          36526: 
        !          36527: #ifndef GRAM
        !          36528: const CHUNK = 8*1024;
        !          36529: void* chunk(int);
        !          36530: #endif
        !          36531: 0707071010112045671004440001630000160000010210000466055411300001000000015476table.c/*ident    "@(#)ctrans:src/table.c 1.3" */
        !          36532: /**************************************************************************
        !          36533: 
        !          36534:         C++ source for cfront, the C++ compiler front-end
        !          36535:         written in the computer science research center of Bell Labs
        !          36536: 
        !          36537:         Copyright (c) 1984 AT&T, Inc. All Rights Reserved
        !          36538:         THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T, INC.
        !          36539: 
        !          36540: table.c:
        !          36541: 
        !          36542: *****************************************************************************/
        !          36543: 
        !          36544: #include "cfront.h"
        !          36545: #include "size.h"
        !          36546: 
        !          36547: #ifdef DBG
        !          36548: extern long node_id;
        !          36549: #define DBCHECK() if(node::allocated) error('i',"allocated node (id %d, base%k) on free list! (src: \"%s\", %d",node::id,node::base,__FILE__,__LINE__);
        !          36550: #else
        !          36551: #define DBCHECK() /**/
        !          36552: #endif
        !          36553: 
        !          36554: table::table(short sz, Ptable nx, Pname n)
        !          36555: /*
        !          36556:        create a symbol table with "size" entries
        !          36557:        the scope of table is enclosed in the scope of "nx"
        !          36558: 
        !          36559:        both the vector of class name pointers and the hash table
        !          36560:        are initialized containing all zeroes
        !          36561:        
        !          36562:        to simplify hashed lookup entries[0] is never used
        !          36563:        so the size of "entries" must be "size+1" to hold "size" entries
        !          36564: */
        !          36565: {
        !          36566:        DBCHECK();
        !          36567:        base = TABLE;
        !          36568:        t_name = n;
        !          36569:        size = sz = (sz<=0) ? 2 : sz+1;
        !          36570: //fprintf(stderr,"table::table %d %s %d (%d %d)\n", this, (n)?n->string:"?", sz,(sz*3)/2);
        !          36571:        entries = new Pname[sz];
        !          36572:        hashsize = sz = (sz*3)/2;
        !          36573:        hashtbl = new short[sz];
        !          36574:        next = nx;
        !          36575:        free_slot = 1;
        !          36576:        DBID();
        !          36577: }
        !          36578: 
        !          36579: table::~table()
        !          36580: {
        !          36581:        delete entries;
        !          36582:        delete hashtbl;
        !          36583: }
        !          36584: 
        !          36585: Pname table::look(char* s, TOK k)
        !          36586: /*
        !          36587:        look for "s" in table, ignore entries which are not of "k" type
        !          36588:        look and insert MUST be the same lookup algorithm
        !          36589: */
        !          36590: {
        !          36591:        Ptable t;
        !          36592:        register char * p;
        !          36593:        register char * q;
        !          36594:        register int i;
        !          36595:        Pname n;
        !          36596:        int rr;
        !          36597: 
        !          36598: //     if (s == 0) error('i',"%d->look(0)",this);
        !          36599: //     if (this == 0) error('i',"0->look(%s)",s);
        !          36600: //     if (base != TABLE) error('i',"(%d,%d)->look(%s)",this,base,s);
        !          36601: 
        !          36602:        /* use simple hashing with linear search for overflow */
        !          36603: 
        !          36604:        p = s;
        !          36605:        i = 0;
        !          36606:        while (*p) i += (i + *p++); /* i<<1 ^ *p++ better?*/
        !          36607:        rr = (0<=i) ? i : -i;
        !          36608: 
        !          36609:        for (t=this; t; t=t->next) {    
        !          36610:                /* in this and all enclosing scopes look for name "s" */
        !          36611:                Pname* np = t->entries;
        !          36612:                int mx = t->hashsize;
        !          36613:                short* hash = t->hashtbl;
        !          36614:                int firsti = i = rr%mx;
        !          36615: 
        !          36616:                do {                    
        !          36617:                        if (hash[i] == 0) goto not_found;
        !          36618:                        n = np[hash[i]];
        !          36619:                        if (n == 0) error('i',"hashed lookup");
        !          36620:                        p = n->string;          /* strcmp(n->n_string,s) */
        !          36621:                        q = s;
        !          36622:                        while (*p && *q)
        !          36623:                                if (*p++ != *q++) goto nxt;
        !          36624:                        if (*p == *q) goto found;
        !          36625:                nxt:
        !          36626:                        if (mx <= ++i) i = 0;           /* wrap around */
        !          36627:                } while (i != firsti);
        !          36628: 
        !          36629:        found:
        !          36630:                for (; n; n=n->n_tbl_list){     /* for  all name "s"s look for a key match */
        !          36631:                        if (n->n_key == k) return n;
        !          36632:                }
        !          36633: 
        !          36634:        not_found:;
        !          36635:        }
        !          36636: 
        !          36637:        return 0;       /* not found && no enclosing scope */
        !          36638: }
        !          36639: 
        !          36640: bit Nold;      /* non-zero if last insert() failed */
        !          36641: 
        !          36642: Pname table::insert(Pname nx, TOK k)
        !          36643: /*
        !          36644:        the lookup algorithm MUST be the same as look
        !          36645:        if nx is found return the older entry otherwise a copy of nx;
        !          36646:        Nold = (nx found) ? 1 : 0;
        !          36647: */
        !          36648: {
        !          36649:        register char * p;
        !          36650:        register int i;
        !          36651:        Pname n;
        !          36652:        Pname* np = entries;
        !          36653:        Pname* link;
        !          36654:        int firsti;
        !          36655:        int mx = hashsize;
        !          36656:        short* hash = hashtbl;
        !          36657:        char* s = nx->string;
        !          36658: 
        !          36659:        if (s==0) error('i',"%p->insert(0,%k)",this,k);
        !          36660:        nx->n_key = k;
        !          36661:        if (nx->n_tbl_list || nx->n_table) error('i',"%n in two tables",nx);
        !          36662:        /* use simple hashing with linear search for overflow */
        !          36663: 
        !          36664:        p = s;
        !          36665:        i = 0;
        !          36666:        while (*p) i += (i + *p++);
        !          36667:        if (i<0) i = -i;
        !          36668:        firsti = i = i%mx;
        !          36669: 
        !          36670:        do {    /* look for name "s" */
        !          36671:                if (hash[i] == 0) {
        !          36672:                        hash[i] = free_slot;
        !          36673:                        goto add_np;
        !          36674:                }
        !          36675:                n = np[hash[i]];
        !          36676:                if (n == 0) error('i',"hashed lookup");
        !          36677:                if (strcmp(n->string,s) == 0) goto found;
        !          36678: /*
        !          36679:                p = n->string;
        !          36680:                q = s;
        !          36681:                while (*p && *q) if (*p++ != *q++) goto nxt;
        !          36682:                if (*p == *q) goto found;
        !          36683:        nxt:
        !          36684: */
        !          36685:                if (mx <= ++i) i = 0;   /* wrap around */
        !          36686:        } while (i != firsti);
        !          36687: 
        !          36688:        error("N table full");
        !          36689: 
        !          36690: found: 
        !          36691: 
        !          36692: 
        !          36693:        for(;;) {
        !          36694:                if ( k!=NESTED && n->n_key==k) { Nold = 1; return n; }
        !          36695: 
        !          36696:                if (n->n_tbl_list)
        !          36697:                        n = n->n_tbl_list;
        !          36698:                else {
        !          36699:                        link = &(n->n_tbl_list);
        !          36700:                        goto re_allocate;
        !          36701:                }
        !          36702:        }
        !          36703: 
        !          36704: add_np:
        !          36705:        if (size <= free_slot) {
        !          36706:                grow(2*size);
        !          36707:                return insert(nx,k);
        !          36708:        }
        !          36709: 
        !          36710:        link = &(np[free_slot++]);
        !          36711: 
        !          36712: re_allocate:
        !          36713:        {       
        !          36714:                Pname nw = new name;
        !          36715:                *nw = *nx;
        !          36716:                char* ps = new char[strlen(s)+1]; // copy string to safer store
        !          36717:                strcpy(ps,s);
        !          36718: //             Nstr++;
        !          36719:                nw->string = ps;
        !          36720:                nw->n_table = this;
        !          36721:                *link = nw;
        !          36722:                Nold = 0;
        !          36723: //             Nname++;
        !          36724:                return nw;
        !          36725:        }
        !          36726: }
        !          36727: 
        !          36728: void table::grow(int g)
        !          36729: {
        !          36730:        short* hash;
        !          36731:        register int j;
        !          36732:        int mx; 
        !          36733:        register Pname* np;
        !          36734:        Pname n;
        !          36735: 
        !          36736:        if (g <= free_slot) error('i',"table.grow(%d,%d)",g,free_slot);
        !          36737:        if (g <= size) return;
        !          36738: //error('d',"grow %d %s %d->%d", this, (t_name)?t_name->string:"?", size, g+1);
        !          36739:        size = mx = g+1;
        !          36740: 
        !          36741:        np = new Pname[mx];
        !          36742:        for (j=0; j<free_slot; j++) np[j] = entries[j];
        !          36743:        delete entries;
        !          36744:        entries = np;
        !          36745: 
        !          36746:        delete hashtbl;
        !          36747:        hashsize = mx = (g*3)/2;
        !          36748:        hash = hashtbl = new short[mx];
        !          36749: 
        !          36750:        for (j=1; j<free_slot; j++) {   /* rehash(np[j]); */
        !          36751:                char * s = np[j]->string;
        !          36752:                register char * p;
        !          36753:                char * q;
        !          36754:                register int i;
        !          36755:                int firsti;
        !          36756: 
        !          36757:                p = s;
        !          36758:                i = 0;
        !          36759:                while (*p) i += (i + *p++);
        !          36760:                if (i<0) i = -i;
        !          36761:                firsti = i = i%mx;
        !          36762: 
        !          36763:                do {    /* look for name "s" */
        !          36764:                        if (hash[i] == 0) {
        !          36765:                                hash[i] = j;
        !          36766:                                goto add_np;
        !          36767:                        }
        !          36768:                        n = np[hash[i]];
        !          36769:                        if (n == 0) error('i',"hashed lookup");
        !          36770:                        p = n->string;  /* strcmp(n->n_string,s) */
        !          36771:                        q = s;
        !          36772:                        while (*p && *q) if (*p++ != *q++) goto nxt;
        !          36773:                        if (*p == *q) goto found;
        !          36774:                nxt:
        !          36775:                        if (mx <= ++i) i = 0;   /* wrap around */
        !          36776:                } while (i != firsti);
        !          36777: 
        !          36778:                error('i',"rehash??");
        !          36779: 
        !          36780:        found:
        !          36781:                error('i',"rehash failed");
        !          36782: 
        !          36783:        add_np:;
        !          36784:        }
        !          36785: }
        !          36786: 
        !          36787: Pname table::get_mem(int i)
        !          36788: /*
        !          36789:        return a pointer to the i'th entry, or 0 if it does not exist
        !          36790: */
        !          36791: {
        !          36792:        return (i<=0 || free_slot<=i) ? 0 : entries[i];
        !          36793: }
        !          36794: 
        !          36795: void table_delete(char* s, TOK k, int ll )
        !          36796: /*
        !          36797:        deletes local class entry from keyword table
        !          36798:        adjusts pointers if multiple entries
        !          36799:        uses same lookup as table::look and table::insert
        !          36800: */
        !          36801: {
        !          36802:        Ptable t = ktbl;
        !          36803:        register char * p;
        !          36804:        register char * q;
        !          36805:        register int i;
        !          36806:        Pname n;
        !          36807:        int rr;
        !          36808: 
        !          36809:        p = s;
        !          36810:        i = 0;
        !          36811:        while (*p) i += (i + *p++); /* i<<1 ^ *p++ better?*/
        !          36812:        rr = (0<=i) ? i : -i;
        !          36813: 
        !          36814: // error ('d', "table_delete: %s ll: %d", s, ll );
        !          36815: 
        !          36816:                Pname* np = t->entries;
        !          36817:                int mx = t->hashsize;
        !          36818:                short* hash = t->hashtbl;
        !          36819:                int firsti = i = rr%mx;
        !          36820: 
        !          36821:                do {                    
        !          36822:                        if (hash[i] == 0) error('i',"table delete: not found: %s", s );
        !          36823:                        n = np[hash[i]];
        !          36824:                        if (n == 0) error('i',"table delete: hashed lookup");
        !          36825:                        p = n->string;          /* strcmp(n->n_string,s) */
        !          36826:                        q = s;
        !          36827: // error( 'd', "table_delete: %s", p );
        !          36828:                        while (*p && *q)
        !          36829:                                if (*p++ != *q++) goto nxt;
        !          36830:                        if (*p == *q) goto found;
        !          36831:                nxt:
        !          36832:                        if (mx <= ++i) i = 0;           /* wrap around */
        !          36833:                } while (i != firsti);
        !          36834: 
        !          36835:        found:
        !          36836:                for (Pname prev = n; n; prev = n, n=n->n_tbl_list){     
        !          36837: // error( 'd', "table_delete: found: %s %k lex: %d", n->string, n->n_key, n->lex_level );
        !          36838:                        if (n->n_key == k && n->lex_level == ll ) {
        !          36839: // error( 'd', "table_delete: prev: %d n: %d n->tbl_list: %d", prev, n, n->n_tbl_list);
        !          36840:                                if ( prev == n && n->n_tbl_list == 0 )
        !          36841:                                        hash[i] = 0;
        !          36842:                                else
        !          36843:                                        prev->n_tbl_list = n->n_tbl_list;
        !          36844:                                return;
        !          36845:                        }
        !          36846:                }
        !          36847: }
        !          36848: 0707071010112046031004440001630000160000010211300466055416400001300000206556template.c/* ident "@(#)ctrans:src/template.c     1.3" */
        !          36849: /*******************************************************************
        !          36850: * template.c
        !          36851: *
        !          36852: * This file contains most of the implementation for a subset of 
        !          36853: * parametrized types as defined by the 1989 Stroustrup JOOP paper.  
        !          36854: * The subset chosen here  was the subset relevant to the 
        !          36855: * implementation of aggregates in ObjectStore.
        !          36856: * 
        !          36857: * The following is a list of features supported by the 
        !          36858: * implementation. The list of features parallels the 
        !          36859: * description of templates in the JOOP paper. 
        !          36860: *      
        !          36861: *      a) Class templates supported.
        !          36862: *                              
        !          36863: *      b) Member function templates supported.  
        !          36864: *      Type-specific member functions as described at the 
        !          36865: *      end of the "Outline of an implementation" section 
        !          36866: *      are also supported. 
        !          36867: *
        !          36868: *      Non-member function templates are not supported.
        !          36869: *                                              
        !          36870: *      c) Template arguments may be of type "type" or 
        !          36871: *      simple integral, real, double and pointer types 
        !          36872: *      that are compile-time constants.
        !          36873: *
        !          36874: *      Default arguments are not suported.
        !          36875: *
        !          36876: * 
        !          36877: * Restrictions:
        !          36878: *      
        !          36879: *      a) template definitions may not be nested.
        !          36880: *                                              
        !          36881: *      b) enums, or class definitions may not be 
        !          36882: *      nested within a template class definition.
        !          36883: *                                              
        !          36884: * This file also supports an internal template facility 
        !          36885: * to facilitate the implementation of ObjectStore data 
        !          36886: * model features. The internal template facility is 
        !          36887: * only used by compiler implementors, and is not user visible.
        !          36888: *                                                      
        !          36889: ************************************************************/
        !          36890: 
        !          36891: 
        !          36892: /***********************************************************
        !          36893: *      
        !          36894: * TBD
        !          36895: * 
        !          36896: * 1) Error recovery, a never ending task, could stand improvement.
        !          36897: * 
        !          36898: * 2) The template copying process could probably be speeded up
        !          36899: * substantially, by only placing "graph-like" nodes in the hash 
        !          36900: * table. The current implementation plays it safe, and places 
        !          36901: * all nodes in the hash table.
        !          36902: *                      
        !          36903: * 3) Clean up $name processing, it needs to be remodularized 
        !          36904: * so that class templates and tree templates share the code.
        !          36905: *                                                      
        !          36906: * 4) Permit parametrized name default names within member 
        !          36907: * functions. 
        !          36908: *
        !          36909: ****************************************************************/
        !          36910: 
        !          36911: #include "tree_copy.h"
        !          36912: #include "cfront.h"
        !          36913: #include <string.h>
        !          36914: #include "tree_dump.h"
        !          36915: #include "template.h"
        !          36916: #include <stdlib.h>
        !          36917: #include <ctype.h>
        !          36918: #include "hash.h"
        !          36919: 
        !          36920: extern int bound ; // is not mentioned in the header file
        !          36921: 
        !          36922: const int max_string_size = 1024 ;
        !          36923: 
        !          36924: const int default_copy_hash_size = 1000 ;
        !          36925: 
        !          36926: // Save and restore global state around a template instantiation
        !          36927: void state::save() {
        !          36928:   
        !          36929:   Cdcl = ::Cdcl ;
        !          36930:   Cstmt = ::Cstmt ;
        !          36931:   curloc   = ::curloc ;
        !          36932: 
        !          36933:   curr_file = ::curr_file ;
        !          36934:   curr_expr = ::curr_expr ;
        !          36935:   curr_icall = ::curr_icall ;
        !          36936:   curr_loop = ::curr_loop;
        !          36937:   curr_block = ::curr_block;
        !          36938:   curr_switch = ::curr_switch;
        !          36939: 
        !          36940:   bound    =  ::bound  ;   
        !          36941:   inline_restr = ::inline_restr ;
        !          36942:   last_line = ::last_line ;
        !          36943: 
        !          36944:   no_of_badcall = ::no_of_badcall;
        !          36945:   no_of_undcl = ::no_of_undcl ;
        !          36946:   
        !          36947:   badcall = ::badcall ;
        !          36948:   undcl = ::undcl ;
        !          36949: } ;
        !          36950: 
        !          36951: 
        !          36952: void state::restore() {
        !          36953:   ::Cdcl = Cdcl ;
        !          36954:   ::Cstmt = Cstmt ;
        !          36955:   ::curloc  = curloc ;
        !          36956: 
        !          36957:   ::curr_file = curr_file ;
        !          36958:   ::curr_expr = curr_expr ;
        !          36959:   ::curr_icall = curr_icall ;
        !          36960:   ::curr_loop = curr_loop;
        !          36961:   ::curr_block = curr_block;
        !          36962:   ::curr_switch = curr_switch;
        !          36963: 
        !          36964:   ::bound    =  bound  ;   
        !          36965:   ::inline_restr = inline_restr ;
        !          36966:   ::last_line = last_line ;
        !          36967: 
        !          36968:   ::no_of_badcall = no_of_badcall;
        !          36969:   ::no_of_undcl = no_of_undcl ;
        !          36970:   
        !          36971:   ::badcall = badcall ;
        !          36972:   ::undcl = undcl ;
        !          36973: } ;
        !          36974: 
        !          36975: 
        !          36976: void state::init()  {
        !          36977:   ::bound = 0 ;
        !          36978:   ::inline_restr = 0 ;
        !          36979:   ::no_of_badcall = ::no_of_undcl = 0 ;
        !          36980:   ::undcl = ::badcall = NULL ;
        !          36981:   // lastline  needs to be initialized probaly via a call to putline
        !          36982:   
        !          36983: }
        !          36984: 
        !          36985: 
        !          36986: bit basetype::parametrized_class()
        !          36987: { return ((base == COBJ) && 
        !          36988:          Ptclass(Pbase(this)->b_name->tp)->class_base == uninstantiated_template_class) ;
        !          36989: }
        !          36990: 
        !          36991: class_type_enum get_class_base (Pbase b) {
        !          36992:   if (b->base != COBJ) error('i', "badA top ::get_class_type") ;
        !          36993:   return Ptclass(Pbase(b)->b_name->tp)->class_base ;
        !          36994: }
        !          36995: 
        !          36996: Ptclass get_template_class (Pbase b) {
        !          36997:   class_type_enum t = get_class_base(b) ;
        !          36998: 
        !          36999:   if (! ((t == instantiated_template_class) ||
        !          37000:         (t == uninstantiated_template_class)))
        !          37001:     error ('i', "C is not aYC") ;
        !          37002:   
        !          37003:   return Ptclass(Pbase(b)->b_name->tp) ;
        !          37004: }
        !          37005: 
        !          37006: 
        !          37007: Ptempl_inst get_templ_inst(Pbase b) {
        !          37008: 
        !          37009:   return (get_template_class(b))->inst ;
        !          37010: }
        !          37011: 
        !          37012:   
        !          37013: bit classdef::parametrized_class()
        !          37014: { return (class_base == uninstantiated_template_class) ;
        !          37015: }
        !          37016: 
        !          37017: // Predicate to determine whether two classes are indeed the same. cfront
        !          37018: // normally relies on pointer identity, however this test is insufficient when
        !          37019: // parametrized class instantiationa are involved, since there are potentially
        !          37020: // many instances of a COBJ and CLASS for a given instantiation.
        !          37021: bit classdef::same_class(Pclass pc)
        !          37022: {
        !          37023:   if (this == pc) return true ;
        !          37024: 
        !          37025:   // An intermediate test to compensate for the fact that instantiations do
        !          37026:   // not cause a copy of the syntax tree to be generated. This kludge should
        !          37027:   // not be necessary once the template implementation is complete, and tree
        !          37028:   // copying is implemented.
        !          37029:   // Later, Sam: tree copying is now implemented, i need to remove the
        !          37030:   // following two statements and rerun the test suite.
        !          37031: 
        !          37032:   if ((this->class_base == template_class) &&
        !          37033:       (pc->class_base == instantiated_template_class) &&
        !          37034:       (Ptclass(pc)->inst->def_basetype()->b_name->tp == this))
        !          37035:     return true ;
        !          37036:   // The inverse symmetric test
        !          37037:   if ((pc->class_base == template_class) &&
        !          37038:       (this->class_base == instantiated_template_class) &&
        !          37039:       (Ptclass(this)->inst->def_basetype()->b_name->tp == pc))
        !          37040:     return true ;
        !          37041: 
        !          37042:   // Check whether the templates were determined to be identical after
        !          37043:   // instantiation. 
        !          37044:   if ((pc->class_base == instantiated_template_class) &&
        !          37045:       (this->class_base == instantiated_template_class) &&
        !          37046:       (Ptclass(this)->inst->same(Ptclass(pc)->inst)))
        !          37047:     return true ;
        !          37048:   return false ;
        !          37049: }
        !          37050: 
        !          37051: // determine whether two instantiations are identical; the test asumes that 
        !          37052: // the templates have been instantiated.
        !          37053: bool templ_inst::same(Ptempl_inst t)
        !          37054: {
        !          37055:   return ((forward && (forward == t->forward)) ||
        !          37056:          (forward == t) || (t->forward == this)) ? true : false ;
        !          37057: }
        !          37058: 
        !          37059: 
        !          37060:                       /* Template parsing support */
        !          37061: 
        !          37062: // The canonical template compilation instance. 
        !          37063: 
        !          37064: templ_compilation *templp ;
        !          37065: 
        !          37066: templ_compilation::templ_compilation()
        !          37067: { templates = new table(128, NULL, NULL) ;
        !          37068:   any_type =  new basetype(ANY, NULL);
        !          37069:   PERM(any_type) ;
        !          37070: }
        !          37071: 
        !          37072: 
        !          37073: // determine whether the string corresponds to a tree formal parameter
        !          37074: Pname templ_compilation::tree_parameter(char *s) {
        !          37075:   for (Plist formal = params ; formal ; formal = formal->l)
        !          37076:     if (strcmp(formal->f->string, s) == 0) {
        !          37077:       formal->f->n_used++ ;
        !          37078:       return formal->f ;
        !          37079:     }
        !          37080:   return 0 ;
        !          37081: }  
        !          37082:   
        !          37083:                                       
        !          37084: // Determine whether the name refers to the canonical template class during
        !          37085: // syntax analysis.
        !          37086: Ptempl templ_compilation::is_template(Pname p) {
        !          37087:   if (p->tp && (p->tp->base == COBJ) &&
        !          37088:       (get_class_base(Pbase(p->tp)) == template_class))
        !          37089:     { Pname n = templates->look(p->string, 0) ;
        !          37090:       return (n ? Ptempl(n->tp) : 0) ;
        !          37091:     }
        !          37092:   return 0 ;
        !          37093: }
        !          37094: 
        !          37095: 
        !          37096: // determine whether the string names a template
        !          37097: Ptempl templ_compilation::is_template(char *s) {
        !          37098:   Pname n = templates->look(s,0) ;
        !          37099:   return (n ? Ptempl(n->tp) : 0) ;
        !          37100: }
        !          37101: 
        !          37102:   
        !          37103: // Set up the environment for parsing a template. This involves setting up a
        !          37104: // new nesting level into which the "type type" parameters of the template can
        !          37105: // be entered, so that the lexer can find them as TNAMES. The scope is
        !          37106: // deallocated by end().
        !          37107: void templ_compilation::start() 
        !          37108: { templp->in_progress = true ;
        !          37109:   // Reinitialize the state.
        !          37110:   params = param_end = NULL ; owner = NULL ;
        !          37111:   modified_tn = 0 ;  // Initialize it here, since ::collect adds new types
        !          37112: }
        !          37113: 
        !          37114: 
        !          37115:   
        !          37116: // Collect each parameter as it is parsed, and add it to the list of parms.
        !          37117: // Validate each parameter to make sure that it is one of the acceptable
        !          37118: // types. 
        !          37119: void templ_compilation::collect(TOK parm_type, Pname n)
        !          37120: {
        !          37121:   switch (parm_type) {
        !          37122:   case CLASS:
        !          37123:     // A "type type" parameter, give it the "ANY" type normally used as a
        !          37124:     // wildcard match internally by the compiler in cases of error.
        !          37125:     n->tp =  new basetype(ANY, 0);
        !          37126:     n =  n->tdef() ;           // Set it up to be a typedef.
        !          37127:     n->lex_level = bl_level + 1 ; // Inner scope, so restore() can hack it
        !          37128:     n->n_template_arg = template_type_formal ;
        !          37129:     PERM(n) ; PERM(n->tp) ;
        !          37130:     break ;
        !          37131:   case STATEMENT:
        !          37132:   case EXPRESSION:
        !          37133:     // the argument is a post-syntax expression tree
        !          37134:     n->n_template_arg =
        !          37135:       ((parm_type == EXPRESSION) ? 
        !          37136:        template_expr_tree_formal : template_stmt_tree_formal) ;
        !          37137:     // canonical any_type is ok here
        !          37138:     n->tp = any_type ;
        !          37139:     PERM(n) ;
        !          37140:     break ;
        !          37141:   default:
        !          37142:     error("theZT for%n must be CLASS, not %k", n,parm_type);
        !          37143:   }
        !          37144:   append_parameter(n) ;
        !          37145: }
        !          37146: 
        !          37147: // append the "non-type" parameter to the end of the list
        !          37148: void templ_compilation::append_parameter(Pname n)
        !          37149: {
        !          37150:   if (params){
        !          37151:     param_end->l = new name_list(n, NULL) ;
        !          37152:     param_end = param_end->l ;
        !          37153:   }else params = param_end = new name_list(n, NULL) ;
        !          37154:   PERM(n) ; PERM(n->tp) ;
        !          37155: }
        !          37156: 
        !          37157: 
        !          37158: // collect non "type type" parameters. The tp field of the name
        !          37159: // indicates the type of the formal parameter. 
        !          37160: void templ_compilation::collect(Pname n) 
        !          37161: {
        !          37162:   // The grammar alone should be sufficient to protect against undesirable
        !          37163:   // types. Any additional checks go here.
        !          37164:   n->n_template_arg = template_expr_formal ;
        !          37165:   append_parameter(n) ;
        !          37166: }
        !          37167:   
        !          37168: 
        !          37169: 
        !          37170: // validate the type for a non-type formal, and make it a const.
        !          37171: static void check_non_type_formal(Pname n) {
        !          37172: 
        !          37173:   switch (n->tp->base) {
        !          37174:   case ZTYPE:
        !          37175:   case CHAR:
        !          37176:   case SHORT:
        !          37177:   case INT:
        !          37178:   case LONG:
        !          37179:   case FLOAT:
        !          37180:   case DOUBLE:
        !          37181:   case FIELD:
        !          37182:   case EOBJ:
        !          37183:   case COBJ:
        !          37184:   case TYPE:
        !          37185:   case ANY:
        !          37186:     { // a basetype node
        !          37187:       TOK bad_base = 0 ;
        !          37188:       
        !          37189:       if (Pbase(n->tp)->b_volatile)
        !          37190:        bad_base = VOLATILE ;
        !          37191:       if (Pbase(n->tp)->b_typedef)
        !          37192:        bad_base = TYPEDEF ;
        !          37193:       if (Pbase(n->tp)->b_inline)
        !          37194:        bad_base = INLINE ;
        !          37195:       if (Pbase(n->tp)->b_virtual)
        !          37196:        bad_base = VIRTUAL ;
        !          37197:       if (bad_base)
        !          37198:        error ("bad %k declarator forY formal %n", bad_base,n);
        !          37199:       
        !          37200:       Pbase b = new basetype(0, 0) ;
        !          37201:       *b= *Pbase(n->tp) ;
        !          37202:       b->b_const = 1 ;
        !          37203:       n->tp = b ;
        !          37204:       break  ;
        !          37205:     }
        !          37206:   case PTR:
        !          37207:     { Pptr b = new ptr(0,0) ;
        !          37208:       *b = *Pptr(n->tp) ;
        !          37209:       
        !          37210:       b->rdo = 1;
        !          37211:       n->tp = b ;
        !          37212:       break ;
        !          37213:     }
        !          37214:   case RPTR:
        !          37215:   case VEC:
        !          37216:     break;             // constant by definition
        !          37217:   default:
        !          37218:     error ("badZT %t for formalZ %n", n->tp, n);
        !          37219:   }
        !          37220:   return ;
        !          37221: }
        !          37222:                
        !          37223: 
        !          37224: 
        !          37225: // The template parameters if any, have been parsed. Member function templates
        !          37226: // may choose to default their template arguments to the class arguments, if
        !          37227: // so, make the defaulting happen.
        !          37228: void templ_compilation::enter_parameters()
        !          37229: {
        !          37230:   for (Plist list = params ; list ; list = list->l) {
        !          37231:     Pname n = list->f ;
        !          37232:     switch(n->n_template_arg) {
        !          37233:     case template_type_formal:
        !          37234:       // Set them up for restoration
        !          37235:       modified_tn = new name_list(n,modified_tn);
        !          37236:       // Bring the names out of hiding
        !          37237:       n->n_key = 0 ;
        !          37238:       break ;
        !          37239:     case template_expr_formal:
        !          37240:       check_non_type_formal(n) ;
        !          37241:       n->tp->dcl(gtbl) ;
        !          37242:       break ;
        !          37243:     case template_expr_tree_formal:
        !          37244:     case template_stmt_tree_formal:
        !          37245:       // simply note it, the guts of the processing takes place when the
        !          37246:       // copy of the syntax tree is generated.
        !          37247:       break ;
        !          37248:     default:
        !          37249:       error ('i', "badY formal" ) ;
        !          37250:     }
        !          37251:   }
        !          37252:   // Save away the list of modified_tn, since the body processing will clobber
        !          37253:   // it.
        !          37254:   param_tn = modified_tn ;
        !          37255:   modified_tn = 0 ;
        !          37256: }
        !          37257: 
        !          37258: 
        !          37259: 
        !          37260: // Resolve the forward declaration of a template to its true definition. The
        !          37261: // template and class type data structures must be reused, since there may be
        !          37262: // outstanding references to them.
        !          37263: void templ::resolve_forward_decl(Plist params, Pclass c) {
        !          37264:   check_formals(params) ; 
        !          37265:   formals = params ;
        !          37266:   defined = true ;
        !          37267:   definition_number = ++ definition_tick ;
        !          37268:   members = c->mem_list ;
        !          37269: }
        !          37270: 
        !          37271: void templ::instantiate_forward_decl() {
        !          37272:   for (Ptempl_inst i = insts ; i ; i = i->next)
        !          37273:     if (Ptclass(Pbase(i->tname->tp)->b_name->tp)->class_base ==
        !          37274:        instantiated_template_class &&
        !          37275:        ! i->forward)
        !          37276:       { // reinstantiate it
        !          37277:        i->instantiate(true) ;
        !          37278:       }
        !          37279: }
        !          37280: 
        !          37281:   
        !          37282: 
        !          37283: // verify thet the qualifier used to declare the member function matches the
        !          37284: // template arguments in name, ie.
        !          37285: // template <class P, class Q, ..> c<P,Q,..>::member_function() {}
        !          37286: // match it's Ps and Qs.
        !          37287: bool templ_inst::check_qualifier(Plist formals)
        !          37288: {
        !          37289:   Pexpr actual = actuals ;
        !          37290:   for (Plist formal = formals ; formal && actual ; formal = formal->l,
        !          37291:        actual = actual->e2)
        !          37292:     
        !          37293:     switch (formal->f->n_template_arg) {
        !          37294:       
        !          37295:     case template_type_formal:
        !          37296:       { Pbase b = Pbase(actual->e1->tp) ;
        !          37297:        
        !          37298:        if (! ((b->base == TYPE) &&
        !          37299:               (b->b_name->base == TNAME) &&
        !          37300:               (strcmp (Pname(b->b_name)->string, formal->f->string) == 0)))
        !          37301:          return false ;
        !          37302:        break ;
        !          37303:       }
        !          37304:       
        !          37305:     case template_expr_formal:
        !          37306:       if (! ((actual->e1->base == NAME) &&
        !          37307:             (strcmp(Pname(actual->e1)->string, formal->f->string) == 0)))
        !          37308:        return false ;
        !          37309:       break ;
        !          37310:       
        !          37311:     case template_expr_tree_formal:
        !          37312:     case template_stmt_tree_formal:
        !          37313:     default:
        !          37314:       error ('i',"badY formal") ;
        !          37315:     }
        !          37316: 
        !          37317:   return true ;
        !          37318: }
        !          37319: 
        !          37320: 
        !          37321: // make the class template visible when compiling the template class
        !          37322: // defintion, so that it can be refernced while compiling the class body.
        !          37323: void templ_compilation::introduce_class_templ(Pname namep)
        !          37324: {
        !          37325:   owner = is_template(namep) ;
        !          37326:   // create a template definition if one did not already exist, due to a
        !          37327:   // forward declaration
        !          37328:   if (!owner){
        !          37329:     owner = new templ(params, namep) ;
        !          37330:     Pname lookup_name = templp->templates->insert(new name(namep->string), 0);
        !          37331:     lookup_name->tp = Ptype(owner) ;  // lie, to permit use of the table
        !          37332:   }
        !          37333: }
        !          37334:                            
        !          37335:                            
        !          37336: // The body of the template has been parsed. Finish the definition of the
        !          37337: // template class. 
        !          37338: void templ_compilation::end(Pname p) 
        !          37339: {
        !          37340:   bool forward_definition = false ;
        !          37341:   // Restore the name environment to the state before the template parameters
        !          37342:   // were processed.
        !          37343:   modified_tn = param_tn ;
        !          37344:   restore() ;
        !          37345:   modified_tn = 0 ;
        !          37346: 
        !          37347:   if (curr_tree_template) {
        !          37348:     // create an expression template
        !          37349:     new tree_template(curr_tree_template,
        !          37350:                      p->string, params, p->n_initializer, templ_refs) ;
        !          37351:   }else {
        !          37352:     if (!p->tp) {
        !          37353:       error ("aC, orMF definition wasX") ;
        !          37354:       return ;
        !          37355:     }
        !          37356:     switch(p->tp->base){
        !          37357:       
        !          37358:     case CLASS:
        !          37359:       // Create the template type to represent the parsed template, and enter it
        !          37360:       // into the global table. This is achieved simply by modifying the TNAME
        !          37361:       // that was entered into ktbl to represent the class definition.
        !          37362:       Pname namep = ktbl->look(p->string, 0) ;
        !          37363: 
        !          37364:       // check for nested definitions, they aren't supported currently. 2.1 is
        !          37365:       // a good time to start supporting them, since they are nested for real.
        !          37366:       for (Pname nn = Pclass(p->tp)->mem_list ; nn ; nn = nn->n_list)
        !          37367:        switch (nn->base) {
        !          37368:        case NAME:
        !          37369:          switch(nn->tp->base) {
        !          37370:          case CLASS:
        !          37371:            error("CD %s not permitted within a ZizedC", nn->string) ;
        !          37372:              break ;
        !          37373:            case ENUM:
        !          37374:              error("enumD %s not permitted within a ZizedC", nn->string) ;
        !          37375:              break ;
        !          37376:          }
        !          37377:          break ;
        !          37378:          
        !          37379:        case TNAME:
        !          37380:          error("typedef %s not permitted within a ZizedC", nn->string) ;
        !          37381:          break ;
        !          37382:        }
        !          37383: 
        !          37384:       owner = is_template(namep);
        !          37385:       if (owner) {
        !          37386:        Pclass c = Pclass(owner->basetype()->b_name->tp) ;
        !          37387:        // ignore it, if it is a forward declaration following a real
        !          37388:        // definition
        !          37389:        if (owner->defined && (Pclass(p->tp)->mem_list != owner->members))
        !          37390:          error("YC %s multiply defined", p->string) ;
        !          37391: 
        !          37392:        forward_definition=bool((c->defined & DEF_SEEN) && (!owner->defined));
        !          37393:        if (forward_definition) owner->resolve_forward_decl(params, c) ;
        !          37394:       }else 
        !          37395:        // a forward declaration
        !          37396:        introduce_class_templ(namep) ;
        !          37397: 
        !          37398:       if (templ_refs) owner->templ_refs = templ_refs ;
        !          37399:       break ;
        !          37400:     
        !          37401:     case FCT:
        !          37402:       { Pname qual = p->n_qualifier ;
        !          37403:        // the function must belong to a declared template class
        !          37404:        if (! qual) {
        !          37405:          error('s', "onlyYMFs may beZized currently") ;
        !          37406:          return ;
        !          37407:        }
        !          37408:        if (qual->tp && (qual->tp->base == COBJ))
        !          37409:          switch (get_class_base(Pbase(qual->tp))) {
        !          37410:          case uninstantiated_template_class:
        !          37411:            owner = Ptclass(Pbase(qual->tp)->b_name->tp)->inst->def ;
        !          37412:            // verify that the formals specified, match the template formals
        !          37413:            // in name, note that the length was already matched when the
        !          37414:            // instantiation was generated.
        !          37415:            if (!get_template_class
        !          37416:                (Pbase(qual->tp))->inst->check_qualifier(params))
        !          37417:              error ("QrZs must match theY formals") ;
        !          37418:            break ;
        !          37419:          case template_class:
        !          37420:            // the template reference was without any of the formals
        !          37421:            owner = is_template(qual) ;
        !          37422:            if (! owner->has_tree_expr_formals())
        !          37423:              error('w',"Qr %n for %n must specifyYZs", qual, p) ;
        !          37424:            break ;
        !          37425:          default:
        !          37426:            error ("Qr %n for %n wasn't aYC", qual, p) ;
        !          37427:            return ;
        !          37428:          }
        !          37429:        Pfunt ft= owner->collect_function_member(p) ;
        !          37430:        if (! Pfct(p->tp)->body)
        !          37431:          error ("theYFM %n must have a body", p) ;
        !          37432:        ft->templ_refs = templ_refs ;
        !          37433:        ft->formals = params ;
        !          37434:        owner->check_formals(params) ;
        !          37435:        break ;
        !          37436:       }
        !          37437:     default: error ("C, or MF definitionX.") ;
        !          37438:     }
        !          37439:   }
        !          37440:   // Note the template references from this definition
        !          37441: 
        !          37442:   clear_ref_templ() ;
        !          37443:   param_end = params = 0;  // Indicates the end of template processing.
        !          37444:   curr_tree_template = 0 ;
        !          37445: 
        !          37446:   if (forward_definition) owner->instantiate_forward_decl() ;
        !          37447:   owner = 0 ;
        !          37448: }
        !          37449: 
        !          37450: 
        !          37451:                                     
        !          37452: 
        !          37453: // Clear the list of templates referenced during the syntax analysis of a top
        !          37454: // level definition. Note that since this list is produced during syntax
        !          37455: // analysis, it does not recognize instantiations that may actualy turn out to
        !          37456: // be identical at instantiation after the substitution of actual parameters.
        !          37457: // Thus, the list may be longer than it would be after actual argument
        !          37458: // substitution. 
        !          37459: void templ_compilation::clear_ref_templ() {
        !          37460:   for (Pcons p = templ_refs ; p ; p = p->cdr)
        !          37461:     Ptempl_inst(p->car)->refp = false ;
        !          37462:   templ_refs = 0 ; last_cons = 0 ;
        !          37463: }
        !          37464: 
        !          37465: 
        !          37466: // Instantiate templates that were referenced by a non-template definition,
        !          37467: // after syntax analysis has been completed on it.
        !          37468: void templ_compilation::instantiate_ref_templ() {
        !          37469:   for (Pcons p = templ_refs ; p ; p = p->cdr)
        !          37470:     Ptempl_inst(p->car)->instantiate() ;
        !          37471:   clear_ref_templ() ;
        !          37472: }
        !          37473: 
        !          37474: 
        !          37475: 
        !          37476: 
        !          37477: // Compile all template member body instantiations. Set in motion the
        !          37478: // compilation of the graph of instantiation bodies. Note that compilation of
        !          37479: // a body may in turn initiate the instantiation of templates that had not
        !          37480: // previously been instantiated.
        !          37481: void templ_compilation::end_of_compilation() {
        !          37482:   bool change = false ;
        !          37483:   do {
        !          37484:     change = false ;
        !          37485:     for (Ptempl p = list ; p ; p = p->next)
        !          37486:       change = ( change | p->instantiate_bodies() ? true : false);
        !          37487:   } while (change) ;
        !          37488: }
        !          37489: 
        !          37490: 
        !          37491: // A predicate to validate that a tname without template parameters is legit
        !          37492: // in the scope, ie. that it does not need actual template arguments.
        !          37493: // Currently, a tname without parameters is ok within the class definition,
        !          37494: // but parameters are required within the member definition. They should not
        !          37495: // be required within the member function either to be consonance with their
        !          37496: // use in the class definition.
        !          37497: Pname templ_compilation::check_tname(Pname p) {
        !          37498:   Ptempl t = is_template(p) ;
        !          37499: 
        !          37500:   if (p->n_template_arg) p->n_used++ ;
        !          37501:   if (!t) return p ;
        !          37502:   if (in_progress && ((owner && (owner->namep == p)) ||
        !          37503:                      (!owner && t->basetype()->b_name->tp == ccl)))
        !          37504:      return p ;
        !          37505:   error ("%n needs Y instantiationAs.", p) ;
        !          37506:   return p ;
        !          37507: }
        !          37508: 
        !          37509: 
        !          37510: // This function determine when the parameters specified to a template are
        !          37511: // redundant, and really refer to the current template class. Thus,
        !          37512: //
        !          37513: // template c<class p1, class p2> c<p1,p2>::foo { ... } ;
        !          37514: // has the redundant template specification c<p1, p2> and can simply be a
        !          37515: // reference to a "c" instead, 
        !          37516: bool templ_compilation::current_template(Pname p, Pexpr actuals) {
        !          37517:   if (in_progress &&
        !          37518:       ((owner  && (owner->namep == p)) ||
        !          37519:        (!owner && ((p->tp->base == COBJ) &&
        !          37520:                   (Pbase(p->tp)->b_name->tp == ccl)))))
        !          37521:     { // Check whether the formal and actual types are identical
        !          37522:       Pexpr actual = actuals;
        !          37523:       for (Plist formal = params ; formal && actual ; formal = formal->l,
        !          37524:           actual = actual->e2)
        !          37525:        if ((formal->f->tp == actual->e1->tp) || 
        !          37526:            ((actual->e1->tp && (actual->e1->tp->base == TYPE)) &&
        !          37527:             (Pbase(actual->e1->tp)->b_name->tp == formal->f->tp)))
        !          37528:          continue ;
        !          37529:        else break ;
        !          37530:       if (!formal && !actual) return true ;
        !          37531:     }
        !          37532:   return false ;
        !          37533: }
        !          37534:   
        !          37535:   
        !          37536:        
        !          37537: // Add a new member function to the list of functions for the template class.
        !          37538: Pfunt templ::collect_function_member(Pname fname) {
        !          37539:   PERM(fname) ; PERM(fname->tp) ; PERM(Pfct(fname->tp)->body) ;
        !          37540:   return new function_template (*this, templp->params, fname) ;
        !          37541: }
        !          37542: 
        !          37543: 
        !          37544: // Check the formals specified for a member function or a forward definition
        !          37545: // of a class, against the formals for the class.
        !          37546: void basic_template::check_formals(Plist f2) {
        !          37547:   
        !          37548:   for (Plist f1 = formals; f1 && f2 ; f1 = f1->l, f2 = f2->l)
        !          37549:     if (f1->f->base != f2->f->base) 
        !          37550:       switch (f1->f->n_template_arg) {
        !          37551:       case template_type_formal:
        !          37552:        error ("Y formalZ mismatch,\
        !          37553: %n must be a type formal parameter.", f2->f) ;
        !          37554:        break ;
        !          37555:       case template_expr_formal:
        !          37556:        error ("formalZ mismatch, %n must be aZ ofT %t",
        !          37557:               f2->f, f2->f->tp) ;
        !          37558:        break ;
        !          37559:       case template_expr_tree_formal:  
        !          37560:       case template_stmt_tree_formal:
        !          37561:        error ("formalZ mismatch, %n must be anE formalZ",
        !          37562:               f2->f) ;
        !          37563:        break ;
        !          37564:       default:
        !          37565:        error ("formalZ mismatch betweenC formal: %n andM formal: %n", f1->f, f2->f) ;
        !          37566:       }else if (f1->f->n_template_arg == template_expr_formal) {
        !          37567:        // the types should be identical
        !          37568:        if (f1->f->tp->check(f2->f->tp, 0) == 1)
        !          37569:          error ("type mismatch betweenM formal %n, andC formal %n", f2->f, f1->f) ;
        !          37570:       }
        !          37571:   if (f1)
        !          37572:     error ("insufficient formalZs,CZ parameter %n onwards are missing", f1->f) ;
        !          37573:   if (f2)
        !          37574:     error ("excess formalZs,Z %n onwards not defined forC", f2->f) ;
        !          37575:   
        !          37576: }
        !          37577: 
        !          37578: // predicate to determine whether the template has expression tree formals
        !          37579: bool templ::has_tree_expr_formals() {
        !          37580:   
        !          37581:   for (Plist formal= formals; formal ; formal = formal->l)
        !          37582:     if (formal->f->n_template_arg == template_expr_tree_formal)
        !          37583:       return true ;
        !          37584: 
        !          37585:   return false ;
        !          37586: }
        !          37587: 
        !          37588: 
        !          37589: // Check that those formals that require class actual arguments, due to their
        !          37590: // use in member function bodies get them.
        !          37591: bool basic_template::check_constraints(Pexpr actual)
        !          37592: 
        !          37593: {
        !          37594:   bool ret = true ;
        !          37595:   
        !          37596:   for (Plist formal = formals ; formal && actual ; formal = formal->l,
        !          37597:        actual = actual->e2)
        !          37598:     if ((formal->f->n_template_arg == template_type_formal) &&
        !          37599:        formal->f->n_template_formal_must_be_class) {
        !          37600: 
        !          37601:          Pname n = Pname(actual->e1) ;
        !          37602: 
        !          37603:          if (n && n->tp && n->tp->is_cl_obj())
        !          37604:            continue ;
        !          37605:          error("expected aCT actual, not %t, for the \"TT\" formal %s",
        !          37606:                n->tp, formal->f->string);
        !          37607:          ret = false ;
        !          37608:        }
        !          37609:   return ret ;
        !          37610: }
        !          37611: 
        !          37612: 
        !          37613: // Check actual template arguments, against the formals.
        !          37614: bool templ::check_actual_args(Pexpr actual)
        !          37615: {
        !          37616:   for (Plist formal = formals ; formal && actual ; formal = formal->l,
        !          37617:        actual = actual->e2)
        !          37618:     switch (formal->f->n_template_arg) {
        !          37619:     case template_type_formal:
        !          37620:       {
        !          37621:        // A "type type" parameter, any actual type that was accepted by the
        !          37622:        // parse is acceptable here, just make sure that it is indeed a type.
        !          37623:        // If it was parsed as a type, the grammar should have created a name
        !          37624:        // node, and attached the type to it, having marked the name as a
        !          37625:        // template_actual_arg_dummy.
        !          37626: 
        !          37627:        Pname n = Pname(actual->e1) ;
        !          37628:        
        !          37629:        if (!((n->base == NAME) &&
        !          37630:            (n->n_template_arg == template_actual_arg_dummy))) {
        !          37631:          error ("Y %s A mismatch, the Y formal:%n\
        !          37632:  required aT actualZ.", namep->string, formal->f) ;
        !          37633:          // recover from the error with a safe expression
        !          37634:          n = new name("") ;
        !          37635:          n->tp = any_type ;
        !          37636:          actual->e1 = n ;
        !          37637:        }
        !          37638:        if ((formal->f->n_template_formal_must_be_class) &&
        !          37639:            !(n->tp && n->tp->is_cl_obj()))
        !          37640:          error("expected aCT actual, not %t, for the \"TT\" formal %s",
        !          37641:                n->tp, formal->f->string) ;
        !          37642:        break ;
        !          37643:       }
        !          37644:     case template_expr_formal:
        !          37645:       // checking can only be done at instantiation, so postpone it 
        !          37646:       break ;
        !          37647:     case template_expr_tree_formal:
        !          37648:     case template_stmt_tree_formal:
        !          37649:       // anything is acceptable, it is a case of "implementor beware". Any
        !          37650:       // illegalities will only be detected when dcl processing takes place.
        !          37651:       break ;
        !          37652:     default:
        !          37653:       error ('i',"badY formal") ;
        !          37654:     }
        !          37655:   // If we provide for optionals, this is where the processing should get done.
        !          37656:   if (formal)
        !          37657:     error ("too fewAs supplied forY %s", namep->string) ;
        !          37658:   if (actual && actual->e1) {
        !          37659:     error ("too manyAs supplied forY %s", namep->string) ;
        !          37660:   }
        !          37661:   return bool(~(formal || actual)) ;
        !          37662: }
        !          37663: 
        !          37664: 
        !          37665: 
        !          37666: 
        !          37667: // Append to the list of references.
        !          37668: void templ_compilation::append_ref(Ptempl_inst ref) 
        !          37669: { cons *p = new cons(ref,0) ;
        !          37670:   if (last_cons)
        !          37671:     last_cons->cdr = p ;
        !          37672:   else templ_refs =  p ;
        !          37673:   last_cons = p ;
        !          37674: } ;
        !          37675: 
        !          37676: 
        !          37677: // Note the reference by a definition to the template, so that the template
        !          37678: // can be instantiated before the definition is processed. 
        !          37679: Ptempl_inst templ_inst::note_ref() 
        !          37680: {  if ((! refp)) {
        !          37681:     refp = true ;
        !          37682:     templp->append_ref(this) ;
        !          37683:   }
        !          37684:   return this ;
        !          37685: }
        !          37686:   
        !          37687:            
        !          37688:            
        !          37689: // Get an instantiation for the template with the given set of actuals. If one
        !          37690: // exists, return it, otherwise create a new one. 
        !          37691: Ptempl_inst templ::get_inst(Pexpr actuals, Ptempl_inst exclude)
        !          37692: { Ptempl_inst inst = get_match(actuals, exclude, false) ;
        !          37693:   
        !          37694:   return (inst ? inst : new templ_inst(actuals, this))->note_ref() ;
        !          37695: }
        !          37696: 
        !          37697: 
        !          37698: // Find an instantiation that has the same set of actuals, exclude the
        !          37699: // instantaition passed in from the set of candidates
        !          37700: Ptempl_inst templ::get_match(Pexpr actuals,       
        !          37701:                             Ptempl_inst exclude,  // don't match this one
        !          37702:                             // Only instantiated templates match
        !          37703:                             bool match_instantiated_only)    
        !          37704: {  
        !          37705:   for (Ptempl_inst p = insts ; p ; p = p->next)
        !          37706:     if ((p != exclude) &&
        !          37707:        (p->actuals_match(actuals)) &&
        !          37708:        (match_instantiated_only ?
        !          37709:         (Pclass(Pbase(p->tname->tp)->b_name->tp)->class_base ==
        !          37710:          instantiated_template_class)
        !          37711:         : true))
        !          37712:       return (p->forward ? p->forward : p) ;
        !          37713:   return NULL ;
        !          37714: }
        !          37715: 
        !          37716: 
        !          37717: // provides the basetype created for a given set of actuals.
        !          37718: Pbase templ::inst_basetype(Pexpr actuals)
        !          37719: {
        !          37720:   return (check_actual_args(actuals) ?
        !          37721:          Pbase(get_inst(actuals)->tname->tp) : basep) ;
        !          37722: }
        !          37723: 
        !          37724: 
        !          37725: // Validate that the name denotes a parametrized type, and prodouce a TNAME
        !          37726: // for the instantiation.
        !          37727: Pname parametrized_typename (Pname p, Pexpr actuals) 
        !          37728: { 
        !          37729:   Ptempl t = templp->is_template(p) ;
        !          37730:   // A template instantiation with redundant actuals identical to the formals
        !          37731:   // of the current template
        !          37732:   if (templp->current_template(p, actuals)) return p ;
        !          37733:   if (t) {
        !          37734:     Pname tname = t->typename(actuals)  ;
        !          37735:     return (tname ? tname : p) ;
        !          37736:   }
        !          37737:   error ("%n hasTAs but is not aZizedC", p) ;
        !          37738:   return p ;
        !          37739: }
        !          37740: 
        !          37741: 
        !          37742: Pbase parametrized_basetype (Pname p, Pexpr actuals) 
        !          37743: { Ptempl t = templp->is_template(p) ;
        !          37744:   // A template instantiation with redundant actuals identical to the formals
        !          37745:   // of the current template 
        !          37746:   if (templp->current_template(p, actuals)) return Pbase(p->tp) ;
        !          37747:   if (t) return t->inst_basetype(actuals) ;
        !          37748:   error ("%n is not aZizedC", p) ;
        !          37749:   return new basetype(TYPE, p);
        !          37750: }
        !          37751: 
        !          37752: 
        !          37753: // Similar primitive for obtaining the typename associated with an
        !          37754: // instantiation. 
        !          37755: Pname templ::typename(Pexpr actuals) 
        !          37756: {
        !          37757:   return (check_actual_args(actuals) ? get_inst(actuals)->tname : 0) ;
        !          37758: }
        !          37759: 
        !          37760: // predicate to get past all the type nodes
        !          37761: static Ptype real_type (Ptype t)
        !          37762: {
        !          37763:   while (t->base == TYPE) t = Pbase(t)->b_name->tp ;
        !          37764:   return t ;
        !          37765: }
        !          37766: 
        !          37767: static int expr_match(Pexpr a1, Pexpr a2) ;
        !          37768: 
        !          37769: // Check whether the actuals provided match the actuals for this instantiation.
        !          37770: // The actuals match the formals, iff they are the same type or parametrized
        !          37771: // type. 
        !          37772: bool templ_inst::actuals_match(Pexpr check_actuals)
        !          37773: { Pexpr ae1, ae2 ;     // the cons cells
        !          37774:   Plist formal = def->formals ;
        !          37775:   
        !          37776:   // The lists should be the same length, since check_actuals will have taken
        !          37777:   // appropriate action.
        !          37778:   for (ae1=actuals, ae2=check_actuals ; formal && ae1 && ae2 ;
        !          37779:        ae1=ae1->e2, ae2=ae2->e2, formal = formal->l)
        !          37780: 
        !          37781:     switch (formal->f->n_template_arg) {
        !          37782:     
        !          37783:     case template_type_formal:
        !          37784:       { Ptype t1 = ae1->e1->tp, t2 = ae2->e1->tp ;
        !          37785:        if (t1->check(t2,255) == 1)
        !          37786:          return false ;
        !          37787:        break ;
        !          37788:       }
        !          37789:     case template_expr_formal:
        !          37790:       if (! expr_match(ae1->e1, ae2->e1)) return false ;
        !          37791:       break ;
        !          37792:       
        !          37793:     case template_expr_tree_formal:
        !          37794:     case template_stmt_tree_formal:
        !          37795:       // these are internal instantiations and consequently never match
        !          37796:       return false ;
        !          37797:       
        !          37798:     default:
        !          37799:       error ('i', "bad template formal") ;
        !          37800:     }
        !          37801:   return true ;
        !          37802: }
        !          37803: 
        !          37804: 
        !          37805: extern char emode ;
        !          37806: 
        !          37807: 
        !          37808: // This set of overloaded fuctions are used to accumulate name strings 
        !          37809: void stradd(char *&target, char *source) {
        !          37810:   while (*target++ = *source++) ;
        !          37811:   target-- ;
        !          37812: }
        !          37813:        
        !          37814: void stradd(char *&p, long i) {
        !          37815:   if (!emode) {
        !          37816:     *p++ = 'L' ;
        !          37817:   }
        !          37818:   char s[16] ;
        !          37819:   
        !          37820:   sprintf(s,"%ld", i) ;
        !          37821:   stradd(p,s) ;
        !          37822: }
        !          37823: 
        !          37824: void stradd(char *&p, Pname n) {
        !          37825:   if (!emode){
        !          37826:     char s[256] ;
        !          37827:     
        !          37828:     sprintf(s,"%d", strlen(n->string)) ;
        !          37829:     stradd(p,s) ;
        !          37830:   }
        !          37831:   stradd(p, n->string) ;
        !          37832: }
        !          37833: 
        !          37834:     
        !          37835: 
        !          37836: // produce a unique string suitable for use within a name; if in emode ie.
        !          37837: // printing in the context of an error, print a pretty name instead.  
        !          37838: char * mangled_expr(char *p, Pexpr e, bool mangle_for_address = false)
        !          37839: {
        !          37840:   static int mangle_address = 0 ;
        !          37841:   if (e == 0) return p;
        !          37842: 
        !          37843:   switch (e->base) {
        !          37844:   case ADDROF:
        !          37845:   case G_ADDROF:
        !          37846:     // unary using e2
        !          37847:     // rely on the
        !          37848:     mangle_address++ ;
        !          37849:     p = mangled_expr(p, e->e2) ;
        !          37850:     mangle_address -- ;
        !          37851:     break ;
        !          37852:     
        !          37853:   case NAME:
        !          37854:     if (mangle_address || mangle_for_address)
        !          37855:       stradd(p, Pname(e)) ;
        !          37856:     else if (Pname(e)->n_evaluated)
        !          37857:       stradd(p, Pname(e)->n_val) ;
        !          37858:     else if (Pname(e)->n_initializer)
        !          37859:       p = mangled_expr(p, Pname(e)->n_initializer, mangle_for_address) ;
        !          37860:     else error ('i', "couldn't mangle %n", e) ;
        !          37861:     break ;
        !          37862:       
        !          37863:   case IVAL:
        !          37864:     stradd(p, ((ival *)e)->i1) ;
        !          37865:     break ;
        !          37866: 
        !          37867:   case CAST:
        !          37868:     { // an IVAL hiding below the cast ?
        !          37869:       if (e->e1->base == IVAL) 
        !          37870:        stradd(p, ((ival *)e->e1)->i1) ;
        !          37871:       else error ('i', "unexpected cast") ;
        !          37872:       break ;
        !          37873:     }
        !          37874:   case ICON:
        !          37875:   case CCON:
        !          37876:   case FCON:
        !          37877:     *p++ = 'L' ;
        !          37878:     strcpy(p, e->string) ;
        !          37879:     // Sam: there needs to be a better encoding scheme, but it can wait.
        !          37880:     if (!emode)
        !          37881:       while (*p)
        !          37882:       if (! (isalnum(*p)))
        !          37883:        switch(*p) {
        !          37884:        case '+':
        !          37885:          *p++ = 'p' ;
        !          37886:          break ;
        !          37887:          
        !          37888:        case '-':
        !          37889:          *p++ = 'm' ;
        !          37890:          break ;
        !          37891: 
        !          37892:        case '.':
        !          37893:          *p++ = 'D' ;
        !          37894:          break ;
        !          37895: 
        !          37896:        case 'e':
        !          37897:          *p++ = 'E' ;
        !          37898:          break ;
        !          37899:        
        !          37900:        default:
        !          37901:          error ('i', "bad character in constant") ;
        !          37902:          break ;
        !          37903:        } else p++ ;
        !          37904:     break ;
        !          37905:     
        !          37906:   case ZERO:
        !          37907:     *p++ = '0' ;
        !          37908:     break ;
        !          37909:     
        !          37910:   default:
        !          37911:     error ('i', "can't mangle %k", e->base) ;
        !          37912:   }
        !          37913:   return p ;
        !          37914: }
        !          37915: 
        !          37916: // this function is invoked once at the top level
        !          37917: char *mangled_expr(char *p, Pname n) {
        !          37918:   if (n->n_evaluated) {
        !          37919:     stradd(p, n->n_val) ;
        !          37920:     return p ;
        !          37921:   }
        !          37922:   return mangled_expr(p, n->n_initializer,
        !          37923:                      (real_type(n->tp)->base == PTR ? true : false)) ;
        !          37924: }
        !          37925: 
        !          37926: // Generate a template instantiation name suitable for printing when it is
        !          37927: // presented to the user.
        !          37928: void templ_inst::print_pretty_name() 
        !          37929: {
        !          37930:   extern char emode ;
        !          37931:   
        !          37932:   fprintf(out_file, " %s<", (def->namep ? def->namep->string : "?")) ;
        !          37933:   Plist formal = inst_formals ;
        !          37934:   emode ++ ;  // so that dcl_print generates c++ rather than c names
        !          37935:   
        !          37936:   for (Pexpr ae1=actuals; formal && ae1  ; ae1=ae1->e2, formal = formal->l) {
        !          37937:     switch (formal->f->n_template_arg) {
        !          37938:     case template_type_formal:
        !          37939:       ae1->e1->tp->dcl_print(0) ;
        !          37940:       break ;
        !          37941:     case template_expr_formal:
        !          37942:       { char buff[256] ;
        !          37943:        
        !          37944:        mangled_expr(buff, ae1->e1) ;
        !          37945:        fprintf(out_file, "%s", buff) ;
        !          37946:        break ;
        !          37947:       }
        !          37948:     case template_expr_tree_formal:
        !          37949:     case template_stmt_tree_formal:
        !          37950:       // doesn't participate in the name generation
        !          37951:       break ;
        !          37952:     default:
        !          37953:       error ('i', "unexpected formal") ;
        !          37954:     }
        !          37955: 
        !          37956:     // this comma is unfortunately misplaced, since it follows a space printed
        !          37957:     // out by dcl_print
        !          37958:     if (formal->l) fprintf(out_file, ", ") ;
        !          37959:   }
        !          37960:   fprintf(out_file, ">") ;
        !          37961:   emode -- ;
        !          37962: }
        !          37963: 
        !          37964:        
        !          37965: 
        !          37966: // there are different representations for ICON based upon whether it has been
        !          37967: // evaluated. 
        !          37968: int check_for_const(Pexpr a1, Pexpr a2) {
        !          37969:   Neval = 0 ;
        !          37970:   if ((a1->base == NAME) &&
        !          37971:       ((a2->base == ICON) || (a2->base == IVAL) || (a2->base == ZERO)))
        !          37972:     { Pname n = Pname(a1) ;
        !          37973:       return (n->n_evaluated && (n->n_val == a2->eval())) ;
        !          37974:     }else if (((a1->base == ICON) || (a1->base == IVAL) || (a1->base == ZERO))
        !          37975:              && (a2->base == NAME))
        !          37976:       { Pname n = Pname(a2) ;
        !          37977:        return (n->n_evaluated && (n->n_val == a1->eval())) ;
        !          37978:       }
        !          37979:   return false ;
        !          37980: }
        !          37981:   
        !          37982: 
        !          37983: // get past the template parameter names to get the the real expression
        !          37984: static Pexpr real_expression(Pexpr e) 
        !          37985: {
        !          37986:   while (e && (e->base == NAME) &&
        !          37987:         (Pname(e)->n_template_arg == template_expr_formal) &&
        !          37988:         (! Pname(e)->n_evaluated) && Pname(e)->n_initializer)
        !          37989:     e = Pname(e)->n_initializer ;
        !          37990:   return e ;
        !          37991: }
        !          37992:         
        !          37993: 
        !          37994: // determine whether two expressions supplied as actual arguments to
        !          37995: // a "template_expr_formal"  formal argument match. 
        !          37996: static int expr_match(Pexpr a1, Pexpr a2)
        !          37997: {
        !          37998:   static int addr_of = 0 ;
        !          37999: 
        !          38000:   a1 = (addr_of ? a1 : real_expression(a1)) ;
        !          38001:   a2 = (addr_of ? a2 : real_expression(a2)) ;
        !          38002:   
        !          38003:   if (a1 == a2) return true;
        !          38004: 
        !          38005:   // 
        !          38006:   if (a1->base != a2->base) return check_for_const(a1, a2) ;
        !          38007:   
        !          38008:   switch (a1->base) {
        !          38009:   case QUEST:
        !          38010:     // a ternary operator
        !          38011:     return ( expr_match(a1->cond, a2->cond) &&
        !          38012:             expr_match(a1->e1, a2->e1) &&
        !          38013:             expr_match(a1->e2, a2->e2)) ;
        !          38014:   
        !          38015:   case PLUS: case MINUS: case MUL: case DIV: case MOD:
        !          38016:   case ER: case OR: case ANDAND: case OROR:
        !          38017:   case LS: case RS:
        !          38018:   case EQ: case NE: case LT: case LE: case GT: case GE:
        !          38019:     // binary operator
        !          38020:     return (expr_match(a1->e1, a2->e1) &&
        !          38021:             expr_match(a1->e2, a2->e2)) ;
        !          38022:   case UMINUS: case UPLUS:
        !          38023:   case NOT: case COMPL:
        !          38024:     return (expr_match(a1->e2, a2->e2)) ;
        !          38025:   case ADDROF:
        !          38026:     {
        !          38027:       // unary using e2
        !          38028:       addr_of ++ ;
        !          38029:       int result = (expr_match(a1->e2, a2->e2)) ;
        !          38030:       addr_of -- ;
        !          38031:       return result ;
        !          38032:     }
        !          38033:   case CAST:
        !          38034:     return (expr_match(a1->e1, a2->e1)) ;
        !          38035:   case NAME:
        !          38036:     if (! addr_of) {
        !          38037:       Pname n1 = Pname(a1), n2 = Pname(a2) ;
        !          38038: 
        !          38039:       if ((n1->n_evaluated) && n2->n_evaluated && (n1->n_val == n2->n_val))
        !          38040:        return true ;
        !          38041:       if (n1->n_initializer &&  (! n2->n_initializer))
        !          38042:        return check_for_const(n2, n1->n_initializer) ;
        !          38043:       if (n2->n_initializer && (! n1->n_initializer))
        !          38044:        return check_for_const(n1, n2->n_initializer) ;
        !          38045:       if (n1->n_initializer &&  n2->n_initializer)
        !          38046:        return expr_match(n1->n_initializer,  n2->n_initializer) ;
        !          38047:     }
        !          38048:     return false ;
        !          38049:   case DOT:
        !          38050:     return (expr_match(a1->e1, a2->e1)) ;
        !          38051:   case REF:
        !          38052:     return (expr_match(a1->e1, a2->e1)) ;
        !          38053:   case IVAL:
        !          38054:     return (ival *)a1->i1 == (ival *)a2->i1 ;
        !          38055:   case ICON:
        !          38056:   case CCON:
        !          38057:   case FCON:
        !          38058:   case STRING:
        !          38059:     return (strcmp (a1->string, a2->string) == 0) ;
        !          38060:   case ZERO:
        !          38061:     return true ;
        !          38062:   case SIZEOF:
        !          38063:     { long l1 = a1->eval(), l2 = a2->eval() ;
        !          38064:       return (l1 == l2) ;
        !          38065:     }
        !          38066:   }
        !          38067:   return false ;
        !          38068: }     
        !          38069: 
        !          38070: 
        !          38071: static char * non_type_argument_signature(Pexpr e, char *p) {
        !          38072:   p = e->tp->signature(p) ;
        !          38073:   return mangled_expr(p, e) ;
        !          38074: }
        !          38075:   
        !          38076: 
        !          38077: 
        !          38078: // generate array suffix information for an array signature. cfront does not
        !          38079: // normally generate this as part of the type signature, since it only deals
        !          38080: // with argument signatures, and arrays can't be arguments.
        !          38081: static void add_array_type_suffix(char *&s, Ptype t) {
        !          38082:   t = real_type(t) ;
        !          38083:   if (t->base == VEC) {
        !          38084:       Pvec v = Pvec(t);
        !          38085:       int dim;
        !          38086:       char a[32] ;
        !          38087:       Neval = 0 ;
        !          38088:       if(v->dim == 0) 
        !          38089:          dim = v->size / v->typ->tsizeof();
        !          38090:       else dim = (int)v->dim->eval();
        !          38091:     sprintf(a, "A%d", dim) ;
        !          38092:     stradd(s,a) ;
        !          38093:     add_array_type_suffix(s, Pvec(t)->typ);
        !          38094:   }
        !          38095: }
        !          38096:     
        !          38097:                           
        !          38098:                           
        !          38099: // Generate a mangled template instantiation name. The syntax of as template
        !          38100: // mangled class name is of the form:
        !          38101: //   original_name__<argument type signatures>__unique_id
        !          38102: // Each non-type argument is replaced by a unique id.
        !          38103: char *templ_inst::mangled_name(char *ip)
        !          38104: { static tree_formal_id = 0 ;
        !          38105:         
        !          38106:   char *start = ip ;
        !          38107:   ip = start ;
        !          38108:   strcpy(ip, (def->namep ? def->namep->string : "?")) ;
        !          38109:   ip= start + strlen(start) ;
        !          38110:   stradd(ip, "__pt__") ;
        !          38111: 
        !          38112:   {
        !          38113:     char  a [max_string_size], *p = a ;
        !          38114:   
        !          38115:     Plist formal = inst_formals ;
        !          38116:   
        !          38117:     for (Pexpr ae1=actuals ; ae1 ; ae1=ae1->e2, formal = formal->l)
        !          38118:       switch (formal->f->n_template_arg) {
        !          38119:       case template_expr_formal:
        !          38120:        *p++ = 'X' ;
        !          38121:        // the formal must have been bound
        !          38122:        p = non_type_argument_signature(formal->f, p) ;
        !          38123:        break ;
        !          38124:       
        !          38125:       case template_type_formal:  
        !          38126:        p = ae1->e1->tp->signature(p) ;
        !          38127:        add_array_type_suffix(p,ae1->e1->tp) ;
        !          38128:        break ;
        !          38129:       
        !          38130:       case template_expr_tree_formal:
        !          38131:       case template_stmt_tree_formal:
        !          38132:        *p++ = 'Y' ;
        !          38133:        stradd(p, tree_formal_id++) ; 
        !          38134:        break ;
        !          38135:       
        !          38136:       default:
        !          38137:        error ("bad template formal:%d", formal->f->base) ;
        !          38138:        break ;
        !          38139:       }
        !          38140:     
        !          38141:     *p = 0 ;
        !          38142:     sprintf(ip, "%d_", strlen(a)+1) ;
        !          38143:     ip = start + strlen(start) ;
        !          38144:     strcpy(ip,a) ;
        !          38145:   }
        !          38146:     
        !          38147:   return start ;
        !          38148: }
        !          38149: 
        !          38150: 
        !          38151: 
        !          38152: // The C compiler barfs when it is passed on through C++ as an automatic
        !          38153: // variable 
        !          38154: const char leader[]= "\t" ;
        !          38155: 
        !          38156: // Explain the location of an instantiation in greater detail, since it may be
        !          38157: // far removed from it's textual definition.
        !          38158: void templ_inst::print_error_loc() {
        !          38159:   if (! head) return ; // No active instantiations
        !          38160: 
        !          38161:   extern void print_loc() ;
        !          38162:   state current_state ;
        !          38163:   char buffer[max_string_size] ;
        !          38164: 
        !          38165:   for (int i = 0 ; i < max_string_size; i++) buffer[i] = 0 ;
        !          38166: 
        !          38167:   current_state.save() ;
        !          38168:   fprintf (out_file, "%sanomaly detected during the instantiation of",
        !          38169:           leader) ;
        !          38170:   print_pretty_name() ;
        !          38171:   fprintf(out_file, "\n") ;
        !          38172:   if (!head->next_active) {
        !          38173:     // A more compact message for a single level of instantiation
        !          38174:     context.restore() ;
        !          38175:     fprintf (out_file, leader) ;
        !          38176:     print_loc() ;    
        !          38177:     fprintf (out_file, "was the site of the instantiation\n") ; 
        !          38178:   }else {
        !          38179:     // The instantiation chain is longer than one
        !          38180:     fprintf (out_file, "%sthe instantiation path was:\n", leader) ;
        !          38181:     for (Ptempl_inst p = head ; p ; p = p->next_active) {
        !          38182:       p->context.restore() ;
        !          38183:       print_loc() ;
        !          38184:       fprintf (out_file, " template:") ;
        !          38185:       p->print_pretty_name() ;
        !          38186:       fprintf(out_file, "\n") ;
        !          38187:     }
        !          38188:   }
        !          38189:   current_state.restore() ;
        !          38190: }
        !          38191: 
        !          38192:   
        !          38193: 
        !          38194: // Generate a class name for the instantiated class. It is constructed in a
        !          38195: // manner similar to the names used in the construction of overloaded functions
        !          38196: char *templ_inst::instantiation_string() {
        !          38197:   char  inst_name[max_string_size] ;
        !          38198:   for (int i = 0 ; i < max_string_size; i++) inst_name[i] = 0 ;
        !          38199:   mangled_name(inst_name) ;
        !          38200:   return strdup(inst_name) ;
        !          38201: } 
        !          38202:   
        !          38203: 
        !          38204:     
        !          38205: // Change the names for the class, constructors, and destructors to reflect
        !          38206: // the new class instantiation name.
        !          38207: void classdef::modify_inst_names(char *s)
        !          38208: {
        !          38209:   char *old = string ;
        !          38210:   string = s ;   // Change the class name
        !          38211:   // Change the constructor names
        !          38212:   for (Pname p=mem_list; p; p=p->n_list)
        !          38213:     if (p->tp && (p->tp->base==FCT) && (!strcmp(old, p->string)))
        !          38214:       p->string = s ;
        !          38215: }
        !          38216: 
        !          38217: // Get past the fake template argument name typename types
        !          38218: Ptype non_template_arg_type(Pbase t) {
        !          38219:   if ((t->base == TYPE) &&
        !          38220:       (t->b_name->n_template_arg == template_type_formal))
        !          38221:     return non_template_arg_type(Pbase(t->b_name->tp)) ;
        !          38222:   else return t ;
        !          38223: }
        !          38224: 
        !          38225: // follow the chain until we hit a non
        !          38226: void non_template_arg_non_type(Pname n) {
        !          38227:   Pexpr i = n->n_initializer; 
        !          38228:   while (i &&
        !          38229:         (i->base == NAME) &&
        !          38230:         (Pname(i)->n_template_arg == template_expr_formal)) 
        !          38231:     {
        !          38232:       if (Pname(i)->n_initializer) {
        !          38233:        n->n_initializer = Pname(i)->n_initializer ;
        !          38234:        i = n->n_initializer ;
        !          38235:        continue ;
        !          38236:       }
        !          38237:       if (Pname(i)->n_evaluated) {
        !          38238:        n->n_evaluated = 1 ;
        !          38239:        n->n_val = Pname(i)->n_val ;
        !          38240:        return ;
        !          38241:       }
        !          38242:     }
        !          38243:   return ;
        !          38244: }
        !          38245:       
        !          38246: 
        !          38247: 
        !          38248: // Now that the actuals are truly resolved, ie. semantics is complete, and the
        !          38249: // template is about to be instantiated.
        !          38250: void forward_template_arg_types(Plist formal, Pexpr actuals)
        !          38251: {   
        !          38252:   for (Pexpr actual = actuals ; formal && actual ;
        !          38253:        formal = formal->l, actual = actual->e2)
        !          38254:     switch(formal->f->n_template_arg){
        !          38255:     case template_type_formal:
        !          38256:       actual->e1->tp = non_template_arg_type(Pbase(actual->e1->tp)) ;
        !          38257:       break ;
        !          38258:     case template_expr_formal:
        !          38259:       break ;
        !          38260:     case template_expr_tree_formal:
        !          38261:     case template_stmt_tree_formal:
        !          38262:       break ;
        !          38263:     default:
        !          38264:       error ('i', "bad template formal") ;
        !          38265:     }
        !          38266: }
        !          38267:      
        !          38268: // determine whether the expression supplied as an actual argument to
        !          38269: // atemplate formal of type "template_expr_formal" is suitable. We are nore
        !          38270: // restrictive than we need to be, simply so that the debugger can have an
        !          38271: // easier time. All expressions must be of the form constant integer
        !          38272: // expression, a float or double literal, or the address of a variable, or an
        !          38273: // array, or function
        !          38274: static int  suitable_const_expr(Pname n)
        !          38275: {
        !          38276:   if (n->n_evaluated) return 1 ;
        !          38277: 
        !          38278:   if (!n->n_initializer) return 0 ;
        !          38279: 
        !          38280:   switch (n->n_initializer->base) {
        !          38281: 
        !          38282:   case CAST:
        !          38283:     { // if it is a cast of an integer value, it's fine.
        !          38284:       if (n->n_initializer->e1->base == IVAL)
        !          38285:        return 1 ;
        !          38286:       else return 0 ;
        !          38287:     }
        !          38288:   
        !          38289:   case FCON:
        !          38290:   case ZERO:
        !          38291:     return 1  ;
        !          38292:   
        !          38293:   case ADDROF:
        !          38294:   case G_ADDROF:
        !          38295:     {
        !          38296:       Pname an = Pname(n->n_initializer->e2) ;
        !          38297:       if (an->base != NAME) return 0 ;
        !          38298:       if (an->n_stclass == STATIC) return 1 ;
        !          38299:       return 0 ;
        !          38300:     }
        !          38301:   case NAME:
        !          38302:     {
        !          38303:       Pname an = Pname(n->n_initializer) ;
        !          38304:       if ((an->n_stclass == STATIC) &&
        !          38305:          (an->tp->base == VEC))
        !          38306:        // assumes that decl processing won, so that the formal could only
        !          38307:        // have been apointer
        !          38308:        return 1 ;
        !          38309:       return 0 ;
        !          38310:     }
        !          38311:   default:
        !          38312:     return 0 ;
        !          38313:   }
        !          38314: }
        !          38315: 
        !          38316: 
        !          38317: 
        !          38318: static bool is_stmt_node(Pnode p) {
        !          38319:   if (!p) return false ;
        !          38320:   switch(p->base) {
        !          38321:   case BREAK: case CONTINUE: case DEFAULT:
        !          38322:   case SM: case WHILE: case DO: case SWITCH: case RETURN: case CASE:
        !          38323:   case FOR:
        !          38324:   case IF:
        !          38325:   case BLOCK:
        !          38326:   case PAIR: // ?
        !          38327:     return true ;
        !          38328:   }
        !          38329:   return false ;
        !          38330: }
        !          38331:        
        !          38332: 
        !          38333: 
        !          38334: static void bind_tree_expr_formal(Pname f, Pexpr actual) 
        !          38335: {
        !          38336:   if (actual->e1->base == TNAME)
        !          38337:     error ('i', "a TNAME is not a valid argument for the formal %n",
        !          38338:            f) ;
        !          38339:   if (is_stmt_node(actual->e1)) {
        !          38340:     error ("an expression node was expected for the expression formal parameter %n", f) ;
        !          38341:     actual->e1 = zero ;
        !          38342:   }
        !          38343:   // bind the formal to the expression, it will be accessed from here by
        !          38344:   // the hook function during the copy
        !          38345:   f->n_initializer = actual->e1 ;
        !          38346: }
        !          38347: 
        !          38348: 
        !          38349: 
        !          38350: // Bind the formals to the types passed in as the actuals, for the
        !          38351: // instantiation, bind the non-type names to their expressions.
        !          38352: void templ_inst::bind_formals()
        !          38353: { Pexpr actual ;
        !          38354:   Plist formal ;
        !          38355:   
        !          38356:   for (formal = inst_formals, actual = actuals ;
        !          38357:        formal && actual ; formal = formal->l, actual = actual->e2)
        !          38358:     switch (formal->f->n_template_arg) {
        !          38359:       case template_type_formal:
        !          38360:        {
        !          38361:          formal->f->tp = non_template_arg_type(Pbase(actual->e1->tp)) ;
        !          38362:          PERM(formal->f->tp) ;
        !          38363:          break ;
        !          38364:        }
        !          38365:        
        !          38366:       case template_expr_formal:
        !          38367:        {
        !          38368:          actual->e1 = actual->e1->typ(gtbl);
        !          38369:          if (formal->f->tp->check(actual->e1->tp,ASSIGN) == 1)
        !          38370:            error("template argument mismatch, expected %t for formal %n, not %t",
        !          38371:                  formal->f->tp, formal->f, actual->e1->tp) ;
        !          38372:          // hide the global name around decl processing of the formal name
        !          38373:          Pname g = gtbl->look (formal->f->string, 0) ;
        !          38374:          if (g) g->n_key = HIDDEN ;
        !          38375:          // bind the non type arguments to their expressions
        !          38376:          // parameters that are bound at syntax analysis, these parameters are
        !          38377:          // bound during dcl processing, so ensure that they can be found.
        !          38378:          formal->f->n_initializer = actual->e1 ;
        !          38379:          formal->f->simpl() ;
        !          38380:          formal->f = formal->f->dcl(gtbl, STATIC) ;
        !          38381:          formal->f->n_key = HIDDEN ;
        !          38382:          
        !          38383:          PERM(formal->f) ;
        !          38384:          non_template_arg_non_type(formal->f) ;
        !          38385:          if (!suitable_const_expr(formal->f))
        !          38386:              error("template argument for formal:%s, is not a suitable constant.",
        !          38387:                    formal->f->string) ;
        !          38388:          if (g) g->n_key = 0 ;
        !          38389:          break ;
        !          38390:        }
        !          38391:        
        !          38392:       case template_expr_tree_formal:
        !          38393:        {
        !          38394:          bind_tree_expr_formal(formal->f, actual) ;
        !          38395:          break ;
        !          38396:        }
        !          38397:       case template_stmt_tree_formal:
        !          38398:        { 
        !          38399:          error("a statement tree may not be specified for a class template") ;
        !          38400:          break ;
        !          38401:        }
        !          38402:        
        !          38403:       default:
        !          38404:        error ('i', "bad template formal") ;
        !          38405:       }
        !          38406:   
        !          38407:   // now that the formals are bound, compute the instantiation string
        !          38408:   char *inst_name = instantiation_string() ;
        !          38409:   tname->string = instantiation_string() ;
        !          38410: 
        !          38411:   for (formal = inst_formals; formal ; formal = formal->l)
        !          38412:     if (formal->f->n_template_arg_string)
        !          38413:        error('i', "attempt to bind a template parameter multiple times") ;
        !          38414:     else
        !          38415:       formal->f->n_template_arg_string =
        !          38416:        strcat(strcpy(calloc(strlen(formal->f->string)+strlen(inst_name)+1,1),
        !          38417:                      formal->f->string), inst_name) ;
        !          38418: }
        !          38419: 
        !          38420: 
        !          38421: // Expose the non-type parameter names so that they are visible during decl
        !          38422: // processing. Conflicting global names are hidden, so that they are not
        !          38423: // found.
        !          38424: void templ_inst::expose_parameter_names() {
        !          38425: 
        !          38426:   if (hidden_globals)
        !          38427:     error ('i', "an expose without a hide of global names") ;
        !          38428:   
        !          38429:   for (Plist formal = inst_formals ; formal  ; formal = formal->l)
        !          38430:     if (formal->f->n_template_arg == template_expr_formal) {
        !          38431:       // Hide any visible globals
        !          38432:       Pname gname = gtbl->look(formal->f->string, 0) ;
        !          38433:       if (gname) {
        !          38434:        // an existing global name, hide it
        !          38435:        gname->n_key = HIDDEN ;
        !          38436:        // note them for future restoration
        !          38437:        hidden_globals = new name_list(gname,hidden_globals);
        !          38438:       }
        !          38439:       formal->f->n_key = 0 ;   // bring it out of hiding
        !          38440:       if (formal->f != gtbl->look(formal->f->string,0))
        !          38441:        error('i', "parameter could not be located in the global table") ;
        !          38442:     }
        !          38443: }
        !          38444: 
        !          38445: 
        !          38446: // Hide the non-type parameter names after an instantiation, and restore any
        !          38447: // globals that may have been hidden during the process.
        !          38448: void templ_inst::hide_parameter_names() {
        !          38449:   
        !          38450:   for (Plist formal = inst_formals ; formal  ; formal = formal->l)
        !          38451:     if (formal->f->n_template_arg == template_expr_formal) {
        !          38452:       formal->f->n_key = HIDDEN ;
        !          38453:     }
        !          38454:   for (; hidden_globals; hidden_globals= hidden_globals->l)
        !          38455:     hidden_globals->f->n_key= 0 ;
        !          38456:   hidden_globals = 0 ;
        !          38457: }
        !          38458: 
        !          38459: 
        !          38460: 
        !          38461: // Primitives for saving and restoring the compilation state around a template
        !          38462: // instantiation. It also maintains the stack of template instantiations.
        !          38463: void templ_inst::save_state(Pname p)  {
        !          38464:   if (next_active) error ('i', "circular instantiation of a template") ;
        !          38465:   context.save() ;
        !          38466:   if (templ_inst::head)
        !          38467:     templ_inst::head->hide_parameter_names() ;
        !          38468:   next_active = templ_inst::head ; templ_inst::head = this ;
        !          38469:   context.init() ;
        !          38470:   Cdcl = p ; Cstmt = NULL ;
        !          38471:   curr_file = (Cdcl) ? Cdcl->where.file : 0;
        !          38472:   expose_parameter_names() ;
        !          38473: } 
        !          38474: 
        !          38475: 
        !          38476: void templ_inst::restore_state() {
        !          38477:   context.restore() ;
        !          38478:   hide_parameter_names() ;
        !          38479:   templ_inst::head = next_active ; next_active = NULL ;
        !          38480:   if (templ_inst::head)
        !          38481:     templ_inst::head->expose_parameter_names() ;
        !          38482: } 
        !          38483: 
        !          38484: 
        !          38485: // Copy over the class definition subtree starting from COBJ down to the
        !          38486: // CLASSDEF node. This minimal subtree has to exist during syntax analysis,
        !          38487: // and already contains pointers into it.
        !          38488: void templ_inst::kludge_copy(Pbase pbc)
        !          38489: {
        !          38490:   // copy just the COBJ ->b_name NAME ->tp CLASS path for now, note that the
        !          38491:   // preceding path of the tree is pre-allocated, since syntax analysis needs
        !          38492:   // to generate pointers to these objects.
        !          38493:   Pbase pb = Pbase(tname->tp) ;
        !          38494:   Pname save_b_name = pb->b_name ;
        !          38495:   Ptype save_tp = pb->b_name->tp ;
        !          38496: 
        !          38497:   if ((pb->base != COBJ) || (pbc->base != COBJ))
        !          38498:     error ('i', "cobj nodes were expected here") ;
        !          38499:   
        !          38500:   *pb = *pbc ;
        !          38501:   pb->b_name = save_b_name ;
        !          38502:   *pb->b_name = *pbc->b_name ;
        !          38503:   pb->b_name->tp = save_tp ;
        !          38504:   *Pclass(pb->b_name->tp) = *Pclass(pbc->b_name->tp) ;
        !          38505:   Pclass(pb->b_name->tp)->class_base = instantiated_template_class ;
        !          38506:   
        !          38507: }
        !          38508: 
        !          38509: 
        !          38510: // these statics probably belong in templ_inst and shouldn't be dangling
        !          38511: // around
        !          38512: 
        !          38513: static Pbase cobj_node ;
        !          38514: static Pname  cname_node ;
        !          38515: static Pclass class_node ;
        !          38516:             
        !          38517: static void syntax_tree_copy_hook(void *,
        !          38518:                             Pnode &,
        !          38519:                             node_class,
        !          38520:                             tree_node_action &action,
        !          38521:                             int& never_see_again)
        !          38522: {
        !          38523:   never_see_again = 1;
        !          38524:   action = tna_continue;
        !          38525:   return;
        !          38526: }
        !          38527: 
        !          38528: 
        !          38529: // create a copy of the expression tree
        !          38530: static Pnode copy_syntax_tree(Pnode n, int no_types = 0) {
        !          38531:   pointer_hash       cht(default_copy_hash_size) ;
        !          38532:     
        !          38533:   tree_copy_info  info ;
        !          38534: 
        !          38535:   if(no_types) info.node_hook = syntax_tree_copy_hook;
        !          38536: 
        !          38537:   copy_tree (n, info, &cht);
        !          38538: 
        !          38539:   return n ;
        !          38540: }
        !          38541:  
        !          38542: 
        !          38543: 
        !          38544: // hook to perform the copying of the pre-allocated class subtree
        !          38545: bool templ_inst::copy_hook(Pnode &node)
        !          38546: {
        !          38547:   switch (node->base) {
        !          38548:   case COBJ:
        !          38549:     if (node == cobj_node) return false ;
        !          38550:     
        !          38551:     if (node == def->namep->tp) {
        !          38552:       *cobj_node =  *Pbase(node) ;
        !          38553:       node = cobj_node ;
        !          38554:     }
        !          38555:     break ;
        !          38556:   case NAME:
        !          38557:     if (node == cname_node) return false ;
        !          38558:     if (node == sta_name) return false ;
        !          38559: 
        !          38560:     if (node == Pbase(def->namep->tp)->b_name) {
        !          38561:       *cname_node= *Pname(node) ;
        !          38562:       node = cname_node ;                
        !          38563:     }else { // check for tree expression formals
        !          38564:       char *s = Pname(node)->string ;
        !          38565:       Pname f =  0 ;
        !          38566:       if (s && (*s == '$') && (f = get_parameter(s+1)))
        !          38567:        {
        !          38568:          if(Pname(node)->n_list) 
        !          38569:            error ('i', "n_list set in tree template formal.");
        !          38570:          node = copy_syntax_tree(Pname(f)->n_initializer) ;
        !          38571:          return false ;
        !          38572:        }
        !          38573:     }
        !          38574:     break ;
        !          38575:   case CLASS:
        !          38576:     if (node == class_node) return false ;
        !          38577:     
        !          38578:     if (node == Pbase(def->namep->tp)->b_name->tp) {
        !          38579:       *class_node = *Pclass(node) ;
        !          38580:       node = class_node ;
        !          38581:     }
        !          38582:     break ;
        !          38583:   }
        !          38584:   return true ;
        !          38585: }
        !          38586: 
        !          38587: 
        !          38588: /*
        !          38589: 
        !          38590: This hook function used during a class copy.
        !          38591:                       
        !          38592: */
        !          38593: static void copy_hook(void /* Ptempl_inst */ *p, Pnode &node,
        !          38594:                      node_class, tree_node_action &action,
        !          38595:                      int& never_see_again)
        !          38596: {
        !          38597:   action = (Ptempl_inst(p)->copy_hook(node) ? tna_continue : tna_stop ) ;
        !          38598:   never_see_again = (action != tna_stop);
        !          38599:   return ;
        !          38600: }      
        !          38601: 
        !          38602:     
        !          38603:     
        !          38604: void establish_class_subtree_correspondence(pointer_hash &h, Pname key_tname,
        !          38605:                                            Pname value_tname) 
        !          38606: {
        !          38607:   h[int(key_tname)] = int(value_tname) ;
        !          38608:   h[int(key_tname->tp)] = int(value_tname->tp) ;
        !          38609:   h[int(Pbase(key_tname->tp)->b_name)] =
        !          38610:     int(Pbase(value_tname->tp)->b_name) ;
        !          38611:   h[int(Pbase(key_tname->tp)->b_name->tp)] =
        !          38612:     int(Pbase(value_tname->tp)->b_name->tp) ;
        !          38613: }
        !          38614: 
        !          38615: 
        !          38616: 
        !          38617: 
        !          38618: Pcons make_ref_copy(pointer_hash &h, tree_copy_info &info, Pcons old_templ_refs)
        !          38619: {
        !          38620:   cons dummy(0,0), *last = &dummy ;
        !          38621:   
        !          38622:   for (Pcons pc = old_templ_refs ; pc ; pc = pc->cdr) {
        !          38623:     
        !          38624:     Ptempl_inst t = Ptempl_inst(pc->car) ;
        !          38625: // +**** this doesn't work without class instances of new and delete
        !          38626: // +**** dtor places this onto free_list: ugh
        !          38627: // +**** want to restore this once new/delete isntances are restored
        !          38628: //    expr   dummy(ELIST, 0, 0) ;
        !          38629: //    elist  list(&dummy) ;
        !          38630:     Pexpr   dummy = new expr(ELIST, 0, 0);
        !          38631:     elist  list(dummy);
        !          38632: 
        !          38633:     // copy the trees corresponding to the actuals
        !          38634:     for (Pexpr actual = t->actuals ; actual ; actual = actual->e2) {
        !          38635:       Pnode root = actual->e1 ;
        !          38636:       copy_tree (root, info, &h);
        !          38637:       // make sure that references to enclosing formals are resolved
        !          38638:       root = Pexpr(root)->typ(gtbl);
        !          38639:       list.add(new expr(ELIST, Pexpr(root), 0)) ;
        !          38640:     }
        !          38641:     Pexpr new_actuals = list.head->e2 ;
        !          38642:     
        !          38643:     // get one if it exists, create one otherwise.
        !          38644:     Ptempl_inst  treal = t->def->get_inst(new_actuals, t) ;
        !          38645:     Pname new_tname = treal->tname ;
        !          38646:     
        !          38647:     last = last->cdr = new cons(treal,0);
        !          38648: 
        !          38649:     establish_class_subtree_correspondence(h, t->tname, new_tname) ;
        !          38650:   }
        !          38651: 
        !          38652:   return dummy.cdr ;
        !          38653: }
        !          38654: 
        !          38655: 
        !          38656: 
        !          38657: 
        !          38658: /*
        !          38659:    Remap the template references from within the body of the template. This
        !          38660: action is similar to the normal tree copy operation; it would normally have
        !          38661: been done during the syntax phase, that produced the tree, but since there
        !          38662: isn't one, for the instantiated body, it must be done here.
        !          38663: 
        !          38664: */                                          
        !          38665: Pcons templ_inst::ref_copy(pointer_hash &h, tree_copy_info &info, Pcons old_templ_refs)
        !          38666: {
        !          38667:   expose_parameter_names() ;
        !          38668:   Pcons new_refs = make_ref_copy(h,info,old_templ_refs) ;
        !          38669:   hide_parameter_names() ;
        !          38670:   return new_refs ;
        !          38671: }
        !          38672: 
        !          38673: static bool is_forward_instantiation(Pbase b_base, Pbase f_base)
        !          38674: {
        !          38675:   return bool(b_base->b_name->tp->defined && f_base->b_name->tp->defined) ;
        !          38676: }
        !          38677: 
        !          38678: 
        !          38679: /*****************************************************************************
        !          38680: *                                                                           *
        !          38681: * If the template instantiation is found to be unique after the decl        *
        !          38682: * processing of the actuals, create a copy of the post syntax graph for the  *
        !          38683: * class. The edges of the graph are determined by "type nodes" that have     *
        !          38684: * already been defined, and TNAME nodes that are in the global keyword      *
        !          38685: * table. Special care is also taken to avoid copying nodes whose identity    *
        !          38686: * must be maintained, since cfront uses them for fast type checks, these     *
        !          38687: * nodes always have the "defined" flag turned on and so are never copied.    *
        !          38688: *                                                                           *
        !          38689: * Copying of the pre-allocated class sub-tree for the template: COBJ        *
        !          38690: * ->b_name NAME ->tp CLASS                                                  *
        !          38691: *                                                                           *
        !          38692: * is handled by the class_copy hook above, that is invoked during the course *
        !          38693: * of the copy.                                                              *
        !          38694: *                                                                           *
        !          38695: *                                                                           *
        !          38696: * Template references from within the class need special handling, since     *
        !          38697: * each instantiation of the class, results in a potentially new template     *
        !          38698: * instantiation.                                                            *
        !          38699: *                                                                           *
        !          38700: *****************************************************************************/
        !          38701: Ptempl_inst  templ_inst::class_copy(Pcons &templ_refs, bool recopy) 
        !          38702: {
        !          38703:   bool forward = false ; // a forward class is instantiated twice
        !          38704:                
        !          38705:   // associate the formals with their types, and their expressions
        !          38706:   if (recopy) {
        !          38707:     // remove the class def node from the table, so that it's attributes are
        !          38708:     // copied. 
        !          38709:     corr->del(int(Pbase(def->namep->tp)->b_name->tp)) ;
        !          38710:     corr->del(int(Pbase(def->namep->tp)->b_name)) ;
        !          38711:     corr->del(int(def->namep->tp)) ;
        !          38712:     
        !          38713:     corr->del(int(tname->tp)) ;
        !          38714:     corr->del(int(Pbase(tname->tp)->b_name)) ;
        !          38715:     corr->del(int(Pbase(tname->tp)->b_name->tp)) ;
        !          38716:   }else corr = new pointer_hash(default_copy_hash_size) ;
        !          38717:   
        !          38718:   { // copy the formals & install them in the correspondence table
        !          38719:     name_list dummy_formal(0,0) ; 
        !          38720:     Plist last = &dummy_formal ;
        !          38721:       
        !          38722:     for (Plist formal = def->formals ; formal ; formal = formal->l) {
        !          38723:       Pname copy_name = new name("") ;
        !          38724:       *copy_name = *formal->f ;
        !          38725:       copy_name->n_tbl_list = 0 ;
        !          38726:       last = last->l = new name_list(copy_name, 0) ;
        !          38727:       (*corr)[int(formal->f)] = (int)copy_name ;
        !          38728:     }
        !          38729:     inst_formals = dummy_formal.l ;
        !          38730:   }
        !          38731:   
        !          38732:   bind_formals() ;
        !          38733:   if ( ! recopy && ktbl->look(tname->string, 0)) {    
        !          38734:     // formal binding may result in detecting identical instantiations
        !          38735:     Ptempl_inst ti = def->get_match(actuals, this, true) ;
        !          38736:     if (ti) return ti ;
        !          38737:     error('i', "Generated template instantiation name %swas not unique",
        !          38738:          tname->string) ;
        !          38739:   }
        !          38740:   
        !          38741:   { 
        !          38742:     tree_copy_info  info ;
        !          38743:     info.node_hook = ::copy_hook ;
        !          38744:     info.hook_info = this ;
        !          38745:     
        !          38746:     (*corr)[int(def->namep)] = int(tname) ; // make the tnames correspond
        !          38747:     
        !          38748:     templ_refs = ref_copy(*corr, info, templ_refs) ;
        !          38749:     Pnode root = def->basep ;  // start the copy at the cobj node
        !          38750: 
        !          38751:     // deal with these nodes differently during the copy, ie. the nodes
        !          38752:     // themselves are not copied, but their attributes are.
        !          38753:     cobj_node = (Pbase)tname->tp ;
        !          38754:     cname_node = Pbase( tname->tp)->b_name ;
        !          38755:     class_node = Pclass(Pbase( tname->tp)->b_name->tp) ;
        !          38756:     
        !          38757:     copy_tree (root, info, corr);
        !          38758: 
        !          38759:     {  // dump the tree if the flag is set
        !          38760:        extern int dump_tree ;
        !          38761:        extern dcn_arg dump_tree_arg;
        !          38762: 
        !          38763:        if (dump_tree) display_cfront_node (dump_tree_arg, root);
        !          38764:      }
        !          38765:   }
        !          38766:   // Perform name modifications for the class, so that it is an
        !          38767:   // instantiation-specific name.
        !          38768:   cname_node->string = tname->string ;
        !          38769:   if (!recopy)
        !          38770:     namep =  ktbl->insert(tname, 0) ;
        !          38771:   else class_node->defined &= ~(DEFINED|SIMPLIFIED) ;
        !          38772:   namep->tp = cobj_node;
        !          38773:     
        !          38774:   class_node->modify_inst_names(cname_node->string) ;
        !          38775:   return 0 ;
        !          38776: }
        !          38777: 
        !          38778: 
        !          38779: /*
        !          38780: This hook function is responsible for the replacement of references to
        !          38781: expression when copying function bodies
        !          38782: */
        !          38783: static void function_copy_hook(void *current_templ_inst,
        !          38784:                             Pnode &node,
        !          38785:                             node_class,
        !          38786:                             tree_node_action &action,
        !          38787:                               int& never_see_again)
        !          38788: {
        !          38789:   never_see_again = 1;
        !          38790: 
        !          38791:   switch (node->base) {
        !          38792:   case SM_PARAM:
        !          38793:     error ('i', "statement parameters not permitted for member functions") ;
        !          38794:     break ;
        !          38795:     
        !          38796:   case NAME:
        !          38797:     { 
        !          38798:       if(node == sta_name) {
        !          38799:          action = tna_stop;
        !          38800:          return;
        !          38801:       }
        !          38802:       char *s = Pname(node)->string ;
        !          38803:       Pname f =  0 ;
        !          38804:       if (s && (*s == '$') &&
        !          38805:          (f = Ptempl_inst(current_templ_inst)->get_parameter(s+1))) {
        !          38806:              if(Pname(node)->n_list) 
        !          38807:                  error ('i', "n_list set in tree template formal.");
        !          38808:              node = copy_syntax_tree(Pname(f)->n_initializer) ;
        !          38809:              action = tna_stop ;
        !          38810:              never_see_again = 0;
        !          38811:          }else action = tna_continue ;
        !          38812:       return ;
        !          38813:     }
        !          38814:   default:
        !          38815:     action = tna_continue ;
        !          38816:     return ;
        !          38817:   }
        !          38818: }
        !          38819: 
        !          38820: 
        !          38821: 
        !          38822: /* 
        !          38823: 
        !          38824: Create a copy of a function member, as part of the instantiation of a function
        !          38825: body. The correspondence table is first initialized with the contents of the
        !          38826: correspondence table used to instantiate the class. Copying is initiated
        !          38827: in this context.
        !          38828: 
        !          38829: */
        !          38830: 
        !          38831: Pname templ_inst::function_copy(Pfunt fnt, Pcons &templ_refs)
        !          38832: {
        !          38833:   pointer_hash fcorr(*corr) ; // initialize it with the old hash table
        !          38834:   
        !          38835:   {     
        !          38836:     tree_copy_info  info ;
        !          38837:     Pnode           root = fnt->fn ; 
        !          38838: 
        !          38839:     // establish a correspondence between the formals used for the class
        !          38840:     // template, andthe formals used for the function template, all references
        !          38841:     // to the function template formals will be replaced by references to the
        !          38842:     // instantiated class template formals after the copy has been completed.
        !          38843:     
        !          38844:     for (Plist fformal = fnt->formals, cformal = inst_formals ;
        !          38845:         fformal ; fformal = fformal->l, cformal = cformal->l)
        !          38846:       {
        !          38847:        fcorr[int(fformal->f)] = int(cformal->f) ;
        !          38848:        if (fcorr[int(fformal->f)] != int(cformal->f))
        !          38849:          error ('i', "hash table bug") ;
        !          38850:       }
        !          38851: 
        !          38852:     info.node_hook = ::function_copy_hook ;
        !          38853:     info.hook_info = this ;
        !          38854: 
        !          38855:     templ_refs = ref_copy(fcorr, info,  templ_refs) ;
        !          38856:     if (fcorr[int(def->namep)] != int(tname))
        !          38857:       error ('i', "template to instantiation typename correspondence is missing") ;
        !          38858:     
        !          38859:     copy_tree (root, info, &fcorr);
        !          38860: 
        !          38861:     {  // dump the tree if the flag is set
        !          38862:       extern int dump_tree ;
        !          38863:       extern dcn_arg dump_tree_arg;
        !          38864: 
        !          38865:       if (dump_tree)
        !          38866:        display_cfront_node (dump_tree_arg, root);
        !          38867:     }
        !          38868:     return Pname(root) ;
        !          38869:   }
        !          38870: }
        !          38871:   
        !          38872:      
        !          38873: /*****************************************************************************
        !          38874: *                                                                           *
        !          38875: * A matching template was found at instantiation time, which was not        *
        !          38876: * detected at syntax analysis time. This can happen, when an instantiation   *
        !          38877: * has as its arguments not real types but template arguments, so that       *
        !          38878: * matches cannot be detected until the templates are bound. Note that it is  *
        !          38879: * also possible to match a template that is in the process of being         *
        !          38880: * instantiated further up the instantiation call chain. In such cases, the   *
        !          38881: * kludge_copy operation will copy over an incomplete class subtree, which    *
        !          38882: * will be recopied with the completed one after the instantiation is        *
        !          38883: * completed, in templ_inst::instantiate.                                    *
        !          38884: *                                                                           *
        !          38885: *****************************************************************************/
        !          38886: void templ_inst::instantiate_match(Ptempl_inst match)
        !          38887: { Pbase pb = Pbase(match->tname->tp) ;
        !          38888:   kludge_copy(pb) ;
        !          38889:   forward = match ;            // Note the fact that this template was matched
        !          38890: }
        !          38891: 
        !          38892: 
        !          38893: Pclass current_instantiation = 0 ;
        !          38894: 
        !          38895: // Do the class declaration instantiation.
        !          38896: void templ_inst::instantiate(bool reinstantiate)
        !          38897: {
        !          38898:   Pcons templ_refs = def->templ_refs  ;
        !          38899:   if (! reinstantiate) {
        !          38900:     switch (Ptclass(Pbase(tname->tp)->b_name->tp)->class_base) {
        !          38901:     case instantiated_template_class: 
        !          38902:       return ;
        !          38903:     case uninstantiated_template_class: 
        !          38904:       break ;
        !          38905:     case vanilla_class:
        !          38906:     case template_class:               // the canonical template class
        !          38907:     default: 
        !          38908:       error ('i', "attempt to instantiate a non-template class") ;
        !          38909:     }
        !          38910:     status = class_instantiated ;
        !          38911:     // Check whether, the template has already been instantiated, if so use it.
        !          38912:     forward_template_arg_types(def->formals, actuals) ;
        !          38913:     Ptempl_inst match = def->get_match(actuals, this, true) ;
        !          38914:     
        !          38915:     if (match || (match = class_copy(templ_refs, false))){
        !          38916:       instantiate_match(match) ;
        !          38917:       return ;
        !          38918:     }
        !          38919:   }else class_copy(templ_refs, true) ;
        !          38920: 
        !          38921:   Pbase pb = Pbase(tname->tp) ;
        !          38922:   
        !          38923:   // Save the state around decl processing
        !          38924:   { save_state(def->namep) ;
        !          38925:     
        !          38926:     if (def->open_instantiations++ > 1) {
        !          38927:       error ("an infinite instantiation sequence was initiated") ;
        !          38928:       def->open_instantiations-- ;
        !          38929:       return ;
        !          38930:     }
        !          38931:     // Mark the class as instantiated so that there are no circular
        !          38932:     // instantiations. 
        !          38933:     Pclass(pb->b_name->tp)->class_base = instantiated_template_class ;
        !          38934: 
        !          38935:     // if it is a forward reference, rely on the usual compilation to
        !          38936:     // provide an error message, if indeed it is an error, and not a
        !          38937:     // benign forward reference such as: friend class foo<X,Y> 
        !          38938:          
        !          38939:     if (def->basep->b_name->tp->defined) {
        !          38940: 
        !          38941:       // Put out the typedefs for the template parameters do this before the
        !          38942:       // call to name::dcl below, since dcl processing will emit c declarations
        !          38943:       // that make use of the type
        !          38944:       for (Plist formal = inst_formals; formal ; formal = formal->l)
        !          38945:        switch(formal->f->n_template_arg) {
        !          38946:        case template_expr_tree_formal:
        !          38947:        case template_stmt_tree_formal:
        !          38948:          break ;
        !          38949:        default:
        !          38950:          formal->f->dcl_print(0) ;
        !          38951:        }
        !          38952:       // Instantiate the parametrized types referenced by this template
        !          38953:       for (Pcons pc = templ_refs ; pc ; pc = pc->cdr)
        !          38954:        Ptempl_inst(pc->car)->instantiate() ;
        !          38955:       
        !          38956:       if (!((pb->b_name->dcl(gtbl, EXTERN) == 0 ) || error_count)) {
        !          38957:        pb->b_name->simpl() ;
        !          38958:        
        !          38959:        if (pb->b_name->tp->base != CLASS)
        !          38960:          error('i', "a classdef was expected in templ_inst::instantiate") ;
        !          38961:        
        !          38962:        current_instantiation =  Pclass(pb->b_name->tp) ;
        !          38963:        pb->b_name->dcl_print(0) ;
        !          38964:        if (! (pb->b_name->tp->defined & DEFINED))
        !          38965:          error ('i', "dcl class is not yet defined") ;
        !          38966:        current_instantiation = 0 ;
        !          38967:       }
        !          38968:     }
        !          38969: 
        !          38970:     // bash every template instantiation class that has been forwarded to
        !          38971:     // it, with the decl processed version.
        !          38972:     for (Ptempl_inst clone = def->insts ; clone ; clone = clone->next)
        !          38973:       if (clone != this) {
        !          38974:        if (clone->forward == this)
        !          38975:          clone->kludge_copy(Pbase(tname->tp)) ;
        !          38976:        else {
        !          38977:          // resolve references to forward declarations
        !          38978:          if (this == def->get_match(clone->actuals, clone, true)) {
        !          38979:            clone->kludge_copy(Pbase(tname->tp)) ;
        !          38980:            clone->forward = this ;
        !          38981:          }
        !          38982:        }
        !          38983:       }
        !          38984:     Pclass result = Pclass(pb->b_name->tp);
        !          38985:       
        !          38986:     // dcl_print the member functions, so that they can be referenced
        !          38987:     int i = 0 ;
        !          38988:     for (Pname fn= Pclass(pb->b_name->tp)->memtbl->get_mem(i=1); fn;
        !          38989:         fn=Pclass(pb->b_name->tp)->memtbl->get_mem(++i))
        !          38990:       if ((fn->base == NAME) && (fn->tp->base == FCT))
        !          38991:        fn->dcl_print(0) ;
        !          38992:     
        !          38993:     restore_state() ;
        !          38994:     def->open_instantiations-- ;
        !          38995:   }
        !          38996: }
        !          38997: 
        !          38998: /* Template Constructors  */
        !          38999: 
        !          39000: 
        !          39001: templ::templ(Plist parms, Pname p) {
        !          39002:   namep   = p ;
        !          39003:   formals = parms ;
        !          39004: 
        !          39005:   if (!formals) error ("a parametrized type must have parameters !") ;
        !          39006: 
        !          39007:   basep   = Pbase(namep->tp) ;
        !          39008: 
        !          39009:   Pclass(basep->b_name->tp)->class_base = template_class ;
        !          39010:   defined = ((basep->b_name->tp->defined & DEF_SEEN) ? true : false) ;
        !          39011:   if (defined)
        !          39012:     members = Pclass(basep->b_name->tp)->mem_list ;
        !          39013:   
        !          39014:   PERM(namep) ; PERM(namep->tp) ;
        !          39015:   // Chain on to the list of templates for the compilation.
        !          39016:   next = templp->list ;
        !          39017:   templp->list = this ;
        !          39018: }
        !          39019: 
        !          39020: 
        !          39021: templ_inst::templ_inst (Pexpr act, Ptempl owner)
        !          39022: {
        !          39023:   // Set up the basetype for the class, so that nodes that need to point to it
        !          39024:   // during syntax processing can do so. Theese objects are merely
        !          39025:   // place-holders during syntax analysis, and are actually filled in during
        !          39026:   // the copy phase of instantiation.
        !          39027:   Pclass c ;
        !          39028:   
        !          39029:   def = owner ;
        !          39030:   tname = new name(def->namep->string) ;
        !          39031:   tname->base = TNAME ;
        !          39032:   tname->tp = new basetype(COBJ, new name(def->namep->string)) ;
        !          39033:   Pbase(tname->tp)->b_name->tp = c = new templ_classdef(this) ;
        !          39034:   PERM(tname) ; PERM(tname->tp) ; PERM(Pbase(tname->tp)->b_name) ;
        !          39035:   PERM(Pbase(tname->tp)->b_name->tp) ;
        !          39036: 
        !          39037:   // initialize the member list so that set_scope can do the right thing
        !          39038:   c->mem_list = Pclass(def->basetype()->b_name->tp)->mem_list ;
        !          39039:   
        !          39040:   actuals = act ;
        !          39041:   next = owner->insts ;
        !          39042:   owner->insts = this ;
        !          39043: }
        !          39044: 
        !          39045: 
        !          39046: templ_classdef::templ_classdef(Ptempl_inst i): classdef(CLASS) {
        !          39047:   inst = i ;
        !          39048:   class_base = uninstantiated_template_class ;
        !          39049:   string = unparametrized_tname()->string ;
        !          39050: }
        !          39051: 
        !          39052: 
        !          39053: // Create a new function template.
        !          39054: function_template::function_template (templ &owner, Plist params, Pname n)
        !          39055: {
        !          39056:   definition_number = ++definition_tick ;
        !          39057:                      
        !          39058:   if (owner.fns_end)
        !          39059:     owner.fns_end->next = this ;
        !          39060:   else owner.fns = this ;
        !          39061:   owner.fns_end = this ;
        !          39062:   formals   = params ;
        !          39063:   fn        = n ;
        !          39064:   PERM(n) ; PERM(n->tp) ;
        !          39065: }
        !          39066: 
        !          39067: 
        !          39068: // create the tree template
        !          39069: tree_template::tree_template(TOK tree_kind, char *s, Plist params, Pnode tree,
        !          39070:                             Pcons references) 
        !          39071: {
        !          39072:   string = s ;
        !          39073:   formals = params;
        !          39074:   e = tree ;
        !          39075:   if (!e)
        !          39076:     error('w', "the internal template %s does not have an associated body", s);
        !          39077:   templ_refs = references ;
        !          39078:   kind = tree_kind ;
        !          39079: 
        !          39080:   // add the expression template too the list of known templates
        !          39081:   if (get(s)) {
        !          39082:       error ("duplicate definition of the internal template %s", s) ;
        !          39083:       return ;
        !          39084:     }
        !          39085:   // link it in
        !          39086:   next = templ_compilation::tree_templates ;
        !          39087:   templ_compilation::tree_templates = this ;
        !          39088: 
        !          39089:   // check that formals weren't misspelt
        !          39090:   for (Plist formal = formals ; formal ; formal = formal->l)
        !          39091:     if (! formal->f->n_used)
        !          39092:       error('w', "the formal parameter %n was not referenced within the template body",formal->f) ;
        !          39093: }
        !          39094: 
        !          39095: 
        !          39096: // lookup an internal expression template
        !          39097: Ptreet tree_template::get(char *s) {
        !          39098:   for (Ptreet o = templ_compilation::tree_templates ; o ; o = o->next)
        !          39099:     if (strcmp(o->string, s) == 0) return o ;
        !          39100:   return 0 ;
        !          39101: }
        !          39102:  
        !          39103:  
        !          39104: Pname tree_template::get_parameter(char *s) {
        !          39105:   for (Plist formal = formals ; formal ; formal = formal->l) {
        !          39106:     if (strcmp(formal->f->string, s)== 0)
        !          39107:       return formal->f ;
        !          39108:   }
        !          39109:   return 0 ;
        !          39110: }
        !          39111: 
        !          39112: 
        !          39113: 
        !          39114: // Sam: some remodularization seems to be in order here, so that this method
        !          39115: // can be shared
        !          39116: Pname templ_inst::get_parameter(char *s) {
        !          39117:   for (Plist formal = inst_formals ; formal ; formal = formal->l) {
        !          39118:     if (strcmp(formal->f->string, s)== 0)
        !          39119:       return formal->f ;
        !          39120:   }
        !          39121:   return 0 ;
        !          39122: }
        !          39123: 
        !          39124: Pexpr tree_template::expand(Pexpr)  
        !          39125: {
        !          39126:   error('i', "no support for tree templates") ;
        !          39127:   return 0 ;
        !          39128: }
        !          39129: 
        !          39130:   
        !          39131: // Instantiate each function member body. It assumes that the class
        !          39132: // declaration has been instantiated. The return value indicates whether an
        !          39133: // instantiation of bodies actually took place. This function is only invoked
        !          39134: // at the end of a file compilation, after all source text has been processed. 
        !          39135: bool templ::instantiate_bodies(){
        !          39136:   bool change = false ;
        !          39137:   // Perform the instantiation of the member function bodies.
        !          39138:   if (!fns) return change ;
        !          39139:   
        !          39140:   for (Ptempl_inst inst = insts ;  inst ; inst = inst->next)
        !          39141:     if (!inst->forward && (inst->status == class_instantiated)) {
        !          39142:       // Set up the environment for the declaration, and subsequent compilation
        !          39143:       // of the function bodies.
        !          39144:       inst->status = body_instantiated ; change = true ;
        !          39145: 
        !          39146:       {  Pclass ic = inst->get_class() ; int i ;
        !          39147:        // note all the overriding definitions explicitly provided by the user
        !          39148:        for (Pname fn= ic->memtbl->get_mem(i=1); fn; fn=ic->memtbl->get_mem(++i))
        !          39149:             if ((fn->base == NAME) && (fn->tp->base == FCT) && Pfct(fn->tp)->body)
        !          39150:          fn->n_redefined = 1 ;
        !          39151:        }
        !          39152: 
        !          39153:       for (Pfunt fnt = fns;  fnt ; fnt = fnt->next) {
        !          39154:        Pcons templ_ref_copy = fnt->templ_refs ;
        !          39155:        Pname fn = inst->function_copy(fnt, templ_ref_copy) ;
        !          39156:        
        !          39157:        // Change the qualifier to be the name of the instantiated, rather than
        !          39158:        // the parametrized class name
        !          39159:        fn->n_qualifier = inst->namep ;
        !          39160: if (fn->n_oper != TYPE ) // cond contains type information
        !          39161:        fn->n_table = 0; 
        !          39162:        fn->n_tbl_list = 0 ;
        !          39163:        
        !          39164:        // Note that the formals were bound to the actuals when the class decl
        !          39165:        // was instantiated, so the binding is not redone.
        !          39166:        
        !          39167:        // Modify constructor and destructor names.
        !          39168:        if (!strcmp(fn->string, namep->string))
        !          39169:          fn->string = inst->namep->string ;    
        !          39170:        { inst->save_state(fn) ;
        !          39171:          // Instantiate the parametrized types referenced by this template
        !          39172:          for (Pcons pc = templ_ref_copy ; pc ; pc = pc->cdr)
        !          39173:            Ptempl_inst(pc->car)->instantiate() ;
        !          39174: 
        !          39175:          // ensure that "type type" formals constrained to be class definitions are
        !          39176:          if (!fnt->check_constraints(inst->actuals))continue ;
        !          39177: 
        !          39178:          if ( ((fn = fn->dcl(gtbl, EXTERN)) == 0) || error_count) {
        !          39179:            inst->restore_state() ;
        !          39180:            continue ;
        !          39181:          }
        !          39182:          fn->simpl() ;
        !          39183:          fn->dcl_print(0) ;
        !          39184:          inst->restore_state() ;
        !          39185:        }
        !          39186:       }
        !          39187:     }
        !          39188:   return change ;
        !          39189: }
        !          39190: 0707071010112046121004440001630000160000010212600466055421700001300000040045template.h/* ident "@(#)ctrans:src/template.h     1.2" */
        !          39191: /* -*- Mode:C++ -*- */
        !          39192: /*
        !          39193:        $Source: /usr3/lang/benson/work/stripped_cfront/RCS/template.h,v $ $RCSfile: template.h,v $
        !          39194:        $Revision: 1.4 $                $Date: 90/04/02 11:31:35 $
        !          39195:        $Author: sam $          $Locker:  $
        !          39196:        $State: Exp $
        !          39197: */
        !          39198: /*
        !          39199:     $Header: /usr3/lang/benson/work/stripped_cfront/RCS/template.h,v 1.4 90/04/02 11:31:35 sam Exp $
        !          39200: 
        !          39201:     Copyright 1989 by Object Design, Inc., Burlington, Mass.
        !          39202:     All rights reserved.
        !          39203: 
        !          39204: */
        !          39205: 
        !          39206: 
        !          39207: /*****************************************************************************
        !          39208: *                                                                           *
        !          39209: * This file contains types pertinent to the implementation of the           *
        !          39210: * parametrized type facility.                                               *
        !          39211: *                                                                           *
        !          39212: *****************************************************************************/
        !          39213: 
        !          39214: enum bool { true = 1, false = 0 } ;
        !          39215: 
        !          39216: typedef class templ *Ptempl ;
        !          39217: 
        !          39218: typedef class templ_inst *Ptempl_inst ;
        !          39219: 
        !          39220: typedef class function_template *Pfunt ;
        !          39221: 
        !          39222: typedef class templ_classdef *Ptclass ;
        !          39223: 
        !          39224: typedef class tree_template *Ptreet ;
        !          39225: 
        !          39226: 
        !          39227: // A Lisp style cons cell to help build lists. The parametrized type facility,
        !          39228: // should obviate the need for this type-unsafe nonsense.
        !          39229: class cons {
        !          39230: public:
        !          39231:   void *car ;
        !          39232:   cons *cdr ;
        !          39233:   cons (void *pcar, cons *pcdr) { car = pcar ; cdr = pcdr ; } ;
        !          39234: } ;
        !          39235: 
        !          39236: typedef cons *Pcons ;
        !          39237: 
        !          39238: 
        !          39239: 
        !          39240: /*****************************************************************************
        !          39241: *                                                                           *
        !          39242: * The class template_compilation holds the state, and the associated methods *
        !          39243: * used during template compilation. There is exactly one instance of the     *
        !          39244: * type, it is mainly a device used to enforce modularity.  In reality, it    *
        !          39245: * would never need to be instantiated since all it's members are static.     *
        !          39246: * However, since the type::mem for of reference is not supported as         *
        !          39247: * yet(cfront 1.2), we need an instantiation to get to the members via       *
        !          39248: * pointer syntax instead.                                                   *
        !          39249: *                                                                           *
        !          39250: * A templ_compilation holds the state relevant to the syntax analysis of a   *
        !          39251: * class or member function template definition.                                     *
        !          39252: *                                                                           *
        !          39253: *****************************************************************************/
        !          39254: 
        !          39255: class templ_compilation {
        !          39256:   static  Plist param_end,   // make append easier
        !          39257:                 param_tn ;   // The type names introduced by the parameters
        !          39258: 
        !          39259: public:
        !          39260:   static Ptempl  list ;      // The list of templates for the compilation
        !          39261:   static Plist   params ;    // The list of parameters to the template
        !          39262:   static Ptempl  owner  ;    // The template when compiling a member
        !          39263:                              //     function.
        !          39264:   static table   *templates ; // The templates defined during this compilation
        !          39265:   
        !          39266:   static Ptreet  tree_templates; // The list of tree templates
        !          39267: 
        !          39268:   static bool    in_progress; // a template compilation is in progress
        !          39269:   // instantiation parameter parsing in progress. Used in the lexer to ensure
        !          39270:   // that name string are consed in the heap, rather than being retained as
        !          39271:   // pointers into the lex buffer.
        !          39272:   static int     parameters_in_progress ;
        !          39273: 
        !          39274:   // the list of templates referenced by the top level definition being compiled.
        !          39275:   static Pcons   templ_refs ;
        !          39276:   static Pcons   last_cons ;
        !          39277:   static Ptype   any_type ;  // canonical "ANY" type for formal parms
        !          39278:   
        !          39279:   // true, if currently compiling an expression tree template
        !          39280:   static TOK   curr_tree_template ;
        !          39281: 
        !          39282:   void append_ref(Ptempl_inst ref) ;
        !          39283:   void start() ;
        !          39284:   
        !          39285:   void collect(TOK parm_type, Pname namep) ;
        !          39286:   void collect(Pname namep) ;
        !          39287: 
        !          39288:   void enter_parameters() ;
        !          39289:   void introduce_class_templ(Pname cnamep) ;
        !          39290:   void end(Pname class_name) ;
        !          39291:   Pname forward_declaration(Pname class_name) ;
        !          39292:   void instantiate_ref_templ() ;
        !          39293:   void clear_ref_templ() ;
        !          39294: 
        !          39295:   Pname check_tname(Pname p) ;
        !          39296:   bool  current_template(Pname p, Pexpr actuals) ;
        !          39297:   Ptempl is_template(Pname p) ;
        !          39298:   Ptempl is_template(char *s);
        !          39299:   void end_of_compilation() ;   // Done with compilation, instantiate bodies
        !          39300:   templ_compilation()  ;
        !          39301: 
        !          39302:   static Pname tree_parameter(char *s) ; // return true if the name is a tree parameter
        !          39303: 
        !          39304: private:
        !          39305:   void append_parameter(Pname p) ;
        !          39306:   
        !          39307: } ;
        !          39308: 
        !          39309: 
        !          39310: 
        !          39311: // The canonical template_compilation instance. templ_compilation exists as a
        !          39312: // class simply to provide a code and data packaging mechanism. There is
        !          39313: // exactly one generated instance of it.
        !          39314: 
        !          39315: extern templ_compilation *templp ;
        !          39316: 
        !          39317: // should actually be static member functions of templ_compilation
        !          39318: Pname parametrized_typename (Pname p, Pexpr actuals) ;
        !          39319: Pbase parametrized_basetype (Pname p, Pexpr actuals) ;
        !          39320: 
        !          39321: 
        !          39322: 
        !          39323: 
        !          39324: // the basis for class and member function templates
        !          39325: class basic_template {
        !          39326:   friend templ_compilation ;
        !          39327: protected:
        !          39328:   Plist       formals ;        // The formal arguments to the template
        !          39329:   Pcons       templ_refs ;     // The templates referenced by this template
        !          39330: 
        !          39331:   // check class constraints placed on formals while processing member
        !          39332:   // function bodies. 
        !          39333:   bool check_constraints(Pexpr actuals) ;
        !          39334:   
        !          39335:   // ensure that use of formals is consistent across, class, member and
        !          39336:   // forward declarations
        !          39337:   void check_formals(Plist formals) ;
        !          39338: 
        !          39339: public:
        !          39340:   // used to order template class definitions for instantiations. Not being
        !          39341:   // used as yet.
        !          39342:   int        definition_number ;
        !          39343: 
        !          39344:   // used to generate the definition numbers, used by the above member.
        !          39345:   static int definition_tick ;
        !          39346:         
        !          39347:   Plist get_formals() {return formals ;}
        !          39348: } ;
        !          39349: 
        !          39350: 
        !          39351: 
        !          39352: // the template for a class
        !          39353: class templ  : public basic_template { 
        !          39354:   Pbase       basep ;          // COBJ basetype for the template
        !          39355:   Ptempl_inst insts  ;         // instantiations of the template
        !          39356:   Pfunt       fns  ;           // member function declarations
        !          39357:   Pfunt       fns_end ;        // last fun in the above list
        !          39358:   
        !          39359:   // Use these state variables to set up the correct state for error
        !          39360:   // processing. They are used by the "error" routines for statement numbers.
        !          39361:   Pname       Cdcl ;
        !          39362:   Pstmt       Cstmt ;
        !          39363:   
        !          39364:   friend templ_inst ;
        !          39365:   friend function_template ;
        !          39366: 
        !          39367:   // used to detect loops during instantiation; a count greater than two is
        !          39368:   // indicative of a non-terminating instantiation sequence
        !          39369:   int         open_instantiations ;
        !          39370:   
        !          39371:   Ptempl_inst get_match(Pexpr actuals,
        !          39372:                        Ptempl_inst exclude,
        !          39373:                        bool match_instantiated_only) ;
        !          39374:   bool check_actual_args (Pexpr actuals) ;
        !          39375: 
        !          39376: public:
        !          39377:   Ptempl      next ;           // connects all the class templates in the comp
        !          39378:   Pname       namep ;          // the TNAME for the template class
        !          39379:   bool        defined ;        // the actual definition, not just a forward
        !          39380:                               // declaration has been seen.
        !          39381: 
        !          39382:   Pname       members ;        // note the members to catch redefinition errors
        !          39383: 
        !          39384:   Ptempl_inst get_inst(Pexpr actuals, Ptempl_inst exclude = 0) ;
        !          39385:   templ(Plist parms, Pname p) ;
        !          39386:   void resolve_forward_decl(Plist parms, Pclass c) ;
        !          39387:   void instantiate_forward_decl() ;
        !          39388:   
        !          39389:   // The uninstantiated base type
        !          39390:   Pbase basetype() {return basep; }
        !          39391:   // The basetype for a specific instantiation
        !          39392:   Pbase inst_basetype(Pexpr actuals) ;
        !          39393: 
        !          39394:   Pname typename(Pexpr actuals) ;
        !          39395:   
        !          39396:   Pfunt collect_function_member(Pname fname) ;
        !          39397:   bool  has_tree_expr_formals() ;
        !          39398:   bool instantiate_bodies() ;
        !          39399: } ;
        !          39400: 
        !          39401: 
        !          39402: 
        !          39403: // Member function templates
        !          39404: class function_template : public basic_template {
        !          39405:   Pname       fn ;             // The name of the member function
        !          39406:   Pfunt       next ;           // connects the list of member functions
        !          39407: 
        !          39408:   friend templ ;
        !          39409:   friend templ_inst ;
        !          39410: 
        !          39411: public:
        !          39412:   function_template (templ & owner, Plist params, Pname n) ;
        !          39413: } ;
        !          39414: 
        !          39415: 
        !          39416: 
        !          39417: // compiler internal expression templates, used to implement Objectstore constructs
        !          39418: class tree_template : public basic_template {
        !          39419:   TOK         kind ;          // STATEMENT or EXPRESSION
        !          39420:   Pnode       e ;             // the post-syntax tree representing the
        !          39421:                              // expression or statement constituting the
        !          39422:                               // template.
        !          39423:   Ptreet      next ;          // the next expression template
        !          39424:   static      int count ;     // the number of instantiations
        !          39425:                                 
        !          39426: public:
        !          39427:   char        *string ;       // the name used for template lookup
        !          39428:   tree_template(TOK tree_kind, char *s, Plist params, Pnode tree,
        !          39429:                Pcons references) ;
        !          39430:   static  Ptreet get(char *s) ;
        !          39431:   Pname   get_parameter(char *s) ;
        !          39432:   static  void test() ;
        !          39433:   Pexpr expand(Pexpr actuals) ;
        !          39434: } ;
        !          39435: 
        !          39436: 
        !          39437: 
        !          39438: 
        !          39439: // Global state variables that must be saved around an instantiation. The
        !          39440: // saving of state was required in the implementstion that interspersed decl
        !          39441: // processing and instantiation, rather than the current strategy, which only
        !          39442: // forces instantiations at the top level outside of any dcl-processing
        !          39443: // context. It is retained in case we ever go back to the "interspersed" style
        !          39444: // of instantiation. 
        !          39445: class state {
        !          39446: 
        !          39447: public:
        !          39448:   Pname       Cdcl ;      // the global variables used by the error routines
        !          39449:   Pstmt       Cstmt ;
        !          39450:   Pname       dcl_list ;  // Holds the list of typedef names that are hidden
        !          39451:   Loc         curloc ;
        !          39452:   
        !          39453:   int         curr_file ;
        !          39454:   Pexpr       curr_expr ;
        !          39455:   Pin         curr_icall ;
        !          39456:   Pstmt       curr_loop;
        !          39457:   Pblock      curr_block;
        !          39458:   Pstmt       curr_switch;
        !          39459: 
        !          39460:   int         bound  ;   
        !          39461:   int         inline_restr ;
        !          39462:   Loc         last_line ;
        !          39463: 
        !          39464:   int         no_of_badcall;
        !          39465:   int         no_of_undcl ;
        !          39466:   
        !          39467:   Pname       badcall ;
        !          39468:   Pname       undcl ;
        !          39469: 
        !          39470:   state() {} ; // prevent used before set warnings.
        !          39471:   void save() ;
        !          39472:   
        !          39473:   void init() ; 
        !          39474:   void restore() ; 
        !          39475: } ;
        !          39476: 
        !          39477: 
        !          39478: class pointer_hash ; 
        !          39479: class tree_copy_info ;
        !          39480: 
        !          39481: 
        !          39482: // A template starts out being uninstantiated, and is class_instantiated when
        !          39483: // there is a refrence to it with actual arguments. It is body_instantiated at
        !          39484: // the end of compilation, when all its function members are instantiated.
        !          39485: enum inst_status { uninstantiated, class_instantiated, body_instantiated };
        !          39486: 
        !          39487: // templ_inst captures the arguments used in the instantiation of a template.
        !          39488: // These instantiations are rooted in the templ object. 
        !          39489: class templ_inst {
        !          39490:   
        !          39491:   friend class template_instantiation ;
        !          39492: 
        !          39493:   Pname      tname ;         // The instantiation name, it is the TNAME that
        !          39494:                              // leads up to an actual instantiation of the class
        !          39495:   Pname      namep ;         // The version of TNAME in the ktbl
        !          39496:   Pexpr      actuals ;       // instantiation arguments, chained using ELIST
        !          39497:                             // as an expression "cons" node, e1 is the car
        !          39498:                             // and e2 the cdr. The car points to a name node.
        !          39499:   Ptempl_inst next ;         // The linked list of instantiations for this
        !          39500:                              // template.
        !          39501:   Ptempl_inst next_active ;  // The list of currently active instantiations.
        !          39502:   state       context ;      // the context of this instantiation
        !          39503:   Ptempl_inst forward ;      // This instantiation is the same as the one
        !          39504:                              // pointed to.
        !          39505: 
        !          39506:   // Contains the list of global names that are hidden during an
        !          39507:   // instantiation.
        !          39508:   Plist hidden_globals ;
        !          39509: 
        !          39510:   // The class correspondence table. This table is initialized 
        !          39511:   // when the class definition is instantiated. Subsequently, it is used to
        !          39512:   // initial member correspondence tables before the copy process is
        !          39513:   // initiated.
        !          39514:   pointer_hash        *corr ;
        !          39515: 
        !          39516:   // the instantiation's copy of the formals
        !          39517:   Plist  inst_formals ;
        !          39518:        
        !          39519:   inst_status status ;
        !          39520:   
        !          39521:   friend class templ ;
        !          39522:   friend class templ_classdef ;
        !          39523:   friend class tree_template ;
        !          39524:   friend Pcons make_ref_copy(pointer_hash &h, tree_copy_info &info,
        !          39525:                             Pcons old_templ_refs);
        !          39526:   
        !          39527:   templ_inst (Pexpr act,  Ptempl owner) ;
        !          39528:   bool actuals_match(Pexpr check_actuals) ;
        !          39529:   void instantiate_match(Ptempl_inst match) ;
        !          39530:   void kludge_copy(Pbase source_base) ;
        !          39531:   // create a copy of the class type subtree preparatory to the ensuing
        !          39532:   // instantiation. Return a non-zero value, only if there was no need to
        !          39533:   // create a copy, ie. an identical instantiation already existed.
        !          39534:   Ptempl_inst class_copy(Pcons &templ_refs, bool recopy) ;
        !          39535:   Pcons ref_copy(pointer_hash &h, tree_copy_info &info, Pcons old_templ_refs) ;
        !          39536:     
        !          39537:   // save and restore state around the template instantiation
        !          39538:   void save_state(Pname p) ;
        !          39539:   void restore_state() ;
        !          39540:   
        !          39541:   // Used to collect references to this template by a definition
        !          39542:   Ptempl_inst note_ref() ;
        !          39543:   char *instantiation_string() ;
        !          39544:   
        !          39545:   void expose_parameter_names() ;
        !          39546:   void hide_parameter_names() ;
        !          39547:   
        !          39548: public:
        !          39549:   Ptempl        def ;           // The template definition, for which this is an
        !          39550:                             // instantiation.
        !          39551:   bool         refp ;        // A flag used to note template references during
        !          39552:                             // a C++ definition
        !          39553:   void print_error_loc() ;   // Wants to be a static function
        !          39554:   // Bind the formals before an instantiation
        !          39555:   void bind_formals() ;
        !          39556: 
        !          39557:   Ptempl_inst canonical_instantiation() {
        !          39558:     return ( forward ? forward : this ) ;
        !          39559:   }
        !          39560: 
        !          39561:   // get the class associated with this instantiation
        !          39562:   Pclass get_class() { return Pclass(Pbase(tname->tp)->b_name->tp) ;}
        !          39563:                              
        !          39564:   void instantiate(bool reinstantiate = false) ;
        !          39565:   static Ptempl_inst head ;  // Head of the list of active instantiations.
        !          39566:   void print_pretty_name() ;
        !          39567:   char *mangled_name(char *buffer) ;
        !          39568:   // The uninstantiated basetype
        !          39569:   Pbase def_basetype() { return def->basep ; } ;
        !          39570:   // A general way of determining whether two template instantiations are
        !          39571:   // the same
        !          39572:   bool  same(Ptempl_inst t) ;
        !          39573:   bool copy_hook(Pnode&) ;
        !          39574:   // return a copy of the function tree starting with it's name
        !          39575:   Pname function_copy(Pfunt fnt, Pcons &templ_refs) ;
        !          39576: 
        !          39577:   // special check for instantiations used in qualifiers for template function
        !          39578:   // member declarations. 
        !          39579:   bool check_qualifier(Plist formals) ;
        !          39580:   Pname get_parameter(char *s) ;
        !          39581: } ;
        !          39582: 
        !          39583: 
        !          39584: 
        !          39585: // Experimental debugging toggle
        !          39586: extern int zdebug  ;
        !          39587: 
        !          39588: 
        !          39589: // The class node used for template classes.
        !          39590: // Rep invariant:
        !          39591: // class_base == uninstantiated_template_class ||
        !          39592: // class_base  == instantiated_template_class
        !          39593: 
        !          39594: class templ_classdef : public classdef {
        !          39595: public:
        !          39596:   Ptempl_inst inst ;              // a pointer to the instantiation; the
        !          39597:                                  // instantiation also points back to it via
        !          39598:                                   // the tname ->cobj->name->class path
        !          39599:   templ_classdef(Ptempl_inst i) ;
        !          39600:   Pname unparametrized_tname() { return inst->def->namep ; } 
        !          39601:   void instantiate() { inst->instantiate() ; }
        !          39602: 
        !          39603: } ;
        !          39604: 
        !          39605: 
        !          39606: // Safe accessor functions for navigating through COBJ base classes
        !          39607: 
        !          39608: extern class_type_enum get_class_base (Pbase b) ;
        !          39609: 
        !          39610: extern Ptclass get_template_class (Pbase b) ;
        !          39611: 
        !          39612: extern Ptempl_inst get_templ_inst(Pbase b) ;
        !          39613:  
        !          39614: 
        !          39615: /*
        !          39616:    $Log:       template.h,v $
        !          39617:  * Revision 1.4  90/04/02  11:31:35  sam
        !          39618:  * Made comments current.
        !          39619:  * 
        !          39620:  * Revision 1.3  90/03/30  18:50:55  sam
        !          39621:  * 1) Added the introduce_class_templ member function to the templ_compilation 
        !          39622:  * class.
        !          39623:  * 2) Rationalized the definition of class templ. Made basic_template be it's
        !          39624:  * base class, instead of type. The latter was the base type, simply so that
        !          39625:  * it could be stored in a table associating strings with types. Don't have
        !          39626:  * to resolve to such kludgery in the PT world.
        !          39627:  * 3) Added the member open_instantiations to detect non-terminating
        !          39628:  * instantiations
        !          39629:  * 
        !          39630:  * Revision 1.2  90/03/27  10:16:27  sam
        !          39631:  * > Merged in revision 1.13 from the main line of development 
        !          39632:  * 
        !          39633:  * Revision 1.1  89/11/20  08:50:58  benson
        !          39634:  * Initial revision
        !          39635:  * 
        !          39636:  * Revision 1.11  89/10/16  15:25:00  sam
        !          39637:  * use pointer_hash rather than Hash as the type of the correspondence table.
        !          39638:  * 
        !          39639:  * Revision 1.10  89/09/26  16:44:34  sam
        !          39640:  * fix the forward declaration of template classes
        !          39641:  * 
        !          39642:  * Revision 1.9  89/09/18  16:37:37  sam
        !          39643:  * provide for error recovery upon argument mismatch in a template instantiation
        !          39644:  * 
        !          39645:  * 
        !          39646:  * Revision 1.8  89/09/15  09:31:50  benson
        !          39647:  * move tree_template.string into the public section.
        !          39648:  * 
        !          39649:  * Revision 1.7  89/08/30  13:02:12  sam
        !          39650:  * added support for dealing with __expressions in class formal templates
        !          39651:  * 
        !          39652:  * Revision 1.6  89/08/28  09:42:05  sam
        !          39653:  * Support for nested references in internal templates. These nested 
        !          39654:  * references are instantiated whenever an expansion takes place.
        !          39655:  * 
        !          39656:  * Revision 1.5  89/08/23  10:26:00  sam
        !          39657:  * support for BS style formal syntax. refer to 1.5 templates.c for more 
        !          39658:  * detailed comments.
        !          39659:  * 
        !          39660:  * Revision 1.4  89/08/11  14:57:09  sam
        !          39661:  *  implementation of multiple instantiation templates.
        !          39662:  * 
        !          39663:  * Revision 1.3  89/07/27  11:33:40  sam
        !          39664:  * the comments in template.c 1.3 describe the modifications.
        !          39665:  * 
        !          39666:  * Revision 1.2  89/07/07  14:34:11  sam
        !          39667:  * Added the templ_classdef::unparametrized_type_name() function member, as part
        !          39668:  * of the base init fix.
        !          39669:  * 
        !          39670:  * Revision 1.1  89/06/29  09:21:32  benson
        !          39671:  * Initial revision
        !          39672:  * 
        !          39673:  * Revision 1.1  89/06/22  16:29:29  sam
        !          39674:  * Initial revision
        !          39675:  * 
        !          39676: 
        !          39677: 
        !          39678:    end_log
        !          39679: */
        !          39680: 
        !          39681: 
        !          39682: 
        !          39683: /*
        !          39684:    $Log $
        !          39685: 
        !          39686: 
        !          39687:    end_log
        !          39688: */
        !          39689: 0707071010112045701004440001630000160000010210100466055411600001000000012452token.h/*ident    "@(#)ctrans:src/token.h 1.4" */
        !          39690: /**************************************************************************
        !          39691: 
        !          39692:        C++ source for cfront, the C++ compiler front-end
        !          39693:        written in the computer science research center of Bell Labs
        !          39694: 
        !          39695:        Copyright (c) 1984 AT&T, Inc. All Rights Reserved
        !          39696:        THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T, INC.
        !          39697: 
        !          39698: token.h:
        !          39699: 
        !          39700: *****************************************************************************/
        !          39701: /*
        !          39702: #ifndef PRESAFE
        !          39703: extern "C" {
        !          39704: #endif
        !          39705: 
        !          39706: extern void free(char*);                       // alloc.h
        !          39707: extern char* malloc(unsigned);
        !          39708: extern char* calloc(unsigned, unsigned);
        !          39709: 
        !          39710: extern strncmp(const char*, const char*, const);       // string.h
        !          39711: extern strcmp(const char*, const char*);
        !          39712: extern int strlen(const char*);
        !          39713: extern char* strcpy(char*, const char*);
        !          39714: 
        !          39715: #ifdef apollo
        !          39716:        extern void set_sbrk_size(int);
        !          39717: #endif
        !          39718: 
        !          39719: #ifndef PRESAFE
        !          39720: }
        !          39721: #endif
        !          39722: */
        !          39723: 
        !          39724: #include <malloc.h>
        !          39725: #include <string.h>
        !          39726: #include <stdio.h>
        !          39727: 
        !          39728: extern void lex_clear();
        !          39729: extern void otbl_init();
        !          39730: 
        !          39731: //#define yylex()      lalex()
        !          39732: 
        !          39733: #define putstring(s)   fputs(s,out_file)
        !          39734: #define putst(s)       (fputs(s,out_file),putc(' ',out_file))
        !          39735: #define putch(c)       putc(c,out_file)
        !          39736: #define putcat(c,s)    (putc(c,out_file),fputs(s,out_file))
        !          39737: 
        !          39738:                        /* token numbers for C parser   */
        !          39739: 
        !          39740: #define MAXTOK 255
        !          39741: extern char* keys[MAXTOK+1];
        !          39742: 
        !          39743: #define EOFTOK 0       /*      EOF     */
        !          39744:                        /* keywords in alphabetical order */
        !          39745: #define ASM            1
        !          39746: #define AUTO           2
        !          39747: #define BREAK          3
        !          39748: #define CASE           4
        !          39749: #define CHAR           5
        !          39750: #define CLASS          6
        !          39751: #define CONTINUE       7
        !          39752: #define DEFAULT                8
        !          39753: #define DELETE         9
        !          39754: #define DO             10
        !          39755: #define DOUBLE         11
        !          39756: #define ELSE           12
        !          39757: #define ENUM           13
        !          39758: #define EXTERN         14
        !          39759: #define FLOAT          15
        !          39760: #define FOR            16
        !          39761: #define FORTRAN                17
        !          39762: #define FRIEND         18
        !          39763: #define GOTO           19
        !          39764: #define IF             20
        !          39765: #define INT            21
        !          39766: #define LONG           22
        !          39767: #define NEW            23
        !          39768: #define OPERATOR       24
        !          39769: #define PUBLIC         25
        !          39770: #define CONST          26
        !          39771: #define REGISTER       27
        !          39772: #define RETURN         28
        !          39773: #define SHORT          29
        !          39774: #define SIZEOF         30
        !          39775: #define STATIC         31
        !          39776: #define STRUCT         32
        !          39777: #define SWITCH         33
        !          39778: #define THIS           34
        !          39779: #define TYPEDEF                35
        !          39780: #define UNION          36
        !          39781: #define UNSIGNED       37
        !          39782: #define VOID           38
        !          39783: #define WHILE          39
        !          39784: 
        !          39785:                        /* operators in priority order (sort of) */
        !          39786: #define LP             40
        !          39787: #define RP             41
        !          39788: #define LB             42
        !          39789: #define RB             43
        !          39790: #define REF            44
        !          39791: #define DOT            45
        !          39792: #define NOT            46
        !          39793: #define COMPL          47
        !          39794: #define INCR           48
        !          39795: #define DECR           49
        !          39796: #define MUL            50
        !          39797: #define DIV            51
        !          39798: #define AND            52
        !          39799: #define MOD            53
        !          39800: #define PLUS           54
        !          39801: #define MINUS          55
        !          39802: #define LS             56
        !          39803: #define RS             57
        !          39804: #define LT             58
        !          39805: #define LE             59
        !          39806: #define GT             60
        !          39807: #define GE             61
        !          39808: #define EQ             62
        !          39809: #define NE             63
        !          39810: #define ER             64
        !          39811: #define OR             65
        !          39812: #define ANDAND         66
        !          39813: #define OROR           67
        !          39814: #define QUEST          68
        !          39815: #define COLON          69
        !          39816: #define ASSIGN         70
        !          39817: #define CM             71
        !          39818: #define SM             72
        !          39819: #define LC             73
        !          39820: #define RC             74
        !          39821: 
        !          39822: #define INLINE         75
        !          39823: #define OVERLOAD       76
        !          39824: #define VIRTUAL                77
        !          39825: #define COERCE         78
        !          39826: #define PROTECTED      79
        !          39827: 
        !          39828:                        /* constants etc. */
        !          39829: #define ID             80
        !          39830: #define STRING         81
        !          39831: #define ICON           82
        !          39832: #define FCON           83
        !          39833: #define CCON           84
        !          39834: #define NAME           85
        !          39835: #define ZERO           86
        !          39836: 
        !          39837:                        /* groups of tokens */
        !          39838: #define ASOP           90      /* op= */
        !          39839: #define RELOP          91      /* LE GE LT GT */
        !          39840: #define EQUOP          92      /* EQ NE */
        !          39841: #define DIVOP          93      /* DIV MOD */
        !          39842: #define SHIFTOP                94      /* LS RS */
        !          39843: #define ICOP           95      /* INCR DECR */
        !          39844: #define UNOP           96      /* NOT COMPL */
        !          39845: #define TYPE           97
        !          39846:        /* TYPE =       INT FLOAT CHAR DOUBLE REGISTER STATIC EXTERN AUTO
        !          39847:                        LONG SHORT UNSIGNED INLINE FRIEND VIRTUAL */
        !          39848: 
        !          39849:                        /* new tokens generated by syn() */
        !          39850: #define UMINUS         107
        !          39851: #define FCT            108
        !          39852: #define CALL           109
        !          39853: #define VEC            110
        !          39854: #define DEREF          111
        !          39855: #define ADDROF         112
        !          39856: #define CAST           113
        !          39857: //#define ENDCAST              122
        !          39858: #define FIELD          114
        !          39859: #define LABEL          115
        !          39860: #define BLOCK          116
        !          39861: //#define QUA          117
        !          39862: #define DCL            118     /* local declaration statement */
        !          39863: #define COBJ           119
        !          39864: #define EOBJ           121
        !          39865: #define TNAME          123
        !          39866: #define ILIST          124
        !          39867: #define PTR            125
        !          39868: 
        !          39869: #define ASPLUS         126
        !          39870: #define ASMINUS                127
        !          39871: #define ASMUL          128
        !          39872: #define ASDIV          129
        !          39873: #define ASMOD          130
        !          39874: #define ASAND          131
        !          39875: #define ASOR           132
        !          39876: #define ASER           133
        !          39877: #define ASLS           134
        !          39878: #define ASRS           135
        !          39879: 
        !          39880: #define ARG            136
        !          39881: #define ARGS           137
        !          39882: #define ZTYPE          138
        !          39883: #define ARGT           139
        !          39884: #define ELIST          140
        !          39885: #define ANY            141
        !          39886: #define TABLE          142
        !          39887: #define LOC            143
        !          39888: #define DUMMY          144
        !          39889: #define G_ADDROF       145
        !          39890: #define G_CALL         146
        !          39891: #define G_CM           147
        !          39892: #define IVAL           150
        !          39893: //#define FVAL         151
        !          39894: //#define LVAL         152
        !          39895: #define ELLIPSIS       155
        !          39896: #define AGGR           156
        !          39897: #define VALUE          157     /* constructor call */
        !          39898: #define RPTR           158     /* reference */
        !          39899: #define HIDDEN         159
        !          39900: #define MEM            160
        !          39901: #define CTOR           161
        !          39902: #define DTOR           162
        !          39903: #define CONST_PTR      163
        !          39904: #define CONST_RPTR     164
        !          39905: #define TEXT           165
        !          39906: #define PAIR           166
        !          39907: #define ANON           167
        !          39908: #define ICALL          168
        !          39909: #define ANAME          169
        !          39910: #define VOLATILE       170
        !          39911: #define SIGNED         171
        !          39912: #define UPLUS          172
        !          39913: #define MEMPTR         173
        !          39914: #define PRIVATE                174
        !          39915: #define PR             175     /* PUBLIC PRIVATE or PROTECTED */
        !          39916: #define MDOT           177
        !          39917: #define TSCOPE         178
        !          39918: #define DECL_MARKER    179
        !          39919: #define REFMUL         180
        !          39920: #define LDOUBLE                181
        !          39921: #define LINKAGE         182
        !          39922: #define LOCAL          183
        !          39923: #define GNEW           184
        !          39924: #define TEMPLATE       185
        !          39925: #define STAT_INIT      186
        !          39926: #define CATCH          187
        !          39927: #define GDELETE                188
        !          39928: //#define CONVERT      189
        !          39929: #define NESTED         190
        !          39930: #define TRY            191
        !          39931: 
        !          39932: // class parameterized types constants
        !          39933: #define XVIRT           200 /* class virt */
        !          39934: #define XNLIST          201 /* struct name_list */
        !          39935: #define XILINE          202
        !          39936: #define XIA             203
        !          39937: #define STATEMENT        205
        !          39938: #define EXPRESSION       206
        !          39939: #define SM_PARAM         207 
        !          39940: #define TEMPLATE_TEST    208
        !          39941: #define PTNAME           209
        !          39942: #define NEW_INIT_KLUDGE  210
        !          39943: #define XDELETED_NODE    211
        !          39944: #define DUMMY_LAST_NODE  212
        !          39945: 
        !          39946: //#define SYN  1
        !          39947: //#define TYP  2
        !          39948: //#define SIMPL        3
        !          39949: //#define ERROR        4
        !          39950: 
        !          39951: //#define ICTOR 88
        !          39952: //#define IDTOR 89
        !          39953: 0707071010112046131004440001630000160000010212340466055422200001600000006724token_names.h/* ident "@(#)ctrans:src/token_names.h       1.2" */
        !          39954: struct _token_name { char * string; int val; } token_names [] = {
        !          39955:        { "EOFTOK",     0 },
        !          39956:        { "ASM",        1 },
        !          39957:        { "AUTO",       2 },
        !          39958:        { "BREAK",      3 },
        !          39959:        { "CASE",       4 },
        !          39960:        { "CHAR",       5 },
        !          39961:        { "CLASS",      6 },
        !          39962:        { "CONTINUE",   7 },
        !          39963:        { "DEFAULT",    8 },
        !          39964:        { "DELETE",     9 },
        !          39965:        { "DO", 10 },
        !          39966:        { "DOUBLE",     11 },
        !          39967:        { "ELSE",       12 },
        !          39968:        { "ENUM",       13 },
        !          39969:        { "EXTERN",     14 },
        !          39970:        { "FLOAT",      15 },
        !          39971:        { "FOR",        16 },
        !          39972:        { "FORTRAN",    17 },
        !          39973:        { "FRIEND",     18 },
        !          39974:        { "GOTO",       19 },
        !          39975:        { "IF", 20 },
        !          39976:        { "INT",        21 },
        !          39977:        { "LONG",       22 },
        !          39978:        { "NEW",        23 },
        !          39979:        { "OPERATOR",   24 },
        !          39980:        { "RETURN",     28 },
        !          39981:        { "PUBLIC",     25 },
        !          39982:        { "CONST",      26 },
        !          39983:        { "REGISTER",   27 },
        !          39984:        { "RETURN",     28 },
        !          39985:        { "SHORT",      29 },
        !          39986:        { "SIZEOF",     30 },
        !          39987:        { "STATIC",     31 },
        !          39988:        { "STRUCT",     32 },
        !          39989:        { "SWITCH",     33 },
        !          39990:        { "THIS",       34 },
        !          39991:        { "TYPEDEF",    35 },
        !          39992:        { "UNION",      36 },
        !          39993:        { "UNSIGNED",   37 },
        !          39994:        { "VOID",       38 },
        !          39995:        { "WHILE",      39 },
        !          39996:        { "LP", 40 },
        !          39997:        { "RP", 41 },
        !          39998:        { "LB", 42 },
        !          39999:        { "RB", 43 },
        !          40000:        { "REF",        44 },
        !          40001:        { "DOT",        45 },
        !          40002:        { "NOT",        46 },
        !          40003:        { "COMPL",      47 },
        !          40004:        { "INCR",       48 },
        !          40005:        { "DECR",       49 },
        !          40006:        { "MUL",        50 },
        !          40007:        { "DIV",        51 },
        !          40008:        { "AND",        52 },
        !          40009:        { "MOD",        53 },
        !          40010:        { "PLUS",       54 },
        !          40011:        { "MINUS",      55 },
        !          40012:        { "LS", 56 },
        !          40013:        { "RS", 57 },
        !          40014:        { "LT", 58 },
        !          40015:        { "LE", 59 },
        !          40016:        { "GT", 60 },
        !          40017:        { "GE", 61 },
        !          40018:        { "EQ", 62 },
        !          40019:        { "NE", 63 },
        !          40020:        { "ER", 64 },
        !          40021:        { "OR", 65 },
        !          40022:        { "ANDAND",     66 },
        !          40023:        { "OROR",       67 },
        !          40024:        { "QUEST",      68 },
        !          40025:        { "COLON",      69 },
        !          40026:        { "ASSIGN",     70 },
        !          40027:        { "CM", 71 },
        !          40028:        { "SM", 72 },
        !          40029:        { "LC", 73 },
        !          40030:        { "RC", 74 },
        !          40031:        { "INLINE",     75 },
        !          40032:        { "OVERLOAD",   76 },
        !          40033:        { "VIRTUAL",    77 },
        !          40034:        { "COERCE",     78 },
        !          40035:        { "PROTECTED",  79 },
        !          40036:        { "ID", 80 },
        !          40037:        { "STRING",     81 },
        !          40038:        { "ICON",       82 },
        !          40039:        { "FCON",       83 },
        !          40040:        { "CCON",       84 },
        !          40041:        { "NAME",       85 },
        !          40042:        { "ZERO",       86 },
        !          40043:        { "ICTOR",      88 },
        !          40044:        { "IDTOR",      89 },
        !          40045:        { "ASOP",       90 },
        !          40046:        { "RELOP",      91 },
        !          40047:        { "EQUOP",      92 },
        !          40048:        { "DIVOP",      93 },
        !          40049:        { "SHIFTOP",    94 },
        !          40050:        { "ICOP",       95 },
        !          40051:        { "UNOP",       96 },
        !          40052:        { "TYPE",       97 },
        !          40053:        { "UMINUS",     107 },
        !          40054:        { "FCT",        108 },
        !          40055:        { "CALL",       109 },
        !          40056:        { "VEC",        110 },
        !          40057:        { "DEREF",      111 },
        !          40058:        { "ADDROF",     112 },
        !          40059:        { "CAST",       113 },
        !          40060:        { "FIELD",      114 },
        !          40061:        { "LABEL",      115 },
        !          40062:        { "BLOCK",      116 },
        !          40063:        { "QUA",        117 },
        !          40064:        { "DCL",        118 },
        !          40065:        { "COBJ",       119 },
        !          40066:        { "EOBJ",       121 },
        !          40067:        { "TNAME",      123 },
        !          40068:        { "ILIST",      124 },
        !          40069:        { "PTR",        125 },
        !          40070:        { "ASPLUS",     126 },
        !          40071:        { "ASMINUS",    127 },
        !          40072:        { "ASMUL",      128 },
        !          40073:        { "ASDIV",      129 },
        !          40074:        { "ASMOD",      130 },
        !          40075:        { "ASAND",      131 },
        !          40076:        { "ASOR",       132 },
        !          40077:        { "ASER",       133 },
        !          40078:        { "ASLS",       134 },
        !          40079:        { "ASRS",       135 },
        !          40080:        { "ARG",        136 },
        !          40081:        { "KNOWN",      137 },
        !          40082:        { "ZTYPE",      138 },
        !          40083:        { "ARGT",       139 },
        !          40084:        { "ELIST",      140 },
        !          40085:        { "ANY",        141 },
        !          40086:        { "TABLE",      142 },
        !          40087:        { "LOC",        143 },
        !          40088:        { "DUMMY",      144 },
        !          40089:        { "G_ADDROF",   145 },
        !          40090:        { "G_CALL",     146 },
        !          40091:        { "G_CM",       147 },
        !          40092:        { "IVAL",       150 },
        !          40093:        { "FVAL",       151 },
        !          40094:        { "LVAL",       152 },
        !          40095:        { "ELLIPSIS",   155 },
        !          40096:        { "AGGR",       156 },
        !          40097:        { "VALUE",      157 },
        !          40098:        { "RPTR",       158 },
        !          40099:        { "HIDDEN",     159 },
        !          40100:        { "MEM",        160 },
        !          40101:        { "CTOR",       161 },
        !          40102:        { "DTOR",       162 },
        !          40103:        { "CONST_PTR",  163 },
        !          40104:        { "CONST_RPTR", 164 },
        !          40105:        { "TEXT",       165 },
        !          40106:        { "PAIR",       166 },
        !          40107:        { "ANON",       167 },
        !          40108:        { "ICALL",      168 },
        !          40109:        { "ANAME",      169 },
        !          40110:        { "VOLATILE",   170 },
        !          40111:        { "SIGNED",     171 },
        !          40112:        { "UPLUS",      172 },
        !          40113:        { "MEMPTR",     173 },
        !          40114:        { "PRIVATE",    174 },
        !          40115:        { "PR", 175 },
        !          40116:        { "MDOT",       177 },
        !          40117:        { "TSCOPE",     178 },
        !          40118:        { "DECL_MARKER",        179 },
        !          40119:        { "REFMUL",     180 },
        !          40120:        { "LDOUBLE",    181 },
        !          40121:        { "LINKAGE",    182 },
        !          40122:        { "LOCAL",      183 },
        !          40123:        { "GNEW",       184 },
        !          40124:        { "TEMPLATE",   185 },
        !          40125:        { "STAT_INIT",  186 },
        !          40126:        { "CATCH",      187 },
        !          40127:        { "GDELETE",    188 },
        !          40128:        { "CONVERT",    189 },
        !          40129:        { "XVIRT",      200 },
        !          40130:        { "XNLIST",     201 },
        !          40131:        { "XILINE",     202 },
        !          40132:        { "XIA",        203 },
        !          40133:        { "STATEMENT",  205 },
        !          40134:        { "EXPRESSION", 206 },
        !          40135:        { "SM_PARAM",   207 },
        !          40136:        { "TEMPLATE_TEST",      208 },
        !          40137:        { "PTNAME",     209 },
        !          40138:        { "NEW_INIT_KLUDGE", 210 },
        !          40139:        { "XDELETED_NODE",      211 },
        !          40140:        { "DUMMY_LAST_TOKEN",   212 },
        !          40141: };
        !          40142: 0707071010112045711004440001630000160000010156650466055412200001100000002515tqueue.h/*ident   "@(#)ctrans:src/tqueue.h        1.3" */
        !          40143: /**************************************************************************
        !          40144: 
        !          40145:         C++ source for cfront, the C++ compiler front-end
        !          40146:         written in the computer science research center of Bell Labs
        !          40147: 
        !          40148:         Copyright (c) 1984 AT&T, Inc. All Rights Reserved
        !          40149:         THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T, INC.
        !          40150: 
        !          40151: tqueue.h:
        !          40152: 
        !          40153: *****************************************************************************/
        !          40154: 
        !          40155: #ifndef EOF
        !          40156: #include <stdio.h>
        !          40157: #endif
        !          40158: 
        !          40159: struct toknode {
        !          40160:        TOK      tok;                   /* token for parser */
        !          40161:        bit      used;                  /* token has been processed by lalex() */
        !          40162:        YYSTYPE  retval;                        /* $arg */
        !          40163:        loc      place;
        !          40164:        toknode* next;
        !          40165:        toknode* last;
        !          40166:        static toknode* free_toks;
        !          40167:        void*   operator new(size_t);
        !          40168:        void    operator delete(void*,size_t);
        !          40169:                toknode(TOK,YYSTYPE,loc);
        !          40170: };
        !          40171: extern toknode* front;
        !          40172: extern toknode* rear;
        !          40173: 
        !          40174: extern void addtok(TOK,YYSTYPE,loc);   /* add tok to rear of Q */
        !          40175: extern TOK deltok(int);                        /* take tok from front of Q */
        !          40176: extern TOK tlex();
        !          40177: 
        !          40178: // interface to parser
        !          40179: extern TOK lalex();
        !          40180: extern int yychar;
        !          40181: extern YYSTYPE yylval;
        !          40182: extern TOK     la_look();
        !          40183: extern void    la_backup( TOK, YYSTYPE );
        !          40184: extern int     la_cast();
        !          40185: extern void    check_decl();
        !          40186: extern void    check_cast();
        !          40187: extern TOK     lalex();
        !          40188: 
        !          40189: // save / restore implicit inline functions
        !          40190: extern toknode*        save_text();
        !          40191: extern void    restore_text();
        !          40192: 0707071010112046041004440001630000160000010211700466055416700001400000014274tree_copy.c/* ident "@(#)ctrans:src/tree_copy.c   1.3" */
        !          40193: /*
        !          40194:        $Source: /usr3/lang/benson/work/stripped_cfront/RCS/tree_copy.c,v $ $RCSfile: tree_copy.c,v $
        !          40195:        $Revision: 1.1 $                $Date: 89/11/20 08:51:04 $
        !          40196:        $Author: benson $               $Locker:  $
        !          40197:        $State: Exp $
        !          40198: */
        !          40199:  
        !          40200: /* utilities to copy pieces of cfront trees. 
        !          40201:    what we have here is a somewhat parameterizable
        !          40202:    action procedure for the tree walker.
        !          40203: 
        !          40204:    We may make more versions of this for template expansion
        !          40205:    and saving things in files, or we may just make it possible
        !          40206:    for this to swing more ways. 
        !          40207: */
        !          40208: 
        !          40209: #include "cfront.h"
        !          40210: #include "tree_walk.h"
        !          40211: #include "tree_copy.h"
        !          40212: #include <memory.h>
        !          40213: 
        !          40214: /* determine whether "n" is a an already defined type */
        !          40215: static unsigned int type_is_defined(Pnode n) {
        !          40216:   return (Ptype(n)->defined & DEFINED) ;
        !          40217: }
        !          40218: 
        !          40219: void
        !          40220: copy_walker (Pnode& node, node_class cl, void * info, 
        !          40221:             tree_node_action& action, int, Pnode, tree_walk_tree&,
        !          40222:             int& register_in_hash)
        !          40223: {
        !          40224:     union {
        !          40225:        Pnode node;
        !          40226:        Pvirt vr;
        !          40227:        Plist list;
        !          40228:        Pgen g;
        !          40229:        Pvec vc;
        !          40230:        Pfct f;
        !          40231:        Ptable t;
        !          40232:        Pbase  bt;
        !          40233:        Pexpr  x;
        !          40234:        Pstmt  s;
        !          40235:        Penum  e;
        !          40236:        Pclass c;
        !          40237:        Pbcl   bcl;
        !          40238:        Pin    iline;
        !          40239:        ia   * ia;
        !          40240:        Pname  n;
        !          40241:        Pptr p;
        !          40242:       } n;
        !          40243:     Pnode original_node = node;
        !          40244: 
        !          40245:     tree_copy_info * tci = (tree_copy_info *)info;
        !          40246:     action = tna_continue;
        !          40247: 
        !          40248:     /* first, give an application-specific hook a shot at the node. */
        !          40249: 
        !          40250:     tci->check_node(node, cl, action, register_in_hash);
        !          40251:     if(action != tna_continue) return;    
        !          40252: 
        !          40253:     if(node != original_node) { /* a replacement */
        !          40254:       n.node = node;
        !          40255:     } else /* ok, nothing funny, we just go ahead and copy */
        !          40256:       switch (cl) {
        !          40257:       default:
        !          40258:        break;  
        !          40259:       case nc_eof:
        !          40260:        n.node = Pnode(tci->malloc(sizeof (node)));
        !          40261:        *n.node = *node;
        !          40262:        goto Replace;
        !          40263: 
        !          40264:       case nc_virt:
        !          40265:        n.vr = Pvirt(tci->malloc(sizeof(virt)));
        !          40266:        *n.vr = *Pvirt(node);
        !          40267:        goto Replace;
        !          40268: 
        !          40269:       case nc_nlist:
        !          40270:        n.list = Plist(tci->malloc(sizeof(name_list)));
        !          40271:        *n.list = *Plist(node);
        !          40272:        goto Replace;
        !          40273: 
        !          40274:       case nc_gen:
        !          40275:        n.g = Pgen(tci->malloc(sizeof(gen)));
        !          40276:        *n.g = *Pgen(node);
        !          40277:        goto Replace;
        !          40278: 
        !          40279:       case nc_vec: 
        !          40280:        n.vc = Pvec(tci->malloc(sizeof(vec)));
        !          40281:        *n.vc = *Pvec(node);
        !          40282:        goto Replace;
        !          40283: 
        !          40284:       case nc_ptr:
        !          40285:        n.p = Pptr(tci->malloc(sizeof(ptr)));
        !          40286:        *n.p = *Pptr(node);
        !          40287:        goto Replace;
        !          40288: 
        !          40289:       case nc_fct:
        !          40290:        n.f = Pfct(tci->malloc(sizeof(fct)));
        !          40291:        *n.f = *Pfct(node);
        !          40292:        if(n.f->f_signature) {
        !          40293:            n.f->f_signature =
        !          40294:                (char *)tci->malloc(strlen(Pfct(node)->f_signature)+1);
        !          40295:            strcpy(n.f->f_signature, Pfct(node)->f_signature);
        !          40296:        };
        !          40297:        goto Replace;
        !          40298: 
        !          40299:       case nc_table:
        !          40300:        n.t = Ptable(tci->malloc(sizeof(table)));
        !          40301:        *n.t = *Ptable(node);
        !          40302:        n.t->entries = (Pname *)tci->malloc(sizeof(Pname) * n.t->size);
        !          40303:        memcpy((char *)n.t->entries, (char *)Ptable(node)->entries, n.t->size * sizeof(Pname));
        !          40304:        n.t->hashtbl = (short *)tci->malloc(sizeof(short) * n.t->hashsize);
        !          40305:        memcpy((char *)n.t->hashtbl, (char *)Ptable(node)->hashtbl, n.t->hashsize * sizeof (short));
        !          40306:        goto Replace;
        !          40307: 
        !          40308:       case nc_basetype:
        !          40309:        // Don't copy types that have already been dealt with
        !          40310:        if (type_is_defined(node)) {
        !          40311:          action = tna_stop ;
        !          40312:          return ;
        !          40313:        }
        !          40314:        n.bt = Pbase(tci->malloc(sizeof(basetype)));
        !          40315:        *n.bt = *Pbase(node);
        !          40316:        if(n.bt->discriminator(0) == 2 && n.bt->b_linkage) {
        !          40317:            n.bt->b_linkage = tci->malloc(strlen(n.bt->b_linkage) + 1);
        !          40318:            strcpy(n.bt->b_linkage, Pbase(node)->b_linkage);
        !          40319:        }
        !          40320:        goto Replace;
        !          40321: 
        !          40322:       case nc_expr:
        !          40323:        // cfront needs identity maintaied for these nodes
        !          40324:        if ((node == dummy) || (node == zero)) {
        !          40325:          action = tna_stop ;
        !          40326:          return ;
        !          40327:        }
        !          40328:        n.x = Pexpr(tci->malloc(sizeof(expr)));
        !          40329:        *n.x = *Pexpr(node);
        !          40330:        if(n.x->discriminator(1) == 3 && n.x->string) {
        !          40331:            n.x->string = tci->malloc(strlen(n.x->string) + 1);
        !          40332:            strcpy(n.x->string, Pexpr(node)->string);
        !          40333:        }
        !          40334:        if(n.x->discriminator(2) == 3 && n.x->string2) {
        !          40335:            n.x->string2 = tci->malloc(strlen(n.x->string2) + 1);
        !          40336:            strcpy(n.x->string2, Pexpr(node)->string2);
        !          40337:        }
        !          40338:        goto Replace;
        !          40339: 
        !          40340:       case nc_stmt:
        !          40341:        n.s = Pstmt(tci->malloc(sizeof(stmt)));
        !          40342:        *n.s = *Pstmt(node);
        !          40343:        goto Replace;
        !          40344: 
        !          40345:       case nc_enumdef:
        !          40346:        if (type_is_defined(node)) {
        !          40347:          action = tna_stop ;
        !          40348:          return ;
        !          40349:        }
        !          40350:        n.e = Penum(tci->malloc(sizeof(enumdef)));
        !          40351:        *n.e = *Penum(node);
        !          40352:        if(n.e->string) {
        !          40353:            n.e->string = tci->malloc(n.e->strlen+1);
        !          40354:            strcpy(n.e->string, Penum(node)->string);
        !          40355:        }
        !          40356:        goto Replace;
        !          40357: 
        !          40358:       case nc_classdef:
        !          40359:        // Don't copy types that have already been dealt with
        !          40360:        if (type_is_defined(node)) {
        !          40361:          action = tna_stop ;
        !          40362:          return ;
        !          40363:        }
        !          40364:        n.c = Pclass(tci->malloc(sizeof(classdef)));
        !          40365:        *n.c = *Pclass(node);
        !          40366:        if(n.c->string) {
        !          40367:            n.c->string = tci->malloc(strlen(n.c->string)+1);
        !          40368:            strcpy(n.c->string, Pclass(node)->string);
        !          40369:        }
        !          40370:        goto Replace;
        !          40371: 
        !          40372:       case nc_baseclass:
        !          40373:        n.bcl = Pbcl(tci->malloc(sizeof(struct basecl)));
        !          40374:        *n.bcl = *Pbcl(node);
        !          40375:        goto Replace;
        !          40376: 
        !          40377:       case nc_iline:
        !          40378:        n.iline = Pin(tci->malloc(sizeof(iline)));
        !          40379:        *n.iline = *Pin(node);
        !          40380:        goto Replace;
        !          40381: 
        !          40382:       case nc_ia:
        !          40383:        n.ia = (ia *)tci->malloc(sizeof(ia));
        !          40384:        *n.ia = *(ia *)node;
        !          40385:        goto Replace;
        !          40386: 
        !          40387:       case nc_name:
        !          40388:        /* check for globalosity */
        !          40389:        if(Pname(node)->string && (node == (node->base == TNAME ? ktbl : gtbl)->look(Pname(node)->string, 0))) {
        !          40390:            action = tna_stop;
        !          40391:            return;
        !          40392:        }
        !          40393:        n.n = Pname(tci->malloc(sizeof(name)));
        !          40394:        *n.n = *Pname(node);
        !          40395: /* First, hack exprosity */
        !          40396:        if(n.x->discriminator(1) == 3 && n.n->string) {
        !          40397:            n.n->string = tci->malloc(strlen(n.n->string) + 1);
        !          40398:            strcpy(n.n->string, Pexpr(node)->string);
        !          40399:        }
        !          40400:        if(n.x->discriminator(2) == 3 && n.n->string2) {
        !          40401:            n.n->string2 = tci->malloc(strlen(n.n->string2) + 1);
        !          40402:            strcpy(n.n->string2, Pexpr(node)->string2);
        !          40403: /* ok, name stuff */
        !          40404:        }
        !          40405:        if(n.n->n_anon) {
        !          40406:            n.n->n_anon = tci->malloc(strlen(n.n->n_anon)+1);
        !          40407:            strcpy(n.n->n_anon, Pname(node)->n_anon);
        !          40408:        }
        !          40409:        if(n.n->n_template_arg_string) {
        !          40410:            n.n->n_template_arg_string =
        !          40411:                tci->malloc(strlen(n.n->n_template_arg_string)+1);
        !          40412:            strcpy(n.n->n_template_arg_string, Pname(node)->n_template_arg_string);
        !          40413:        }
        !          40414:     }
        !          40415:   Replace:
        !          40416:     node = n.node;
        !          40417:     action = tna_continue;
        !          40418:     return;
        !          40419: }
        !          40420: 
        !          40421: static int call_error (int i, const char * s)
        !          40422: {
        !          40423:     return error (i, s);
        !          40424: }
        !          40425: 
        !          40426: void
        !          40427: copy_tree (Pnode& node, tree_copy_info& tci, Hash * cht)
        !          40428: {
        !          40429:     tree_walk_control twc;
        !          40430: 
        !          40431:     twc.call_i_error = 1;
        !          40432:     twc.i_error = call_error; /* ... in type of error confuses compiler */
        !          40433:     twc.action_proc = copy_walker;
        !          40434:     twc.nodes_seen_hash = cht;
        !          40435:     twc.callback_info = (void *)&tci;
        !          40436: 
        !          40437:     walk_tree (twc, node);
        !          40438: }
        !          40439: 
        !          40440: 0707071010112046141004440001630000160000010210160466055422600001400000003011tree_copy.h/* ident "@(#)ctrans:src/tree_copy.h   1.2" */
        !          40441: /* -*- Mode: C -*- begin include file tree_copy.H 
        !          40442:    argument class for copying trees. */
        !          40443: 
        !          40444: #include "hash.h"
        !          40445: #include "tree_walk.h"
        !          40446: 
        !          40447: /* The copier procedure expects one of these as its 
        !          40448:     info pointer */
        !          40449: 
        !          40450: class tree_copy_info {
        !          40451:   public:
        !          40452: /* If non-zero, this procedure is called at each node.
        !          40453:    it returns an action. It cannot currently return
        !          40454:    a node of a different class and also return an
        !          40455:    action other than tna_stop, since the walker won't
        !          40456:    notice that the rug has been removed from beneath its feet. 
        !          40457:    The procedure must set the last argument to indicate whether
        !          40458:    or not to register the node in the hash table and use the
        !          40459:    replacement every future time it is encountered.
        !          40460: */
        !          40461: 
        !          40462:     void (* node_hook) (void * info, Pnode&, node_class, tree_node_action&,
        !          40463:                        int&);
        !          40464: 
        !          40465:     /* if this is nonzero it is used to allocate space for
        !          40466:        the copies. We don't run constructors since we always
        !          40467:        bit copy over the new copy. */
        !          40468:     char * (* malloc_hook) (void * info, size_t);
        !          40469:     void * hook_info;
        !          40470:     tree_copy_info ()
        !          40471:        {
        !          40472:            hook_info = 0;
        !          40473:            node_hook = 0;
        !          40474:            malloc_hook = 0;
        !          40475:        }; 
        !          40476:     char * malloc (size_t s) {
        !          40477:        return malloc_hook ? malloc_hook(hook_info, s) : ::malloc (s);
        !          40478:     };
        !          40479:     void check_node (Pnode& n,
        !          40480:                     node_class cl, 
        !          40481:                     tree_node_action& action, 
        !          40482:                     int& never_see_again) {
        !          40483:        if(node_hook)
        !          40484:            node_hook(hook_info, n, cl, action, never_see_again);
        !          40485:     };
        !          40486: };
        !          40487: 
        !          40488: void copy_tree (Pnode& n, tree_copy_info& tci, Hash * cht = 0);
        !          40489: 
        !          40490: /* End tree_copy.H */
        !          40491: 
        !          40492: 0707071010112046161004440001630000160000010213300466055423500001400000061200tree_dump.c/* ident "@(#)ctrans:src/tree_dump.c   1.2" */
        !          40493: /* -*- Mode:C++ -*- */
        !          40494: /* tree_dump.C -- utilities for displaying the cfront tree. */
        !          40495: /* BIM 890530 */
        !          40496: /* rewritten 890712 to use the tree-walking facilities */
        !          40497: 
        !          40498: /*
        !          40499:        $Source: /usr3/lang/benson/work/stripped_cfront/RCS/tree_dump.c,v $ $RCSfile: tree_dump.c,v $
        !          40500:        $Revision: 1.1 $                $Date: 89/11/20 08:50:22 $
        !          40501:        $Author: benson $               $Locker:  $
        !          40502:        $State: Exp $
        !          40503: 
        !          40504: 
        !          40505: */
        !          40506: 
        !          40507: #include "tree_dump.h"
        !          40508: #include <stdio.h>
        !          40509: #include <malloc.h>
        !          40510: #include "template.h"
        !          40511: #include "token_names.h"
        !          40512: 
        !          40513: const int Indent_Increment = 4;
        !          40514: static char badnamebuf[100];
        !          40515: 
        !          40516: char *
        !          40517: token_name(TOK t)
        !          40518: {
        !          40519:     char * bnb = badnamebuf;
        !          40520: 
        !          40521:     if((int) t == -1) return "-1";
        !          40522:     if(t > DUMMY_LAST_NODE) {
        !          40523: bad:
        !          40524:        printf_to_string(bnb, sizeof(badnamebuf), 
        !          40525:                         "<unknown token %d>", (int) t);
        !          40526:        return bnb;
        !          40527:     } 
        !          40528:     int x;
        !          40529:     for (x = 0; x < DUMMY_LAST_NODE; x++) {
        !          40530:        if(token_names[x].val == t) return token_names[x].string;
        !          40531:     }
        !          40532:     goto bad;
        !          40533: }
        !          40534: 
        !          40535: class displayer{
        !          40536:   public:
        !          40537:     dcn_arg * arg;
        !          40538:     Pnode node;
        !          40539:     Pnode node_address;
        !          40540:     displayer (dcn_arg& d) { arg = &d; indent = 0; print_null_values = 0; };
        !          40541:     void do_node (Pnode& node, node_class cl, tree_node_action& action, int depth, Pnode);
        !          40542:   private:
        !          40543:     enum ppc {print_ptr_copy = 0, print_ptr_copied = 1};
        !          40544:     int indent;
        !          40545:     int err;
        !          40546:     int print_null_values;
        !          40547:     void printf (const char *, ...);
        !          40548:     void catprintf (const char *, ...);
        !          40549:     void print_ptr (const char *, Pnode);
        !          40550:     void print_ptr (Pnode, ppc = print_ptr_copy);
        !          40551:     void minimal ();
        !          40552:     void a_basetype ();
        !          40553:     void a_basecl() ;
        !          40554:     void a_type() ;
        !          40555:     void a_node() ;
        !          40556:     void a_name ();
        !          40557:     void a_expr (int from_name = 0);
        !          40558:     void a_fct ();
        !          40559:     void a_stmt ();
        !          40560:     void a_enumdef ();
        !          40561:     void a_table();
        !          40562:     void a_classdef ();
        !          40563:     void a_gen ();
        !          40564:     void a_vec ();
        !          40565:     void a_ptr ();
        !          40566:     void a_virt ();
        !          40567:     void a_nlist ();
        !          40568:     void a_iline ();
        !          40569:     void a_elist ();
        !          40570:     void a_ia ();
        !          40571:     void a_by_name ();
        !          40572:     void print_loc(loc&);
        !          40573:     void * display_address () { return node_address; }
        !          40574:     void fetch (void * addr, unsigned long length, void *& taddr);
        !          40575:     void fetch_string (void * addr, unsigned long length, void *& taddr);
        !          40576:     void free_fetched(void *);
        !          40577:     void flag (int, const char *);
        !          40578:     void print_string (const char *, void *);
        !          40579:     void print_string_brief (void *);
        !          40580:     void null_field (const char *);
        !          40581:     void nz_printf(const char *format, const int i) ;
        !          40582:     void nz_printf(const char *format, const char *p) ;
        !          40583:     void nz_printf(const char *format, const long l) ;
        !          40584:     void ind();
        !          40585: };
        !          40586: 
        !          40587: const char many_spaces[] = "                                                                                                                                                                                                        ";
        !          40588: 
        !          40589: inline void
        !          40590: displayer::ind()
        !          40591: {
        !          40592:     arg->output_stream->write(many_spaces, indent);
        !          40593: }
        !          40594: 
        !          40595: /* call me for full lines */
        !          40596: 
        !          40597: void
        !          40598: displayer::printf (const char * format, ...)
        !          40599: {
        !          40600:     va_list args;
        !          40601:     va_start(args, format);
        !          40602: 
        !          40603:     ind();
        !          40604:     vostream_printf (format, args, *arg->output_stream);
        !          40605:     arg->output_stream->write("\n", 1);
        !          40606:     va_end (args);
        !          40607: }
        !          40608: 
        !          40609: void
        !          40610: displayer::catprintf (const char * format, ...)
        !          40611: {
        !          40612:     va_list args;
        !          40613:     va_start(args, format);
        !          40614: 
        !          40615:     vostream_printf (format, args, *arg->output_stream);
        !          40616:     va_end (args);
        !          40617: }
        !          40618: 
        !          40619: void
        !          40620: displayer::minimal ()
        !          40621: {
        !          40622:     print_ptr(node, print_ptr_copied);
        !          40623: }    
        !          40624: 
        !          40625: void
        !          40626: displayer::print_ptr(const char * label, Pnode node)
        !          40627: {
        !          40628:     if(node || print_null_values) {
        !          40629:        ind();
        !          40630:        catprintf("%s:\t", label);
        !          40631:        print_ptr(node);
        !          40632:        catprintf("\n");
        !          40633:     }
        !          40634: }
        !          40635: 
        !          40636: 
        !          40637: void
        !          40638: displayer::print_ptr(Pnode node, ppc copy_ptr)
        !          40639: {
        !          40640:     void * string = 0;
        !          40641:     void * ncopy;
        !          40642:     void * na = (void *)node;
        !          40643: 
        !          40644:     if(node) {
        !          40645: 
        !          40646:        if(copy_ptr == print_ptr_copy) {
        !          40647:            fetch(na, sizeof(node), ncopy);
        !          40648:            node = Pnode(ncopy);
        !          40649:        } else ncopy = node;
        !          40650: 
        !          40651:        switch(node->base) {
        !          40652:        case CLASS:
        !          40653:            free_fetched(ncopy);
        !          40654:            fetch(na, sizeof(classdef),ncopy);
        !          40655:            node = Pnode(ncopy);
        !          40656:            string = Pclass(node)->string;
        !          40657:            break;
        !          40658:        case ENUM:
        !          40659:            free_fetched(ncopy);
        !          40660:            fetch(na, sizeof(enumdef),ncopy);
        !          40661:            node = Pnode(ncopy);
        !          40662:            string = Penum(node)->string;
        !          40663:            break;
        !          40664:        case NAME:
        !          40665:        case TNAME:
        !          40666:        case PUBLIC:
        !          40667:        case PROTECTED:
        !          40668:            if(!node->baseclass) {
        !          40669:                free_fetched(ncopy);
        !          40670:                fetch(na, sizeof(name),ncopy);
        !          40671:                node = Pnode(ncopy);
        !          40672:                string = Pname(node)->string;
        !          40673:            }
        !          40674:            break;
        !          40675:        }
        !          40676:        if(string) {
        !          40677:            catprintf("<%s |0x%p ", token_name(node->base), na);
        !          40678:            print_string_brief(string);
        !          40679:            catprintf(">");
        !          40680:        }
        !          40681:        else catprintf("<%s |0x%p>", token_name(node->base), na);
        !          40682:        free_fetched (ncopy);
        !          40683:     }
        !          40684:     else catprintf("Null");
        !          40685: }
        !          40686: 
        !          40687: void
        !          40688: displayer::do_node (Pnode& n, node_class cl, tree_node_action& action,
        !          40689:         int depth, Pnode na)
        !          40690: {
        !          40691:     int forced_min = 0;
        !          40692:     int printed_min = 0;
        !          40693:     int prune = 0;
        !          40694: 
        !          40695:     switch(cl) {
        !          40696:       case nc_table:
        !          40697:        if(depth > 0 && !arg->walk_tables)prune = 1;
        !          40698:       case nc_fct:
        !          40699:       case nc_classdef:
        !          40700:       case nc_enumdef:
        !          40701:        if(arg->stop_at_top && depth > 1) prune = 1;
        !          40702:        break;
        !          40703:     }
        !          40704: 
        !          40705:     if((arg->max_depth > 0) && (depth >= arg->max_depth))
        !          40706:        prune = 1;
        !          40707: 
        !          40708:     if(prune || arg->max_depth == 0)
        !          40709:        action = tna_stop;
        !          40710:     else action = tna_continue;
        !          40711: 
        !          40712:     node = n;
        !          40713:     node_address = na;
        !          40714: 
        !          40715:     if(arg->verbose == dt_brief || prune) {
        !          40716:        printed_min = 1;
        !          40717:        minimal();
        !          40718:     }
        !          40719:     else {
        !          40720:        switch(cl)
        !          40721:            {
        !          40722:              default:
        !          40723:            case nc_unused:
        !          40724:                ostream_printf(*arg->error_stream, "Unknown node %d\n", node->base);
        !          40725:                forced_min = 1;
        !          40726: 
        !          40727:            case nc_eof:
        !          40728:                minimal();
        !          40729:                printed_min = 1;
        !          40730:                break;
        !          40731: 
        !          40732:            case nc_virt:
        !          40733:                a_virt ();
        !          40734:                break;
        !          40735: 
        !          40736:            case nc_nlist:
        !          40737:                a_nlist();
        !          40738:                break;
        !          40739: 
        !          40740:            case nc_gen:
        !          40741:                a_gen();
        !          40742:                break;
        !          40743: 
        !          40744:            case nc_vec:
        !          40745:                a_vec();
        !          40746:                break;
        !          40747: 
        !          40748:            case nc_ptr:
        !          40749:                a_ptr();
        !          40750:                break;
        !          40751: 
        !          40752:            case nc_fct:
        !          40753:                a_fct();
        !          40754:                break;
        !          40755: 
        !          40756:            case nc_table:
        !          40757:                a_table();
        !          40758:                break;
        !          40759: 
        !          40760:            case nc_basetype:
        !          40761:                a_basetype();
        !          40762:                break;
        !          40763: 
        !          40764:            case nc_name:
        !          40765:                a_name();
        !          40766:                break;
        !          40767: 
        !          40768:            case nc_expr:
        !          40769:                a_expr();
        !          40770:                break;
        !          40771: 
        !          40772:            case nc_stmt:
        !          40773:                a_stmt();
        !          40774:                break;
        !          40775: 
        !          40776:            case nc_enumdef:
        !          40777:                a_enumdef();
        !          40778:                break;
        !          40779: 
        !          40780:            case nc_classdef:
        !          40781:                a_classdef();
        !          40782:                break;
        !          40783: 
        !          40784:            case nc_baseclass:
        !          40785:                a_basecl ();
        !          40786:                break;
        !          40787: 
        !          40788:            case nc_iline:
        !          40789:                a_iline();
        !          40790:                break;
        !          40791: 
        !          40792:            case nc_ia:
        !          40793:                a_ia();
        !          40794:                break;
        !          40795: 
        !          40796:            }
        !          40797:        if(printed_min) catprintf(">");
        !          40798:     }
        !          40799: }
        !          40800: 
        !          40801: 
        !          40802: void
        !          40803: displayer::flag(int f, const char * n)
        !          40804: {
        !          40805:     if(f)catprintf("%s", n);
        !          40806: }
        !          40807: 
        !          40808: void
        !          40809: displayer::free_fetched (void * addr)
        !          40810: {
        !          40811:     if (arg->fetcher != null_tfp) /* not in the same address space. */
        !          40812:        free ((char *)addr);
        !          40813: }    
        !          40814: 
        !          40815: 
        !          40816: void
        !          40817: displayer::fetch (void * addr, unsigned long length, void *& taddr)
        !          40818: {
        !          40819:     if (arg->fetcher == null_tfp) {    /* in the same address space. */
        !          40820:        taddr = addr;
        !          40821:        err = 0;
        !          40822:     } else {
        !          40823:        taddr = (void *)malloc ((unsigned int)length);
        !          40824:        err = arg->fetcher (arg->fetcher_info,
        !          40825:                            addr,
        !          40826:                            length,
        !          40827:                            0,
        !          40828:                            taddr);
        !          40829:     }
        !          40830: }
        !          40831: 
        !          40832: void
        !          40833: displayer::fetch_string (void * addr, unsigned long length, void *& taddr)
        !          40834: {
        !          40835:     if (arg->fetcher == null_tfp) {    /* in the same address space. */
        !          40836:        taddr = addr;
        !          40837:        err = 0;
        !          40838:     } else {
        !          40839:        taddr = (void *)malloc ((unsigned int)length);
        !          40840:        err = arg->fetcher (arg->fetcher_info,
        !          40841:                            addr,
        !          40842:                            length,
        !          40843:                            1,
        !          40844:                            taddr);
        !          40845:     }
        !          40846: }
        !          40847: 
        !          40848: /* Print the field, only if it has a non_zero value, or requested to print */
        !          40849: /* always */
        !          40850: void
        !          40851: displayer::nz_printf(const char *format, const int i)
        !          40852: {
        !          40853:     if (i || print_null_values) {
        !          40854:        printf(format, i) ;
        !          40855:     }
        !          40856: } 
        !          40857: 
        !          40858: void
        !          40859: displayer::nz_printf(const char *format, const char *p)
        !          40860: {
        !          40861:     if (p || print_null_values) {
        !          40862:        printf(format, (p ? p : "0")) ;
        !          40863:     }
        !          40864: } 
        !          40865: 
        !          40866: 
        !          40867: void 
        !          40868: displayer::nz_printf(const char *format, const long i)
        !          40869: {
        !          40870:     if (i || print_null_values) {
        !          40871:        printf(format, i) ;
        !          40872:     }
        !          40873: } 
        !          40874: 
        !          40875: void 
        !          40876: displayer::a_node() 
        !          40877: {
        !          40878:     struct node &n = *node ;
        !          40879: 
        !          40880:     nz_printf("$node", n.permanent);
        !          40881: //    nz_printf("n_key:\t%d", (int)n.n_key) ;
        !          40882:     nz_printf("permanent:\t%d", n.permanent) ;
        !          40883:     nz_printf("baseclass:\t%d", n.baseclass) ;
        !          40884: }
        !          40885:   
        !          40886:   
        !          40887: 
        !          40888: void 
        !          40889: displayer::a_type()
        !          40890: {
        !          40891:     struct type& t = *Ptype(node);
        !          40892:     int show_up =  t.defined  /* || t.inline_temp_index != 0 */;
        !          40893: 
        !          40894:     if(show_up) {
        !          40895:        printf("$type") ;
        !          40896:        nz_printf("defined:\t%d", t.defined) ;
        !          40897:        // nz_printf("inline_temp_index:\t%d", t.inline_temp_index);
        !          40898:        indent += Indent_Increment;
        !          40899:     }
        !          40900:     a_node();
        !          40901:     if(show_up) indent -= Indent_Increment;
        !          40902: } 
        !          40903:   
        !          40904: 
        !          40905:   
        !          40906:   
        !          40907: 
        !          40908: void
        !          40909: displayer::null_field(const char * name)
        !          40910: {
        !          40911:   nz_printf( "%s:\t0", name);
        !          40912: }
        !          40913: 
        !          40914: 
        !          40915: void 
        !          40916: displayer::a_basecl()
        !          40917: {
        !          40918:     struct basecl& bc = *Pbcl(node);
        !          40919: 
        !          40920:     printf("$basecl %s |0x%p",
        !          40921:           token_name(node->base),
        !          40922:           node_address);
        !          40923:     
        !          40924:     nz_printf ("ppp:\t%s", token_name(bc.ppp)) ;
        !          40925:     nz_printf ("allocated:\t%d", bc.allocated) ;
        !          40926:     nz_printf ("promoted:\t%d", bc.promoted) ;
        !          40927:     print_ptr("bclass", bc.bclass);
        !          40928:     nz_printf ("ptr_offset:\t%d", bc.ptr_offset) ;
        !          40929:     nz_printf ("obj_offset:\t%d", bc.obj_offset) ;
        !          40930:     indent += Indent_Increment;
        !          40931:     a_node();                  /* do the supertype. */
        !          40932:     indent -= Indent_Increment;
        !          40933: }
        !          40934: 
        !          40935: 
        !          40936: 
        !          40937: 
        !          40938: void
        !          40939: displayer::a_basetype ()
        !          40940: {
        !          40941:     struct basetype& bt = *Pbase(node);
        !          40942:   
        !          40943:     printf("$basetype %s |0x%p",
        !          40944:           token_name(node->base),
        !          40945:           node_address);
        !          40946: 
        !          40947:     ind();
        !          40948:     catprintf("Flags:\t");
        !          40949:     flag(bt.b_unsigned, "unsigned ");
        !          40950:     flag(bt.b_signed, "signed ");
        !          40951:     flag(bt.b_volatile, "volatile ");
        !          40952:     flag(bt.b_const, "const ");
        !          40953:     flag(bt.b_typedef, "typedef ");
        !          40954:     flag(bt.b_virtual, "virtual ");
        !          40955:     flag(bt.b_short, "short ");
        !          40956:     flag(bt.b_long, "long ");
        !          40957:     catprintf("\n");
        !          40958:     nz_printf( "b_bits:\t%d", bt.b_bits);
        !          40959:     nz_printf( "b_offset:\t%d", bt.b_offset);
        !          40960:     nz_printf( "b_sto:\t%s", bt.b_sto ? token_name(bt.b_sto) : 0);
        !          40961:     switch(bt.discriminator(0)) {
        !          40962:       case 1:
        !          40963:        print_ptr("b_fieldtype", bt.b_fieldtype);
        !          40964:        break;
        !          40965:       case 2:
        !          40966:        nz_printf( "b_linkage:\t%s", bt.b_linkage ? "C" : "0(C++)");
        !          40967:     }
        !          40968: 
        !          40969:     print_ptr("b_name", bt.b_name);
        !          40970:     print_ptr("b_table", bt.b_table);
        !          40971:     // print_ptr("b_field", bt.b_field);
        !          40972:     print_ptr("b_xname", bt.b_xname);
        !          40973: 
        !          40974:     indent += Indent_Increment;
        !          40975:     a_type();                  /* do the supertype. */
        !          40976:     indent -= Indent_Increment;
        !          40977:     
        !          40978: }
        !          40979: 
        !          40980: void
        !          40981: displayer::print_loc(loc& loc)
        !          40982: {
        !          40983:   catprintf("file %d line %d", (int)loc.file, (int)loc.line);
        !          40984: }
        !          40985: 
        !          40986: 
        !          40987: void
        !          40988: displayer::print_string_brief(void * addr)
        !          40989: {
        !          40990:   void * tmp;
        !          40991:   
        !          40992:   fetch_string (addr, 1000, tmp);
        !          40993:   *arg->output_stream << (char *)tmp;
        !          40994:   free_fetched (tmp);
        !          40995: }
        !          40996: 
        !          40997: void
        !          40998: displayer::print_string(const char * label, void * addr)
        !          40999: {
        !          41000:   ind();
        !          41001:   catprintf("%s:\t", label);
        !          41002:   print_string_brief(addr);
        !          41003:   *arg->output_stream << "\n";
        !          41004: }
        !          41005: 
        !          41006: void
        !          41007: displayer::a_expr(int from_name)
        !          41008: {
        !          41009:     struct expr& e = *Pexpr(node);
        !          41010:   
        !          41011:     if(from_name) printf("$expr");
        !          41012:     else printf("$expr %s |0x%p",
        !          41013:                token_name(node->base),
        !          41014:                node_address);
        !          41015:   
        !          41016:     print_ptr("tp", e.tp);
        !          41017:   
        !          41018:     switch(e.discriminator(1)) {
        !          41019:       case 0: break;
        !          41020:       case 1:
        !          41021:        print_ptr("e1", e.e1);
        !          41022:        break;
        !          41023:       case 2:
        !          41024:        printf("i1:\t%ld", e.i1);
        !          41025:        break;
        !          41026:       case 3:
        !          41027:        print_string("string", (void *)e.string);
        !          41028:     }
        !          41029: 
        !          41030:     switch(e.discriminator(2)) {
        !          41031:       case 0: break;
        !          41032:       case 1:
        !          41033:        print_ptr("e2", e.e2);
        !          41034:        break;
        !          41035:       case 2:
        !          41036:        printf("i2:\t%ld", e.i2);
        !          41037:        break;
        !          41038:       case 3:
        !          41039:        print_string("string2", (void *)e.string2);
        !          41040:        break;
        !          41041:       case 4:
        !          41042:        print_ptr("n_initializer", e.n_initializer);
        !          41043:     }
        !          41044: 
        !          41045:     switch(e.discriminator(3)) {
        !          41046:       case 0:
        !          41047:        break;
        !          41048:       case 1: print_ptr ("tp2", e.tp2); break;
        !          41049:       case 2: print_ptr ("fct_name", e.fct_name); break;
        !          41050:       case 3: print_ptr ("cond", e.cond); break;
        !          41051:       case 4: print_ptr ("mem", e.mem); break;
        !          41052:       case 5: print_ptr ("as_type", e.as_type); break;
        !          41053:       case 6: print_ptr ("n_table", e.n_table); break;
        !          41054:       case 7: print_ptr ("il", e.il); break;
        !          41055:       case 8: print_ptr ("query_this", e.query_this); break;
        !          41056:     }
        !          41057: 
        !          41058:   indent += Indent_Increment;
        !          41059:   a_node();
        !          41060:   indent -= Indent_Increment;
        !          41061: 
        !          41062: }
        !          41063: 
        !          41064: void
        !          41065: displayer::a_name()
        !          41066: {
        !          41067:     struct name& n = *Pname(node);
        !          41068: 
        !          41069: 
        !          41070:     ind();
        !          41071:     catprintf("$name %s |0x%p ",
        !          41072:              token_name(node->base),
        !          41073:              node_address);
        !          41074:     print_string_brief((void *)n.string);
        !          41075:     *arg->output_stream << "\n";
        !          41076: 
        !          41077:     nz_printf("n_key:\t%d", (int)n.n_key) ;
        !          41078:     nz_printf( "n_oper:\t\t%s", n.n_oper ?
        !          41079:              token_name(n.n_oper) : 0);
        !          41080:     nz_printf( "n_sto:\t\t%s", n.n_sto ?
        !          41081:              token_name(n.n_sto) : 0);
        !          41082:     nz_printf( "n_stclass:\t%s", n.n_stclass ?
        !          41083:              token_name(n.n_stclass) : 0);
        !          41084:     nz_printf( "n_scope:\t%s", n.n_scope ?
        !          41085:              token_name(n.n_scope) : 0);
        !          41086:     nz_printf( "n_union:\t%d", n.n_union);
        !          41087:     nz_printf( "n_evaluated:\t%d", n.n_evaluated);
        !          41088:     nz_printf( "n_xref:\t\t%d", n.n_xref);
        !          41089:     nz_printf( "lex_level:\t%d", n.lex_level);
        !          41090:     nz_printf( "n_protect:\t%s", n.n_protect ?
        !          41091:              token_name(n.n_protect) : 0);
        !          41092:     if (n.n_dcl_printed || print_null_values) {
        !          41093:        ind();
        !          41094:        catprintf("n_dcl_printed:\t%d", n.n_dcl_printed);
        !          41095: 
        !          41096:        switch(n.n_dcl_printed)
        !          41097:            {
        !          41098:            case 0:
        !          41099:                catprintf("(not)\n");
        !          41100:                break;
        !          41101:            case 1:
        !          41102:                printf("(declaration)\n");
        !          41103:                break;
        !          41104:            case 2:
        !          41105:                printf("(definition)\n");
        !          41106:                break;
        !          41107:            }
        !          41108:        
        !          41109:     }
        !          41110:     if(n.n_template_arg) {
        !          41111:        ind();
        !          41112:        catprintf( "n_template_arg:\t");
        !          41113:        switch(n.n_template_arg) 
        !          41114:            { 
        !          41115:            case template_type_formal:
        !          41116:                catprintf("template_type_formal\n");
        !          41117:                break;
        !          41118:            case template_expr_formal:
        !          41119:                catprintf("template_expr_formal\n");
        !          41120:                break;
        !          41121:            case template_stmt_tree_formal:
        !          41122:                catprintf("template_stmt_formal\n");
        !          41123:                break;
        !          41124:            case template_expr_tree_formal:
        !          41125:                catprintf("template_expr_tree_formal\n");
        !          41126:                break;
        !          41127:            case template_actual_arg_dummy:
        !          41128:                catprintf("template_actual_arg_dummy\n");
        !          41129:                break;
        !          41130:            } ;
        !          41131:     }
        !          41132:     nz_printf( "n_addr_taken:\t%d", n.n_addr_taken);
        !          41133:     nz_printf( "n_used:\t\t%d", n.n_used);
        !          41134:     nz_printf( "n_assigned_to:\t%d", n.n_assigned_to);
        !          41135:     ind();
        !          41136:     catprintf("loc:\t\t");
        !          41137:     print_loc(n.where);
        !          41138:     catprintf("\n");
        !          41139:     nz_printf( "n_offset:\t%d", n.n_offset);
        !          41140:     // if(n.output_string) { print_string("output_string", (void *)n.output_string); }
        !          41141:     nz_printf( "n_val:\t\t%ld", n.n_val);
        !          41142: 
        !          41143:     print_ptr("n_list", n.n_list);
        !          41144:     print_ptr("n_tbl_list", n.n_tbl_list);
        !          41145:     if(n.n_gen_fct_name)
        !          41146:        print_string("n_gen_fct_name", n.n_gen_fct_name);
        !          41147:     if(n.n_template_arg_string) {
        !          41148:        print_string("n_template_arg_string",
        !          41149:                     n.n_template_arg_string);
        !          41150:     }
        !          41151:     switch(n.discriminator(0)) {
        !          41152:     case 2: print_ptr("n_realscope", n.n_realscope); break;
        !          41153:     case 1: print_ptr("n_qualifier", n.n_qualifier); break;
        !          41154:     }
        !          41155:     nz_printf("n_val:\t%ld", n.n_val);
        !          41156: 
        !          41157:     indent += Indent_Increment;
        !          41158:     a_expr(1);                 /* do the supertype. */
        !          41159:     indent -= Indent_Increment;
        !          41160: }
        !          41161: 
        !          41162: void
        !          41163: displayer::a_fct()
        !          41164: {
        !          41165:     struct fct& f = *Pfct(node);
        !          41166: 
        !          41167:     printf("$fct %s |0x%p",
        !          41168:           token_name(node->base),
        !          41169:           node_address);
        !          41170: 
        !          41171: 
        !          41172:     printf("nargs:\t\t%d", f.nargs);
        !          41173:     printf("nargs_known:\t%d%s", f.nargs_known,
        !          41174:           f.nargs_known == 0 ? " UNKNOWN" :
        !          41175:           (f.nargs_known == 1 ? " KNOWN" :
        !          41176:            (f.nargs_known == ELLIPSIS ? "ELLIPSIS" : "" )));
        !          41177:     nz_printf( "f_vdef:\t\t%d", f.f_vdef);
        !          41178:     printf("f_inline:\t%d%s", f.f_inline,
        !          41179:           f.f_inline == 0 ? "" :
        !          41180:           f.f_inline == 1 ? " inline" :
        !          41181:           f.f_inline == 2 ? " inline in expansion" : "");
        !          41182:     nz_printf( "f_const:\t\t%d", f.f_const);
        !          41183:     nz_printf( "f_static:\t\t%d", f.f_static);
        !          41184:     nz_printf( "f_virtual:\t%d", f.f_virtual);
        !          41185:     nz_printf( "f_imeasure:\t%d", f.f_imeasure);
        !          41186:     print_string("f_signature", (void *)f.f_signature);
        !          41187: 
        !          41188:     print_ptr("returns", f.returns);
        !          41189:     print_ptr("argtype", f.argtype);
        !          41190:     print_ptr("s_returns", f.s_returns);
        !          41191:     print_ptr("f_this", f.f_this);
        !          41192:     print_ptr("memof", f.memof);
        !          41193:     print_ptr("body", f.body);
        !          41194:     print_ptr("f_init", f.f_init);
        !          41195:     print_ptr("f_expr", f.f_expr);
        !          41196:     print_ptr("last_expanded", f.last_expanded);
        !          41197:     print_ptr("f_result", f.f_result);
        !          41198:     print_ptr("f_args", f.f_args);
        !          41199:     print_ptr("local_classes", f.local_class);
        !          41200:     
        !          41201:     indent += Indent_Increment;
        !          41202:     a_type();                  /* do the supertype. */
        !          41203:     indent -= Indent_Increment;
        !          41204: }
        !          41205: 
        !          41206: void
        !          41207: displayer::a_stmt ()
        !          41208: {
        !          41209:     struct stmt& s = *Pstmt(node);
        !          41210: 
        !          41211:     ind();
        !          41212:     catprintf("$stmt %s |0x%p ",
        !          41213:              token_name(node->base),
        !          41214:              node_address);
        !          41215:     print_loc(s.where);
        !          41216:     *arg->output_stream << "\n";
        !          41217: 
        !          41218:     ind();
        !          41219:     *arg->output_stream << "where:\t";
        !          41220:     print_loc(s.where);
        !          41221:     *arg->output_stream << "\n";
        !          41222: 
        !          41223:     print_ptr("s", s.s);
        !          41224:     print_ptr("s_list", s.s_list);
        !          41225:     print_ptr("memtbl", s.memtbl);
        !          41226:     switch(s.discriminator(0)) {
        !          41227:       case 1: print_ptr("d", s.d); break;
        !          41228:       case 2: print_ptr("e2", s.e2); break;
        !          41229:       case 3: print_ptr("has_default", s.has_default); break;
        !          41230:       case 4: nz_printf("case_value:\t0x%x", s.case_value);
        !          41231:       case 5: print_ptr("ret_tp", s.ret_tp); break;
        !          41232:     }
        !          41233:     switch(s.discriminator(1)) {
        !          41234:       case 1: print_ptr("e", s.e); break;
        !          41235:       case 2: nz_printf("own_tbl:\t%d", s.own_tbl); break;
        !          41236:       case 3: print_ptr("s2", s.s2); break;
        !          41237:     }
        !          41238: 
        !          41239:     switch(s.discriminator(2)) {
        !          41240:        case 1: print_ptr("for_init", s.for_init); break;
        !          41241:        case 2: print_ptr("else_stmt",s.for_init); break;
        !          41242:        case 3: print_ptr("case_list", s.case_list); break;
        !          41243:     }
        !          41244: }
        !          41245: 
        !          41246: void
        !          41247: displayer::a_enumdef ()
        !          41248: {
        !          41249:    struct enumdef& e = *Penum(node);
        !          41250: 
        !          41251:    printf("$enumdef %s |0x%p",
        !          41252:          token_name(node->base),
        !          41253:          node_address);
        !          41254: 
        !          41255:    nz_printf( "e_body:\t\t%d", e.e_body);
        !          41256:    nz_printf( "no_of_enumerators: %d", 
        !          41257:             e.no_of_enumerators);
        !          41258:    nz_printf( "strlen:\t%d", e.strlen);
        !          41259:    print_string ("string", (void *)e.string);
        !          41260: 
        !          41261:    print_ptr("mem", e.mem);
        !          41262:    print_ptr("e_type", e.e_type);
        !          41263:    indent += Indent_Increment;
        !          41264:    a_type();                   /* do the supertype. */
        !          41265:    indent -= Indent_Increment;
        !          41266: }
        !          41267: 
        !          41268: void
        !          41269: displayer::a_classdef ()
        !          41270: {
        !          41271:     struct classdef& c = *Pclass(node);
        !          41272: 
        !          41273:     ind();
        !          41274:     catprintf("$classdef %s |0x%p ",
        !          41275:              token_name(node->base),
        !          41276:              node_address);
        !          41277:     print_string_brief(c.string);
        !          41278:     *arg->output_stream << "\n";
        !          41279:     ind();
        !          41280:     catprintf("class_base:\t");
        !          41281:     switch(c.class_base) 
        !          41282:        { 
        !          41283:          case vanilla_class:
        !          41284:            *arg->output_stream << "vanilla_class\n";
        !          41285:            break;
        !          41286:          case template_class:
        !          41287:            *arg->output_stream << "template_class\n";
        !          41288: Template_Class:            
        !          41289:            nz_printf("inst:\t\t%p", (int)Ptclass(&c)->inst);
        !          41290:            break;
        !          41291:          case instantiated_template_class:
        !          41292:            *arg->output_stream << "instantiated_template_class\n";
        !          41293:            goto Template_Class;
        !          41294:          case uninstantiated_template_class:
        !          41295:            *arg->output_stream << "uninstantiated_template_class\n";
        !          41296:            goto Template_Class;
        !          41297:          case relationship_class:
        !          41298:            *arg->output_stream << "relationship_class\n";
        !          41299:            break;
        !          41300:          case defining_class:
        !          41301:            *arg->output_stream << "defining_class\n";
        !          41302:            break;
        !          41303:        }
        !          41304: 
        !          41305:     nz_printf( "c_body:\t\t%d", c.c_body);
        !          41306:     printf("csu:\t\t%s", 
        !          41307:           token_name(c.csu));
        !          41308:     nz_printf( "obj_align:\t%d", c.obj_align);
        !          41309:     if(c.c_xref) {
        !          41310:        ind();
        !          41311:        catprintf( "c_xref:\t%x", c.c_xref);
        !          41312:        flag(c.c_xref & 1, "has-vptr ");
        !          41313:        flag(c.c_xref & 2, "X(X&)-defined ");
        !          41314:        flag(c.c_xref & 4, "operator=(X&)-defined ");
        !          41315:        flag(c.c_xref & 8, "has-vbaseptr(s) ");
        !          41316:        *arg->output_stream << "\n";
        !          41317:     }
        !          41318:     nz_printf( "virt_count:\t%d", c.virt_count);
        !          41319:     nz_printf( "virt_merge:\t%d", c.virt_merge);
        !          41320:     nz_printf( "c_abstract:\t%d", c.c_abstract);
        !          41321:     nz_printf( "has_vvtab:\t%d", c.has_vvtab);
        !          41322:     nz_printf( "strlen:\t%d", c.strlen);
        !          41323:     print_string ("string", (void *)c.string);
        !          41324:     nz_printf( "obj_size:\t%d", c.obj_size);
        !          41325:     nz_printf( "real_size:\t%d", c.real_size);
        !          41326:     nz_printf("lex_level:\t%d", c.lex_level);
        !          41327:     if(c.lcl)print_string("lcl", c.lcl);
        !          41328: 
        !          41329:     print_ptr("baselist", c.baselist);
        !          41330:     print_ptr("mem_list", c.mem_list);
        !          41331:     print_ptr("memtbl", c.memtbl);
        !          41332:     print_ptr("friend_list", c.friend_list);
        !          41333:     print_ptr("pubdef", c.pubdef);
        !          41334:     print_ptr("tn_list", c.tn_list); /* not brief */
        !          41335:     print_ptr("in_class", c.in_class);
        !          41336:     print_ptr("in_fct", c.in_fct);
        !          41337:     print_ptr("this_type", c.this_type);
        !          41338:     print_ptr("virt_list", c.virt_list); 
        !          41339:     print_ptr("c_ctor", c.c_ctor);
        !          41340:     print_ptr("c_dtor", c.c_dtor);
        !          41341:     print_ptr("c_itor", c.c_itor);
        !          41342:     print_ptr("conv", c.conv);
        !          41343:     indent += Indent_Increment;
        !          41344:     a_type();                  /* do the supertype. */
        !          41345:     indent -= Indent_Increment;
        !          41346: }
        !          41347: 
        !          41348: 
        !          41349: void
        !          41350: displayer::a_virt()
        !          41351: {
        !          41352:     virt& v = *Pvirt(node);
        !          41353:     void * vna;
        !          41354:     void * vna_e;
        !          41355:     int vx;
        !          41356: 
        !          41357:     printf("$virt %s |0x%p ",
        !          41358:           token_name(node->base),
        !          41359:           node_address);
        !          41360:     
        !          41361:     print_ptr("next", v.next);
        !          41362:     if(v.n_init) {
        !          41363:        printf("n_init:\t%d", v.n_init);
        !          41364:        printf("virt_init:");
        !          41365:        for (vna = v.virt_init, vx = 0; vx < (v.n_init - 1);
        !          41366:             vna = (char *)vna + sizeof (velem), vx++)
        !          41367:            {
        !          41368:                fetch(vna, sizeof (velem), vna_e);
        !          41369:                struct velem * ve = (struct velem *) vna_e;
        !          41370:                ind();
        !          41371:                catprintf("%d offset %d\t", vx, ve->offset);
        !          41372:                print_ptr(ve->n);
        !          41373:                free_fetched(vna_e);
        !          41374:            }
        !          41375:     }
        !          41376:     print_ptr("vclass", v.vclass);
        !          41377:     nz_printf( "\nis_vbase:\t %d", v.is_vbase);
        !          41378:     nz_printf( "\nprinted:\t %d", v.printed);
        !          41379: }
        !          41380: 
        !          41381: void
        !          41382: displayer::a_table ()
        !          41383: {
        !          41384:    struct table& t = *Ptable(node);
        !          41385:    int x;
        !          41386:    int y;
        !          41387:    void * nlist;
        !          41388:    void * slist;
        !          41389: 
        !          41390:    printf("$table %s |0x%p",
        !          41391:          token_name(node->base),
        !          41392:          node_address);
        !          41393: 
        !          41394:     printf("init_stat:\t%d%s", t.init_stat,
        !          41395:           t.init_stat == 0 ? " not simplified" :
        !          41396:           t.init_stat == 1 ? " simplified, no inits" :
        !          41397:           t.init_stat == 2 ? " simplified, inits" :
        !          41398:           "");
        !          41399:    printf("size:\t%d", t.size);
        !          41400:    printf("hashsize:\t%d", t.hashsize);
        !          41401:    printf("free_slot:\t%d", t.free_slot);
        !          41402: 
        !          41403:    /* it looks like there is an array of Pnames here ... */
        !          41404:    *arg->output_stream << "\n";
        !          41405:    ind();
        !          41406:    *arg->output_stream << "entries:\n";
        !          41407:    fetch((void *)t.entries, t.size * sizeof(Pname), nlist);
        !          41408:    Pname * tmp_nlist = (Pname *)nlist;
        !          41409:    for(x = 0; x < t.size; x ++) {
        !          41410:        if(tmp_nlist[x]) {
        !          41411:           ind();
        !          41412:           *arg->output_stream << x;
        !          41413:           *arg->output_stream << "\t";
        !          41414:           print_ptr(tmp_nlist[x]);
        !          41415:           unsigned char tmp_name_s[sizeof(name)];
        !          41416:           void * tmp_name;
        !          41417:           tmp_name = (void *)&tmp_name_s[0];
        !          41418:           fetch(tmp_nlist[x], sizeof(name), tmp_name);
        !          41419:           catprintf(" key %d\n", Pname(tmp_name)->n_key);
        !          41420:        }
        !          41421:    }
        !          41422:    free_fetched(nlist);
        !          41423:    /* and then an array of shorts for the hash table. */
        !          41424:    /* we really need a tabular format here, alright. */
        !          41425:    ind();
        !          41426:    *arg->output_stream << "hashtbl:\n";
        !          41427:    fetch(t.hashtbl, t.hashsize * sizeof(short), slist);
        !          41428:    short * tmp_slist = (short *)slist;
        !          41429:    for(x = 0;; x++ ) {
        !          41430:        for (y = 0; y < 11; y ++) {
        !          41431:        if(((x * 12) + y) > t.hashsize) break;
        !          41432:           catprintf("%6d ", tmp_slist[(x*12)+y]);
        !          41433:        }
        !          41434:        *arg->output_stream << "\n";
        !          41435:        if(((x * 12) + y) > t.hashsize) break;
        !          41436:    }
        !          41437: 
        !          41438:    free_fetched (slist);
        !          41439: 
        !          41440:    print_ptr("t_name", t.t_name);
        !          41441:    print_ptr("real_block", t.real_block);
        !          41442:    print_ptr("name", t.t_name);
        !          41443:    print_ptr("next", t.next);
        !          41444: }
        !          41445: 
        !          41446: void
        !          41447: displayer::a_gen ()
        !          41448: {
        !          41449:     struct gen& g = *Pgen(node);
        !          41450: 
        !          41451:     printf("$gen %s |0x%p",
        !          41452:           token_name(node->base),
        !          41453:           node_address);
        !          41454: 
        !          41455:     print_ptr ("fct_list", g.fct_list);
        !          41456:     indent += Indent_Increment;
        !          41457:     a_type();                  /* do the supertype. */
        !          41458:     indent -= Indent_Increment;
        !          41459: }
        !          41460: 
        !          41461: void
        !          41462: displayer::a_vec ()
        !          41463: {
        !          41464:    struct vec& v = *Pvec(node);
        !          41465: 
        !          41466:    printf("$vec %s |0x%p",
        !          41467:          token_name(node->base),
        !          41468:          node_address);
        !          41469:    printf("size:\t\t%d", v.size);
        !          41470:    print_ptr ("typ", v.typ);
        !          41471:    print_ptr ("dim", v.dim);
        !          41472: }
        !          41473: 
        !          41474: void
        !          41475: displayer::a_ptr ()
        !          41476: {
        !          41477:     struct ptr& p = *Pptr(node);
        !          41478: 
        !          41479:     printf("$ptr %s |0x%p",
        !          41480:           token_name(node->base),
        !          41481:           node_address);
        !          41482:     ind();
        !          41483:     printf("rdo:\t\t%d", p.rdo);
        !          41484:     ind();
        !          41485: 
        !          41486:     print_ptr ("typ", p.typ);
        !          41487:     print_ptr ("memof", p.memof);
        !          41488: }
        !          41489: 
        !          41490: 
        !          41491: void
        !          41492: displayer::a_nlist()
        !          41493: {
        !          41494:     name_list& n = *Plist(node);
        !          41495: 
        !          41496:     printf("$name_list %s |0x%p ",
        !          41497:           token_name(node->base),
        !          41498:           node_address);
        !          41499:     
        !          41500:     print_ptr("f", n.f);
        !          41501:     print_ptr("l", n.l);
        !          41502: }
        !          41503: 
        !          41504: void
        !          41505: displayer::a_iline()
        !          41506: {
        !          41507:     struct iline& i = *(struct iline *)node;
        !          41508: 
        !          41509:     printf("$iline %s |0x%p ",
        !          41510:           token_name(node->base),
        !          41511:           node_address);
        !          41512:     
        !          41513:     print_ptr("fct_name", i.fct_name);
        !          41514:     print_ptr("i_next", i.i_next);
        !          41515:     print_ptr("i_table", i.i_table);
        !          41516:     nz_printf("i_slots:\t%d", i.i_slots);
        !          41517:     print_ptr("i_args", i.i_args);
        !          41518: }
        !          41519: 
        !          41520: void
        !          41521: displayer::a_ia()
        !          41522: {
        !          41523:     struct ia& i = *(struct ia *)node;
        !          41524: 
        !          41525:     printf("$ia %s |0x%p ",
        !          41526:           token_name(node->base),
        !          41527:           node_address);
        !          41528:     
        !          41529:     print_ptr("local", i.local);
        !          41530:     print_ptr("arg", i.arg);
        !          41531:     print_ptr("tp", i.tp);
        !          41532: }
        !          41533: 
        !          41534: static int fetcher (void * info,
        !          41535:                    void * pointer,
        !          41536:                    unsigned long length,
        !          41537:                    int zero_stop,  /* for character strings.*/
        !          41538:                    void * target)
        !          41539: {
        !          41540:     displayer * d = (displayer *)info;
        !          41541:     if(d->arg->fetcher)
        !          41542:        return d->arg->fetcher(d->arg->fetcher_info, pointer, length,
        !          41543:                               zero_stop, target);
        !          41544: }
        !          41545: 
        !          41546: static void 
        !          41547: do_node (Pnode& node, node_class cl, void * info, tree_node_action& action,
        !          41548:         int depth, Pnode na, tree_walk_tree&, int&)
        !          41549: {
        !          41550:     displayer * d = (displayer *)info;
        !          41551:     d->do_node(node, cl, action, depth, na);
        !          41552:     d->arg->output_stream->write("\n", 1);
        !          41553: }
        !          41554: 
        !          41555: 
        !          41556: /* Note -- declared extern "C" in tree_dump.h. */
        !          41557: 
        !          41558: void
        !          41559: display_cfront_node (dcn_arg& arg, Pnode n)
        !          41560: {
        !          41561:     tree_walk_control twc;
        !          41562:     displayer d (arg);
        !          41563:     
        !          41564:     if(arg.verbose == dt_normal)arg.max_depth = 0;
        !          41565:     twc.callback_info = (void *)&d;
        !          41566:     if(arg.fetcher) twc.fetcher = fetcher;
        !          41567:     twc.action_proc = do_node;
        !          41568:     twc.error_stream = arg.error_stream;
        !          41569:     twc.nodes_seen_hash = arg.nodes_seen_hash;
        !          41570:     twc.resolve_by_name = 0;   /* we want to display the by_name nodes */
        !          41571:     twc.dont_chase_lists_top = 1; /* don't display n_list or s_list peers
        !          41572:                                     at the top level. */
        !          41573: 
        !          41574:     walk_tree(twc, n);
        !          41575: 
        !          41576:     arg.error_stream->flush();
        !          41577:     arg.output_stream->flush();
        !          41578: }
        !          41579: 
        !          41580: 
        !          41581: extern "C" void _fcout();
        !          41582: void _fcout () { cout.flush(); }
        !          41583: 0707071010112046001004440001630000160000010207660466055415100001400000003407tree_dump.h/* ident "@(#)ctrans:src/tree_dump.h   1.2" */
        !          41584: /* -*- Mode: C -*- Begin tree_dump.h */
        !          41585: 
        !          41586: #ifndef _DUMP_TREE
        !          41587: #define _DUMP_TREE
        !          41588: 
        !          41589: #include "tree_walk.h"
        !          41590: #include <iostream.h>
        !          41591: #include "hash.h"
        !          41592: 
        !          41593: enum dump_tree_verbosity {
        !          41594:     dt_brief = 1,              /* minimal identification */
        !          41595:     dt_normal = 2,             /* all data, outpointers Brief (one level) */
        !          41596:     dt_recursive_0 = 3,                /* minimal, but recurse down.
        !          41597:                                   (outpointers Recursive_0) */
        !          41598:     dt_recursive_1 = 4,                /* all data, outpointers Recursive_2. */
        !          41599: };
        !          41600: 
        !          41601: class dcn_arg {
        !          41602:   public:
        !          41603:     int version;
        !          41604:     dump_tree_verbosity verbose;
        !          41605:     tree_fetch_proc fetcher;
        !          41606:     void * fetcher_info;
        !          41607:     ostream* output_stream;
        !          41608:     ostream* error_stream;
        !          41609:     int max_depth;
        !          41610:     Hash * nodes_seen_hash;
        !          41611:     /* end of version 1 */
        !          41612:     int walk_tables;
        !          41613:     /* end of version 2 */
        !          41614:     int stop_at_top;
        !          41615:     dcn_arg () { version = 2; 
        !          41616:                 nodes_seen_hash = 0;
        !          41617:                 fetcher = null_tfp; 
        !          41618:                 output_stream = &cout;
        !          41619:                 error_stream = &cerr; 
        !          41620:                 max_depth = -1;
        !          41621:                 walk_tables = 1;
        !          41622:                 stop_at_top = 0;
        !          41623:             };
        !          41624: };
        !          41625: 
        !          41626: 
        !          41627: extern "C" {
        !          41628:     void display_cfront_node (dcn_arg&, Pnode);
        !          41629: }
        !          41630: #else
        !          41631: 
        !          41632: typedef enum dump_tree_verbosity {
        !          41633:     dt_brief = 1,              /* minimal identification */
        !          41634:     dt_normal = 2,             /* all data, outpointers Brief (one level) */
        !          41635:     dt_recursive_0 = 3,                /* minimal, but recurse down.
        !          41636:                                   (outpointers Recursive_0) */
        !          41637:     dt_recursive_1 = 4,                /* all data, outpointers Recursive_2. */
        !          41638: } dump_tree_verbosity;
        !          41639: 
        !          41640: struct dcn_arg {
        !          41641:     int version;               /* must be 1 for now. */
        !          41642:     dump_tree_verbosity verbose;
        !          41643:     int (*fetcher) ();
        !          41644:     void * fetcher_info;
        !          41645:     void * output_stream;      /* these are c++ streams */
        !          41646:     void * error_stream;
        !          41647:     int max_depth;
        !          41648:     void * nodes_seen_hash;
        !          41649:     int walk_tables;
        !          41650:     int stop_at_top;
        !          41651: };
        !          41652: 
        !          41653: void display_cfront_node ();
        !          41654: #endif
        !          41655: 
        !          41656: /* End tree_dump.h */
        !          41657: 0707071010112046051004440001630000160000010212000466055417300001400000066517tree_walk.c/* ident "@(#)ctrans:src/tree_walk.c   1.2" */
        !          41658: /* 
        !          41659:        tree_walk.c
        !          41660:        Utilities for tree-walking 
        !          41661: */
        !          41662: 
        !          41663: #include "cfront.h"
        !          41664: #include "tree_walk.h"
        !          41665: #include <stdarg.h>
        !          41666: #include "hash.h"
        !          41667: // #include <alloca.h>
        !          41668: // ************ need to add an explicit call of free
        !          41669: // ************ make it an ifdef
        !          41670: // ??? #include <streamdefs.h>
        !          41671: #include <malloc.h>
        !          41672: 
        !          41673: class walker {
        !          41674:     tree_walk_control control;
        !          41675:     Pnode orig_addr;
        !          41676:     Hash *nodes_seen_hash;
        !          41677:     int depth;
        !          41678:     int made_ht;
        !          41679:     tree_walk_tree * cur_tree;
        !          41680:   public:
        !          41681:     walker(tree_walk_control& c) ;
        !          41682:  
        !          41683:     ~walker () {
        !          41684:        if(made_ht) delete nodes_seen_hash;
        !          41685:     }
        !          41686:     tree_node_action walk (Pnode&);
        !          41687:     tree_node_action walk_ (Pnode& n) 
        !          41688:     {
        !          41689:        if(n) {
        !          41690:            int save_depth = depth;
        !          41691:            tree_walk_tree * save_cur_tree = cur_tree;
        !          41692: 
        !          41693:            depth ++;
        !          41694:            if(control.alloc_stack_bytes) {
        !          41695:                cur_tree = (tree_walk_tree *)
        !          41696:                    // alloca (control.alloc_stack_bytes + sizeof (tree_walk_tree));
        !          41697:                    malloc(control.alloc_stack_bytes + sizeof (tree_walk_tree));
        !          41698:                cur_tree->parent = save_cur_tree;
        !          41699:            }
        !          41700:            tree_node_action r = walk(n);
        !          41701:            depth = save_depth;
        !          41702:            return r;
        !          41703:        } else return tna_continue;
        !          41704:     }
        !          41705:        
        !          41706:     tree_node_action walk(Pgen& n) 
        !          41707:     { return walk_ ((struct node * &)n); };
        !          41708:     tree_node_action walk(Pvec& n) 
        !          41709:     { return walk_ ((struct node * &)n); };
        !          41710:     tree_node_action walk(Pptr& n) 
        !          41711:     { return walk_ ((struct node * &)n); };
        !          41712:     tree_node_action walk(Ptype& n) 
        !          41713:     { return walk_ ((struct node * &)n); };
        !          41714:     tree_node_action walk(Pfct& n) 
        !          41715:     { return walk_ ((struct node * &)n); };
        !          41716:     tree_node_action walk(Ptable& n) 
        !          41717:     { return walk_ ((struct node * &)n); };
        !          41718:     tree_node_action walk(Pbase& n) 
        !          41719:     { return walk_ ((struct node * &)n); };
        !          41720:     tree_node_action walk(Pname& n) 
        !          41721:     { return walk_ ((struct node * &)n); };
        !          41722:      tree_node_action walk(Pexpr& n) 
        !          41723:     { return walk_ ((struct node * &)n); };
        !          41724:     tree_node_action walk(Pstmt& n) 
        !          41725:     { return walk_ ((struct node * &)n); };
        !          41726:     tree_node_action walk(Pblock& n) 
        !          41727:     { return walk_ ((struct node * &)n); };
        !          41728:     tree_node_action walk(Penum& n) 
        !          41729:     { return walk_ ((struct node * &)n); };
        !          41730:     tree_node_action walk(Pclass& n) 
        !          41731:     { return walk_ ((struct node * &)n); };
        !          41732:     tree_node_action walk(Pvirt& n) 
        !          41733:     { return walk_ ((struct node * &)n); };
        !          41734:     tree_node_action walk(Plist& n) 
        !          41735:     { return walk_ ((struct node * &)n); };
        !          41736:     tree_node_action walk(Pin& n) 
        !          41737:     { return walk_ ((struct node * &)n); };
        !          41738:     tree_node_action walk(struct ia * & n) 
        !          41739:     { return walk_ ((struct node * &)n); };
        !          41740:     tree_node_action walk(Pbcl& n) 
        !          41741:     { return walk_ ((struct node * &)n); };
        !          41742:   private:
        !          41743:     int fetching () {  return (control.fetcher != null_tfp); } ;
        !          41744:     void free_fetched (void *);
        !          41745:     int fetch (void *, unsigned long, void *&);
        !          41746:     int fetch (void * a, unsigned long l, Pnode& p) 
        !          41747:     {
        !          41748:        int ret;
        !          41749:        void * t;               /* this is an output argument */
        !          41750:        ret = fetch(a,l,t);
        !          41751:        if(!ret) {
        !          41752:            p = Pnode(t);
        !          41753:        }
        !          41754:        return ret;
        !          41755:     };
        !          41756:     // void error (const char *,...); ?? at&t -- to get it up quick, line 155
        !          41757:     void error ( char *, unsigned long=0 );
        !          41758:     tree_node_action pre_act_on_node (Pnode node, node_class nc,
        !          41759:                                      Pnode node_copy, Pnode& replacement);
        !          41760:                                       
        !          41761:     tree_node_action a_gen (Pnode, Pgen, Pnode&);
        !          41762:     tree_node_action a_vec (Pnode, Pvec, Pnode&);
        !          41763:     tree_node_action a_ptr (Pnode, Pptr, Pnode&);
        !          41764:     tree_node_action a_fct (Pnode, Pfct, Pnode&);
        !          41765:     tree_node_action a_table (Pnode, Ptable, Pnode&);
        !          41766:     tree_node_action a_basetype (Pnode, Pbase, Pnode&);
        !          41767:     tree_node_action a_name(Pnode, Pname, Pnode&);
        !          41768:     tree_node_action a_expr (Pnode, Pexpr, Pnode&);
        !          41769:     tree_node_action a_stmt (Pnode, Pstmt, Pnode&);
        !          41770:     tree_node_action a_enumdef (Pnode, Penum, Pnode&);
        !          41771:     tree_node_action a_classdef (Pnode, Pclass, Pnode&);
        !          41772:     tree_node_action a_virt (Pnode, Pvirt, Pnode&);
        !          41773:     tree_node_action a_name_list (Pnode, Plist, Pnode&);
        !          41774:     tree_node_action a_iline (Pnode, Pin, Pnode&);
        !          41775:     tree_node_action a_ia (Pnode, struct ia *, Pnode&);
        !          41776:     tree_node_action a_baseclass (Pnode, Pbcl, Pnode&);
        !          41777:     tree_node_action a_expr_guts (Pexpr);
        !          41778: };
        !          41779: 
        !          41780: 
        !          41781: walker::walker(tree_walk_control& c) 
        !          41782: { control = c;
        !          41783:   made_ht = 0;
        !          41784:   if (c.nodes_seen_hash)
        !          41785:     nodes_seen_hash = c.nodes_seen_hash;
        !          41786:   else {
        !          41787:     nodes_seen_hash = new pointer_hash (100);
        !          41788:     made_ht = 1;
        !          41789:   }
        !          41790:   depth = 0;
        !          41791:   cur_tree = 0;
        !          41792: }
        !          41793: 
        !          41794: 
        !          41795: tree_node_action
        !          41796: walk_tree (tree_walk_control& c, Pnode& n)
        !          41797: {
        !          41798:     walker w (c);
        !          41799:     return w.walk(n);
        !          41800: }
        !          41801: 
        !          41802: 
        !          41803: /* error messages are of finite length, so no need to run
        !          41804:    around mallocing strings */
        !          41805: 
        !          41806: // void walker::error (const char * format, ...)
        !          41807: void walker::error (char *format, unsigned long v)
        !          41808: {
        !          41809:     va_list args;
        !          41810:     va_start(args, format);
        !          41811:     if(control.call_i_error) {
        !          41812:        char buf[1000];
        !          41813:        // vsprintf(buf, format, args);
        !          41814:         // vsprintf not universal: by inspection
        !          41815:         // all calls are currently of 1 or 0 arguments
        !          41816:        sprintf(buf, format, v);
        !          41817:        (*control.i_error)('i', buf);
        !          41818:     } else {
        !          41819:        vostream_printf (format, args, *control.error_stream);
        !          41820:        *control.error_stream << "\n";
        !          41821:        control.error_stream->flush();
        !          41822:     }
        !          41823:     va_end (args);
        !          41824: }
        !          41825: 
        !          41826: 
        !          41827: void
        !          41828: walker::free_fetched (void * addr)
        !          41829: {
        !          41830:     if (control.fetcher != null_tfp)   /* null indicates no cross-address-space */
        !          41831:        free ((char *)addr);    
        !          41832: }    
        !          41833: 
        !          41834: int
        !          41835: walker::fetch (void * addr, unsigned long length, void*& taddr)
        !          41836: {
        !          41837:     int err;
        !          41838: 
        !          41839:     if (control.fetcher == null_tfp) { 
        !          41840:        taddr = addr;
        !          41841:        return 0;
        !          41842:     } else {
        !          41843:        taddr = (void *)malloc ((unsigned int)length);
        !          41844:        if(taddr == 0) {
        !          41845:           error ("walker::fetch: failed to malloc %d bytes.", length);
        !          41846:           return 1;
        !          41847:        }
        !          41848: 
        !          41849:        err = (*control.fetcher) (control.callback_info, addr, length, 0, taddr);
        !          41850:        if(err) {
        !          41851:           error("walker::fetch: fetcher returned %d.", err);
        !          41852:           return 1;
        !          41853:        }
        !          41854:    }
        !          41855: }
        !          41856: 
        !          41857: /* ::walk is called with a node pointer and a reference to
        !          41858:    a replacement node pointer. When it returns,
        !          41859:    replacement will be set if the action procedure
        !          41860:    called on the node decided to copy it or replace it.
        !          41861:    There are two possible modularities. 
        !          41862:    In case there is cross-address-space action,
        !          41863:    ::walk can't call the action procedure until it has
        !          41864:    entered the case on node bases. Once it has,
        !          41865:    it calls the per-structure-type procedure,
        !          41866:    which calls the action proc. If the action 
        !          41867:    proc supplies a replacement, then that replacement
        !          41868:    will be returned up via the reference parameters to 
        !          41869:    the per-structure procedures.
        !          41870: 
        !          41871:    It the action procedure returns tna_continue,
        !          41872:    then the walk continues against the new copy of the node
        !          41873:    so that further replacements are reflected in the new copies.
        !          41874:    This prevents replacement from being meaningful cross-address-space,
        !          41875:    since the new copy will presumably be in the current 
        !          41876:    (and not the cross) address space. That is, if the node
        !          41877:    is replaced by the action proc, the pointers in the new 
        !          41878:    node will drive the subsequent tree walk. Usually one
        !          41879:    would just bitcopy, and then they would be replaced in turn.
        !          41880: */
        !          41881: 
        !          41882: tree_node_action
        !          41883: walker::walk (Pnode& top)
        !          41884: {
        !          41885:     Pnode replacement = 0;
        !          41886:     tree_node_action err;
        !          41887:     int class_err;
        !          41888:     node_class nclass;
        !          41889:     Pnode node = 0; /* assign to shut up compiler,
        !          41890:                       which dosen't recognize pass-by-reference as a set */
        !          41891: 
        !          41892:     orig_addr = top;
        !          41893: 
        !          41894:     if(fetching ()) {
        !          41895:        if(fetch((void *)top, sizeof (struct node), node))
        !          41896:            return tna_error;
        !          41897:     } else node = top;
        !          41898: 
        !          41899: /* This has a complete catalog of bases, rather than just a list
        !          41900:    of those associated with data structures. Its important
        !          41901:    to detect the errs.
        !          41902: */   
        !          41903: 
        !          41904:     nclass = classify_node (node, class_err);
        !          41905: 
        !          41906:     if(class_err) {
        !          41907:        error("walker::walk: unknown node type %d.", node->base);
        !          41908:        free_fetched ((void *)node);
        !          41909:        err = tna_error;
        !          41910:        goto Return;
        !          41911:     }
        !          41912:     
        !          41913:     switch(nclass)
        !          41914:     {
        !          41915:       default:
        !          41916:       case nc_unused:
        !          41917:        error("walker::walk: unused node type %d.", node->base);
        !          41918:        err = tna_error;
        !          41919:        goto Return;
        !          41920: 
        !          41921:       case nc_eof:
        !          41922:        break;
        !          41923: 
        !          41924:       case nc_virt:
        !          41925:        fetch((void *)top, sizeof (struct virt), node);
        !          41926:        err = a_virt(top, Pvirt (node), replacement);
        !          41927:        break;
        !          41928: 
        !          41929:       case nc_nlist:
        !          41930:        fetch((void *)top, sizeof (struct name_list), node);
        !          41931:        err = a_name_list(top, (struct name_list *)node, replacement);
        !          41932:        break;
        !          41933: 
        !          41934:       case nc_iline:
        !          41935:        fetch((void *)top, sizeof (struct iline), node);
        !          41936:        err = a_iline(top, (struct iline *)node, replacement);
        !          41937:        break;
        !          41938: 
        !          41939:       case nc_gen:
        !          41940:        fetch((void *)top, sizeof (struct gen), node);
        !          41941:        err = a_gen(top, Pgen (node), replacement);
        !          41942:        break;
        !          41943: 
        !          41944:       case nc_vec:
        !          41945:        fetch((void *)top, sizeof (struct vec), node);
        !          41946:        err = a_vec(top, Pvec(node), replacement);
        !          41947:        break;
        !          41948: 
        !          41949:       case nc_ptr:
        !          41950:        fetch((void *)top, sizeof (struct ptr), node);
        !          41951:        err = a_ptr(top, Pptr(node), replacement);
        !          41952:        break;
        !          41953: 
        !          41954:       case nc_fct:
        !          41955:        fetch((void *)top, sizeof (struct fct), node);
        !          41956:        err = a_fct(top, Pfct(node), replacement);
        !          41957:        break;
        !          41958: 
        !          41959:       case nc_table:
        !          41960:        fetch((void *)top, sizeof (struct table), node);
        !          41961:        err = a_table(top, Ptable(node), replacement);
        !          41962:        break;
        !          41963: 
        !          41964:       case nc_basetype:
        !          41965:        fetch((void *)top, sizeof (struct basetype), node);
        !          41966:        err = a_basetype(top, Pbase(node), replacement);
        !          41967:        break;
        !          41968: 
        !          41969:       case nc_name:
        !          41970:        fetch((void *)top, sizeof (struct name), node);
        !          41971:        err = a_name(top, Pname(node), replacement);
        !          41972:        break;
        !          41973: 
        !          41974:       case nc_expr:
        !          41975:        fetch((void *)top, sizeof (struct expr), node);
        !          41976:        err = a_expr(top, Pexpr(node), replacement);
        !          41977:        break;
        !          41978: 
        !          41979:       case nc_stmt:
        !          41980:        fetch((void *)top, sizeof (struct stmt), node);
        !          41981:        err = a_stmt(top, Pstmt(node), replacement);
        !          41982:        break;
        !          41983: 
        !          41984:       case nc_enumdef:
        !          41985:        fetch((void *)top, sizeof (struct enumdef), node);
        !          41986:        err = a_enumdef(top, Penum(node), replacement);
        !          41987:        break;
        !          41988: 
        !          41989:       case nc_classdef:
        !          41990:        fetch((void *)top, sizeof (struct classdef), node);
        !          41991:        err = a_classdef(top, Pclass(node), replacement);
        !          41992:        break;
        !          41993: 
        !          41994:       case nc_ia:
        !          41995:        fetch((void *)top, sizeof (struct ia), node);
        !          41996:        err = a_ia(top, (struct ia *)node, replacement);
        !          41997:        break;
        !          41998: 
        !          41999:       case nc_baseclass:
        !          42000:        fetch((void *)top, sizeof (struct basecl), node);
        !          42001:        err = a_baseclass(top, Pbcl(node), replacement);
        !          42002:        break;
        !          42003: 
        !          42004:     }
        !          42005: 
        !          42006:     if(replacement) {
        !          42007:        if (fetching ()) {
        !          42008:            error
        !          42009:                ("walker::walk: Attempt to replace tree in cross-address space mode.");
        !          42010:            err = tna_error;
        !          42011:        } 
        !          42012:        else top = replacement;
        !          42013:     }
        !          42014:        
        !          42015:     if (control.post_action_proc && err != tna_error) {
        !          42016:        tree_node_action post_err;
        !          42017:        Pnode& post_repl = node;
        !          42018: 
        !          42019:        (*control.post_action_proc) (post_repl, nclass, control.callback_info, post_err,
        !          42020:                                     depth, orig_addr, *cur_tree);
        !          42021:        if(post_err != tna_continue) err = post_err;
        !          42022:        if(post_repl != node) {
        !          42023:            if (fetching ()) {
        !          42024:                error
        !          42025:                    ("walker::walk: Attempt to replace tree in cross-address space mode.");
        !          42026:                err = tna_error;
        !          42027:            } 
        !          42028:            else top = post_repl;
        !          42029:        }
        !          42030:     }
        !          42031: 
        !          42032:     free_fetched((void *) node);
        !          42033: 
        !          42034: Return:
        !          42035:     return err;
        !          42036: }
        !          42037: 
        !          42038: /* This is called in pre-order for each node. Then
        !          42039:    post_act_on_node is called after whatever recursive
        !          42040:    processing ensues.
        !          42041:    
        !          42042:    This is called from each of the structure-specific procedures
        !          42043:    to give the action procedure an opportunity to act.
        !          42044:    It can return a replacement pointer and control
        !          42045:    whether to examine the insides of the node.
        !          42046:    */
        !          42047: 
        !          42048: tree_node_action 
        !          42049: walker::pre_act_on_node (Pnode node, node_class nc,
        !          42050:                       Pnode node_copy, Pnode& replacement)
        !          42051: {
        !          42052: /* If we have been here before, then we never proceed */
        !          42053: /* node_copy is != node when a fetcher is in use */
        !          42054: 
        !          42055:     int found;
        !          42056:     int old_node;
        !          42057:     tree_node_action action;
        !          42058:     Pnode new_node;
        !          42059:     int register_in_hash = 1;
        !          42060: 
        !          42061:     nodes_seen_hash->action((int)node, 0, Hash::probe, found, old_node);
        !          42062: 
        !          42063:     if(found) {
        !          42064:        new_node = Pnode(old_node);
        !          42065:        if(new_node != node) replacement = new_node;
        !          42066:        return tna_stop; /* no need to proceed */
        !          42067:     }
        !          42068: 
        !          42069:     /* OK, we don't know from a previous pass. Call our actor */
        !          42070: 
        !          42071:     new_node = fetching () && node_copy ? node_copy : node;
        !          42072: 
        !          42073:     (*control.action_proc)(new_node, nc, control.callback_info, action, 
        !          42074:                           depth, orig_addr, *cur_tree,
        !          42075:                           register_in_hash);
        !          42076: 
        !          42077:     if(action != tna_error && !fetching () && new_node != node) {
        !          42078:        replacement = new_node;
        !          42079:        if(register_in_hash)
        !          42080:            nodes_seen_hash->action((int)node, 
        !          42081:                                    (int)new_node, 
        !          42082:                                    Hash::insert, 0, 0);
        !          42083:     }
        !          42084:     else {
        !          42085:        if(register_in_hash)
        !          42086:            nodes_seen_hash->action((int)node, (int) node, Hash::insert, 0, 0);
        !          42087:     }
        !          42088:     return action;
        !          42089: }                         
        !          42090: 
        !          42091: tree_node_action walker::a_table(Pnode ta, Ptable t, Pnode& replacement) 
        !          42092: {
        !          42093:     /* no unions */
        !          42094: 
        !          42095:     tree_node_action action;
        !          42096:     action = pre_act_on_node(ta, nc_table, Pnode(t), replacement);
        !          42097:     if(action != tna_continue) return action;
        !          42098: 
        !          42099: /* -----------------------------*/
        !          42100: /* For Now, Never Walk a Table. */
        !          42101: 
        !          42102:     action = tna_stop; return action;
        !          42103: 
        !          42104: /* An array of pointers. 
        !          42105:  * The action procedure is responsible for allocating a new one
        !          42106:  * of those if it replaced and continued. 
        !          42107:  * *** end of comment
        !          42108: 
        !          42109:     if(!fetching () && replacement)
        !          42110:        t = Ptable(replacement);
        !          42111: 
        !          42112:     Pname * t_entries;
        !          42113: 
        !          42114:     if(fetching ()) {
        !          42115:        void * temp;
        !          42116:        fetch((void *)t->entries, t->size * sizeof(Pname), temp);
        !          42117:        t_entries = (Pname *)temp;
        !          42118:     }
        !          42119:     else t_entries = t->entries;
        !          42120: 
        !          42121:     for(int nx = 0; nx < t->size; nx ++) {
        !          42122:        action = walk(t_entries[nx]);
        !          42123:        if(action == tna_error) return action;
        !          42124:     }
        !          42125: 
        !          42126:     if(fetching ()) free_fetched ((void *)t_entries);
        !          42127:     
        !          42128:     Pnode n = Pnode(t->real_block);
        !          42129: 
        !          42130:     action = walk(t->real_block);
        !          42131:     if(action == tna_error) return action;
        !          42132:     
        !          42133:     action = walk(t->next);
        !          42134:     action = walk(t->t_name);
        !          42135:     return tna_continue;
        !          42136: */ // don't walk table
        !          42137: }
        !          42138: 
        !          42139: tree_node_action walker::a_enumdef (Pnode ta, Penum e, Pnode& replacement) 
        !          42140: {
        !          42141:     tree_node_action action = pre_act_on_node(ta, nc_enumdef, Pnode(e), replacement);
        !          42142: 
        !          42143:     action = walk(e->mem);
        !          42144:     if(action == tna_error) return action;
        !          42145: 
        !          42146:     action = walk(e->e_type);
        !          42147: 
        !          42148:     return tna_continue;
        !          42149: }    
        !          42150: 
        !          42151: tree_node_action walker::a_virt(Pnode ta, Pvirt v, Pnode& replacement) 
        !          42152: {
        !          42153:     /* no unions */
        !          42154: 
        !          42155:     int nx;
        !          42156:     tree_node_action action = pre_act_on_node(ta, nc_enumdef, Pnode(v), replacement);
        !          42157: 
        !          42158:     if(action != tna_continue) return action;
        !          42159: 
        !          42160:     if(!fetching () && replacement)
        !          42161:        v = Pvirt(replacement);
        !          42162: 
        !          42163: /* an array of velem structures. */
        !          42164: 
        !          42165:     velem * v_virt_init;
        !          42166: 
        !          42167:     if(fetching ()) {
        !          42168:        void * t;
        !          42169:        fetch((void *)v->virt_init, v->n_init * sizeof(velem), t);
        !          42170:        v_virt_init = (velem *)t;
        !          42171:     }
        !          42172:     else v_virt_init = v->virt_init;
        !          42173: 
        !          42174:     for(nx = 0; nx < v->n_init; nx ++) {
        !          42175:        action = walk(v_virt_init[nx].n);
        !          42176:        if(action == tna_error) return action;
        !          42177:     }
        !          42178: 
        !          42179:     if(fetching ()) free_fetched ((void *)v_virt_init);
        !          42180:     
        !          42181:     action = walk(v->vclass);
        !          42182:     
        !          42183:     return tna_continue;
        !          42184: }
        !          42185: 
        !          42186: tree_node_action walker::a_classdef(Pnode ta, Pclass c, Pnode& replacement) 
        !          42187: {
        !          42188: 
        !          42189:     tree_node_action action = pre_act_on_node(ta, nc_classdef, Pnode(c), replacement);
        !          42190: 
        !          42191:     if(action != tna_continue) return action;
        !          42192: 
        !          42193:     if(!fetching () && replacement)
        !          42194:        c = Pclass(replacement);
        !          42195: 
        !          42196:     action = walk(c->baselist);
        !          42197:     if(action == tna_error) return action;
        !          42198: 
        !          42199:     action=walk(c->mem_list);
        !          42200:     if(action == tna_error) return action;
        !          42201:     
        !          42202:     action=walk(c->memtbl);
        !          42203:     if(action == tna_error) return action;
        !          42204: 
        !          42205:     action=walk(c->friend_list);
        !          42206:     if(action == tna_error) return action;
        !          42207: 
        !          42208:     action=walk(c->pubdef);
        !          42209:     if(action == tna_error) return action;
        !          42210:     
        !          42211:     action=walk(c->tn_list);
        !          42212:     if(action == tna_error) return action;
        !          42213: 
        !          42214:     action=walk(c->in_class);
        !          42215:     if(action == tna_error) return action;
        !          42216: 
        !          42217:     action=walk(c->in_fct);
        !          42218:     if(action == tna_error) return action;
        !          42219: 
        !          42220:     action=walk(c->this_type);
        !          42221:     if(action == tna_error) return action;
        !          42222: 
        !          42223:     action=walk(c->virt_list);
        !          42224:     if(action == tna_error) return action;
        !          42225: 
        !          42226:     action=walk(c->c_ctor);
        !          42227:     if(action == tna_error) return action;
        !          42228:     action=walk(c->c_dtor);
        !          42229:     if(action == tna_error) return action;
        !          42230:     action=walk(c->c_itor);
        !          42231:     if(action == tna_error) return action;
        !          42232: 
        !          42233:     action=walk(c->conv);
        !          42234:     if(action == tna_error) return action;
        !          42235: 
        !          42236:     return tna_continue;
        !          42237: }
        !          42238: 
        !          42239: tree_node_action walker::a_basetype(Pnode ta, Pbase b, Pnode& replacement) 
        !          42240: {
        !          42241: 
        !          42242:     tree_node_action action = pre_act_on_node(ta, nc_basetype, Pnode(b), replacement);
        !          42243:     int derr;
        !          42244: 
        !          42245:     if(action != tna_continue) return action;
        !          42246: 
        !          42247:     if(!fetching () && replacement)
        !          42248:        b = Pbase(replacement);
        !          42249: 
        !          42250:     action = walk(b->b_name);
        !          42251:     if(action == tna_error) return action;
        !          42252: 
        !          42253:     action = walk(b->b_table);
        !          42254:     if(action == tna_error) return action;
        !          42255: 
        !          42256:     // action = walk(b->b_field);
        !          42257:     // if(action == tna_error) return action;
        !          42258: 
        !          42259:     action = walk(b->b_xname);
        !          42260:     if(action == tna_error) return action;
        !          42261: 
        !          42262:     switch(derr = b->discriminator(0)) {
        !          42263:       case 0: break;
        !          42264:       case 1:
        !          42265:        action = walk(b->b_fieldtype);
        !          42266:        if(action == tna_error) return action;
        !          42267:        break;
        !          42268:       case 2: break;
        !          42269:       default:
        !          42270:        error ("a_basetype: discrim error %d.", derr);
        !          42271:        return tna_error;
        !          42272:     }
        !          42273: 
        !          42274:     return tna_continue;
        !          42275: }
        !          42276: 
        !          42277: tree_node_action walker::a_fct(Pnode ta, Pfct f, Pnode& replacement) 
        !          42278: {
        !          42279: 
        !          42280:     tree_node_action action = pre_act_on_node(ta, nc_fct, Pnode(f), replacement);
        !          42281: 
        !          42282:     if(action != tna_continue) return action;
        !          42283: 
        !          42284:     if(!fetching () && replacement)
        !          42285:        f = Pfct(replacement);
        !          42286: 
        !          42287:     action = walk(f->returns);
        !          42288:     if(action == tna_error) return action;
        !          42289: 
        !          42290:     action = walk(f->argtype);
        !          42291:     if(action == tna_error) return action;
        !          42292: 
        !          42293:     action = walk(f->s_returns);
        !          42294:     if(action == tna_error) return action;
        !          42295: 
        !          42296:     action = walk(f->f_this);
        !          42297:     if(action == tna_error) return action;
        !          42298: 
        !          42299:     action = walk(f->memof);
        !          42300:     if(action == tna_error) return action;
        !          42301: 
        !          42302:     action = walk(f->body);
        !          42303:     if(action == tna_error) return action;
        !          42304: 
        !          42305:     action = walk(f->f_init);
        !          42306:     if(action == tna_error) return action;
        !          42307: 
        !          42308:     action = walk(f->f_expr);
        !          42309:     if(action == tna_error) return action;
        !          42310: 
        !          42311:     action = walk(f->last_expanded);
        !          42312:     if(action == tna_error) return action;
        !          42313: 
        !          42314:     action = walk(f->f_result);
        !          42315:     if(action == tna_error) return action;
        !          42316: 
        !          42317:     action = walk(f->f_args);
        !          42318:     if(action == tna_error) return action;
        !          42319: 
        !          42320:     return tna_continue;
        !          42321: }
        !          42322: 
        !          42323: tree_node_action walker::a_name_list(Pnode ta, Plist l, Pnode& replacement) 
        !          42324: {
        !          42325: 
        !          42326:     int cl_error;
        !          42327:     tree_node_action action = pre_act_on_node(ta, nc_nlist, Pnode(l), replacement);
        !          42328: 
        !          42329:     if(action == tna_stop) {
        !          42330:        if(!fetching () && replacement)
        !          42331:            l = Plist(replacement);
        !          42332:        cl_error = 0;
        !          42333:        if((classify_node(Pnode(l), cl_error) == nc_nlist) && !cl_error) {
        !          42334:            action = walk(l->l);
        !          42335:            if(action == tna_error) return action;
        !          42336:        }
        !          42337:     }
        !          42338: 
        !          42339:     if(action != tna_continue) return action;
        !          42340: 
        !          42341:     if(!fetching () && replacement)
        !          42342:        l = Plist(replacement);
        !          42343: 
        !          42344:     action = walk(l->f);
        !          42345:     if(action == tna_error) return action;
        !          42346: 
        !          42347:     action = walk(l->l);
        !          42348:     if(action == tna_error) return action;
        !          42349: 
        !          42350:     return tna_continue;
        !          42351: }
        !          42352: 
        !          42353: tree_node_action walker::a_gen(Pnode ta, Pgen g, Pnode& replacement) 
        !          42354: {
        !          42355: 
        !          42356:     tree_node_action action = pre_act_on_node(ta, nc_gen, Pnode(g), replacement);
        !          42357: 
        !          42358:     if(action != tna_continue) return action;
        !          42359: 
        !          42360:     if(!fetching () && replacement)
        !          42361:        g = Pgen(replacement);
        !          42362: 
        !          42363:     action = walk(g->fct_list);
        !          42364:     if(action == tna_error) return action;
        !          42365: 
        !          42366:     return tna_continue;
        !          42367: }
        !          42368: 
        !          42369: tree_node_action walker::a_vec(Pnode ta, Pvec v, Pnode& replacement) 
        !          42370: {
        !          42371: 
        !          42372:     tree_node_action action = pre_act_on_node(ta, nc_vec, Pnode(v), replacement);
        !          42373: 
        !          42374:     if(action != tna_continue) return action;
        !          42375: 
        !          42376:     if(!fetching () && replacement)
        !          42377:        v = Pvec(replacement);
        !          42378: 
        !          42379:     action = walk(v->typ);
        !          42380:     if(action == tna_error) return action;
        !          42381: 
        !          42382:     action = walk(v->dim);
        !          42383:     if(action == tna_error) return action;
        !          42384: 
        !          42385:     return tna_continue;
        !          42386: }
        !          42387: 
        !          42388: tree_node_action walker::a_ptr(Pnode ta, Pptr p, Pnode& replacement) 
        !          42389: {
        !          42390: 
        !          42391:     tree_node_action action = pre_act_on_node(ta, nc_ptr, Pnode(p), replacement);
        !          42392: 
        !          42393:     if(action != tna_continue) return action;
        !          42394: 
        !          42395:     if(!fetching () && replacement)
        !          42396:        p = Pptr(replacement);
        !          42397: 
        !          42398:     action = walk(p->typ);
        !          42399:     if(action == tna_error) return action;
        !          42400: 
        !          42401:     action = walk(p->memof);
        !          42402:     if(action == tna_error) return action;
        !          42403: 
        !          42404:     return tna_continue;
        !          42405: }
        !          42406: 
        !          42407: 
        !          42408: tree_node_action walker::a_expr_guts(Pexpr e)
        !          42409: {
        !          42410:     int derr;
        !          42411:     tree_node_action action;
        !          42412: 
        !          42413:     switch(derr = e->discriminator (0)) {
        !          42414:       case 1:
        !          42415:        action = walk(e->tp);
        !          42416:        if(action == tna_error) return action;
        !          42417:        break;
        !          42418:       case 0:
        !          42419:        break;
        !          42420:       default:
        !          42421:        error ("a_expr: discrim error %d on union 0.", derr);
        !          42422:        return tna_error;
        !          42423:     }
        !          42424: 
        !          42425:     switch(derr = e->discriminator (1)) {
        !          42426:       case 0:
        !          42427:        break;
        !          42428:       default:
        !          42429:        error ("a_expr: discrim error %d on union 1.", derr);
        !          42430:        return tna_error;
        !          42431:       case 1:
        !          42432:        action = walk(e->e1);
        !          42433:        if(action == tna_error) return action;
        !          42434:        break;
        !          42435:       case 2:
        !          42436:        break;
        !          42437:       case 3:
        !          42438:        break;
        !          42439:     }
        !          42440: 
        !          42441:     switch(derr = e->discriminator (2)) {
        !          42442:       case 0:
        !          42443:        break;
        !          42444:       default:
        !          42445:        error ("a_expr: discrim error %d on union 2.", derr);
        !          42446:        return tna_error;
        !          42447:       case 1:
        !          42448:        /* elists are special. e2 for an elist is a peer, not
        !          42449:           a child. */
        !          42450:        if(e->base != ELIST) {
        !          42451:            action = walk(e->e2);
        !          42452:            if(action == tna_error) return action;
        !          42453:        }
        !          42454:        break;
        !          42455:       case 2:
        !          42456:        break;
        !          42457:       case 3:
        !          42458:        break;
        !          42459:       case 4:
        !          42460:        action = walk(e->n_initializer);
        !          42461:        if(action == tna_error) return action;
        !          42462:        break;
        !          42463:     }
        !          42464:     
        !          42465:     switch(derr = e->discriminator (3)) {
        !          42466:       case 0:
        !          42467:        break;
        !          42468:       default:
        !          42469:        error ("a_expr: discrim error %d on union 3.", derr);
        !          42470:        return tna_error;
        !          42471:       case 1:
        !          42472:        action = walk(e->tp2);
        !          42473:        if(action == tna_error) return action;
        !          42474:        break;
        !          42475:       case 2:
        !          42476:        action = walk(e->fct_name);
        !          42477:        if(action == tna_error) return action;
        !          42478:        break;
        !          42479:       case 3:
        !          42480:        action = walk(e->cond);
        !          42481:        if(action == tna_error) return action;
        !          42482:        break;
        !          42483:       case 4:
        !          42484:        action = walk(e->mem);
        !          42485:        if(action == tna_error) return action;
        !          42486:        break;
        !          42487:       case 5:
        !          42488:        action = walk(e->as_type);
        !          42489:        if(action == tna_error) return action;
        !          42490:        break;
        !          42491:       case 6:
        !          42492:        action = walk(e->n_table);
        !          42493:        if(action == tna_error) return action;
        !          42494:        break;
        !          42495:       case 7:
        !          42496:        action = walk(e->il);
        !          42497:        if(action == tna_error) return action;
        !          42498:        break;
        !          42499:       case 8:
        !          42500:        action = walk(e->query_this);
        !          42501:        if(action == tna_error) return action;
        !          42502:        break;
        !          42503:     }
        !          42504:     return tna_continue;
        !          42505: }
        !          42506: 
        !          42507: 
        !          42508: tree_node_action walker::a_expr(Pnode ta, Pexpr e, Pnode& replacement) 
        !          42509: {
        !          42510:     tree_node_action action = pre_act_on_node(ta, nc_expr, Pnode(e), replacement);
        !          42511: 
        !          42512:     if(action == tna_stop) {
        !          42513:        if(!fetching () && replacement)
        !          42514:            e = Pexpr(replacement);
        !          42515:        /* ELIST implies that e2 is a peer, not a child */
        !          42516:        if(e->base == ELIST) {
        !          42517:            action = walk(e->e2);
        !          42518:            return action;
        !          42519:        }
        !          42520:     }
        !          42521:        
        !          42522:     if(action != tna_continue) return action;
        !          42523: 
        !          42524:     if(!fetching () && replacement)
        !          42525:        e = Pexpr(replacement);
        !          42526: 
        !          42527:     action = a_expr_guts(e);
        !          42528:     if (action == tna_error) return action;
        !          42529:     if(e->base == ELIST)
        !          42530:        action = walk(e->e2);
        !          42531:     return action;
        !          42532: }
        !          42533: 
        !          42534: tree_node_action walker::a_baseclass(Pnode ta, Pbcl b, Pnode& replacement) 
        !          42535: {
        !          42536:     tree_node_action action = pre_act_on_node(ta, nc_baseclass, Pnode(b), replacement);
        !          42537: 
        !          42538:     if(action != tna_continue) return action;
        !          42539: 
        !          42540:     if(!fetching () && replacement)
        !          42541:        b = Pbcl(replacement);
        !          42542: 
        !          42543:     action = walk(b->bclass);
        !          42544:     if(action == tna_error) return action;
        !          42545: 
        !          42546:     action = walk(b->init);
        !          42547:     if(action == tna_error) return action;
        !          42548: 
        !          42549:     action = walk(b->next);
        !          42550:     if(action == tna_error) return action;
        !          42551: 
        !          42552:     return tna_continue;
        !          42553: }
        !          42554: 
        !          42555: 
        !          42556: /* a name is also an expr. */
        !          42557:    
        !          42558: 
        !          42559: tree_node_action walker::a_name(Pnode ta, Pname n, Pnode& replacement) 
        !          42560: {
        !          42561:     int derr;
        !          42562:     int cl_error;
        !          42563:     tree_node_action action = pre_act_on_node(ta, nc_name, Pnode(n), replacement);
        !          42564: 
        !          42565:     /* n_list is a sibling, not a child. We always process it
        !          42566:        except in case of an error. */
        !          42567:     if(action == tna_stop) {
        !          42568:        cl_error = 0;
        !          42569:        if(!fetching () && replacement)
        !          42570:            n = Pname(replacement);
        !          42571:        if((classify_node(Pnode(n), cl_error) == nc_name) && !cl_error) {
        !          42572:            if(depth > 0 || !control.dont_chase_lists_top) {
        !          42573:                action = walk(n->n_list); 
        !          42574:                if(action == tna_error) return action;
        !          42575:            }
        !          42576:        }
        !          42577:        return tna_stop;
        !          42578:     }  
        !          42579: 
        !          42580:     if(action != tna_continue) return action;
        !          42581: 
        !          42582:     if(!fetching () && replacement)
        !          42583:        n = Pname(replacement);
        !          42584: 
        !          42585: /* We don't walk n_tbl_list. Its not part of the graph.
        !          42586:    */
        !          42587: 
        !          42588:     switch(derr = n->discriminator(0)) {
        !          42589:       case 0:
        !          42590:        break;
        !          42591:       case 1:
        !          42592:        action = walk(n->n_qualifier);
        !          42593:        if(action == tna_error) return action;
        !          42594:        break;
        !          42595:       case 2:
        !          42596:        action = walk(n->n_realscope);
        !          42597:        if(action == tna_error) return action;
        !          42598:        break;
        !          42599:       default:
        !          42600:        error ("a_name: discrim error %d on union 0.", derr);
        !          42601:        return tna_error;
        !          42602:     }
        !          42603: 
        !          42604:     action = a_expr_guts(Pexpr(n));
        !          42605:     if(action == tna_error) return action;
        !          42606: 
        !          42607:     if(depth > 0 || !control.dont_chase_lists_top) {
        !          42608:        action = walk(n->n_list);
        !          42609:        if(action == tna_error) return action;
        !          42610:     }
        !          42611:     
        !          42612:     return action;
        !          42613: }
        !          42614:     
        !          42615: /* --- NOTE: s_list should be deferred until AFTER the post-action
        !          42616:    procedure is called, if there is one. Since no one uses
        !          42617:    post-actions yet I haven't bothered to make this fix.
        !          42618:    --benson */
        !          42619: 
        !          42620: tree_node_action walker::a_stmt(Pnode ta, Pstmt s, Pnode& replacement) 
        !          42621: {
        !          42622:     int cl_error;
        !          42623:     int derr;
        !          42624:     tree_node_action action = pre_act_on_node(ta, nc_stmt, Pnode(s), replacement);
        !          42625: 
        !          42626:     if(action == tna_stop) {
        !          42627:        if(!fetching () && replacement)
        !          42628:            s = Pstmt(replacement);
        !          42629:        cl_error = 0;
        !          42630:        if((classify_node(Pnode(s), cl_error) == nc_stmt) && !cl_error) {
        !          42631:            /* s_list is not our subordinate, it is our peer */
        !          42632:            if(depth > 0 || !control.dont_chase_lists_top) {
        !          42633:                action = walk(s->s_list); /* continue walk of sibs */
        !          42634:                if (action == tna_error) return tna_error;
        !          42635:            }
        !          42636:        }
        !          42637:        return tna_stop;
        !          42638:     }
        !          42639: 
        !          42640:     if(action != tna_continue) return action;
        !          42641: 
        !          42642:     if(!fetching () && replacement)
        !          42643:        s = Pstmt(replacement);
        !          42644: 
        !          42645:     action = walk(s->s);
        !          42646:     if(action == tna_error) return action;
        !          42647: 
        !          42648:     action = walk(s->memtbl);
        !          42649:     if(action == tna_error) return action;
        !          42650: 
        !          42651:     switch(derr = s->discriminator(0)) {
        !          42652:       default:
        !          42653:        error ("a_stmt: discrim error %d on union 0.", derr);
        !          42654:        return tna_error;
        !          42655:       case 4:
        !          42656:       case 0: break;
        !          42657:       case 1:
        !          42658:        action = walk(s->d);
        !          42659:        if(action == tna_error) return action;
        !          42660:        break;
        !          42661:       case 2:
        !          42662:        action = walk(s->e2);
        !          42663:        if(action == tna_error) return action;
        !          42664:        break;
        !          42665:       case 3:
        !          42666:        action = walk(s->has_default);
        !          42667:        if(action == tna_error) return action;
        !          42668:        break;
        !          42669:       case 5:
        !          42670:        action = walk(s->ret_tp);
        !          42671:        if(action == tna_error) return action;
        !          42672:        break;
        !          42673:     }
        !          42674: 
        !          42675:     switch(derr = s->discriminator(1)) {
        !          42676:       default:
        !          42677:        error ("a_stmt: discrim error %d on union 1.", derr);
        !          42678:        return tna_error;
        !          42679:       case 2:
        !          42680:       case 0: break;
        !          42681:       case 1:
        !          42682:        action = walk(s->e);
        !          42683:        if(action == tna_error) return action;
        !          42684:        break;
        !          42685:       case 3:
        !          42686:        action = walk(s->s2);
        !          42687:        if(action == tna_error) return action;
        !          42688:        break;
        !          42689:     }
        !          42690: 
        !          42691:     switch(derr = s->discriminator(2)) {
        !          42692:       default:
        !          42693:        error ("a_stmt: discrim error %d on union 2.", derr);
        !          42694:        return tna_error;
        !          42695:       case 0: break;
        !          42696:       case 1:
        !          42697:        action = walk(s->for_init);
        !          42698:        if(action == tna_error) return action;
        !          42699:        break;
        !          42700:       case 2:
        !          42701:        action = walk(s->else_stmt);
        !          42702:        if(action == tna_error) return action;
        !          42703:        break;
        !          42704:       case 3:
        !          42705:        action = walk(s->case_list);
        !          42706:        if(action == tna_error) return action;
        !          42707:        break;
        !          42708:     }
        !          42709: 
        !          42710:     if(depth > 0 || !control.dont_chase_lists_top) {
        !          42711:        action = walk(s->s_list);
        !          42712:        if(action == tna_error) return action;
        !          42713:     }
        !          42714: 
        !          42715:     return tna_continue;
        !          42716: }
        !          42717: 
        !          42718: tree_node_action walker::a_ia(Pnode ta, struct ia * ia, Pnode& replacement) 
        !          42719: {
        !          42720:     tree_node_action action = pre_act_on_node(ta, nc_ia, Pnode(ia), replacement);
        !          42721: 
        !          42722:     if(action != tna_continue) return action;
        !          42723: 
        !          42724:     if(!fetching () && replacement)
        !          42725:        ia = (struct ia *)&replacement;
        !          42726: 
        !          42727:     action = walk(ia->local);
        !          42728:     if(action == tna_error) return action;
        !          42729: 
        !          42730:     action = walk(ia->arg);
        !          42731:     if(action == tna_error) return action;
        !          42732:     
        !          42733:     action = walk(ia->tp);
        !          42734:     if(action == tna_error) return action;
        !          42735: 
        !          42736:     return tna_continue;
        !          42737: }
        !          42738: 
        !          42739: tree_node_action walker::a_iline(Pnode ta, Pin iline, Pnode& replacement) 
        !          42740: {
        !          42741:     tree_node_action action = pre_act_on_node(ta, nc_iline, Pnode(iline), replacement);
        !          42742: 
        !          42743:     if(action != tna_continue) return action;
        !          42744: 
        !          42745:     if(!fetching () && replacement)
        !          42746:        iline = Pin(replacement);
        !          42747: 
        !          42748:     action = walk(iline->fct_name);
        !          42749:     if(action == tna_error) return action;
        !          42750: 
        !          42751:     action = walk(iline->i_next);
        !          42752:     if(action == tna_error) return action;
        !          42753:     
        !          42754:     action = walk(iline->i_table);
        !          42755:     if(action == tna_error) return action;
        !          42756: 
        !          42757:     action = walk(iline->i_args);
        !          42758:     if(action == tna_error) return action;
        !          42759: 
        !          42760:     return tna_continue;
        !          42761: }
        !          42762: 0707071010112046151004440001630000160000010107200466055423100001400000004551tree_walk.h/* ident "@(#)ctrans:src/tree_walk.h   1.2" */
        !          42763: /* -*- Mode: C -*- Begin include file tree_walk.H */
        !          42764: /*
        !          42765:        $Source: /usr3/lang/benson/work/stripped_cfront/RCS/tree_walk.H,v $ $RCSfile: tree_walk.H,v $
        !          42766:        $Revision: 1.1 $                $Date: 89/11/20 08:51:05 $
        !          42767:        $Author: benson $               $Locker:  $
        !          42768:        $State: Exp $
        !          42769: */
        !          42770: 
        !          42771: #ifndef _TREE_WALK
        !          42772: #define _TREE_WALK
        !          42773: 
        !          42774: #include "cfront.h"
        !          42775: #include "node_classes.h"
        !          42776: #include <iostream.h>
        !          42777: #include "ios_printf.h"
        !          42778: #include "hash.h"
        !          42779: 
        !          42780: enum tree_node_action {
        !          42781:     tna_continue = 0,          /* plain vanilla */
        !          42782:     tna_stop = 1,              /* don't proceed */
        !          42783:     tna_error = 2,             /* stop entire walk now. */
        !          42784: };
        !          42785: 
        !          42786: /* procedural interface to indirect via a pointer. */
        !          42787: typedef int (*tree_fetch_proc) (void * info,
        !          42788:                                void * pointer,
        !          42789:                                unsigned long length,
        !          42790:                                int zero_stop,  /* for character strings.*/
        !          42791:                                void * target);
        !          42792: 
        !          42793: 
        !          42794: const tree_fetch_proc null_tfp = (tree_fetch_proc) 0;
        !          42795: 
        !          42796: class tree_walk_tree {
        !          42797:   public:
        !          42798:     tree_walk_tree * parent;
        !          42799:     char storage[1];           /* variable amt, specified by caller. */
        !          42800: };
        !          42801: 
        !          42802: /* The trailing int here controls whether to remember the
        !          42803:    node in the hash table to short-circuit meeting it again */
        !          42804: 
        !          42805: typedef void (*tree_pre_action)
        !          42806:     (Pnode&, node_class, void *, tree_node_action&, int, Pnode, 
        !          42807:      tree_walk_tree&, int&);
        !          42808: 
        !          42809: 
        !          42810: typedef void (*tree_post_action)
        !          42811:     (Pnode&, node_class, void *, tree_node_action&, int, Pnode, 
        !          42812:      tree_walk_tree&);
        !          42813: 
        !          42814: typedef void (*errorp) (char, const char *);
        !          42815: 
        !          42816: class tree_walk_control {
        !          42817:   public:
        !          42818:     int version;
        !          42819:     void * callback_info;
        !          42820:     tree_fetch_proc fetcher;
        !          42821:     tree_pre_action action_proc;
        !          42822:     tree_post_action post_action_proc;
        !          42823:     int (*i_error) (int, const char *); /* usually part of cfront */
        !          42824:     int call_i_error;          /* if 0, just use the following */
        !          42825:     ostream * error_stream;
        !          42826:     Hash * nodes_seen_hash;    /* allows this to be global over
        !          42827:                                 more than one call to the walker. */
        !          42828:     int resolve_by_name;
        !          42829:     int alloc_stack_bytes;
        !          42830:     /* if on, n_list and s_list are ignored for the very top node. 
        !          42831:        this is for the benefit of the printer. */
        !          42832:     int dont_chase_lists_top;
        !          42833:     tree_walk_control () {
        !          42834:        version = 1;
        !          42835:        callback_info = 0;
        !          42836:        fetcher = null_tfp;
        !          42837:        call_i_error = 0;
        !          42838:        error_stream = &cerr;
        !          42839:        nodes_seen_hash = 0;
        !          42840:        resolve_by_name = 1;    /* the dumper turns this off */
        !          42841:        alloc_stack_bytes = 0;
        !          42842:        post_action_proc = 0;
        !          42843:        dont_chase_lists_top = 0;
        !          42844:     }
        !          42845: };
        !          42846: 
        !          42847: tree_node_action walk_tree (tree_walk_control& c, Pnode& n);
        !          42848: 
        !          42849: #endif
        !          42850: 0707071010112045721004440001630000160000010210200466055412600000600000054504typ.c/*ident      "@(#)ctrans:src/typ.c   1.4" */
        !          42851: /**************************************************************************
        !          42852: 
        !          42853:        C++ source for cfront, the C++ compiler front-end
        !          42854:        written in the computer science research center of Bell Labs
        !          42855: 
        !          42856:        Copyright (c) 1984 AT&T, Inc. All Rights Reserved
        !          42857:        THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T, INC.
        !          42858: 
        !          42859: typ.c:
        !          42860: 
        !          42861: 
        !          42862: ***************************************************************************/
        !          42863:  
        !          42864: #include "cfront.h"
        !          42865: #include "size.h"
        !          42866: 
        !          42867: Pbase short_type;
        !          42868: Pbase int_type;
        !          42869: Pbase char_type;
        !          42870: Pbase long_type;
        !          42871: 
        !          42872: Pbase uchar_type;
        !          42873: Pbase ushort_type;
        !          42874: Pbase uint_type;
        !          42875: Pbase ulong_type;
        !          42876: 
        !          42877: Pbase zero_type;
        !          42878: Pbase float_type;
        !          42879: Pbase double_type;
        !          42880: Pbase ldouble_type;
        !          42881: Pbase void_type;
        !          42882: Pbase any_type;
        !          42883: 
        !          42884: Ptype Pint_type;
        !          42885: Ptype Pchar_type;
        !          42886: Ptype Pvoid_type;
        !          42887: Ptype Pfctvec_type;
        !          42888: 
        !          42889: Ptable gtbl;
        !          42890: Ptable ptbl;
        !          42891: 
        !          42892: Pname Cdcl;
        !          42893: Pstmt Cstmt;
        !          42894: 
        !          42895: bit new_type;
        !          42896: 
        !          42897: void echeck(Ptype t1, Ptype t2)
        !          42898: /*
        !          42899:        t1 is an enum, t2 is assigned to it
        !          42900: */
        !          42901: {
        !          42902:        if (t1 == t2) return;
        !          42903: 
        !          42904: //error('d',"echeck(%t,%t) %d %d",t1,t2,t1->base,t2->base);
        !          42905: //error('d',"se %d promote: %d",suppress_error, enum_promote);
        !          42906:        if (t1->base==EOBJ
        !          42907:        && t2->base==EOBJ
        !          42908:        && Pbase(t1)->b_name->tp == Pbase(t2)->b_name->tp) return;
        !          42909: 
        !          42910:        if (enum_promote) return;
        !          42911:        error(strict_opt?0:'w',"%t assigned to %t (anachronism)",t2,t1);
        !          42912: }
        !          42913: 
        !          42914: 
        !          42915: Ptype np_promote(TOK oper, TOK r1, TOK r2, Ptype t1, Ptype t2, TOK p)
        !          42916: /*
        !          42917:        an arithmetic operator "oper" is applied to "t1" and "t2",
        !          42918:        types t1 and t2 has been checked and belongs to catagories
        !          42919:        "r1" and "r2", respectively:
        !          42920:                A       ANY
        !          42921:                Z       ZERO
        !          42922:                I       CHAR, SHORT, INT, LONG, FIELD, or EOBJ
        !          42923:                F       FLOAT DOUBLE LDOUBLE
        !          42924:                P       PTR (to something) or VEC (of something)
        !          42925:        test for compatability of the operands,
        !          42926:        if (p) return the promoted result type
        !          42927: */
        !          42928: {
        !          42929:        if (r2 == 'A') return t1;
        !          42930: 
        !          42931: //error('d',"promote(%t,%t,%k)",t1,t2,oper);
        !          42932: 
        !          42933:        switch (r1) {
        !          42934:        case 'A':       return t2;
        !          42935:        case 'Z':
        !          42936:                switch (r2) {
        !          42937:                case 'Z':               return int_type;
        !          42938:                case 'I':
        !          42939:                case 'F':
        !          42940:                        if(oper==DEREF) return any_type;
        !          42941:                        return (p) ? Pbase(t2)->arit_conv(0) : 0;
        !          42942:                case 'P': switch (oper) {
        !          42943:                        case PLUS:
        !          42944:                        case ASPLUS:    if(t2!=Pvoid_type) break;
        !          42945:                        default:        return any_type;
        !          42946:                        }
        !          42947:                        return t2;
        !          42948:                case FCT:       error("zero%kF",oper); return any_type;
        !          42949:                default:        error('i',"zero(%d)",r2);
        !          42950:                }
        !          42951:        case 'I':
        !          42952:                switch (r2) {
        !          42953:                case 'Z': t2 = 0;
        !          42954:                case 'I':
        !          42955:                case 'F': 
        !          42956:                        if(oper==DEREF) return any_type;
        !          42957:                        return (p) ? Pbase(t1)->arit_conv(Pbase(t2)) : 0;
        !          42958:                case 'P': switch (oper) {
        !          42959:                        case PLUS:
        !          42960:                        case ASPLUS:    if(t2!=Pvoid_type) break;
        !          42961:                        default:        error("int%kP",oper); return any_type;
        !          42962:                        }
        !          42963:                        return t2;
        !          42964:                case FCT: error("int%kF",oper); return any_type;
        !          42965:                default: error('i',"int(%d)",r2); return any_type;
        !          42966:                }
        !          42967:        case 'F':
        !          42968:                switch (r2) {
        !          42969:                case 'Z': t2 = 0;
        !          42970:                case 'I':
        !          42971:                case 'F': 
        !          42972:                        if(oper==DEREF) return any_type;
        !          42973:                        return (p) ? Pbase(t1)->arit_conv(Pbase(t2)) : 0;
        !          42974:                case 'P': error("float%kP",oper); return any_type;
        !          42975:                case FCT: error("float%kF",oper); return any_type;
        !          42976:                default: error('i',"float(%d)",r2); return any_type;
        !          42977:                }
        !          42978:        case 'P':
        !          42979:                switch (r2) {
        !          42980:                case 'Z': return t1;
        !          42981:                case 'I':
        !          42982:                        switch (oper) {
        !          42983:                        case PLUS:
        !          42984:                        case MINUS:
        !          42985:                        case ASPLUS:
        !          42986:                        case ASMINUS:
        !          42987:                                if (t1->check(Pvoid_type,0)==0) {
        !          42988:                                        return any_type;
        !          42989:                                }
        !          42990:                                break;
        !          42991:                        default: error("P%k int",oper); return any_type;
        !          42992:                        }
        !          42993:                        return t1;
        !          42994:                case 'F': error("P%k float",oper); return any_type;
        !          42995:                case 'P':
        !          42996:                        if (t1->check(t2,ASSIGN)) {
        !          42997:                                switch (oper) {
        !          42998:                                case EQ:
        !          42999:                                case NE:
        !          43000:                                case LE:
        !          43001:                                case GE:
        !          43002:                                case GT:
        !          43003:                                case LT:
        !          43004:                                case QUEST:
        !          43005:                                        if (t2->check(t1,ASSIGN) == 0) goto zz;
        !          43006:                                }
        !          43007:                                error("T mismatch:%t %k%t",t1,oper,t2);
        !          43008:                                return any_type;
        !          43009:                        }
        !          43010:                        zz:
        !          43011:                        switch (oper) {
        !          43012:                        case MINUS:     
        !          43013:                                return (t2!=Pvoid_type) ? int_type : any_type;
        !          43014:                        case ASMINUS:   error("P -=P"); return any_type;
        !          43015:                        case PLUS:      error("P +P"); return any_type;
        !          43016:                        case ASPLUS:    error("P +=P"); return any_type;
        !          43017:                        case LS:
        !          43018:                        case RS:        return any_type;
        !          43019:                        default:        return (t1!=Pvoid_type) ? t1 : any_type;
        !          43020:                        }
        !          43021:                case FCT:       return t1;
        !          43022:                default:        error('i',"P(%d)",r2);
        !          43023:                }
        !          43024:        case FCT:
        !          43025:                if(oper == QUEST) {
        !          43026:                        switch (r2) {
        !          43027:                        case 'Z':
        !          43028:                                return any_type;
        !          43029:                        case 'P':
        !          43030:                                return t2;
        !          43031:                        case 'I':
        !          43032:                        case 'F':
        !          43033:                                error("F%k%t",oper,t2);
        !          43034:                        default:
        !          43035:                                return t1;
        !          43036:                        }
        !          43037:                }
        !          43038:                error("F%k%t",oper,t2);
        !          43039:                return any_type;
        !          43040:        default:
        !          43041:                error('i',"np_promote(%d,%d)",r1,r2);
        !          43042:        }
        !          43043: }
        !          43044: 
        !          43045: TOK type::kind(TOK oper, TOK v)
        !          43046: /*     v ==    'I'     integral
        !          43047:                'N'     numeric
        !          43048:                'P'     numeric or pointer
        !          43049: */
        !          43050: {
        !          43051:        Ptype t = this;
        !          43052:        if (this == 0) error('i',"type::kind(): this==0");
        !          43053: xx:
        !          43054:        switch (t->base) {
        !          43055:        case ANY:       return 'A';
        !          43056:        case ZTYPE:     return 'Z';
        !          43057:        case FIELD:
        !          43058:        case CHAR:
        !          43059:        case SHORT:
        !          43060:        case INT:
        !          43061:        case LONG:
        !          43062:        case EOBJ:      return 'I';
        !          43063:        case FLOAT:
        !          43064:        case LDOUBLE:
        !          43065:        case DOUBLE:    if (v == 'I') error("float operand for %k",oper);       return 'F';
        !          43066:        case VEC:
        !          43067:        case PTR:       if (v != 'P') error("P operand for %k",oper);
        !          43068:                        switch (oper) {
        !          43069:                        case INCR:
        !          43070:                        case DECR:
        !          43071:                        case MINUS:
        !          43072:                        case PLUS:
        !          43073:                        case ASMINUS:
        !          43074:                        case ASPLUS:
        !          43075:                                if (t->base==PTR
        !          43076:                                && (Pptr(t)->memof || Pptr(t)->typ->base==FCT))
        !          43077:                                        error("%t operand of%k",this,oper);
        !          43078:                                else
        !          43079:                                        Pptr(t)->typ->tsizeof(); // get increment
        !          43080:                                break;
        !          43081:                        default:
        !          43082:                                if (t->base==PTR
        !          43083:                                && (Pptr(t)->memof || Pptr(t)->typ->base==FCT))
        !          43084:                                        error("%t operand of%k",this,oper);
        !          43085:                        case ANDAND:
        !          43086:                        case OROR:
        !          43087:                        case ASSIGN:
        !          43088:                        case NE:
        !          43089:                        case EQ:
        !          43090:                        case IF:
        !          43091:                        case WHILE:
        !          43092:                        case DO:
        !          43093:                        case FOR:
        !          43094:                        case QUEST:
        !          43095:                        case NOT:
        !          43096:                                        break;
        !          43097:                        }
        !          43098:                        return 'P';
        !          43099:        case RPTR:      error("R operand for %k",oper);                 return 'A';
        !          43100:        case TYPE:      t = Pbase(t)->b_name->tp;                       goto xx;
        !          43101:        case FCT:       if (v != 'P') error("F operand for %k",oper);   return FCT;
        !          43102:        case OVERLOAD:  error("overloaded operand for %k",oper);        return 'A';
        !          43103:        case CLASS:
        !          43104:        case ENUM:      error("%k operand for %k",base,oper);           return 'A';
        !          43105:        default:        error("%t operand for %k",this,oper);           return 'A';
        !          43106:        }
        !          43107: }
        !          43108: 
        !          43109: void type::dcl(Ptable tbl)
        !          43110: /*
        !          43111:        go through the type (list) and
        !          43112:        (1) evaluate vector dimensions
        !          43113:        (2) evaluate field sizes
        !          43114:        (3) lookup struct tags, etc.
        !          43115:        (4) handle implicit tag declarations
        !          43116: */
        !          43117: {
        !          43118: static arg_fudge;
        !          43119: 
        !          43120:        Ptype t = this;
        !          43121: 
        !          43122:        if (this == 0) error('i',"T::dcl(this==0)");
        !          43123:        if (tbl->base != TABLE) error('i',"T::dcl(%d)",tbl->base);
        !          43124: 
        !          43125: xx:
        !          43126: //error('d',"type::dcl %k",t->base);
        !          43127:        switch (t->base) {
        !          43128:        case TYPE:
        !          43129:                t = Pbase(t)->b_name->tp;
        !          43130:                goto xx;
        !          43131:        case PTR:
        !          43132:        case RPTR:
        !          43133:        {       Pptr p = Pptr(t);
        !          43134:                t = p->typ;
        !          43135:                if (t->base == TYPE) {
        !          43136:                        Ptype tt = Pbase(t)->b_name->tp;
        !          43137:                        if (tt->base == FCT) p->typ = tt;
        !          43138:                        return;
        !          43139:                }
        !          43140:                goto xx;
        !          43141:        }
        !          43142: 
        !          43143:        case VEC:
        !          43144:        {       Pvec v = Pvec(t);
        !          43145:                Pexpr e = v->dim;
        !          43146:                if (e) {
        !          43147:                        Ptype et;
        !          43148:                        v->dim = e = e->typ(tbl);
        !          43149:                        et = e->tp;
        !          43150:                        if (et->integral(0) == 'A') {
        !          43151:                                error("UN in array dimension");
        !          43152:                        }
        !          43153:                        else {
        !          43154:                                long i;
        !          43155:                                Neval = 0;
        !          43156:                                i = e->eval();
        !          43157:                                if (Neval == 0) {
        !          43158:                                        if (largest_int<i)
        !          43159:                                                error("array dimension too large");
        !          43160:                                        v->size = int(i);
        !          43161: 
        !          43162:                                if ( lcl_tbl == 0 )
        !          43163: 
        !          43164:                                        DEL(v->dim);
        !          43165:                                        v->dim = 0;
        !          43166:                                }
        !          43167: 
        !          43168:                                if (new_type) {
        !          43169:                                        if (Neval)
        !          43170:                                                ;
        !          43171:                                        else if (i == 0)
        !          43172:                                                v->dim = zero;
        !          43173:                                        else if (i < 0) {
        !          43174:                                                error("negative array dimension");
        !          43175:                                                i = 1;
        !          43176:                                        }
        !          43177:                                }
        !          43178:                                else {
        !          43179:                                        if (Neval)
        !          43180:                                                error("%s",Neval);
        !          43181:                                        else if (i == 0)
        !          43182:                                                error('w',"array dimension == 0");
        !          43183:                                        else if (i < 0) {
        !          43184:                                                error("negative array dimension");
        !          43185:                                                i = 1;
        !          43186:                                        }
        !          43187:                                }
        !          43188:                        }
        !          43189:                }
        !          43190:                t = v->typ;
        !          43191:        llx:
        !          43192:                switch (t->base) {
        !          43193:                case TYPE:
        !          43194:                        t = Pbase(t)->b_name->tp;
        !          43195:                        goto llx;
        !          43196:                case FCT:
        !          43197:                        v->typ = t;
        !          43198:                        break;
        !          43199:                case VEC:                               
        !          43200:                        if (Pvec(t)->dim==0 && Pvec(t)->size==0) error("null dimension (something like [][] seen)");
        !          43201:                        if (arg_fudge) {
        !          43202:                                v->base = PTR;  // X[12][10] ==> X(*)[10]
        !          43203:                                Pptr(v)->rdo = 0;
        !          43204:                                Pptr(v)->memof = 0;
        !          43205:                        }
        !          43206:                }
        !          43207:                goto xx;
        !          43208:        }
        !          43209: 
        !          43210:        case FCT:
        !          43211:        {       Pfct f = Pfct(t);
        !          43212: void dargs(Pname, Pfct, Ptable);
        !          43213:                if (f->argtype) dargs(0,f,tbl);
        !          43214:                for (Pname n=f->argtype; n; n = n->n_list) {
        !          43215:                        arg_fudge++;
        !          43216:                        n->tp->dcl(tbl);
        !          43217:                        arg_fudge--;
        !          43218:                }
        !          43219:                Pname cn = f->returns->is_cl_obj();
        !          43220:                if (cn && Pclass(cn->tp)->has_itor())
        !          43221:                        make_res(f);
        !          43222:                else if (f->f_this == 0)
        !          43223:                        f->f_args = f->argtype;
        !          43224:                t = f->returns;
        !          43225:                goto xx;
        !          43226:        }
        !          43227: 
        !          43228:        case FIELD:
        !          43229:        {       Pbase f = Pbase(t);
        !          43230:                Pexpr e = Pexpr(f->b_name);
        !          43231:                long i;
        !          43232:                Ptype et;
        !          43233:                e = e->typ(tbl);
        !          43234:                f->b_name = Pname(e);
        !          43235:                et = e->tp;
        !          43236:                if (et->integral(0) == 'A') {
        !          43237:                        error("UN in field size");
        !          43238:                        i = 1;
        !          43239:                }
        !          43240:                else {
        !          43241:                        Neval = 0;
        !          43242:                        i = e->eval();
        !          43243:                        if (Neval)
        !          43244:                                error("%s",Neval);
        !          43245:                        else if (i < 0) {
        !          43246:                                error("negative field size");
        !          43247:                                i = 1;
        !          43248:                        }
        !          43249:                        else if (f->b_fieldtype->tsizeof()*BI_IN_BYTE < i)
        !          43250:                                error("field size > sizeof(%t)",f->b_fieldtype);
        !          43251:                        DEL(e);
        !          43252:                }
        !          43253:                f->b_bits = int(i);
        !          43254:                f->b_name = 0;
        !          43255:                break;
        !          43256:        }
        !          43257:        }
        !          43258: }
        !          43259: 
        !          43260: bit vrp_equiv;         // vector == pointer equivalence used in check()
        !          43261: bit const_problem;     // types differs only in const
        !          43262: int Vcheckerror;
        !          43263: 
        !          43264: bit type::check(Ptype t, TOK oper)
        !          43265: /*
        !          43266:        check if "this" can be combined with "t" by the operator "oper"
        !          43267: 
        !          43268:        used for check of
        !          43269:                        assignment types                (oper==ASSIGN)
        !          43270:                        declaration compatability       (oper==0)
        !          43271:                         parameterized type formals      (oper==255)
        !          43272:                           as for (oper==0) but
        !          43273:                           special checking for ANY types
        !          43274:                        argument types                  (oper==ARG)
        !          43275:                        return types                    (oper==RETURN)
        !          43276:                        overloaded function name match  (oper==OVERLOAD)
        !          43277:                        overloaded function coercion    (oper==COERCE)
        !          43278:                        virtual function match          (oper==VIRTUAL)
        !          43279: 
        !          43280:        NOT for arithmetic operators
        !          43281: 
        !          43282:        return 1 if the check failed
        !          43283: 
        !          43284:        checking of const const* and *const is a mess
        !          43285: */
        !          43286: {
        !          43287:         const unsigned int strict_any_check = (oper == 255);
        !          43288: 
        !          43289:        Ptype t1 = this;
        !          43290:        Ptype t2 = t;
        !          43291:        Ptype tt1 = this;
        !          43292:        Ptype tt2 = t;
        !          43293:        int cnst1 = 0;
        !          43294:        int cnst2 = 0;
        !          43295:        TOK b1, b2;
        !          43296:        bit first = 1;
        !          43297:        TOK r;
        !          43298:        int vv;
        !          43299:        int ptr_count = 0;
        !          43300:        int fct_seen = 0;
        !          43301:        int over;
        !          43302:        Pptr p1 = 0;
        !          43303:        Pptr p2 = 0;
        !          43304:        int p_count = 0;
        !          43305: 
        !          43306:         if (strict_any_check) oper = 0;
        !          43307: 
        !          43308: //error('d',"check %k %t %t",oper,t1,t2);
        !          43309:        if (t1==0 || t2==0) error('i',"check(%p,%p,%d)",t1,t2,oper);
        !          43310: 
        !          43311:        if (oper==VIRTUAL) {
        !          43312:                vv = 1;
        !          43313:                Vcheckerror = 0;
        !          43314:                oper = 0;
        !          43315:        }
        !          43316:        else
        !          43317:                vv = 0;
        !          43318: 
        !          43319:        if (oper == OVERLOAD) {
        !          43320:                over = 1;
        !          43321:                oper = 0;
        !          43322:        }
        !          43323:        else
        !          43324:                over = 0;
        !          43325: 
        !          43326:        const_problem = 0;
        !          43327: 
        !          43328:        while (t1 && t2) {
        !          43329:        top:
        !          43330: //error('d',"top: %t (%d) %t (%d)",t1,t1->base,t2,t2->base);
        !          43331:                if (t1 == t2) {
        !          43332:                        if (cnst1==cnst2) return 0;
        !          43333:                        if (oper) {
        !          43334: //error('d',"oper %d cnst1 %d cnst2 %d ptr %d",oper,cnst1,cnst2,tt1->is_ptr());
        !          43335:                                if (tt1 = tt1->is_ptr()) {
        !          43336: 
        !          43337:                                        // const* = int*
        !          43338:                                        if (cnst2<cnst1) return 0;
        !          43339: 
        !          43340:                                        // int* = int *const
        !          43341:                                        if (cnst2==1 && tt2->tconst()) {
        !          43342:                                                // check for int* = const *const
        !          43343:                                                tt2 = tt2->is_ptr();
        !          43344:                                                if (tt2->tconst()) return 1;
        !          43345:                                                return 0;
        !          43346:                                        }
        !          43347:                                }
        !          43348:                                else {  // int = const allowed
        !          43349:                                        if (oper==ARG || cnst1<cnst2) return 0;
        !          43350:                                }
        !          43351:                        }
        !          43352:                        else {
        !          43353:                                if (p_count) {
        !          43354:                                        int pr1 = p1->rdo ? 1 : 0;
        !          43355:                                        int pr2 = p2->rdo ? 1 : 0;
        !          43356:                                        if (pr1+cnst1==pr2+cnst2)
        !          43357:                                                return 0;
        !          43358:                                }
        !          43359:                        //      const_problem = 1;
        !          43360:                        }
        !          43361: 
        !          43362:                        const_problem = 1;
        !          43363:                        return 1;
        !          43364:                }
        !          43365: 
        !          43366:                 if  ((t1->base == ANY || t2->base == ANY)) {
        !          43367:                           if (! strict_any_check) return 0;
        !          43368:                           // Perform the check for strict_any, ie. the
        !          43369:                           return ((t1 == t2) ? 0 : 1) ;
        !          43370:                 }
        !          43371: 
        !          43372:                b1 = t1->base;
        !          43373:                switch (b1) {
        !          43374:                case TYPE:
        !          43375:                        if (Pbase(t1)->b_const) cnst1++;
        !          43376:                        t1 = Pbase(t1)->b_name->tp;
        !          43377:                        goto top;
        !          43378:                }
        !          43379: 
        !          43380:                b2 = t2->base;
        !          43381:                switch (b2) {
        !          43382:                case TYPE:
        !          43383:                        if (Pbase(t2)->b_const) cnst2++;
        !          43384:                        t2 = Pbase(t2)->b_name->tp;
        !          43385:                        goto top;
        !          43386:                }
        !          43387: 
        !          43388: //error('d',"oper %k b1 %k b2 %k",oper,b1,b2);
        !          43389:                if (b1 != b2) {
        !          43390:                        switch (b1) {
        !          43391:                        case PTR:
        !          43392:                                switch (b2) {
        !          43393:                                case VEC:
        !          43394:                                        if (ptr_count) return 1;
        !          43395:                                        // ptr/vec equivalence does not
        !          43396:                                        // apply to declaration matching
        !          43397:                                        t1 = Pptr(t1)->typ;
        !          43398:                                        t2 = Pvec(t2)->typ;
        !          43399:                                        if (oper == 0 && over==0) return 1;
        !          43400:                                        ptr_count++;
        !          43401:                                        first = 0;
        !          43402:                                        goto top;
        !          43403:                                case FCT:
        !          43404:                                        t1 = Pptr(t1)->typ;
        !          43405:                                        if (t1->base!=VOID) 
        !          43406:                                                if (first==0 || t1->base!=b2) return 1;
        !          43407:                                        first = 0;
        !          43408:                                        goto top;
        !          43409:                                }
        !          43410:                                first = 0;
        !          43411:                                break;
        !          43412: 
        !          43413:                         case FCT:
        !          43414:                                 switch( b2 ) {
        !          43415:                                 case PTR:
        !          43416:                                         t2 = Pptr(t2)->typ;
        !          43417:                                         if (t1->base!=VOID
        !          43418:                                        && (first==0||t2->base!=b1)) return 1;
        !          43419:                                         first = 0;
        !          43420:                                         goto top;
        !          43421:                                 }
        !          43422:                                 first = 0;
        !          43423:                                 break;
        !          43424: 
        !          43425:                        case VEC:
        !          43426:                                switch (b2) {
        !          43427:                                case PTR:
        !          43428:                                        if (ptr_count) return 1;
        !          43429:                                        t1 = Pvec(t1)->typ;
        !          43430:                                        t2 = Pptr(t2)->typ;
        !          43431:                                        switch (oper) {
        !          43432:                                        case ARG:
        !          43433:                                        case ASSIGN:
        !          43434:                                        case COERCE:
        !          43435:                                                break;
        !          43436:                                        case 0:
        !          43437:                                                if (over) break;
        !          43438:                                        default:
        !          43439:                                                return 1;
        !          43440:                                        }
        !          43441:                                        ptr_count++;
        !          43442:                                        first = 0;
        !          43443:                                        goto top;
        !          43444:                                }
        !          43445:                                first = 0;
        !          43446:                                break;
        !          43447:                        }
        !          43448:                        goto base_check; 
        !          43449:                }
        !          43450: 
        !          43451:                switch (b1) {
        !          43452:                case VEC:
        !          43453: //error('d',"vec %k %d %d",oper,Pvec(t1)->size,Pvec(t2)->size);
        !          43454:                        if (first==0 && Pvec(t1)->size!=Pvec(t2)->size) return 1;
        !          43455:                        first = 0;
        !          43456:                        t1 = Pvec(t1)->typ;
        !          43457:                        t2 = Pvec(t2)->typ;
        !          43458:                        ptr_count++;
        !          43459:                        break;
        !          43460: 
        !          43461:                case PTR:
        !          43462:                case RPTR:
        !          43463:                        first = 0;
        !          43464:                        p1 = Pptr(t1);
        !          43465:                        p2 = Pptr(t2);
        !          43466:                        p_count++;
        !          43467: 
        !          43468:                        if (p1->memof != p2->memof) {
        !          43469: 
        !          43470:                                if(p1->memof!=0 && p2->memof!=0
        !          43471:                                    && p1->memof->baseof(p2->memof)==0)
        !          43472:                                        return 1;
        !          43473: 
        !          43474:                                int flag1=0,flag2=0;
        !          43475:                                t1 = p1->typ;
        !          43476:                                t2 = p2->typ;
        !          43477:                                while (t1->base == TYPE) {
        !          43478:                                        flag1++;
        !          43479:                                        t1 = Pbase(t1)->b_name->tp;
        !          43480:                                }
        !          43481:                                while (t2->base == TYPE) {
        !          43482:                                        flag2++;
        !          43483:                                        t2 = Pbase(t2)->b_name->tp;
        !          43484:                                }
        !          43485:                                if (t1 != t2 || (!flag1 && !flag2)) {
        !          43486:                                        if (p1->memof==0
        !          43487:                                        || p2->memof==0
        !          43488:                                        || p1->memof->baseof(p2->memof)==0)
        !          43489:                                                return 1;
        !          43490:                                        Nstd++;
        !          43491:                                }
        !          43492:                        }
        !          43493: 
        !          43494:                        t1 = p1->typ;
        !          43495:                        t2 = p2->typ;
        !          43496:                        ptr_count++;
        !          43497: 
        !          43498:                        if (oper==0) {
        !          43499:                                int pr1 = p1->rdo ? 1 : 0;
        !          43500:                                int pr2 = p2->rdo ? 1 : 0;
        !          43501:                                if (pr1+cnst1!=pr2+cnst2
        !          43502:                                && cnst1+Pbase(t1)->b_const!=cnst2+Pbase(t2)->b_const) {
        !          43503:                                        // const_problem only if nothing
        !          43504:                                        // more serious is wrong
        !          43505:                                        if (t1->check(t2,0) == 0) const_problem = 1;
        !          43506:                                        return 1;
        !          43507:                                }
        !          43508: 
        !          43509:                                if (b1==RPTR && t1->tconst()!=t2->tconst())
        !          43510:                                        const_problem = 1;
        !          43511:                        }
        !          43512:                        break;
        !          43513: 
        !          43514:                case FCT:
        !          43515:                        first = 0;
        !          43516:                {       Pfct f1 = Pfct(t1);
        !          43517:                        Pfct f2 = Pfct(t2);
        !          43518:                        Pname a1 = f1->argtype;
        !          43519:                        Pname a2 = f2->argtype;
        !          43520:                        TOK k1 = f1->nargs_known;
        !          43521:                        TOK k2 = f2->nargs_known;
        !          43522:                        int n1 = f1->nargs;
        !          43523:                        int n2 = f2->nargs;
        !          43524: //error('d',"f1%t f2%t",f1,f2);
        !          43525:                        if (f1->memof != f2->memof) {
        !          43526:                                if (f1->memof==0 && f2->f_this==0)      //SSS
        !          43527:                                        goto sss;
        !          43528:                                if (vv == 0)    // match even if private base class
        !          43529:                                        if (f1->memof==0
        !          43530:                                        || f2->memof==0
        !          43531:                                        || f1->memof->baseof(f2->memof)==0) return 1;
        !          43532:                                Nstd++;
        !          43533:                                sss:;   //SSS
        !          43534:                        }
        !          43535: 
        !          43536:                        if (k1 != k2) return 1;
        !          43537: 
        !          43538:                        if (n1!=n2 && k1 && k2) {
        !          43539:                                goto aaa;
        !          43540:                        }
        !          43541:                        else if (a1 && a2) {
        !          43542:                                int i = 0;
        !          43543:                                while (a1 && a2) {
        !          43544:                                        i++;
        !          43545:                                        if (a1->tp->check(a2->tp,over?OVERLOAD:0)) return 1;
        !          43546:                                        a1 = a1->n_list;
        !          43547:                                        a2 = a2->n_list;
        !          43548:                                }
        !          43549:                                if (a1 || a2) goto aaa;
        !          43550:                        }
        !          43551:                        else if (a1 || a2) {
        !          43552:                        aaa:
        !          43553: //error('d',"aaa k1 %d k2 %d",k1,k2);
        !          43554:                                if (k1 == ELLIPSIS) {
        !          43555:                                        switch (oper) {
        !          43556:                                        case 0:
        !          43557:                                                if (a2 && k2==0) break;
        !          43558:                                                return 1;
        !          43559:                                        case ASSIGN:
        !          43560:                                                if (a2 && k2==0) break;
        !          43561:                                                return 1;
        !          43562:                                        case ARG:
        !          43563:                                                if (a1) return 1;
        !          43564:                                                break;
        !          43565:                                //      case OVERLOAD:
        !          43566:                                        case COERCE:
        !          43567:                                                return 1;
        !          43568:                                        }
        !          43569:                                }
        !          43570:                                else if (k2 == ELLIPSIS) {
        !          43571:                                        return 1;
        !          43572:                                }
        !          43573:                                else if (k1 || k2) {
        !          43574:                                        return 1;
        !          43575:                                }
        !          43576:                        }
        !          43577: 
        !          43578:                        t1 = f1->returns;
        !          43579:                        t2 = f2->returns;
        !          43580:                        fct_seen = 1;
        !          43581: 
        !          43582:                        switch (oper) { //CCC
        !          43583:                        case 0:
        !          43584:                                if (f1->f_const!=f2->f_const) {
        !          43585:                                        if (t1->check(t2,0)==0) const_problem = 1;
        !          43586:                                        return 1;
        !          43587:                                //      if (vv == 0) return 1;
        !          43588:                                //      Vcheckerror = 1;
        !          43589:                                }
        !          43590:                                break;
        !          43591:                        default:        // really pointer to function
        !          43592:                                if (f1->f_const && f2->f_const==0) return 1;
        !          43593:                        }
        !          43594: 
        !          43595: 
        !          43596:                        if (vv && t1->check(t2,0)) { Vcheckerror = 1; return 1; }
        !          43597:                }
        !          43598:                        break;
        !          43599: 
        !          43600:                case FIELD:
        !          43601:                        goto field_check;
        !          43602:                case CHAR:
        !          43603:                case SHORT:
        !          43604:                case INT:
        !          43605:                case LONG:
        !          43606:                        goto int_check;
        !          43607:                case FLOAT:
        !          43608:                case DOUBLE:
        !          43609:                case LDOUBLE:
        !          43610:                        goto float_check;
        !          43611:                case EOBJ:
        !          43612:                        goto enum_check;
        !          43613:                case COBJ:
        !          43614:                        goto cla_check;
        !          43615:                case ZTYPE:
        !          43616:                case VOID:
        !          43617:                        return 0;
        !          43618:                default:
        !          43619:                        error('i',"T::check(o=%d %d %d)",oper,b1,b2);
        !          43620:                }
        !          43621:        }
        !          43622: 
        !          43623:        if (t1 || t2) {
        !          43624:                const_problem = 0;      // not a problem: the type itself is bad
        !          43625:                return 1;
        !          43626:        }
        !          43627:        return 0;
        !          43628: 
        !          43629: field_check:
        !          43630:        switch (oper) {
        !          43631:        case 0:
        !          43632:        case ARG:
        !          43633:                error('i',"check field?");
        !          43634:        }
        !          43635:        return 0;
        !          43636: 
        !          43637: enum_check:
        !          43638: //error('d',"enum check %t %t",t1,t2);
        !          43639:        if (Pbase(t1)->b_name->tp != Pbase(t2)->b_name->tp) goto base_check;
        !          43640:        goto const_check;
        !          43641: 
        !          43642: float_check:
        !          43643:        if (first==0 && b1!=b2 && b2!=ZTYPE) return 1;
        !          43644:        // no break
        !          43645: 
        !          43646: int_check:
        !          43647: //error('d',"int_check");
        !          43648:        if (Pbase(t1)->b_unsigned != Pbase(t2)->b_unsigned) {
        !          43649:                if (first == 0) return 1;
        !          43650:                if (oper /*&& oper!=OVERLOAD*/)
        !          43651:                        Nstd++;
        !          43652:                else
        !          43653:                        return 1;
        !          43654:        }
        !          43655:        // no break
        !          43656: 
        !          43657: const_check:
        !          43658: //error('d',"const_check %t (%d) %t (%d)",t1,t1->tconst(),t2,t2->tconst());
        !          43659:        if (oper==0) {
        !          43660: //error('d',"oper==0: t1 %t t2 %t cnst1 %d cnst2 %d",t1,t2,cnst1,cnst2);
        !          43661:                if (t1->tconst()+cnst1!=t2->tconst()+cnst2) {
        !          43662:                        const_problem = 1;
        !          43663:                        return 1;
        !          43664:                }
        !          43665:        }
        !          43666:        else if (first==0) {
        !          43667:                if (t1->tconst()+cnst1==0 && t2->tconst()+cnst2) {
        !          43668: //error('d',"t1 %t t2 %t cnst1 %d cnst2 %d",t1,t2,cnst1,cnst2);
        !          43669: //error('d',"tt1 %t %d cnst1 %d cnst2 %d",tt1,tt1->is_ptr(),cnst1,cnst2);
        !          43670: //error('d',"tt2 %t",tt2);
        !          43671:                        if (tt1->is_ptr()) {
        !          43672:                                if (fct_const || vec_const) cnst2--;
        !          43673: 
        !          43674:                                // const* = int*
        !          43675:                                if (cnst2-tt2->tconst()<cnst1-tt1->tconst()) return 0;
        !          43676: 
        !          43677:                                // int* = *const
        !          43678:                                //if (cnst2==1 && tt2->tconst()) return 0;
        !          43679: 
        !          43680:                                // const T* = const T*
        !          43681:                                if (t2->tconst()+cnst2==t1->tconst()+cnst1) return 0;
        !          43682:                        }
        !          43683:                        else {  // int = const allowed
        !          43684:                                if (cnst1<cnst2) return 0;
        !          43685:                        }
        !          43686:                        const_problem = 1;
        !          43687:                        return 1;
        !          43688:                }
        !          43689:                else {  // const* vs int *const
        !          43690: /*
        !          43691:  //error('d',"t1 %t cnst1 %d t2 %t cnst2 %d",t1,cnst1,t2,cnst2);
        !          43692:                        if (tt1->is_ptr()) {
        !          43693:                                int tt1c = tt1->tconst();
        !          43694:                                int tt2c = tt2->tconst() - fct_const - vec_const;
        !          43695:  //error('d',"tt1c %d tt2c %d",tt1c,tt2c);
        !          43696:                                if (tt1c<tt2c) return 1;
        !          43697:                                int t1c = t1->tconst();
        !          43698:                                int t2c = t2->tconst() - fct_const - vec_const;
        !          43699:  //error('d',"t1c %d t2c %d",t1c,t2c);
        !          43700:                                if (cnst1+t1c<cnst2+t2c) return 1;
        !          43701:                                if (tt2c<tt1c   // *const = *
        !          43702:                                && cnst1+t1c>cnst2+t2c) // T = constT
        !          43703:                                        return 1;
        !          43704:                        }
        !          43705: */
        !          43706:                        
        !          43707:                }
        !          43708:        }
        !          43709:        else {
        !          43710: //error('d',"first t1 %t t2 %t cnst1 %d cnst2 %d",t1,t2,cnst1,cnst2);
        !          43711:        }
        !          43712: //error('d',"return 0");
        !          43713:        return 0;
        !          43714: 
        !          43715: cla_check:
        !          43716:        {       Pname n1 = Pbase(t1)->b_name;
        !          43717:                Pname n2 = Pbase(t2)->b_name;
        !          43718: //error('d',"cla_check %n %n ptr_count %d",n1,n2,ptr_count);
        !          43719:                if (n1 == n2) goto const_check;
        !          43720: 
        !          43721:                 // once again, a more comprehensive check for classes,
        !          43722:                 // since they may be parametrized.
        !          43723:                 if ((t1->base == COBJ) && (t2->base == COBJ) &&
        !          43724:                    ((Pclass(n1->tp)->same_class(Pclass(n2->tp)))))
        !          43725:                         goto const_check;
        !          43726: 
        !          43727:                if (/*first || */1<ptr_count || fct_seen) return 1;
        !          43728: 
        !          43729:                switch (oper) {
        !          43730:                case ARG:
        !          43731:                case ASSIGN:
        !          43732:                case RETURN:
        !          43733:                case COERCE:
        !          43734:                {
        !          43735:                        ppbase = PUBLIC;
        !          43736:                        if (Pclass(n2->tp)->is_base(n1->string)) {
        !          43737:                                if (ppbase!=PUBLIC) {
        !          43738:                                        const_problem = 0;
        !          43739:                                //      vrp_equiv = 0;
        !          43740:                                        return 1;       // private or protected base
        !          43741:                                }
        !          43742:                                Nstd++;
        !          43743:                                goto const_check;
        !          43744:                        }
        !          43745:                }
        !          43746:                        // no break
        !          43747:                case 0:
        !          43748:                case OVERLOAD:
        !          43749:                        const_problem = 0;
        !          43750:                //      vrp_equiv = 0;
        !          43751:                        return 1;
        !          43752:                }
        !          43753: 
        !          43754:                goto const_check;
        !          43755:        }
        !          43756: 
        !          43757: base_check:
        !          43758: //error('d',"base_check t1=%t t2=%t oper=%d %s",t1,t2,oper,first?"first":"");
        !          43759: //error('d',"ptr_count %d",ptr_count);
        !          43760:        if (oper)
        !          43761:        if (first || 1!=ptr_count) {
        !          43762:                if (b1==VOID || b2==VOID) return 1;
        !          43763:        }
        !          43764:        else {
        !          43765:                if (b1 == VOID) {               // check for void* = T*
        !          43766:                        register Ptype tpx = this;
        !          43767:                tpxloop:
        !          43768:                        switch (tpx->base) {    // t1 == void*
        !          43769:                        default:
        !          43770:                                        const_problem = 0;
        !          43771:                                        return 1;
        !          43772:                        case VOID:      break;
        !          43773:                        case PTR:
        !          43774:                        case VEC:       tpx = Pvec(tpx)->typ;
        !          43775:                                        goto tpxloop;
        !          43776:                        case TYPE:      tpx = Pbase(tpx)->b_name->tp;
        !          43777:                                        goto tpxloop;
        !          43778:                        }
        !          43779: 
        !          43780:                        tpx = t;
        !          43781:                bloop:
        !          43782:                        switch (tpx->base) {    // t2 == T*
        !          43783:                        default:
        !          43784:                                        const_problem = 0;
        !          43785:                                        return 1;
        !          43786:                        case VEC:
        !          43787:                        case PTR:
        !          43788:                        case FCT:       Nstd++;
        !          43789:                                //      return 0;
        !          43790:                                        goto const_check; // prevent void* = const*
        !          43791:                        case TYPE:      tpx = Pbase(tpx)->b_name->tp;
        !          43792:                                        goto bloop;
        !          43793:                        }
        !          43794:                }
        !          43795: 
        !          43796:                if (b2 != ZTYPE) {
        !          43797:                        const_problem = 0;
        !          43798:                        return 1;
        !          43799:                }
        !          43800:        }
        !          43801: //error('d',"oper %d b1 %d b2 %d cp %d",oper,b1,b2,const_problem);
        !          43802:        switch (oper) {
        !          43803:        case 0:
        !          43804:                if (b1 != b2) {
        !          43805:                        const_problem = 0; // we have a bigger problem
        !          43806:                //      vrp_equiv = 0;
        !          43807:                }
        !          43808:                return 1;
        !          43809:        case COERCE:    // could probably be merged with the cases below
        !          43810:                switch (b1) {
        !          43811:                case EOBJ:
        !          43812:                case ZTYPE:
        !          43813:                case CHAR:
        !          43814:                case SHORT:
        !          43815:                case INT:
        !          43816:                        switch (b2) {
        !          43817:                                case LONG:
        !          43818:                                case FLOAT:
        !          43819:                                case DOUBLE:
        !          43820:                                case LDOUBLE:
        !          43821:                                case EOBJ:
        !          43822:                                case ZTYPE:
        !          43823:                                case CHAR:
        !          43824:                                case SHORT:
        !          43825:                                case INT:
        !          43826:                                case FIELD:
        !          43827:                                        Nstd++;
        !          43828:                                        suppress_error++;
        !          43829:                                        if (b1 == EOBJ) echeck(t1,t2);
        !          43830:                                        suppress_error--;
        !          43831:                                        goto const_check;
        !          43832:                        }
        !          43833:                        return 1;
        !          43834:                case LONG:      // char, short, and int promotes to long
        !          43835:                        switch (b2) {
        !          43836:                                case FLOAT:
        !          43837:                                case DOUBLE:
        !          43838:                                case LDOUBLE:
        !          43839:                        case ZTYPE:
        !          43840:                        case EOBJ:
        !          43841:                        case CHAR:
        !          43842:                        case SHORT:
        !          43843:                        case INT:
        !          43844:                        case FIELD:
        !          43845:                                Nstd++;
        !          43846:                                goto const_check;
        !          43847:                        }
        !          43848:                        return 1;
        !          43849:                case FLOAT:
        !          43850:                //      switch (b2) {
        !          43851:                //      case ZTYPE:
        !          43852:                //              Nstd++;
        !          43853:                //      case FLOAT:
        !          43854:                //      case DOUBLE:
        !          43855:                //              goto const_check;
        !          43856:                //      }
        !          43857:                //      return 1;
        !          43858:                case DOUBLE:    // char, short, int, and float promotes to double
        !          43859:                case LDOUBLE:
        !          43860:                        switch (b2) {
        !          43861:                        case LONG:
        !          43862:                        case ZTYPE:
        !          43863:                        case EOBJ:
        !          43864:                        case CHAR:
        !          43865:                        case SHORT:
        !          43866:                        case INT:
        !          43867:                //              Nstd++;
        !          43868:                        case FLOAT:
        !          43869:                        case DOUBLE:
        !          43870:                        case LDOUBLE:
        !          43871: Nstd++;
        !          43872:                                goto const_check;
        !          43873:                        }
        !          43874:                        return 1;
        !          43875:                case PTR:
        !          43876:                        switch (b2) {
        !          43877:                        case ZTYPE:
        !          43878:                                Nstd++;
        !          43879:                                goto const_check;
        !          43880:                        }
        !          43881:                case RPTR:
        !          43882:                case VEC:
        !          43883:                case COBJ:
        !          43884:                case FCT:
        !          43885:                        return 1;
        !          43886:                }
        !          43887:        case ARG:
        !          43888:        case ASSIGN:
        !          43889:        case RETURN:
        !          43890:                switch (b1) {
        !          43891:                case COBJ:
        !          43892:                        return 1;
        !          43893:                case EOBJ:
        !          43894:                case ZTYPE:
        !          43895:                case CHAR:
        !          43896:                case SHORT:
        !          43897:                case INT:
        !          43898:                case LONG:
        !          43899:                        suppress_error++;
        !          43900:                        r = t2->num_ptr(ASSIGN);
        !          43901:                        suppress_error--;
        !          43902:                        switch (r) {
        !          43903:                        case 'F':
        !          43904:                        //      if (oper!=ARG) error('w',"%t assigned to%t",t2,t1);
        !          43905:                                break;
        !          43906:                        case 'A':
        !          43907:                        case 'P':
        !          43908:                        case FCT:       return 1;
        !          43909:                        }
        !          43910:                        if (b1 == EOBJ) echeck(t1,t2);  
        !          43911:                        break;
        !          43912:                case FLOAT:
        !          43913:                case DOUBLE:
        !          43914:                case LDOUBLE:
        !          43915:                        suppress_error++;
        !          43916:                        r = t2->numeric(ASSIGN);
        !          43917:                        suppress_error--;
        !          43918:                        switch (r) {    
        !          43919:                        case 'A':
        !          43920:                        case 'P':
        !          43921:                        case FCT:       return 1;
        !          43922:                        }
        !          43923:                        break;
        !          43924:                case VEC:
        !          43925:                        if(oper==ARG && b2==ZTYPE) goto const_check;
        !          43926:                        return 1;
        !          43927:                case PTR:
        !          43928:                        suppress_error++;
        !          43929:                        r = t2->num_ptr(ASSIGN);
        !          43930:                        suppress_error--;
        !          43931:                        switch (r) {
        !          43932:                        case 'A':
        !          43933:                        case 'I':
        !          43934:                        case 'F':       return 1;
        !          43935:                        case FCT:       if (Pptr(t1)->typ->base != FCT) return 1;
        !          43936:                        }
        !          43937:                        break;
        !          43938:                case RPTR:
        !          43939:                        return 1;
        !          43940:                case FCT:
        !          43941:                        switch (oper) {
        !          43942:                        case ARG:
        !          43943:                        case ASSIGN:
        !          43944:                                return 1;
        !          43945:                        }
        !          43946:                }       
        !          43947:                break;
        !          43948:        }
        !          43949:        goto const_check;
        !          43950: }
        !          43951: 
        !          43952: 0707071010112045731004440001630000160000010210500466055413100000700000022542typ2.c/*ident     "@(#)ctrans:src/typ2.c  1.3" */
        !          43953: /**************************************************************************
        !          43954: 
        !          43955:        C++ source for cfront, the C++ compiler front-end
        !          43956:        written in the computer science research center of Bell Labs
        !          43957: 
        !          43958:        Copyright (c) 1984 AT&T, Inc. All Rights Reserved
        !          43959:        THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T, INC.
        !          43960: 
        !          43961: typ2.c:
        !          43962: 
        !          43963: ***************************************************************************/
        !          43964:  
        !          43965: #include "cfront.h"
        !          43966: #include "size.h"
        !          43967: 
        !          43968: extern int chars_in_largest;
        !          43969: int largest_int;
        !          43970: 
        !          43971: void typ_init()
        !          43972: {      
        !          43973:        chars_in_largest = strlen(LARGEST_INT);
        !          43974:        largest_int = int(str_to_long(LARGEST_INT));
        !          43975: 
        !          43976:        defa_type = new basetype(INT,0);        // note defa_type!=int_type
        !          43977:        int_type = new basetype(INT,0);         // but they both represent `int'
        !          43978: 
        !          43979:        PERM(int_type); int_type->defined = DEFINED ;
        !          43980:        PERM(defa_type); defa_type->defined = DEFINED ;
        !          43981: 
        !          43982:        moe_type = new basetype(INT,0);
        !          43983:        PERM(moe_type); moe_type->defined = DEFINED ;
        !          43984:        moe_type->b_const = 1;
        !          43985:        moe_type->check(0);
        !          43986: 
        !          43987:        uint_type = new basetype(INT,0);
        !          43988:        PERM(uint_type); uint_type->defined = DEFINED ;
        !          43989:        uint_type->type_adj(UNSIGNED);
        !          43990:        uint_type->check(0);
        !          43991: 
        !          43992:        long_type = new basetype(LONG,0);
        !          43993:        PERM(long_type); long_type->defined = DEFINED ;
        !          43994:        long_type->check(0);
        !          43995: 
        !          43996:        ulong_type = new basetype(LONG,0);
        !          43997:        PERM(ulong_type); ulong_type->defined = DEFINED ;
        !          43998:        ulong_type->type_adj(UNSIGNED);
        !          43999:        ulong_type->check(0);
        !          44000: 
        !          44001:        short_type = new basetype(SHORT,0);
        !          44002:        PERM(short_type); short_type->defined = DEFINED ;
        !          44003:        short_type->check(0);
        !          44004: 
        !          44005:        ushort_type = new basetype(SHORT,0);
        !          44006:        PERM(ushort_type); ushort_type->defined = DEFINED ;
        !          44007:        ushort_type->type_adj(UNSIGNED);
        !          44008:        ushort_type->check(0);
        !          44009: 
        !          44010:        float_type = new basetype(FLOAT,0);
        !          44011:        PERM(float_type); float_type->defined = DEFINED ;
        !          44012: 
        !          44013:        double_type = new basetype(DOUBLE,0);
        !          44014:        PERM(double_type); double_type->defined = DEFINED ;
        !          44015: 
        !          44016:        ldouble_type = new basetype(LDOUBLE,0);
        !          44017:        PERM(ldouble_type); ldouble_type->defined = DEFINED ;
        !          44018: 
        !          44019:        zero_type = new basetype(ZTYPE,0);
        !          44020:        PERM(zero_type); zero_type->defined = DEFINED ;
        !          44021:        zero->tp = zero_type;
        !          44022: 
        !          44023:        void_type = new basetype(VOID,0);
        !          44024:        PERM(void_type); void_type->defined = DEFINED ;
        !          44025: 
        !          44026:        char_type = new basetype(CHAR,0);
        !          44027:        PERM(char_type); char_type->defined = DEFINED ;
        !          44028: 
        !          44029:        uchar_type = new basetype(CHAR,0);
        !          44030:        PERM(uchar_type); uchar_type->defined = DEFINED ;
        !          44031:        uchar_type->type_adj(UNSIGNED);
        !          44032:        uchar_type->check(0);
        !          44033: 
        !          44034:        Pchar_type = char_type->addrof();
        !          44035:        PERM(Pchar_type); Pchar_type->defined = DEFINED ;
        !          44036: 
        !          44037:        Pint_type = int_type->addrof();
        !          44038:        PERM(Pint_type); Pint_type->defined = DEFINED ;
        !          44039: 
        !          44040:        Pvoid_type = void_type->addrof();
        !          44041:        PERM(Pvoid_type); Pvoid_type->defined = DEFINED ;
        !          44042: 
        !          44043:        Pfctvec_type = new fct(int_type,0,0);   // must be last, see basetype::normalize()
        !          44044:        Pfctvec_type = Pfctvec_type->addrof();
        !          44045:        Pfctvec_type = Pfctvec_type->addrof();
        !          44046:        PERM(Pfctvec_type); Pfctvec_type->defined = DEFINED ;
        !          44047: 
        !          44048:        gtbl = new table(GTBLSIZE,0,0);
        !          44049:        gtbl->t_name = new name("global");
        !          44050:        ptbl = new table(CTBLSIZE,0,0);
        !          44051:        ptbl->t_name = new name("ptbl");
        !          44052: }
        !          44053: 
        !          44054: bit enum_promote;
        !          44055: 
        !          44056: Pbase basetype::arit_conv(Pbase t)
        !          44057: /*
        !          44058:        perform the "usual arithmetic conversions" C ref Manual 6.6
        !          44059:        on "this" op "t"
        !          44060:        "this" and "t" are integral or floating
        !          44061:        "t" may be 0
        !          44062: */
        !          44063: {
        !          44064:        while (base == TYPE) this = Pbase(Pbase(this)->b_name->tp);
        !          44065: // error('d', "arit_conv: this: %k %d %t %d", base, base, this, this );
        !          44066: 
        !          44067:        bit l;
        !          44068:        bit u;
        !          44069:        bit f;
        !          44070:        bit l1 = (base == LONG);
        !          44071:        bit u1 = b_unsigned;
        !          44072:        bit f1 = (base==FLOAT || base==DOUBLE || base==LDOUBLE);
        !          44073:        if (t) {
        !          44074:                while (t->base == TYPE) t = Pbase(Pbase(t)->b_name->tp);
        !          44075: // error('d', "arit_conv: t: %k %d %t %d", t->base, t->base, t, t );
        !          44076: 
        !          44077:                bit l2 = (t->base == LONG);
        !          44078:                bit u2 = t->b_unsigned;
        !          44079:                bit f2 = (t->base==FLOAT || t->base==DOUBLE || base==LDOUBLE);
        !          44080:                l = l1 || l2;
        !          44081:                u = u1 || u2;
        !          44082:                f = f1 || f2;
        !          44083:        }
        !          44084:        else {
        !          44085:                l = l1;
        !          44086:                u = u1;
        !          44087:                f = f1;
        !          44088:        }
        !          44089: 
        !          44090:        if (f) {
        !          44091:                if (base==LDOUBLE || (t && t->base==LDOUBLE)) return ldouble_type;
        !          44092:                if (base==DOUBLE || (t && t->base==DOUBLE)) return double_type;
        !          44093:                return float_type;
        !          44094:        }
        !          44095:        if (l & u) return ulong_type;
        !          44096:        if (l & !u) return long_type;
        !          44097:        if (u) {
        !          44098:                if (base==INT || (t && t->base==INT)) return uint_type;
        !          44099:                if (SZ_SHORT==SZ_INT) // ANSIism
        !          44100:                        if (base==SHORT || (t && t->base==SHORT)) return uint_type;
        !          44101:                return int_type;
        !          44102:        }
        !          44103: 
        !          44104:        if (t && t->base == EOBJ && base == EOBJ) enum_promote = 1;
        !          44105:        return int_type;
        !          44106: }
        !          44107: 
        !          44108: bit vec_const = 0;
        !          44109: bit fct_const = 0;
        !          44110: 
        !          44111: bit type::tconst()
        !          44112: /*
        !          44113:        is this type a constant
        !          44114: */
        !          44115: {
        !          44116:        Ptype t = this;
        !          44117:        vec_const = 0;
        !          44118:        fct_const = 0;
        !          44119: //error('d',"tconst %t",t);
        !          44120: xxx:
        !          44121:        switch (t->base) {
        !          44122:        case TYPE:
        !          44123:                if (Pbase(t)->b_const) return 1;
        !          44124:                t = Pbase(t)->b_name->tp;
        !          44125:                goto xxx;
        !          44126:        case VEC:
        !          44127:                vec_const = 1;
        !          44128:                return 1;
        !          44129:        case PTR:
        !          44130:        case RPTR:
        !          44131:                return Pptr(t)->rdo;
        !          44132:        case FCT:
        !          44133:        case OVERLOAD:
        !          44134:                fct_const = 1;
        !          44135:                return 1;
        !          44136:        default:
        !          44137:                return Pbase(t)->b_const;
        !          44138:        }
        !          44139: }
        !          44140: 
        !          44141: TOK type::set_const(bit mode)
        !          44142: /*
        !          44143:        make someting a constant or variable, return old status
        !          44144: */
        !          44145: {
        !          44146:        Ptype t = this;
        !          44147:        int m;
        !          44148: xxx:
        !          44149:        switch (t->base) {
        !          44150:        case TYPE:
        !          44151:                m = Pbase(t)->b_const;
        !          44152:                Pbase(t)->b_const = mode;
        !          44153:                t = Pbase(t)->b_name->tp;
        !          44154:                goto xxx;
        !          44155:        case ANY:
        !          44156:        case RPTR:
        !          44157:        case VEC:
        !          44158:                return t->base;         // constant by definition
        !          44159:        case PTR:
        !          44160:                m = Pptr(t)->rdo;
        !          44161:                Pptr(t)->rdo = mode;
        !          44162:                return m;
        !          44163:        default:
        !          44164:                m = Pbase(t)->b_const;
        !          44165:                Pbase(t)->b_const = mode;
        !          44166:                return m;
        !          44167:        }
        !          44168: }
        !          44169: 
        !          44170: Pptr type::is_ref()
        !          44171: {
        !          44172:        Ptype t = this;
        !          44173: xxx:
        !          44174:        switch (t->base) {
        !          44175:        case TYPE:      t = Pbase(t)->b_name->tp; goto xxx;
        !          44176:        case RPTR:      return Pptr(t);
        !          44177:        default:        return 0;
        !          44178:        }
        !          44179: }
        !          44180: 
        !          44181: Pclass Mptr;
        !          44182: 
        !          44183: Pptr type::is_ptr()
        !          44184: {
        !          44185:        Ptype t = this;
        !          44186: xxx:
        !          44187:        switch (t->base) {
        !          44188:        case TYPE:      t = Pbase(t)->b_name->tp; goto xxx;
        !          44189:        case PTR:
        !          44190:        case VEC:       Mptr = Pptr(t)->memof;
        !          44191:                        return Pptr(t);
        !          44192:        default:        return 0;
        !          44193:        }
        !          44194: }
        !          44195: 
        !          44196: Pptr type::is_ptr_or_ref()
        !          44197: {
        !          44198:        Ptype t = this;
        !          44199: xxx:
        !          44200:        switch (t->base) {
        !          44201:        case TYPE:      t = Pbase(t)->b_name->tp; goto xxx;
        !          44202:        case PTR:
        !          44203:        case RPTR:
        !          44204:        case VEC:       Mptr = Pptr(t)->memof;
        !          44205:                        return Pptr(t);
        !          44206:        default:        return 0;
        !          44207:        }
        !          44208: }
        !          44209: 
        !          44210: int type::align()
        !          44211: {
        !          44212:        Ptype t = this;
        !          44213: xx:
        !          44214: /*fprintf(stderr,"align %d %d\n",t,t->base);*/
        !          44215:        switch (t->base) {
        !          44216:        case TYPE:      t = Pbase(t)->b_name->tp; goto xx;
        !          44217:        case COBJ:      t = Pbase(t)->b_name->tp; goto xx;
        !          44218:        case VEC:       t = Pvec(t)->typ; goto xx;
        !          44219:        case ANY:       return 1;
        !          44220:        case CHAR:      return AL_CHAR;
        !          44221:        case SHORT:     return AL_SHORT;
        !          44222:        case INT:       return AL_INT;
        !          44223:        case LONG:      return AL_LONG;
        !          44224:        case FLOAT:     return AL_FLOAT;
        !          44225:        case DOUBLE:    return AL_DOUBLE;
        !          44226:        case LDOUBLE:   return AL_LDOUBLE;
        !          44227:        case PTR:
        !          44228:        case RPTR:      return AL_WPTR;
        !          44229:        case CLASS:     return Pclass(t)->obj_align;
        !          44230:        case ENUM:
        !          44231:        case EOBJ:      return AL_INT;
        !          44232:        case VOID:      error("illegal use of void"); return AL_INT;
        !          44233:        default:        error('i',"(%d,%k)->type::align",t,t->base);
        !          44234:        }
        !          44235: }
        !          44236: 
        !          44237: bit fake_sizeof;
        !          44238: 
        !          44239: int type::tsizeof(int ptmc)
        !          44240: /*
        !          44241:        the sizeof type operator
        !          44242:        return the size in bytes of the types representation
        !          44243: */
        !          44244: {
        !          44245:        Ptype t = this;
        !          44246: zx:
        !          44247: //error('d',"zx %t %d",t,t->base);
        !          44248:        if (t == 0) error('i',"typ.tsizeof(t==0)");
        !          44249:        switch (t->base) {
        !          44250:        case TYPE:
        !          44251:                t = Pbase(t)->b_name->tp;
        !          44252:                goto zx;
        !          44253:        case COBJ:
        !          44254:                t = Pbase(t)->b_name->tp;
        !          44255:                if (t == 0) return 0;   // ``fake'' generated classes: _Sdd
        !          44256:                goto zx;
        !          44257: 
        !          44258:        case ANY:       return 1;
        !          44259:        case VOID:      return 0;
        !          44260:        case ZTYPE:     return SZ_WPTR; /* assume pointer */
        !          44261:        case CHAR:      return SZ_CHAR;
        !          44262:        case SHORT:     return SZ_SHORT;
        !          44263:        case INT:       return SZ_INT;
        !          44264:        case LONG:      return SZ_LONG;
        !          44265:        case FLOAT:     return SZ_FLOAT;
        !          44266:        case DOUBLE:    return SZ_DOUBLE;
        !          44267:        case LDOUBLE:   return SZ_LDOUBLE;
        !          44268: 
        !          44269:        case VEC:
        !          44270:                {       Pvec v = Pvec(t);
        !          44271:                        if (v->size == 0) {
        !          44272:                                if (fake_sizeof == 0) error('w',"sizeof array with undeclared dimension");
        !          44273:                                return SZ_WPTR; // vector argument has sizeof ptr
        !          44274:                        }
        !          44275:                        return v->size * v->typ->tsizeof();
        !          44276:                }
        !          44277:        case RPTR:      
        !          44278:        case PTR:
        !          44279:        {       
        !          44280:                int k = (Pptr(t)->memof && !ptmc)?sizeof(short)+sizeof(short):0;
        !          44281:                t = Pptr(t)->typ;
        !          44282:        xxx:
        !          44283:                switch (t->base) {
        !          44284:                default:        return SZ_WPTR;
        !          44285:                case CHAR:      return SZ_BPTR;
        !          44286:                case FCT:       return SZ_WPTR+k;
        !          44287:                case TYPE:      t = Pbase(t)->b_name->tp; goto xxx;
        !          44288:                }
        !          44289:        }
        !          44290:        case FIELD:
        !          44291:                error("sizeof(field)");
        !          44292:                return Pbase(t)->b_bits/BI_IN_BYTE+1;
        !          44293:        case FCT:
        !          44294:                error("sizeof(function)");
        !          44295:                return 0;
        !          44296: 
        !          44297:        case CLASS:     
        !          44298:        {
        !          44299:                 Pclass cl = Pclass(t);
        !          44300:                if ((cl->defined&(DEFINED|SIMPLIFIED)) == 0) {
        !          44301:                        error("%tU, size not known",cl);
        !          44302:                        return SZ_INT;
        !          44303:                }
        !          44304:                if (cl->c_body == 1)    // detect first allocation or sizeof
        !          44305:                        cl->dcl_print(0);
        !          44306:                return cl->obj_size;
        !          44307:        }
        !          44308: 
        !          44309:        case EOBJ:
        !          44310:        case ENUM:      return SZ_INT;
        !          44311: 
        !          44312:        default:        return 0;       // deref can be called for any type
        !          44313:                        //error('i',"sizeof(%d)",t->base);
        !          44314:        }
        !          44315: }
        !          44316: 
        !          44317: bit type::vec_type()
        !          44318: {
        !          44319:        Ptype t = this;
        !          44320: xx:
        !          44321:        switch (t->base) {
        !          44322:        case ANY:
        !          44323:        case VEC:
        !          44324:        case PTR:
        !          44325:        case RPTR:      return 1;
        !          44326:        case TYPE:      t = Pbase(t)->b_name->tp; goto xx;
        !          44327:        default:        return 0;
        !          44328:        }
        !          44329: }
        !          44330: 
        !          44331: int ref_initializer;
        !          44332: 
        !          44333: Ptype type::deref()
        !          44334: /*     index==1:       *p
        !          44335:        index==0:       p[expr]
        !          44336: */
        !          44337: {
        !          44338: //error('d',"%t -> deref() refd %d",this,ref_initializer);
        !          44339:        Ptype t = this;
        !          44340: xx:
        !          44341:        switch (t->base) {
        !          44342:        case TYPE:
        !          44343:                t = Pbase(t)->b_name->tp;
        !          44344:                goto xx;
        !          44345:        case PTR:
        !          44346:        case RPTR:
        !          44347:        case VEC:
        !          44348:        {       if (t == Pvoid_type) error("void* dereferenced");
        !          44349:                Ptype tt = t = Pvec(t)->typ;
        !          44350:                if (ref_initializer == 0) {
        !          44351:                        while (tt->base == TYPE) tt = Pbase(tt)->b_name->tp;
        !          44352:                        if (tt->base == COBJ) { 
        !          44353:                                tt = Pbase(tt)->b_name->tp;
        !          44354:                                if (tt && Pclass(tt)->defined&(DEFINED|SIMPLIFIED))
        !          44355:                                        (void) t->tsizeof();
        !          44356:                         }
        !          44357:                }
        !          44358:                // no break
        !          44359:        }
        !          44360:        case ANY:
        !          44361:                return t;
        !          44362:        default:
        !          44363:                error("nonP dereferenced");
        !          44364:                return any_type;
        !          44365:        }
        !          44366: }
        !          44367: 
        !          44368: Pfct type::memptr()
        !          44369: // is ``this'' a pointer to member function
        !          44370: {
        !          44371:        Ptype t = this;
        !          44372:        while (t->base == TYPE) t = Pbase(t)->b_name->tp;
        !          44373:        if (t->base != PTR || Pptr(t)->memof==0) return 0;
        !          44374: 
        !          44375:        t = Pptr(t)->typ;
        !          44376:        while (t->base == TYPE) t = Pbase(t)->b_name->tp;
        !          44377:        return (t->base == FCT) ? Pfct(t) : 0;
        !          44378: }
        !          44379: 0707071010112045741004440001630000160000010177160466055413400001200000002731typedef.h/*ident  "@(#)ctrans:src/typedef.h       1.2" */
        !          44380: /**************************************************************************
        !          44381: 
        !          44382:         C++ source for cfront, the C++ compiler front-end
        !          44383:         written in the computer science research center of Bell Labs
        !          44384: 
        !          44385:         Copyright (c) 1984 AT&T, Inc. All Rights Reserved
        !          44386:         THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T, INC.
        !          44387: 
        !          44388: typedef.h:
        !          44389: 
        !          44390: *****************************************************************************/
        !          44391: 
        !          44392: typedef unsigned char TOK;
        !          44393: typedef unsigned char bit;     // sometimes used as bits
        !          44394: typedef class node * PP;
        !          44395: typedef int (*PFI)();
        !          44396: typedef void (*PFV)();
        !          44397: typedef class node * Pnode;
        !          44398: typedef struct key * Pkey;
        !          44399: typedef class name * Pname;
        !          44400: typedef class basetype * Pbase;
        !          44401: typedef class basecl* Pbcl;
        !          44402: typedef class type * Ptype;
        !          44403: typedef class fct  * Pfct;
        !          44404: typedef class field * Pfield;
        !          44405: typedef class expr * Pexpr;
        !          44406: typedef class qexpr * Pqexpr;
        !          44407: typedef class texpr * Ptexpr;
        !          44408: typedef class classdef * Pclass;
        !          44409: typedef class enumdef * Penum;
        !          44410: typedef class stmt * Pstmt;
        !          44411: typedef class estmt * Pestmt;
        !          44412: typedef class tstmt * Ptstmt;
        !          44413: typedef class vec * Pvec;
        !          44414: typedef class ptr * Pptr;
        !          44415: typedef class block * Pblock;
        !          44416: typedef class table * Ptable;
        !          44417: typedef struct loc Loc;
        !          44418: typedef class call * Pcall;
        !          44419: typedef class gen* Pgen;
        !          44420: typedef class ref * Pref;
        !          44421: typedef class name_list * Plist;
        !          44422: typedef class iline * Pin;
        !          44423: typedef class nlist * Pnlist;
        !          44424: typedef class slist * Pslist;
        !          44425: typedef class elist * Pelist;
        !          44426: typedef class virt * Pvirt;
        !          44427: typedef char* Pchar;
        !          44428: 
        !          44429: 0707071010112045751004440001630000160000010201670466055413700001200000001374yystype.h/*ident  "@(#)ctrans:src/yystype.h       1.2" */
        !          44430: /**************************************************************************
        !          44431: 
        !          44432:         C++ source for cfront, the C++ compiler front-end
        !          44433:         written in the computer science research center of Bell Labs
        !          44434: 
        !          44435:         Copyright (c) 1984 AT&T, Inc. All Rights Reserved
        !          44436:         THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T, INC.
        !          44437: 
        !          44438: yystype:
        !          44439: 
        !          44440: *****************************************************************************/
        !          44441: 
        !          44442: typedef union {
        !          44443:        char*   s;
        !          44444:        TOK     t;
        !          44445:        int     i;
        !          44446:        loc     l;
        !          44447:        Pname   pn;
        !          44448:        Ptype   pt;
        !          44449:        Pexpr   pe;
        !          44450:        Pstmt   ps;
        !          44451:        Pbase   pb;
        !          44452:        Pnlist  nl;
        !          44453:        Pslist  sl;
        !          44454:        Pelist  el;
        !          44455:        Pbcl    pbc;
        !          44456:        Pptr    pp;
        !          44457:        PP      p;      // fudge: pointer to all class node objects
        !          44458:        Plist   pl;     // fudge: pointer to all class node objects
        !          44459: } YYSTYPE;
        !          44460: extern YYSTYPE yylval;
        !          44461: 0707071010112045751004440001630000160000010201670466055413700001300000000000TRAILER!!!ss node objects
        !          44462: } YYSTYPE;
        !          44463: extern YYSTYPE yylval;
        !          44464: 0707071010112045751004440001630000160000010201670466055413700001300000000000TRAILER!!!ss node objects
        !          44465: } YYSTYPE;
        !          44466: extern YYSTYPE yylval;
        !          44467: 0707071010112045751004440001630000160000010201670466055413700001300000000000TRAILER!!!ss node objects
        !          44468: } YYSTYPE;
        !          44469: extern YYSTYPE yylval;
        !          44470: 070707101011204575100444000163000016000001020167046