pexpr.c

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

                case TOK_XOR:
                    gettok();
                    ex2 = p_term(tp_integer);
                    ex = makeexpr_bin(EK_BXOR, ex->val.type, ex, ex2);
                    break;

                default:
                    return ex;
            }
        }
    }
}



Expr *p_rexpr(target)
Type *target;
{
    Expr *ex, *ex2, *ex3, *ex4;
    Type *type;
    Meaning *tvar;
    long mask, smin, smax;
    int i, j;

    if (curtok == TOK_NOT && lowpreclogicals) {
	gettok();
	ex = p_rexpr(target);
	if (ord_type(ex->val.type)->kind == TK_INTEGER)
	    return makeexpr_un(EK_BNOT, tp_integer, ex);
	else
	    return makeexpr_not(ex);
    }
    ex = p_sexpr(target);
    switch (curtok) {

        case TOK_EQ:
            gettok();
            return makeexpr_rel(EK_EQ, ex, p_sexpr(ex->val.type));

        case TOK_NE:
            gettok();
            return makeexpr_rel(EK_NE, ex, p_sexpr(ex->val.type));

        case TOK_LT:
            gettok();
            return makeexpr_rel(EK_LT, ex, p_sexpr(ex->val.type));

        case TOK_GT:
            gettok();
            return makeexpr_rel(EK_GT, ex, p_sexpr(ex->val.type));

        case TOK_LE:
            gettok();
            return makeexpr_rel(EK_LE, ex, p_sexpr(ex->val.type));

        case TOK_GE:
            gettok();
            return makeexpr_rel(EK_GE, ex, p_sexpr(ex->val.type));

        case TOK_IN:
            gettok();
            ex2 = p_sexpr(tp_smallset);
            ex = gentle_cast(ex, ex2->val.type->indextype);
            if (ex2->val.type->kind == TK_SMALLSET) {
                if (!ord_range(ex->val.type, &smin, &smax)) {
                    smin = -1;
                    smax = setbits;
                }
                if (!nosideeffects(ex, 0)) {
                    tvar = makestmttempvar(ex->val.type, name_TEMP);
                    ex3 = makeexpr_assign(makeexpr_var(tvar), ex);
                    ex = makeexpr_var(tvar);
                } else
                    ex3 = NULL;
                ex4 = copyexpr(ex);
                if (ex->kind == EK_CONST && smallsetconst)
                    ex = makesmallsetconst(1L<<ex->val.i, ex2->val.type);
                else
                    ex = makeexpr_bin(EK_LSH, ex2->val.type,
                                      makeexpr_longcast(makeexpr_long(1), 1),
                                      enum_to_int(ex));
                ex = makeexpr_rel(EK_NE, makeexpr_bin(EK_BAND, tp_integer, ex, ex2),
                                         makeexpr_long(0));
                if (*name_SETBITS ||
                    ((ex4->kind == EK_CONST) ? ((unsigned long)ex4->val.i >= setbits)
                                             : !(0 <= smin && smax < setbits))) {
                    ex = makeexpr_and(makeexpr_range(enum_to_int(ex4),
                                                     makeexpr_long(0),
                                                     makeexpr_setbits(), 0),
                                      ex);
                } else
                    freeexpr(ex4);
                ex = makeexpr_comma(ex3, ex);
                return ex;
            } else {
                ex3 = ex2;
                while (ex3->kind == EK_BICALL &&
                       (!strcmp(ex3->val.s, setaddname) ||
                        !strcmp(ex3->val.s, setaddrangename)))
                    ex3 = ex3->args[0];
                if (ex3->kind == EK_BICALL && !strcmp(ex3->val.s, setexpandname) &&
                    (tvar = istempvar(ex3->args[0])) != NULL && 
                    isconstexpr(ex3->args[1], &mask)) {
                    canceltempvar(tvar);
                    if (!nosideeffects(ex, 0)) {
                        tvar = makestmttempvar(ex->val.type, name_TEMP);
                        ex3 = makeexpr_assign(makeexpr_var(tvar), ex);
                        ex = makeexpr_var(tvar);
                    } else
                        ex3 = NULL;
                    type = ord_type(ex2->val.type->indextype);
                    ex4 = NULL;
                    i = 0;
                    while (i < setbits) {
                        if (mask & (1L<<i++)) {
                            if (i+1 < setbits && (mask & (2L<<i))) {
                                for (j = i; j < setbits && (mask & (1L<<j)); j++) ;
                                ex4 = makeexpr_or(ex4,
                                        makeexpr_range(copyexpr(ex),
                                                       makeexpr_val(make_ord(type, i-1)),
                                                       makeexpr_val(make_ord(type, j-1)), 1));
                                i = j;
                            } else {
                                ex4 = makeexpr_or(ex4,
                                        makeexpr_rel(EK_EQ, copyexpr(ex),
                                                            makeexpr_val(make_ord(type, i-1))));
                            }
                        }
                    }
                    mask = 0;
                    for (;;) {
                        if (!strcmp(ex2->val.s, setaddrangename)) {
                            if (checkconst(ex2->args[1], 'a') &&
                                checkconst(ex2->args[2], 'z')) {
                                mask |= 0x1;
                            } else if (checkconst(ex2->args[1], 'A') &&
                                       checkconst(ex2->args[2], 'Z')) {
                                mask |= 0x2;
                            } else if (checkconst(ex2->args[1], '0') &&
                                       checkconst(ex2->args[2], '9')) {
                                mask |= 0x4;
                            } else {
                                ex4 = makeexpr_or(ex4,
                                        makeexpr_range(copyexpr(ex), ex2->args[1], ex2->args[2], 1));
                            }
                        } else if (!strcmp(ex2->val.s, setaddname)) {
                            ex4 = makeexpr_or(ex4,
                                    makeexpr_rel(EK_EQ, copyexpr(ex), ex2->args[1]));
                        } else
                            break;
                        ex2 = ex2->args[0];
                    }
                    /* do these now so that EK_OR optimizations will work: */
                    if (mask & 0x1)
                        ex4 = makeexpr_or(ex4, makeexpr_range(copyexpr(ex),
                                                              makeexpr_char('a'),
                                                              makeexpr_char('z'), 1));
                    if (mask & 0x2)
                        ex4 = makeexpr_or(ex4, makeexpr_range(copyexpr(ex),
                                                              makeexpr_char('A'),
                                                              makeexpr_char('Z'), 1));
                    if (mask & 0x4)
                        ex4 = makeexpr_or(ex4, makeexpr_range(copyexpr(ex),
                                                              makeexpr_char('0'),
                                                              makeexpr_char('9'), 1));
                    freeexpr(ex);
                    return makeexpr_comma(ex3, ex4);
                }
                return makeexpr_bicall_2(setinname, tp_boolean,
                                         makeexpr_arglong(ex, 0), ex2);
            }

	default:
	    return ex;
    }
}



