cgen.c

1.小型编译器 2。支持整数

					emitRM(opPOP, ac, 0, 0, "abs pop value");
					emitRM(opSYSCALL,0,index,0,"call abs function");
					emitRM(opPUSH, ac, 0, 0, "abs push value");
				} else if(strcmp(tree->attr.name,"ceil") == 0){
					cGen(p1);
					emitRM(opPOP, ac, 0, 0, "ceil pop double value",sizeofdouble);
					emitRM(opSYSCALL,0,index,0,"call ceil function",sizeofdouble);
					emitRM(opPUSH, ac, 0, 0, "ceil push double value",sizeofdouble);
				} else if(strcmp(tree->attr.name,"floor") == 0){
					cGen(p1);
					emitRM(opPOP, ac, 0, 0, "floor pop double value",sizeofdouble);
					emitRM(opSYSCALL,0,index,0,"call floor function",sizeofdouble);
					emitRM(opPUSH, ac, 0, 0, "floor push double value",sizeofdouble);
				} else if(strcmp(tree->attr.name,"fabs") == 0){
					cGen(p1);
					emitRM(opPOP, ac, 0, 0, "fabs pop double value",sizeofdouble);
					emitRM(opSYSCALL,0,index,0,"call fabs function",sizeofdouble);
					emitRM(opPUSH, ac, 0, 0, "fabs push double value",sizeofdouble);
				} else if(strcmp(tree->attr.name,"fmod") == 0){
					cGen(p1);
					emitRM(opPOP,ac,0,0,"op: fmod pop double right",sizeofdouble);
					emitRM(opPOP,ac1,0,0,"op: fmod pop double left",sizeofdouble);
					emitRM(opSYSCALL,0,index,0,"call fmod function",sizeofdouble);
					emitRM(opPUSH, ac, 0, 0, "fmod push double value",sizeofdouble);
				} else if(strcmp(tree->attr.name,"strcmp") == 0){
					cGen(p1,1);
					emitRM(opPOP, ac, 0, 0, "read pop right addr");
					emitRM(opPOP, ac1, 0, 0, "read pop left addr");
					emitRM(opSYSCALL,0,index,0,"call strcmp function",sizeofint);
					emitRM(opPUSH, ac, 0, 0, "strcmp push int value",sizeofint);
				} else if(strcmp(tree->attr.name,"strcat") == 0){
				} else if(strcmp(tree->attr.name,"strcpy") == 0){
					cGen(p1,1);
					emitRM(opPOP, ac, 0, 0, "read pop right addr");
					emitRM(opPOP, ac1, 0, 0, "read pop left addr");
					emitRM(opSYSCALL,0,index,0,"call strcpy function",sizeofint);
					emitRM(opPUSH, ac, 0, 0, "strcpy push int value",sizeofint);
				}		

				if (TraceCode) 
					emitComment("<- SysCallK") ;
			}			
			break;

		case ReturnK:
			p1 = tree->child[0];
			if(p1)
			{
				cGen(p1);
				ret(TRUE,pTable ->funEntry ->name);
			}else 
				ret(FALSE,pTable ->funEntry ->name);
			break;

		case BreakK:
			ujp(pTable ->parent ->lab2);
			break;
       	case ContinueK:
			ujp(pTable ->parent ->lab1);			
			break;
	
	    case AssignK:
	       	if (TraceCode) 
				emitComment("-> assign") ;
			
	        /* generate code for rhs */
			p1 = tree->child[0];
			cGen(p1, 1);

			p2 = tree->child[1];
			cGen(p2);

			type = getType(p1);
			type2 = getType(p2);

			/* gen code to pop right value */
			//浮点数赋值给整数
			if((type == Integer)&&(type2 == Double))
				emitRM(opPOP,ac,0,0,"op: pop right double value",sizeofdouble,2);
			else if(type == Double)
				emitRM(opPOP,ac,0,0,"op: pop right double value",sizeofdouble);
			else if(type == Integer)
				emitRM(opPOP,ac,0,0,"op: pop right integer value",sizeofint);
			else if(type == Char)
				emitRM(opPOP,ac,0,0,"op: pop right char value", sizeofchar);
			
			/* gen code to pop left addr */
			emitRM(opPOP,ac1,0,0,"op: pop left addr");
			
			if(type == Double)
				emitRM(opST,ac, 0, ac1, "op: Assign store double ",sizeofdouble);
			else if(type == Integer)
				emitRM(opST,ac, 0, ac1, "op: Assign store integer ",sizeofint);
			else if(type == Char)
				emitRM(opST,ac, 0, ac1, "op: Assign store char ",sizeofchar);

			//printf("AssignK tmpOffset:%d\n", tmpOffset);
	     	
	     	if (TraceCode)  
				emitComment("<- assign") ;
	     	break; /* assign_k */
			
      		default:
         		break;
    }
} /* genStmt */

