expr.c

把pascal程序转成C语言程序 把pascal程序转成C语言程序

    Expr *ex;

    ex = makeexpr(EK_VAR, 0);
    ex->val.i = (long) mp;
    ex->val.type = mp->type;
    if (debug>2) { fprintf(outf,"makeexpr_var returns "); dumpexpr(ex); fprintf(outf,"\n"); }
    return ex;
}



Expr *makeexpr_name(name, type)
char *name;
Type *type;
{
    Expr *ex;

    ex = makeexpr(EK_NAME, 0);
    ex->val.s = stralloc(name);
    ex->val.type = type;
    if (debug>2) { fprintf(outf,"makeexpr_name returns "); dumpexpr(ex); fprintf(outf,"\n"); }
    return ex;
}



Expr *makeexpr_setbits()
{
    if (*name_SETBITS)
        return makeexpr_name(name_SETBITS, tp_integer);
    else
        return makeexpr_long(setbits);
}



/* Note: BICALL's to the following functions should obey the ANSI standard. */
/*       Non-ANSI transformations occur while writing the expression. */
/*              char *sprintf(buf, fmt, ...)   [returns buf]  */
/*              void *memcpy(dest, src, size)  [returns dest] */

Expr *makeexpr_bicall_0(name, type)
char *name;
Type *type;
{
    Expr *ex;

    if (!name || !*name) {
        intwarning("makeexpr_bicall_0", "Required name of built-in procedure is missing [157]");
        name = "MissingProc";
    }
    ex = makeexpr(EK_BICALL, 0);
    ex->val.s = stralloc(name);
    ex->val.type = type;
    if (debug>2) { fprintf(outf,"makeexpr_bicall returns "); dumpexpr(ex); fprintf(outf,"\n"); }
    return ex;
}


Expr *makeexpr_bicall_1(name, type, arg1)
char *name;
Type *type;
Expr *arg1;
{
    Expr *ex;

    if (!name || !*name) {
        intwarning("makeexpr_bicall_1", "Required name of built-in procedure is missing [157]");
        name = "MissingProc";
    }
    ex = makeexpr(EK_BICALL, 1);
    ex->val.s = stralloc(name);
    ex->val.type = type;
    ex->args[0] = arg1;
    if (debug>2) { fprintf(outf,"makeexpr_bicall returns "); dumpexpr(ex); fprintf(outf,"\n"); }
    return ex;
}


Expr *makeexpr_bicall_2(name, type, arg1, arg2)
char *name;
Type *type;
Expr *arg1, *arg2;
{
    Expr *ex;

    if (!name || !*name) {
        intwarning("makeexpr_bicall_2", "Required name of built-in procedure is missing [157]");
        name = "MissingProc";
    }
    ex = makeexpr(EK_BICALL, 2);
    ex->val.s = stralloc(name);
    ex->val.type = type;
    ex->args[0] = arg1;
    ex->args[1] = arg2;
    if (debug>2) { fprintf(outf,"makeexpr_bicall returns "); dumpexpr(ex); fprintf(outf,"\n"); }
    return ex;
}


Expr *makeexpr_bicall_3(name, type, arg1, arg2, arg3)
char *name;
Type *type;
Expr *arg1, *arg2, *arg3;
{
    Expr *ex;

    if (!name || !*name) {
        intwarning("makeexpr_bicall_3", "Required name of built-in procedure is missing [157]");
        name = "MissingProc";
    }
    ex = makeexpr(EK_BICALL, 3);
    ex->val.s = stralloc(name);
    ex->val.type = type;
    ex->args[0] = arg1;
    ex->args[1] = arg2;
    ex->args[2] = arg3;
    if (debug>2) { fprintf(outf,"makeexpr_bicall returns "); dumpexpr(ex); fprintf(outf,"\n"); }
    return ex;
}


Expr *makeexpr_bicall_4(name, type, arg1, arg2, arg3, arg4)
char *name;
Type *type;
Expr *arg1, *arg2, *arg3, *arg4;
{
    Expr *ex;

    if (!name || !*name) {
        intwarning("makeexpr_bicall_4", "Required name of built-in procedure is missing [157]");
        name = "MissingProc";
    }
    ex = makeexpr(EK_BICALL, 4);
    ex->val.s = stralloc(name);
    ex->val.type = type;
    ex->args[0] = arg1;
    ex->args[1] = arg2;
    ex->args[2] = arg3;
    ex->args[3] = arg4;
    if (debug>2) { fprintf(outf,"makeexpr_bicall returns "); dumpexpr(ex); fprintf(outf,"\n"); }
    return ex;
}


Expr *makeexpr_bicall_5(name, type, arg1, arg2, arg3, arg4, arg5)
char *name;
Type *type;
Expr *arg1, *arg2, *arg3, *arg4, *arg5;
{
    Expr *ex;

    if (!name || !*name) {
        intwarning("makeexpr_bicall_5", "Required name of built-in procedure is missing [157]");
        name = "MissingProc";
    }
    ex = makeexpr(EK_BICALL, 5);
    ex->val.s = stralloc(name);
    ex->val.type = type;
    ex->args[0] = arg1;
    ex->args[1] = arg2;
    ex->args[2] = arg3;
    ex->args[3] = arg4;
    ex->args[4] = arg5;
    if (debug>2) { fprintf(outf,"makeexpr_bicall returns "); dumpexpr(ex); fprintf(outf,"\n"); }
    return ex;
}