Expr *p_andexpr(target)
Type *target;
{
    Expr *ex = p_rexpr(target);
    Expr *ex2;
    int useshort = 0;

    while (curtok == TOK_AND && (lowpreclogicals || peeknextword("THEN"))) {
	gettok();
	if (curtok == TOK_THEN) {
	    useshort = 1;
	    gettok();
	}
	ex2 = p_rexpr(tp_integer);
	if (ord_type(ex->val.type)->kind == TK_INTEGER)
	    ex = makeexpr_bin(EK_BAND, ex->val.type, ex, ex2);
	else if (partial_eval_flag || useshort ||
		 (shortopt && nosideeffects(ex2, 1)))
	    ex = makeexpr_and(ex, ex2);
	else
	    ex = makeexpr_bin(EK_BAND, tp_boolean, ex, ex2);
    }
    return ex;
}



Expr *p_expr(target)
Type *target;
{
    Expr *ex = p_andexpr(target);
    Expr *ex2;
    int useshort = 0;

    while (curtok == TOK_OR && (lowpreclogicals || peeknextword("ELSE"))) {
	gettok();
	if (curtok == TOK_ELSE) {
	    useshort = 1;
	    gettok();
	}
	ex2 = p_andexpr(tp_integer);
	if (ord_type(ex->val.type)->kind == TK_INTEGER)
	    ex = makeexpr_bin(EK_BOR, ex->val.type, ex, ex2);
	else if (partial_eval_flag || useshort ||
		 (shortopt && nosideeffects(ex2, 1)))
	    ex = makeexpr_or(ex, ex2);
	else
	    ex = makeexpr_bin(EK_BOR, tp_boolean, ex, ex2);
    }
    return ex;
}






/* Parse a C expression; used by VarMacro, etc. */

Type *nametotype(name)
char *name;
{
    if (!strcicmp(name, "malloc") ||
	!strcicmp(name, mallocname)) {
	return tp_anyptr;
    }
    return tp_integer;
}


int istypespec(iscast)
int iscast;
{
    char *cp;

    switch (curtok) {

        case TOK_CONST:
            return 1;

        case TOK_IDENT:
	    cp = peeknextptr();
	    if (*cp == ')' && iscast) {
		while (isspace(*++cp)) ;
		if (*cp == '(' || isalnum(*cp)) {
		    return 1;   /* assume (x)(y) is a cast */
		}
	    }
            return !strcmp(curtokcase, "volatile") ||
                   !strcmp(curtokcase, "void") ||
                   !strcmp(curtokcase, "char") ||
                   !strcmp(curtokcase, "short") ||
                   !strcmp(curtokcase, "int") ||
                   !strcmp(curtokcase, "long") ||
                   !strcmp(curtokcase, "float") ||
                   !strcmp(curtokcase, "double") ||
                   !strcmp(curtokcase, "signed") ||
                   !strcmp(curtokcase, "unsigned") ||
                   !strcmp(curtokcase, "struct") ||
                   !strcmp(curtokcase, "union") ||
                   !strcmp(curtokcase, "class") ||
                   !strcmp(curtokcase, "enum") ||
                   !strcmp(curtokcase, "typedef") ||
                   (curtokmeaning &&
                    curtokmeaning->kind == MK_TYPE);

        default:
            return 0;
    }
}



