void print_slotstmt (SlotStmt* s) {
switch(s->tag) {
case VAR_STMT: {
SlotVar* s2 = (SlotVar*)s;
printf("var %s = ", s2->name);
print_exp(s2->exp);
break;
}
case FN_STMT: {
SlotMethod* s2 = (SlotMethod*)s;
printf("method %s (", s2->name);
for(int i=0; i<s2->nargs; i++) {
if(i>0) printf(", ");
printf("%s", s2->args[i]);
}
printf(") : (");
print_scopestmt(s2->body);
printf(")");
break;
}
default:
printf("Unrecognized slot statement with tag %d\n", s->tag);
exit(-1);
}
}
void print_scopestmt (ScopeStmt* s) {
switch(s->tag) {
case VAR_STMT: {
ScopeVar* s2 = (ScopeVar*)s;
printf("var %s = ", s2->name);
print_exp(s2->exp);
break;
}
case FN_STMT: {
ScopeFn* s2 = (ScopeFn*)s;
printf("defn %s (", s2->name);
for(int i=0; i<s2->nargs; i++) {
if(i>0) printf(", ");
printf("%s", s2->args[i]);
}
printf(") : (");
print_scopestmt(s2->body);
printf(")");
break;
}
case SEQ_STMT: {
ScopeSeq* s2 = (ScopeSeq*)s;
print_scopestmt(s2->a);
printf(" ");
print_scopestmt(s2->b);
break;
}
case EXP_STMT: {
ScopeExp* s2 = (ScopeExp*)s;
print_exp(s2->exp);
break;
}
default:
printf("Unrecognized scope statement with tag %d\n", s->tag);
exit(-1);
}
}
void
print_pattern (pretty_printer *pp, const_rtx x, int verbose)
{
if (! x)
{
pp_string (pp, "(nil)");
return;
}
switch (GET_CODE (x))
{
case SET:
print_value (pp, SET_DEST (x), verbose);
pp_equal (pp);
print_value (pp, SET_SRC (x), verbose);
break;
case RETURN:
case SIMPLE_RETURN:
case EH_RETURN:
pp_string (pp, GET_RTX_NAME (GET_CODE (x)));
break;
case CALL:
print_exp (pp, x, verbose);
break;
case CLOBBER:
case USE:
pp_printf (pp, "%s ", GET_RTX_NAME (GET_CODE (x)));
print_value (pp, XEXP (x, 0), verbose);
break;
case VAR_LOCATION:
pp_string (pp, "loc ");
print_value (pp, PAT_VAR_LOCATION_LOC (x), verbose);
break;
case COND_EXEC:
pp_left_paren (pp);
if (GET_CODE (COND_EXEC_TEST (x)) == NE
&& XEXP (COND_EXEC_TEST (x), 1) == const0_rtx)
print_value (pp, XEXP (COND_EXEC_TEST (x), 0), verbose);
else if (GET_CODE (COND_EXEC_TEST (x)) == EQ
&& XEXP (COND_EXEC_TEST (x), 1) == const0_rtx)
{
pp_exclamation (pp);
print_value (pp, XEXP (COND_EXEC_TEST (x), 0), verbose);
}
else
print_value (pp, COND_EXEC_TEST (x), verbose);
pp_string (pp, ") ");
print_pattern (pp, COND_EXEC_CODE (x), verbose);
break;
case PARALLEL:
{
int i;
pp_left_brace (pp);
for (i = 0; i < XVECLEN (x, 0); i++)
{
print_pattern (pp, XVECEXP (x, 0, i), verbose);
pp_semicolon (pp);
}
pp_right_brace (pp);
}
break;
case SEQUENCE:
{
pp_string (pp, "sequence{");
if (INSN_P (XVECEXP (x, 0, 0)))
{
/* Print the sequence insns indented. */
const char * save_print_rtx_head = print_rtx_head;
char indented_print_rtx_head[32];
pp_newline (pp);
gcc_assert (strlen (print_rtx_head) < sizeof (indented_print_rtx_head) - 4);
snprintf (indented_print_rtx_head,
sizeof (indented_print_rtx_head),
"%s ", print_rtx_head);
print_rtx_head = indented_print_rtx_head;
for (int i = 0; i < XVECLEN (x, 0); i++)
print_insn_with_notes (pp, XVECEXP (x, 0, i));
pp_printf (pp, "%s ", save_print_rtx_head);
print_rtx_head = save_print_rtx_head;
}
else
{
for (int i = 0; i < XVECLEN (x, 0); i++)
{
print_pattern (pp, XVECEXP (x, 0, i), verbose);
pp_semicolon (pp);
}
}
pp_right_brace (pp);
}
break;
case ASM_INPUT:
pp_printf (pp, "asm {%s}", XSTR (x, 0));
break;
case ADDR_VEC:
/* Fall through. */
case ADDR_DIFF_VEC:
print_value (pp, XEXP (x, 0), verbose);
break;
case TRAP_IF:
pp_string (pp, "trap_if ");
print_value (pp, TRAP_CONDITION (x), verbose);
break;
case UNSPEC:
case UNSPEC_VOLATILE:
/* Fallthru -- leave UNSPECs to print_exp. */
default:
print_value (pp, x, verbose);
}
} /* print_pattern */
void
print_value (pretty_printer *pp, const_rtx x, int verbose)
{
char tmp[1024];
if (!x)
{
pp_string (pp, "(nil)");
return;
}
switch (GET_CODE (x))
{
case CONST_INT:
pp_scalar (pp, HOST_WIDE_INT_PRINT_HEX,
(unsigned HOST_WIDE_INT) INTVAL (x));
break;
case CONST_DOUBLE:
if (FLOAT_MODE_P (GET_MODE (x)))
{
real_to_decimal (tmp, CONST_DOUBLE_REAL_VALUE (x),
sizeof (tmp), 0, 1);
pp_string (pp, tmp);
}
else
pp_printf (pp, "<%wx,%wx>",
(unsigned HOST_WIDE_INT) CONST_DOUBLE_LOW (x),
(unsigned HOST_WIDE_INT) CONST_DOUBLE_HIGH (x));
break;
case CONST_FIXED:
fixed_to_decimal (tmp, CONST_FIXED_VALUE (x), sizeof (tmp));
pp_string (pp, tmp);
break;
case CONST_STRING:
pp_printf (pp, "\"%s\"", XSTR (x, 0));
break;
case SYMBOL_REF:
pp_printf (pp, "`%s'", XSTR (x, 0));
break;
case LABEL_REF:
pp_printf (pp, "L%d", INSN_UID (XEXP (x, 0)));
break;
case CONST:
case HIGH:
case STRICT_LOW_PART:
pp_printf (pp, "%s(", GET_RTX_NAME (GET_CODE (x)));
print_value (pp, XEXP (x, 0), verbose);
pp_right_paren (pp);
break;
case REG:
if (REGNO (x) < FIRST_PSEUDO_REGISTER)
{
if (ISDIGIT (reg_names[REGNO (x)][0]))
pp_modulo (pp);
pp_string (pp, reg_names[REGNO (x)]);
}
else
pp_printf (pp, "r%d", REGNO (x));
if (verbose)
pp_printf (pp, ":%s", GET_MODE_NAME (GET_MODE (x)));
break;
case SUBREG:
print_value (pp, SUBREG_REG (x), verbose);
pp_printf (pp, "#%d", SUBREG_BYTE (x));
break;
case SCRATCH:
case CC0:
case PC:
pp_string (pp, GET_RTX_NAME (GET_CODE (x)));
break;
case MEM:
pp_left_bracket (pp);
print_value (pp, XEXP (x, 0), verbose);
pp_right_bracket (pp);
break;
case DEBUG_EXPR:
pp_printf (pp, "D#%i", DEBUG_TEMP_UID (DEBUG_EXPR_TREE_DECL (x)));
break;
default:
print_exp (pp, x, verbose);
break;
}
} /* print_value */
void
print_pattern (char *buf, const_rtx x, int verbose)
{
char t1[BUF_LEN], t2[BUF_LEN], t3[BUF_LEN];
switch (GET_CODE (x))
{
case SET:
print_value (t1, SET_DEST (x), verbose);
print_value (t2, SET_SRC (x), verbose);
sprintf (buf, "%s=%s", t1, t2);
break;
case RETURN:
sprintf (buf, "return");
break;
case SIMPLE_RETURN:
sprintf (buf, "simple_return");
break;
case CALL:
print_exp (buf, x, verbose);
break;
case CLOBBER:
print_value (t1, XEXP (x, 0), verbose);
sprintf (buf, "clobber %s", t1);
break;
case USE:
print_value (t1, XEXP (x, 0), verbose);
sprintf (buf, "use %s", t1);
break;
case VAR_LOCATION:
print_value (t1, PAT_VAR_LOCATION_LOC (x), verbose);
sprintf (buf, "loc %s", t1);
break;
case COND_EXEC:
if (GET_CODE (COND_EXEC_TEST (x)) == NE
&& XEXP (COND_EXEC_TEST (x), 1) == const0_rtx)
print_value (t1, XEXP (COND_EXEC_TEST (x), 0), verbose);
else if (GET_CODE (COND_EXEC_TEST (x)) == EQ
&& XEXP (COND_EXEC_TEST (x), 1) == const0_rtx)
{
t1[0] = '!';
print_value (t1 + 1, XEXP (COND_EXEC_TEST (x), 0), verbose);
}
else
print_value (t1, COND_EXEC_TEST (x), verbose);
print_pattern (t2, COND_EXEC_CODE (x), verbose);
sprintf (buf, "(%s) %s", t1, t2);
break;
case PARALLEL:
{
int i;
sprintf (t1, "{");
for (i = 0; i < XVECLEN (x, 0); i++)
{
print_pattern (t2, XVECEXP (x, 0, i), verbose);
sprintf (t3, "%s%s;", t1, t2);
strcpy (t1, t3);
}
sprintf (buf, "%s}", t1);
}
break;
case SEQUENCE:
/* Should never see SEQUENCE codes until after reorg. */
gcc_unreachable ();
case ASM_INPUT:
sprintf (buf, "asm {%s}", XSTR (x, 0));
break;
case ADDR_VEC:
/* Fall through. */
case ADDR_DIFF_VEC:
print_value (buf, XEXP (x, 0), verbose);
break;
case TRAP_IF:
print_value (t1, TRAP_CONDITION (x), verbose);
sprintf (buf, "trap_if %s", t1);
break;
case UNSPEC:
{
int i;
sprintf (t1, "unspec{");
for (i = 0; i < XVECLEN (x, 0); i++)
{
print_pattern (t2, XVECEXP (x, 0, i), verbose);
sprintf (t3, "%s%s;", t1, t2);
strcpy (t1, t3);
}
sprintf (buf, "%s}", t1);
}
break;
case UNSPEC_VOLATILE:
{
int i;
sprintf (t1, "unspec/v{");
for (i = 0; i < XVECLEN (x, 0); i++)
{
print_pattern (t2, XVECEXP (x, 0, i), verbose);
sprintf (t3, "%s%s;", t1, t2);
strcpy (t1, t3);
}
sprintf (buf, "%s}", t1);
}
break;
default:
print_value (buf, x, verbose);
}
} /* print_pattern */
void
print_value (char *buf, const_rtx x, int verbose)
{
char t[BUF_LEN];
char *cur = buf;
if (!x)
{
safe_concat (buf, buf, "(nil)");
return;
}
switch (GET_CODE (x))
{
case CONST_INT:
sprintf (t, HOST_WIDE_INT_PRINT_HEX,
(unsigned HOST_WIDE_INT) INTVAL (x));
cur = safe_concat (buf, cur, t);
break;
case CONST_DOUBLE:
if (FLOAT_MODE_P (GET_MODE (x)))
real_to_decimal (t, CONST_DOUBLE_REAL_VALUE (x), sizeof (t), 0, 1);
else
sprintf (t,
"<" HOST_WIDE_INT_PRINT_HEX "," HOST_WIDE_INT_PRINT_HEX ">",
(unsigned HOST_WIDE_INT) CONST_DOUBLE_LOW (x),
(unsigned HOST_WIDE_INT) CONST_DOUBLE_HIGH (x));
cur = safe_concat (buf, cur, t);
break;
case CONST_FIXED:
fixed_to_decimal (t, CONST_FIXED_VALUE (x), sizeof (t));
cur = safe_concat (buf, cur, t);
break;
case CONST_STRING:
cur = safe_concat (buf, cur, "\"");
cur = safe_concat (buf, cur, XSTR (x, 0));
cur = safe_concat (buf, cur, "\"");
break;
case SYMBOL_REF:
cur = safe_concat (buf, cur, "`");
cur = safe_concat (buf, cur, XSTR (x, 0));
cur = safe_concat (buf, cur, "'");
break;
case LABEL_REF:
sprintf (t, "L%d", INSN_UID (XEXP (x, 0)));
cur = safe_concat (buf, cur, t);
break;
case CONST:
print_value (t, XEXP (x, 0), verbose);
cur = safe_concat (buf, cur, "const(");
cur = safe_concat (buf, cur, t);
cur = safe_concat (buf, cur, ")");
break;
case HIGH:
print_value (t, XEXP (x, 0), verbose);
cur = safe_concat (buf, cur, "high(");
cur = safe_concat (buf, cur, t);
cur = safe_concat (buf, cur, ")");
break;
case REG:
if (REGNO (x) < FIRST_PSEUDO_REGISTER)
{
int c = reg_names[REGNO (x)][0];
if (ISDIGIT (c))
cur = safe_concat (buf, cur, "%");
cur = safe_concat (buf, cur, reg_names[REGNO (x)]);
}
else
{
sprintf (t, "r%d", REGNO (x));
cur = safe_concat (buf, cur, t);
}
if (verbose
#ifdef INSN_SCHEDULING
&& !current_sched_info
#endif
)
{
sprintf (t, ":%s", GET_MODE_NAME (GET_MODE (x)));
cur = safe_concat (buf, cur, t);
}
break;
case SUBREG:
print_value (t, SUBREG_REG (x), verbose);
cur = safe_concat (buf, cur, t);
sprintf (t, "#%d", SUBREG_BYTE (x));
cur = safe_concat (buf, cur, t);
break;
case STRICT_LOW_PART:
print_value (t, XEXP (x, 0), verbose);
cur = safe_concat (buf, cur, "strict_low_part(");
cur = safe_concat (buf, cur, t);
cur = safe_concat (buf, cur, ")");
break;
case SCRATCH:
cur = safe_concat (buf, cur, "scratch");
break;
case CC0:
cur = safe_concat (buf, cur, "cc0");
break;
case PC:
cur = safe_concat (buf, cur, "pc");
break;
case MEM:
print_value (t, XEXP (x, 0), verbose);
cur = safe_concat (buf, cur, "[");
cur = safe_concat (buf, cur, t);
cur = safe_concat (buf, cur, "]");
break;
case DEBUG_EXPR:
sprintf (t, "D#%i", DEBUG_TEMP_UID (DEBUG_EXPR_TREE_DECL (x)));
cur = safe_concat (buf, cur, t);
break;
default:
print_exp (t, x, verbose);
cur = safe_concat (buf, cur, t);
break;
}
} /* print_value */
static void
print_value (char *buf, rtx x, int verbose)
{
char t[BUF_LEN];
char *cur = buf;
switch (GET_CODE (x))
{
case CONST_INT:
sprintf (t, HOST_WIDE_INT_PRINT_HEX, INTVAL (x));
cur = safe_concat (buf, cur, t);
break;
case CONST_DOUBLE:
if (FLOAT_MODE_P (GET_MODE (x)))
real_to_decimal (t, CONST_DOUBLE_REAL_VALUE (x), sizeof (t), 0, 1);
else
sprintf (t, "<0x%lx,0x%lx>", (long) CONST_DOUBLE_LOW (x), (long) CONST_DOUBLE_HIGH (x));
cur = safe_concat (buf, cur, t);
break;
case CONST_STRING:
cur = safe_concat (buf, cur, "\"");
cur = safe_concat (buf, cur, XSTR (x, 0));
cur = safe_concat (buf, cur, "\"");
break;
case SYMBOL_REF:
cur = safe_concat (buf, cur, "`");
cur = safe_concat (buf, cur, XSTR (x, 0));
cur = safe_concat (buf, cur, "'");
break;
case LABEL_REF:
sprintf (t, "L%d", INSN_UID (XEXP (x, 0)));
cur = safe_concat (buf, cur, t);
break;
case CONST:
print_value (t, XEXP (x, 0), verbose);
cur = safe_concat (buf, cur, "const(");
cur = safe_concat (buf, cur, t);
cur = safe_concat (buf, cur, ")");
break;
case HIGH:
print_value (t, XEXP (x, 0), verbose);
cur = safe_concat (buf, cur, "high(");
cur = safe_concat (buf, cur, t);
cur = safe_concat (buf, cur, ")");
break;
case REG:
if (REGNO (x) < FIRST_PSEUDO_REGISTER)
{
int c = reg_names[REGNO (x)][0];
if (ISDIGIT (c))
cur = safe_concat (buf, cur, "%");
cur = safe_concat (buf, cur, reg_names[REGNO (x)]);
}
else
{
sprintf (t, "r%d", REGNO (x));
cur = safe_concat (buf, cur, t);
}
break;
case SUBREG:
print_value (t, SUBREG_REG (x), verbose);
cur = safe_concat (buf, cur, t);
sprintf (t, "#%d", SUBREG_BYTE (x));
cur = safe_concat (buf, cur, t);
break;
case SCRATCH:
cur = safe_concat (buf, cur, "scratch");
break;
case CC0:
cur = safe_concat (buf, cur, "cc0");
break;
case PC:
cur = safe_concat (buf, cur, "pc");
break;
case MEM:
print_value (t, XEXP (x, 0), verbose);
cur = safe_concat (buf, cur, "[");
cur = safe_concat (buf, cur, t);
cur = safe_concat (buf, cur, "]");
break;
default:
print_exp (t, x, verbose);
cur = safe_concat (buf, cur, t);
break;
}
} /* print_value */
void print_exp ( cEXP* p ) {
if( p ) {
switch( p->exp_id ) {
case eTYPE: printf("cEXP(eTYPE):%d\n", p->val);
printf("-- end of cEXP(eTYPE)\n");
break;
case ePLIST: printf("cEXP(ePLIST):\n");
print_exp( p->exp1 );
print_exp( p->next );
printf("-- end of cEXP(ePLIST)\n");
break;
case ePDEC: printf("cEXP(ePDEC): %s\n", p->name);
print_exp( p->exp1 );
printf("-- end of cEXP(ePDEC)\n");
break;
case eVLIST: printf("cEXP{eVLIST):\n");
print_exp( p->exp1 );
print_exp( p->next );
printf("-- end of cEXP(eVLIST)\n");
break;
case eVASS: printf("cEXP{eVASS): %s = \n", p->name);
print_exp( p->exp1 );
printf("-- end of cEXP(eVASS)\n");
break;
case eID: printf("cEXP{eID): %s\n", p->name);
printf("-- end of cEXP(eID)\n");
break;
case eEOPT: printf("cEXP{eEOPT):\n");
print_exp( p->exp1 );
print_exp( p->exp2 );
print_exp( p->next );
printf("-- end of cEXP(eEOPT)\n");
break;
case eOR: printf("cEXP{eOR):\n");
print_exp( p->exp1 );
print_exp( p->exp2 );
printf("-- end of cEXP(eOR)\n");
break;
case eAND: printf("cEXP{eAND):\n");
print_exp( p->exp1 );
print_exp( p->exp2 );
printf("-- end of cEXP(eAND)\n");
break;
case eEQU: printf("cEXP{eEQU):\n");
print_exp( p->exp1 );
print_exp( p->exp2 );
printf("-- end of cEXP(eEQU)\n");
break;
case eREL: printf("cEXP{eREL): %d\n", p->val);
print_exp( p->exp1 );
print_exp( p->exp2 );
printf("-- end of cEXP(eREL)\n");
break;
case eADD: printf("cEXP{eADD):\n");
print_exp( p->exp1 );
print_exp( p->exp2 );
printf("-- end of cEXP(eADD)\n");
break;
case eMINUS: printf("cEXP{eMINUS):\n");
print_exp( p->exp1 );
print_exp( p->exp2 );
printf("-- end of cEXP(eMINUS)\n");
break;
case eTIMES: printf("cEXP{eTIMES):\n");
print_exp( p->exp1 );
print_exp( p->exp2 );
printf("-- end of cEXP(eTIMES)\n");
break;
case eDIVIDE: printf("cEXP{eDIVIDE):\n");
print_exp( p->exp1 );
print_exp( p->exp2 );
printf("-- end of cEXP(eDIVIDE)\n");
break;
case eREMAIN: printf("cEXP{eREMAIN):\n");
print_exp( p->exp1 );
print_exp( p->exp2 );
printf("-- end of cEXP(eREMAIN)\n");
break;
case eNOT: printf("cEXP{eNOT):\n");
print_exp( p->exp1 );
printf("-- end of cEXP(eADD)\n");
break;
case eUMINUS: printf("cEXP{eUMINUS):\n");
print_exp( p->exp1 );
printf("-- end of cEXP(eUMINUS)\n");
break;
case eNUM: printf("cEXP{eNUM): %d\n", p->val);
printf("-- end of cEXP(eNUM)\n");
break;
case eFCALL: printf("cEXP{eFCALL): %s\n", p->name);
print_exp( p->exp1 );
printf("-- end of cEXP(eFCALL)\n");
break;
case eALIST: printf("cEXP{eALIST): %s\n", p->name);
print_exp( p->exp1 );
print_exp( p->next );
printf("-- end of cEXP(eALIST)\n");
break;
case eOEXP: printf("cEXP{eOEXP):\n");
print_exp( p->exp1 );
printf("-- end of cEXP(eOEXP)\n");
break;
case eEXP: printf("cEXP{eEXP): %s\n", p->name);
print_exp( p->next );
printf("-- end of cEXP(eFCALL)\n");
break;
case eLP: printf("cEXP{eLP):\n");
print_exp( p->exp1 );
printf("-- end of cEXP(eLP)\n");
break;
default: fprintf(stderr, "******* An error in expressions!\n");
break;
}
}
}
void print_stm ( cSTM* p ) {
cEXP *te;
cSTM *ts;
if( p ) {
switch( p->stm_id ) {
case sFUNC: printf("cSTM(sFUNC): %s\n", p->exp1->name);
print_exp( p->exp1 );
print_exp( p->exp2 );
print_stm( p->stm1 );
printf("** end of cSTM(sFUNC)\n");
break;
case sSLIST: printf("cSTM(sSLIST):\n");
print_stm( p->stm1 );
print_stm( p->next );
printf("** end of cSTM(sSLIST)\n");
break;
case sCSTM: printf("cSTM(sCSTM):\n");
print_stm( p->stm1 );
print_stm( p->stm2 );
printf("** end of cSTM(sCSTM)\n");
break;
case sVDLIST: printf("cSTM(sVDLIST):\n");
print_stm( p->stm1 );
print_stm( p->next );
printf("** end of cSTM(sVDLIST)\n");
break;
case sVDEC: printf("cSTM(sVDEC):\n");
print_exp( p->exp1 );
print_exp( p->exp2 );
printf("** end of cSTM(sVDEC)\n");
break;
case sISTM: printf("cSTM(sISTM):\n");
print_exp( p->exp1 );
print_stm( p->stm1 );
print_stm( p->stm2 );
printf("** end of cSTM(sISTM)\n");
break;
case sWSTM: printf("cSTM(sWSTM):\n");
print_exp( p->exp1 );
print_stm( p->stm1 );
printf("** end of cSTM(sWSTM)\n");
break;
case sASTM: printf("cSTM(sASTM): %s\n", p->name);
print_exp( p->exp1 );
printf("** end of cSTM(sASTM)\n");
break;
case sBR: printf("cSTM(sBR):\n");
printf("** end of cSTM(sBR)\n");
break;
case sCONT: printf("cSTM(sCONT):\n");
printf("** end of cSTM(sCONT)\n");
break;
case sRET: printf("cSTM(sRET):\n");
print_exp( p->exp1 );
printf("** end of cSTM(sRET)\n");
break;
case sPRF: printf("cSTM(sPRF):\n");
print_exp( p->exp1 );
print_exp( p->exp2 );
printf("** end of cSTM(sPRF)\n");
break;
case sOELS: printf("cSTM(sOELS):\n");
print_stm( p->stm1 );
printf("** end of cSTM(sOELS)\n");
break;
default: fprintf(stderr, "******* An error in statements!\n");
break;
}
}
}
void print_exp (Exp* e) {
switch(e->tag) {
case INT_EXP: {
IntExp* e2 = (IntExp*)e;
printf("%d", e2->value);
break;
}
case NULL_EXP: {
printf("null");
break;
}
case PRINTF_EXP: {
PrintfExp* e2 = (PrintfExp*)e;
printf("printf(");
print_string(e2->format);
for(int i=0; i<e2->nexps; i++) {
printf(", ");
print_exp(e2->exps[i]);
}
printf(")");
break;
}
case ARRAY_EXP: {
ArrayExp* e2 = (ArrayExp*)e;
printf("array(");
print_exp(e2->length);
printf(", ");
print_exp(e2->init);
printf(")");
break;
}
case OBJECT_EXP: {
ObjectExp* e2 = (ObjectExp*)e;
printf("object : (");
for(int i=0; i<e2->nslots; i++) {
if(i > 0) printf(" ");
print_slotstmt(e2->slots[i]);
}
printf(")");
break;
}
case SLOT_EXP: {
SlotExp* e2 = (SlotExp*)e;
print_exp(e2->exp);
printf(".%s", e2->name);
break;
}
case SET_SLOT_EXP: {
SetSlotExp* e2 = (SetSlotExp*)e;
print_exp(e2->exp);
printf(".%s = ", e2->name);
print_exp(e2->value);
break;
}
case CALL_SLOT_EXP: {
CallSlotExp* e2 = (CallSlotExp*)e;
print_exp(e2->exp);
printf(".%s(", e2->name);
for(int i=0; i<e2->nargs; i++) {
if(i > 0) printf(", ");
print_exp(e2->args[i]);
}
printf(")");
break;
}
case CALL_EXP: {
CallExp* e2 = (CallExp*)e;
printf("%s(", e2->name);
for(int i=0; i<e2->nargs; i++) {
if(i > 0) printf(", ");
print_exp(e2->args[i]);
}
printf(")");
break;
}
case SET_EXP: {
SetExp* e2 = (SetExp*)e;
printf("%s = ", e2->name);
print_exp(e2->exp);
break;
}
case IF_EXP: {
IfExp* e2 = (IfExp*)e;
printf("if ");
print_exp(e2->pred);
printf(" : (");
print_scopestmt(e2->conseq);
printf(") else : (");
print_scopestmt(e2->alt);
printf(")");
break;
}
case WHILE_EXP: {
WhileExp* e2 = (WhileExp*)e;
printf("while ");
print_exp(e2->pred);
printf(" : (");
print_scopestmt(e2->body);
printf(")");
break;
}
case REF_EXP: {
RefExp* e2 = (RefExp*)e;
printf("%s", e2->name);
break;
}
default:
printf("Unrecognized Expression with tag %d\n", e->tag);
exit(-1);
}
}