Expr *makeexpr_SETIO(flag, code, name)
Expr *flag;
char *code;
Expr *name;
{
    Expr *ecode;

    if (code) {
	ecode = makeexpr_name(code, tp_int);
    } else {
	ecode = name->args[0];
	name = name->args[1];
    }
    if (iocheck_flag) {
	if (name) {
	    if (name->val.type->kind == TK_STRING ||
		name->val.type->kind == TK_ARRAY)
		name = copyexpr(name);
	    else
		name = filenamepart(name);
	}
	if (name)
	    return makeexpr_bicall_3("~~SETIO", tp_void, flag, ecode, name);
	else
	    return makeexpr_bicall_2("~~SETIO", tp_void, flag, ecode);
    } else
	return makeexpr_bicall_2(name_SETIO, tp_void, flag, ecode);
}




Expr *copyexpr(ex)
register Expr *ex;
{
    register int i;
    register Expr *ex2;

    if (ex) {
        ex2 = makeexpr(ex->kind, ex->nargs);
        for (i = 0; i < ex->nargs; i++)
            ex2->args[i] = copyexpr(ex->args[i]);
        switch (ex->kind) {

            case EK_CONST:
            case EK_LONGCONST:
                ex2->val = copyvalue(ex->val);
                break;

            case EK_DOT:
            case EK_NAME:
            case EK_BICALL:
                ex2->val.type = ex->val.type;
                ex2->val.i = ex->val.i;
                if (ex->val.s)
                    ex2->val.s = stralloc(ex->val.s);
                break;

            default:
                ex2->val = ex->val;
                break;
        }
        return ex2;
    } else
        return NULL;
}



int exprsame(a, b, strict)
register Expr *a, *b;
int strict;
{
    register int i;

    if (!a)
        return (!b);
    if (!b)
        return 0;
    if (a->val.type != b->val.type && strict != 2) {
        if (strict ||
	    !((a->val.type->kind == TK_POINTER &&
	       a->val.type->basetype == b->val.type) ||
	      (b->val.type->kind == TK_POINTER &&
	       b->val.type->basetype == a->val.type)))
        return 0;
    }
    if (a->kind != b->kind || a->nargs != b->nargs)
        return 0;
    switch (a->kind) {

        case EK_CONST:
        case EK_LONGCONST:
            if (!valuesame(a->val, b->val))
                return 0;
            break;

        case EK_BICALL:
        case EK_NAME:
            if (strcmp(a->val.s, b->val.s))
                return 0;
            break;

        case EK_VAR:
        case EK_FUNCTION:
        case EK_CTX:
        case EK_MACARG:
            if (a->val.i != b->val.i)
                return 0;
            break;

        case EK_DOT:
            if (a->val.i != b->val.i ||
                (!a->val.i && strcmp(a->val.s, b->val.s)))
                return 0;
            break;

	default:
	    break;
    }
    i = a->nargs;
    while (--i >= 0)
        if (!exprsame(a->args[i], b->args[i], (strict == 2) ? 1 : strict))
            return 0;
    return 1;
}



int exprequiv(a, b)
register Expr *a, *b;
{
    register int i, j, k;
    enum exprkind kind2;

    if (!a)
        return (!b);
    if (!b)
        return 0;
    switch (a->kind) {

        case EK_PLUS:
        case EK_TIMES:
        case EK_BAND:
        case EK_BOR:
        case EK_BXOR:
        case EK_EQ:
        case EK_NE:
            if (b->kind != a->kind || b->nargs != a->nargs ||
                b->val.type != a->val.type)
                return 0;
            if (a->nargs > 3)
                break;
            for (i = 0; i < b->nargs; i++) {
                if (exprequiv(a->args[0], b->args[i])) {
                    for (j = 0; j < b->nargs; j++) {
                        if (j != i &&
                            exprequiv(a->args[1], b->args[i])) {
                            if (a->nargs == 2)
                                return 1;
                            for (k = 0; k < b->nargs; k++) {
                                if (k != i && k != j &&
                                    exprequiv(a->args[2], b->args[k]))
                                    return 1;
                            }
                        }
                    }
                }
            }
            break;

        case EK_LT:
        case EK_GT:
        case EK_LE:
        case EK_GE:
            switch (a->kind) {
                case EK_LT:  kind2 = EK_GT; break;
                case EK_GT:  kind2 = EK_LT; break;
                case EK_LE:  kind2 = EK_GE; break;
                default:     kind2 = EK_LE; break;
            }
            if (b->kind != kind2 || b->val.type != a->val.type)
                break;
            if (exprequiv(a->args[0], b->args[1]) &&
                exprequiv(a->args[1], b->args[0])) {
                return 1;
            }
            break;

        case EK_CONST:
        case EK_LONGCONST:
        case EK_BICALL:
        case EK_NAME:
        case EK_VAR:
        case EK_FUNCTION:
        case EK_CTX:
        case EK_DOT:
            return exprsame(a, b, 0);

	default:
	    break;
    }
    if (b->kind != a->kind || b->nargs != a->nargs ||
        b->val.type != a->val.type)
        return 0;
    i = a->nargs;
    while (--i >= 0)
        if (!exprequiv(a->args[i], b->args[i]))
            return 0;
    return 1;
}