Expr *pc_parentype(cp)
char *cp;
{
    Expr *ex;

    if (curtok == TOK_IDENT &&
         curtokmeaning &&
         curtokmeaning->kind == MK_TYPE) {
        ex = makeexpr_type(curtokmeaning->type);
        gettok();
        skipcloseparen();
    } else if (curtok == TOK_IDENT && !strcmp(curtokcase, "typedef")) {
        ex = makeexpr_name(getparenstr(inbufptr), tp_integer);
        gettok();
    } else {
        ex = makeexpr_name(getparenstr(cp), tp_integer);
        gettok();
    }
    return ex;
}


Expr *pc_typename()
{
    Type *tp;
    int sign = 0;

    if (!strcmp(curtokcase, "signed")) {
	sign = 1;
	gettok();
    } else if (!strcmp(curtokcase, "unsigned")) {
	sign = -1;
	gettok();
    } else if (!strcmp(curtokcase, "struct") || !strcmp(curtokcase, "union") ||
	       !strcmp(curtokcase, "class") || !strcmp(curtokcase, "enum"))
	gettok();
    if (!strcmp(curtokcase, "void"))
	tp = tp_void;
    else if (!strcmp(curtokcase, "char"))
	tp = (sign > 0) ? tp_schar : (sign < 0) ? tp_uchar : tp_char; 
    else if (!strcmp(curtokcase, "short"))
	tp = (sign >= 0) ? tp_sshort : tp_ushort;
    else if (!strcmp(curtokcase, "int"))
	tp = (sign >= 0) ? tp_int : tp_uint;
    else if (!strcmp(curtokcase, "long"))
	tp = (sign >= 0) ? tp_integer : tp_unsigned;
    else if (!strcmp(curtokcase, "float"))
	tp = tp_real;
    else if (!strcmp(curtokcase, "double"))
	tp = tp_longreal;
    else if (curtokmeaning && curtokmeaning->kind == MK_TYPE)
	tp = curtokmeaning->type;
    else {
	warning("Unrecognized C type name [339]");
	return makeexpr_name(curtokcase, tp_integer);
    }
    gettok();
    if (curtok == TOK_IDENT && !strcmp(curtokcase, "int"))
	gettok();
    while (curtok == TOK_STAR) {
	tp = makepointertype(tp);
	gettok();
    }
    return makeexpr_type(tp);
}



Expr *pc_expr2();

Expr *pc_factor()
{
    Expr *ex;
    char *cp;
    Strlist *sl;
    int i;

    switch (curtok) {

        case TOK_BANG:
            gettok();
            return makeexpr_not(pc_expr2(14));

        case TOK_TWIDDLE:
            gettok();
            return makeexpr_un(EK_BNOT, tp_integer, pc_expr2(14));

        case TOK_PLPL:
            gettok();
            ex = pc_expr2(14);
            return makeexpr_assign(ex, makeexpr_plus(copyexpr(ex), makeexpr_long(1)));

        case TOK_MIMI:
            gettok();
            ex = pc_expr2(14);
            return makeexpr_assign(ex, makeexpr_minus(copyexpr(ex), makeexpr_long(1)));

        case TOK_STAR:
            gettok();
            ex = pc_expr2(14);
            if (ex->val.type->kind != TK_POINTER)
                ex->val.type = makepointertype(ex->val.type);
            return makeexpr_hat(ex, 0);

        case TOK_AMP:
            gettok();
            return makeexpr_addr(pc_expr2(14));

        case TOK_PLUS:
            gettok();
            return pc_expr2(14);

        case TOK_MINUS:
            gettok();
            return makeexpr_neg(pc_expr2(14));

        case TOK_LPAR:
            cp = inbufptr;
            gettok();
            if (istypespec(1)) {
                ex = pc_parentype(cp);
                return makeexpr_bin(EK_LITCAST, tp_integer, ex, pc_expr2(14));
            }
            ex = pc_expr();
            skipcloseparen();
            return ex;

        case TOK_IDENT:
            if (!strcmp(curtokcase, "sizeof")) {
                gettok();
                if (curtok != TOK_LPAR)
                    return makeexpr_sizeof(pc_expr2(14), 1);
                cp = inbufptr;
                gettok();
                if (istypespec(0)) {
                    ex = makeexpr_sizeof(pc_parentype(cp), 1);
                } else {
                    ex = makeexpr_sizeof(pc_expr(), 1);
                    skipcloseparen();
                }
                return ex;
            }