struct InterCodes* translate_VarDec(struct TreeNode* VarDec){
if(strcmp(VarDec->children->name, "ID") == 0){
printf("VarDec - ID\n");
FieldList item = (FieldList)malloc(sizeof(struct FieldList_));
lookupTable(VarDec->children->value_str,&item,0);
if(item->type->kind == structure){
struct InterCodes* code1 = (struct InterCodes*)malloc(sizeof(struct InterCodes));
code1->code.kind = DEC_;
code1->code.u.dec.space = (Operand)malloc(sizeof(struct Operand_));
code1->code.u.dec.space->kind = VARIABLE;
strcpy(code1->code.u.dec.space->u.ID, item->inter_name);
code1->code.u.dec.size = dec_size(item->type);
return code1;
}
}
if(strcmp(VarDec->children->name, "RB") == 0){
printf("VarDec - VarDec LB INT RB\n");
FieldList item = (FieldList)malloc(sizeof(struct FieldList_));
lookupTable(VarDec->children->neighbours->neighbours->neighbours->children->value_str,&item,0);
struct InterCodes* code1 = (struct InterCodes*)malloc(sizeof(struct InterCodes));
code1->code.kind = DEC_;
code1->code.u.dec.space = (Operand)malloc(sizeof(struct Operand_));
code1->code.u.dec.space->kind = VARIABLE;
strcpy(code1->code.u.dec.space->u.ID, item->inter_name);
code1->code.u.dec.size = dec_size(item->type);
}
}
static int mdbAddTable(Edi *edi, cchar *tableName)
{
Mdb *mdb;
MdbTable *table;
mprAssert(edi);
mprAssert(tableName && *tableName);
mdb = (Mdb*) edi;
lock(mdb);
if ((table = lookupTable(mdb, tableName)) != 0) {
unlock(mdb);
return MPR_ERR_ALREADY_EXISTS;
}
if ((table = mprAllocObj(MdbTable, manageTable)) == 0) {
unlock(mdb);
return MPR_ERR_MEMORY;
}
if ((table->rows = mprCreateList(0, 0)) == 0) {
unlock(mdb);
return MPR_ERR_MEMORY;
}
table->name = sclone(tableName);
if (mdb->tables == 0) {
mdb->tables = mprCreateList(0, 0);
}
if (!growSchema(table)) {
unlock(mdb);
return MPR_ERR_MEMORY;
}
mprAddItem(mdb->tables, table);
autoSave(mdb, lookupTable(mdb, tableName));
unlock(mdb);
return 0;
}
static int mdbDeleteRow(Edi *edi, cchar *tableName, cchar *key)
{
Mdb *mdb;
MdbTable *table;
int r, rc;
mprAssert(edi);
mprAssert(tableName && *tableName);
mprAssert(key && *key);
mdb = (Mdb*) edi;
lock(mdb);
if ((table = lookupTable(mdb, tableName)) == 0) {
unlock(mdb);
return MPR_ERR_CANT_FIND;
}
if ((r = lookupRow(table, key)) < 0) {
unlock(mdb);
return MPR_ERR_CANT_FIND;
}
rc = mprRemoveItemAtPos(table->rows, r);
if (table->index) {
mprRemoveKey(table->index, key);
}
autoSave(mdb, table);
unlock(mdb);
return rc;
}
static int mdbChangeColumn(Edi *edi, cchar *tableName, cchar *columnName, int type, int flags)
{
Mdb *mdb;
MdbTable *table;
MdbCol *col;
mprAssert(edi);
mprAssert(tableName && *tableName);
mprAssert(columnName && *columnName);
mprAssert(type);
mdb = (Mdb*) edi;
lock(mdb);
if ((table = lookupTable(mdb, tableName)) == 0) {
unlock(mdb);
return MPR_ERR_CANT_FIND;
}
if ((col = lookupColumn(table, columnName)) == 0) {
unlock(mdb);
return MPR_ERR_CANT_FIND;
}
col->name = sclone(columnName);
col->type = type;
autoSave(mdb, table);
unlock(mdb);
return 0;
}
static int mdbAddValidation(Edi *edi, cchar *tableName, cchar *columnName, EdiValidation *vp)
{
Mdb *mdb;
MdbTable *table;
MdbCol *col;
mprAssert(edi);
mprAssert(tableName && *tableName);
mprAssert(columnName && *columnName);
mdb = (Mdb*) edi;
lock(mdb);
if ((table = lookupTable(mdb, tableName)) == 0) {
unlock(mdb);
return MPR_ERR_CANT_FIND;
}
if ((col = lookupColumn(table, columnName)) == 0) {
unlock(mdb);
return MPR_ERR_CANT_FIND;
}
if (col->validations == 0) {
col->validations = mprCreateList(0, 0);
}
mprAddItem(col->validations, vp);
unlock(mdb);
return 0;
}
/*
IndexName is not implemented yet
*/
static int mdbAddIndex(Edi *edi, cchar *tableName, cchar *columnName, cchar *indexName)
{
Mdb *mdb;
MdbTable *table;
MdbCol *col;
mprAssert(edi);
mprAssert(tableName && *tableName);
mprAssert(columnName && *columnName);
mdb = (Mdb*) edi;
lock(mdb);
if ((table = lookupTable(mdb, tableName)) == 0) {
unlock(mdb);
return MPR_ERR_CANT_FIND;
}
if ((col = lookupColumn(table, columnName)) == 0) {
unlock(mdb);
return MPR_ERR_CANT_FIND;
}
if ((table->index = mprCreateHash(0, MPR_HASH_STATIC_VALUES)) == 0) {
unlock(mdb);
return MPR_ERR_MEMORY;
}
table->indexCol = col;
col->flags |= EDI_INDEX;
autoSave(mdb, table);
unlock(mdb);
return 0;
}
static int mdbAddColumn(Edi *edi, cchar *tableName, cchar *columnName, int type, int flags)
{
Mdb *mdb;
MdbTable *table;
MdbCol *col;
mprAssert(edi);
mprAssert(tableName && *tableName);
mprAssert(columnName && *columnName);
mprAssert(type);
mdb = (Mdb*) edi;
lock(mdb);
if ((table = lookupTable(mdb, tableName)) == 0) {
unlock(mdb);
return MPR_ERR_CANT_FIND;
}
if ((col = lookupColumn(table, columnName)) != 0) {
unlock(mdb);
return MPR_ERR_ALREADY_EXISTS;
}
if ((col = createCol(table, columnName)) == 0) {
unlock(mdb);
return MPR_ERR_CANT_FIND;
}
col->type = type;
col->flags = flags;
autoSave(mdb, table);
unlock(mdb);
return 0;
}
static EdiRec *mdbCreateRec(Edi *edi, cchar *tableName)
{
Mdb *mdb;
MdbTable *table;
MdbCol *col;
EdiRec *rec;
EdiField *fp;
int f, nfields;
mdb = (Mdb*) edi;
if ((table = lookupTable(mdb, tableName)) == 0) {
return 0;
}
nfields = max(table->schema->ncols, 1);
if ((rec = mprAllocMem(sizeof(EdiRec) + sizeof(EdiField) * nfields, MPR_ALLOC_MANAGER | MPR_ALLOC_ZERO)) == 0) {
return 0;
}
mprSetManager(rec, ediManageEdiRec);
rec->edi = edi;
rec->tableName = table->name;
rec->nfields = nfields;
for (f = 0; f < nfields; f++) {
col = getCol(table, f);
fp = &rec->fields[f];
fp->type = col->type;
fp->name = col->name;
fp->flags = col->flags;
}
return rec;
}
static EdiRec *mdbReadRec(Edi *edi, cchar *tableName, cchar *key)
{
Mdb *mdb;
MdbTable *table;
MdbRow *row;
EdiRec *rec;
int r;
mdb = (Mdb*) edi;
rec = 0;
lock(mdb);
if ((table = lookupTable(mdb, tableName)) == 0) {
unlock(mdb);
return 0;
}
if ((r = lookupRow(table, key)) < 0) {
unlock(mdb);
return 0;
}
if ((row = mprGetItem(table->rows, r)) != 0) {
rec = createRecFromRow(edi, row);
}
unlock(mdb);
return rec;
}
static int mdbGetColumnSchema(Edi *edi, cchar *tableName, cchar *columnName, int *type, int *flags, int *cid)
{
Mdb *mdb;
MdbTable *table;
MdbCol *col;
mdb = (Mdb*) edi;
lock(mdb);
if ((table = lookupTable(mdb, tableName)) == 0) {
unlock(mdb);
return MPR_ERR_CANT_FIND;
}
if ((col = lookupColumn(table, columnName)) == 0) {
unlock(mdb);
return MPR_ERR_CANT_FIND;
}
if (type) {
*type = col->type;
}
if (flags) {
*flags = col->flags;
}
if (cid) {
*cid = col->cid;
}
unlock(mdb);
return 0;
}
static EdiField mdbReadField(Edi *edi, cchar *tableName, cchar *key, cchar *fieldName)
{
Mdb *mdb;
MdbTable *table;
MdbCol *col;
MdbRow *row;
EdiField field, err;
int r;
mdb = (Mdb*) edi;
lock(mdb);
err.valid = 0;
if ((table = lookupTable(mdb, tableName)) == 0) {
unlock(mdb);
return err;
}
if ((col = lookupColumn(table, fieldName)) == 0) {
unlock(mdb);
return err;
}
if ((r = lookupRow(table, key)) < 0) {
unlock(mdb);
return err;
}
row = mprGetItem(table->rows, r);
field = makeFieldFromRow(row, col);
unlock(mdb);
return field;
}
struct InterCodes* translate_Dec(struct TreeNode* Dec){
if(strcmp(Dec->children->name, "Exp") == 0){
printf("Dec - VarDec ASSIGNOP Exp\n");
Operand t1 = new_temp();
FieldList item = (FieldList)malloc(sizeof(struct FieldList_));
lookupTable(Dec->children->neighbours->neighbours->children->value_str,&item,0);
struct InterCodes* code1 = translate_Exp(Dec->children, t1);
struct InterCodes* code2 = (struct InterCodes*)malloc(sizeof(struct InterCodes));
code2->code.kind = ASSIGN_;
code2->code.u.assign.left = (Operand)malloc(sizeof(struct Operand_));
code2->code.u.assign.left->kind = VARIABLE;
strcpy(code2->code.u.assign.left->u.ID, item->inter_name);
code2->code.u.assign.right = t1;
struct InterCodes* p = code1;
while(p->next != NULL)
p = p->next;
p->next = code2;
code2->prev = p;
code2->next = NULL;
return code1;
}
}
/*
Return a list of column names
*/
static MprList *mdbGetColumns(Edi *edi, cchar *tableName)
{
Mdb *mdb;
MdbTable *table;
MdbSchema *schema;
MprList *list;
int i;
mprAssert(edi);
mprAssert(tableName && *tableName);
mdb = (Mdb*) edi;
lock(mdb);
if ((table = lookupTable(mdb, tableName)) == 0) {
unlock(mdb);
return 0;
}
schema = table->schema;
mprAssert(schema);
list = mprCreateList(schema->ncols, 0);
for (i = 0; i < schema->ncols; i++) {
/* No need to clone */
mprAddItem(list, schema->cols[i].name);
}
unlock(mdb);
return list;
}
struct InterCodes* translate_FunDec(struct TreeNode* FunDec){
if(strcmp(FunDec->children->neighbours->name, "LP") == 0){
printf("FunDec - ID LP RP\n");
lookupTable(FunDec->children->neighbours->neighbours->value_str,&pFunc,1);
struct InterCodes* code1 = (struct InterCodes*)malloc(sizeof(struct InterCodes));
code1->code.kind = FUNCTION_;
strcpy(code1->code.u.function.func, FunDec->children->neighbours->neighbours->value_str);
return code1;
}
if(strcmp(FunDec->children->neighbours->name, "VarList") == 0){
printf("FunDec - ID LP VarList RP\n");
struct InterCodes* code1 = (struct InterCodes*)malloc(sizeof(struct InterCodes));
code1->code.kind = FUNCTION_;
strcpy(code1->code.u.function.func, FunDec->children->neighbours->neighbours->neighbours->value_str);
FieldList item = (FieldList)malloc(sizeof(struct FieldList_));
lookupTable(FunDec->children->neighbours->neighbours->neighbours->value_str,&item,1);
lookupTable(FunDec->children->neighbours->neighbours->neighbours->value_str,&pFunc,1);
FieldList p = item->type->u.function->tail;
while(p != NULL){
struct InterCodes* code2 = (struct InterCodes*)malloc(sizeof(struct InterCodes));
code2->code.kind = PARAM_;
code2->code.u.param.op = (Operand)malloc(sizeof(struct Operand_));
code2->code.u.param.op->kind = VARIABLE;
strcpy(code2->code.u.param.op->u.ID, p->inter_name);
struct InterCodes* p = code1;
while(p->next != NULL)
p = p->next;
p->next = code2;
code2->prev = p;
code2->next = NULL;
p = p->next;
}
return code1;
}
}
static EdiGrid *mdbReadWhere(Edi *edi, cchar *tableName, cchar *columnName, cchar *operation, cchar *value)
{
Mdb *mdb;
EdiGrid *grid;
MdbTable *table;
MdbCol *col;
MdbRow *row;
int nrows, next, op, r, count;
assert(edi);
assert(tableName && *tableName);
mdb = (Mdb*) edi;
lock(mdb);
if ((table = lookupTable(mdb, tableName)) == 0) {
unlock(mdb);
return 0;
}
nrows = mprGetListLength(table->rows);
if ((grid = ediCreateBareGrid(edi, tableName, nrows)) == 0) {
unlock(mdb);
return 0;
}
grid->flags = EDI_GRID_READ_ONLY;
if (columnName) {
if ((col = lookupColumn(table, columnName)) == 0) {
unlock(mdb);
return 0;
}
if ((op = parseOperation(operation)) < 0) {
unlock(mdb);
return 0;
}
if (col->flags & EDI_INDEX && (op & OP_EQ)) {
if ((r = lookupRow(table, value)) != 0) {
row = getRow(table, r);
grid->records[0] = createRecFromRow(edi, row);
grid->nrecords = 1;
}
} else {
grid->nrecords = count = 0;
for (ITERATE_ITEMS(table->rows, row, next)) {
if (!matchRow(col, row->fields[col->cid], op, value)) {
continue;
}
grid->records[count++] = createRecFromRow(edi, row);
grid->nrecords = count;
}
}
} else {
for (ITERATE_ITEMS(table->rows, row, next)) {
/*
This function generates a 10 ascii character router extension string
@exceptions: This function can throw exceptions
*/
std::string virtualPortRouter::generateRouterExtension()
{
std::string lookupTable("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz");
std::string routerExtension;
std::random_device rd;
std::mt19937 gen(rd());
std::uniform_int_distribution<> stringGenerationDistribution(0, lookupTable.size()-1);
//Generate 10 random characters
for(int i=0; i<10; i++)
{
routerExtension.push_back(lookupTable[stringGenerationDistribution(gen)]);
}
return routerExtension;
}
static int mdbLookupField(Edi *edi, cchar *tableName, cchar *fieldName)
{
Mdb *mdb;
MdbTable *table;
MdbCol *col;
mdb = (Mdb*) edi;
lock(mdb);
if ((table = lookupTable(mdb, tableName)) == 0) {
unlock(mdb);
return MPR_ERR_CANT_FIND;
}
if ((col = lookupColumn(table, fieldName)) == 0) {
unlock(mdb);
return MPR_ERR_CANT_FIND;
}
unlock(mdb);
return col->cid;
}
/**
* This utility function does interpolation and range resizing for
* a table representing a lookup function.
* newXdivs is one less than the size of the table; it is the number of
* subdivisions that the table represents.
*/
void HHGate::tabFill( vector< double >& table,
unsigned int newXdivs, double newXmin, double newXmax )
{
if ( newXdivs < 3 ) {
cout << "Error: tabFill: # divs must be >= 3. Not filling table.\n";
return;
}
vector< double > old = table;
double newDx = ( newXmax - newXmin ) / newXdivs;
table.resize( newXdivs + 1 );
bool origLookupMode = lookupByInterpolation_;
lookupByInterpolation_ = 1;
for( unsigned int i = 0; i <= newXdivs; ++i ) {
table[i] = lookupTable( table, newXmin + i * newDx );
}
lookupByInterpolation_ = origLookupMode;
}
static int mdbGetTableSchema(Edi *edi, cchar *tableName, int *numRows, int *numCols)
{
Mdb *mdb;
MdbTable *table;
mdb = (Mdb*) edi;
lock(mdb);
if ((table = lookupTable(mdb, tableName)) == 0) {
unlock(mdb);
return MPR_ERR_CANT_FIND;
}
if (numRows) {
*numRows = mprGetListLength(table->rows);
}
if (numCols) {
*numCols = table->schema->ncols;
}
unlock(mdb);
return 0;
}
static int mdbAddColumn(Edi *edi, cchar *tableName, cchar *columnName, int type, int flags)
{
Mdb *mdb;
MdbTable *table;
MdbCol *col;
assert(edi);
assert(tableName && *tableName);
assert(columnName && *columnName);
assert(type);
mdb = (Mdb*) edi;
lock(mdb);
if ((table = lookupTable(mdb, tableName)) == 0) {
unlock(mdb);
return MPR_ERR_CANT_FIND;
}
if ((col = lookupColumn(table, columnName)) != 0) {
unlock(mdb);
return MPR_ERR_ALREADY_EXISTS;
}
if ((col = createCol(table, columnName)) == 0) {
unlock(mdb);
return MPR_ERR_CANT_FIND;
}
col->type = type;
col->flags = flags;
if (flags & EDI_INDEX) {
if (table->index) {
mprError("Index already specified in table %s, replacing.", tableName);
}
if ((table->index = mprCreateHash(0, MPR_HASH_STATIC_VALUES)) != 0) {
table->indexCol = col;
}
}
autoSave(mdb, table);
unlock(mdb);
return 0;
}
double HHGate::lookupB( double v ) const
{
return lookupTable( B_, v );
}
double HHGate::lookupA( double v ) const
{
return lookupTable( A_, v );
}
//符号表是全局变量
struct InterCodes* translate_Exp(struct TreeNode* Exp, Operand place){
if (strcmp(Exp->children->name, "INT")){
printf("Exp - INT\n");
if(place != NULL){
FieldList item = (FieldList)malloc(sizeof(struct FieldList_));
lookupTable(Exp->children->value_str,&item,0);
place->kind = CONSTANT;
place->u.value = Exp->children->value_int;
struct InterCodes* temp = (struct InterCodes*)malloc(sizeof(struct InterCodes));
temp->code.kind = NONE_;
return temp;
}
else{
struct InterCodes* temp = (struct InterCodes*)malloc(sizeof(struct InterCodes));
temp->code.kind = NONE_;
return temp;
}
}
if (strcmp(Exp->children->name, "ID")){
if(Exp->children->neighbours == NULL){
printf("Exp - ID\n");
if(place != NULL){
FieldList item = (FieldList)malloc(sizeof(struct FieldList_));
lookupTable(Exp->children->value_str,&item,0);
place->kind = VARIABLE;
strcpy(place->u.ID, item->inter_name);
struct InterCodes* temp = (struct InterCodes*)malloc(sizeof(struct InterCodes));
temp->code.kind = NONE_;
return temp;
}
else{
struct InterCodes* temp = (struct InterCodes*)malloc(sizeof(struct InterCodes));
temp->code.kind = NONE_;
return temp;
}
}
if(strcmp(Exp->children->neighbours->name, "DOT")){
printf("Exp - Exp DOT ID\n");
//Operand t1 = new_temp();
//struct InterCodes* code1 = translate_Exp(Exp->children->neighbours->neighbours, t1);
FieldList item = (FieldList)malloc(sizeof(struct FieldList_));
int i = lookupTable(Exp->children->neighbours->neighbours->value_str,&item,0);
switch(i){
case 0:{
Operand t1 = new_temp();
struct InterCodes* code1 = (struct InterCodes*)malloc(sizeof(struct InterCodes));
code1->code.kind = ADD_;
code1->code.u.binop.result = t1;
code1->code.u.binop.op1 = (Operand)malloc(sizeof(struct Operand_));
code1->code.u.binop.op1->kind = VARIABLE;
strcpy(code1->code.u.binop.op1->u.ID, item->inter_name);
code1->code.u.binop.op2 = (Operand)malloc(sizeof(struct Operand_));
code1->code.u.binop.op2->kind = CONSTANT;
code1->code.u.binop.op2->u.value = index_size(item, Exp->children->value_str);
place->kind = REFERENCE;
strcpy(place->u.ID, t1->u.ID);
return code1;
//break;
}
case 1:{
Operand t1 = new_temp();
Operand t2 = new_temp();
struct InterCodes* code1 = (struct InterCodes*)malloc(sizeof(struct InterCodes));
code1->code.kind = ASSIGN_;
code1->code.u.assign.left = t1;
code1->code.u.assign.right = (Operand)malloc(sizeof(struct Operand_));
code1->code.u.assign.right->kind = ADDRESS;
strcpy(code1->code.u.assign.right->u.ID, item->inter_name);
struct InterCodes* code2 = (struct InterCodes*)malloc(sizeof(struct InterCodes));
code2->code.kind = ADD_;
code2->code.u.binop.result = t2;
code2->code.u.binop.op1 = t1;
code2->code.u.binop.op2 = (Operand)malloc(sizeof(struct Operand_));
code2->code.u.binop.op2->kind = CONSTANT;
code2->code.u.binop.op2->u.value = index_size(item, Exp->children->value_str);
place->kind = REFERENCE;
strcpy(place->u.ID, t2->u.ID);
code1->next = code2;
code2->prev = code1;
return code1;
}
}
}
}
if (strcmp(Exp->children->name, "Exp")){
if (strcmp(Exp->children->neighbours->name, "ASSIGNOP")){
if (strcmp(Exp->children->neighbours->neighbours->children->name, "ID")){
printf("Exp - Exp ASSIGNOP Exp\n");
if(place != NULL){
Operand t1 = new_temp();
FieldList item = (FieldList)malloc(sizeof(struct FieldList_));
lookupTable(Exp->children->neighbours->neighbours->children->value_str,&item,0);
struct InterCodes* code1 = translate_Exp(Exp->children, t1);
struct InterCodes* code2 = (struct InterCodes*)malloc(sizeof(struct InterCodes));
code2->code.kind = ASSIGN_;
code2->code.u.assign.left = (Operand)malloc(sizeof(struct Operand_));
code2->code.u.assign.left->kind = VARIABLE;
strcpy(code2->code.u.assign.left->u.ID, item->inter_name);
code2->code.u.assign.right = t1;
/*struct InterCodes* code3 = (struct InterCodes*)malloc(sizeof(struct InterCodes));
code3->code.kind = ASSIGN;
code3->code.u.assign.left = (Operand)malloc(sizeof(struct Operand_));
code3->code.u.assign.left->kind = VARIABLE;
strcpy(code3->code.u.assign.left->u.ID, place->u.ID);
code3->code.u.assign.right = (Operand)malloc(sizeof(struct Operand_));
code3->code.u.assign.right->kind = VARIABLE;
strcpy(code3->code.u.assign.right->u.ID, Exp->children->neighbours->neighbours->children->inter_name);*/
place->kind = VARIABLE;
strcpy(place->u.ID, item->inter_name);
struct InterCodes* p = code1;
while(p->next != NULL)
p = p->next;
p->next = code2;
code2->prev = p;
code2->next = NULL;
return code1;
}
else{
Operand t1 = new_temp();
FieldList item = (FieldList)malloc(sizeof(struct FieldList_));
lookupTable(Exp->children->neighbours->neighbours->children->value_str,&item,0);
struct InterCodes* code1 = translate_Exp(Exp->children, t1);
struct InterCodes* code2 = (struct InterCodes*)malloc(sizeof(struct InterCodes));
code2->code.kind = ASSIGN_;
code2->code.u.assign.left = (Operand)malloc(sizeof(struct Operand_));
code2->code.u.assign.left->kind = VARIABLE;
strcpy(code2->code.u.assign.left->u.ID, item->inter_name);
code2->code.u.assign.right = t1;
struct InterCodes* p = code1;
while(p->next != NULL)
p = p->next;
p->next = code2;
code2->prev = p;
code2->next = NULL;
return code1;
}
}
}
if(strcmp(Exp->children->neighbours->name, "PLUS")){
printf("Exp - Exp PLUS Exp\n");
if(place != NULL){
Operand t1 = new_temp();
Operand t2 = new_temp();
struct InterCodes* code1 = translate_Exp(Exp->children->neighbours->neighbours, t1);
struct InterCodes* code2 = translate_Exp(Exp->children, t2);
struct InterCodes* code3 = (struct InterCodes*)malloc(sizeof(struct InterCodes));
code3->code.kind = ADD_;
code3->code.u.binop.result = (Operand)malloc(sizeof(struct Operand_));
code3->code.u.binop.result->kind = VARIABLE;
strcpy(code3->code.u.binop.result->u.ID, place->u.ID);
code3->code.u.binop.op1 = t1;
code3->code.u.binop.op2 = t2;
struct InterCodes* p = code1;
while(p->next != NULL)
p = p->next;
p->next = code2;
code2->prev = p;
p = code2;
while(p->next != NULL)
p = p->next;
p->next = code3;
code3->prev = p;
code3->next = NULL;
return code1;
}
else{
Operand t1 = new_temp();
Operand t2 = new_temp();
struct InterCodes* code1 = translate_Exp(Exp->children->neighbours->neighbours, t1);
struct InterCodes* code2 = translate_Exp(Exp->children, t2);
struct InterCodes* p = code1;
while(p->next != NULL)
p = p->next;
p->next = code2;
code2->prev = p;
code2->next = NULL;
return code1;
}
}
if(strcmp(Exp->children->neighbours->name, "MINUS")){
printf("Exp - Exp MINUS Exp\n");
if(place != NULL){
if(Exp->children->neighbours->neighbours != NULL){
Operand t1 = new_temp();
Operand t2 = new_temp();
struct InterCodes* code1 = translate_Exp(Exp->children->neighbours->neighbours, t1);
struct InterCodes* code2 = translate_Exp(Exp->children, t2);
struct InterCodes* code3 = (struct InterCodes*)malloc(sizeof(struct InterCodes));
code3->code.kind = SUB_;
code3->code.u.binop.result = (Operand)malloc(sizeof(struct Operand_));
code3->code.u.binop.result->kind = VARIABLE;
strcpy(code3->code.u.binop.result->u.ID, place->u.ID);
code3->code.u.binop.op1 = t1;
code3->code.u.binop.op2 = t2;
struct InterCodes* p = code1;
while(p->next != NULL)
p = p->next;
p->next = code2;
code2->prev = p;
p = code2;
while(p->next != NULL)
p = p->next;
p->next = code3;
code3->prev = p;
code3->next = NULL;
return code1;
}
else{
Operand t1 = new_temp();
struct InterCodes* code1 = translate_Exp(Exp->children, t1);
struct InterCodes* code2 = (struct InterCodes*)malloc(sizeof(struct InterCodes));
code2->code.kind = SUB_;
code2->code.u.binop.result = (Operand)malloc(sizeof(struct Operand_));
code2->code.u.binop.result->kind = VARIABLE;
strcpy(code2->code.u.binop.result->u.ID, place->u.ID);
code2->code.u.binop.op1 = (Operand)malloc(sizeof(struct Operand_));
code2->code.u.binop.op1->kind = CONSTANT;
code2->code.u.binop.op1->u.value = 0;
code2->code.u.binop.op2 = t1;
struct InterCodes* p = code1;
while(p->next != NULL)
p = p->next;
p->next = code2;
code2->prev = p;
code2->next = NULL;
return code1;
}
}
else{
if(Exp->children->neighbours->neighbours != NULL){
Operand t1 = new_temp();
Operand t2 = new_temp();
struct InterCodes* code1 = translate_Exp(Exp->children->neighbours->neighbours, t1);
struct InterCodes* code2 = translate_Exp(Exp->children, t2);
struct InterCodes* p = code1;
while(p->next != NULL)
p = p->next;
p->next = code2;
code2->prev = p;
code2->next = NULL;
return code1;
}
else{
Operand t1 = new_temp();
struct InterCodes* code1 = translate_Exp(Exp->children, t1);
return code1;
}
}
}
if(strcmp(Exp->children->neighbours->name, "STAR")){
printf("Exp - Exp STAR Exp\n");
if(place != NULL){
Operand t1 = new_temp();
Operand t2 = new_temp();
struct InterCodes* code1 = translate_Exp(Exp->children->neighbours->neighbours, t1);
struct InterCodes* code2 = translate_Exp(Exp->children, t2);
struct InterCodes* code3 = (struct InterCodes*)malloc(sizeof(struct InterCodes));
code3->code.kind = MUL_;
code3->code.u.binop.result = (Operand)malloc(sizeof(struct Operand_));
code3->code.u.binop.result->kind = VARIABLE;
strcpy(code3->code.u.binop.result->u.ID, place->u.ID);
code3->code.u.binop.op1 = t1;
code3->code.u.binop.op2 = t2;
struct InterCodes* p = code1;
while(p->next != NULL)
p = p->next;
p->next = code2;
code2->prev = p;
p = code2;
while(p->next != NULL)
p = p->next;
p->next = code3;
code3->prev = p;
code3->next = NULL;
return code1;
}
else{
Operand t1 = new_temp();
Operand t2 = new_temp();
struct InterCodes* code1 = translate_Exp(Exp->children->neighbours->neighbours, t1);
struct InterCodes* code2 = translate_Exp(Exp->children, t2);
struct InterCodes* p = code1;
while(p->next != NULL)
p = p->next;
p->next = code2;
code2->prev = p;
code2->next = NULL;
return code1;
}
}
if(strcmp(Exp->children->neighbours->name, "DIV")){
printf("Exp - Exp DIV Exp\n");
if(place != NULL){
Operand t1 = new_temp();
Operand t2 = new_temp();
struct InterCodes* code1 = translate_Exp(Exp->children->neighbours->neighbours, t1);
struct InterCodes* code2 = translate_Exp(Exp->children, t2);
struct InterCodes* code3 = (struct InterCodes*)malloc(sizeof(struct InterCodes));
code3->code.kind = DIV_;
code3->code.u.binop.result = (Operand)malloc(sizeof(struct Operand_));
code3->code.u.binop.result->kind = VARIABLE;
strcpy(code3->code.u.binop.result->u.ID, place->u.ID);
code3->code.u.binop.op1 = t1;
code3->code.u.binop.op2 = t2;
struct InterCodes* p = code1;
while(p->next != NULL)
p = p->next;
p->next = code2;
code2->prev = p;
p = code2;
while(p->next != NULL)
p = p->next;
p->next = code3;
code3->prev = p;
code3->next = NULL;
return code1;
}
else{
Operand t1 = new_temp();
Operand t2 = new_temp();
struct InterCodes* code1 = translate_Exp(Exp->children->neighbours->neighbours, t1);
struct InterCodes* code2 = translate_Exp(Exp->children, t2);
struct InterCodes* p = code1;
while(p->next != NULL)
p = p->next;
p->next = code2;
code2->prev = p;
code2->next = NULL;
return code1;
}
}
if(strcmp(Exp->children->neighbours->name, "RELOP") || strcmp(Exp->children->neighbours->name, "NOT") || strcmp(Exp->children->neighbours->name, "AND") || strcmp(Exp->children->neighbours->name, "OR")){
printf("Exp - Exp Cond Exp\n");
if(place != NULL){
Operand label1 = new_label();
Operand label2 = new_label();
struct InterCodes* code1 = (struct InterCodes*)malloc(sizeof(struct InterCodes));
code1->code.kind = ASSIGN_;
code1->code.u.assign.left = (Operand)malloc(sizeof(struct Operand_));
code1->code.u.assign.left->kind = VARIABLE;
strcpy(code1->code.u.assign.left->u.ID, place->u.ID);
code1->code.u.assign.right = (Operand)malloc(sizeof(struct Operand_));
code1->code.u.assign.right->kind = CONSTANT;
code1->code.u.assign.right->u.value = 0;
struct InterCodes* code2 = translate_Cond(Exp, label1, label2);
struct InterCodes* code3 = (struct InterCodes*)malloc(sizeof(struct InterCodes));
code3->code.kind = LABEL_;
code3->code.u.labelcode.label = label1;
struct InterCodes* code4 = (struct InterCodes*)malloc(sizeof(struct InterCodes));
code4->code.kind = ASSIGN_;
code4->code.u.assign.left = (Operand)malloc(sizeof(struct Operand_));
code4->code.u.assign.left->kind = VARIABLE;
strcpy(code4->code.u.assign.left->u.ID, place->u.ID);
code4->code.u.assign.right = (Operand)malloc(sizeof(struct Operand_));
code4->code.u.assign.right->kind = CONSTANT;
code4->code.u.assign.right->u.value = 1;
struct InterCodes* code5 = (struct InterCodes*)malloc(sizeof(struct InterCodes));
code5->code.kind = LABEL_;
code5->code.u.labelcode.label = label2;
code1->next = code2;
code2->prev = code1;
struct InterCodes* p = code2;
while(p->next != NULL)
p = p->next;
p->next = code3;
code3->prev = p;
code3->next = code4;
code4->prev = code3;
code4->next = code5;
code5->prev = code4;
code5->next = NULL;
return code1;
}
}
}
if (strcmp(Exp->children->neighbours->name, "LP")){
printf("Exp - ID LP RP\n");
if(strcmp(Exp->children->neighbours->neighbours->value_str, "read") == 0){
struct InterCodes* code1 = (struct InterCodes*)malloc(sizeof(struct InterCodes));
code1->code.kind = READ_;
code1->code.u.read.rd = place;
return code1;
}
else{
FieldList item = (FieldList)malloc(sizeof(struct FieldList_));
lookupTable(Exp->children->neighbours->neighbours->value_str,&item,1);//查函数
struct InterCodes* code1 = (struct InterCodes*)malloc(sizeof(struct InterCodes));
code1->code.kind = CALL_;
code1->code.u.call.left = (Operand)malloc(sizeof(struct Operand_));
code1->code.u.call.left->kind = VARIABLE;
strcpy(code1->code.u.assign.left->u.ID, place->u.ID);
code1->code.u.call.function = (Operand)malloc(sizeof(struct Operand_));
code1->code.u.call.function->kind = VARIABLE;
strcpy(code1->code.u.call.function->u.ID, item->name);
return code1;
}
}
if(strcmp(Exp->children->neighbours->name, "Args")){
printf("Exp - ID LP Args RP\n");
struct ArgList* arg_list = NULL;
struct InterCodes* code1 = translate_Args(Exp->children->neighbours, arg_list);
if(strcpy(Exp->children->neighbours->neighbours->neighbours->value_str, "write") == 0){
struct InterCodes* code2 = (struct InterCodes*)malloc(sizeof(struct InterCodes));
code2->code.kind = WRITE_;
code2->code.u.write.wr = arg_list->op;
struct InterCodes* p = code1;
while(p->next != NULL)
p = p->next;
p->next = code2;
code2->prev = p;
code2->next = NULL;
return code1;
}
else{
FieldList item = (FieldList)malloc(sizeof(struct FieldList_));
lookupTable(Exp->children->neighbours->neighbours->neighbours->value_str,&item,0);
struct ArgList* q = arg_list;
struct InterCodes* code2 = NULL;
while(q != NULL){
struct InterCodes* code3 = (struct InterCodes*)malloc(sizeof(struct InterCodes));
code3->code.kind = ARG_;
code3->code.u.arg.argument = q->op;
if(code2 == NULL){
code2 = code3;
}
else{
struct InterCodes* p = code2;
while(p->next != NULL)
p = p->next;
p->next = code3;
code3->prev = p;
}
q = q->next;
}
struct InterCodes* code4 = (struct InterCodes*)malloc(sizeof(struct InterCodes));
code4->code.kind = CALL_;
code4->code.u.call.left = (Operand)malloc(sizeof(struct Operand_));
code4->code.u.call.left->kind = VARIABLE;
strcpy(code4->code.u.assign.left->u.ID, place->u.ID);
code4->code.u.call.function = (Operand)malloc(sizeof(struct Operand_));
code4->code.u.call.function->kind = VARIABLE;
strcpy(code4->code.u.call.function->u.ID, item->name);
struct InterCodes* p = code1;
while(p->next != NULL)
p = p->next;
p->next = code2;
code2->prev = p;
p = code2;
while(p->next != NULL)
p = p->next;
p->next = code4;
code4->prev = p;
code4->next = NULL;
return code1;
}
}
if (strcmp(Exp->children->name, "RB") == 0){
printf("Exp - Exp LB Exp RB\n");
FieldList item = (FieldList)malloc(sizeof(struct FieldList_));
lookupTable(Exp->children->neighbours->neighbours->neighbours->children->value_str,&item,0);
Operand t1 = new_temp();
Operand t2 = new_temp();
Operand t3 = new_temp();
struct InterCodes* code1 = translate_Exp(Exp->children->neighbours, t1);
struct InterCodes* code2 = (struct InterCodes*)malloc(sizeof(struct InterCodes));
code2->code.kind = MUL_;
code2->code.u.binop.result = t2;
code2->code.u.binop.op1 = t1;
code2->code.u.binop.op2 = (Operand)malloc(sizeof(struct Operand_));
code2->code.u.binop.result->kind = CONSTANT;
code2->code.u.binop.result->u.value = 4;
struct InterCodes* code3 = (struct InterCodes*)malloc(sizeof(struct InterCodes));
code3->code.kind = ADD_;
code3->code.u.binop.result = t3;
code3->code.u.binop.op1 = (Operand)malloc(sizeof(struct Operand_));
code3->code.u.binop.op1->kind = ADDRESS;
strcpy(code3->code.u.binop.op1->u.ID, item->inter_name);
code3->code.u.binop.op2 = t2;
//place = t4;
place->kind = REFERENCE;
strcpy(place->u.ID, t3->u.ID);
struct InterCodes* p = code1;
while(p->next != NULL)
p = p->next;
p->next = code2;
code2->prev = p;
code2->next = code3;
code3->prev = code2;
code3->next = NULL;
return code1;
}
}