/* Procedure genExp generates code at an expression node */
static void genExp( TreeNode * tree, int addrFlag = 0)
{ 
	int i, loc, os, offset, level,size, flag, refFlag;
	ValEntry * pEntry = (ValEntry *)malloc(sizeof(ValEntry));
	StructEntry * pStruct = (StructEntry *)malloc(sizeof(StructEntry));
  	TreeNode * p1, * p2;
	ExpType	type,type2;
	char *c;

	//printf("addrFlag: %d\n", addrFlag);
  	switch (tree->kind.exp) {

    	case NumK :
      		if (TraceCode) 
				emitComment("-> Num") ;
      		/* gen code to load integer constant using LDC */
			size = sizeof(WORD);

			//类型转换
			if(tree->type.type == Double){
	      		emitRM2(opLDC,ac,tree->attr.val.f,0,"load trans num",sizeofdouble);
				emitRM(opPUSH,ac,0,0,"push trans num",sizeofdouble);
			}else if(tree->type.type == Integer){
				emitRM(opLDC,ac,tree->attr.val.i,0,"load num",sizeofint);
				emitRM(opPUSH,ac,0,0,"push num",sizeofint);
			}
	      	if (TraceCode)  
				emitComment("<- Num") ;
	      	break; /* ConstK */

		case DNumK :
      		if (TraceCode) 
				emitComment("-> DNum") ;
      		/* gen code to load integer constant using LDC */
			size = sizeof(DWORD);
			
	      	emitRM2(opLDC,ac,tree->attr.val.f,0,"load dnum",sizeofdouble);
			emitRM(opPUSH,ac,0,0,"push dnum",sizeofdouble,1);
	      	if (TraceCode)  
				emitComment("<- DNum") ;
	      	break; /* ConstK */

		case CharK :
      		if (TraceCode) 
				emitComment("-> Char") ;
      		/* gen code to load integer constant using LDC */
			size = sizeof(BYTE);
				
	      	emitRM(opLDC,ac,tree->attr.val.i,0,"load char",sizeofchar);
			emitRM(opPUSH,ac,0,0,"push char",sizeofchar);
	      	if (TraceCode)  
				emitComment("<- Char") ;
	      	break; /* ConstK */	

		case StringK:
			if (TraceCode) 
				emitComment("-> StringK");

			//Copy String
			size = strlen(tree->attr.val.str)-2;
			printf("StringK:%s length: %d\n", tree->attr.val.str, size);

			c = tree->attr.val.str + 1;
			emitRM(opPUSH,bp,0,0,"push bp");
			emitRM(opLDC,bp,0,0,"set bp");
			for(i=0;i<size;i++){
				loc = (int)(*c+i);
				printf("%c", loc);
				emitRM(opLDC,ac,loc,0,"load char",sizeofchar);
				emitRM(opST,ac,i,bp, "store char",sizeofchar);
			}
			emitRM(opLDC,ac,0,0,"load char",sizeofchar);
			emitRM(opST,ac,i,bp, "store char",sizeofchar);
				
			emitRM(opLDC,ac,0,0,"load string addr",sizeofint);
			emitRM(opPOP,bp,0,0,"pop bp");
			emitRM(opPUSH,ac,0,0,"push string addr",sizeofint);
						
			if (TraceCode)  
				emitComment("<- StringK") ;
			break;

		case StructIdK:
			if (TraceCode) 
				emitComment("-> StructIdK") ;
			level = Lookup_Var(pTable, pTable ->funEntry, tree->attr.name, pEntry);
			loc = pEntry ->offset;
			refFlag = pEntry->refFlag;
			p1 = tree->child[0];
			pStruct = Lookup_Struct(pEntry->type.name);
			Lookup_Struct_Field(pStruct, p1->attr.name, pEntry);
			offset = pEntry->offset;
			printf("%s.%s refFlag: %d loc: %d offset:%d\n", tree->attr.name, p1->attr.name, refFlag, loc, offset);

			//引用取地址时直接用值
			if(refFlag && addrFlag){
				if(p1->child[0]){
					cGen(p1->child[0]);
					emitRM(opPOP, ac, 0, 0, "pop array ixa");
					if(p1->type.type == Double)
						emitRM(opLDC,ac1,sizeofdouble,0,"array load ixa");
					else if(p1->type.type == Integer)
						emitRM(opLDC,ac1,sizeofint,0,"array load ixa");
					else if(p1->type.type == Char)
						emitRM(opLDC,ac1,sizeofchar,0,"array load ixa");
					emitRO(opMUL,ac1,ac1,ac,"array op *");

					emitRM(opLDA,bp,base[level-1],sp,"load ref base top");
					emitRM(opLDA,ac,loc,bp,"add ref loc");
					emitRM(opLD,ac,0,ac,"load ref addr");					
					emitRM(opADD,ac1,ac,ac1, "op: add ixa");
					emitRM(opLDA,ac,offset,ac1,"add ref offset");
					emitRM(opPUSH, ac, 0, 0, "push ref addr");
				} else {	
					emitRM(opLDA,bp,base[level-1],sp,"load ref base top");
					emitRM(opLDA,ac,loc,bp,"add ref loc");
					emitRM(opLD,ac,0,ac,"load ref addr");
					emitRM(opLDA,ac,offset,ac,"add ref offset");
					emitRM(opPUSH, ac, 0, 0, "push ref addr");
				}			

				if (TraceCode)  
					emitComment("<- StructIdK") ;
				break;
			} else if(refFlag){
				//引用取值
				if(p1->child[0]){
					cGen(p1->child[0]);
					emitRM(opPOP, ac, 0, 0, "pop array ixa");
					if(p1->type.type == Double)
						emitRM(opLDC,ac1,sizeofdouble,0,"array load ixa");
					else if(p1->type.type == Integer)
						emitRM(opLDC,ac1,sizeofint,0,"array load ixa");
					else if(p1->type.type == Char)
						emitRM(opLDC,ac1,sizeofchar,0,"array load ixa");
					emitRO(opMUL,ac1,ac1,ac,"array op *");

					emitRM(opLDA,bp,base[level-1],sp,"load ref base top");
					emitRM(opLDA,ac,loc,bp,"add ref loc");
					emitRM(opLD,ac,0,ac,"load ref addr");					
					emitRM(opADD,ac1,ac,ac1, "op: add ixa");
					emitRM(opLDA,ac,offset,ac1,"add ref offset");
					if(p1->type.type == Double){
						emitRM(opLD,ac,0,ac,"load ref double value",sizeofdouble);
						emitRM(opPUSH, ac, 0, 0, "push ref double value",sizeofdouble);
					}else if(p1->type.type == Integer){
						emitRM(opLD,ac,0,ac,"load ref value",sizeofint);
						emitRM(opPUSH, ac, 0, 0, "push ref value",sizeofint);
					}else if(p1->type.type == Char){
						emitRM(opLD,ac,0,ac,"load ref value",sizeofchar);
						emitRM(opPUSH, ac, 0, 0, "push ref value",sizeofchar);
					}
				} else {	
					emitRM(opLDA,bp,base[level-1],sp,"load ref base top");
					emitRM(opLDA,ac,loc,bp,"add ref loc");
					emitRM(opLD,ac,0,ac,"load ref addr");
					emitRM(opLDA,ac,offset,ac,"add ref offset");
					if(p1->type.type == Double){
						emitRM(opLD,ac,0,ac,"load ref double value",sizeofdouble);
						emitRM(opPUSH, ac, 0, 0, "push ref double value",sizeofdouble);
					}else if(p1->type.type == Integer){
						emitRM(opLD,ac,0,ac,"load ref value",sizeofint);
						emitRM(opPUSH, ac, 0, 0, "push ref value",sizeofint);
					}else if(p1->type.type == Char){
						emitRM(opLD,ac,0,ac,"load ref value",sizeofchar);
						emitRM(opPUSH, ac, 0, 0, "push ref value",sizeofchar);
					}	
				}				
				
				if (TraceCode)  
					emitComment("<- StructIdK") ;
				break;
			}

			loc += offset;
			
			//数组
			if(p1->child[0]){
				cGen(p1->child[0]);
				emitRM(opPOP, ac, 0, 0, "pop array ixa");
				if(p1->type.type == Double)
					emitRM(opLDC,ac1,sizeofdouble,0,"array load ixa");
				else
					emitRM(opLDC,ac1,sizeofint,0,"array load ixa");
				emitRO(opMUL,ac1,ac1,ac,"array op *");
			} 	

			if(level == 0){
				if(p1->child[0]){
					if(p1->type.type == Double){
						emitRM(opADD,ac1,ac1,gp, "op: add ixa");
						if(addrFlag){
		  					emitRM(opLDA,ac,loc,ac1,"array assign: store double addr");
							emitRM(opPUSH, ac, 0, 0, "array assign: push double addr");
						}else{
							emitRM(opLD,ac,loc,ac1,"array assign: store double value",sizeofdouble);
							emitRM(opPUSH, ac, 0, 0, "array assign: push double value",sizeofdouble);
						}
					}else if(p1->type.type == Integer){
						emitRM(opADD,ac1,ac1,gp, "op: add ixa");
						if(addrFlag){
							emitRM(opLDA,ac,loc,ac1,"array assign: store addr");
							emitRM(opPUSH, ac, 0, 0, "array assign: push addr");
						}else{
							emitRM(opLD,ac,loc,ac1,"array assign: store value");
							emitRM(opPUSH, ac, 0, 0, "array assign: push value");
						}
					}else if(p1->type.type == Char){
						emitRM(opADD,ac1,ac1,gp, "op: add ixa");
						if(addrFlag){
							emitRM(opLDA,ac,loc,ac1,"array assign: store char addr");
							emitRM(opPUSH, ac, 0, 0, "array assign: push char addr");
						}else{
							emitRM(opLD,ac,loc,ac1,"array assign: store char value",sizeofchar);
							emitRM(opPUSH, ac, 0, 0, "array assign: push char value",sizeofchar);
						}
					}
				}if(p1->type.type == Double){
					if(addrFlag){
      					emitRM(opLDA,ac,loc,gp,"load id double addr",sizeofint, flag);
						emitRM(opPUSH, ac, 0, 0, "assign: push double addr");
					}else{
						emitRM(opLD,ac,loc,gp,"load id double value",sizeofdouble, flag);
						emitRM(opPUSH, ac, 0, 0, "assign: push value",sizeofdouble);
					}
				} else if(p1->type.type == Integer){
					if(addrFlag){
						emitRM(opLDA,ac,loc,gp,"load id addr");
						emitRM(opPUSH, ac, 0, 0, "assign: push addr");
					}else{
						emitRM(opLD,ac,loc,gp,"load id value");
						emitRM(opPUSH, ac, 0, 0, "assign: push value");
					}
				} else if(p1->type.type == Char){
					if(addrFlag){
						emitRM(opLDA,ac,loc,gp,"load id char addr",sizeofint);
						emitRM(opPUSH, ac, 0, 0, "assign: push char addr");
					}else{
						emitRM(opLD,ac,loc,gp,"load id char value",sizeofchar);
						emitRM(opPUSH, ac, 0, 0, "assign: push char value",sizeofchar);
					}
				}
      		} else {
      			if(p1->child[0]){
					emitRM(opLDA,bp,base[level-1],sp,"load base top");
					if(p1->type.type == Double){
						emitRM(opADD,ac1,ac1,bp, "op: add ixa");
						if(addrFlag){
		  					emitRM(opLDA,ac,loc,ac1,"array assign: store double addr");
							emitRM(opPUSH, ac, 0, 0, "array assign: push double addr");
						}else{
							emitRM(opLD,ac,loc,ac1,"array assign: store double value",sizeofdouble);
							emitRM(opPUSH, ac, 0, 0, "array assign: push double value",sizeofdouble);
						}
					}else if(p1->type.type == Integer){
						emitRM(opADD,ac1,ac1,bp, "op: add ixa");
						if(addrFlag){
							emitRM(opLDA,ac,loc,ac1,"array assign: store addr");
							emitRM(opPUSH, ac, 0, 0, "array assign: push addr");
						}else{
							emitRM(opLD,ac,loc,ac1,"array assign: store value");
							emitRM(opPUSH, ac, 0, 0, "array assign: push value");
						}
					}else if(p1->type.type == Char){
						emitRM(opADD,ac1,ac1,bp, "op: add ixa");
						if(addrFlag){
							emitRM(opLDA,ac,loc,ac1,"array assign: store char addr");
							emitRM(opPUSH, ac, 0, 0, "array assign: push char addr");
						}else{
							emitRM(opLD,ac,loc,ac1,"array assign: store char value",sizeofchar);
							emitRM(opPUSH, ac, 0, 0, "array assign: push char value",sizeofchar);
						}
					}
				}else if(p1->type.type == Double){
					emitRM(opLDA,bp,base[level-1],sp,"load base top");
					if(addrFlag){
						emitRM(opLDA,ac,loc,bp,"load id double addr",sizeofint, flag);
						emitRM(opPUSH, ac, 0, 0, "assign: push double addr");
					}else{
						emitRM(opLD,ac,loc,bp,"load id double value",sizeofdouble, flag);
						emitRM(opPUSH, ac, 0, 0, "assign: push double value",sizeofdouble);
					}
				} else if(p1->type.type == Integer){
					//printf("addrFlag2: %d\n", addrFlag);
					emitRM(opLDA,bp,base[level-1],sp,"load base top");
					if(addrFlag){
						emitRM(opLDA,ac,loc,bp,"load id addr");
						emitRM(opPUSH, ac, 0, 0, "assign: push addr");
					}else {
						emitRM(opLD,ac,loc,bp,"load id value");
						emitRM(opPUSH, ac, 0, 0, "assign: push value");
					}
				} else if(p1->type.type == Char){
					//printf("addrFlag2: %d\n", addrFlag);
					emitRM(opLDA,bp,base[level-1],sp,"load base top");
					if(addrFlag){
						emitRM(opLDA,ac,loc,bp,"load id char addr", sizeofint);
						emitRM(opPUSH, ac, 0, 0, "assign: push char addr");
					}else {
						emitRM(opLD,ac,loc,bp,"load id char value",sizeofchar);
						emitRM(opPUSH, ac, 0, 0, "assign: push char value",sizeofchar);
					}
				}
      		}
			
			if (TraceCode)  
				emitComment("<- StructIdK") ;
			break;
    
    	case IdK :
      		if (TraceCode) 
				emitComment("-> Id") ;
			level = Lookup_Var(pTable, pTable ->funEntry, tree->attr.name, pEntry);
			loc = pEntry ->offset;
			refFlag = pEntry->refFlag;

			//引用取地址
			if(refFlag && addrFlag){
				emitRM(opLDA,bp,base[level-1],sp,"load ref base top");
				emitRM(opLDA,ac,loc,bp,"add ref loc");
				emitRM(opLD,ac,0,ac,"load ref addr");
				emitRM(opPUSH, ac, 0, 0, "push ref addr");

				if (TraceCode)  
					emitComment("<- Id") ;
				break;
			} else if(refFlag){
				//引用取值
				emitRM(opLDA,bp,base[level-1],sp,"load ref base top");
				emitRM(opLDA,ac,loc,bp,"add ref loc");
				emitRM(opLD,ac,0,ac,"load ref addr");
				if(tree->type.type == Double){
					emitRM(opLD,ac,0,ac,"load ref double value",sizeofdouble);
					emitRM(opPUSH, ac, 0, 0, "push ref double value",sizeofdouble);
				}else if(tree->type.type == Integer){
					emitRM(opLD,ac,0,ac,"load ref value");
					emitRM(opPUSH, ac, 0, 0, "push ref value");
				}else if(tree->type.type == Char){
					emitRM(opLD,ac,0,ac,"load ref char value",sizeofchar);
					emitRM(opPUSH, ac, 0, 0, "push ref char value",sizeofchar);
				}		
			
				if (TraceCode)  
					emitComment("<- Id") ;
				break;
			}

			//数组
			if(tree->child[0]){
				cGen(tree->child[0]);
				emitRM(opPOP, ac, 0, 0, "pop array ixa");
				if(tree->type.type == Double)
					emitRM(opLDC,ac1,sizeofdouble,0,"array load ixa");
				else if(tree->type.type == Integer)
					emitRM(opLDC,ac1,sizeofint,0,"array load ixa");
				else if(tree->type.type == Char)
					emitRM(opLDC,ac1,sizeofchar,0,"array load ixa");
				emitRO(opMUL,ac1,ac1,ac,"array op *");
			}

			//置类型转换标志
			flag = 0;
			if((tree->type.type == Double)&&(pEntry->type.type == Integer))
				flag = 1;
			else if((tree->type.type == Integer)&&(pEntry->type.type == Double))
				flag = 2;

			printf("Name: %s, level: %d flag: %d pLevel:%d loc:%d\n ",tree->attr.name, level, flag,pLevel, loc);
			//printType(tree->type);
			//printType(pEntry->type);