Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-07-04 01:18:59 +03:00
Code Issues Actions 4 Packages Projects Releases Wiki Activity

cpu/h8, cpu/tms32010, cpu/tms32025: Replaced sprintf with type-safe equivalents. (#10979)

Browse Source 
cpu/h8/h8_sci.cpp: Made clock mode a scoped enumeration and fixed a save state issue.
This commit is contained in:
Erik 2023-03-13 15:05:54 +00:00 committed by GitHub
parent 4ad375512b
commit 94ebbd67dd
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
6 changed files with 115 additions and 112 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

104
src/devices/cpu/h8/h8_sci.cpp
View File

@ -20,7 +20,7 @@ h8_sci_device::h8_sci_device(const machine_config &mconfig, const char *tag, dev
cpu(*this, DEVICE_SELF_OWNER), cpu(*this, DEVICE_SELF_OWNER),
tx_cb(*this), tx_cb(*this),
clk_cb(*this), intc(nullptr), intc_tag(nullptr), external_to_internal_ratio(0), internal_to_external_ratio(0), sync_timer(nullptr), eri_int(0), rxi_int(0), txi_int(0), tei_int(0), clk_cb(*this), intc(nullptr), intc_tag(nullptr), external_to_internal_ratio(0), internal_to_external_ratio(0), sync_timer(nullptr), eri_int(0), rxi_int(0), txi_int(0), tei_int(0),
tx_state(0), rx_state(0), tx_bit(0), rx_bit(0), clock_state(0), clock_mode(0), tx_parity(0), rx_parity(0), ext_clock_counter(0), clock_value(false), ext_clock_value(false), rx_value(false), tx_state(0), rx_state(0), tx_bit(0), rx_bit(0), clock_state(0), tx_parity(0), rx_parity(0), ext_clock_counter(0), clock_mode(clock_mode_t::INTERNAL_ASYNC), clock_value(false), ext_clock_value(false), rx_value(false),
rdr(0), tdr(0), smr(0), scr(0), ssr(0), brr(0), rsr(0), tsr(0), clock_base(0), divider(0) rdr(0), tdr(0), smr(0), scr(0), ssr(0), brr(0), rsr(0), tsr(0), clock_base(0), divider(0)
{ {
external_clock_period = attotime::never; external_clock_period = attotime::never;
@ -192,54 +192,51 @@ void h8_sci_device::clock_update()
if(smr & SMR_CA) { if(smr & SMR_CA) {
if(scr & SCR_CKE1) if(scr & SCR_CKE1)
clock_mode = CLKM_EXTERNAL_SYNC; clock_mode = clock_mode_t::EXTERNAL_SYNC;
else else
clock_mode = CLKM_INTERNAL_SYNC_OUT; clock_mode = clock_mode_t::INTERNAL_SYNC_OUT;
} else { } else {
if(scr & SCR_CKE1) if(scr & SCR_CKE1)
clock_mode = CLKM_EXTERNAL_ASYNC; clock_mode = clock_mode_t::EXTERNAL_ASYNC;
else if(scr & SCR_CKE0) else if(scr & SCR_CKE0)
clock_mode = CLKM_INTERNAL_ASYNC_OUT; clock_mode = clock_mode_t::INTERNAL_ASYNC_OUT;
else else
clock_mode = CLKM_INTERNAL_ASYNC; clock_mode = clock_mode_t::INTERNAL_ASYNC;
} }
if(clock_mode == CLKM_EXTERNAL_ASYNC && !external_clock_period.is_never()) if(clock_mode == clock_mode_t::EXTERNAL_ASYNC && !external_clock_period.is_never())
clock_mode = CLKM_EXTERNAL_RATE_ASYNC; clock_mode = clock_mode_t::EXTERNAL_RATE_ASYNC;
if(clock_mode == CLKM_EXTERNAL_SYNC && !external_clock_period.is_never()) if(clock_mode == clock_mode_t::EXTERNAL_SYNC && !external_clock_period.is_never())
clock_mode = CLKM_EXTERNAL_RATE_SYNC; clock_mode = clock_mode_t::EXTERNAL_RATE_SYNC;
if(V>=1) { if(V>=1) {
char buf[4096]; std::string new_message;
switch(clock_mode) { switch(clock_mode) {
case CLKM_INTERNAL_ASYNC: case clock_mode_t::INTERNAL_ASYNC:
sprintf(buf, "clock internal at %d Hz, async, bitrate %d bps\n", int(cpu->clock() / divider), int(cpu->clock() / (divider*16))); new_message = util::string_format("clock internal at %d Hz, async, bitrate %d bps\n", int(cpu->clock() / divider), int(cpu->clock() / (divider*16)));
break; break;
case CLKM_INTERNAL_ASYNC_OUT: case clock_mode_t::INTERNAL_ASYNC_OUT:
sprintf(buf, "clock internal at %d Hz, async, bitrate %d bps, output\n", int(cpu->clock() / divider), int(cpu->clock() / (divider*16))); new_message = util::string_format("clock internal at %d Hz, async, bitrate %d bps, output\n", int(cpu->clock() / divider), int(cpu->clock() / (divider*16)));
break; break;
case clock_mode_t::EXTERNAL_ASYNC:
case CLKM_EXTERNAL_ASYNC: new_message = "clock external, async\n";
sprintf(buf, "clock external, async\n");
break; break;
case CLKM_EXTERNAL_RATE_ASYNC: case clock_mode_t::EXTERNAL_RATE_ASYNC:
sprintf(buf, "clock external at %d Hz, async, bitrate %d bps\n", int(cpu->clock()*internal_to_external_ratio), int(cpu->clock()*internal_to_external_ratio/16)); new_message = util::string_format("clock external at %d Hz, async, bitrate %d bps\n", int(cpu->clock()*internal_to_external_ratio), int(cpu->clock()*internal_to_external_ratio/16));
break; break;
case clock_mode_t::INTERNAL_SYNC_OUT:
case CLKM_INTERNAL_SYNC_OUT: new_message = util::string_format("clock internal at %d Hz, sync, output\n", int(cpu->clock() / (divider*2)));
sprintf(buf, "clock internal at %d Hz, sync, output\n", int(cpu->clock() / (divider*2)));
break; break;
case clock_mode_t::EXTERNAL_SYNC:
case CLKM_EXTERNAL_SYNC: new_message = "clock external, sync\n";
sprintf(buf, "clock external, sync\n");
break; break;
case CLKM_EXTERNAL_RATE_SYNC: case clock_mode_t::EXTERNAL_RATE_SYNC:
sprintf(buf, "clock external at %d Hz, sync\n", int(cpu->clock()*internal_to_external_ratio)); new_message = util::string_format("clock external at %d Hz, sync\n", int(cpu->clock()*internal_to_external_ratio));
break; break;
} }
if(buf != last_clock_message) { if(new_message != last_clock_message) {
last_clock_message = buf; logerror(new_message);
logerror("%s", buf); last_clock_message = std::move(new_message);
} }
} }
} }
@ -297,7 +294,7 @@ void h8_sci_device::device_reset()
tx_state = ST_IDLE; tx_state = ST_IDLE;
rx_state = ST_IDLE; rx_state = ST_IDLE;
clock_state = 0; clock_state = 0;
clock_mode = CLKM_INTERNAL_ASYNC; clock_mode = clock_mode_t::INTERNAL_ASYNC;
clock_base = 0; clock_base = 0;
clock_update(); clock_update();
clock_value = true; clock_value = true;
@ -309,6 +306,12 @@ void h8_sci_device::device_reset()
cur_sync_time = attotime::never; cur_sync_time = attotime::never;
} }
void h8_sci_device::device_post_load()
{
// Set clock_mode correctly as it's not saved
clock_update();
}
TIMER_CALLBACK_MEMBER(h8_sci_device::sync_tick) TIMER_CALLBACK_MEMBER(h8_sci_device::sync_tick)
{ {
// Used only to force system-wide syncs // Used only to force system-wide syncs
@ -328,7 +331,7 @@ WRITE_LINE_MEMBER(h8_sci_device::clk_w)
ext_clock_value = state; ext_clock_value = state;
if(clock_state) { if(clock_state) {
switch(clock_mode) { switch(clock_mode) {
case CLKM_EXTERNAL_ASYNC: case clock_mode_t::EXTERNAL_ASYNC:
if(ext_clock_value) { if(ext_clock_value) {
ext_clock_counter = (ext_clock_counter+1) & 15; ext_clock_counter = (ext_clock_counter+1) & 15;
@ -339,13 +342,16 @@ WRITE_LINE_MEMBER(h8_sci_device::clk_w)
} }
break; break;
case CLKM_EXTERNAL_SYNC: case clock_mode_t::EXTERNAL_SYNC:
if((!ext_clock_value) && (clock_state & CLK_TX)) if((!ext_clock_value) && (clock_state & CLK_TX))
tx_dropped_edge(); tx_dropped_edge();
else if(ext_clock_value && (clock_state & CLK_RX)) else if(ext_clock_value && (clock_state & CLK_RX))
rx_raised_edge(); rx_raised_edge();
break; break;
default:
// Do nothing
break;
} }
} }
} }
@ -355,7 +361,7 @@ uint64_t h8_sci_device::internal_update(uint64_t current_time)
{ {
uint64_t event = 0; uint64_t event = 0;
switch(clock_mode) { switch(clock_mode) {
case CLKM_INTERNAL_SYNC_OUT: case clock_mode_t::INTERNAL_SYNC_OUT:
if(clock_state || !clock_value) { if(clock_state || !clock_value) {
uint64_t fp = divider*2; uint64_t fp = divider*2;
if(current_time >= clock_base) { if(current_time >= clock_base) {
@ -384,8 +390,8 @@ uint64_t h8_sci_device::internal_update(uint64_t current_time)
} }
break; break;
case CLKM_INTERNAL_ASYNC: case clock_mode_t::INTERNAL_ASYNC:
case CLKM_INTERNAL_ASYNC_OUT: case clock_mode_t::INTERNAL_ASYNC_OUT:
if(clock_state || !clock_value) { if(clock_state || !clock_value) {
uint64_t fp = divider*16; uint64_t fp = divider*16;
if(current_time >= clock_base) { if(current_time >= clock_base) {
@ -405,7 +411,7 @@ uint64_t h8_sci_device::internal_update(uint64_t current_time)
rx_raised_edge(); rx_raised_edge();
clock_value = new_clock; clock_value = new_clock;
if(clock_mode == CLKM_INTERNAL_ASYNC_OUT && (clock_state || !clock_value)) if(clock_mode == clock_mode_t::INTERNAL_ASYNC_OUT && (clock_state || !clock_value))
clk_cb(clock_value); clk_cb(clock_value);
} }
} }
@ -414,7 +420,7 @@ uint64_t h8_sci_device::internal_update(uint64_t current_time)
} }
break; break;
case CLKM_EXTERNAL_RATE_SYNC: case clock_mode_t::EXTERNAL_RATE_SYNC:
if(clock_state || !clock_value) { if(clock_state || !clock_value) {
uint64_t ctime = uint64_t(current_time*internal_to_external_ratio*2); uint64_t ctime = uint64_t(current_time*internal_to_external_ratio*2);
if(ctime >= clock_base) { if(ctime >= clock_base) {
@ -438,7 +444,7 @@ uint64_t h8_sci_device::internal_update(uint64_t current_time)
} }
break; break;
case CLKM_EXTERNAL_RATE_ASYNC: case clock_mode_t::EXTERNAL_RATE_ASYNC:
if(clock_state || !clock_value) { if(clock_state || !clock_value) {
uint64_t ctime = uint64_t(current_time*internal_to_external_ratio); uint64_t ctime = uint64_t(current_time*internal_to_external_ratio);
if(ctime >= clock_base) { if(ctime >= clock_base) {
@ -462,8 +468,8 @@ uint64_t h8_sci_device::internal_update(uint64_t current_time)
} }
break; break;
case CLKM_EXTERNAL_ASYNC: case clock_mode_t::EXTERNAL_ASYNC:
case CLKM_EXTERNAL_SYNC: case clock_mode_t::EXTERNAL_SYNC:
break; break;
} }
if(event) { if(event) {
@ -488,32 +494,32 @@ void h8_sci_device::clock_start(int mode)
machine().scheduler().synchronize(); machine().scheduler().synchronize();
clock_state = mode; clock_state = mode;
switch(clock_mode) { switch(clock_mode) {
case CLKM_INTERNAL_ASYNC: case clock_mode_t::INTERNAL_ASYNC:
case CLKM_INTERNAL_ASYNC_OUT: case clock_mode_t::INTERNAL_ASYNC_OUT:
case CLKM_INTERNAL_SYNC_OUT: case clock_mode_t::INTERNAL_SYNC_OUT:
if(V>=2) logerror("Starting internal clock\n"); if(V>=2) logerror("Starting internal clock\n");
clock_base = cpu->total_cycles(); clock_base = cpu->total_cycles();
cpu->internal_update(); cpu->internal_update();
break; break;
case CLKM_EXTERNAL_RATE_ASYNC: case clock_mode_t::EXTERNAL_RATE_ASYNC:
if(V>=2) logerror("Simulating external clock async\n"); if(V>=2) logerror("Simulating external clock async\n");
clock_base = uint64_t(cpu->total_cycles()*internal_to_external_ratio); clock_base = uint64_t(cpu->total_cycles()*internal_to_external_ratio);
cpu->internal_update(); cpu->internal_update();
break; break;
case CLKM_EXTERNAL_RATE_SYNC: case clock_mode_t::EXTERNAL_RATE_SYNC:
if(V>=2) logerror("Simulating external clock sync\n"); if(V>=2) logerror("Simulating external clock sync\n");
clock_base = uint64_t(cpu->total_cycles()*2*internal_to_external_ratio); clock_base = uint64_t(cpu->total_cycles()*2*internal_to_external_ratio);
cpu->internal_update(); cpu->internal_update();
break; break;
case CLKM_EXTERNAL_ASYNC: case clock_mode_t::EXTERNAL_ASYNC:
if(V>=2) logerror("Waiting for external clock async\n"); if(V>=2) logerror("Waiting for external clock async\n");
ext_clock_counter = 15; ext_clock_counter = 15;
break; break;
case CLKM_EXTERNAL_SYNC: case clock_mode_t::EXTERNAL_SYNC:
if(V>=2) logerror("Waiting for external clock sync\n"); if(V>=2) logerror("Waiting for external clock sync\n");
break; break;
} }

24
src/devices/cpu/h8/h8_sci.h
View File

@ -63,14 +63,14 @@ protected:
CLK_RX = 2 CLK_RX = 2
}; };
enum { enum class clock_mode_t {
CLKM_INTERNAL_ASYNC, INTERNAL_ASYNC,
CLKM_INTERNAL_ASYNC_OUT, INTERNAL_ASYNC_OUT,
CLKM_EXTERNAL_ASYNC, EXTERNAL_ASYNC,
CLKM_EXTERNAL_RATE_ASYNC, EXTERNAL_RATE_ASYNC,
CLKM_INTERNAL_SYNC_OUT, INTERNAL_SYNC_OUT,
CLKM_EXTERNAL_SYNC, EXTERNAL_SYNC,
CLKM_EXTERNAL_RATE_SYNC EXTERNAL_RATE_SYNC
}; };
enum { enum {
@ -112,7 +112,8 @@ protected:
int eri_int, rxi_int, txi_int, tei_int; int eri_int, rxi_int, txi_int, tei_int;
int tx_state, rx_state, tx_bit, rx_bit, clock_state, clock_mode, tx_parity, rx_parity, ext_clock_counter; int tx_state, rx_state, tx_bit, rx_bit, clock_state, tx_parity, rx_parity, ext_clock_counter;
clock_mode_t clock_mode;
bool clock_value, ext_clock_value, rx_value; bool clock_value, ext_clock_value, rx_value;
uint8_t rdr, tdr, smr, scr, ssr, brr, rsr, tsr; uint8_t rdr, tdr, smr, scr, ssr, brr, rsr, tsr;
@ -120,8 +121,9 @@ protected:
std::string last_clock_message; std::string last_clock_message;
virtual void device_start() override; void device_start() override;
virtual void device_reset() override; void device_reset() override;
void device_post_load() override;
TIMER_CALLBACK_MEMBER(sync_tick); TIMER_CALLBACK_MEMBER(sync_tick);

28
src/devices/cpu/h8/h8_timer8.cpp
View File

@ -65,73 +65,73 @@ void h8_timer8_channel_device::set_extra_clock_bit(bool bit)
void h8_timer8_channel_device::update_tcr() void h8_timer8_channel_device::update_tcr()
{ {
char buf[4096]; std::ostringstream message;
char *p = buf;
switch(tcr & TCR_CKS) { switch(tcr & TCR_CKS) {
case 0: case 0:
clock_type = STOPPED; clock_type = STOPPED;
clock_divider = 0; clock_divider = 0;
if(V>=1) p += sprintf(p, "clock stopped"); if(V>=1) message << "clock stopped";
break; break;
case 1: case 2: case 3: case 1: case 2: case 3:
clock_type = DIV; clock_type = DIV;
clock_divider = div_tab[((tcr & TCR_CKS)-1)*2 + extra_clock_bit]; clock_divider = div_tab[((tcr & TCR_CKS)-1)*2 + extra_clock_bit];
if(V>=1) p += sprintf(p, "clock %dHz", cpu->clock()/clock_divider); if(V>=1) util::stream_format(message, "clock %dHz", cpu->clock()/clock_divider);
break; break;
case 4: case 4:
clock_type = chain_type; clock_type = chain_type;
clock_divider = 0; clock_divider = 0;
if(V>=1) p += sprintf(p, "clock chained %s", clock_type == CHAIN_A ? "tcora" : "overflow"); if(V>=1) util::stream_format(message, "clock chained %s", clock_type == CHAIN_A ? "tcora" : "overflow");
break; break;
case 5: case 5:
clock_type = INPUT_UP; clock_type = INPUT_UP;
clock_divider = 0; clock_divider = 0;
if(V>=1) p += sprintf(p, "clock external raising edge"); if(V>=1) message << "clock external raising edge";
break; break;
case 6: case 6:
clock_type = INPUT_DOWN; clock_type = INPUT_DOWN;
clock_divider = 0; clock_divider = 0;
if(V>=1) p += sprintf(p, "clock external falling edge"); if(V>=1) message << "clock external falling edge";
break; break;
case 7: case 7:
clock_type = INPUT_UPDOWN; clock_type = INPUT_UPDOWN;
clock_divider = 0; clock_divider = 0;
if(V>=1) p += sprintf(p, "clock external both edges"); if(V>=1) message << "clock external both edges";
break; break;
} }
switch(tcr & TCR_CCLR) { switch(tcr & TCR_CCLR) {
case 0x00: case 0x00:
clear_type = CLEAR_NONE; clear_type = CLEAR_NONE;
if(V>=1) p += sprintf(p, ", no clear"); if(V>=1) message << ", no clear";
break; break;
case 0x08: case 0x08:
clear_type = CLEAR_A; clear_type = CLEAR_A;
if(V>=1) p += sprintf(p, ", clear on tcora"); if(V>=1) message << ", clear on tcora";
break; break;
case 0x10: case 0x10:
clear_type = CLEAR_B; clear_type = CLEAR_B;
if(V>=1) p += sprintf(p, ", clear on tcorb"); if(V>=1) message << ", clear on tcorb";
break; break;
case 0x18: case 0x18:
clear_type = CLEAR_EXTERNAL; clear_type = CLEAR_EXTERNAL;
if(V>=1) p += sprintf(p, ", clear on external"); if(V>=1) message << ", clear on external";
break; break;
} }
if(V>=1) p += sprintf(p, ", irq=%c%c%c\n", if(V>=1) util::stream_format(message, ", irq=%c%c%c\n",
tcr & TCR_CMIEB ? 'b' : '-', tcr & TCR_CMIEB ? 'b' : '-',
tcr & TCR_CMIEA ? 'a' : '-', tcr & TCR_CMIEA ? 'a' : '-',
tcr & TCR_OVIE ? 'o' : '-'); tcr & TCR_OVIE ? 'o' : '-');
logerror(buf);
logerror(std::move(message).str());
} }
uint8_t h8_timer8_channel_device::tcsr_r() uint8_t h8_timer8_channel_device::tcsr_r()

23
src/devices/cpu/h8/h8s2245.cpp
View File

@ -338,17 +338,16 @@ void h8s2245_device::mstpcr_w(offs_t offset, uint16_t data, uint16_t mem_mask)
uint16_t omstpcr = mstpcr; uint16_t omstpcr = mstpcr;
COMBINE_DATA(&mstpcr); COMBINE_DATA(&mstpcr);
if((omstpcr ^ mstpcr) & 0x72e0) { if((omstpcr ^ mstpcr) & 0x72e0) {
char buf[4096]; std::ostringstream message;
char *p = buf; message << "Online modules:";
p += sprintf(p, "Online modules:"); if(mstpcr & 0x0020) message << " sci0";
if(mstpcr & 0x0020) p += sprintf(p, " sci0"); if(mstpcr & 0x0040) message << " sci1";
if(mstpcr & 0x0040) p += sprintf(p, " sci1"); if(mstpcr & 0x0080) message << " sci2";
if(mstpcr & 0x0080) p += sprintf(p, " sci2"); if(mstpcr & 0x0200) message << " adc";
if(mstpcr & 0x0200) p += sprintf(p, " adc"); if(mstpcr & 0x1000) message << " timer8";
if(mstpcr & 0x1000) p += sprintf(p, " timer8"); if(mstpcr & 0x2000) message << " timer16";
if(mstpcr & 0x2000) p += sprintf(p, " timer16"); if(mstpcr & 0x4000) message << " dtc";
if(mstpcr & 0x4000) p += sprintf(p, " dtc"); message << "\n";
p += sprintf(p, "\n"); logerror(std::move(message).str());
logerror(buf);
} }
} }

22
src/devices/cpu/tms32010/32010dsm.cpp
View File

@ -275,28 +275,26 @@ offs_t tms32010_disassembler::disassemble(std::ostream &stream, offs_t pc, const
{ {
if (*cp == '%') if (*cp == '%')
{ {
char num[20];
cp++; cp++;
switch (*cp++) switch (*cp++)
{ {
case 'A': sprintf(num,"%02Xh",a); break; // was $%02X case 'A': util::stream_format(stream,"%02Xh",a); break;
case 'B': case 'B':
if (strncmp(cp, "b ", 3) && strncmp(cp, "cal", 3)) if (strncmp(cp, "b ", 3) && strncmp(cp, "cal", 3))
flags = STEP_COND; flags = STEP_COND;
sprintf(num,"%04Xh",b); // was $%04X util::stream_format(stream,"%04Xh",b);
break; break;
case 'D': sprintf(num,"%02Xh",d); break; case 'D': util::stream_format(stream,"%02Xh",d); break;
case 'K': sprintf(num,"%d",k); break; case 'K': util::stream_format(stream,"%d",k); break;
case 'N': sprintf(num,"%s",nextar[n]); break; case 'N': stream << nextar[n]; break;
case 'M': sprintf(num,"%s",arith[m]); break; case 'M': stream << arith[m]; break;
case 'P': sprintf(num,"PA%d",p); break; case 'P': util::stream_format(stream,"PA%d",p); break;
case 'R': sprintf(num,"AR%d",r); break; case 'R': util::stream_format(stream,"AR%d",r); break;
case 'S': sprintf(num,",%d",s); break; case 'S': util::stream_format(stream,",%d",s); break;
case 'W': sprintf(num,"%04Xh",w); break; case 'W': util::stream_format(stream,"%04Xh",w); break;
default: default:
throw std::logic_error(util::string_format("illegal escape character in format '%s'\n",Op[op].fmt)); throw std::logic_error(util::string_format("illegal escape character in format '%s'\n",Op[op].fmt));
} }
stream << num;
} }
else else
{ {

26
src/devices/cpu/tms32025/32025dsm.cpp
View File

@ -445,27 +445,25 @@ offs_t tms32025_disassembler::disassemble(std::ostream &stream, offs_t pc, const
{ {
if (*cp == '%') if (*cp == '%')
{ {
char num[30];
cp++; cp++;
switch (*cp++) switch (*cp++)
{ {
case 'A': sprintf(num,"%02Xh",a); break; case 'A': util::stream_format(stream,"%02Xh",a); break;
case 'B': sprintf(num,"%04Xh",b); break; case 'B': util::stream_format(stream,"%04Xh",b); break;
case 'C': sprintf(num,"%s",cmpmode[c]); break; case 'C': stream << cmpmode[c]; break;
case 'D': sprintf(num,"%02Xh",d); break; case 'D': util::stream_format(stream,"%02Xh",d); break;
case 'K': sprintf(num,"%d",k); break; case 'K': util::stream_format(stream,"%d",k); break;
case 'M': sprintf(num,"%s",arith[m]); break; case 'M': stream << arith[m]; break;
case 'N': sprintf(num,"%s",nextar[n]); break; case 'N': stream << nextar[n]; break;
case 'P': sprintf(num,"PA$%01X",p); break; case 'P': util::stream_format(stream,"PA$%01X",p); break;
case 'R': sprintf(num,"AR%d",r); break; case 'R': util::stream_format(stream,"AR%d",r); break;
case 'S': sprintf(num,",%d",s); break; case 'S': util::stream_format(stream,",%d",s); break;
case 'T': sprintf(num,"%01Xh",t); break; case 'T': util::stream_format(stream,"%01Xh",t); break;
case 'W': sprintf(num,"%04Xh",w); break; case 'W': util::stream_format(stream,"%04Xh",w); break;
case 'X': break; case 'X': break;
default: default:
throw std::logic_error(util::string_format("illegal escape character in format '%s'\n",Op[op].fmt)); throw std::logic_error(util::string_format("illegal escape character in format '%s'\n",Op[op].fmt));
} }
stream << num;
} }
else else
{ {