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

    void visit(WithStatement *s)    {        Symbol *sp;        elem *e;        elem *ei;        ExpInitializer *ie;        Blockx *blx = irs->blx;        //printf("WithStatement::toIR()/n");        if (s->exp->op == TOKimport || s->exp->op == TOKtype)        {        }        else        {            // Declare with handle            sp = toSymbol(s->wthis);            symbol_add(sp);            // Perform initialization of with handle            ie = s->wthis->_init->isExpInitializer();            assert(ie);            ei = toElemDtor(ie->exp, irs);            e = el_var(sp);            e = el_bin(OPeq,e->Ety, e, ei);            elem_setLoc(e, s->loc);            incUsage(irs, s->loc);            block_appendexp(blx->curblock,e);        }        // Execute with block        if (s->_body)            Statement_toIR(s->_body, irs);    }

Element* TextBase::drop(EditData& ed)      {      TextCursor* _cursor = cursor(ed);      Element* e = ed.element;      switch (e->type()) {            case ElementType::SYMBOL:                  {                  SymId id = toSymbol(e)->sym();                  delete e;                  deleteSelectedText(ed);                  insertSym(ed, id);                  }                  break;            case ElementType::FSYMBOL:                  {                  uint code = toFSymbol(e)->code();                  delete e;                  QString s = QString::fromUcs4(&code, 1);                  deleteSelectedText(ed);                  score()->undo(new InsertText(_cursor, s), &ed);                  }                  break;            default:                  break;            }      return 0;      }

/************************************** * Given an expression e that is an array, * determine and set the 'length' variable. * Input: *      lengthVar       Symbol of 'length' variable *      &e      expression that is the array *      t1      Type of the array * Output: *      e       is rewritten to avoid side effects * Returns: *      expression that initializes 'length' */elem *resolveLengthVar(VarDeclaration *lengthVar, elem **pe, Type *t1){    //printf("resolveLengthVar()/n");    elem *einit = NULL;    if (lengthVar && !(lengthVar->storage_class & STCconst))    {        elem *elength;        Symbol *slength;        if (t1->ty == Tsarray)        {            TypeSArray *tsa = (TypeSArray *)t1;            dinteger_t length = tsa->dim->toInteger();            elength = el_long(TYsize_t, length);            goto L3;        }        else if (t1->ty == Tarray)        {            elength = *pe;            *pe = el_same(&elength);            elength = el_una(I64 ? OP128_64 : OP64_32, TYsize_t, elength);        L3:            slength = toSymbol(lengthVar);            //symbol_add(slength);            einit = el_bin(OPeq, TYsize_t, el_var(slength), elength);        }    }    return einit;}

UseStmt::UseStmt(BaseAST*                            source,                 std::vector<const char*>*           args,                 bool                                exclude,                 std::map<const char*, const char*>* renames) :  Stmt(E_UseStmt),  src(NULL),  named(),  renamed(),  except(exclude),  relatedNames(){  if (Symbol* b = toSymbol(source)) {    src = new SymExpr(b);  } else if (Expr* b = toExpr(source)) {    src = b;  } else {    INT_FATAL(this, "Bad mod in UseStmt constructor");  }  if (args->size() > 0) {    // Symbols to search when going through this module's scope from an outside    // scope    for_vector(const char, str, *args) {      named.push_back(str);    }  }

        void visit(TypeInfoDeclaration *tid)        {            //printf("TypeInfoDeclaration::toObjFile(%p '%s') protection %d/n", tid, tid->toChars(), tid->protection);            if (multiobj)            {                obj_append(tid);                return;            }            Symbol *s = toSymbol(tid);            s->Sclass = SCcomdat;            s->Sfl = FLdata;            TypeInfo_toDt(&s->Sdt, tid);            dt_optimize(s->Sdt);            // See if we can convert a comdat to a comdef,            // which saves on exe file space.            if (s->Sclass == SCcomdat &&                dtallzeros(s->Sdt))            {                s->Sclass = SCglobal;                dt2common(&s->Sdt);            }            outdata(s);            if (tid->isExport())                objmod->export_symbol(s, 0);        }

void Expr::verify() {  if (prev || next)    if (!list)      INT_FATAL(this, "Expr is in list but does not point at it");  if (prev && prev->next != this)    INT_FATAL(this, "Bad Expr->prev->next");  if (next && next->prev != this)    INT_FATAL(this, "Bad Expr->next->prev");  if (!parentSymbol)    INT_FATAL(this, "Expr::parentSymbol is NULL");  if (parentExpr && parentExpr->parentSymbol != parentSymbol)    INT_FATAL(this, "Bad Expr::parentSymbol");  if (list && parentExpr && list->parent != parentExpr)    INT_FATAL(this, "Bad Expr::list::parent");  if (list && !parentExpr) {    if (Symbol* lps = toSymbol(list->parent))      if (lps != parentSymbol)        INT_FATAL(this, "Bad symbol Expr::list::parent");    if (Type* lpt = toType(list->parent))      if (lpt->symbol != parentSymbol)        INT_FATAL(this, "Bad type Expr::list::parent");    if (isExpr(list->parent))      INT_FATAL(this, "Expr::list::parent is an Expr unexpectedly");  }}

elem *Module::toEmodulename(){   elem *efilename;    // Get filename    if (needModuleInfo())    {   Symbol *si;	/* Class ModuleInfo is defined in std.moduleinfo.	 * The first member is the name of it, char name[],	 * which will be at offset 8.	 */	si = toSymbol();#if 1	// Use this instead so -fPIC will work	efilename = el_ptr(si);	efilename = el_bin(OPadd, TYnptr, efilename, el_long(TYuint, 8));	efilename = el_una(OPind, TYdarray, efilename);#else	efilename = el_var(si);	efilename->Ety = TYdarray;	efilename->EV.sp.Voffset += 8;#endif    }    else // generate our own filename    {	efilename = toEfilename();    }    return efilename;}

static voidview_ast(BaseAST* ast, bool number = false, int mark = -1, int indent = 0) {  if (!ast)    return;  if (Expr* expr = toExpr(ast)) {    printf("/n");    for (int i = 0; i < indent; i++)      printf(" ");    printf("(");    if (ast->id == mark)      printf("***");    if (number)      printf("%d ", ast->id);    printf("%s", expr->astTagAsString());    if (isBlockStmt(expr))      if (FnSymbol* fn = toFnSymbol(expr->parentSymbol))        if (expr == fn->where)          printf(" where");    if (GotoStmt *gs= toGotoStmt(ast)) {      printf( " ");      view_ast(gs->label, number, mark, indent+1);    }    if (CallExpr* call = toCallExpr(expr))      if (call->primitive)        printf(" %s", call->primitive->name);    if (NamedExpr* named = toNamedExpr(expr))      printf(" /"%s/"", named->name);    if (toDefExpr(expr))      printf(" ");    int64_t i;    const char *str;    if (get_int(expr, &i)) {      printf(" %" PRId64, i);    } else if (get_string(expr, &str)) {      printf(" /"%s/"", str);    }    if (SymExpr* sym = toSymExpr(expr)) {      printf(" ");      view_sym(sym->var, number, mark);    } else if (UnresolvedSymExpr* sym = toUnresolvedSymExpr(expr)) {      printf(" '%s'", sym->unresolved);    }  }  if (Symbol* sym = toSymbol(ast)) {    view_sym(sym, number, mark);  }  AST_CHILDREN_CALL(ast, view_ast, number, mark, indent+2);  if (toExpr(ast))    printf(")");}

Symbol *FuncDeclaration::toThunkSymbol(int offset){    toSymbol(this);    Symbol *sthunk = symbol_generate(SCstatic, csym->Stype);    sthunk->Sflags |= SFLimplem;    cod3_thunk(sthunk, csym, 0, TYnptr, -offset, -1, 0);    return sthunk;}

Symbol *toSymbol(Type *t){    if (t->ty == Tclass)    {        return toSymbol(((TypeClass *)t)->sym);    }    assert(0);    return NULL;}

Symbol *toThunkSymbol(FuncDeclaration *fd, int offset){    toSymbol(fd);    Symbol *sthunk = symbol_generate(SCstatic, fd->csym->Stype);    sthunk->Sflags |= SFLimplem;    cod3_thunk(sthunk, fd->csym, 0, TYnptr, -offset, -1, 0);    return sthunk;}

    void visit(TypeInfoAssociativeArrayDeclaration *d)    {        //printf("TypeInfoAssociativeArrayDeclaration::toDt()/n");        verifyStructSize(Type::typeinfoassociativearray, 4 * Target::ptrsize);        dtxoff(pdt, Type::typeinfoassociativearray->toVtblSymbol(), 0); // vtbl for TypeInfo_AssociativeArray        dtsize_t(pdt, 0);                        // monitor        assert(d->tinfo->ty == Taarray);        TypeAArray *tc = (TypeAArray *)d->tinfo;        tc->next->genTypeInfo(NULL);        dtxoff(pdt, toSymbol(tc->next->vtinfo), 0); // TypeInfo for array of type        tc->index->genTypeInfo(NULL);        dtxoff(pdt, toSymbol(tc->index->vtinfo), 0); // TypeInfo for array of type    }

Symbol *Dsymbol::toImport(){    if (!isym)    {	if (!csym)	    csym = toSymbol();	isym = toImport(csym);    }    return isym;}

void list_view_noline(BaseAST* ast) {  if (ast==NULL) {    printf("<NULL>");  } else {    if (toSymbol(ast))      printf("%-7d ", ast->id);    list_ast(ast);  }  fflush(stdout);}

symbol *callFuncsAndGates(Module *m, symbols *sctors, StaticDtorDeclarations *ectorgates,        const char *id){    symbol *sctor = NULL;    if ((sctors && sctors->dim) ||        (ectorgates && ectorgates->dim))    {        static type *t;        if (!t)        {            /* t will be the type of the functions generated:             *      extern (C) void func();             */            t = type_function(TYnfunc, NULL, 0, false, tsvoid);            t->Tmangle = mTYman_c;        }        localgot = NULL;        sctor = toSymbolX(m, id, SCglobal, t, "FZv");        cstate.CSpsymtab = &sctor->Sfunc->Flocsym;        elem *ector = NULL;        if (ectorgates)        {            for (size_t i = 0; i < ectorgates->dim; i++)            {   StaticDtorDeclaration *f = (*ectorgates)[i];                Symbol *s = toSymbol(f->vgate);                elem *e = el_var(s);                e = el_bin(OPaddass, TYint, e, el_long(TYint, 1));                ector = el_combine(ector, e);            }        }        if (sctors)        {            for (size_t i = 0; i < sctors->dim; i++)            {   symbol *s = (*sctors)[i];                elem *e = el_una(OPucall, TYvoid, el_var(s));                ector = el_combine(ector, e);            }        }        block *b = block_calloc();        b->BC = BCret;        b->Belem = ector;        sctor->Sfunc->Fstartline.Sfilename = m->arg;        sctor->Sfunc->Fstartblock = b;        writefunc(sctor);    }    return sctor;}

void localizeGlobals() {  if (fNoGlobalConstOpt) return;  forv_Vec(FnSymbol, fn, gFnSymbols) {    Map<Symbol*,VarSymbol*> globals;    std::vector<BaseAST*> asts;    collect_asts(fn->body, asts);    for_vector(BaseAST, ast, asts) {      if (SymExpr* se = toSymExpr(ast)) {        Symbol* var = se->symbol();        ModuleSymbol* parentmod = toModuleSymbol(var->defPoint->parentSymbol);        CallExpr* parentExpr = toCallExpr(se->parentExpr);        bool inAddrOf = parentExpr && parentExpr->isPrimitive(PRIM_ADDR_OF);        bool lhsOfMove = parentExpr && isMoveOrAssign(parentExpr) && (parentExpr->get(1) == se);        // Is var a global constant?        // Don't replace the var name in its init function since that's        //      where we're setting the value. Similarly, dont replace them        //      inside initStringLiterals        // If the parentSymbol is the rootModule, the var is 'void,'        //      'false,' '0,' ...        // Also don't replace it when it's in an addr of primitive.        if (parentmod &&            fn != parentmod->initFn &&            fn != initStringLiterals &&            !inAddrOf &&            !lhsOfMove &&            var->hasFlag(FLAG_CONST) &&            var->defPoint->parentSymbol != rootModule) {          VarSymbol* local_global = globals.get(var);          SET_LINENO(se); // Set the se line number for output          if (!local_global) {            const char * newname = astr("local_", var->cname);            local_global = newTemp(newname, var->type);            fn->insertAtHead(new CallExpr(PRIM_MOVE, local_global, var));            fn->insertAtHead(new DefExpr(local_global));            // Copy string immediates to localized strings so that            // we can show the string value in comments next to uses.            if (!llvmCodegen)              if (VarSymbol* localVarSym = toVarSymbol(var))                if (Immediate* immediate = localVarSym->immediate)                  if (immediate->const_kind == CONST_KIND_STRING)                    local_global->immediate =                      new Immediate(immediate->v_string, immediate->string_kind);            globals.put(var, local_global);          }          se->replace(new SymExpr(toSymbol(local_global)));        }      }    }  }

//// Print routines for debugging and development//voidprintNode(BaseAST* ast) {  Symbol* sym = toSymbol(ast);  WideInfo* wi = wideInfoMap.get(sym);  printf("%s[%d]/n", sym->cname, sym->id);  printf("%s/n", (wi->mustBeWide) ? "WIDE" : "NARROW");  printf("IN: ");  forv_Vec(Symbol, inSym, wi->inVec)    printf("%d ", inSym->id);  printf("/n");  printf("OUT: ");  forv_Vec(Symbol, outSym, wi->outVec)    printf("%d ", outSym->id);  printf("/n");}

voidviewFlags(BaseAST* ast) {  if (!viewFlagsShort && !viewFlagsName && !viewFlagsComment)    viewFlagsName = true;  if (Symbol* sym = toSymbol(ast)) {    for (int flagNum = FLAG_FIRST; flagNum <= FLAG_LAST; flagNum++) {      if (sym->flags[flagNum]) {        if (viewFlagsName)          printf("%s ", flagNames[flagNum]);        if (viewFlagsPragma)          printf("%s", flagPragma[flagNum] ? "ypr " : "npr ");        if (viewFlagsShort)          printf("/"%s/" ", flagShortNames[flagNum]);        if (viewFlagsComment)          printf("// %s",                 *flagComments[flagNum] ? flagComments[flagNum] : "ncm");        printf("/n");      }    }    if (viewFlagsExtras) {      if (VarSymbol* vs = toVarSymbol(sym)) {        if (vs->immediate) {          printf("immediate ");          fprint_imm(stdout, *toVarSymbol(sym)->immediate, true);          printf("/n");        }      } else if (ArgSymbol* as = toArgSymbol(sym)) {        printf("%s arg/n", as->intentDescrString());      } else if (toTypeSymbol(sym)) {        printf("a TypeSymbol/n");      } else if (FnSymbol* fs = toFnSymbol(sym)) {        printf("fn %s(%d args) %s/n",               fs->_this ? intentDescrString(fs->thisTag) : "",               fs->numFormals(), retTagDescrString(fs->retTag));      } else if (toEnumSymbol(sym)) {        printf("an EnumSymbol/n");      } else if (ModuleSymbol* ms = toModuleSymbol(sym)) {        printf("module %s/n", modTagDescrString(ms->modTag));      } else if (toLabelSymbol(sym)) {        printf("a LabelSymbol/n");      } else {        printf("unknown symbol kind/n");      }    }  } else {    printf("[%d]: not a Symbol, has no flags/n", ast->id);  }}

UseStmt::UseStmt(BaseAST* source) : Stmt(E_UseStmt) {  src    = NULL;  except = false;  if (Symbol* b = toSymbol(source)) {    src = new SymExpr(b);  } else if (Expr* b = toExpr(source)) {    src = b;  } else {    INT_FATAL(this, "Bad mod in UseStmt constructor");  }  gUseStmts.add(this);}

static Symbol* symflagOK(const char* msg, BaseAST* ast, int flag) {  Symbol* sym = toSymbol(ast);  if (!sym) {    printf("%s: [%d] is a %s (does not support Flags)/n", msg, ast->id,           ast->astTagAsString());    return NULL;  } else if (flag <= 0) {    printf("%s: flag is non-positive: %d/n", msg, flag);    return NULL;  } else if (flag >= NUM_FLAGS) {    printf("%s: flag is too big (NUM_FLAGS is %d): %d/n", msg, NUM_FLAGS, flag);    return NULL;  } else {    printf("%s(%s=%d)/n", msg, flagNames[flag], flag);    return sym;  }}

void TypeInfoDeclaration::toObjFile(int multiobj){    Symbol *s;    unsigned sz;    Dsymbol *parent;    //printf("TypeInfoDeclaration::toObjFile(%p '%s') protection %d/n", this, toChars(), protection);    if (multiobj)    {        obj_append(this);        return;    }    s = toSymbol();    sz = type->size();    parent = this->toParent();    s->Sclass = SCcomdat;    s->Sfl = FLdata;    toDt(&s->Sdt);    dt_optimize(s->Sdt);    // See if we can convert a comdat to a comdef,    // which saves on exe file space.    if (s->Sclass == SCcomdat &&        s->Sdt->dt == DT_azeros &&        s->Sdt->DTnext == NULL)    {        s->Sclass = SCglobal;        s->Sdt->dt = DT_common;    }#if ELFOBJ || MACHOBJ // Burton    if (s->Sdt && s->Sdt->dt == DT_azeros && s->Sdt->DTnext == NULL)        s->Sseg = UDATA;    else        s->Sseg = DATA;#endif    outdata(s);    if (isExport())        obj_export(s,0);}