x86dos.c

浙江大学编译原理课程设计源代码,高等院校计算机专业

            break;
        case TYPE_ARRAY:
            if(p->type_link->last->type->type_id ==
                    TYPE_INTEGER
                    || p->type_link->last->type->type_id ==
                    TYPE_BOOLEAN)
                sprintf(tp, "word	ptr");
            else if (p->type_link->last->type->type_id == TYPE_CHAR)
                sprintf(tp, "byte	ptr");
            break;
        case TYPE_RECORD:
            sprintf(tp, "byte  ptr");
            break;
        default:
            break;
        }
        fprintf(codfp,"	%s\t\tequ\t%s	[bp-%04xh]\n",
                p->rname,tp,p->offset);
    }

    fprintf(codfp,";arguments in %s\n", ptab->name);
    for(p = ptab->args;p ;p = p->next)
    {
        switch(p->type->type_id)
        {
        case    TYPE_CHAR:
            sprintf(tp, "byte  ptr");
            break;
        case    TYPE_INTEGER:
        case    TYPE_BOOLEAN:
            sprintf(tp, "word  ptr");
            break;
        case    TYPE_REAL:
            sprintf(tp, "dword  ptr");
            break;
        default:
            break;
        }
        fprintf(codfp,"%s\t\tequ\t%s	[bp+%04xh]\n",
                p->rname, tp, p->offset);
    }
}

static void emit_dos_routine_epilogue(symtab *ptab)
{
    if(ptab->defn == DEF_PROG)
        return;
    if(ptab->defn == DEF_FUNCT)
    {
        switch(ptab->type->type_id)
        {
        case  TYPE_INTEGER:
        case  TYPE_BOOLEAN:
            fprintf(codfp,"\n\t\tmov\tax, word ptr %s\n",LABEL_RETVAL);
            break;
        case  TYPE_CHAR:
            fprintf(codfp,"\n\t\tmov\tah, 0\n");
            fprintf(codfp,"\n\t\tmov\tax, byte  ptr %s\n",
                    LABEL_RETVAL);
            break;
        case  TYPE_REAL:
            fprintf(codfp,"\n\t\tmov\tax,%s\n",
                    LABEL_RETVAL);
            fprintf(codfp,"\n\t\tmov\tdx,%s\n",
                    LABEL_HIRETVAL);
            break;
        }
    }
    fprintf(codfp,"\t\tmov\tsp,bp\n");
    fprintf(codfp,"\t\tpop\tbp\n");
    fprintf(codfp,"\t\tret\t%04xh\n",ptab->args_size + 2);
    fprintf(codfp,"\n%s\t\tendp\n",ptab->rname);
}

static void emit_dos_dos_push_op(Type ptype)
{
    switch(ptype->type_id)
    {
    case  TYPE_CHAR:
    case  TYPE_BOOLEAN:
    case  TYPE_INTEGER:
        fprintf(codfp,"\t\tpush\tax\n");
        break;
    case  TYPE_REAL:
        fprintf(codfp,"\t\tpush\tdx\n");
        fprintf(codfp,"\t\tpush\tax\n");
        break;
    }
}

static void emit_dos_load_value(symbol *p)
{
    if(p->defn == DEF_VARPARA)
    {
        fprintf(codfp,"\t\tmov\tbx,word ptr [bp+4]\n");
        switch(p->type->type_id)
        {
        case  TYPE_CHAR:
            fprintf(codfp,"\t\txor\tah, ah\n");
            fprintf(codfp,"\t\tmov\tal, byte ptr [bx]\n");
            break;
        case TYPE_REAL:
            fprintf(codfp,"\t\tmov\tax,word ptr [bx]\n");
            fprintf(codfp,"\t\tmov\tdx,word ptr [bx+2]\n");
            break;
        case  TYPE_INTEGER:
        case  TYPE_BOOLEAN:
            fprintf(codfp,"\t\tmov\tax,word ptr [bx]\n");
            break;
        }
    }
    else if (p->tab->level==0
             ||p->tab==top_symtab_stack())
    {
        switch(p->type->type_id)
        {
        case  TYPE_CHAR:
            fprintf(codfp,"\t\tsub\tax, ax\n");
            fprintf(codfp,"\b\t\tmov\tal, byte  ptr %s\n"
                    ,p->rname);
            break;
        case  	TYPE_REAL:
            fprintf(codfp,"\t\t\tmov\tax, word ptr %s\n",p->rname);
            fprintf(codfp,"\t\t\tmov\tdx, word ptr %s+2\n",p->rname);
            break;
        case  	TYPE_INTEGER:
        case  	TYPE_BOOLEAN:
            fprintf(codfp,"\t\t\tmov\tax, word ptr %s\n",p->rname);
            break;
        case  	TYPE_ARRAY:
            fprintf(codfp,"\t\tpop\tbx\n");
            if(p->type_link->last->type->type_id ==
                    TYPE_INTEGER
                    ||p->type_link->last->type->type_id ==
                    TYPE_BOOLEAN)
                fprintf(codfp, "\t\tmov\tax,word ptr [bx]\n");
            else if (p->type_link->last->type->type_id ==
                     TYPE_CHAR)
                fprintf(codfp, "\t\tmov\tal,byte ptr [bx]\n");
            break;
        default:
            break;
        }
    }
}

