/*!
* \param instr l'instruction à imprimer
* \param addr son adresse
*/
void print_instruction(Instruction instr, unsigned addr) {
printf("%s ", cop_names[instr.instr_generic._cop]);
switch (instr.instr_generic._cop) {
case ILLOP:
case NOP:
case RET:
case HALT:
break;
case LOAD:
case STORE:
case ADD:
case SUB:
print_register(instr);
print_op(instr);
break;
case BRANCH:
case CALL:
print_condition(instr);
print_op(instr);
break;
case PUSH:
case POP:
print_op(instr);
break;
}
}
int bot_parse_service(struct IRC *bot, char *server, char *command, char *me, char *channel, char *msg){
if(DEBUG){
printf("[server: %s] [command: %s] [me: %s] [channel: %s] %s\n",server,command,me,channel,msg);
}
// 353 is the NAMES list
if(strcasecmp(command, "353") == 0){
parse_op(bot,msg);
if(DEBUG){
print_op(bot);
}
}
if(strcasecmp(command, "MODE") ==0){
if((msg[0]=='+') && (msg[1]=='o')){
// if it's not already in the oplist
if(is_op(bot,&msg[3])==-1){
add_op(bot,&msg[3]);
if(DEBUG){
print_op(bot);
}
}
}
else if((msg[0]=='-') && (msg[1]=='o')){
if(is_op(bot,&msg[3])!=-1){
rm_op(bot,&msg[3]);
if(DEBUG){
print_op(bot);
}
}
}
}
return 0;
}
/* Empty loop body */
}
for (i = specified; i < 3; i++) {
if (tp[i+1] != am_Underscore) {
goto error;
}
}
mfa.module = tp[1];
mfa.function = tp[2];
if (is_small(tp[3])) {
mfa.arity = signed_val(tp[3]);
}
if (!erts_try_seize_code_write_permission(BIF_P)) {
ERTS_BIF_YIELD2(bif_export[BIF_erts_debug_breakpoint_2],
BIF_P, BIF_ARG_1, BIF_ARG_2);
}
erts_proc_unlock(p, ERTS_PROC_LOCK_MAIN);
erts_thr_progress_block();
erts_bp_match_functions(&f, &mfa, specified);
if (boolean == am_true) {
erts_set_debug_break(&f);
erts_install_breakpoints(&f);
erts_commit_staged_bp();
} else {
erts_clear_debug_break(&f);
erts_commit_staged_bp();
erts_uninstall_breakpoints(&f);
}
erts_consolidate_bp_data(&f, 1);
res = make_small(f.matched);
erts_bp_free_matched_functions(&f);
erts_thr_progress_unblock();
erts_proc_lock(p, ERTS_PROC_LOCK_MAIN);
erts_release_code_write_permission();
return res;
error:
BIF_ERROR(p, BADARG);
}
#if 0 /* Kept for conveninence when hard debugging. */
void debug_dump_code(BeamInstr *I, int num)
{
BeamInstr *code_ptr = I;
BeamInstr *end = code_ptr + num;
erts_dsprintf_buf_t *dsbufp;
BeamInstr instr;
int i;
dsbufp = erts_create_tmp_dsbuf(0);
while (code_ptr < end) {
erts_print(ERTS_PRINT_DSBUF, (void *) dsbufp, HEXF ": ", code_ptr);
instr = (BeamInstr) code_ptr[0];
for (i = 0; i < NUM_SPECIFIC_OPS; i++) {
if (BeamIsOpCode(instr, i) && opc[i].name[0] != '\0') {
code_ptr += print_op(ERTS_PRINT_DSBUF, (void *) dsbufp,
i, opc[i].sz-1, code_ptr) + 1;
break;
}
}
if (i >= NUM_SPECIFIC_OPS) {
erts_print(ERTS_PRINT_DSBUF, (void *) dsbufp,
"unknown " HEXF "\n", instr);
code_ptr++;
}
}
dsbufp->str[dsbufp->str_len] = 0;
erts_fprintf(stderr,"%s", dsbufp->str);
erts_destroy_tmp_dsbuf(dsbufp);
}
static void print_qual(NODE *n)
{
if (n == NULL)
return;
printf(" where ");
if (n->kind == N_SELECT) {
print_qualattr(n->u.SELECT.selattr);
print_op(n->u.SELECT.op);
print_val(n->u.SELECT.value);
} else {
print_qualattr(n->u.JOIN.joinattr1);
print_op(n->u.JOIN.op);
printf(" ");
print_qualattr(n->u.JOIN.joinattr2);
}
}
void call_op(int op, t_ps *ps)
{
ps->total_ops++;
if (OPT(OPT_EXEC) && OPT(OPT_TIME))
usleep(ps->op_sleep);
g_ops[op].f(ps);
print_op(ps, op);
}
static void print_condition(NODE *n)
{
print_relattr(n->u.CONDITION.lhsRelattr);
print_op(n->u.CONDITION.op);
if (n->u.CONDITION.rhsRelattr)
print_relattr(n->u.CONDITION.rhsRelattr);
else
print_value(n->u.CONDITION.rhsValue);
}
void print_tree(NODE r, int s)
{
if (r != NULL)
{
fprintf(treefile, "type=%s\n", print_op(r->op));
fprintf(treefile, "children=%d\n", r->children);
if (r->name) fprintf(treefile, "my check == = = ==> %s\n", r->name);
if (r->op == IDE) fprintf(treefile, "string=%s\n", r->name);
if (r->op == INTCONST) fprintf(treefile, "int value=%d\n", r->num_val.val);
if (r->op == REALCONST) fprintf(treefile, "real value=%f\n", r->num_val.rval);
fprintf(treefile, "node type: %s\n\n", print_op(r->type));
if (r->s1 != NULL)
{
fprintf(treefile, "| Son1 of %s\n", print_op(r->op));
fprintf(treefile, "|\n");
fprintf(treefile, "---------------\n");
print_tree(r->s1, s + 2);
}
if (r->s2 != NULL)
{
fprintf(treefile, "| Son2 of %s\n", print_op(r->op));
fprintf(treefile, "|\n");
fprintf(treefile, "---------------\n");
print_tree(r->s2, s + 2);
}
if (r->s3 != NULL)
{
fprintf(treefile, "| Son3 of %s\n", print_op(r->op));
fprintf(treefile, "|\n");
fprintf(treefile, "---------------\n");
print_tree(r->s3, s + 2);
}
}
}
void print_inst(FILE* fptr, inst_t i) {
if (i->label) {
fprintf(fptr, "%s:", i->label);
}
if (i->op == OP_BR) {
fprintf(fptr, "\t%s", opnames[i->op]);
print_cc(fptr, i->ccode);
} else
fprintf(fptr, "\t%s ", opnames[i->op]);
switch (i->op) {
/* 3 operands */
case OP_ADD:
case OP_AND:
case OP_ANDL:
case OP_DIV:
case OP_LDR:
case OP_MUL:
case OP_OR:
case OP_ORL:
case OP_STR:
case OP_SUB:
print_op(fptr, i->ops[0]);
fprintf(fptr, ", ");
print_op(fptr, i->ops[1]);
fprintf(fptr, ", ");
print_op(fptr, i->ops[2]);
break;
/* 2 operands */
case OP_BR:
case OP_SET:
case OP_ST:
case OP_STI:
case OP_LD:
case OP_LDI:
case OP_LEA:
case OP_NOT:
case OP_NOTL:
print_op(fptr, i->ops[0]);
fprintf(fptr, ", ");
print_op(fptr, i->ops[1]);
break;
/* one operand */
case OP_JSRR:
case OP_BRA:
case OP_JMP:
case OP_JSR:
print_op(fptr, i->ops[0]);
default:
break;
}
fprintf(fptr, "\n");
}
/**
test if 'from' can be cast into type 'to'
currently hardcoded, but can be make smarter.
*/
int is_legal_cast(int from, int to)
{
FILE* txt;
if (from == INTEGER && to == FLOAT || from == FLOAT && to == INTEGER)
return 1;
txt = fopen("outputParser.txt", "a");
printf("\nError at line %d: cannot cast from type %s to type %s\n", line_number, print_op(from), print_op(to));
fprintf(txt, "\nError at line %d: cannot cast from type %s to type %s\n", line_number, print_op(from), print_op(to));
fclose(txt);
return 0;
}
BIF_RETTYPE
erts_debug_disassemble_1(BIF_ALIST_1)
{
Process* p = BIF_P;
Eterm addr = BIF_ARG_1;
erts_dsprintf_buf_t *dsbufp;
Eterm* hp;
Eterm* tp;
Eterm bin;
Eterm mfa;
ErtsCodeMFA *cmfa = NULL;
BeamCodeHeader* code_hdr;
BeamInstr *code_ptr;
BeamInstr instr;
BeamInstr uaddr;
Uint hsz;
int i;
if (term_to_UWord(addr, &uaddr)) {
code_ptr = (BeamInstr *) uaddr;
if ((cmfa = find_function_from_pc(code_ptr)) == NULL) {
BIF_RET(am_false);
}
} else if (is_tuple(addr)) {
ErtsCodeIndex code_ix;
Module* modp;
Eterm mod;
Eterm name;
Export* ep;
Sint arity;
int n;
tp = tuple_val(addr);
if (tp[0] != make_arityval(3)) {
error:
BIF_ERROR(p, BADARG);
}
mod = tp[1];
name = tp[2];
if (!is_atom(mod) || !is_atom(name) || !is_small(tp[3])) {
goto error;
}
arity = signed_val(tp[3]);
code_ix = erts_active_code_ix();
modp = erts_get_module(mod, code_ix);
/*
* Try the export entry first to allow disassembly of special functions
* such as erts_debug:apply/4. Then search for it in the module.
*/
if ((ep = erts_find_function(mod, name, arity, code_ix)) != NULL) {
/* XXX: add "&& ep->address != ep->code" condition?
* Consider a traced function.
* Its ep will have ep->address == ep->code.
* erts_find_function() will return the non-NULL ep.
* Below we'll try to derive a code_ptr from ep->address.
* But this code_ptr will point to the start of the Export,
* not the function's func_info instruction. BOOM !?
*/
cmfa = erts_code_to_codemfa(ep->addressv[code_ix]);
} else if (modp == NULL || (code_hdr = modp->curr.code_hdr) == NULL) {
BIF_RET(am_undef);
} else {
n = code_hdr->num_functions;
for (i = 0; i < n; i++) {
cmfa = &code_hdr->functions[i]->mfa;
if (cmfa->function == name && cmfa->arity == arity) {
break;
}
}
if (i == n) {
BIF_RET(am_undef);
}
}
code_ptr = (BeamInstr*)erts_code_to_codeinfo(erts_codemfa_to_code(cmfa));
} else {
goto error;
}
dsbufp = erts_create_tmp_dsbuf(0);
erts_print(ERTS_PRINT_DSBUF, (void *) dsbufp, HEXF ": ", code_ptr);
instr = (BeamInstr) code_ptr[0];
for (i = 0; i < NUM_SPECIFIC_OPS; i++) {
if (BeamIsOpCode(instr, i) && opc[i].name[0] != '\0') {
code_ptr += print_op(ERTS_PRINT_DSBUF, (void *) dsbufp,
i, opc[i].sz-1, code_ptr) + 1;
break;
}
}
if (i >= NUM_SPECIFIC_OPS) {
erts_print(ERTS_PRINT_DSBUF, (void *) dsbufp,
"unknown " HEXF "\n", instr);
code_ptr++;
}
bin = new_binary(p, (byte *) dsbufp->str, dsbufp->str_len);
erts_destroy_tmp_dsbuf(dsbufp);
hsz = 4+4;
(void) erts_bld_uword(NULL, &hsz, (BeamInstr) code_ptr);
hp = HAlloc(p, hsz);
addr = erts_bld_uword(&hp, NULL, (BeamInstr) code_ptr);
ASSERT(is_atom(cmfa->module) || is_nil(cmfa->module));
ASSERT(is_atom(cmfa->function) || is_nil(cmfa->function));
mfa = TUPLE3(hp, cmfa->module, cmfa->function,
make_small(cmfa->arity));
hp += 4;
return TUPLE3(hp, addr, bin, mfa);
}
NODE makenode(int op, NODE s1, NODE s2, NODE s3, int val, char *id)
{
NODE t;
FILE *txt;
t = (NODE)malloc(sizeof(struct node));
t->num_val.val = val;
if (op == CASE)
t->s1 = genLeaf(INTCONST, val, 0, NULL);
else
t->s1 = s1;
t->s2 = s2;
t->s3 = s3;
t->name = (id != NULL) ? id : "";
// counting children
t->children = 0;
if (t->s1 != NULL) t->children++;
if (t->s2 != NULL) t->children++;
if (t->s3 != NULL) t->children++;
t->op = op;
switch (op)
{
case ADD:
case MMIN:
case MUL:
case DIV:
case AND:
case OR:
case NOT:
case ASSIGN:
if (t->s1->type == t->s2->type)
t->type = t->s1->type;
else
{
txt = fopen("outputParser.txt", "a");
printf("\nError at line %d: %s %s %s\n", line_number, print_op(t->s2->type), print_op(op), print_op(t->s1->type));
fprintf(txt, "\nError at line %d: %s %s %s\n", line_number, print_op(t->s2->type), print_op(op), print_op(t->s1->type));
fclose(txt);
}
break;
case LES:
case LEQ:
case EQU:
case NEQ:
case GRE:
case GEQ:
if (t->s1->type == t->s2->type)
t->type = BOOLEAN;
else
{
txt = fopen("outputParser.txt", "a");
printf("\nError at line %d: %s %s %s\n", line_number, print_op(t->s2->type), print_op(op), print_op(t->s1->type));
fprintf(txt, "\nError at line %d: %s %s %s\n", line_number, print_op(t->s2->type), print_op(op), print_op(t->s1->type));
fclose(txt);
}
break;
case CAST:
if (is_legal_cast(t->s1->type, currentType))
t->type = currentType;
}
return(t);
}
void trace( unsigned int o_pc,
unsigned char op,
int rx,
int ry,
int offset )
/* Dump out the registers, program counter, and memory near the program counter
*/
{
unsigned int b ; /* Base for memory dump */
b = pc < 16 ? 0 : (pc + 32) < MEMMAX ? pc & 0xfffffff0 : MEMMAX - 32 ;
print_op( o_pc, op, rx, ry, offset ) ;
printf( "R0 = %08x ", r[0] ) ; /* Registers */
printf( "R1 = %08x ", r[1] ) ;
printf( "R2 = %08x ", r[2] ) ;
printf( "R3 = %08x\n", r[3] ) ;
printf( "R4 = %08x ", r[4] ) ;
printf( "R5 = %08x ", r[5] ) ;
printf( "R6 = %08x ", r[6] ) ;
printf( "R7 = %08x\n", r[7] ) ;
printf( "R8 = %08x ", r[8] ) ;
printf( "R9 = %08x ", r[9] ) ;
printf( "R10 = %08x ", r[10] ) ;
printf( "R11 = %08x\n", r[11] ) ;
printf( "R12 = %08x ", r[12] ) ;
printf( "R13 = %08x ", r[13] ) ;
printf( "R14 = %08x ", r[14] ) ;
printf( "R15 = %08x\n\n", r[15] ) ;
printf( "PC = %08x ", pc ) ; /* PC */
printf( "Z = %8x ", z_flag ) ; /* Status flag */
printf( "CLK = %d\n\n", vam_clock ) ; /* Number of ticks */
printf( "%08x: ", b ) ;
printf( "%02x%02x%02x%02x ", mem[b], mem[b+1], mem[b+2], mem[b+3] ) ;
b += 4 ;
printf( "%02x%02x%02x%02x ", mem[b], mem[b+1], mem[b+2], mem[b+3] ) ;
b += 4 ;
printf( "%02x%02x%02x%02x ", mem[b], mem[b+1], mem[b+2], mem[b+3] ) ;
b += 4 ;
printf( "%02x%02x%02x%02x\n", mem[b], mem[b+1], mem[b+2], mem[b+3] ) ;
b += 4 ;
printf( "%08x: ", b ) ;
printf( "%02x%02x%02x%02x ", mem[b], mem[b+1], mem[b+2], mem[b+3] ) ;
b += 4 ;
printf( "%02x%02x%02x%02x ", mem[b], mem[b+1], mem[b+2], mem[b+3] ) ;
b += 4 ;
printf( "%02x%02x%02x%02x ", mem[b], mem[b+1], mem[b+2], mem[b+3] ) ;
b += 4 ;
printf( "%02x%02x%02x%02x\n", mem[b], mem[b+1], mem[b+2], mem[b+3] ) ;
b += 4 ;
printf( "%08x: ", b ) ;
printf( "%02x%02x%02x%02x ", mem[b], mem[b+1], mem[b+2], mem[b+3] ) ;
b += 4 ;
printf( "%02x%02x%02x%02x ", mem[b], mem[b+1], mem[b+2], mem[b+3] ) ;
b += 4 ;
printf( "%02x%02x%02x%02x ", mem[b], mem[b+1], mem[b+2], mem[b+3] ) ;
b += 4 ;
printf( "%02x%02x%02x%02x\n\n",
mem[b], mem[b+1], mem[b+2], mem[b+3] ) ;
b = r[1] < 16 ? 0 : (r[1] + 32) < MEMMAX ? r[1] & 0xfffffff0 :
MEMMAX - 32 ;
printf( "%08x: ", b ) ;
printf( "%02x%02x%02x%02x ", mem[b], mem[b+1], mem[b+2], mem[b+3] ) ;
b += 4 ;
printf( "%02x%02x%02x%02x ", mem[b], mem[b+1], mem[b+2], mem[b+3] ) ;
b += 4 ;
printf( "%02x%02x%02x%02x ", mem[b], mem[b+1], mem[b+2], mem[b+3] ) ;
b += 4 ;
printf( "%02x%02x%02x%02x\n", mem[b], mem[b+1], mem[b+2], mem[b+3] ) ;
b += 4 ;
printf( "%08x: ", b ) ;
printf( "%02x%02x%02x%02x ", mem[b], mem[b+1], mem[b+2], mem[b+3] ) ;
b += 4 ;
printf( "%02x%02x%02x%02x ", mem[b], mem[b+1], mem[b+2], mem[b+3] ) ;
b += 4 ;
printf( "%02x%02x%02x%02x ", mem[b], mem[b+1], mem[b+2], mem[b+3] ) ;
b += 4 ;
printf( "%02x%02x%02x%02x\n", mem[b], mem[b+1], mem[b+2], mem[b+3] ) ;
b += 4 ;
printf( "%08x: ", b ) ;
printf( "%02x%02x%02x%02x ", mem[b], mem[b+1], mem[b+2], mem[b+3] ) ;
b += 4 ;
printf( "%02x%02x%02x%02x ", mem[b], mem[b+1], mem[b+2], mem[b+3] ) ;
b += 4 ;
printf( "%02x%02x%02x%02x ", mem[b], mem[b+1], mem[b+2], mem[b+3] ) ;
b += 4 ;
printf( "%02x%02x%02x%02x\n\n\n",
mem[b], mem[b+1], mem[b+2], mem[b+3] ) ;
fflush( stdout ) ;
} /* trace( o_pc, op, rx, ry, offset ) */
void BijouBlock_dump2(VM, BijouBlock* b, int level)
{
char * str;
size_t x;
INDENT;
printf("; block at: %p, %s (level %d)\n", (void *)b, b->funcname != NULL ?
b->funcname : "", level);
INDENT;
printf("; %zu registers\n", b->regc);
INDENT;
printf("; constants (%zu)\n", kv_size(b->k));
for (x = 0; x < kv_size(b->k); ++x) {
str = TValue_to_string(kv_A(b->k, x));
int s = ttisstring(&kv_A(b->k, x));
INDENT;
printf("\t%zu: (%s) %s%s%s\n", x, TValue_type_to_string(kv_A(b->k, x)), s ? "\"" : "",
str, s ? "\"" : "");
if (ttisnumber(&kv_A(b->k, x))) B_FREE(str);
}
INDENT;
printf("; locals (%zu)\n", kv_size(b->locals));
for (x = 0; x < kv_size(b->locals); ++x) {
str = TValue_to_string(kv_A(b->locals, x));
INDENT;
printf("\t%zu: (%s) %s\n", x, TValue_type_to_string(kv_A(b->locals, x)), str);
if (ttisnumber(&kv_A(b->locals, x))) B_FREE(str);
}
INDENT;
printf("; upvals (%zu)\n", kv_size(b->upvals));
for (x = 0; x < kv_size(b->upvals); ++x) {
str = TValue_to_string(kv_A(b->upvals, x));
INDENT;
printf("\t%zu: (%s) %s\n", x, TValue_type_to_string(kv_A(b->upvals, x)), str);
if (ttisnumber(&kv_A(b->upvals, x))) B_FREE(str);
}
INDENT;
printf("; code section (%zu instructions)\n", kv_size(b->code));
for (x = 0; x < kv_size(b->code); ++x) {
bInst i = kv_A(b->code, x);
INDENT;
print_op(i);
printf("\t");
switch (GET_OPCODE(i)) {
case OP_MOVE:
printf("; R[%d] = R[%d]", GETARG_A(i), GETARG_B(i));
break;
case OP_LOADK:
printf("; R[%d] = K[%d]", GETARG_A(i), GETARG_Bx(i));
break;
case OP_LOADBOOL:
printf("; R[%d] = %s", GETARG_A(i), GETARG_B(i) == 0 ? "false" : "true" );
break;
case OP_LOADNULL:
printf("; R[%d] = null", GETARG_A(i));
break;
case OP_GETGLOBAL:
printf("; R[%d] = globals[K[%d]]", GETARG_A(i), GETARG_Bx(i));
break;
case OP_SETGLOBAL:
printf("; globals[K[%d]] = R[%d]", GETARG_Bx(i), GETARG_A(i));
break;
case OP_GETLOCAL:
printf("; R[%d] = locals[K[%d]]", GETARG_A(i), GETARG_Bx(i));
break;
case OP_SETLOCAL:
printf("; locals[K[%d]] = R[%d]", GETARG_Bx(i), GETARG_A(i));
break;
case OP_ADD:
printf("; R[%d] = RK[%d] + RK[%d]", GETARG_A(i), GETARG_B(i),
GETARG_C(i));
break;
case OP_SUB:
printf("; R[%d] = RK[%d] - RK[%d]", GETARG_A(i), GETARG_B(i),
GETARG_C(i));
break;
case OP_MUL:
printf("; R[%d] = RK[%d] * RK[%d]", GETARG_A(i), GETARG_B(i),
GETARG_C(i));
break;
case OP_DIV:
printf("; R[%d] = RK[%d] / RK[%d]", GETARG_A(i), GETARG_B(i),
GETARG_C(i));
break;
case OP_POW:
printf("; R[%d] = RK[%d] ** RK[%d]", GETARG_A(i), GETARG_B(i),
GETARG_C(i));
break;
case OP_REM:
printf("; R[%d] = RK[%d] %% RK[%d]", GETARG_A(i), GETARG_B(i),
GETARG_C(i));
break;
case OP_UNM:
printf("; R[%d] = -RK[%d]", GETARG_A(i), GETARG_B(i));
break;
case OP_NOT:
printf("; R[%d] = !RK[%d]", GETARG_A(i), GETARG_B(i));
break;
case OP_CLOSURE:
printf("; R[%d] = ", GETARG_A(i));
if (ISK(GETARG_Bx(i))) {
BijouFunction *func = kv_A(vm->functions, GETARG_Bx(i) & ~0x100);
printf("%s\n", func->name);
} else
printf("closure[%d] (%s)\n", GETARG_Bx(i),
b->children[GETARG_Bx(i)]->funcname);
break;
case OP_CALL:
printf("; R[%d] = R[%d](", GETARG_A(i), GETARG_B(i));
size_t x;
for (x = 0; x < GETARG_C(i); ++x) {
printf("R[%zu], ", x);
}
if (x > 0) {
printf("\b\b");
}
printf(")");
break;
case OP_GETEXTERNAL:
printf("; R[%d] = closure(K[%d])", GETARG_A(i), GETARG_B(i));
break;
}
printf("\n");
}
INDENT;
printf("; functions (%zu definitions)\n", b->numchildren);
for (x = 0; x < b->numchildren; ++x) {
BijouBlock_dump2(vm, b->children[x], level + 1);
}
}
void showOperator(unsigned op) {
printf("%s\n", print_op(op));
}
//print codes
void print_code(char* name) {
FILE *fp = fopen(name,"w");
if (fp == NULL) {
printf("creating error\n");
return;
}
start = start -> child -> child;
head = translate_ExtDef(start);
intercodes mark = head;
tail -> next = NULL;
// printf("%d\n",tail->prev->code->kind);
while (mark != NULL) {
switch (mark->code->kind) {
case ASSIGN_K:
print_op(mark->code->u.assign.left,fp);
fputs(" := ",fp);
print_op(mark->code->u.assign.right,fp);
fputs("\n",fp);
break;
case ADD_K:
print_op(mark->code->u.binop.result,fp);
fputs(" := ",fp);
print_op(mark->code->u.binop.op1,fp);
fputs(" + ",fp);
print_op(mark->code->u.binop.op2,fp);
fputs("\n",fp);
break;
case SUB_K:
print_op(mark->code->u.binop.result,fp);
fputs(" := ",fp);
print_op(mark->code->u.binop.op1,fp);
fputs(" - ",fp);
print_op(mark->code->u.binop.op2,fp);
fputs("\n",fp);
break;
case MUL_K:
print_op(mark->code->u.binop.result,fp);
fputs(" := ",fp);
print_op(mark->code->u.binop.op1,fp);
fputs(" * ",fp);
print_op(mark->code->u.binop.op2,fp);
fputs("\n",fp);
break;
case DIV_K:
print_op(mark->code->u.binop.result,fp);
fputs(" := ",fp);
print_op(mark->code->u.binop.op1,fp);
fputs(" / ",fp);
print_op(mark->code->u.binop.op2,fp);
fputs("\n",fp);
break;
case RETURN_K:
fputs("RETURN ",fp);
print_op(mark->code->u.one.op,fp);
fputs("\n",fp);
break;
case LABEL_K:
fputs("LABEL ",fp);
print_op(mark->code->u.one.op,fp);
fputs(" :\n",fp);
break;
case GOTO_K:
fputs("GOTO ",fp);
print_op(mark->code->u.one.op,fp);
fputs("\n",fp);
break;
case IFGOTO_K:
fputs("IF ",fp);
print_op(mark->code->u.triop.c1,fp);
print_relop_type(mark->code->u.triop.reltype,fp);
print_op(mark->code->u.triop.c2,fp);
fputs("GOTO ",fp);
print_op(mark->code->u.triop.label,fp);
fputs("\n",fp);
break;
case DEC_K:
fputs("DEC ",fp);
print_op(mark->code->u.assign.left,fp);
fputs(" ",fp);
fprintf(fp,"%d",mark->code->u.assign.right->u.value);
fputs("\n",fp);
break;
case ARG_K:
fputs("ARG ",fp);
print_op(mark->code->u.one.op,fp);
fputs("\n",fp);
break;
case CALL_K:
print_op(mark->code->u.assign.left,fp);
fputs(" := CALL ",fp);
print_op(mark->code->u.assign.right,fp);
fputs("\n",fp);
break;
case PARAM_K:
fputs("PARAM ",fp);
print_op(mark->code->u.one.op,fp);
fputs("\n",fp);
break;
case READ_K:
fputs("READ ",fp);
print_op(mark->code->u.one.op,fp);
fputs("\n",fp);
break;
case WRITE_K:
fputs("WRITE ",fp);
print_op(mark->code->u.one.op,fp);
fputs("\n",fp);
break;
case FUNCTION_K:
fputs("FUNCTION ",fp);
print_op(mark->code->u.one.op,fp);
fputs(" :\n",fp);
break;
}
mark = mark->next;
}
fclose(fp);
}
