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;
}