static void emit_dos_load_address(symbol *p)
{
    symtab *ptab;
    int  n,i;

    switch(p->defn)
    {
    case DEF_VARPARA:
        fprintf(codfp, "\t\tmov\tax,word ptr %s\n",
                p->rname);
        break;

    case DEF_VAR:
        if(p->tab->level == 0
                || p->tab == top_symtab_stack())
        {
            /*
            fprintf(codfp, "\t\tmov\tax,word ptr %s\n",
            		p->rname);
            */
            fprintf(codfp, "\t\tlea\tax,word ptr %s\n",
                    p->rname);
        }
        else
        {
            ptab = top_symtab_stack();
            n = p->tab->level - ptab->level + 1;
            fprintf(codfp,"\t\tmov\tbx,bp\n");
            for (i = 0; i < n; i++)
                fprintf(codfp, "\t\tmov\tbp,%s\n",
                        LABEL_SLINK);
            fprintf(codfp, "\t\tlea\tax,word ptr %s\n",
                    p->rname);
            fprintf(codfp,"\t\tmov\tbp,bx\n");
        }
        break;
    case DEF_VALPARA:
        fprintf(codfp, "\t\tlea\tax,word ptr %s\n",
                p->rname);
        break;
    default:
        break;
    }
}

static void emit_dos_load_field(symbol*p)
{
    if(!p)
        return;
    fprintf(codfp, "\t\tpop\tbx\n");
    switch(p->type->type_id)
    {
    case  TYPE_INTEGER:
    case  TYPE_BOOLEAN:
        fprintf(codfp,"\t\tmov\tax,word ptr [bx]\n");
        break;
    case  TYPE_CHAR:
        fprintf(codfp,"\t\tmov\tal,byte ptr [bx]\n");
        break;
    default:
        break;
    }
}

#if 0
static int pop_stmt_stack()
{
    if(stmt_tos==STMT_STACK_SIZE)
        internal_error("Satement stack underflow.\n");
    return stmt_stack[++stmt_tos];
}

static void push_stmt_stack(int index)
{
    if(stmt_tos==0)
        internal_error("Satement stack overflow.\n");
    stmt_stack[stmt_tos--] = index;
}

static int top_stmt_stack()
{
    return stmt_stack[stmt_tos + 1];
}
#endif

static void do_dos_function_assign(symtab *ptab, int srctype)
{
    if(!ptab)
        return;

    if(ptab->type->type_id != srctype)
    {
        parse_error("operand type to not match operator.", "");
        return;
    }
    switch(ptab->type->type_id)
    {
    case  TYPE_CHAR:
        fprintf(codfp,"\t\txor\tah,ah\n");
        fprintf(codfp,"\t\tmov\tbyte ptr %s,al\n",
                LABEL_RETVAL);
        break;
    case  TYPE_BOOLEAN:
    case  TYPE_INTEGER:
        fprintf(codfp,"\t\tmov\tword ptr %s,ax\n",
                LABEL_RETVAL);
        break;
    case  TYPE_REAL:
        fprintf(codfp,"\t\tmov\tword ptr %s,ax\n",
                LABEL_RETVAL);
        fprintf(codfp,"\t\tmov\tword ptr %s,ax\n",
                LABEL_HIRETVAL);
        break;
    default:
        break;
    }
}

static void do_dos_procedure_call(symtab *ptab)
{
    symtab *caller = top_symtab_stack();
    symtab *callee = ptab;
    int n ;
    int i ;

    if(!caller || !callee)
    {
        parse_error("Undeclared procedure","");
        return;
    }

    n = (callee->level) -(caller->level) + 1;
    if(callee->level == caller->level + 1)
    {
        fprintf(codfp,"\t\tpush\tbp\n");
    }
    else if (callee->level == caller->level)
    {
        fprintf(codfp, "\t\tpush\t%s\n",
                LABEL_SLINK);
    }
    else if(callee->level < caller->level)
    {
        fprintf(codfp,"\t\tmov\tbx,bp\n");
        for(i = 0; i < n; i++)
            fprintf(codfp,"\t\tmov\tbp,%s\n",
                    LABEL_SLINK);
        fprintf(codfp,"\t\tpush\tbp\n");
        fprintf(codfp,"\t\tmov\tbp,bx\n");
    }
    else
        return;
    fprintf(codfp,"\t\tcall\t%s\n", ptab->rname);
}

#if 0
static void reset_args(symtab *ptab)
{
    rtn = ptab;
}
#endif