void deletearg(ex, n)
Expr **ex;
register int n;
{
    register Expr *ex1 = *ex, *ex2;
    register int i;

    if (debug>2) { fprintf(outf,"deletearg("); dumpexpr(*ex); fprintf(outf,", %d)\n", n); }
    if (n < 0 || n >= (*ex)->nargs) {
        intwarning("deletearg", "argument number out of range [158]");
        return;
    }
    ex2 = makeexpr(ex1->kind, ex1->nargs-1);
    ex2->val = ex1->val;
    for (i = 0; i < n; i++)
        ex2->args[i] = ex1->args[i];
    for (; i < ex2->nargs; i++)
        ex2->args[i] = ex1->args[i+1];
    *ex = ex2;
    FREE(ex1);
    if (debug>2) { fprintf(outf,"deletearg returns "); dumpexpr(*ex); fprintf(outf,"\n"); }
}



void insertarg(ex, n, arg)
Expr **ex;
Expr *arg;
register int n;
{
    register Expr *ex1 = *ex, *ex2;
    register int i;

    if (debug>2) { fprintf(outf,"insertarg("); dumpexpr(*ex); fprintf(outf,", %d)\n", n); }
    if (n < 0 || n > (*ex)->nargs) {
        intwarning("insertarg", "argument number out of range [159]");
        return;
    }
    ex2 = makeexpr(ex1->kind, ex1->nargs+1);
    ex2->val = ex1->val;
    for (i = 0; i < n; i++)
        ex2->args[i] = ex1->args[i];
    ex2->args[n] = arg;
    for (; i < ex1->nargs; i++)
        ex2->args[i+1] = ex1->args[i];
    *ex = ex2;
    FREE(ex1);
    if (debug>2) { fprintf(outf,"insertarg returns "); dumpexpr(*ex); fprintf(outf,"\n"); }
}



Expr *grabarg(ex, n)
Expr *ex;
int n;
{
    Expr *ex2;

    if (n < 0 || n >= ex->nargs) {
        intwarning("grabarg", "argument number out of range [160]");
        return ex;
    }
    ex2 = ex->args[n];
    ex->args[n] = makeexpr_long(0);   /* placeholder */
    freeexpr(ex);
    return ex2;
}



void delsimparg(ep, n)
Expr **ep;
int n;
{
    if (n < 0 || n >= (*ep)->nargs) {
        intwarning("delsimparg", "argument number out of range [161]");
        return;
    }
    deletearg(ep, n);
    switch ((*ep)->kind) {

        case EK_PLUS:
        case EK_TIMES:
        case EK_COMMA:
            if ((*ep)->nargs == 1)
                *ep = grabarg(*ep, 0);
            break;

	default:
	    break;

    }
}




Expr *resimplify(ex)
Expr *ex;
{
    Expr *ex2;
    Type *type;
    int i;

    if (debug>2) { fprintf(outf,"resimplify("); dumpexpr(ex); fprintf(outf,")\n"); }
    if (!ex)
        return NULL;
    type = ex->val.type;
    switch (ex->kind) {

        case EK_PLUS:
            ex2 = ex->args[0];
            for (i = 1; i < ex->nargs; i++)
                ex2 = makeexpr_plus(ex2, ex->args[i]);
            FREE(ex);
            return ex2;

        case EK_TIMES:
            ex2 = ex->args[0];
            for (i = 1; i < ex->nargs; i++)
                ex2 = makeexpr_times(ex2, ex->args[i]);
            FREE(ex);
            return ex2;

        case EK_NEG:
            ex = makeexpr_neg(grabarg(ex, 0));
            ex->val.type = type;
            return ex;

        case EK_NOT:
            ex = makeexpr_not(grabarg(ex, 0));
            ex->val.type = type;
            return ex;

        case EK_HAT:
            ex = makeexpr_hat(grabarg(ex, 0), 0);
	    if (ex->kind == EK_HAT)
		ex->val.type = type;
            return ex;

        case EK_ADDR:
            ex = makeexpr_addr(grabarg(ex, 0));
            ex->val.type = type;
            return ex;

	case EK_ASSIGN:
	    ex2 = makeexpr_assign(ex->args[0], ex->args[1]);
	    FREE(ex);
	    return ex2;

	default:
	    break;
    }
    return ex;
}






int realzero(s)
register char *s;
{
    if (*s == '-') s++;
    while (*s == '0' || *s == '.') s++;
    return (!isdigit(*s));
}

int realint(s, i)
register char *s;
int i;
{