自学教程：C++ type_debug函数代码示例

type *type_copy(type *t){   type *tn;    param_t *p;    type_debug(t);    if (tybasic(t->Tty) == TYtemplate)    {        tn = type_alloc_template(((typetemp_t *)t)->Tsym);    }    else        tn = type_alloc(t->Tty);    *tn = *t;    switch (tybasic(tn->Tty))    {       case TYtemplate:                ((typetemp_t *)tn)->Tsym = ((typetemp_t *)t)->Tsym;                goto L1;            case TYident:                tn->Tident = (char *)MEM_PH_STRDUP(t->Tident);                break;            case TYarray:                if (tn->Tflags & TFvla)                    tn->Tel = el_copytree(tn->Tel);                break;            default:                if (tyfunc(tn->Tty))                {                L1:                    tn->Tparamtypes = NULL;                    for (p = t->Tparamtypes; p; p = p->Pnext)                    {   param_t *pn;                        pn = param_append_type(&tn->Tparamtypes,p->Ptype);                        if (p->Pident)                        {                            pn->Pident = (char *)MEM_PH_STRDUP(p->Pident);                        }                        assert(!p->Pelem);                    }                }#if SCPP                else if (tn->Talternate && typtr(tn->Tty))                    tn->Talternate->Tcount++;#endif#if MARS                else if (tn->Tkey && typtr(tn->Tty))                    tn->Tkey->Tcount++;#endif                break;    }    if (tn->Tnext)    {   type_debug(tn->Tnext);        tn->Tnext->Tcount++;    }    tn->Tcount = 0;    return tn;}

void param_hydrate(param_t **pp){    param_t *p;    assert(pp);    if (isdehydrated(*pp))    {   while (*pp)        {   assert(isdehydrated(*pp));            p = (param_t *) ph_hydrate(pp);            param_debug(p);            type_hydrate(&p->Ptype);            if (p->Ptype)                type_debug(p->Ptype);            ph_hydrate(&p->Pident);            if (CPP)            {                el_hydrate(&p->Pelem);                if (p->Pelem)                    elem_debug(p->Pelem);                type_hydrate(&p->Pdeftype);                if (p->Pptpl)                    param_hydrate(&p->Pptpl);                if (p->Psym)                    symbol_hydrate(&p->Psym);                if (p->PelemToken)                    token_hydrate(&p->PelemToken);            }            pp = &p->Pnext;        }    }}

STATIC void cpp_ecsu_data_type(type *t){   char c;    symbol *stag;    int i;    type_debug(t);    switch (tybasic(t->Tty))    {        case TYstruct:            stag = t->Ttag;            switch (stag->Sstruct->Sflags & (STRclass | STRunion))            {   case 0:         c = 'U';        break;                case STRunion:  c = 'T';        break;                case STRclass:  c = 'V';        break;                default:                    assert(0);            }            CHAR(c);            cpp_ecsu_name(stag);            break;        case TYenum:            CHAR('W');            cpp_enum_name(t->Ttag);            break;        default:#ifdef DEBUG            type_print(t);#endif            assert(0);    }}

void param_dehydrate(param_t **pp){    param_t *p;    assert(pp);    while ((p = *pp) != NULL && !isdehydrated(p))    {   param_debug(p);        ph_dehydrate(pp);        if (p->Ptype && !isdehydrated(p->Ptype))            type_debug(p->Ptype);        type_dehydrate(&p->Ptype);        ph_dehydrate(&p->Pident);        if (CPP)        {            el_dehydrate(&p->Pelem);            type_dehydrate(&p->Pdeftype);            if (p->Pptpl)                param_dehydrate(&p->Pptpl);            if (p->Psym)                symbol_dehydrate(&p->Psym);            if (p->PelemToken)                token_dehydrate(&p->PelemToken);        }        pp = &p->Pnext;    }}

int type_jparam(type *t){    targ_size_t sz;    type_debug(t);    return tyjparam(t->Tty) ||                ((tybasic(t->Tty) == TYstruct || tybasic(t->Tty) == TYarray) &&                 (sz = type_size(t)) <= NPTRSIZE &&                 (sz == 1 || sz == 2 || sz == 4 || sz == 8));}

void type_hydrate(type **pt){    type *t;    assert(pt);    while (isdehydrated(*pt))    {        t = (type *) ph_hydrate(pt);        type_debug(t);#if !TX86        if (t->Tflags & TFhydrated)            return;#if SOURCE_4TYPES        t->Tsrcpos.Sfilnum += File_Hydrate_Num; /* file number relative header build */#endif        t->Tflags |= TFhydrated;#endif        switch (tybasic(t->Tty))        {            case TYstruct:            case TYenum:            case TYmemptr:            case TYvtshape:                // Cannot assume symbol is hydrated, because entire HX file                // may not have been hydrated.                Classsym_hydrate(&t->Ttag);                symbol_debug(t->Ttag);                break;            case TYident:                ph_hydrate(&t->Tident);                break;            case TYtemplate:                symbol_hydrate(&((typetemp_t *)t)->Tsym);                param_hydrate(&t->Tparamtypes);                break;            case TYarray:                if (t->Tflags & TFvla)                    el_hydrate(&t->Tel);                break;            default:                if (tyfunc(t->Tty))                {   param_hydrate(&t->Tparamtypes);                    list_hydrate(&t->Texcspec, (list_free_fp)type_hydrate);                }#if SCPP                else if (t->Talternate && typtr(t->Tty))                    type_hydrate(&t->Talternate);#endif#if MARS                else if (t->Tkey && typtr(t->Tty))                    type_hydrate(&t->Tkey);#endif                break;        }        pt = &t->Tnext;    }}

type *type_allocn(tym_t ty,type *tn){   type *t;    //printf("type_allocn(ty = x%x, tn = %p)/n", ty, tn);    assert(tn);    type_debug(tn);    t = type_alloc(ty);    t->Tnext = tn;    tn->Tcount++;    //printf("/tt = %p/n", t);    return t;}

STATIC void cpp_this_type(type *tfunc,Classsym *stag){   type *t;    type_debug(tfunc);    symbol_debug(stag);#if MARS    t = type_pointer(stag->Stype);#else    t = cpp_thistype(tfunc,stag);#endif    //cpp_data_indirect_type(t);    cpp_ecsu_data_indirect_type(t);    type_free(t);}

param_t *param_append_type(param_t **pp,type *t){   param_t *p;    p = param_calloc();    while (*pp)    {   param_debug(*pp);        pp = &((*pp)->Pnext);   /* find end of list     */    }    *pp = p;                    /* append p to list     */    type_debug(t);    p->Ptype = t;    t->Tcount++;    return p;}

void type_dehydrate(type **pt){    type *t;    while ((t = *pt) != NULL && !isdehydrated(t))    {        ph_dehydrate(pt);#if DEBUG_XSYMGEN        /* don't dehydrate types in HEAD when creating XSYM */        if (xsym_gen && (t->Tflags & TFhydrated))            return;#endif        type_debug(t);        switch (tybasic(t->Tty))        {            case TYstruct:            case TYenum:            case TYmemptr:            case TYvtshape:                Classsym_dehydrate(&t->Ttag);                break;            case TYident:                ph_dehydrate(&t->Tident);                break;            case TYtemplate:                symbol_dehydrate(&((typetemp_t *)t)->Tsym);                param_dehydrate(&t->Tparamtypes);                break;            case TYarray:                if (t->Tflags & TFvla)                    el_dehydrate(&t->Tel);                break;            default:                if (tyfunc(t->Tty))                {   param_dehydrate(&t->Tparamtypes);                    list_dehydrate(&t->Texcspec, (list_free_fp)type_dehydrate);                }#if SCPP                else if (t->Talternate && typtr(t->Tty))                    type_dehydrate(&t->Talternate);#endif#if MARS                else if (t->Tkey && typtr(t->Tty))                    type_dehydrate(&t->Tkey);#endif                break;        }        pt = &t->Tnext;    }}

STATIC void cpp_this_type(type *tfunc,Classsym *stag){   type *t;    type_debug(tfunc);    symbol_debug(stag);#if MARS    t = type_allocn(TYnptr, stag->Stype);    t->Tcount++;#else    t = cpp_thistype(tfunc,stag);#endif    //cpp_data_indirect_type(t);    cpp_ecsu_data_indirect_type(t);    type_free(t);}

int type_isdependent(type *t){    Symbol *stempl;    type *tstart;    //printf("type_isdependent(%p)/n", t);    //type_print(t);    for (tstart = t; t; t = t->Tnext)    {        type_debug(t);        if (t->Tflags & TFdependent)            goto Lisdependent;        if (tyfunc(t->Tty)#if TARGET_SEGMENTED                || tybasic(t->Tty) == TYtemplate#endif                )        {            for (param_t *p = t->Tparamtypes; p; p = p->Pnext)            {                if (p->Ptype && type_isdependent(p->Ptype))                    goto Lisdependent;                if (p->Pelem && el_isdependent(p->Pelem))                    goto Lisdependent;            }        }        else if (type_struct(t) &&                 (stempl = t->Ttag->Sstruct->Stempsym) != NULL)        {            for (param_t *p = t->Ttag->Sstruct->Sarglist; p; p = p->Pnext)            {                if (p->Ptype && type_isdependent(p->Ptype))                    goto Lisdependent;                if (p->Pelem && el_isdependent(p->Pelem))                    goto Lisdependent;            }        }    }    //printf("/tis not dependent/n");    return 0;Lisdependent:    //printf("/tis dependent/n");    // Dependence on a dependent type makes this type dependent as well    tstart->Tflags |= TFdependent;    return 1;}

int type_embed(type *t,type *u){   param_t *p;    for (; t; t = t->Tnext)    {        type_debug(t);        if (t == u)            return 1;        if (tyfunc(t->Tty))        {            for (p = t->Tparamtypes; p; p = p->Pnext)                if (type_embed(p->Ptype,u))                    return 1;        }    }    return 0;}

void type_hydrate(type **pt){    type *t;    assert(pt);    while (isdehydrated(*pt))    {        t = (type *) ph_hydrate(pt);        type_debug(t);        switch (tybasic(t->Tty))        {            case TYstruct:            case TYenum:            case TYmemptr:            case TYvtshape:                // Cannot assume symbol is hydrated, because entire HX file                // may not have been hydrated.                Classsym_hydrate(&t->Ttag);                symbol_debug(t->Ttag);                break;            case TYident:                ph_hydrate(&t->Tident);                break;            case TYtemplate:                symbol_hydrate(&((typetemp_t *)t)->Tsym);                param_hydrate(&t->Tparamtypes);                break;            case TYarray:                if (t->Tflags & TFvla)                    el_hydrate(&t->Tel);                break;            default:                if (tyfunc(t->Tty))                {   param_hydrate(&t->Tparamtypes);                    list_hydrate(&t->Texcspec, (list_free_fp)type_hydrate);                }                else if (t->Talternate && typtr(t->Tty))                    type_hydrate(&t->Talternate);                else if (t->Tkey && typtr(t->Tty))                    type_hydrate(&t->Tkey);                break;        }        pt = &t->Tnext;    }}

STATIC void cpp_data_type(type *t){    type_debug(t);    switch (tybasic(t->Tty))    {   case TYvoid:            CHAR('X');            break;        case TYstruct:        case TYenum:            CHAR('?');            cpp_ecsu_data_indirect_type(t);            cpp_ecsu_data_type(t);            break;        default:            cpp_primary_data_type(t);            break;    }}

void type_free(type *t){   type *tn;    tym_t ty;    while (t)    {        //dbg_printf("type_free(%p, Tcount = %d)/n", t, t->Tcount);        type_debug(t);        assert((int)t->Tcount != -1);        if (--t->Tcount)                /* if usage count doesn't go to 0 */            break;        ty = tybasic(t->Tty);        if (tyfunc(ty))        {   param_free(&t->Tparamtypes);            list_free(&t->Texcspec, (list_free_fp)type_free);        }#if !MARS        else if (ty == TYtemplate)            param_free(&t->Tparamtypes);        else if (ty == TYident)            MEM_PH_FREE(t->Tident);#endif        else if (t->Tflags & TFvla && t->Tel)            el_free(t->Tel);#if SCPP        else if (t->Talternate && typtr(ty))            type_free(t->Talternate);#endif#if MARS        else if (t->Tkey && typtr(ty))            type_free(t->Tkey);#endif#ifdef DEBUG        type_num--;        //dbg_printf("Free'ing type %p ",t); WRTYxx(t->Tty); dbg_printf("/n");        t->id = 0;                      /* no longer a valid type       */#endif        tn = t->Tnext;        t->Tnext = type_list;        type_list = t;                  /* link into free list          */        t = tn;    }}

unsigned type_alignsize(type *t){   targ_size_t sz;L1:    type_debug(t);    sz = tyalignsize(t->Tty);    if (sz == (targ_size_t)-1)    {        switch (tybasic(t->Tty))        {            case TYarray:                if (t->Tflags & TFsizeunknown)                    goto err1;                t = t->Tnext;                goto L1;            case TYstruct:                t = t->Ttag->Stype;         // find main instance                                            // (for const struct X)                if (t->Tflags & TFsizeunknown)                    goto err1;                sz = t->Ttag->Sstruct->Salignsize;                if (sz > t->Ttag->Sstruct->Sstructalign)                    sz = t->Ttag->Sstruct->Sstructalign;                break;            case TYldouble:                assert(0);            default:            err1:                   // let type_size() handle error messages                sz = type_size(t);                break;        }    }    //printf("type_alignsize() = %d/n", sz);    return sz;}

void param_hydrate(param_t **pp){    param_t *p;    assert(pp);    if (isdehydrated(*pp))    {   while (*pp)        {   assert(isdehydrated(*pp));            p = (param_t *) ph_hydrate(pp);#if SOURCE_4PARAMS            p->Psrcpos.Sfilnum += File_Hydrate_Num;     /* file number relative header build */#endif            param_debug(p);            type_hydrate(&p->Ptype);            if (p->Ptype)                type_debug(p->Ptype);            ph_hydrate(&p->Pident);            if (CPP)            {                el_hydrate(&p->Pelem);                if (p->Pelem)                    elem_debug(p->Pelem);                type_hydrate(&p->Pdeftype);                if (p->Pptpl)                    param_hydrate(&p->Pptpl);                if (p->Psym)                    symbol_hydrate(&p->Psym);                if (p->PelemToken)                    token_hydrate(&p->PelemToken);            }            pp = &p->Pnext;        }    }}

void type_print(type *t){  type_debug(t);  dbg_printf("Tty="); WRTYxx(t->Tty);  dbg_printf(" Tmangle=%d",t->Tmangle);  dbg_printf(" Tflags=x%x",t->Tflags);  dbg_printf(" Tcount=%d",t->Tcount);  if (!(t->Tflags & TFsizeunknown) &&        tybasic(t->Tty) != TYvoid &&        tybasic(t->Tty) != TYident &&        tybasic(t->Tty) != TYmfunc &&        tybasic(t->Tty) != TYarray &&        tybasic(t->Tty) != TYtemplate)      dbg_printf(" Tsize=%ld",type_size(t));  dbg_printf(" Tnext=%p",t->Tnext);  switch (tybasic(t->Tty))  {     case TYstruct:        case TYmemptr:            dbg_printf(" Ttag=%p,'%s'",t->Ttag,t->Ttag->Sident);            //dbg_printf(" Sfldlst=%p",t->Ttag->Sstruct->Sfldlst);            break;        case TYarray:            dbg_printf(" Tdim=%ld",t->Tdim);            break;        case TYident:            dbg_printf(" Tident='%s'",t->Tident);            break;        case TYtemplate:            dbg_printf(" Tsym='%s'",((typetemp_t *)t)->Tsym->Sident);            {   param_t *p;                int i;                i = 1;                for (p = t->Tparamtypes; p; p = p->Pnext)                {   dbg_printf("/nTP%d (%p): ",i++,p);                    fflush(stdout);dbg_printf("Pident=%p,Ptype=%p,Pelem=%p,Pnext=%p ",p->Pident,p->Ptype,p->Pelem,p->Pnext);                    param_debug(p);                    if (p->Pident)                        printf("'%s' ", p->Pident);                    if (p->Ptype)                        type_print(p->Ptype);                    if (p->Pelem)                        elem_print(p->Pelem);                }            }            break;        default:            if (tyfunc(t->Tty))            {   param_t *p;                int i;                i = 1;                for (p = t->Tparamtypes; p; p = p->Pnext)                {   dbg_printf("/nP%d (%p): ",i++,p);                    fflush(stdout);dbg_printf("Pident=%p,Ptype=%p,Pelem=%p,Pnext=%p ",p->Pident,p->Ptype,p->Pelem,p->Pnext);                    param_debug(p);                    if (p->Pident)                        printf("'%s' ", p->Pident);                    type_print(p->Ptype);                }            }            break;  }  dbg_printf("/n");  if (t->Tnext) type_print(t->Tnext);}

targ_size_t type_size(type *t){   targ_size_t s;    unsigned long u;    tym_t tyb;    type_debug(t);    tyb = tybasic(t->Tty);#ifdef DEBUG    if (tyb >= TYMAX)        /*type_print(t),*/        dbg_printf("tyb = x%lx/n",tyb);#endif    assert(tyb < TYMAX);    s = tysize[tyb];    if (s == (targ_size_t) -1)    {        switch (tyb)        {            // in case program plays games with function pointers            case TYffunc:            case TYfpfunc:#if TX86            case TYnfunc:       /* in case program plays games with function pointers */            case TYhfunc:            case TYnpfunc:            case TYnsfunc:            case TYfsfunc:            case TYf16func:            case TYifunc:            case TYjfunc:#endif#if SCPP                if (ANSI)                    synerr(EM_unknown_size,"function"); /* size of function is not known */#endif                s = 1;                break;            case TYarray:                if (t->Tflags & TFsizeunknown)                {#if SCPP                    synerr(EM_unknown_size,"array");    /* size of array is unknown     */#endif                    t->Tflags &= ~TFsizeunknown;                }                if (t->Tflags & TFvla)                {                    s = tysize[pointertype];                    break;                }                s = type_size(t->Tnext);                u = t->Tdim * (unsigned long) s;#if TX86 && SCPP                type_chksize(u);#endif                s = u;                break;            case TYstruct:                t = t->Ttag->Stype;     /* find main instance           */                                        /* (for const struct X)         */                if (t->Tflags & TFsizeunknown)                {#if SCPP                    template_instantiate_forward(t->Ttag);                    if (t->Tflags & TFsizeunknown)                        synerr(EM_unknown_size,t->Tty & TYstruct ? prettyident(t->Ttag) : "struct");                    t->Tflags &= ~TFsizeunknown;#endif                }                assert(t->Ttag);                s = t->Ttag->Sstruct->Sstructsize;                break;#if SCPP            case TYenum:                if (t->Ttag->Senum->SEflags & SENforward)                    synerr(EM_unknown_size, prettyident(t->Ttag));                s = type_size(t->Tnext);                break;#endif            case TYvoid:#if SCPP && TARGET_WINDOS               // GNUC allows it, so we will, too                synerr(EM_void_novalue);        // voids have no value#endif                s = 1;                break;#if SCPP            case TYref:            case TYmemptr:            case TYvtshape:                s = tysize(tym_conv(t));                break;            case TYident:                synerr(EM_unknown_size, t->Tident);                s = 1;                break;#endif#if MARS            case TYref:                s = tysize(TYnptr);//.........这里部分代码省略.........