static void do_dos_first_arg(int ptype)
{

    rtn = top_call_stack();
    if(rtn)
        arg = rtn->args;
    else
        return;
    if(!arg)
        return;

    switch(arg->type->type_id)
    {
    case  TYPE_REAL:
        if (ptype != TYPE_REAL)
            fprintf(codfp,"\t\txor\tdx,dx\n");
        fprintf(codfp,"\t\tpush\tdx\n");
        fprintf(codfp,"\t\tpush\tax\n");
        break;
    case  TYPE_CHAR:
        fprintf(codfp,"\t\txor\tah,ah\n");
    case  TYPE_INTEGER:
    case  TYPE_BOOLEAN:
    default:
        fprintf(codfp,"\t\tpush\tax\n");
        break;
    }
}

static void do_dos_args(int ptype)
{
    arg = top_call_symbol();

    if(arg->next)
        arg = arg->next;
    else
        return;
    set_call_stack_top(arg);
    switch(arg->type->type_id)
    {
    case  TYPE_REAL:
        if (ptype!=TYPE_REAL)
            fprintf(codfp,"\t\txor\tdx,dx\n");
        fprintf(codfp,"\t\tpush\tdx\n");
        fprintf(codfp,"\t\tpush\tax\n");
        break;
    case TYPE_CHAR:
        fprintf(codfp,"\t\txor\tah, ah\n");
    case  TYPE_INTEGER:
    case  TYPE_BOOLEAN:
    default:
        fprintf(codfp,"\t\tpush\tax\n");
        break;
    }
}

static void do_dos_assign(symbol *p, int srctype)
{

    symtab *ptab;

    int  n,i;
    
	if (!p)
        return;

	if ((p->type->type_id != TYPE_ARRAY) 
			&& (p->type->type_id != TYPE_RECORD)
			&& (p->type->type_id != srctype))
    {
        parse_error("operand type do not match operator.","");
        return;
    }

    if((p->type->type_id == TYPE_ARRAY) 
		&& (srctype != p->type->first->type->type_id))
    {
        parse_error("operand type do not match operator.","");
        return;
    }

    if((p->type->type_id == TYPE_RECORD)) 
    {
        parse_error("operand type do not match operator.","");
        return;
    }

    switch(p->defn)
    {
    case DEF_VARPARA:
        fprintf(codfp,"\t\tpush\tax\n");
        fprintf(codfp,"\t\tmov\tax,word ptr %s\n",
                p->rname);
        break;
    case DEF_FIELD:
        fprintf(codfp,"\t\tpop\tbx\n");
        if(p->type->type_id == TYPE_INTEGER
                ||p->type->type_id == TYPE_BOOLEAN)
            fprintf(codfp,"\t\tmov\tword ptr [bx],ax\n");
        else if (p->type->type_id == TYPE_CHAR)
            fprintf(codfp,"\t\tmov\tbyte ptr [bx],al\n");
        return;
    case DEF_VAR:
    case DEF_CONST:
    case DEF_ELEMENT:
        if(p->type->type_id==TYPE_ARRAY)
        {
            fprintf(codfp,"\t\tpush\tax\n");
            break;
        }
        if(p->tab->level == 0
                ||p->type->type_id == TYPE_REAL)
            break;
        else if( p->tab->level
                 && p->tab == top_symtab_stack())
        {
            fprintf(codfp,"\t\tpush\tax\n");
            fprintf(codfp,"\t\tlea\tax,word ptr %s\n",
                    p->rname);
            fprintf(codfp,"\t\tpush\tax\n");
            break;
        }
        else
        {
            ptab = top_symtab_stack();
            n = ptab->level - p->tab->level;
            fprintf(codfp,"\t\tpush\tax\n");
            fprintf(codfp,"\t\tmov\tbx,bp\n");
            for(i =0;i<n;i++)
                fprintf(codfp,"\t\tmov\tbp,%s\n",
                        LABEL_SLINK);
            fprintf(codfp,"\t\tlea\tax,word ptr %s\n",
                    p->rname);
            fprintf(codfp,"\t\tmov\tbp,bx\n");
            fprintf(codfp,"\t\tpush\tax\n");
        }
        break;
    case DEF_VALPARA:
        if(p->tab->level==0
                || p->tab==top_symtab_stack())
            fprintf(codfp,"\t\tpush\tax\n");
        fprintf(codfp,"\t\tlea\tax,word ptr %s\n",
                p->rname);
        fprintf(codfp,"\t\rpush\tax\n");
        break;
    default:
        parse_error("lvalue expected.","");
        break;
    }

    switch(p->type->type_id)
    {
    case TYPE_CHAR:
        if(p->tab->level)
        {
            fprintf(codfp,"\t\tpop\tbx\n");
            fprintf(codfp,"\t\tpop\tax\n");
            fprintf(codfp,"\tmov\tbyte ptr [bx],al\n");
        }
        else
            fprintf(codfp,"\t\tmov\tbyte ptr %s,al\n",
                    p->rname);

        break;
    case TYPE_INTEGER: