static long ParseTagData( char * buffer, TagPtr * tag ) { long length; TagPtr tmpTag; length = FixDataMatchingTag(buffer, kXMLTagData); if (length == -1) return -1; tmpTag = NewTag(); if (tmpTag == 0) return -1; //printf("ParseTagData unimplimented\n"); //printf("Data: %s\n", buffer); // getchar(); // TODO: base64 decode char* string = NewSymbol(buffer); tmpTag->type = kTagTypeData; tmpTag->string = string; tmpTag->tag = 0; tmpTag->offset = buffer_start ? buffer - buffer_start: 0; tmpTag->tagNext = 0; *tag = tmpTag; return length; }
//----------------------------------------------------------------------------- // NewSymbolVar - Add new var to current context. //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- static Var *NewSymbolVar(Context *co, char *Name) { Symbol *s; Var *v; // static int ID = 0; CodeOutput(VERBOSE_L, "// NewSymbolVar Name: %s\n", Name); s = NewSymbol(co); s->Name = CreateName(Name); s->Type = S_VAR; v = malloc(sizeof(Var)); assert(v != NULL); s->details = v; // p->ID = ID++; v->Type = 0; // undetermined type v->ArraySize = 0; // not an array, -1 = undetermined size. v->CallMethod = 0; // 0 = not a param, 'v' = value, 'r' = reference, 'c' = code v->put = NULL; v->get = NULL; v->data = NULL; v->size = 1; // size in bytes, bit values are rounded up. v->p1 = 0; v->p2 = 0; return v; }
EFI_STATUS ParseTagData(CHAR8* buffer, TagPtr * tag,UINT32* lenPtr) { EFI_STATUS Status; UINT32 length; TagPtr tmpTag; Status = FixDataMatchingTag(buffer, kXMLTagData,&length); if (EFI_ERROR(Status)) return Status; tmpTag = NewTag(); if (tmpTag == 0) return EFI_UNSUPPORTED; //Slice - correction as Apple 2003 CHAR8* string = NewSymbol(buffer); tmpTag->type = kTagTypeData; tmpTag->string = string; tmpTag->tag = NULL; tmpTag->offset = buffer_start ? buffer - buffer_start: 0; tmpTag->tagNext = NULL; *tag = tmpTag; *lenPtr=length; return EFI_SUCCESS; }
static long ParseTagInteger(char *buffer, TagPtr *tag) { long length; char *intString; TagPtr tmpTag; length = FixDataMatchingTag(buffer, kXMLTagInteger); if (length == -1) return -1; tmpTag = NewTag(); if (tmpTag == 0) return -1; intString = NewSymbol(buffer); if (intString == 0) { FreeTag(tmpTag); return -1; } tmpTag->type = kTagTypeInteger; tmpTag->string = intString; tmpTag->tag = 0; tmpTag->tagNext = 0; *tag = tmpTag; return length; }
EFI_STATUS ParseTagString(CHAR8* buffer, TagPtr * tag,UINT32* lenPtr) { EFI_STATUS Status; UINT32 length; CHAR8* string; TagPtr tmpTag; Status = FixDataMatchingTag(buffer, kXMLTagString,&length); if (EFI_ERROR(Status)) return Status; tmpTag = NewTag(); if (tmpTag == NULL) return EFI_UNSUPPORTED; string = NewSymbol(buffer); if (string == NULL) { FreeTag(tmpTag); return EFI_UNSUPPORTED; } tmpTag->type = kTagTypeString; tmpTag->string = string; tmpTag->tag = NULL; tmpTag->tagNext = NULL; tmpTag->offset = buffer_start ? buffer - buffer_start: 0; *tag = tmpTag; *lenPtr=length; return EFI_SUCCESS; }
static long ParseTagString( char * buffer, TagPtr * tag ) { long length; char * string; length = FixDataMatchingTag(buffer, kXMLTagString); if (length == -1) return -1; TagPtr tmpTag = NewTag(); if (tmpTag == 0) return -1; string = NewSymbol(buffer); if (string == 0) { XMLFreeTag(tmpTag); return -1; } tmpTag->type = kTagTypeString; tmpTag->string = string; tmpTag->tag = 0; tmpTag->offset = buffer_start ? buffer - buffer_start: 0; tmpTag->tagNext = 0; *tag = tmpTag; return length; }
//----------------------------------------------------------------------------- // NewSymbolAlias - add an ALIAS record to symbol table //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- Symbol *NewSymbolAlias(Context *co, char *AliasName, char *AliasTarget) { Symbol *s; SymbolFunction *f; Symbol *Target; // make sure alias name does not exists s = GetSymbolPointer(co, AliasName, S_ALL, 1); if (s != NULL) { printf("warning adding alias '%s' - Symbol already exists\n", AliasName); CodeOutput(VERBOSE_ALL, "// waring adding alias '%s' - Symbol already exists\n", AliasName); // ErrorCount++; // return NULL; } // find alias target Target = GetSymbolPointer(co, AliasTarget, S_ALL, 1); if (Target == NULL) { printf("Error adding alias '%s' - Target '%s' does not exist\n", AliasName, AliasTarget); CodeOutput(VERBOSE_ALL, "// Error adding alias '%s' - Target '%s' does not exist\n", AliasName, AliasTarget); ErrorCount++; return NULL; } // add alias s = NewSymbol(co); s->Name = CreateName(AliasName); s->Type = S_ALIAS; s->details = Target; // details points to symbol record. return s; }
TPpContext::Symbol* TPpContext::AddSymbol(int atom) { Symbol *lSymb; lSymb = NewSymbol(atom); symbols[lSymb->atom] = lSymb; return lSymb; }
Symbol *AddSymbol( CgContext *cg, SourceLoc *loc, Scope *fScope, Atom atom, Type *fType, SymbolKind kind) { Symbol *lSymb; if (!fScope) fScope = cg->currentScope; lSymb = NewSymbol( cg, loc, fScope, atom, fType, kind); lAddToTree( cg, &fScope->symbols, lSymb, fType); return lSymb; } // AddSymbol
Symbol *AddSymbol(SourceLoc *loc, Scope *fScope, int atom, symbolkind kind) { Symbol *lSymb; if (!fScope) fScope = CurrentScope; lSymb = NewSymbol(loc, fScope, atom, kind); lAddToTree(&fScope->symbols, lSymb); return lSymb; } // AddSymbol
//-------------------------------------------------------------------------- // Name SymTab_Init // // //-------------------------------------------------------------------------- void SymTab_Init ( void ) { StructDefHeap_Init(); SymbolHeap_Init(); ScopeHeap_Init(); MainScope = NewScope( FILE_SCOPE, NULL ); CurScope = MainScope; EllipsisSym = NewSymbol( NULL ); };
Symbol *AddTag(SourceLoc *loc, Scope *fScope, int atom, int category) { Symbol *lSymb; Type *pType; if (!fScope) fScope = CurrentScope; pType = NewType(category, 0); pType->str.unqualifiedtype = pType; lSymb = NewSymbol(loc, fScope, atom, pType, TAG_S); lAddToTree(&fScope->tags, lSymb, pType); return lSymb; } // AddTag
Symbol *AddTag( CgContext *cg, SourceLoc *loc, Scope *fScope, Atom atom, TypeCategory category) { Symbol *lSymb; Type *pType; if (!fScope) fScope = cg->currentScope; pType = NewType( cg,atom, TB_NoType, category, TD_Unknown, TQ_None, false, 0, 0); static_cast< TypeStruct * >( pType )->unqualifiedtype = pType; lSymb = NewSymbol( cg, loc, fScope, atom, pType, SK_Tag); lAddToTree( cg, &fScope->tags, lSymb, pType); return lSymb; } // AddTag
MCAHead translate_DecList(Node *n, SymbolTable table, MCA mca) { assert(n->nodetype == DecList); Var v1 = NULL, v2 = NULL, v3 = NULL; Node* declist = n; Node *dec = NULL; char *decid; MCAHead h = NULL; MCAHead h1 = NULL, h2 = NULL, h3 = NULL; Symbol symbol; while(1) { dec = NT_getChild(declist, 0); decid = getVarId(NT_getChild(dec, 0)); symbol = LookUpSymbol(sts, NewSymbol(decid, NULL, -1)); switch(symbol->type->tn) { case ARRAY: v1 = NewVar(VAR); v1->name = decid; v2 = NewVar(SIZE); v2->value = symbol->type->width; h1 = NewMCAHead(mca, NewMidCode(C_DEC, v1, v2, NULL)); break; case STRUCTURE: printf("%s", "Cannot translate: Code contains variables or parameters of structure type\n."); exit(0); break; case BASIC: break; } if(dec->seq == 1) { v1 = NewVar(VAR); v1->name = decid; v2 = NewVar(PLACE); v2->ttype = TEMP; h2 = translate_Exp(NT_getChild(dec, 2), table, v2, mca); h3 = NewMCAHead(mca, NewMidCode(C_ASSIGN, v1, v2, NULL)); } h = LinkMulMCAHead(mca, 4, h, h1, h2, h3); if(declist->seq == 0) break; declist = NT_getChild(declist, 2); } return h; }
static void DefineSymbol (const char* Def) /* Define a symbol from the command line */ { const char* P; long Val; StrBuf SymName = AUTO_STRBUF_INITIALIZER; /* The symbol must start with a character or underline */ if (!IsIdStart (Def [0])) { InvDef (Def); } P = Def; /* Copy the symbol, checking the rest */ while (IsIdChar (*P)) { SB_AppendChar (&SymName, *P++); } SB_Terminate (&SymName); /* Do we have a value given? */ if (*P != '=') { if (*P != '\0') { InvDef (Def); } Val = 0; } else { /* We have a value */ ++P; if (*P == '$') { ++P; if (sscanf (P, "%lx", &Val) != 1) { InvDef (Def); } } else { if (sscanf (P, "%li", &Val) != 1) { InvDef (Def); } } } /* Define the new symbol */ NewSymbol (SB_GetConstBuf (&SymName), Val); /* Release string memory */ SB_Done (&SymName); }
FRAGMENT(GCCellPtr, simple) { JS::GCCellPtr nulll(nullptr); JS::Rooted<JSObject*> glob(cx, JS::CurrentGlobalOrNull(cx)); JS::Rooted<JSString*> empty(cx, JS_NewStringCopyN(cx, nullptr, 0)); JS::Rooted<Symbol*> unique(cx, NewSymbol(cx, nullptr)); JS::GCCellPtr object(glob.get()); JS::GCCellPtr string(empty.get()); JS::GCCellPtr symbol(unique.get()); breakpoint(); (void) nulll; (void) object; (void) string; (void) symbol; }
EFI_STATUS ParseTagKey( char * buffer, TagPtr * tag,UINT32* lenPtr) { EFI_STATUS Status; UINT32 length; UINT32 length2; CHAR8* string; TagPtr tmpTag; TagPtr subTag; Status = FixDataMatchingTag(buffer, kXMLTagKey,&length); if (EFI_ERROR(Status)) return Status; Status = XMLParseNextTag(buffer + length, &subTag,&length2); if (EFI_ERROR(Status)) return Status; tmpTag = NewTag(); if (tmpTag == NULL) { FreeTag(subTag); return EFI_UNSUPPORTED; } string = NewSymbol(buffer); if (string == NULL) { FreeTag(subTag); FreeTag(tmpTag); return EFI_UNSUPPORTED; } tmpTag->type = kTagTypeKey; tmpTag->string = string; tmpTag->tag = subTag; tmpTag->offset = buffer_start ? buffer - buffer_start: 0; tmpTag->tagNext = 0; *tag = tmpTag; *lenPtr=length + length2; return EFI_SUCCESS; }
//----------------------------------------------------------------------------- // NewSymbolFunction - add function record to symbol table //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- Symbol *NewSymbolFunction(Context *co) { Symbol *s; SymbolFunction *f; s = NewSymbol(co); s->Name = NULL; //CreateName(Name); s->Type = S_FUNCTION; f = malloc(sizeof(SymbolFunction)); assert(f != NULL); s->details = f; f->ReturnType = L_VOID; // f->NrOfParams = 0; f->Param = NULL; return s; }
bool XMLAddTagToDictionary(TagPtr dict, char* key, TagPtr value) { if (!dict || dict->type != kTagTypeDict) return false; TagPtr tmpTag; char* string; tmpTag = NewTag(); if (tmpTag == 0) { return false; } string = NewSymbol(key); if (string == 0) { XMLFreeTag(tmpTag); return false; } tmpTag->type = kTagTypeKey; tmpTag->string = string; tmpTag->tag = value; tmpTag->offset = 0; tmpTag->tagNext = 0; TagPtr tagList = dict->tag; if(!tagList) { // First tag dict->tag = tmpTag; return true; } while(tagList && tagList->tagNext) tagList = tagList->tagNext; if(tagList) { tagList->tagNext = tmpTag; return true; } XMLFreeTag(tmpTag); return false; }
static long ParseTagKey(char *buffer, TagPtr * tag) { long length = FixDataMatchingTag(buffer, kXMLTagKey); if (length == -1) { return -1; } TagPtr subTag; long length2 = XMLParseNextTag(buffer + length, &subTag); if (length2 == -1) { return -1; } TagPtr tmpTag = NewTag(); if (tmpTag == 0) { XMLFreeTag(subTag); return -1; } char *string = NewSymbol(buffer); if (string == 0) { XMLFreeTag(subTag); XMLFreeTag(tmpTag); return -1; } tmpTag->type = kTagTypeKey; tmpTag->string = string; tmpTag->tag = subTag; tmpTag->tagNext = 0; *tag = tmpTag; return length + length2; }
static long ParseTagKey(char *buffer, TagPtr *tag) { long length, length2; char *string; TagPtr tmpTag, subTag = (TagPtr)-1; // eliminate possible stale tag length = FixDataMatchingTag(buffer, kXMLTagKey); if (length == -1) return -1; length2 = ParseNextTag(buffer + length, &subTag); if (length2 == -1) return -1; // XXXX revisit 4063982 if FreeTag becomes real if(subTag == (TagPtr)-1) subTag = NULL; tmpTag = NewTag(); if (tmpTag == 0) { FreeTag(subTag); return -1; } string = NewSymbol(buffer); if (string == 0) { FreeTag(subTag); FreeTag(tmpTag); return -1; } tmpTag->type = kTagTypeKey; tmpTag->string = string; tmpTag->tag = subTag; tmpTag->tagNext = 0; *tag = tmpTag; return length + length2; }
MCAHead translate_FunDec(Node *n, SymbolTable table, MCA mca) { assert(n->nodetype == FunDec); Var v1, v2, v3; Node* varlist = NT_getChild(n, 2); char *varid; Node *funcdecid; MCAHead h = NULL; MCAHead h1, h2, h3; funcdecid = NT_getChild(n, 0); v1 = NewVar(VAR); v1->name = funcdecid->data.s; h = NewMCAHead(mca, NewMidCode(C_FUNC, v1, NULL, NULL)); if(n->seq == 0) { while(1) { varid = getVarId(NT_getChild(NT_getChild(varlist, 0), 1)); Symbol s = LookUpSymbol(sts, NewSymbol(varid, NULL, -1)); if(s->type->tn == STRUCTURE) { printf("%s", "Cannot translate: Code contains variables or parameters of structure type.\n"); exit(0); } v1 = NewVar(VAR); v1->name = varid; h1 = NewMCAHead(mca, NewMidCode(C_PARAM, v1, NULL, NULL)); h = LinkMulMCAHead(mca, 2, h, h1); if(varlist->seq == 1) break; varlist = NT_getChild(varlist, 2); } } return h; }
static void SetSys (const char* Sys) /* Define a target system */ { switch (Target = FindTarget (Sys)) { case TGT_NONE: break; case TGT_MODULE: AbEnd ("Cannot use `module' as a target for the assembler"); break; case TGT_ATARI: NewSymbol ("__ATARI__", 1); break; case TGT_ATARIXL: NewSymbol ("__ATARI__", 1); NewSymbol ("__ATARIXL__", 1); break; case TGT_C16: CBMSystem ("__C16__"); break; case TGT_C64: CBMSystem ("__C64__"); break; case TGT_VIC20: CBMSystem ("__VIC20__"); break; case TGT_C128: CBMSystem ("__C128__"); break; case TGT_PLUS4: CBMSystem ("__C16__"); NewSymbol ("__PLUS4__", 1); break; case TGT_CBM510: CBMSystem ("__CBM510__"); break; case TGT_CBM610: CBMSystem ("__CBM610__"); break; case TGT_PET: CBMSystem ("__PET__"); break; case TGT_BBC: NewSymbol ("__BBC__", 1); break; case TGT_APPLE2: NewSymbol ("__APPLE2__", 1); break; case TGT_APPLE2ENH: NewSymbol ("__APPLE2__", 1); NewSymbol ("__APPLE2ENH__", 1); break; case TGT_GEOS_CBM: /* Do not handle as a CBM system */ NewSymbol ("__GEOS__", 1); NewSymbol ("__GEOS_CBM__", 1); break; case TGT_GEOS_APPLE: NewSymbol ("__GEOS__", 1); NewSymbol ("__GEOS_APPLE__", 1); break; case TGT_LUNIX: NewSymbol ("__LUNIX__", 1); break; case TGT_ATMOS: NewSymbol ("__ATMOS__", 1); break; case TGT_NES: NewSymbol ("__NES__", 1); break; case TGT_SUPERVISION: NewSymbol ("__SUPERVISION__", 1); break; case TGT_SNES: NewSymbol ("__SNES__", 1); break; case TGT_LYNX: NewSymbol ("__LYNX__", 1); break; case TGT_SIM6502: NewSymbol ("__SIM6502__", 1); break; case TGT_SIM65C02: NewSymbol ("__SIM65C02__", 1); break; default: AbEnd ("Invalid target name: `%s'", Sys); } /* Initialize the translation tables for the target system */ TgtTranslateInit (); }
static void CBMSystem (const char* Sys) /* Define a CBM system */ { NewSymbol ("__CBM__", 1); NewSymbol (Sys, 1); }
// Initialize internal variables of the compiler void initialize() { int i; ArmVersion=400; // default ARM version // variables for predefined types halfword_t IntegerTypeNode; halfword_t BooleanTypeNode; halfword_t RealTypeNode; halfword_t PointerTypeNode; // initialization of variables for (i=0;i<NB_FILES;i++) Files[i].f=NULL; iStackPtr=0; // declare that no input file is open HiPoolMin=POOL_SIZE; LoPoolMax=0; InitMem(); // memory initialization InitStrings(); InitHTable(); InitCode(); InitParse(); // read the time start_time=clock(); // initialize initial stack value initial_stack_value=get_stack_value(); // Predefined identifier initialisation NewSymbol("write",sWRITE,0); NewSymbol("writeln",sWRITE,1); NewSymbol("sizeof",sSIZEOF,0); NewConst("true",TBOOLEAN,1); NewConst("false",TBOOLEAN,0); NewConst("maxint",TINTEGER,0x7fffffff); // predefined types IntegerTypeNode=NewType("integer",TINTEGER); BooleanTypeNode=NewType("boolean",TBOOLEAN); RealTypeNode=NewType("real",TREAL); CharTypeNode=NewType("char",TCHAR); PointerTypeNode=NewType("pointer",TPOINTER); NewType("text",TTEXT); NewSymbol("ord", sORDF,0); NewSymbol("pred", sORDF,1); NewSymbol("succ", sORDF,2); NewSymbol("abs",sNUMF,0); NewSymbol("sqr",sNUMF,1); NewSymbol("chr",sCHR,0); NewSymbol("new",sNEW,0); NewSymbol("dispose",sNEW,1); // predefined inlines functions NewInline1("odd",IntegerTypeNode,BooleanTypeNode,-1,1,0xe2100001); NewInline1("sqrt",RealTypeNode,RealTypeNode,-2,2,0xE1A0E00F, // MOV lr,pc 0xE599F000+REALSQRT); NewInline1("round",RealTypeNode,IntegerTypeNode,-4,2,0xE1A0E00F,0xE599F000+REALROUND); NewInline1("trunc",RealTypeNode,IntegerTypeNode,-4,2,0xE1A0E00F,0xE599F000+REALTRUNC); NewInline1("ln",RealTypeNode,RealTypeNode,-4,2,0xE1A0E00F,0xE599F000+REALLN); NewInline1("exp",RealTypeNode,RealTypeNode,-4,2,0xE1A0E00F,0xE599F000+REALEXP); NewInline1("sin",RealTypeNode,RealTypeNode,-4,2,0xE1A0E00F,0xE599F000+REALSIN); NewInline1("cos",RealTypeNode,RealTypeNode,-4,2,0xE1A0E00F,0xE599F000+REALCOS); NewInline1("arctan",RealTypeNode,RealTypeNode,-4,2,0xE1A0E00F,0xE599F000+REALATAN); NewFunc1("halt",IntegerTypeNode,NADA,HALT); NewInlineProc("clrscr",-10,2,0xE1A0E00F,0xE599F000+CLRSCR); InputVar=NewVar("input", TTEXT, -36); OutputVar=NewVar("output", TTEXT, -24); NewSymbol("rewrite",sOPEN,1); NewSymbol("reset",sOPEN,0); NewSymbol("close",sFILEP,CLOSE); NewSymbol("get",sFILEP,GET); NewSymbol("put",sFILEP,PUT); // crt functions NewInline1("wherex",NADA,IntegerTypeNode,-4,2,0xE1A0E00F,0xE599F000+WHEREX); NewInline1("wherey",NADA,IntegerTypeNode,-4,2,0xE1A0E00F,0xE599F000+WHEREY); NewInline1("screenwidth",NADA,IntegerTypeNode,-4,2,0xE1A0E00F,0xE599F000+SCREENWIDTH); NewInline1("screenheight",NADA,IntegerTypeNode,-4,2,0xE1A0E00F,0xE599F000+SCREENHEIGHT); NewInline2("gotoxy",IntegerTypeNode, IntegerTypeNode, -4,2,0xE1A0E00F,0xE599F000+GOTOXY); NewSymbol("read",sREAD,0); NewSymbol("readln",sREAD,1); NewSymbol("eof",sEOF,0); NewSymbol("eoln",sEOF,1); NewFunc1("length",StringTypeNode,IntegerTypeNode,LENGTH); }
VMSymbol* Universe::SymbolFor(const StdString& str) { map<string,GCSymbol*>::iterator it = symbolsMap.find(str); return (it == symbolsMap.end()) ? NewSymbol(str) : load_ptr(it->second); }
MCAHead translate_Exp(Node *n, SymbolTable table, Var place, MCA mca) { assert(n->nodetype == Exp); Var v1, v2, v3, v4, v5; Node* child = n->children->head->next; Symbol symbol; MCAHead h; MCAHead h1, h2, h3, h4, h5; char *temp; Var vlist[12]; int vlistlen = 0; int t; switch(n->seq) { case 0: //ASSIGNOP v1 = NewVar(PLACE); v1->ttype = TEMP; h1 = translate_Exp(child, table, v1, mca); v2 = NewVar(PLACE); v2->ttype = TEMP; h2 = translate_Exp(child->next->next, table, v2, mca); h3 = NewMCAHead(mca, NewMidCode(C_ASSIGN, v1, v2, NULL)); h4 = genPlaceMidCode(mca, C_ASSIGN, place, v3, NULL); h = LinkMulMCAHead(mca, 4, h1, h2, h3, h4); break; case 1: case 2: case 3: case 10: //AND OR NOT RELOP v3 = NewVar(CON); v3->value = 0; h1 = genPlaceMidCode(mca, C_ASSIGN, place, v3, NULL); v1 = NewVar(PLACE); v1->ttype = LABEL; v2 = NewVar(PLACE); v2->ttype = LABEL; h2 = translate_Cond(n, v1, v2, table, mca); v3 = NewVar(CON); v3->value = 1; h = LinkMulMCAHead(mca, 5, h1, h2, NewMCAHead(mca, NewMidCode(C_LAB, v1, NULL, NULL)), genPlaceMidCode(mca, C_ASSIGN, place, v3, NULL), NewMCAHead(mca, NewMidCode(C_LAB, v2, NULL, NULL))); break; case 4: //PLUS v2 = NewVar(PLACE); v2->ttype = TEMP; h1 = translate_Exp(child, table, v2, mca); v3 = NewVar(PLACE); v3->ttype = TEMP; h2 = translate_Exp(child->next->next, table, v3, mca); h3 = genPlaceMidCode(mca, C_ADD, place, v2, v3); h = LinkMulMCAHead(mca, 3, h1, h2, h3); break; case 5: //MINUS v2 = NewVar(PLACE); v2->ttype = TEMP; h1 = translate_Exp(child, table, v2, mca); v3 = NewVar(PLACE); v3->ttype = TEMP; h2 = translate_Exp(child->next->next, table, v3, mca); h3 = genPlaceMidCode(mca, C_SUB, place, v2, v3); h = LinkMulMCAHead(mca, 3, h1, h2, h3); break; case 6: //STAR v2 = NewVar(PLACE); v2->ttype = TEMP; h1 = translate_Exp(child, table, v2, mca); v3 = NewVar(PLACE); v3->ttype = TEMP; h2 = translate_Exp(child->next->next, table, v3, mca); h3 = genPlaceMidCode(mca, C_MUL, place, v2, v3); h = LinkMulMCAHead(mca, 3, h1, h2, h3); break; case 7: //DIV v2 = NewVar(PLACE); v2->ttype = TEMP; h1 = translate_Exp(child, table, v2, mca); v3 = NewVar(PLACE); v3->ttype = TEMP; h2 = translate_Exp(child->next->next, table, v3, mca); h3 = genPlaceMidCode(mca, C_DIV, place, v2, v3); h = LinkMulMCAHead(mca, 3, h1, h2, h3); break; case 8: //LPRP h = translate_Exp(child->next, table, place, mca); break; case 9: //MINUS v1 = NewVar(PLACE); v1->ttype = TEMP; h1 = translate_Exp(child->next, table, v1, mca); v2 = NewVar(CON); v2->value = 0; h2 = genPlaceMidCode(mca, C_SUB, place, v2, v1); h = LinkMulMCAHead(mca, 2, h1, h2); break; case 11: //CALL v1 = NewVar(VAR); v1->name = NT_getChild(n, 0)->data.s; h1 = translate_Args(NT_getChild(n, 2), table, vlist, &vlistlen, mca); #ifdef debug printf("args\n"); printMCA(mca, h1); printf("args\n"); #endif if(strcmp(v1->name, "write") == 0) { h = LinkMulMCAHead(mca, 2, h1, NewMCAHead(mca, NewMidCode(C_WRITE, vlist[0], NULL, NULL))); } else { for(t = 0; t < vlistlen; t++) h1 = LinkMulMCAHead(mca, 2, h1, NewMCAHead(mca, NewMidCode(C_ARG, vlist[t], NULL, NULL))); h = LinkMulMCAHead(mca, 2, h1, genPlaceMidCode(mca, C_CALL, place, v1, NULL)); } break; case 12: //CALL NO ARG v1 = NewVar(VAR); v1->name = NT_getChild(n, 0)->data.s; if(strcmp(v1->name, "read") == 0) h = genPlaceMidCode(mca, C_READ, place, NULL, NULL); else h = genPlaceMidCode(mca, C_CALL, place, v1, NULL); break; case 13: //ARRAY if(NT_getChild(n, 0)->seq == 15) { temp = NT_getChild(NT_getChild(n, 0), 0)->data.s; symbol = LookUpSymbol(sts, NewSymbol(temp, NULL, -1)); if(n->syn == NULL) n->syn = NewSyn(); n->syn->SType = symbol->type->tv->array->elem; n->syn->symbol = symbol; v1 = NewVar(PLACE); v1->ttype = TEMP; h1 = translate_Exp(NT_getChild(n, 2), table, v1, mca); v2 = NewVar(CON); v2->value = n->syn->SType->width; v3 = NewVar(TEMP); n->syn->addr = v3; h2 = NewMCAHead(mca, NewMidCode(C_MUL, v3, v1, v2)); h = LinkMulMCAHead(mca, 2, h1, h2); } else { if(n->syn == NULL) n->syn = NewSyn(); h1 = translate_Exp(NT_getChild(n, 0), table, NULL, mca); n->syn->SType = NT_getChild(n, 0)->syn->SType->tv->array->elem; n->syn->symbol = NT_getChild(n, 0)->syn->symbol; v1 = NewVar(PLACE); v1->ttype = TEMP; h2 = translate_Exp(NT_getChild(n, 2), table, v1, mca); v2 = NewVar(TEMP); v3 = NewVar(CON); v3->value = n->syn->SType->width; h3 = NewMCAHead(mca, NewMidCode(C_MUL, v2, v1, v3)); v4 = NewVar(TEMP); n->syn->addr = v4; h4 = NewMCAHead(mca, NewMidCode(C_ADD, v4, NT_getChild(n, 0)->syn->addr, v2)); h = LinkMulMCAHead(mca, 4, h1, h2, h3, h4); } if(n->parent->nodetype != Exp || n->parent->seq != 13) { if(n->syn->symbol->type->ispointer) v1 = NewVar(VAR); else v1 = NewVar(GetADDR); v1->name = n->syn->symbol->name; v2 = NewVar(TEMP); h5 = NewMCAHead(mca, NewMidCode(C_ADD, v2, v1, n->syn->addr)); h = LinkMulMCAHead(mca, 2, h, h5); n->syn->addr = v2; changevar(place, n->syn->addr); place->kind = ADDR; char *temp = malloc(5); sprintf(temp, "t%d", place->var_no); place->name = temp; } break; case 14: //STRUCT break; case 15: //ID symbol = LookUpSymbol(sts, NewSymbol(child->data.s, NULL, -1)); switch(symbol->type->tn) { case BASIC: v2 = NewVar(VAR); v2->name = child->data.s; changevar(place, v2); //h = genPlaceMidCode(mca, C_ASSIGN, place, v2, NULL); h = NULL; break; case ARRAY: v2 = NewVar(GetADDR); v2->name = child->data.s; changevar(place, v2); h = NULL; break; case STRUCTURE: printf("%s", "Cannot translate: Code contains variables or parameters of structure type\n."); exit(0); break; } break; case 16: //INT v2 = NewVar(CON); v2->value = child->data.i; changevar(place, v2); // place = v2; //h = genPlaceMidCode(mca, C_ASSIGN, place, v2, NULL); h = NULL; break; case 17: //FLOAT break; } return h; }