//---------------------------------------------------------------------- void idaapi out(void) { char buf[MAXSTR]; init_output_buffer(buf, sizeof(buf)); // output instruction mnemonics char postfix[4]; postfix[0] = '\0'; OutMnem(8, postfix); bool comma = out_one_operand(0); if ( cmd.Op2.type != o_void ) { if ( comma ) out_symbol(','); out_one_operand(1); } if ( cmd.Op3.type != o_void ) { out_symbol(','); out_one_operand(2); } if ( isVoid(cmd.ea, uFlag, 0) ) OutImmChar(cmd.Op1); if ( isVoid(cmd.ea, uFlag, 1) ) OutImmChar(cmd.Op2); if ( isVoid(cmd.ea, uFlag, 3) ) OutImmChar(cmd.Op3); term_output_buffer(); gl_comm = 1; MakeLine(buf); }
//---------------------------------------------------------------------- void out(void) { char buf[MAXSTR]; init_output_buffer(buf, sizeof(buf)); // setup the output pointer OutMnem(); // output instruction mnemonics out_one_operand(0); // output the first operand //Вывод операнда if(cmd.Op2.type != o_void) { out_symbol(',');//вывод разделителя между операндами //если неуказан флаг UAS_NOSPA ставим пробел if(!(ash.uflag & UAS_NOSPA)) OutChar(' '); out_one_operand(1); } if(cmd.Op3.type != o_void) { out_symbol(','); if(!(ash.uflag & UAS_NOSPA)) OutChar(' '); out_one_operand(2); } if(isVoid(cmd.ea, uFlag, 0)) OutImmChar(cmd.Op1); if(isVoid(cmd.ea, uFlag, 1)) OutImmChar(cmd.Op2); if(isVoid(cmd.ea, uFlag, 2)) OutImmChar(cmd.Op3); term_output_buffer(); gl_comm = 1; MakeLine(buf); }
void out( void ) { char buf[MAXSTR]; init_output_buffer(buf, sizeof(buf)); OutMnem(); out_one_operand( 0 ); if( cmd.Op2.type != o_void ) { out_symbol( ',' ); OutChar( ' ' ); out_one_operand( 1 ); } if( cmd.Op3.type != o_void ) { out_symbol( ',' ); OutChar( ' ' ); out_one_operand( 2 ); } if( isVoid( cmd.ea, uFlag, 0 ) ) OutImmChar( cmd.Op1 ); if( isVoid( cmd.ea, uFlag, 1 ) ) OutImmChar( cmd.Op2 ); if( isVoid( cmd.ea, uFlag, 2 ) ) OutImmChar( cmd.Op3 ); term_output_buffer(); gl_comm = 1; MakeLine( buf ); }
// outputs an instruction void idaapi out(void) { char buf[MAXSTR]; init_output_buffer(buf, sizeof(buf)); OutMnem(); out_one_operand(0); // output the first operand if ( cmd.Op2.type != o_void ) { out_symbol(','); OutChar(' '); out_one_operand(1); } if ( cmd.Op3.type != o_void ) { out_symbol(','); OutChar(' '); out_one_operand(2); } // output a character representation of the immediate values // embedded in the instruction as comments if ( isVoid(cmd.ea,uFlag,0)) OutImmChar(cmd.Op1 ); if ( isVoid(cmd.ea,uFlag,1)) OutImmChar(cmd.Op2 ); if ( isVoid(cmd.ea,uFlag,2)) OutImmChar(cmd.Op3 ); term_output_buffer(); // terminate the output string gl_comm = 1; // ask to attach a possible user- // defined comment to it MakeLine(buf); // pass the generated line to the // kernel }
//---------------------------------------------------------------------- // основная выводилка команд void N78K_out(void) { char buf[MAXSTR]; #if IDP_INTERFACE_VERSION > 37 init_output_buffer(buf, sizeof(buf)); // setup the output pointer #else uFlag = getFlags(cmd.ea); u_line = buf; #endif // выведем мнемонику OutMnem(); // выведем первый операнд if(cmd.Op1.type!=o_void)out_one_operand(0); // выведем второй операнд if(cmd.Op2.type != o_void) { out_symbol(','); OutChar(' '); out_one_operand(1); } // выведем непосредственные данные, если они есть if(isVoid(cmd.ea, uFlag, 0)) OutImmChar(cmd.Op1); if(isVoid(cmd.ea, uFlag, 1)) OutImmChar(cmd.Op2); #if IDP_INTERFACE_VERSION > 37 term_output_buffer(); #else *u_line = '\0'; #endif gl_comm = 1; MakeLine(buf); }
//---------------------------------------------------------------------- void out(void) { char buf[MAXSTR]; // output .org for enties without any labels if ( !has_any_name(uFlag) && helper.altval(cmd.ea) ) { btoa(buf, sizeof(buf), cmd.ip); printf_line(inf.indent, COLSTR("%s %s", SCOLOR_ASMDIR), ash.origin, buf); } init_output_buffer(buf, sizeof(buf)); OutMnem(); out_one_operand(0); if ( cmd.Op2.type != o_void ) { out_symbol(','); OutChar(' '); out_one_operand(1); } if ( isVoid(cmd.ea, uFlag, 0) ) OutImmChar(cmd.Op1); if ( isVoid(cmd.ea, uFlag, 1) ) OutImmChar(cmd.Op2); term_output_buffer(); gl_comm = 1; MakeLine(buf); }
//---------------------------------------------------------------------- void out(void) { char buf[MAXSTR]; init_output_buffer(buf, sizeof(buf)); const char *postfix = NULL; if ( cmd.auxpref & aux_byte ) postfix = ".b"; else if ( cmd.auxpref & aux_word ) postfix = ".w"; else if ( cmd.auxpref & aux_f ) postfix = "/f"; else if ( cmd.auxpref & aux_ne ) postfix = "/ne"; else if ( cmd.auxpref & aux_eq ) postfix = "/eq"; OutMnem(8, postfix); out_one_operand(0); if ( cmd.Op2.type != o_void ) { out_symbol(','); OutChar(' '); out_one_operand(1); } if ( isVoid(cmd.ea, uFlag, 0) ) OutImmChar(cmd.Op1); if ( isVoid(cmd.ea, uFlag, 1) ) OutImmChar(cmd.Op2); term_output_buffer(); gl_comm = 1; MakeLine(buf); }
// Output an instruction void out(void) { // // print insn mnemonic // char buf[MAXSTR]; init_output_buffer(buf, sizeof(buf)); char postfix[5]; postfix[0] = '\0'; if ( is_jmp_cc(cmd.itype) ) qstrncpy(postfix, ConditionCodes[cmd.auxpref], sizeof(postfix)); OutMnem(8, postfix); // // print insn operands // out_one_operand(0); // output the first operand if ( cmd.Op2.type != o_void ) { out_symbol(','); OutChar(' '); out_one_operand(1); } if ( cmd.Op3.type != o_void ) { out_symbol(','); OutChar(' '); out_one_operand(2); } // output a character representation of the immediate values // embedded in the instruction as comments if ( isVoid(cmd.ea,uFlag,0)) OutImmChar(cmd.Op1 ); if ( isVoid(cmd.ea,uFlag,1)) OutImmChar(cmd.Op2 ); if ( isVoid(cmd.ea,uFlag,2)) OutImmChar(cmd.Op3 ); if ( gr_cmt != NULL ) { OutChar(' '); out_line(ash.cmnt, COLOR_AUTOCMT); OutChar(' '); out_line(gr_cmt, COLOR_AUTOCMT); if ( ash.cmnt2 != NULL ) { OutChar(' '); out_line(ash.cmnt2, COLOR_AUTOCMT); } gr_cmt = NULL; } term_output_buffer(); // terminate the output string gl_comm = 1; // ask to attach a possible user- // defined comment to it MakeLine(buf); // pass the generated line to the // kernel }
//---------------------------------------------------------------------- // generate a text representation of an instruction // the information about the instruction is in the 'cmd' structure void idaapi out(void) { char buf[MAXSTR]; // setup the output pointer init_output_buffer(buf, sizeof(buf)); // output instruction mnemonics OutMnem(); // check for JP/JR instruction with condition code // add the condition on as a pseudo operand if present if ((cmd.itype == SAM8_JR) || ((cmd.itype == SAM8_JP) && (cmd.c_condition != ccNone))) { // sanity check if (cmd.c_condition >= cc_last) { warning("%a (%s): Internal error: bad condition code %i", cmd.ea, cmd.get_canon_mnem(), cmd.c_condition); return; } // output the condition code normally out_keyword(ccNames[cmd.c_condition]); out_symbol(','); OutChar(' '); } // output the first operand if (cmd.Op1.type != o_void) { out_one_operand(0); } // output the second operand if (cmd.Op2.type != o_void) { out_symbol(','); OutChar(' '); out_one_operand(1); } // output the third operand if (cmd.Op3.type != o_void) { out_symbol(','); OutChar(' '); out_one_operand(2); } // terminate the output string term_output_buffer(); // ask to attach a possible user-defined comment to it gl_comm = 1; // pass the generated line to the kernel MakeLine(buf); }
//---------------------------------------------------------------------- void out(void) { char buf[MAXSTR]; init_output_buffer(buf, sizeof(buf)); int op; if (!(cmd.SpecialModes & TMS_MODE_USER_PARALLEL)) { if ((cmd.SpecialModes & TMS_MODE_LR) || (cmd.SpecialModes & TMS_MODE_CR)) { out_line(cmd.get_canon_mnem(), COLOR_INSN); out_line((cmd.SpecialModes & TMS_MODE_LR) ? ".lr ":".cr ", COLOR_INSN); } else OutMnem(); } else { // user-defined parallelism out_line("|| ", COLOR_INSN); out_line(cmd.get_canon_mnem(), COLOR_INSN); out_line(" ", COLOR_INSN); } for (op = 0; op < UA_MAXOP; op++) { if (cmd.Operands[op].type == o_void) break; if (op != 0) // not the first operand { if (cmd.Parallel != TMS_PARALLEL_BIT && op == cmd.Parallel) // multi-line instruction { term_output_buffer(); MakeLine(buf); // print the second instruction line init_output_buffer(buf, sizeof(buf)); if (cmd.SpecialModes & TMS_MODE_SIMULATE_USER_PARALLEL) out_line("|| ", COLOR_INSN); else out_line(":: ", COLOR_INSN); const char *insn2 = cmd.get_canon_mnem(); insn2 += strlen(insn2); insn2++; out_line(insn2, COLOR_INSN); } else out_symbol(','); OutChar(' '); } // print the operand out_one_operand(op); } // print immediate values for (op = 0; op < UA_MAXOP; op++) if ( isVoid(cmd.ea, uFlag, op) ) OutImmChar(cmd.Operands[op]); term_output_buffer(); gl_comm = 1; MakeLine(buf); }
void __stdcall out( void ) { char buf[MAXSTR]; init_output_buffer(buf, sizeof(buf)); OutMnem(); if (cmd.Op1.type != o_void) { // output first operand out_one_operand( 0 ); } if( cmd.Op2.type != o_void ) { //pading out_symbol( ',' ); OutChar( ' ' ); // output second operand out_one_operand( 1 ); } if( cmd.Op3.type != o_void ) { //pading out_symbol( ',' ); OutChar( ' ' ); // output third operand out_one_operand( 2 ); } if( cmd.Op4.type != o_void ) { //pading out_symbol( ',' ); OutChar( ' ' ); // output fourth operand out_one_operand( 3 ); } if( cmd.Op5.type != o_void ) { //pading out_symbol( ',' ); OutChar( ' ' ); // output fifth operand out_one_operand( 4 ); } if( cmd.Op6.type != o_void ) { //pading out_symbol( ',' ); OutChar( ' ' ); // output sixth operand out_one_operand( 5 ); } //more processing due to instructions //having more than 6 operands op_t op; op.flags = OF_SHOW; switch(cmd.insnpref) { case SWFACTION_PUSH: { uint16 length = get_word(cmd.ea + 1) + 3; uint16 p = cmd.auxpref; uint8 error = 0; while((length - p) > 0 && error == 0) { switch(get_byte(cmd.ea + p++)) { case 0: //string op.type = o_string; op.dtyp = dt_string; op.addr = cmd.ea + p; //increment the pointer past the string while((length - p) > 0 && get_byte(cmd.ea + p)){ p++; } if ((length - p) > 0) { p++; //adjust for the null caracter } else { error = 1; } break; case 1: //float op.type = o_imm; //op.dtyp = dt_float; op.dtyp = dt_dword; if ((length - p) >= 4) { op.value = get_long(cmd.ea + p); p += 4; } else { error = 1; } break; case 2: //null op.type = o_null; op.dtyp = dt_void; break; case 3: //undefined op.type = o_undefined; op.dtyp = dt_void; break; case 4: //register op.type = o_reg; op.dtyp = dt_byte; if ((length - p) >= 1) { op.reg = get_byte(cmd.ea + p++); } else { error = 1; } break; case 5: //bool op.type = o_bool; op.dtyp = dt_byte; if ((length - p) >= 1) { op.value = get_byte(cmd.ea + p++); } else { error = 1; } break; case 6: //double op.type = o_imm; op.dtyp = dt_double; if ((length - p) >= 8) { double d = (double)(get_qword(cmd.ea + p)); op.value = d; p += 8; } else { error = 1; } break; case 7: //integer op.type = o_imm; op.dtyp = dt_dword; if ((length - p) >= 4) { op.value = get_long(cmd.ea + p); p += 4; } else { error = 1; } break; case 8: //constant 8 op.type = o_const; op.dtyp = dt_byte; if ((length - p) >= 1) { op.value = get_byte(cmd.ea + p++); } else { error = 1; } break; case 9: //constant 16 op.type = o_const; op.dtyp = dt_word; if ((length - p) >= 2) { op.value = get_word(cmd.ea + p); p += 2; } else { error = 1; } default: //unknown type, will not search for more items if this happens error = 1; } //switch if (error == 0) { //pading out_symbol( ',' ); OutChar( ' ' ); // output extra operand outop(op); } } //while } //case break; case SWFACTION_TRY: //ToDo break; case SWFACTION_DEFINEFUNCTION: // Todo: highlight somehow the function body // this must be written some other place because // every time IDA rephreshes the view a duplicate line appears. :( //describe(cmd.ea + cmd.size, true, "%s {", cmd.segpref ? (char*)cmd.Op1.addr : "<anonymous>"); //describe(cmd.ea + cmd.size + get_word(cmd.ea + cmd.size - 2), true, " }"); break; default:; } term_output_buffer(); // attach a possible user-defined comment to this instruction gl_comm = 1; MakeLine( buf ); //multiline instruction printing switch (cmd.insnpref) { case SWFACTION_CONSTANTPOOL: { uint16 length = get_word(cmd.ea + 1); uint8 c = 0, count = 0; if(cmd.Op1.value == 0) break; //limit printed lines to 499 //IDA does not suport more than 500 per item if (cmd.Op1.value > 498) { cmd.Op1.value = 498; msg ("\nWarning: CONSTANTPOOL instruction ar %X has more that 498 declared constants!\n", cmd.ea); } char line[MAXSTR], buf[MAXSTR]; init_output_buffer(line, sizeof(line)); OutChar( ' ' ); out_char('0', COLOR_NUMBER); out_line(": \"",COLOR_SYMBOL); for (uint16 i = 2; i < length; i++) { c = get_byte(cmd.ea + i + 3); if (c == 0) { if (count++ < (cmd.Op1.value - 1)) { out_line("\"", COLOR_SYMBOL); //terminate buffer for current constant //and print it term_output_buffer(); MakeLine(line); //initialize buffer for next constant init_output_buffer(line, sizeof(line)); OutChar( ' ' ); qsnprintf(buf, MAXSTR, "%d", count); out_line(buf, COLOR_NUMBER); out_line(": \"", COLOR_SYMBOL); } else break; } else { if (is_printable(c)) out_char(c, COLOR_CHAR); else { qsnprintf(buf, MAXSTR, "\\x%02X", c); out_line(buf, COLOR_STRING); } }//else }//for out_char('"',COLOR_SYMBOL); //terminate buffer for last constant //and print it term_output_buffer(); MakeLine(line); } break; } }
//---------------------------------------------------------------------- void idaapi out(void) { char buf[MAXSTR]; init_output_buffer(buf, sizeof(buf)); OutMnem(); out_one_operand(0); if ( cmd.Op2.type != o_void ) { out_symbol(','); OutChar(' '); out_one_operand(1); if ( cmd.IsParallel ) { // new line for Parallel instructions term_output_buffer(); MakeLine(buf); init_output_buffer(buf, sizeof(buf)); out_line("|| ", COLOR_INSN); const char *insn2 = NULL; switch ( cmd.itype ) { case TMS320C54_ld_mac: insn2 = "mac "; break; case TMS320C54_ld_macr: insn2 = "macr "; break; case TMS320C54_ld_mas: insn2 = "mas "; break; case TMS320C54_ld_masr: insn2 = "masr "; break; case TMS320C54_st_add: insn2 = "add "; break; case TMS320C54_st_sub: insn2 = "sub "; break; case TMS320C54_st_ld: insn2 = "ld "; break; case TMS320C54_st_mpy: insn2 = "mpy "; break; case TMS320C54_st_mac: insn2 = "mac "; break; case TMS320C54_st_macr: insn2 = "macr "; break; case TMS320C54_st_mas: insn2 = "mas "; break; case TMS320C54_st_masr: insn2 = "masr "; break; default: warning("interr: out parallel instruction"); } out_line(insn2, COLOR_INSN); } if ( cmd.Op3.type != o_void ) { if ( !cmd.IsParallel ) { out_symbol(','); OutChar(' '); } out_one_operand(2); if ( cmd.Op4_type != 0 ) { out_symbol(','); OutChar(' '); switch ( cmd.Op4_type ) { case o_reg: out_register(ph.regNames[cmd.Op4_value]); break; case o_cond8: out_cond8(cmd.Op4_value); break; default: break; } } } } if ( isVoid(cmd.ea, uFlag, 0) ) OutImmChar(cmd.Op1); if ( isVoid(cmd.ea, uFlag, 1) ) OutImmChar(cmd.Op2); if ( isVoid(cmd.ea, uFlag, 2) ) OutImmChar(cmd.Op3); term_output_buffer(); gl_comm = 1; MakeLine(buf); }
//---------------------------------------------------------------------- void idaapi cr16c_out(void) { char str[MAXSTR]; //MAXSTR is an IDA define from pro.h init_output_buffer(str, sizeof(str)); OutMnem(12); //first we output the mnemonic switch(cmd.auxpref) { case ooType0: //no operands break; case ooType1: //4,0x444(r0) ->1,20 out_one_operand(1); out_symbol(','); out_one_operand(2); out_one_operand(0); break; case ooType2: //4 ->0 out_one_operand(0); break; case ooType3: //6(r5), r1 ->20,1 out_one_operand(2); out_one_operand(0); out_symbol(','); out_one_operand(1); break; case ooType4: //$4,0x444 ->1,0 out_one_operand(1); out_symbol(','); out_one_operand(0); break; case ooType5: //0x66666, r5 ->0,1 out_one_operand(0); out_symbol(','); out_one_operand(1); break; case ooType6: //$7, [r12]0x26666 ->1,[2]0 out_one_operand(1); out_symbol(','); out_symbol('['); out_one_operand(2); out_symbol(']'); out_one_operand(0); break; case ooType7: //$7, [r12]0x26666(r3,r2) out_one_operand(1); out_symbol(','); out_symbol('['); out_one_operand(3); out_symbol(']'); out_one_operand(2); out_one_operand(0); break; case ooType8: //[r12]0x26666(r3,r2), r0 out_symbol('['); out_one_operand(3); out_symbol(']'); out_one_operand(2); out_one_operand(0); out_symbol(','); out_one_operand(1); break; case ooType9: //[r12]0x26666,R3 ->[2]0,1 out_symbol('['); out_one_operand(2); out_symbol(']'); out_one_operand(0); out_symbol(','); out_one_operand(1); break; case ooType10: //x,y,z ->0,1,2 out_one_operand(0); out_symbol(','); out_one_operand(1); out_symbol(','); out_one_operand(2); break; case ooType11: //4 ->2 out_one_operand(2); break; case ooType12: //y,x{,z} ->1,0{,2} out_one_operand(1); out_symbol(','); out_one_operand(0); if(cmd.Op3.type != o_void) { out_symbol(','); out_one_operand(2); } break; default: if(cmd.Op1.type != o_void) { out_one_operand(0); } out_snprintf(" , "); if(cmd.Op2.type != o_void) { //then there is an argument to print out_one_operand(1); } out_snprintf(" , "); if(cmd.Op3.type != o_void) { //then there is an argument to print out_one_operand(2); } } term_output_buffer(); gl_comm = 1; //we want comments! MakeLine(str); //output the line with default indentation }
// output an instruction and its operands void idaapi out(void) { char buf[MAXSTR]; init_output_buffer(buf, sizeof(buf)); // setup the output pointer // if this DSP instruction in executed in parallel with a NOP instruction // (example: nop || machi r1, r2), first print the NOP. if ( cmd.segpref & NEXT_INSN_PARALLEL_DSP ) { out_line("nop", COLOR_INSN); OutChar(' '); out_symbol('|'); out_symbol('|'); OutChar(' '); } char postfix[3]; // postfix to eventually insert after the insn name postfix[0] = '\0'; // postfix is null by default // use synthetic option is selected if ( use_synthetic_insn() ) { if ( cmd.segpref & SYNTHETIC_SHORT ) qstrncpy(postfix, (cmd.itype == m32r_ldi ? "8" : ".s"), sizeof(postfix)); if ( cmd.segpref & SYNTHETIC_LONG ) qstrncpy(postfix, (cmd.itype == m32r_ldi ? "16" : ".l"), sizeof(postfix)); } OutMnem(8, postfix); out_one_operand(0); // output the first operand if ( cmd.Op2.type != o_void ) { out_symbol(','); OutChar(' '); out_one_operand(1); // output the second operand } if ( cmd.Op3.type != o_void ) { out_symbol(','); OutChar(' '); out_one_operand(2); // output the third operand } // output a character representation of the immediate values // embedded in the instruction as comments if ( isVoid(cmd.ea,uFlag,0) ) OutImmChar(cmd.Op1); if ( isVoid(cmd.ea,uFlag,1) ) OutImmChar(cmd.Op2); if ( isVoid(cmd.ea,uFlag,2) ) OutImmChar(cmd.Op3); // print a parallel NOP instruction unless the current instruction // is either push or pop (in this special case, nop cannot be executed in //) if ( (cmd.itype != m32r_push && cmd.itype != m32r_pop) && cmd.segpref & NEXT_INSN_PARALLEL_NOP ) { // don't print NOP if the instruction was ld/st reg, fp, and has been converted to ld/st reg, @(arg, fp) // (in other words, in the second operand is a stack variable). // because the o_displ form of ld/st insn is 32 bits, and cannot handle a parallel nop. if ( (cmd.itype != m32r_ld && cmd.itype != m32r_st) || !isStkvar1(uFlag) ) { if ( cmd.Op1.type != o_void ) OutChar(' '); out_symbol('|'); out_symbol('|'); OutChar(' '); out_line("nop", COLOR_INSN); } } if ( cmd.segpref & NEXT_INSN_PARALLEL_OTHER ) { if ( cmd.Op1.type != o_void ) OutChar(' '); out_symbol('|'); out_symbol('|'); out_symbol('\\'); } term_output_buffer(); // terminate the output string gl_comm = 1; // ask to attach a possible user- // defined comment to it MakeLine(buf); // pass the generated line to the // kernel }
//---------------------------------------------------------------------- void out(void) { char buf[MAXSTR]; init_output_buffer(buf, sizeof(buf)); // output instruction mnemonics char postfix[10]; postfix[0] = '\0'; OutMnem(8); bool comma = out_one_operand(0); if ( cmd.Op2.type != o_void ) { if ( comma ) out_symbol(','); out_one_operand(1); } if ( cmd.Op3.type != o_void ) { out_symbol(','); out_one_operand(2); } if ( isVoid(cmd.ea, uFlag, 0) ) OutImmChar(cmd.Op1); if ( isVoid(cmd.ea, uFlag, 1) ) OutImmChar(cmd.Op2); if ( isVoid(cmd.ea, uFlag, 3) ) OutImmChar(cmd.Op3); switch ( cmd.itype ) { case OAK_Dsp_callr: case OAK_Dsp_ret: case OAK_Dsp_br: case OAK_Dsp_call: case OAK_Dsp_reti: case OAK_Dsp_brr: case OAK_Dsp_shfc: case OAK_Dsp_shr: case OAK_Dsp_shr4: case OAK_Dsp_shl: case OAK_Dsp_shl4: case OAK_Dsp_ror: case OAK_Dsp_rol: case OAK_Dsp_clr: case OAK_Dsp_not: case OAK_Dsp_neg: case OAK_Dsp_rnd: case OAK_Dsp_pacr: case OAK_Dsp_clrr: case OAK_Dsp_inc: case OAK_Dsp_dec: case OAK_Dsp_copy: case OAK_Dsp_maxd: case OAK_Dsp_max: case OAK_Dsp_min: qsnprintf(postfix, sizeof(postfix), "%s%s%s", ( (cmd.auxpref & aux_comma_cc) ? ", ": ""), \ cc_text[cmd.auxpref & aux_cc], \ ( (cmd.auxpref & aux_iret_context) ? ", context": "") ); out_line(postfix, COLOR_REG); break; } term_output_buffer(); gl_comm = 1; MakeLine(buf); }