summaryrefslogtreecommitdiffstatshomepage
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/devices/cpu/8x300/8x300dasm.cpp94
-rw-r--r--src/devices/cpu/apexc/apexcdsm.cpp38
-rw-r--r--src/devices/cpu/arm/armdasm.cpp196
-rw-r--r--src/devices/cpu/asap/asapdasm.cpp98
-rw-r--r--src/devices/cpu/ccpu/ccpudasm.cpp112
-rw-r--r--src/devices/cpu/cop400/cop410ds.cpp157
-rw-r--r--src/devices/cpu/cop400/cop420ds.cpp180
-rw-r--r--src/devices/cpu/cop400/cop440ds.cpp190
-rw-r--r--src/devices/cpu/cosmac/cosdasm.cpp16
-rw-r--r--src/devices/cpu/cp1610/1610dasm.cpp250
-rw-r--r--src/devices/cpu/cubeqcpu/cubedasm.cpp43
-rw-r--r--src/devices/cpu/dsp16/dsp16dis.cpp77
-rw-r--r--src/mame/drivers/tv910.cpp552
-rw-r--r--src/mame/drivers/vis.cpp24
-rw-r--r--src/mame/mame.lst3
-rw-r--r--src/mame/mess.flt1
-rw-r--r--src/osd/modules/sound/xaudio2_sound.cpp2
17 files changed, 1365 insertions, 668 deletions
diff --git a/src/devices/cpu/8x300/8x300dasm.cpp b/src/devices/cpu/8x300/8x300dasm.cpp
index 562dbaf4693..5b66dbd1f05 100644
--- a/src/devices/cpu/8x300/8x300dasm.cpp
+++ b/src/devices/cpu/8x300/8x300dasm.cpp
@@ -41,9 +41,8 @@ static inline bool is_src_rot(uint16_t opcode)
return true;
}
-CPU_DISASSEMBLE( n8x300 )
+static offs_t internal_disasm_n8x300(cpu_device *device, std::ostream &stream, offs_t pc, const uint8_t *oprom, const uint8_t *opram, int options)
{
- char tmp[16];
unsigned startpc = pc;
uint16_t opcode = (oprom[pc - startpc] << 8) | oprom[pc+1 - startpc];
uint8_t inst = opcode >> 13;
@@ -53,99 +52,90 @@ CPU_DISASSEMBLE( n8x300 )
switch (inst)
{
case 0x00:
- sprintf(buffer,"MOVE ");
- strcat(buffer,reg_names[SRC]);
+ stream << "MOVE " << reg_names[SRC];
if(is_rot(opcode))
- sprintf(tmp,"(%i),",ROTLEN);
+ util::stream_format(stream, "(%i),", ROTLEN);
else
- sprintf(tmp,",%i,",ROTLEN);
- strcat(buffer,tmp);
- strcat(buffer,reg_names[DST]);
+ util::stream_format(stream, ",%i,", ROTLEN);
+ stream << reg_names[DST];
break;
case 0x01:
- sprintf(buffer,"ADD ");
- strcat(buffer,reg_names[SRC]);
+ stream << "ADD " << reg_names[SRC];
if(is_rot(opcode))
- sprintf(tmp,"(%i),",ROTLEN);
+ util::stream_format(stream, "(%i),", ROTLEN);
else
- sprintf(tmp,",%i,",ROTLEN);
- strcat(buffer,tmp);
- strcat(buffer,reg_names[DST]);
+ util::stream_format(stream, ",%i,", ROTLEN);
+ stream << reg_names[DST];
break;
case 0x02:
- sprintf(buffer,"AND ");
- strcat(buffer,reg_names[SRC]);
+ stream << "AND " << reg_names[SRC];
if(is_rot(opcode))
- sprintf(tmp,"(%i),",ROTLEN);
+ util::stream_format(stream, "(%i),", ROTLEN);
else
- sprintf(tmp,",%i,",ROTLEN);
- strcat(buffer,tmp);
- strcat(buffer,reg_names[DST]);
+ util::stream_format(stream, ",%i,", ROTLEN);
+ stream << reg_names[DST];
break;
case 0x03:
- sprintf(buffer,"XOR ");
- strcat(buffer,reg_names[SRC]);
+ stream << "XOR " << reg_names[SRC];
if(is_rot(opcode))
- sprintf(tmp,"(%i),",ROTLEN);
+ util::stream_format(stream, "(%i),", ROTLEN);
else
- sprintf(tmp,",%i,",ROTLEN);
- strcat(buffer,tmp);
- strcat(buffer,reg_names[DST]);
+ util::stream_format(stream, ",%i,", ROTLEN);
+ stream << reg_names[DST];
break;
case 0x04:
- sprintf(buffer,"XEC ");
- strcat(buffer,reg_names[SRC]);
+ stream << "XEC " << reg_names[SRC];
if(is_src_rot(opcode))
{
- sprintf(tmp,",%02XH",IMM8);
- strcat(buffer,tmp);
+ util::stream_format(stream, ",%02XH", IMM8);
}
else
{
- sprintf(tmp,",%i",ROTLEN);
- strcat(buffer,tmp);
- sprintf(tmp,",%02XH",IMM5);
- strcat(buffer,tmp);
+ util::stream_format(stream, ",%i", ROTLEN);
+ util::stream_format(stream, ",%02XH", IMM5);
}
break;
case 0x05:
- sprintf(buffer,"NZT ");
- strcat(buffer,reg_names[SRC]);
+ stream << "NZT " << reg_names[SRC];
if(is_src_rot(opcode))
{
- sprintf(tmp,",%02XH",IMM8);
- strcat(buffer,tmp);
+ util::stream_format(stream, ",%02XH", IMM8);
}
else
{
- sprintf(tmp,",%i",ROTLEN);
- strcat(buffer,tmp);
- sprintf(tmp,",%02XH",IMM5);
- strcat(buffer,tmp);
+ util::stream_format(stream, ",%i", ROTLEN);
+ util::stream_format(stream, ",%02XH", IMM5);
}
break;
case 0x06:
- sprintf(buffer,"XMIT ");
+ stream << "XMIT ";
if(is_src_rot(opcode))
{
- sprintf(tmp,"%02XH,",IMM8);
- strcat(buffer,tmp);
- strcat(buffer,reg_names[SRC]);
+ util::stream_format(stream, "%02XH,", IMM8);
+ stream << reg_names[SRC];
}
else
{
- sprintf(tmp,"%02XH,",IMM5);
- strcat(buffer,tmp);
- strcat(buffer,reg_names[SRC]);
- sprintf(tmp,",%i",ROTLEN);
- strcat(buffer,tmp);
+ util::stream_format(stream, "%02XH,", IMM5);
+ stream << reg_names[SRC];
+ util::stream_format(stream, ",%i", ROTLEN);
}
break;
case 0x07:
- sprintf(buffer,"JMP %04XH",opcode & 0x1fff);
+ util::stream_format(stream, "JMP %04XH", opcode & 0x1fff);
break;
}
return (pc - startpc);
}
+
+
+CPU_DISASSEMBLE(n8x300)
+{
+ std::ostringstream stream;
+ offs_t result = internal_disasm_n8x300(device, stream, pc, oprom, opram, options);
+ std::string stream_str = stream.str();
+ strcpy(buffer, stream_str.c_str());
+ return result;
+}
diff --git a/src/devices/cpu/apexc/apexcdsm.cpp b/src/devices/cpu/apexc/apexcdsm.cpp
index a5d5cfbf754..6113ef2e137 100644
--- a/src/devices/cpu/apexc/apexcdsm.cpp
+++ b/src/devices/cpu/apexc/apexcdsm.cpp
@@ -83,7 +83,7 @@ static const instr_desc instructions[16] =
{ "A", store }, { "S", swap }
};
-CPU_DISASSEMBLE( apexc )
+static offs_t internal_disasm_apexc(cpu_device *device, std::ostream &stream, offs_t pc, const uint8_t *oprom, const uint8_t *opram, int options)
{
uint32_t instruction; /* 32-bit machine instruction */
int x, y, function, c6, vector; /* instruction fields */
@@ -114,7 +114,7 @@ CPU_DISASSEMBLE( apexc )
case two_address:
case branch:
case swap:
- buffer += sprintf(buffer, " %-10s", mnemonic); /* 10 chars*/
+ util::stream_format(stream, " %-10s", mnemonic); /* 10 chars*/
break;
case shiftl:
@@ -123,32 +123,32 @@ CPU_DISASSEMBLE( apexc )
n = c6;
else
n = 64-c6;
- buffer += sprintf(buffer, " %-2s(%2d) ", mnemonic, n); /* 10 chars */
+ util::stream_format(stream, " %-2s(%2d) ", mnemonic, n); /* 10 chars */
break;
case multiply:
n = 33-c6;
if (n == 32)
/* case "32" : do not show bit specifier */
- buffer += sprintf(buffer, " %-10s", mnemonic); /* 10 chars */
+ util::stream_format(stream, " %-10s", mnemonic); /* 10 chars */
else
- buffer += sprintf(buffer, " %-2s(%2d) ", mnemonic, n); /* 10 chars */
+ util::stream_format(stream, " %-2s(%2d) ", mnemonic, n); /* 10 chars */
break;
case store:
if (c6 == 0)
{ /* case "1-32" : do not show bit specifier */
- buffer += sprintf(buffer, " %-10s", mnemonic); /* 10 chars*/
+ util::stream_format(stream, " %-10s", mnemonic); /* 10 chars*/
}
else if (c6 & 0x20)
{ /* case "1-n" */
n = c6-32;
- buffer += sprintf(buffer, " %-2s (1-%02d) ", mnemonic, n); /* 10 chars */
+ util::stream_format(stream, " %-2s (1-%02d) ", mnemonic, n); /* 10 chars */
}
else
{ /* case "n-32" */
n = c6+1;
- buffer += sprintf(buffer, " %-2s(%02d-32) ", mnemonic, n); /* 8 chars */
+ util::stream_format(stream, " %-2s(%02d-32) ", mnemonic, n); /* 8 chars */
}
}
@@ -156,29 +156,39 @@ CPU_DISASSEMBLE( apexc )
switch (the_desc->format)
{
case branch:
- buffer--; /* eat last char */
- buffer += sprintf(buffer, "<%03X(%02d/%02d) >=", x<<2, (x >> 5) & 0x1f, x & 0x1f); /* 10+1 chars */
+ stream.seekp(-1, std::ios_base::cur); /* eat last char */
+ util::stream_format(stream, "<%03X(%02d/%02d) >=", x<<2, (x >> 5) & 0x1f, x & 0x1f); /* 10+1 chars */
break;
case multiply:
case swap:
- buffer += sprintf(buffer, " (%02d) ", (x >> 5) & 0x1f); /* 10 chars */
+ util::stream_format(stream, " (%02d) ", (x >> 5) & 0x1f); /* 10 chars */
break;
case one_address:
case shiftl:
case shiftr:
- buffer += sprintf(buffer, " "); /* 10 chars */
+ util::stream_format(stream, " "); /* 10 chars */
break;
case two_address:
case store:
- buffer += sprintf(buffer, "%03X(%02d/%02d) ", x<<2, (x >> 5) & 0x1f, x & 0x1f); /* 10 chars */
+ util::stream_format(stream, "%03X(%02d/%02d) ", x<<2, (x >> 5) & 0x1f, x & 0x1f); /* 10 chars */
break;
}
/* print Y address */
- buffer += sprintf(buffer, "%03X(%02d/%02d)", y<<2, (y >> 5) & 0x1f, y & 0x1f); /* 7 chars */
+ util::stream_format(stream, "%03X(%02d/%02d)", y<<2, (y >> 5) & 0x1f, y & 0x1f); /* 7 chars */
return 4;
}
+
+
+CPU_DISASSEMBLE(apexc)
+{
+ std::ostringstream stream;
+ offs_t result = internal_disasm_apexc(device, stream, pc, oprom, opram, options);
+ std::string stream_str = stream.str();
+ strcpy(buffer, stream_str.c_str());
+ return result;
+}
diff --git a/src/devices/cpu/arm/armdasm.cpp b/src/devices/cpu/arm/armdasm.cpp
index 08a0b282afe..b93b509789e 100644
--- a/src/devices/cpu/arm/armdasm.cpp
+++ b/src/devices/cpu/arm/armdasm.cpp
@@ -9,7 +9,7 @@
#include "emu.h"
#include "arm.h"
-static char *WriteImmediateOperand( char *pBuf, uint32_t opcode )
+static void WriteImmediateOperand( std::ostream &stream, uint32_t opcode )
{
/* rrrrbbbbbbbb */
uint32_t imm;
@@ -18,69 +18,70 @@ static char *WriteImmediateOperand( char *pBuf, uint32_t opcode )
imm = opcode&0xff;
r = ((opcode>>8)&0xf)*2;
imm = (imm>>r)|(r?(imm<<(32-r)):0);
- pBuf += sprintf( pBuf, ", #$%x", imm );
- return pBuf;
+ util::stream_format( stream, ", #$%x", imm );
}
-static char *WriteDataProcessingOperand( char *pBuf, uint32_t opcode, int printOp0, int printOp1, int printOp2 )
+static void WriteDataProcessingOperand( std::ostream &stream, uint32_t opcode, int printOp0, int printOp1, int printOp2 )
{
/* ccccctttmmmm */
static const char *const pRegOp[4] = { "LSL","LSR","ASR","ROR" };
if (printOp0)
- pBuf += sprintf(pBuf,"R%d, ", (opcode>>12)&0xf);
+ util::stream_format(stream, "R%d, ", (opcode>>12)&0xf);
if (printOp1)
- pBuf += sprintf(pBuf,"R%d, ", (opcode>>16)&0xf);
+ util::stream_format(stream, "R%d, ", (opcode>>16)&0xf);
/* Immediate Op2 */
- if( opcode&0x02000000 )
- return WriteImmediateOperand(pBuf-2,opcode);
+ if (opcode & 0x02000000)
+ {
+ stream.seekp(-2, std::ios_base::cur);
+ WriteImmediateOperand(stream, opcode);
+ return;
+ }
/* Register Op2 */
if (printOp2)
- pBuf += sprintf(pBuf,"R%d, ", (opcode>>0)&0xf);
+ util::stream_format(stream, "R%d, ", (opcode>>0)&0xf);
- pBuf += sprintf(pBuf, "%s ", pRegOp[(opcode>>5)&3] );
+ util::stream_format(stream, "%s ", pRegOp[(opcode>>5)&3]);
if( opcode&0x10 ) /* Shift amount specified in bottom bits of RS */
{
- pBuf += sprintf( pBuf, "R%d", (opcode>>8)&0xf );
+ util::stream_format( stream, "R%d", (opcode>>8)&0xf );
}
else /* Shift amount immediate 5 bit unsigned integer */
{
int c=(opcode>>7)&0x1f;
if( c==0 ) c = 32;
- pBuf += sprintf( pBuf, "#%d", c );
+ util::stream_format( stream, "#%d", c );
}
- return pBuf;
}
-static char *WriteRegisterOperand1( char *pBuf, uint32_t opcode )
+static void WriteRegisterOperand1( std::ostream &stream, uint32_t opcode )
{
/* ccccctttmmmm */
static const char *const pRegOp[4] = { "LSL","LSR","ASR","ROR" };
- pBuf += sprintf(
- pBuf,
+ util::stream_format(
+ stream,
", R%d %s ", /* Operand 1 register, Operand 2 register, shift type */
(opcode>> 0)&0xf,
- pRegOp[(opcode>>5)&3] );
+ pRegOp[(opcode>>5)&3]);
if( opcode&0x10 ) /* Shift amount specified in bottom bits of RS */
{
- pBuf += sprintf( pBuf, "R%d", (opcode>>7)&0xf );
+ util::stream_format( stream, "R%d", (opcode>>7)&0xf );
}
else /* Shift amount immediate 5 bit unsigned integer */
{
int c=(opcode>>7)&0x1f;
if( c==0 ) c = 32;
- pBuf += sprintf( pBuf, "#%d", c );
+ util::stream_format( stream, "#%d", c );
}
- return pBuf;
} /* WriteRegisterOperand */
-static char *WriteBranchAddress( char *pBuf, uint32_t pc, uint32_t opcode )
+static void WriteBranchAddress( std::ostream &stream, uint32_t pc, uint32_t opcode )
{
opcode &= 0x00ffffff;
if( opcode&0x00800000 )
@@ -88,24 +89,18 @@ static char *WriteBranchAddress( char *pBuf, uint32_t pc, uint32_t opcode )
opcode |= 0xff000000; /* sign-extend */
}
pc += 8+4*opcode;
- sprintf( pBuf, "$%x", pc );
- return pBuf;
+ util::stream_format( stream, "$%x", pc );
} /* WriteBranchAddress */
-static char *WritePadding( char *pBuf, const char *pBuf0 )
+static void WritePadding(std::ostream &stream, std::streampos start_position)
{
- pBuf0 += 8;
- while( pBuf<pBuf0 )
- {
- *pBuf++ = ' ';
- }
- return pBuf;
+ std::streamoff difference = stream.tellp() - start_position;
+ for (std::streamoff i = difference; i < 8; i++)
+ stream << ' ';
}
-static uint32_t arm_disasm( char *pBuf, uint32_t pc, uint32_t opcode )
+static uint32_t arm_disasm( std::ostream &stream, uint32_t pc, uint32_t opcode )
{
- const char *pBuf0;
-
static const char *const pConditionCodeTable[16] =
{
"EQ","NE","CS","CC",
@@ -122,9 +117,9 @@ static uint32_t arm_disasm( char *pBuf, uint32_t pc, uint32_t opcode )
};
const char *pConditionCode;
uint32_t dasmflags = 0;
+ std::streampos start_position = stream.tellp();
pConditionCode= pConditionCodeTable[opcode>>28];
- pBuf0 = pBuf;
if( (opcode&0x0fc000f0)==0x00000090u )
{
@@ -132,28 +127,28 @@ static uint32_t arm_disasm( char *pBuf, uint32_t pc, uint32_t opcode )
/* xxxx0000 00ASdddd nnnnssss 1001mmmm */
if( opcode&0x00200000 )
{
- pBuf += sprintf( pBuf, "MLA" );
+ util::stream_format( stream, "MLA" );
}
else
{
- pBuf += sprintf( pBuf, "MUL" );
+ util::stream_format( stream, "MUL" );
}
- pBuf += sprintf( pBuf, "%s", pConditionCode );
+ util::stream_format( stream, "%s", pConditionCode );
if( opcode&0x00100000 )
{
- *pBuf++ = 'S';
+ stream << 'S';
}
- pBuf = WritePadding( pBuf, pBuf0 );
+ WritePadding(stream, start_position);
- pBuf += sprintf( pBuf,
+ util::stream_format(stream,
"R%d, R%d, R%d",
(opcode>>16)&0xf,
(opcode&0xf),
- (opcode>>8)&0xf );
+ (opcode>>8)&0xf);
if( opcode&0x00200000 )
{
- pBuf += sprintf( pBuf, ", R%d", (opcode>>12)&0xf );
+ util::stream_format( stream, ", R%d", (opcode>>12)&0xf );
}
}
else if( (opcode&0x0c000000)==0 )
@@ -164,17 +159,17 @@ static uint32_t arm_disasm( char *pBuf, uint32_t pc, uint32_t opcode )
/* xxxx001a aaaSnnnn ddddrrrr bbbbbbbb */
/* xxxx000a aaaSnnnn ddddcccc ctttmmmm */
- pBuf += sprintf(
- pBuf, "%s%s",
+ util::stream_format(stream,
+ "%s%s",
pOperation[op],
- pConditionCode );
+ pConditionCode);
if( (opcode&0x01000000) )
{
- *pBuf++ = 'S';
+ stream << 'S';
}
- pBuf = WritePadding( pBuf, pBuf0 );
+ WritePadding(stream, start_position);
switch (op) {
case 0x00:
@@ -187,20 +182,20 @@ static uint32_t arm_disasm( char *pBuf, uint32_t pc, uint32_t opcode )
case 0x07:
case 0x0c:
case 0x0e:
- WriteDataProcessingOperand(pBuf, opcode, 1, 1, 1);
+ WriteDataProcessingOperand(stream, opcode, 1, 1, 1);
break;
case 0x08:
case 0x09:
case 0x0a:
case 0x0b:
- WriteDataProcessingOperand(pBuf, opcode, 0, 1, 1);
+ WriteDataProcessingOperand(stream, opcode, 0, 1, 1);
break;
case 0x0d:
/* look for mov pc,lr */
if (((opcode >> 12) & 0x0f) == 15 && ((opcode >> 0) & 0x0f) == 14 && (opcode & 0x02000000) == 0)
dasmflags = DASMFLAG_STEP_OUT;
case 0x0f:
- WriteDataProcessingOperand(pBuf, opcode, 1, 0, 1);
+ WriteDataProcessingOperand(stream, opcode, 1, 0, 1);
break;
}
}
@@ -212,17 +207,17 @@ static uint32_t arm_disasm( char *pBuf, uint32_t pc, uint32_t opcode )
/* xxxx011P UBWLnnnn ddddcccc ctt0mmmm Register form */
if( opcode&0x00100000 )
{
- pBuf += sprintf( pBuf, "LDR" );
+ util::stream_format( stream, "LDR" );
}
else
{
- pBuf += sprintf( pBuf, "STR" );
+ util::stream_format( stream, "STR" );
}
- pBuf += sprintf( pBuf, "%s", pConditionCode );
+ util::stream_format( stream, "%s", pConditionCode );
if( opcode&0x00400000 )
{
- pBuf += sprintf( pBuf, "B" );
+ util::stream_format( stream, "B" );
}
if( opcode&0x00200000 )
@@ -231,36 +226,36 @@ static uint32_t arm_disasm( char *pBuf, uint32_t pc, uint32_t opcode )
if( opcode&0x01000000 )
{
/* pre-indexed addressing */
- pBuf += sprintf( pBuf, "!" );
+ util::stream_format( stream, "!" );
}
else
{
/* post-indexed addressing */
- pBuf += sprintf( pBuf, "T" );
+ util::stream_format( stream, "T" );
}
}
- pBuf = WritePadding( pBuf, pBuf0 );
- pBuf += sprintf( pBuf, "R%d, [R%d",
+ WritePadding(stream, start_position);
+ util::stream_format( stream, "R%d, [R%d",
(opcode>>12)&0xf, (opcode>>16)&0xf );
if( opcode&0x02000000 )
{
/* register form */
- pBuf = WriteRegisterOperand1( pBuf, opcode );
- pBuf += sprintf( pBuf, "]" );
+ WriteRegisterOperand1( stream, opcode );
+ util::stream_format( stream, "]" );
}
else
{
/* immediate form */
- pBuf += sprintf( pBuf, "]" );
+ util::stream_format( stream, "]" );
if( opcode&0x00800000 )
{
- pBuf += sprintf( pBuf, ", #$%x", opcode&0xfff );
+ util::stream_format( stream, ", #$%x", opcode&0xfff );
}
else
{
- pBuf += sprintf( pBuf, ", -#$%x", opcode&0xfff );
+ util::stream_format( stream, ", -#$%x", opcode&0xfff );
}
}
}
@@ -271,33 +266,33 @@ static uint32_t arm_disasm( char *pBuf, uint32_t pc, uint32_t opcode )
if( opcode&0x00100000 )
{
- pBuf += sprintf( pBuf, "LDM" );
+ util::stream_format( stream, "LDM" );
}
else
{
- pBuf += sprintf( pBuf, "STM" );
+ util::stream_format( stream, "STM" );
}
- pBuf += sprintf( pBuf, "%s", pConditionCode );
+ util::stream_format( stream, "%s", pConditionCode );
if( opcode&0x01000000 )
{
- pBuf += sprintf( pBuf, "P" );
+ util::stream_format( stream, "P" );
}
if( opcode&0x00800000 )
{
- pBuf += sprintf( pBuf, "U" );
+ util::stream_format( stream, "U" );
}
if( opcode&0x00400000 )
{
- pBuf += sprintf( pBuf, "^" );
+ util::stream_format( stream, "^" );
}
if( opcode&0x00200000 )
{
- pBuf += sprintf( pBuf, "W" );
+ util::stream_format( stream, "W" );
}
- pBuf = WritePadding( pBuf, pBuf0 );
- pBuf += sprintf( pBuf, "[R%d], {",(opcode>>16)&0xf);
+ WritePadding(stream, start_position);
+ util::stream_format( stream, "[R%d], {",(opcode>>16)&0xf);
{
int j=0,last=0,found=0;
@@ -308,20 +303,20 @@ static uint32_t arm_disasm( char *pBuf, uint32_t pc, uint32_t opcode )
}
else if ((opcode&(1<<j))==0 && found) {
if (last==j-1)
- pBuf += sprintf( pBuf, " R%d,",last);
+ util::stream_format( stream, " R%d,",last);
else
- pBuf += sprintf( pBuf, " R%d-R%d,",last,j-1);
+ util::stream_format( stream, " R%d-R%d,",last,j-1);
found=0;
}
}
if (found && last==15)
- pBuf += sprintf( pBuf, " R15,");
+ util::stream_format( stream, " R15,");
else if (found)
- pBuf += sprintf( pBuf, " R%d-R%d,",last,15);
+ util::stream_format( stream, " R%d-R%d,",last,15);
}
- pBuf--;
- pBuf += sprintf( pBuf, " }");
+ stream.seekp(-1, std::ios_base::cur);
+ util::stream_format( stream, " }");
}
else if( (opcode&0x0e000000)==0x0a000000 )
{
@@ -329,19 +324,19 @@ static uint32_t arm_disasm( char *pBuf, uint32_t pc, uint32_t opcode )
/* xxxx101L oooooooo oooooooo oooooooo */
if( opcode&0x01000000 )
{
- pBuf += sprintf( pBuf, "BL" );
+ util::stream_format( stream, "BL" );
dasmflags = DASMFLAG_STEP_OVER;
}
else
{
- pBuf += sprintf( pBuf, "B" );
+ util::stream_format( stream, "B" );
}
- pBuf += sprintf( pBuf, "%s", pConditionCode );
+ util::stream_format( stream, "%s", pConditionCode );
- pBuf = WritePadding( pBuf, pBuf0 );
+ WritePadding(stream, start_position);
- pBuf = WriteBranchAddress( pBuf, pc, opcode );
+ WriteBranchAddress( stream, pc, opcode );
}
else if( (opcode&0x0f000000) == 0x0e000000 )
{
@@ -351,50 +346,59 @@ static uint32_t arm_disasm( char *pBuf, uint32_t pc, uint32_t opcode )
{
if( (opcode&0x0f100010)==0x0e100010 )
{
- pBuf += sprintf( pBuf, "MRC" );
+ util::stream_format( stream, "MRC" );
}
else if( (opcode&0x0f100010)==0x0e000010 )
{
- pBuf += sprintf( pBuf, "MCR" );
+ util::stream_format( stream, "MCR" );
}
else
{
- pBuf += sprintf( pBuf, "???" );
+ util::stream_format( stream, "???" );
}
- pBuf += sprintf( pBuf, "%s", pConditionCode );
- pBuf = WritePadding( pBuf, pBuf0 );
- pBuf += sprintf( pBuf, "R%d, CR%d {CRM%d, q%d}",(opcode>>12)&0xf, (opcode>>16)&0xf, (opcode>>0)&0xf, (opcode>>5)&0x7);
+ util::stream_format( stream, "%s", pConditionCode );
+ WritePadding(stream, start_position);
+ util::stream_format( stream, "R%d, CR%d {CRM%d, q%d}",(opcode>>12)&0xf, (opcode>>16)&0xf, (opcode>>0)&0xf, (opcode>>5)&0x7);
/* Nb: full form should be o, p, R, CR, CRM, q */
}
else if( (opcode&0x0f000010)==0x0e000000 )
{
- pBuf += sprintf( pBuf, "CDP" );
- pBuf += sprintf( pBuf, "%s", pConditionCode );
- pBuf = WritePadding( pBuf, pBuf0 );
- pBuf += sprintf( pBuf, "%08x", opcode );
+ util::stream_format( stream, "CDP" );
+ util::stream_format( stream, "%s", pConditionCode );
+ WritePadding(stream, start_position);
+ util::stream_format( stream, "%08x", opcode );
}
else
{
- pBuf += sprintf( pBuf, "???" );
+ util::stream_format( stream, "???" );
}
}
else if( (opcode&0x0f000000) == 0x0f000000 )
{
/* Software Interrupt */
- pBuf += sprintf( pBuf, "SWI%s $%x",
+ util::stream_format( stream, "SWI%s $%x",
pConditionCode,
opcode&0x00ffffff );
dasmflags = DASMFLAG_STEP_OVER;
}
else
{
- pBuf += sprintf( pBuf, "Undefined" );
+ util::stream_format( stream, "Undefined" );
}
return dasmflags | DASMFLAG_SUPPORTED;
}
+static uint32_t arm_disasm(char *buffer, uint32_t pc, uint32_t opcode)
+{
+ std::ostringstream stream;
+ uint32_t result = arm_disasm(stream, pc, opcode);
+ std::string stream_str = stream.str();
+ strcpy(buffer, stream_str.c_str());
+ return result;
+}
+
CPU_DISASSEMBLE( arm )
{
uint32_t opcode = oprom[0] | (oprom[1] << 8) | (oprom[2] << 16) | (oprom[3] << 24);
diff --git a/src/devices/cpu/asap/asapdasm.cpp b/src/devices/cpu/asap/asapdasm.cpp
index 47665331da2..1f24fef64ec 100644
--- a/src/devices/cpu/asap/asapdasm.cpp
+++ b/src/devices/cpu/asap/asapdasm.cpp
@@ -45,7 +45,7 @@ static inline char *src2(uint32_t op, int scale)
return temp;
}
-CPU_DISASSEMBLE( asap )
+static offs_t internal_disasm_asap(cpu_device *device, std::ostream &stream, offs_t pc, const uint8_t *oprom, const uint8_t *opram, int options)
{
uint32_t op = oprom[0] | (oprom[1] << 8) | (oprom[2] << 16) | (oprom[3] << 24);
int opcode = op >> 27;
@@ -58,89 +58,99 @@ CPU_DISASSEMBLE( asap )
switch (opcode)
{
- case 0x00: sprintf(buffer, "trap $00"); flags = DASMFLAG_STEP_OVER; break;
- case 0x01: sprintf(buffer, "b%s $%08x", condition[rdst & 15], pc + ((int32_t)(op << 10) >> 8)); break;
+ case 0x00: util::stream_format(stream, "trap $00"); flags = DASMFLAG_STEP_OVER; break;
+ case 0x01: util::stream_format(stream, "b%s $%08x", condition[rdst & 15], pc + ((int32_t)(op << 10) >> 8)); break;
case 0x02: if ((op & 0x003fffff) == 3)
{
uint32_t nextop = oprom[4] | (oprom[5] << 8) | (oprom[6] << 16) | (oprom[7] << 24);
if ((nextop >> 27) == 0x10 && ((nextop >> 22) & 31) == rdst && (nextop & 0xffff) == 0)
{
uint32_t nextnextop = oprom[8] | (oprom[9] << 8) | (oprom[10] << 16) | (oprom[11] << 24);
- sprintf(buffer, "llit%s $%08x,%s", setcond[cond], nextnextop, reg[rdst]);
+ util::stream_format(stream, "llit%s $%08x,%s", setcond[cond], nextnextop, reg[rdst]);
return 12 | DASMFLAG_STEP_OVER | DASMFLAG_SUPPORTED;
}
}
if (rdst)
{
flags = DASMFLAG_STEP_OVER | DASMFLAG_STEP_OVER_EXTRA(1);
- sprintf(buffer, "bsr %s,$%08x", reg[rdst], pc + ((int32_t)(op << 10) >> 8));
+ util::stream_format(stream, "bsr %s,$%08x", reg[rdst], pc + ((int32_t)(op << 10) >> 8));
}
else
- sprintf(buffer, "bra $%08x", pc + ((int32_t)(op << 10) >> 8));
+ util::stream_format(stream, "bra $%08x", pc + ((int32_t)(op << 10) >> 8));
break;
- case 0x03: sprintf(buffer, "lea%s %s[%s],%s", setcond[cond], reg[rsrc1], src2(op,2), reg[rdst]); break;
- case 0x04: sprintf(buffer, "leah%s %s[%s],%s", setcond[cond], reg[rsrc1], src2(op,1), reg[rdst]); break;
- case 0x05: sprintf(buffer, "subr%s %s,%s,%s", setcond[cond], reg[rsrc1], src2(op,0), reg[rdst]); break;
- case 0x06: sprintf(buffer, "xor%s %s,%s,%s", setcond[cond], reg[rsrc1], src2(op,0), reg[rdst]); break;
- case 0x07: sprintf(buffer, "xorn%s %s,%s,%s", setcond[cond], reg[rsrc1], src2(op,0), reg[rdst]); break;
+ case 0x03: util::stream_format(stream, "lea%s %s[%s],%s", setcond[cond], reg[rsrc1], src2(op,2), reg[rdst]); break;
+ case 0x04: util::stream_format(stream, "leah%s %s[%s],%s", setcond[cond], reg[rsrc1], src2(op,1), reg[rdst]); break;
+ case 0x05: util::stream_format(stream, "subr%s %s,%s,%s", setcond[cond], reg[rsrc1], src2(op,0), reg[rdst]); break;
+ case 0x06: util::stream_format(stream, "xor%s %s,%s,%s", setcond[cond], reg[rsrc1], src2(op,0), reg[rdst]); break;
+ case 0x07: util::stream_format(stream, "xorn%s %s,%s,%s", setcond[cond], reg[rsrc1], src2(op,0), reg[rdst]); break;
case 0x08: if (!rsrc1 && !rdst && rsrc2_iszero)
- sprintf(buffer, "nop");
+ util::stream_format(stream, "nop");
else if (!rsrc1)
- sprintf(buffer, "mov%s %s,%s", setcond[cond], src2(op,0), reg[rdst]);
+ util::stream_format(stream, "mov%s %s,%s", setcond[cond], src2(op,0), reg[rdst]);
else if (rsrc2_iszero)
- sprintf(buffer, "mov%s %s,%s", setcond[cond], reg[rsrc1], reg[rdst]);
+ util::stream_format(stream, "mov%s %s,%s", setcond[cond], reg[rsrc1], reg[rdst]);
else
- sprintf(buffer, "add%s %s,%s,%s", setcond[cond], reg[rsrc1], src2(op,0), reg[rdst]);
+ util::stream_format(stream, "add%s %s,%s,%s", setcond[cond], reg[rsrc1], src2(op,0), reg[rdst]);
break;
- case 0x09: sprintf(buffer, "sub%s %s,%s,%s", setcond[cond], reg[rsrc1], src2(op,0), reg[rdst]); break;
- case 0x0a: sprintf(buffer, "addc%s %s,%s,%s", setcond[cond], reg[rsrc1], src2(op,0), reg[rdst]); break;
- case 0x0b: sprintf(buffer, "subc%s %s,%s,%s", setcond[cond], reg[rsrc1], src2(op,0), reg[rdst]); break;
- case 0x0c: sprintf(buffer, "and%s %s,%s,%s", setcond[cond], reg[rsrc1], src2(op,0), reg[rdst]); break;
- case 0x0d: sprintf(buffer, "andn%s %s,%s,%s", setcond[cond], reg[rsrc1], src2(op,0), reg[rdst]); break;
+ case 0x09: util::stream_format(stream, "sub%s %s,%s,%s", setcond[cond], reg[rsrc1], src2(op,0), reg[rdst]); break;
+ case 0x0a: util::stream_format(stream, "addc%s %s,%s,%s", setcond[cond], reg[rsrc1], src2(op,0), reg[rdst]); break;
+ case 0x0b: util::stream_format(stream, "subc%s %s,%s,%s", setcond[cond], reg[rsrc1], src2(op,0), reg[rdst]); break;
+ case 0x0c: util::stream_format(stream, "and%s %s,%s,%s", setcond[cond], reg[rsrc1], src2(op,0), reg[rdst]); break;
+ case 0x0d: util::stream_format(stream, "andn%s %s,%s,%s", setcond[cond], reg[rsrc1], src2(op,0), reg[rdst]); break;
case 0x0e: if (!rsrc1 && !rdst && rsrc2_iszero)
- sprintf(buffer, "nop");
+ util::stream_format(stream, "nop");
else if (!rsrc1)
- sprintf(buffer, "mov%s %s,%s", setcond[cond], src2(op,0), reg[rdst]);
+ util::stream_format(stream, "mov%s %s,%s", setcond[cond], src2(op,0), reg[rdst]);
else if (rsrc2_iszero)
- sprintf(buffer, "mov%s %s,%s", setcond[cond], reg[rsrc1], reg[rdst]);
+ util::stream_format(stream, "mov%s %s,%s", setcond[cond], reg[rsrc1], reg[rdst]);
else
- sprintf(buffer, "or%s %s,%s,%s", setcond[cond], reg[rsrc1], src2(op,0), reg[rdst]);
+ util::stream_format(stream, "or%s %s,%s,%s", setcond[cond], reg[rsrc1], src2(op,0), reg[rdst]);
break;
- case 0x0f: sprintf(buffer, "orn%s %s,%s,%s", setcond[cond], reg[rsrc1], src2(op,0), reg[rdst]); break;
- case 0x10: sprintf(buffer, "ld%s %s[%s],%s", setcond[cond], reg[rsrc1], src2(op,2), reg[rdst]); break;
- case 0x11: sprintf(buffer, "ldh%s %s[%s],%s", setcond[cond], reg[rsrc1], src2(op,1), reg[rdst]); break;
- case 0x12: sprintf(buffer, "lduh%s %s[%s],%s", setcond[cond], reg[rsrc1], src2(op,1), reg[rdst]); break;
- case 0x13: sprintf(buffer, "sth%s %s[%s],%s", setcond[cond], reg[rsrc1], src2(op,1), reg[rdst]); break;
- case 0x14: sprintf(buffer, "st%s %s[%s],%s", setcond[cond], reg[rsrc1], src2(op,2), reg[rdst]); break;
- case 0x15: sprintf(buffer, "ldb%s %s[%s],%s", setcond[cond], reg[rsrc1], src2(op,0), reg[rdst]); break;
- case 0x16: sprintf(buffer, "ldub%s %s[%s],%s", setcond[cond], reg[rsrc1], src2(op,0), reg[rdst]); break;
- case 0x17: sprintf(buffer, "stb%s %s[%s],%s", setcond[cond], reg[rsrc1], src2(op,0), reg[rdst]); break;
- case 0x18: sprintf(buffer, "ashr%s %s,%s,%s", setcond[cond], reg[rsrc1], src2(op,0), reg[rdst]); break;
- case 0x19: sprintf(buffer, "lshr%s %s,%s,%s", setcond[cond], reg[rsrc1], src2(op,0), reg[rdst]); break;
- case 0x1a: sprintf(buffer, "ashl%s %s,%s,%s", setcond[cond], reg[rsrc1], src2(op,0), reg[rdst]); break;
- case 0x1b: sprintf(buffer, "rotl%s %s,%s,%s", setcond[cond], reg[rsrc1], src2(op,0), reg[rdst]); break;
- case 0x1c: sprintf(buffer, "getps %s", reg[rdst]); break;
- case 0x1d: sprintf(buffer, "putps %s", src2(op,0)); break;
+ case 0x0f: util::stream_format(stream, "orn%s %s,%s,%s", setcond[cond], reg[rsrc1], src2(op,0), reg[rdst]); break;
+ case 0x10: util::stream_format(stream, "ld%s %s[%s],%s", setcond[cond], reg[rsrc1], src2(op,2), reg[rdst]); break;
+ case 0x11: util::stream_format(stream, "ldh%s %s[%s],%s", setcond[cond], reg[rsrc1], src2(op,1), reg[rdst]); break;
+ case 0x12: util::stream_format(stream, "lduh%s %s[%s],%s", setcond[cond], reg[rsrc1], src2(op,1), reg[rdst]); break;
+ case 0x13: util::stream_format(stream, "sth%s %s[%s],%s", setcond[cond], reg[rsrc1], src2(op,1), reg[rdst]); break;
+ case 0x14: util::stream_format(stream, "st%s %s[%s],%s", setcond[cond], reg[rsrc1], src2(op,2), reg[rdst]); break;
+ case 0x15: util::stream_format(stream, "ldb%s %s[%s],%s", setcond[cond], reg[rsrc1], src2(op,0), reg[rdst]); break;
+ case 0x16: util::stream_format(stream, "ldub%s %s[%s],%s", setcond[cond], reg[rsrc1], src2(op,0), reg[rdst]); break;
+ case 0x17: util::stream_format(stream, "stb%s %s[%s],%s", setcond[cond], reg[rsrc1], src2(op,0), reg[rdst]); break;
+ case 0x18: util::stream_format(stream, "ashr%s %s,%s,%s", setcond[cond], reg[rsrc1], src2(op,0), reg[rdst]); break;
+ case 0x19: util::stream_format(stream, "lshr%s %s,%s,%s", setcond[cond], reg[rsrc1], src2(op,0), reg[rdst]); break;
+ case 0x1a: util::stream_format(stream, "ashl%s %s,%s,%s", setcond[cond], reg[rsrc1], src2(op,0), reg[rdst]); break;
+ case 0x1b: util::stream_format(stream, "rotl%s %s,%s,%s", setcond[cond], reg[rsrc1], src2(op,0), reg[rdst]); break;
+ case 0x1c: util::stream_format(stream, "getps %s", reg[rdst]); break;
+ case 0x1d: util::stream_format(stream, "putps %s", src2(op,0)); break;
case 0x1e: if (rdst && rsrc2_iszero)
{
flags = DASMFLAG_STEP_OVER | DASMFLAG_STEP_OVER_EXTRA(1);
- sprintf(buffer, "jsr%s %s,%s", setcond[cond], reg[rdst], reg[rsrc1]);
+ util::stream_format(stream, "jsr%s %s,%s", setcond[cond], reg[rdst], reg[rsrc1]);
}
else if (rdst)
{
flags = DASMFLAG_STEP_OVER | DASMFLAG_STEP_OVER_EXTRA(1);
- sprintf(buffer, "jsr%s %s,%s[%s]", setcond[cond], reg[rdst], reg[rsrc1], src2(op,2));
+ util::stream_format(stream, "jsr%s %s,%s[%s]", setcond[cond], reg[rdst], reg[rsrc1], src2(op,2));
}
else if (rsrc2_iszero)
{
if (rsrc1 == 28)
flags = DASMFLAG_STEP_OUT;
- sprintf(buffer, "jmp%s %s", setcond[cond], reg[rsrc1]);
+ util::stream_format(stream, "jmp%s %s", setcond[cond], reg[rsrc1]);
}
else
- sprintf(buffer, "jmp%s %s[%s]", setcond[cond], reg[rsrc1], src2(op,2));
+ util::stream_format(stream, "jmp%s %s[%s]", setcond[cond], reg[rsrc1], src2(op,2));
break;
- case 0x1f: sprintf(buffer, "trap $1f"); flags = DASMFLAG_STEP_OVER; break;
+ case 0x1f: util::stream_format(stream, "trap $1f"); flags = DASMFLAG_STEP_OVER; break;
}
return 4 | flags | DASMFLAG_SUPPORTED;
}
+
+
+CPU_DISASSEMBLE(asap)
+{
+ std::ostringstream stream;
+ offs_t result = internal_disasm_asap(device, stream, pc, oprom, opram, options);
+ std::string stream_str = stream.str();
+ strcpy(buffer, stream_str.c_str());
+ return result;
+}
diff --git a/src/devices/cpu/ccpu/ccpudasm.cpp b/src/devices/cpu/ccpu/ccpudasm.cpp
index 9a02ee58d49..309b4167cc1 100644
--- a/src/devices/cpu/ccpu/ccpudasm.cpp
+++ b/src/devices/cpu/ccpu/ccpudasm.cpp
@@ -14,7 +14,7 @@
#include "ccpu.h"
-CPU_DISASSEMBLE( ccpu )
+static offs_t internal_disasm_ccpu(cpu_device *device, std::ostream &stream, offs_t pc, const uint8_t *oprom, const uint8_t *opram, int options)
{
unsigned startpc = pc;
uint8_t opcode = oprom[pc++ - startpc];
@@ -27,7 +27,7 @@ CPU_DISASSEMBLE( ccpu )
case 0x04: case 0x05: case 0x06: case 0x07:
case 0x08: case 0x09: case 0x0a: case 0x0b:
case 0x0c: case 0x0d: case 0x0e: case 0x0f:
- sprintf(buffer, "LDAI $%X", opcode & 0x0f);
+ util::stream_format(stream, "LDAI $%X", opcode & 0x0f);
break;
/* INP */
@@ -35,12 +35,12 @@ CPU_DISASSEMBLE( ccpu )
case 0x14: case 0x15: case 0x16: case 0x17:
case 0x18: case 0x19: case 0x1a: case 0x1b:
case 0x1c: case 0x1d: case 0x1e: case 0x1f:
- sprintf(buffer, "INP $%X", opcode & 0x0f);
+ util::stream_format(stream, "INP $%X", opcode & 0x0f);
break;
/* A8I */
case 0x20:
- sprintf(buffer, "A8I $%X", oprom[pc++ - startpc]);
+ util::stream_format(stream, "A8I $%X", oprom[pc++ - startpc]);
break;
/* A4I */
@@ -48,12 +48,12 @@ CPU_DISASSEMBLE( ccpu )
case 0x24: case 0x25: case 0x26: case 0x27:
case 0x28: case 0x29: case 0x2a: case 0x2b:
case 0x2c: case 0x2d: case 0x2e: case 0x2f:
- sprintf(buffer, "A4I $%X", opcode & 0x0f);
+ util::stream_format(stream, "A4I $%X", opcode & 0x0f);
break;
/* S8I */
case 0x30:
- sprintf(buffer, "S8I $%X", oprom[pc++ - startpc]);
+ util::stream_format(stream, "S8I $%X", oprom[pc++ - startpc]);
break;
/* S4I */
@@ -61,7 +61,7 @@ CPU_DISASSEMBLE( ccpu )
case 0x34: case 0x35: case 0x36: case 0x37:
case 0x38: case 0x39: case 0x3a: case 0x3b:
case 0x3c: case 0x3d: case 0x3e: case 0x3f:
- sprintf(buffer, "S4I $%X", opcode & 0x0f);
+ util::stream_format(stream, "S4I $%X", opcode & 0x0f);
break;
/* LPAI */
@@ -70,87 +70,87 @@ CPU_DISASSEMBLE( ccpu )
case 0x48: case 0x49: case 0x4a: case 0x4b:
case 0x4c: case 0x4d: case 0x4e: case 0x4f:
tempval = oprom[pc++ - startpc];
- sprintf(buffer, "LPAI $%03X", (opcode & 0x0f) + (tempval & 0xf0) + ((tempval & 0x0f) << 8));
+ util::stream_format(stream, "LPAI $%03X", (opcode & 0x0f) + (tempval & 0xf0) + ((tempval & 0x0f) << 8));
break;
/* T4K */
case 0x50:
- sprintf(buffer, "T4K");
+ util::stream_format(stream, "T4K");
break;
/* JMIB/JEHB */
case 0x51:
- sprintf(buffer, "JMIB/JEHB");
+ util::stream_format(stream, "JMIB/JEHB");
break;
/* JVNB */
case 0x52:
- sprintf(buffer, "JVNB");
+ util::stream_format(stream, "JVNB");
break;
/* JLTB */
case 0x53:
- sprintf(buffer, "JLTB");
+ util::stream_format(stream, "JLTB");
break;
/* JEQB */
case 0x54:
- sprintf(buffer, "JEQB");
+ util::stream_format(stream, "JEQB");
break;
/* JCZB */
case 0x55:
- sprintf(buffer, "JCZB");
+ util::stream_format(stream, "JCZB");
break;
/* JOSB */
case 0x56:
- sprintf(buffer, "JOSB");
+ util::stream_format(stream, "JOSB");
break;
/* SSA */
case 0x57:
- sprintf(buffer, "SSA");
+ util::stream_format(stream, "SSA");
break;
/* JMP */
case 0x58:
- sprintf(buffer, "JMP");
+ util::stream_format(stream, "JMP");
break;
/* JMI/JEH */
case 0x59:
- sprintf(buffer, "JMI/JEH");
+ util::stream_format(stream, "JMI/JEH");
break;
/* JVN */
case 0x5a:
- sprintf(buffer, "JVN");
+ util::stream_format(stream, "JVN");
break;
/* JLT */
case 0x5b:
- sprintf(buffer, "JLT");
+ util::stream_format(stream, "JLT");
break;
/* JEQ */
case 0x5c:
- sprintf(buffer, "JEQ");
+ util::stream_format(stream, "JEQ");
break;
/* JCZ */
case 0x5d:
- sprintf(buffer, "JCZ");
+ util::stream_format(stream, "JCZ");
break;
/* JOS */
case 0x5e:
- sprintf(buffer, "JOS");
+ util::stream_format(stream, "JOS");
break;
/* NOP */
case 0x5f:
- sprintf(buffer, "NOP");
+ util::stream_format(stream, "NOP");
break;
/* ADD */
@@ -158,7 +158,7 @@ CPU_DISASSEMBLE( ccpu )
case 0x64: case 0x65: case 0x66: case 0x67:
case 0x68: case 0x69: case 0x6a: case 0x6b:
case 0x6c: case 0x6d: case 0x6e: case 0x6f:
- sprintf(buffer, "ADD $%X", opcode & 0x0f);
+ util::stream_format(stream, "ADD $%X", opcode & 0x0f);
break;
/* SUB n */
@@ -166,7 +166,7 @@ CPU_DISASSEMBLE( ccpu )
case 0x74: case 0x75: case 0x76: case 0x77:
case 0x78: case 0x79: case 0x7a: case 0x7b:
case 0x7c: case 0x7d: case 0x7e: case 0x7f:
- sprintf(buffer, "SUB $%X", opcode & 0x0f);
+ util::stream_format(stream, "SUB $%X", opcode & 0x0f);
break;
/* SETP n */
@@ -174,7 +174,7 @@ CPU_DISASSEMBLE( ccpu )
case 0x84: case 0x85: case 0x86: case 0x87:
case 0x88: case 0x89: case 0x8a: case 0x8b:
case 0x8c: case 0x8d: case 0x8e: case 0x8f:
- sprintf(buffer, "SETP $%X", opcode & 0x0f);
+ util::stream_format(stream, "SETP $%X", opcode & 0x0f);
break;
/* OUT */
@@ -182,7 +182,7 @@ CPU_DISASSEMBLE( ccpu )
case 0x94: case 0x95: case 0x96: case 0x97:
case 0x98: case 0x99: case 0x9a: case 0x9b:
case 0x9c: case 0x9d: case 0x9e: case 0x9f:
- sprintf(buffer, "OUT $%X", opcode & 0x0f);
+ util::stream_format(stream, "OUT $%X", opcode & 0x0f);
break;
/* LDA */
@@ -190,7 +190,7 @@ CPU_DISASSEMBLE( ccpu )
case 0xa4: case 0xa5: case 0xa6: case 0xa7:
case 0xa8: case 0xa9: case 0xaa: case 0xab:
case 0xac: case 0xad: case 0xae: case 0xaf:
- sprintf(buffer, "LDA $%X", opcode & 0x0f);
+ util::stream_format(stream, "LDA $%X", opcode & 0x0f);
break;
/* CMP */
@@ -198,7 +198,7 @@ CPU_DISASSEMBLE( ccpu )
case 0xb4: case 0xb5: case 0xb6: case 0xb7:
case 0xb8: case 0xb9: case 0xba: case 0xbb:
case 0xbc: case 0xbd: case 0xbe: case 0xbf:
- sprintf(buffer, "TST $%X", opcode & 0x0f);
+ util::stream_format(stream, "TST $%X", opcode & 0x0f);
break;
/* WS */
@@ -206,7 +206,7 @@ CPU_DISASSEMBLE( ccpu )
case 0xc4: case 0xc5: case 0xc6: case 0xc7:
case 0xc8: case 0xc9: case 0xca: case 0xcb:
case 0xcc: case 0xcd: case 0xce: case 0xcf:
- sprintf(buffer, "WS $%X", opcode & 0x0f);
+ util::stream_format(stream, "WS $%X", opcode & 0x0f);
break;
/* STA n */
@@ -214,117 +214,127 @@ CPU_DISASSEMBLE( ccpu )
case 0xd4: case 0xd5: case 0xd6: case 0xd7:
case 0xd8: case 0xd9: case 0xda: case 0xdb:
case 0xdc: case 0xdd: case 0xde: case 0xdf:
- sprintf(buffer, "STA $%X", opcode & 0x0f);
+ util::stream_format(stream, "STA $%X", opcode & 0x0f);
break;
/* DV */
case 0xe0:
- sprintf(buffer, "DV");
+ util::stream_format(stream, "DV");
break;
/* LPAP */
case 0xe1:
- sprintf(buffer, "LPAP");
+ util::stream_format(stream, "LPAP");
break;
/* WSP */
case 0xf1:
- sprintf(buffer, "WSP");
+ util::stream_format(stream, "WSP");
break;
/* LKP */
case 0xe2:
case 0xf2:
- sprintf(buffer, "LKP");
+ util::stream_format(stream, "LKP");
break;
/* MUL */
case 0xe3:
case 0xf3:
- sprintf(buffer, "MUL");
+ util::stream_format(stream, "MUL");
break;
/* NV */
case 0xe4:
case 0xf4:
- sprintf(buffer, "NV");
+ util::stream_format(stream, "NV");
break;
/* FRM */
case 0xe5:
case 0xf5:
- sprintf(buffer, "FRM");
+ util::stream_format(stream, "FRM");
break;
/* STAP */
case 0xe6:
case 0xf6:
- sprintf(buffer, "STAP");
+ util::stream_format(stream, "STAP");
break;
/* CST */
case 0xf7:
- sprintf(buffer, "CST");
+ util::stream_format(stream, "CST");
break;
/* ADDP */
case 0xe7:
- sprintf(buffer, "ADDP");
+ util::stream_format(stream, "ADDP");
break;
/* SUBP */
case 0xe8:
case 0xf8:
- sprintf(buffer, "SUBP");
+ util::stream_format(stream, "SUBP");
break;
/* ANDP */
case 0xe9:
case 0xf9:
- sprintf(buffer, "ANDP");
+ util::stream_format(stream, "ANDP");
break;
/* LDAP */
case 0xea:
case 0xfa:
- sprintf(buffer, "LDAP");
+ util::stream_format(stream, "LDAP");
break;
/* SHR */
case 0xeb:
case 0xfb:
- sprintf(buffer, "SHR");
+ util::stream_format(stream, "SHR");
break;
/* SHL */
case 0xec:
case 0xfc:
- sprintf(buffer, "SHL");
+ util::stream_format(stream, "SHL");
break;
/* ASR */
case 0xed:
case 0xfd:
- sprintf(buffer, "ASR");
+ util::stream_format(stream, "ASR");
break;
/* SHRB */
case 0xee:
case 0xfe:
- sprintf(buffer, "SHRB");
+ util::stream_format(stream, "SHRB");
break;
/* SHLB */
case 0xef:
case 0xff:
- sprintf(buffer, "SHLB");
+ util::stream_format(stream, "SHLB");
break;
/* IV */
case 0xf0:
- sprintf(buffer, "IV");
+ util::stream_format(stream, "IV");
break;
}
return (pc - startpc) | DASMFLAG_SUPPORTED;
}
+
+
+CPU_DISASSEMBLE(ccpu)
+{
+ std::ostringstream stream;
+ offs_t result = internal_disasm_ccpu(device, stream, pc, oprom, opram, options);
+ std::string stream_str = stream.str();
+ strcpy(buffer, stream_str.c_str());
+ return result;
+}
diff --git a/src/devices/cpu/cop400/cop410ds.cpp b/src/devices/cpu/cop400/cop410ds.cpp
index fa8f675506e..1c28ea070bf 100644
--- a/src/devices/cpu/cop400/cop410ds.cpp
+++ b/src/devices/cpu/cop400/cop410ds.cpp
@@ -10,7 +10,7 @@
#include "emu.h"
-CPU_DISASSEMBLE( cop410 )
+static offs_t internal_disasm_cop410(cpu_device *device, std::ostream &stream, offs_t pc, const uint8_t *oprom, const uint8_t *opram, int options)
{
uint8_t opcode = oprom[0];
uint8_t next_opcode = oprom[1];
@@ -23,130 +23,130 @@ CPU_DISASSEMBLE( cop410 )
if ((pc & 0x3E0) >= 0x80 && (pc & 0x3E0) < 0x100) //JP pages 2,3
{
address = (uint16_t)((pc & 0x380) | (opcode & 0x7F));
- sprintf(buffer, "JP %x", address);
+ util::stream_format(stream, "JP %x", address);
}
else
{
if ((opcode & 0xC0) == 0xC0) //JP other pages
{
address = (uint16_t)((pc & 0x3C0) | (opcode & 0x3F));
- sprintf(buffer, "JP %x", address);
+ util::stream_format(stream, "JP %x", address);
}
else //JSRP
{
address = (uint16_t)(0x80 | (opcode & 0x3F));
- sprintf(buffer, "JSRP %x", address);
+ util::stream_format(stream, "JSRP %x", address);
flags = DASMFLAG_STEP_OVER;
}
}
}
else if (opcode >= 0x08 && opcode <= 0x0F)
{
- sprintf(buffer, "LBI 0,%u", ((opcode & 0xF) + 1) & 0xF);
+ util::stream_format(stream, "LBI 0,%u", ((opcode & 0xF) + 1) & 0xF);
}
else if (opcode >= 0x18 && opcode <= 0x1F)
{
- sprintf(buffer, "LBI 1,%u", ((opcode & 0xF) + 1) & 0xF);
+ util::stream_format(stream, "LBI 1,%u", ((opcode & 0xF) + 1) & 0xF);
}
else if (opcode >= 0x28 && opcode <= 0x2F)
{
- sprintf(buffer, "LBI 2,%u", ((opcode & 0xF) + 1) & 0xF);
+ util::stream_format(stream, "LBI 2,%u", ((opcode & 0xF) + 1) & 0xF);
}
else if (opcode >= 0x38 && opcode <= 0x3F)
{
- sprintf(buffer, "LBI 3,%u", ((opcode & 0xF) + 1) & 0xF);
+ util::stream_format(stream, "LBI 3,%u", ((opcode & 0xF) + 1) & 0xF);
}
else if (opcode >= 0x51 && opcode <= 0x5F)
{
- sprintf(buffer, "AISC %u", opcode & 0xF);
+ util::stream_format(stream, "AISC %u", opcode & 0xF);
}
else if (opcode >= 0x60 && opcode <= 0x61)
{
address = ((opcode & 0x01) << 8) | next_opcode;
- sprintf(buffer, "JMP %x", address);
+ util::stream_format(stream, "JMP %x", address);
bytes = 2;
}
else if (opcode >= 0x68 && opcode <= 0x69)
{
address = ((opcode & 0x01) << 8) | next_opcode;
- sprintf(buffer, "JSR %x", address);
+ util::stream_format(stream, "JSR %x", address);
flags = DASMFLAG_STEP_OVER;
bytes = 2;
}
else if (opcode >= 0x70 && opcode <= 0x7F)
{
- sprintf(buffer, "STII %u", opcode & 0xF);
+ util::stream_format(stream, "STII %u", opcode & 0xF);
}
else
{
switch (opcode)
{
case 0:
- sprintf(buffer, "CLRA");
+ util::stream_format(stream, "CLRA");
break;
case 1:
- sprintf(buffer, "SKMBZ 0");
+ util::stream_format(stream, "SKMBZ 0");
break;
case 2:
- sprintf(buffer, "XOR");
+ util::stream_format(stream, "XOR");
break;
case 3:
- sprintf(buffer, "SKMBZ 2");
+ util::stream_format(stream, "SKMBZ 2");
break;
case 4:
- sprintf(buffer, "XIS 0");
+ util::stream_format(stream, "XIS 0");
break;
case 5:
- sprintf(buffer, "LD 0");
+ util::stream_format(stream, "LD 0");
break;
case 6:
- sprintf(buffer, "X 0");
+ util::stream_format(stream, "X 0");
break;
case 7:
- sprintf(buffer, "XDS 0");
+ util::stream_format(stream, "XDS 0");
break;
case 0x11:
- sprintf(buffer, "SKMBZ 1");
+ util::stream_format(stream, "SKMBZ 1");
break;
case 0x13:
- sprintf(buffer, "SKMBZ 3");
+ util::stream_format(stream, "SKMBZ 3");
break;
case 0x14:
- sprintf(buffer, "XIS 1");
+ util::stream_format(stream, "XIS 1");
break;
case 0x15:
- sprintf(buffer, "LD 1");
+ util::stream_format(stream, "LD 1");
break;
case 0x16:
- sprintf(buffer, "X 1");
+ util::stream_format(stream, "X 1");
break;
case 0x17:
- sprintf(buffer, "XDS 1");
+ util::stream_format(stream, "XDS 1");
break;
case 0x20:
- sprintf(buffer, "SKC");
+ util::stream_format(stream, "SKC");
break;
case 0x21:
- sprintf(buffer, "SKE");
+ util::stream_format(stream, "SKE");
break;
case 0x22:
- sprintf(buffer, "SC");
+ util::stream_format(stream, "SC");
break;
case 0x23:
@@ -155,40 +155,40 @@ CPU_DISASSEMBLE( cop410 )
if (next_opcode >= 0x80 && next_opcode <= 0xbf)
{
address = (uint16_t)(next_opcode & 0x3F);
- sprintf(buffer, "XAD %x,%x", ((address & 0x30) >> 4),address & 0x0F);
+ util::stream_format(stream, "XAD %x,%x", ((address & 0x30) >> 4),address & 0x0F);
}
else
{
- sprintf(buffer, "Invalid");
+ util::stream_format(stream, "Invalid");
}
break;
case 0x24:
- sprintf(buffer, "XIS 2");
+ util::stream_format(stream, "XIS 2");
break;
case 0x25:
- sprintf(buffer, "LD 2");
+ util::stream_format(stream, "LD 2");
break;
case 0x26:
- sprintf(buffer, "X 2");
+ util::stream_format(stream, "X 2");
break;
case 0x27:
- sprintf(buffer, "XDS 2");
+ util::stream_format(stream, "XDS 2");
break;
case 0x30:
- sprintf(buffer, "ASC");
+ util::stream_format(stream, "ASC");
break;
case 0x31:
- sprintf(buffer, "ADD");
+ util::stream_format(stream, "ADD");
break;
case 0x32:
- sprintf(buffer, "RC");
+ util::stream_format(stream, "RC");
break;
case 0x33:
@@ -196,154 +196,165 @@ CPU_DISASSEMBLE( cop410 )
if (next_opcode >= 0x60 && next_opcode <= 0x6F)
{
- sprintf(buffer, "LEI %x", next_opcode & 0xF);
+ util::stream_format(stream, "LEI %x", next_opcode & 0xF);
}
else
{
switch (next_opcode)
{
case 0x01:
- sprintf(buffer, "SKGBZ 0");
+ util::stream_format(stream, "SKGBZ 0");
break;
case 0x03:
- sprintf(buffer, "SKGBZ 2");
+ util::stream_format(stream, "SKGBZ 2");
break;
case 0x11:
- sprintf(buffer, "SKGBZ 1");
+ util::stream_format(stream, "SKGBZ 1");
break;
case 0x13:
- sprintf(buffer, "SKGBZ 3");
+ util::stream_format(stream, "SKGBZ 3");
break;
case 0x21:
- sprintf(buffer, "SKGZ");
+ util::stream_format(stream, "SKGZ");
break;
case 0x2A:
- sprintf(buffer, "ING");
+ util::stream_format(stream, "ING");
break;
case 0x2E:
- sprintf(buffer, "INL");
+ util::stream_format(stream, "INL");
break;
case 0x38:
- sprintf(buffer, "HALT");
+ util::stream_format(stream, "HALT");
break;
case 0x3A:
- sprintf(buffer, "OMG");
+ util::stream_format(stream, "OMG");
break;
case 0x3C:
- sprintf(buffer, "CAMQ");
+ util::stream_format(stream, "CAMQ");
break;
case 0x3E:
- sprintf(buffer, "OBD");
+ util::stream_format(stream, "OBD");
break;
default:
- sprintf(buffer, "Invalid");
+ util::stream_format(stream, "Invalid");
break;
}
break;
}
+ break;
case 0x34:
- sprintf(buffer, "XIS 3");
+ util::stream_format(stream, "XIS 3");
break;
case 0x35:
- sprintf(buffer, "LD 3");
+ util::stream_format(stream, "LD 3");
break;
case 0x36:
- sprintf(buffer, "X 3");
+ util::stream_format(stream, "X 3");
break;
case 0x37:
- sprintf(buffer, "XDS 3");
+ util::stream_format(stream, "XDS 3");
break;
case 0x40:
- sprintf(buffer, "COMP");
+ util::stream_format(stream, "COMP");
break;
case 0x42:
- sprintf(buffer, "RMB 2");
+ util::stream_format(stream, "RMB 2");
break;
case 0x43:
- sprintf(buffer, "RMB 3");
+ util::stream_format(stream, "RMB 3");
break;
case 0x44:
- sprintf(buffer, "NOP");
+ util::stream_format(stream, "NOP");
break;
case 0x45:
- sprintf(buffer, "RMB 1");
+ util::stream_format(stream, "RMB 1");
break;
case 0x46:
- sprintf(buffer, "SMB 2");
+ util::stream_format(stream, "SMB 2");
break;
case 0x47:
- sprintf(buffer, "SMB 1");
+ util::stream_format(stream, "SMB 1");
break;
case 0x48:
- sprintf(buffer, "RET");
+ util::stream_format(stream, "RET");
flags = DASMFLAG_STEP_OUT;
break;
case 0x49:
- sprintf(buffer, "RETSK");
+ util::stream_format(stream, "RETSK");
flags = DASMFLAG_STEP_OUT;
break;
case 0x4B:
- sprintf(buffer, "SMB 3");
+ util::stream_format(stream, "SMB 3");
break;
case 0x4C:
- sprintf(buffer, "RMB 0");
+ util::stream_format(stream, "RMB 0");
break;
case 0x4D:
- sprintf(buffer, "SMB 0");
+ util::stream_format(stream, "SMB 0");
break;
case 0x4E:
- sprintf(buffer, "CBA");
+ util::stream_format(stream, "CBA");
break;
case 0x4F:
- sprintf(buffer, "XAS");
+ util::stream_format(stream, "XAS");
break;
case 0x50:
- sprintf(buffer, "CAB");
+ util::stream_format(stream, "CAB");
break;
case 0xBF:
- sprintf(buffer, "LQID");
+ util::stream_format(stream, "LQID");
break;
case 0xFF:
- sprintf(buffer, "JID");
+ util::stream_format(stream, "JID");
break;
default:
- sprintf(buffer, "Invalid");
+ util::stream_format(stream, "Invalid");
break;
}
}
return bytes | flags | DASMFLAG_SUPPORTED;
}
+
+
+CPU_DISASSEMBLE(cop410)
+{
+ std::ostringstream stream;
+ offs_t result = internal_disasm_cop410(device, stream, pc, oprom, opram, options);
+ std::string stream_str = stream.str();
+ strcpy(buffer, stream_str.c_str());
+ return result;
+}
diff --git a/src/devices/cpu/cop400/cop420ds.cpp b/src/devices/cpu/cop400/cop420ds.cpp
index e1e90eb7130..bf032238687 100644
--- a/src/devices/cpu/cop400/cop420ds.cpp
+++ b/src/devices/cpu/cop400/cop420ds.cpp
@@ -10,7 +10,7 @@
#include "emu.h"
-CPU_DISASSEMBLE( cop420 )
+static offs_t internal_disasm_cop420(cpu_device *device, std::ostream &stream, offs_t pc, const uint8_t *oprom, const uint8_t *opram, int options)
{
uint8_t opcode = oprom[0];
uint8_t next_opcode = oprom[1];
@@ -23,138 +23,138 @@ CPU_DISASSEMBLE( cop420 )
if ((pc & 0x3E0) >= 0x80 && (pc & 0x3E0) < 0x100) //JP pages 2,3
{
address = (uint16_t)((pc & 0x380) | (opcode & 0x7F));
- sprintf(buffer, "JP %x", address);
+ util::stream_format(stream, "JP %x", address);
}
else
{
if ((opcode & 0xC0) == 0xC0) //JP other pages
{
address = (uint16_t)((pc & 0x3C0) | (opcode & 0x3F));
- sprintf(buffer, "JP %x", address);
+ util::stream_format(stream, "JP %x", address);
}
else //JSRP
{
address = (uint16_t)(0x80 | (opcode & 0x3F));
- sprintf(buffer, "JSRP %x", address);
+ util::stream_format(stream, "JSRP %x", address);
flags = DASMFLAG_STEP_OVER;
}
}
}
else if (opcode >= 0x08 && opcode <= 0x0F)
{
- sprintf(buffer, "LBI 0,%u", ((opcode & 0xF) + 1) & 0xF);
+ util::stream_format(stream, "LBI 0,%u", ((opcode & 0xF) + 1) & 0xF);
}
else if (opcode >= 0x18 && opcode <= 0x1F)
{
- sprintf(buffer, "LBI 1,%u", ((opcode & 0xF) + 1) & 0xF);
+ util::stream_format(stream, "LBI 1,%u", ((opcode & 0xF) + 1) & 0xF);
}
else if (opcode >= 0x28 && opcode <= 0x2F)
{
- sprintf(buffer, "LBI 2,%u", ((opcode & 0xF) + 1) & 0xF);
+ util::stream_format(stream, "LBI 2,%u", ((opcode & 0xF) + 1) & 0xF);
}
else if (opcode >= 0x38 && opcode <= 0x3F)
{
- sprintf(buffer, "LBI 3,%u", ((opcode & 0xF) + 1) & 0xF);
+ util::stream_format(stream, "LBI 3,%u", ((opcode & 0xF) + 1) & 0xF);
}
else if (opcode >= 0x51 && opcode <= 0x5F)
{
- sprintf(buffer, "AISC %u", opcode & 0xF);
+ util::stream_format(stream, "AISC %u", opcode & 0xF);
}
else if (opcode >= 0x60 && opcode <= 0x63)
{
address = ((opcode & 0x03) << 8) | next_opcode;
- sprintf(buffer, "JMP %x", address);
+ util::stream_format(stream, "JMP %x", address);
bytes = 2;
}
else if (opcode >= 0x68 && opcode <= 0x6B)
{
address = ((opcode & 0x03) << 8) | next_opcode;
- sprintf(buffer, "JSR %x", address);
+ util::stream_format(stream, "JSR %x", address);
flags = DASMFLAG_STEP_OVER;
bytes = 2;
}
else if (opcode >= 0x70 && opcode <= 0x7F)
{
- sprintf(buffer, "STII %u", opcode & 0xF);
+ util::stream_format(stream, "STII %u", opcode & 0xF);
}
else
{
switch (opcode)
{
case 0:
- sprintf(buffer, "CLRA");
+ util::stream_format(stream, "CLRA");
break;
case 1:
- sprintf(buffer, "SKMBZ 0");
+ util::stream_format(stream, "SKMBZ 0");
break;
case 2:
- sprintf(buffer, "XOR");
+ util::stream_format(stream, "XOR");
break;
case 3:
- sprintf(buffer, "SKMBZ 2");
+ util::stream_format(stream, "SKMBZ 2");
break;
case 4:
- sprintf(buffer, "XIS 0");
+ util::stream_format(stream, "XIS 0");
break;
case 5:
- sprintf(buffer, "LD 0");
+ util::stream_format(stream, "LD 0");
break;
case 6:
- sprintf(buffer, "X 0");
+ util::stream_format(stream, "X 0");
break;
case 7:
- sprintf(buffer, "XDS 0");
+ util::stream_format(stream, "XDS 0");
break;
case 0x10:
- sprintf(buffer, "CASC");
+ util::stream_format(stream, "CASC");
break;
case 0x11:
- sprintf(buffer, "SKMBZ 1");
+ util::stream_format(stream, "SKMBZ 1");
break;
case 0x12:
- sprintf(buffer, "XABR");
+ util::stream_format(stream, "XABR");
break;
case 0x13:
- sprintf(buffer, "SKMBZ 3");
+ util::stream_format(stream, "SKMBZ 3");
break;
case 0x14:
- sprintf(buffer, "XIS 1");
+ util::stream_format(stream, "XIS 1");
break;
case 0x15:
- sprintf(buffer, "LD 1");
+ util::stream_format(stream, "LD 1");
break;
case 0x16:
- sprintf(buffer, "X 1");
+ util::stream_format(stream, "X 1");
break;
case 0x17:
- sprintf(buffer, "XDS 1");
+ util::stream_format(stream, "XDS 1");
break;
case 0x20:
- sprintf(buffer, "SKC");
+ util::stream_format(stream, "SKC");
break;
case 0x21:
- sprintf(buffer, "SKE");
+ util::stream_format(stream, "SKE");
break;
case 0x22:
- sprintf(buffer, "SC");
+ util::stream_format(stream, "SC");
break;
case 0x23:
@@ -163,45 +163,45 @@ CPU_DISASSEMBLE( cop420 )
if (next_opcode <= 0x3f)
{
address = (uint16_t)(next_opcode & 0x3F);
- sprintf(buffer, "LDD %x,%x", ((address & 0x30) >> 4),address & 0x0F);
+ util::stream_format(stream, "LDD %x,%x", ((address & 0x30) >> 4),address & 0x0F);
}
else if (next_opcode >= 0x80 && next_opcode <= 0xbf)
{
address = (uint16_t)(next_opcode & 0x3F);
- sprintf(buffer, "XAD %x,%x", ((address & 0x30) >> 4),address & 0x0F);
+ util::stream_format(stream, "XAD %x,%x", ((address & 0x30) >> 4),address & 0x0F);
}
else
{
- sprintf(buffer, "Invalid");
+ util::stream_format(stream, "Invalid");
}
break;
case 0x24:
- sprintf(buffer, "XIS 2");
+ util::stream_format(stream, "XIS 2");
break;
case 0x25:
- sprintf(buffer, "LD 2");
+ util::stream_format(stream, "LD 2");
break;
case 0x26:
- sprintf(buffer, "X 2");
+ util::stream_format(stream, "X 2");
break;
case 0x27:
- sprintf(buffer, "XDS 2");
+ util::stream_format(stream, "XDS 2");
break;
case 0x30:
- sprintf(buffer, "ASC");
+ util::stream_format(stream, "ASC");
break;
case 0x31:
- sprintf(buffer, "ADD");
+ util::stream_format(stream, "ADD");
break;
case 0x32:
- sprintf(buffer, "RC");
+ util::stream_format(stream, "RC");
break;
case 0x33:
@@ -209,190 +209,200 @@ CPU_DISASSEMBLE( cop420 )
if (next_opcode >= 0x50 && next_opcode <= 0x5F)
{
- sprintf(buffer, "OGI %u", next_opcode & 0xF);
+ util::stream_format(stream, "OGI %u", next_opcode & 0xF);
}
else if (next_opcode >= 0x60 && next_opcode <= 0x6F)
{
- sprintf(buffer, "LEI %u", next_opcode & 0xF);
+ util::stream_format(stream, "LEI %u", next_opcode & 0xF);
}
else if (next_opcode >= 0x80 && next_opcode <= 0x8F)
{
- sprintf(buffer, "LBI 0,%u", next_opcode & 0xF);
+ util::stream_format(stream, "LBI 0,%u", next_opcode & 0xF);
}
else if (next_opcode >= 0x90 && next_opcode <= 0x9F)
{
- sprintf(buffer, "LBI 1,%u", next_opcode & 0xF);
+ util::stream_format(stream, "LBI 1,%u", next_opcode & 0xF);
}
else if (next_opcode >= 0xA0 && next_opcode <= 0xAF)
{
- sprintf(buffer, "LBI 2,%u", next_opcode & 0xF);
+ util::stream_format(stream, "LBI 2,%u", next_opcode & 0xF);
}
else if (next_opcode >= 0xB0 && next_opcode <= 0xBF)
{
- sprintf(buffer, "LBI 3,%u", next_opcode & 0xF);
+ util::stream_format(stream, "LBI 3,%u", next_opcode & 0xF);
}
else
{
switch (next_opcode)
{
case 0x01:
- sprintf(buffer, "SKGBZ 0");
+ util::stream_format(stream, "SKGBZ 0");
break;
case 0x03:
- sprintf(buffer, "SKGBZ 2");
+ util::stream_format(stream, "SKGBZ 2");
break;
case 0x11:
- sprintf(buffer, "SKGBZ 1");
+ util::stream_format(stream, "SKGBZ 1");
break;
case 0x13:
- sprintf(buffer, "SKGBZ 3");
+ util::stream_format(stream, "SKGBZ 3");
break;
case 0x21:
- sprintf(buffer, "SKGZ");
+ util::stream_format(stream, "SKGZ");
break;
case 0x28:
- sprintf(buffer, "ININ");
+ util::stream_format(stream, "ININ");
break;
case 0x29:
- sprintf(buffer, "INIL");
+ util::stream_format(stream, "INIL");
break;
case 0x2A:
- sprintf(buffer, "ING");
+ util::stream_format(stream, "ING");
break;
case 0x2C:
- sprintf(buffer, "CQMA");
+ util::stream_format(stream, "CQMA");
break;
case 0x2E:
- sprintf(buffer, "INL");
+ util::stream_format(stream, "INL");
break;
case 0x3A:
- sprintf(buffer, "OMG");
+ util::stream_format(stream, "OMG");
break;
case 0x3C:
- sprintf(buffer, "CAMQ");
+ util::stream_format(stream, "CAMQ");
break;
case 0x3E:
- sprintf(buffer, "OBD");
+ util::stream_format(stream, "OBD");
break;
default:
- sprintf(buffer, "Invalid");
+ util::stream_format(stream, "Invalid");
break;
}
}
break;
case 0x34:
- sprintf(buffer, "XIS 3");
+ util::stream_format(stream, "XIS 3");
break;
case 0x35:
- sprintf(buffer, "LD 3");
+ util::stream_format(stream, "LD 3");
break;
case 0x36:
- sprintf(buffer, "X 3");
+ util::stream_format(stream, "X 3");
break;
case 0x37:
- sprintf(buffer, "XDS 3");
+ util::stream_format(stream, "XDS 3");
break;
case 0x40:
- sprintf(buffer, "COMP");
+ util::stream_format(stream, "COMP");
break;
case 0x41:
- sprintf(buffer, "SKT");
+ util::stream_format(stream, "SKT");
break;
case 0x42:
- sprintf(buffer, "RMB 2");
+ util::stream_format(stream, "RMB 2");
break;
case 0x43:
- sprintf(buffer, "RMB 3");
+ util::stream_format(stream, "RMB 3");
break;
case 0x44:
- sprintf(buffer, "NOP");
+ util::stream_format(stream, "NOP");
break;
case 0x45:
- sprintf(buffer, "RMB 1");
+ util::stream_format(stream, "RMB 1");
break;
case 0x46:
- sprintf(buffer, "SMB 2");
+ util::stream_format(stream, "SMB 2");
break;
case 0x47:
- sprintf(buffer, "SMB 1");
+ util::stream_format(stream, "SMB 1");
break;
case 0x48:
- sprintf(buffer, "RET");
+ util::stream_format(stream, "RET");
flags = DASMFLAG_STEP_OUT;
break;
case 0x49:
- sprintf(buffer, "RETSK");
+ util::stream_format(stream, "RETSK");
flags = DASMFLAG_STEP_OUT;
break;
case 0x4A:
- sprintf(buffer, "ADT");
+ util::stream_format(stream, "ADT");
break;
case 0x4B:
- sprintf(buffer, "SMB 3");
+ util::stream_format(stream, "SMB 3");
break;
case 0x4C:
- sprintf(buffer, "RMB 0");
+ util::stream_format(stream, "RMB 0");
break;
case 0x4D:
- sprintf(buffer, "SMB 0");
+ util::stream_format(stream, "SMB 0");
break;
case 0x4E:
- sprintf(buffer, "CBA");
+ util::stream_format(stream, "CBA");
break;
case 0x4F:
- sprintf(buffer, "XAS");
+ util::stream_format(stream, "XAS");
break;
case 0x50:
- sprintf(buffer, "CAB");
+ util::stream_format(stream, "CAB");
break;
case 0xBF:
- sprintf(buffer, "LQID");
+ util::stream_format(stream, "LQID");
break;
case 0xFF:
- sprintf(buffer, "JID");
+ util::stream_format(stream, "JID");
break;
default:
- sprintf(buffer, "Invalid");
+ util::stream_format(stream, "Invalid");
break;
}
}
return bytes | flags | DASMFLAG_SUPPORTED;
}
+
+
+CPU_DISASSEMBLE(cop420)
+{
+ std::ostringstream stream;
+ offs_t result = internal_disasm_cop420(device, stream, pc, oprom, opram, options);
+ std::string stream_str = stream.str();
+ strcpy(buffer, stream_str.c_str());
+ return result;
+}
diff --git a/src/devices/cpu/cop400/cop440ds.cpp b/src/devices/cpu/cop400/cop440ds.cpp
index 460cf0a4e5b..0150e20ea76 100644
--- a/src/devices/cpu/cop400/cop440ds.cpp
+++ b/src/devices/cpu/cop400/cop440ds.cpp
@@ -4,13 +4,13 @@
cop440ds.c
- National Semiconductor COP420 Emulator.
+ National Semiconductor COP440 Emulator.
***************************************************************************/
#include "emu.h"
-CPU_DISASSEMBLE( cop444 )
+static offs_t internal_disasm_cop444(cpu_device *device, std::ostream &stream, offs_t pc, const uint8_t *oprom, const uint8_t *opram, int options)
{
uint8_t opcode = oprom[0];
uint8_t next_opcode = oprom[1];
@@ -23,138 +23,138 @@ CPU_DISASSEMBLE( cop444 )
if ((pc & 0x3E0) >= 0x80 && (pc & 0x3E0) < 0x100) //JP pages 2,3
{
address = (uint16_t)((pc & 0x380) | (opcode & 0x7F));
- sprintf(buffer, "JP %x", address);
+ util::stream_format(stream, "JP %x", address);
}
else
{
if ((opcode & 0xC0) == 0xC0) //JP other pages
{
address = (uint16_t)((pc & 0x3C0) | (opcode & 0x3F));
- sprintf(buffer, "JP %x", address);
+ util::stream_format(stream, "JP %x", address);
}
else //JSRP
{
address = (uint16_t)(0x80 | (opcode & 0x3F));
- sprintf(buffer, "JSRP %x", address);
+ util::stream_format(stream, "JSRP %x", address);
flags = DASMFLAG_STEP_OVER;
}
}
}
else if (opcode >= 0x08 && opcode <= 0x0F)
{
- sprintf(buffer, "LBI 0,%u", ((opcode & 0xF) + 1) & 0xF);
+ util::stream_format(stream, "LBI 0,%u", ((opcode & 0xF) + 1) & 0xF);
}
else if (opcode >= 0x18 && opcode <= 0x1F)
{
- sprintf(buffer, "LBI 1,%u", ((opcode & 0xF) + 1) & 0xF);
+ util::stream_format(stream, "LBI 1,%u", ((opcode & 0xF) + 1) & 0xF);
}
else if (opcode >= 0x28 && opcode <= 0x2F)
{
- sprintf(buffer, "LBI 2,%u", ((opcode & 0xF) + 1) & 0xF);
+ util::stream_format(stream, "LBI 2,%u", ((opcode & 0xF) + 1) & 0xF);
}
else if (opcode >= 0x38 && opcode <= 0x3F)
{
- sprintf(buffer, "LBI 3,%u", ((opcode & 0xF) + 1) & 0xF);
+ util::stream_format(stream, "LBI 3,%u", ((opcode & 0xF) + 1) & 0xF);
}
else if (opcode >= 0x51 && opcode <= 0x5F)
{
- sprintf(buffer, "AISC %u", opcode & 0xF);
+ util::stream_format(stream, "AISC %u", opcode & 0xF);
}
else if (opcode >= 0x60 && opcode <= 0x63)
{
address = ((opcode & 0x03) << 8) | next_opcode;
- sprintf(buffer, "JMP %x", address);
+ util::stream_format(stream, "JMP %x", address);
bytes = 2;
}
else if (opcode >= 0x68 && opcode <= 0x6B)
{
address = ((opcode & 0x03) << 8) | next_opcode;
- sprintf(buffer, "JSR %x", address);
+ util::stream_format(stream, "JSR %x", address);
flags = DASMFLAG_STEP_OVER;
bytes = 2;
}
else if (opcode >= 0x70 && opcode <= 0x7F)
{
- sprintf(buffer, "STII %u", opcode & 0xF);
+ util::stream_format(stream, "STII %u", opcode & 0xF);
}
else
{
switch (opcode)
{
case 0:
- sprintf(buffer, "CLRA");
+ util::stream_format(stream, "CLRA");
break;
case 1:
- sprintf(buffer, "SKMBZ 0");
+ util::stream_format(stream, "SKMBZ 0");
break;
case 2:
- sprintf(buffer, "XOR");
+ util::stream_format(stream, "XOR");
break;
case 3:
- sprintf(buffer, "SKMBZ 2");
+ util::stream_format(stream, "SKMBZ 2");
break;
case 4:
- sprintf(buffer, "XIS 0");
+ util::stream_format(stream, "XIS 0");
break;
case 5:
- sprintf(buffer, "LD 0");
+ util::stream_format(stream, "LD 0");
break;
case 6:
- sprintf(buffer, "X 0");
+ util::stream_format(stream, "X 0");
break;
case 7:
- sprintf(buffer, "XDS 0");
+ util::stream_format(stream, "XDS 0");
break;
case 0x10:
- sprintf(buffer, "CASC");
+ util::stream_format(stream, "CASC");
break;
case 0x11:
- sprintf(buffer, "SKMBZ 1");
+ util::stream_format(stream, "SKMBZ 1");
break;
case 0x12:
- sprintf(buffer, "XABR");
+ util::stream_format(stream, "XABR");
break;
case 0x13:
- sprintf(buffer, "SKMBZ 3");
+ util::stream_format(stream, "SKMBZ 3");
break;
case 0x14:
- sprintf(buffer, "XIS 1");
+ util::stream_format(stream, "XIS 1");
break;
case 0x15:
- sprintf(buffer, "LD 1");
+ util::stream_format(stream, "LD 1");
break;
case 0x16:
- sprintf(buffer, "X 1");
+ util::stream_format(stream, "X 1");
break;
case 0x17:
- sprintf(buffer, "XDS 1");
+ util::stream_format(stream, "XDS 1");
break;
case 0x20:
- sprintf(buffer, "SKC");
+ util::stream_format(stream, "SKC");
break;
case 0x21:
- sprintf(buffer, "SKE");
+ util::stream_format(stream, "SKE");
break;
case 0x22:
- sprintf(buffer, "SC");
+ util::stream_format(stream, "SC");
break;
case 0x23:
@@ -163,45 +163,45 @@ CPU_DISASSEMBLE( cop444 )
if (next_opcode <= 0x3f)
{
address = (uint16_t)(next_opcode & 0x3F);
- sprintf(buffer, "LDD %x,%x", ((address & 0x30) >> 4),address & 0x0F);
+ util::stream_format(stream, "LDD %x,%x", ((address & 0x30) >> 4),address & 0x0F);
}
else if (next_opcode >= 0x80 && next_opcode <= 0xbf)
{
address = (uint16_t)(next_opcode & 0x3F);
- sprintf(buffer, "XAD %x,%x", ((address & 0x30) >> 4),address & 0x0F);
+ util::stream_format(stream, "XAD %x,%x", ((address & 0x30) >> 4),address & 0x0F);
}
else
{
- sprintf(buffer, "Invalid");
+ util::stream_format(stream, "Invalid");
}
break;
case 0x24:
- sprintf(buffer, "XIS 2");
+ util::stream_format(stream, "XIS 2");
break;
case 0x25:
- sprintf(buffer, "LD 2");
+ util::stream_format(stream, "LD 2");
break;
case 0x26:
- sprintf(buffer, "X 2");
+ util::stream_format(stream, "X 2");
break;
case 0x27:
- sprintf(buffer, "XDS 2");
+ util::stream_format(stream, "XDS 2");
break;
case 0x30:
- sprintf(buffer, "ASC");
+ util::stream_format(stream, "ASC");
break;
case 0x31:
- sprintf(buffer, "ADD");
+ util::stream_format(stream, "ADD");
break;
case 0x32:
- sprintf(buffer, "RC");
+ util::stream_format(stream, "RC");
break;
case 0x33:
@@ -209,207 +209,217 @@ CPU_DISASSEMBLE( cop444 )
if (next_opcode >= 0x50 && next_opcode <= 0x5F)
{
- sprintf(buffer, "OGI %u", next_opcode & 0xF);
+ util::stream_format(stream, "OGI %u", next_opcode & 0xF);
}
else if (next_opcode >= 0x60 && next_opcode <= 0x6F)
{
- sprintf(buffer, "LEI %u", next_opcode & 0xF);
+ util::stream_format(stream, "LEI %u", next_opcode & 0xF);
}
else if (next_opcode >= 0x80 && next_opcode <= 0x8F)
{
- sprintf(buffer, "LBI 0,%u", next_opcode & 0xF);
+ util::stream_format(stream, "LBI 0,%u", next_opcode & 0xF);
}
else if (next_opcode >= 0x90 && next_opcode <= 0x9F)
{
- sprintf(buffer, "LBI 1,%u", next_opcode & 0xF);
+ util::stream_format(stream, "LBI 1,%u", next_opcode & 0xF);
}
else if (next_opcode >= 0xA0 && next_opcode <= 0xAF)
{
- sprintf(buffer, "LBI 2,%u", next_opcode & 0xF);
+ util::stream_format(stream, "LBI 2,%u", next_opcode & 0xF);
}
else if (next_opcode >= 0xB0 && next_opcode <= 0xBF)
{
- sprintf(buffer, "LBI 3,%u", next_opcode & 0xF);
+ util::stream_format(stream, "LBI 3,%u", next_opcode & 0xF);
}
else
{
switch (next_opcode)
{
case 0x01:
- sprintf(buffer, "SKGBZ 0");
+ util::stream_format(stream, "SKGBZ 0");
break;
case 0x03:
- sprintf(buffer, "SKGBZ 2");
+ util::stream_format(stream, "SKGBZ 2");
break;
case 0x11:
- sprintf(buffer, "SKGBZ 1");
+ util::stream_format(stream, "SKGBZ 1");
break;
case 0x13:
- sprintf(buffer, "SKGBZ 3");
+ util::stream_format(stream, "SKGBZ 3");
break;
case 0x21:
- sprintf(buffer, "SKGZ");
+ util::stream_format(stream, "SKGZ");
break;
case 0x28:
- sprintf(buffer, "ININ");
+ util::stream_format(stream, "ININ");
break;
case 0x29:
- sprintf(buffer, "INIL");
+ util::stream_format(stream, "INIL");
break;
case 0x2A:
- sprintf(buffer, "ING");
+ util::stream_format(stream, "ING");
break;
case 0x2C:
- sprintf(buffer, "CQMA");
+ util::stream_format(stream, "CQMA");
break;
case 0x2E:
- sprintf(buffer, "INL");
+ util::stream_format(stream, "INL");
break;
case 0x2F:
- sprintf(buffer, "CTMA");
+ util::stream_format(stream, "CTMA");
break;
case 0x38:
- sprintf(buffer, "HALT");
+ util::stream_format(stream, "HALT");
break;
case 0x39:
- sprintf(buffer, "IT");
+ util::stream_format(stream, "IT");
break;
case 0x3A:
- sprintf(buffer, "OMG");
+ util::stream_format(stream, "OMG");
break;
case 0x3C:
- sprintf(buffer, "CAMQ");
+ util::stream_format(stream, "CAMQ");
break;
case 0x3E:
- sprintf(buffer, "OBD");
+ util::stream_format(stream, "OBD");
break;
case 0x3F:
- sprintf(buffer, "CAMT");
+ util::stream_format(stream, "CAMT");
break;
default:
- sprintf(buffer, "Invalid");
+ util::stream_format(stream, "Invalid");
break;
}
}
break;
case 0x34:
- sprintf(buffer, "XIS 3");
+ util::stream_format(stream, "XIS 3");
break;
case 0x35:
- sprintf(buffer, "LD 3");
+ util::stream_format(stream, "LD 3");
break;
case 0x36:
- sprintf(buffer, "X 3");
+ util::stream_format(stream, "X 3");
break;
case 0x37:
- sprintf(buffer, "XDS 3");
+ util::stream_format(stream, "XDS 3");
break;
case 0x40:
- sprintf(buffer, "COMP");
+ util::stream_format(stream, "COMP");
break;
case 0x41:
- sprintf(buffer, "SKT");
+ util::stream_format(stream, "SKT");
break;
case 0x42:
- sprintf(buffer, "RMB 2");
+ util::stream_format(stream, "RMB 2");
break;
case 0x43:
- sprintf(buffer, "RMB 3");
+ util::stream_format(stream, "RMB 3");
break;
case 0x44:
- sprintf(buffer, "NOP");
+ util::stream_format(stream, "NOP");
break;
case 0x45:
- sprintf(buffer, "RMB 1");
+ util::stream_format(stream, "RMB 1");
break;
case 0x46:
- sprintf(buffer, "SMB 2");
+ util::stream_format(stream, "SMB 2");
break;
case 0x47:
- sprintf(buffer, "SMB 1");
+ util::stream_format(stream, "SMB 1");
break;
case 0x48:
- sprintf(buffer, "RET");
+ util::stream_format(stream, "RET");
flags = DASMFLAG_STEP_OUT;
break;
case 0x49:
- sprintf(buffer, "RETSK");
+ util::stream_format(stream, "RETSK");
flags = DASMFLAG_STEP_OUT;
break;
case 0x4A:
- sprintf(buffer, "ADT");
+ util::stream_format(stream, "ADT");
break;
case 0x4B:
- sprintf(buffer, "SMB 3");
+ util::stream_format(stream, "SMB 3");
break;
case 0x4C:
- sprintf(buffer, "RMB 0");
+ util::stream_format(stream, "RMB 0");
break;
case 0x4D:
- sprintf(buffer, "SMB 0");
+ util::stream_format(stream, "SMB 0");
break;
case 0x4E:
- sprintf(buffer, "CBA");
+ util::stream_format(stream, "CBA");
break;
case 0x4F:
- sprintf(buffer, "XAS");
+ util::stream_format(stream, "XAS");
break;
case 0x50:
- sprintf(buffer, "CAB");
+ util::stream_format(stream, "CAB");
break;
case 0xBF:
- sprintf(buffer, "LQID");
+ util::stream_format(stream, "LQID");
break;
case 0xFF:
- sprintf(buffer, "JID");
+ util::stream_format(stream, "JID");
break;
default:
- sprintf(buffer, "Invalid");
+ util::stream_format(stream, "Invalid");
break;
}
}
return bytes | flags | DASMFLAG_SUPPORTED;
}
+
+
+CPU_DISASSEMBLE(cop444)
+{
+ std::ostringstream stream;
+ offs_t result = internal_disasm_cop444(device, stream, pc, oprom, opram, options);
+ std::string stream_str = stream.str();
+ strcpy(buffer, stream_str.c_str());
+ return result;
+}
diff --git a/src/devices/cpu/cosmac/cosdasm.cpp b/src/devices/cpu/cosmac/cosdasm.cpp
index ce93110e021..c5689b25fcc 100644
--- a/src/devices/cpu/cosmac/cosdasm.cpp
+++ b/src/devices/cpu/cosmac/cosdasm.cpp
@@ -18,10 +18,10 @@ enum
};
#define CDP1801_OPCODE(...) \
- sprintf(buffer, __VA_ARGS__)
+ util::stream_format(stream, __VA_ARGS__)
#define CDP1802_OPCODE(...) \
- if (variant < TYPE_1802) sprintf(buffer, "illegal"); else sprintf(buffer, __VA_ARGS__)
+ if (variant < TYPE_1802) stream << "illegal"; else util::stream_format(stream, __VA_ARGS__)
static offs_t implied(const uint8_t opcode)
{
@@ -53,7 +53,7 @@ static offs_t long_skip(offs_t pc)
return pc + 3;
}
-static uint32_t disassemble(device_t *device, char *buffer, offs_t pc, const uint8_t *oprom, const uint8_t *opram, uint32_t variant)
+static uint32_t disassemble(device_t *device, std::ostream &stream, offs_t pc, const uint8_t *oprom, const uint8_t *opram, uint32_t variant)
{
const uint8_t *startram = opram;
uint32_t flags = 0;
@@ -185,6 +185,16 @@ static uint32_t disassemble(device_t *device, char *buffer, offs_t pc, const uin
}
+static uint32_t disassemble(device_t *device, char *buffer, offs_t pc, const uint8_t *oprom, const uint8_t *opram, uint32_t variant)
+{
+ std::ostringstream stream;
+ uint32_t result = disassemble(device, stream, pc, oprom, opram, variant);
+ std::string stream_str = stream.str();
+ strcpy(buffer, stream_str.c_str());
+ return result;
+}
+
+
CPU_DISASSEMBLE( cdp1801 )
{
return disassemble(device, buffer, pc, oprom, opram, TYPE_1801);
diff --git a/src/devices/cpu/cp1610/1610dasm.cpp b/src/devices/cpu/cp1610/1610dasm.cpp
index 964b1a5e612..5a2daf2cbfe 100644
--- a/src/devices/cpu/cp1610/1610dasm.cpp
+++ b/src/devices/cpu/cp1610/1610dasm.cpp
@@ -4,7 +4,7 @@
#include "debugger.h"
#include "cp1610.h"
-CPU_DISASSEMBLE( cp1610 )
+static offs_t internal_disasm_cp1610(cpu_device *device, std::ostream &stream, offs_t pc, const uint8_t *oprom, const uint8_t *opram, int options)
{
uint16_t oprom16[4]={ static_cast<uint16_t>((oprom[0] << 8) | oprom[1]), static_cast<uint16_t>((oprom[2] << 8) | oprom[3]), static_cast<uint16_t>((oprom[4] << 8) | oprom[5]), static_cast<uint16_t>((oprom[6] << 8) | oprom[7]) };
uint16_t op = oprom16[0]; uint16_t subop;
@@ -17,7 +17,7 @@ CPU_DISASSEMBLE( cp1610 )
/* opcode bitmask */
case 0x00: /* 0 000 000 000 */
// sym = set_ea_info( 0, 12, EA_UINT8, EA_ZPG_RD );
- sprintf(buffer, "HLT");
+ util::stream_format(stream, "HLT");
break;
case 0x001: /* 0 000 000 001 */
subop = oprom16[1];
@@ -30,14 +30,14 @@ CPU_DISASSEMBLE( cp1610 )
case 0x2a0: /* 1 010 100 xxx */
case 0x2a8: /* 1 010 101 xxx */
case 0x2b0: /* 1 010 110 xxx */
- sprintf(buffer,"MVI@ (R%01d), R%01d",(subop&0x38)>>3,subop&7);
+ util::stream_format(stream, "MVI@ (R%01d), R%01d",(subop&0x38)>>3,subop&7);
size += 1;
break;
case 0x2b8: /* 1 010 111 xxx */
ea1 = oprom16[2];
ea2 = oprom16[3];
ea = ((ea2&0xff)<<8) | (ea1&0xff);
- sprintf(buffer,"MVII #%04X, R%01d",ea,subop&7);
+ util::stream_format(stream, "MVII #%04X, R%01d",ea,subop&7);
size += 3;
break;
case 0x2c0: /* 1 011 000 xxx */
@@ -47,14 +47,14 @@ CPU_DISASSEMBLE( cp1610 )
case 0x2e0: /* 1 011 100 xxx */
case 0x2e8: /* 1 011 101 xxx */
case 0x2f0: /* 1 011 110 xxx */
- sprintf(buffer,"ADD@ (R%01d), R%01d",(subop&0x38)>>3,subop&7);
+ util::stream_format(stream, "ADD@ (R%01d), R%01d",(subop&0x38)>>3,subop&7);
size += 1;
break;
case 0x2f8: /* 1 011 111 xxx */
ea1 = oprom16[2];
ea2 = oprom16[3];
ea = ((ea2&0xff)<<8) | (ea1&0xff);
- sprintf(buffer,"ADDI #%04X, R%01d",ea,subop&7);
+ util::stream_format(stream, "ADDI #%04X, R%01d",ea,subop&7);
size += 3;
break;
case 0x300: /* 1 100 000 xxx */
@@ -64,14 +64,14 @@ CPU_DISASSEMBLE( cp1610 )
case 0x320: /* 1 100 100 xxx */
case 0x328: /* 1 100 101 xxx */
case 0x330: /* 1 100 110 xxx */
- sprintf(buffer,"SUB@ (R%01d), R%01d",(subop&0x38)>>3,subop&7);
+ util::stream_format(stream, "SUB@ (R%01d), R%01d",(subop&0x38)>>3,subop&7);
size += 1;
break;
case 0x338: /* 1 100 111 xxx */
ea1 = oprom16[2];
ea2 = oprom16[3];
ea = ((ea2&0xff)<<8) | (ea1&0xff);
- sprintf(buffer,"SUBI #%04X, R%01d",ea,subop&7);
+ util::stream_format(stream, "SUBI #%04X, R%01d",ea,subop&7);
size += 3;
break;
case 0x340: /* 1 101 000 xxx */
@@ -81,14 +81,14 @@ CPU_DISASSEMBLE( cp1610 )
case 0x360: /* 1 101 100 xxx */
case 0x368: /* 1 101 101 xxx */
case 0x370: /* 1 101 110 xxx */
- sprintf(buffer,"CMP@ (R%01d), R%01d",(subop&0x38)>>3,subop&7);
+ util::stream_format(stream, "CMP@ (R%01d), R%01d",(subop&0x38)>>3,subop&7);
size += 1;
break;
case 0x378: /* 1 101 111 xxx */
ea1 = oprom16[2];
ea2 = oprom16[3];
ea = ((ea2&0xff)<<8) | (ea1&0xff);
- sprintf(buffer,"CMPI #%04X, R%01d",ea,subop&7);
+ util::stream_format(stream, "CMPI #%04X, R%01d",ea,subop&7);
size += 3;
break;
case 0x380: /* 1 110 000 xxx */
@@ -98,14 +98,14 @@ CPU_DISASSEMBLE( cp1610 )
case 0x3a0: /* 1 110 100 xxx */
case 0x3a8: /* 1 110 101 xxx */
case 0x3b0: /* 1 110 110 xxx */
- sprintf(buffer,"AND@ (R%01d), R%01d",(subop&0x38)>>3,subop&7);
+ util::stream_format(stream, "AND@ (R%01d), R%01d",(subop&0x38)>>3,subop&7);
size += 1;
break;
case 0x3b8: /* 1 110 111 xxx */
ea1 = oprom16[2];
ea2 = oprom16[3];
ea = ((ea2&0xff)<<8) | (ea1&0xff);
- sprintf(buffer,"ANDI #%04X, R%01d",ea,subop&7);
+ util::stream_format(stream, "ANDI #%04X, R%01d",ea,subop&7);
size += 3;
break;
case 0x3c0: /* 1 111 000 xxx */
@@ -115,26 +115,26 @@ CPU_DISASSEMBLE( cp1610 )
case 0x3e0: /* 1 111 100 xxx */
case 0x3e8: /* 1 111 101 xxx */
case 0x3f0: /* 1 111 110 xxx */
- sprintf(buffer,"XOR@ (R%01d), R%01d",(subop&0x38)>>3,subop&7);
+ util::stream_format(stream, "XOR@ (R%01d), R%01d",(subop&0x38)>>3,subop&7);
size += 1;
break;
case 0x3f8: /* 1 111 111 xxx */
ea1 = oprom16[2];
ea2 = oprom16[3];
ea = ((ea2&0xff)<<8) | (ea1&0xff);
- sprintf(buffer,"XORI #%04X, R%01d",ea,subop&7);
+ util::stream_format(stream, "XORI #%04X, R%01d",ea,subop&7);
size += 3;
break;
default:
size += 1;
- sprintf(buffer, "SDBD ????");
+ util::stream_format(stream, "SDBD ????");
}
break;
case 0x002: /* 0 000 000 010 */
- sprintf(buffer, "EIS");
+ util::stream_format(stream, "EIS");
break;
case 0x003: /* 0 000 000 011 */
- sprintf(buffer, "DIS");
+ util::stream_format(stream, "DIS");
break;
case 0x004: /* 0 000 000 100 */
size += 2;
@@ -147,16 +147,16 @@ CPU_DISASSEMBLE( cp1610 )
switch(ea1 & 0x03)
{
case 0:
- sprintf(buffer, "J %04X",ea);
+ util::stream_format(stream, "J %04X",ea);
break;
case 1:
- sprintf(buffer, "JE %04X",ea);
+ util::stream_format(stream, "JE %04X",ea);
break;
case 2:
- sprintf(buffer, "JD %04X",ea);
+ util::stream_format(stream, "JD %04X",ea);
break;
case 3:
- sprintf(buffer, "????");
+ util::stream_format(stream, "????");
break;
}
}
@@ -166,28 +166,28 @@ CPU_DISASSEMBLE( cp1610 )
switch(ea1 & 0x03)
{
case 0:
- sprintf(buffer, "JSR R%01d,%04X",((ea1&0x300)>>8)+4,ea);
+ util::stream_format(stream, "JSR R%01d,%04X",((ea1&0x300)>>8)+4,ea);
break;
case 1:
- sprintf(buffer, "JSRE R%01d,%04X",((ea1&0x300)>>8)+4,ea);
+ util::stream_format(stream, "JSRE R%01d,%04X",((ea1&0x300)>>8)+4,ea);
break;
case 2:
- sprintf(buffer, "JSRD R%01d,%04X",((ea1&0x300)>>8)+4,ea);
+ util::stream_format(stream, "JSRD R%01d,%04X",((ea1&0x300)>>8)+4,ea);
break;
case 3:
- sprintf(buffer, "????");
+ util::stream_format(stream, "????");
break;
}
}
break;
case 0x005: /* 0 000 000 101 */
- sprintf(buffer, "TCI");
+ util::stream_format(stream, "TCI");
break;
case 0x006: /* 0 000 000 110 */
- sprintf(buffer, "CLRC");
+ util::stream_format(stream, "CLRC");
break;
case 0x007: /* 0 000 000 111 */
- sprintf(buffer, "SETC");
+ util::stream_format(stream, "SETC");
break;
case 0x008: /* 0 000 001 000 */
case 0x009: /* 0 000 001 001 */
@@ -197,7 +197,7 @@ CPU_DISASSEMBLE( cp1610 )
case 0x00d: /* 0 000 001 101 */
case 0x00e: /* 0 000 001 110 */
case 0x00f: /* 0 000 001 111 */
- sprintf(buffer, "INCR R%01d",op&0x7);
+ util::stream_format(stream, "INCR R%01d",op&0x7);
break;
case 0x010: /* 0 000 010 000 */
case 0x011: /* 0 000 010 001 */
@@ -207,7 +207,7 @@ CPU_DISASSEMBLE( cp1610 )
case 0x015: /* 0 000 010 101 */
case 0x016: /* 0 000 010 110 */
case 0x017: /* 0 000 010 111 */
- sprintf(buffer, "DECR R%01d",op&0x7);
+ util::stream_format(stream, "DECR R%01d",op&0x7);
break;
case 0x018: /* 0 000 011 000 */
case 0x019: /* 0 000 011 001 */
@@ -217,7 +217,7 @@ CPU_DISASSEMBLE( cp1610 )
case 0x01d: /* 0 000 011 101 */
case 0x01e: /* 0 000 011 110 */
case 0x01f: /* 0 000 011 111 */
- sprintf(buffer, "COMR R%01d",op&0x7);
+ util::stream_format(stream, "COMR R%01d",op&0x7);
break;
case 0x020: /* 0 000 100 000 */
case 0x021: /* 0 000 100 001 */
@@ -227,7 +227,7 @@ CPU_DISASSEMBLE( cp1610 )
case 0x025: /* 0 000 100 101 */
case 0x026: /* 0 000 100 110 */
case 0x027: /* 0 000 100 111 */
- sprintf(buffer, "NEGR R%01d",op&0x7);
+ util::stream_format(stream, "NEGR R%01d",op&0x7);
break;
case 0x028: /* 0 000 101 000 */
case 0x029: /* 0 000 101 001 */
@@ -237,21 +237,21 @@ CPU_DISASSEMBLE( cp1610 )
case 0x02d: /* 0 000 101 101 */
case 0x02e: /* 0 000 101 110 */
case 0x02f: /* 0 000 101 111 */
- sprintf(buffer, "ADCR R%01d",op&0x7);
+ util::stream_format(stream, "ADCR R%01d",op&0x7);
break;
case 0x030: /* 0 000 110 000 */
case 0x031: /* 0 000 110 001 */
case 0x032: /* 0 000 110 010 */
case 0x033: /* 0 000 110 011 */
- sprintf(buffer, "GSWD R%01d",op&0x3);
+ util::stream_format(stream, "GSWD R%01d",op&0x3);
break;
case 0x034: /* 0 000 110 100 */
case 0x035: /* 0 000 110 101 */
- sprintf(buffer, "NOP (%01d)",op&0x1); //???
+ util::stream_format(stream, "NOP (%01d)",op&0x1); //???
break;
case 0x036: /* 0 000 110 110 */
case 0x037: /* 0 000 110 111 */
- sprintf(buffer, "SIN");
+ util::stream_format(stream, "SIN");
break;
case 0x038: /* 0 000 111 000 */
case 0x039: /* 0 000 111 001 */
@@ -261,103 +261,103 @@ CPU_DISASSEMBLE( cp1610 )
case 0x03d: /* 0 000 111 101 */
case 0x03e: /* 0 000 111 110 */
case 0x03f: /* 0 000 111 111 */
- sprintf(buffer, "RSWD R%01d",op&0x7);
+ util::stream_format(stream, "RSWD R%01d",op&0x7);
break;
case 0x040: /* 0 001 000 000 */
case 0x041: /* 0 001 000 001 */
case 0x042: /* 0 001 000 010 */
case 0x043: /* 0 001 000 011 */
- sprintf(buffer, "SWAP R%01d,1",op&0x3);
+ util::stream_format(stream, "SWAP R%01d,1",op&0x3);
break;
case 0x044: /* 0 001 000 100 */
case 0x045: /* 0 001 000 101 */
case 0x046: /* 0 001 000 110 */
case 0x047: /* 0 001 000 111 */
- sprintf(buffer, "SWAP R%01d,2",op&0x3);
+ util::stream_format(stream, "SWAP R%01d,2",op&0x3);
break;
case 0x048: /* 0 001 001 000 */
case 0x049: /* 0 001 001 001 */
case 0x04a: /* 0 001 001 010 */
case 0x04b: /* 0 001 001 011 */
- sprintf(buffer, "SLL R%01d,1",op&0x3);
+ util::stream_format(stream, "SLL R%01d,1",op&0x3);
break;
case 0x04c: /* 0 001 001 100 */
case 0x04d: /* 0 001 001 101 */
case 0x04e: /* 0 001 001 110 */
case 0x04f: /* 0 001 001 111 */
- sprintf(buffer, "SLL R%01d,2",op&0x3);
+ util::stream_format(stream, "SLL R%01d,2",op&0x3);
break;
case 0x050: /* 0 001 010 000 */
case 0x051: /* 0 001 010 001 */
case 0x052: /* 0 001 010 010 */
case 0x053: /* 0 001 010 011 */
- sprintf(buffer, "RLC R%01d,1",op&0x3);
+ util::stream_format(stream, "RLC R%01d,1",op&0x3);
break;
case 0x054: /* 0 001 010 100 */
case 0x055: /* 0 001 010 101 */
case 0x056: /* 0 001 010 110 */
case 0x057: /* 0 001 010 111 */
- sprintf(buffer, "RLC R%01d,2",op&0x3);
+ util::stream_format(stream, "RLC R%01d,2",op&0x3);
break;
case 0x058: /* 0 001 011 000 */
case 0x059: /* 0 001 011 001 */
case 0x05a: /* 0 001 011 010 */
case 0x05b: /* 0 001 011 011 */
- sprintf(buffer, "SLLC R%01d,1",op&0x3);
+ util::stream_format(stream, "SLLC R%01d,1",op&0x3);
break;
case 0x05c: /* 0 001 011 100 */
case 0x05d: /* 0 001 011 101 */
case 0x05e: /* 0 001 011 110 */
case 0x05f: /* 0 001 011 111 */
- sprintf(buffer, "SLLC R%01d,2",op&0x3);
+ util::stream_format(stream, "SLLC R%01d,2",op&0x3);
break;
case 0x060: /* 0 001 100 000 */
case 0x061: /* 0 001 100 001 */
case 0x062: /* 0 001 100 010 */
case 0x063: /* 0 001 100 011 */
- sprintf(buffer, "SLR R%01d,1",op&0x3);
+ util::stream_format(stream, "SLR R%01d,1",op&0x3);
break;
case 0x064: /* 0 001 100 100 */
case 0x065: /* 0 001 100 101 */
case 0x066: /* 0 001 100 110 */
case 0x067: /* 0 001 100 111 */
- sprintf(buffer, "SLR R%01d,2",op&0x3);
+ util::stream_format(stream, "SLR R%01d,2",op&0x3);
break;
case 0x068: /* 0 001 101 000 */
case 0x069: /* 0 001 101 001 */
case 0x06a: /* 0 001 101 010 */
case 0x06b: /* 0 001 101 011 */
- sprintf(buffer, "SAR R%01d,1",op&0x3);
+ util::stream_format(stream, "SAR R%01d,1",op&0x3);
break;
case 0x06c: /* 0 001 101 100 */
case 0x06d: /* 0 001 101 101 */
case 0x06e: /* 0 001 101 110 */
case 0x06f: /* 0 001 101 111 */
- sprintf(buffer, "SAR R%01d,2",op&0x3);
+ util::stream_format(stream, "SAR R%01d,2",op&0x3);
break;
case 0x070: /* 0 001 110 000 */
case 0x071: /* 0 001 110 001 */
case 0x072: /* 0 001 110 010 */
case 0x073: /* 0 001 110 011 */
- sprintf(buffer, "RRC R%01d,1",op&0x3);
+ util::stream_format(stream, "RRC R%01d,1",op&0x3);
break;
case 0x074: /* 0 001 110 100 */
case 0x075: /* 0 001 110 101 */
case 0x076: /* 0 001 110 110 */
case 0x077: /* 0 001 110 111 */
- sprintf(buffer, "RRC R%01d,2",op&0x3);
+ util::stream_format(stream, "RRC R%01d,2",op&0x3);
break;
case 0x078: /* 0 001 111 000 */
case 0x079: /* 0 001 111 001 */
case 0x07a: /* 0 001 111 010 */
case 0x07b: /* 0 001 111 011 */
- sprintf(buffer, "SARC R%01d,1",op&0x3);
+ util::stream_format(stream, "SARC R%01d,1",op&0x3);
break;
case 0x07c: /* 0 001 111 100 */
case 0x07d: /* 0 001 111 101 */
case 0x07e: /* 0 001 111 110 */
case 0x07f: /* 0 001 111 111 */
- sprintf(buffer, "SARC R%01d,2",op&0x3);
+ util::stream_format(stream, "SARC R%01d,2",op&0x3);
break;
case 0x080: /* 0 010 000 000 */
case 0x089: /* 0 010 001 001 */
@@ -367,7 +367,7 @@ CPU_DISASSEMBLE( cp1610 )
case 0x0ad: /* 0 010 101 101 */
case 0x0b6: /* 0 010 110 110 */
case 0x0bf: /* 0 010 111 111 */
- sprintf(buffer, "TSTR R%01d",op&0x7);
+ util::stream_format(stream, "TSTR R%01d",op&0x7);
break;
case 0x087: /* 0 010 000 111 */
case 0x08f: /* 0 010 001 111 */
@@ -376,7 +376,7 @@ CPU_DISASSEMBLE( cp1610 )
case 0x0a7: /* 0 010 100 111 */
case 0x0af: /* 0 010 101 111 */
case 0x0b7: /* 0 010 110 111 */
- sprintf(buffer, "JR R%01d",(op&0x38)>>3);
+ util::stream_format(stream, "JR R%01d",(op&0x38)>>3);
break;
case 0x081: /* 0 010 000 001 */
case 0x082: /* 0 010 000 010 */
@@ -427,7 +427,7 @@ CPU_DISASSEMBLE( cp1610 )
case 0x0bc: /* 0 010 111 100 */
case 0x0bd: /* 0 010 111 101 */
case 0x0be: /* 0 010 111 110 */
- sprintf(buffer, "MOVR R%01d,R%01d",(op&0x38)>>3,op&0x7);
+ util::stream_format(stream, "MOVR R%01d,R%01d",(op&0x38)>>3,op&0x7);
break;
case 0x0c0: /* 0 011 000 000 */
case 0x0c1: /* 0 011 000 001 */
@@ -493,7 +493,7 @@ CPU_DISASSEMBLE( cp1610 )
case 0x0fd: /* 0 011 111 101 */
case 0x0fe: /* 0 011 111 110 */
case 0x0ff: /* 0 011 111 111 */
- sprintf(buffer, "ADDR R%01d,R%01d",(op&0x38)>>3,op&7);
+ util::stream_format(stream, "ADDR R%01d,R%01d",(op&0x38)>>3,op&7);
break;
case 0x100: /* 0 100 000 000 */
case 0x101: /* 0 100 000 001 */
@@ -559,7 +559,7 @@ CPU_DISASSEMBLE( cp1610 )
case 0x13d: /* 0 100 111 101 */
case 0x13e: /* 0 100 111 110 */
case 0x13f: /* 0 100 111 111 */
- sprintf(buffer, "SUBR R%01d,R%01d",(op&0x38)>>3,op&7);
+ util::stream_format(stream, "SUBR R%01d,R%01d",(op&0x38)>>3,op&7);
break;
case 0x140: /* 0 101 000 000 */
case 0x141: /* 0 101 000 001 */
@@ -625,7 +625,7 @@ CPU_DISASSEMBLE( cp1610 )
case 0x17d: /* 0 101 111 101 */
case 0x17e: /* 0 101 111 110 */
case 0x17f: /* 0 101 111 111 */
- sprintf(buffer, "CMPR R%01d,R%01d",(op&0x38)>>3,op&7);
+ util::stream_format(stream, "CMPR R%01d,R%01d",(op&0x38)>>3,op&7);
break;
case 0x180: /* 0 110 000 000 */
case 0x181: /* 0 110 000 001 */
@@ -691,7 +691,7 @@ CPU_DISASSEMBLE( cp1610 )
case 0x1bd: /* 0 110 111 101 */
case 0x1be: /* 0 110 111 110 */
case 0x1bf: /* 0 110 111 111 */
- sprintf(buffer, "ANDR R%01d,R%01d",(op&0x38)>>3,op&7);
+ util::stream_format(stream, "ANDR R%01d,R%01d",(op&0x38)>>3,op&7);
break;
case 0x1c0: /* 0 111 000 000 */
case 0x1c9: /* 0 111 001 001 */
@@ -701,7 +701,7 @@ CPU_DISASSEMBLE( cp1610 )
case 0x1ed: /* 0 111 101 101 */
case 0x1f6: /* 0 111 110 110 */
case 0x1ff: /* 0 111 111 111 */
- sprintf(buffer, "CLRR R%01d",op&7);
+ util::stream_format(stream, "CLRR R%01d",op&7);
break;
case 0x1c1: /* 0 111 000 001 */
case 0x1c2: /* 0 111 000 010 */
@@ -759,87 +759,87 @@ CPU_DISASSEMBLE( cp1610 )
case 0x1fc: /* 0 111 111 100 */
case 0x1fd: /* 0 111 111 101 */
case 0x1fe: /* 0 111 111 110 */
- sprintf(buffer, "XORR R%01d,R%01d",(op&0x38)>>3,op&7);
+ util::stream_format(stream, "XORR R%01d,R%01d",(op&0x38)>>3,op&7);
break;
case 0x200: /* 1 000 000 000 */
size += 1;
ea = oprom16[1];
- sprintf(buffer, "B %04X",pc+2+ea);
+ util::stream_format(stream, "B %04X",pc+2+ea);
break;
case 0x201: /* 1 000 000 001 */
size += 1;
ea = oprom16[1];
- sprintf(buffer, "BC %04X",pc+2+ea);
+ util::stream_format(stream, "BC %04X",pc+2+ea);
break;
case 0x202: /* 1 000 000 010 */
size += 1;
ea = oprom16[1];
- sprintf(buffer, "BOV %04X",pc+2+ea);
+ util::stream_format(stream, "BOV %04X",pc+2+ea);
break;
case 0x203: /* 1 000 000 011 */
size += 1;
ea = oprom16[1];
- sprintf(buffer, "BPL %04X",pc+2+ea);
+ util::stream_format(stream, "BPL %04X",pc+2+ea);
break;
case 0x204: /* 1 000 000 100 */
size += 1;
ea = oprom16[1];
- sprintf(buffer, "BZE %04X",pc+2+ea);
+ util::stream_format(stream, "BZE %04X",pc+2+ea);
break;
case 0x205: /* 1 000 000 101 */
size += 1;
ea = oprom16[1];
- sprintf(buffer, "BLT %04X",pc+2+ea);
+ util::stream_format(stream, "BLT %04X",pc+2+ea);
break;
case 0x206: /* 1 000 000 110 */
size += 1;
ea = oprom16[1];
- sprintf(buffer, "BLE %04X",pc+2+ea);
+ util::stream_format(stream, "BLE %04X",pc+2+ea);
break;
case 0x207: /* 1 000 000 111 */
size += 1;
ea = oprom16[1];
- sprintf(buffer, "BUSC %04X",pc+2+ea);
+ util::stream_format(stream, "BUSC %04X",pc+2+ea);
break;
case 0x208: /* 1 000 001 000 */
size += 1;
ea = oprom16[1];
- sprintf(buffer, "NOPP %04X",pc+2+ea);
+ util::stream_format(stream, "NOPP %04X",pc+2+ea);
break;
case 0x209: /* 1 000 001 001 */
size += 1;
ea = oprom16[1];
- sprintf(buffer, "BNC %04X",pc+2+ea);
+ util::stream_format(stream, "BNC %04X",pc+2+ea);
break;
case 0x20a: /* 1 000 001 010 */
size += 1;
ea = oprom16[1];
- sprintf(buffer, "BNOV %04X",pc+2+ea);
+ util::stream_format(stream, "BNOV %04X",pc+2+ea);
break;
case 0x20b: /* 1 000 001 011 */
size += 1;
ea = oprom16[1];
- sprintf(buffer, "BMI %04X",pc+2+ea);
+ util::stream_format(stream, "BMI %04X",pc+2+ea);
break;
case 0x20c: /* 1 000 001 100 */
size += 1;
ea = oprom16[1];
- sprintf(buffer, "BNZE %04X",pc+2+ea);
+ util::stream_format(stream, "BNZE %04X",pc+2+ea);
break;
case 0x20d: /* 1 000 001 101 */
size += 1;
ea = oprom16[1];
- sprintf(buffer, "BGE %04X",pc+2+ea);
+ util::stream_format(stream, "BGE %04X",pc+2+ea);
break;
case 0x20e: /* 1 000 001 110 */
size += 1;
ea = oprom16[1];
- sprintf(buffer, "BGT %04X",pc+2+ea);
+ util::stream_format(stream, "BGT %04X",pc+2+ea);
break;
case 0x20f: /* 1 000 001 111 */
size += 1;
ea = oprom16[1];
- sprintf(buffer, "BESC %04X",pc+2+ea);
+ util::stream_format(stream, "BESC %04X",pc+2+ea);
break;
case 0x210: /* 1 000 010 000 */
case 0x211: /* 1 000 010 001 */
@@ -859,87 +859,87 @@ CPU_DISASSEMBLE( cp1610 )
case 0x21f: /* 1 000 011 111 */
size += 1;
ea = oprom16[1];
- sprintf(buffer, "BEXT %04X,%01X",pc+2+ea,op&0x0f);
+ util::stream_format(stream, "BEXT %04X,%01X",pc+2+ea,op&0x0f);
break;
case 0x220: /* 1 000 100 000 */
size += 1;
ea = oprom16[1];
- sprintf(buffer, "B %04X",pc+1-ea);
+ util::stream_format(stream, "B %04X",pc+1-ea);
break;
case 0x221: /* 1 000 100 001 */
size += 1;
ea = oprom16[1];
- sprintf(buffer, "BC %04X",pc+1-ea);
+ util::stream_format(stream, "BC %04X",pc+1-ea);
break;
case 0x222: /* 1 000 100 010 */
size += 1;
ea = oprom16[1];
- sprintf(buffer, "BOV %04X",pc+1-ea);
+ util::stream_format(stream, "BOV %04X",pc+1-ea);
break;
case 0x223: /* 1 000 100 011 */
size += 1;
ea = oprom16[1];
- sprintf(buffer, "BPL %04X",pc+1-ea);
+ util::stream_format(stream, "BPL %04X",pc+1-ea);
break;
case 0x224: /* 1 000 100 100 */
size += 1;
ea = oprom16[1];
- sprintf(buffer, "BZE %04X",pc+1-ea);
+ util::stream_format(stream, "BZE %04X",pc+1-ea);
break;
case 0x225: /* 1 000 100 101 */
size += 1;
ea = oprom16[1];
- sprintf(buffer, "BLT %04X",pc+1-ea);
+ util::stream_format(stream, "BLT %04X",pc+1-ea);
break;
case 0x226: /* 1 000 100 110 */
size += 1;
ea = oprom16[1];
- sprintf(buffer, "BLE %04X",pc+1-ea);
+ util::stream_format(stream, "BLE %04X",pc+1-ea);
break;
case 0x227: /* 1 000 100 111 */
size += 1;
ea = oprom16[1];
- sprintf(buffer, "BUSC %04X",pc+1-ea);
+ util::stream_format(stream, "BUSC %04X",pc+1-ea);
break;
case 0x228: /* 1 000 101 000 */
size += 1;
ea = oprom16[1];
- sprintf(buffer, "NOPP %04X",pc+1-ea);
+ util::stream_format(stream, "NOPP %04X",pc+1-ea);
break;
case 0x229: /* 1 000 101 001 */
size += 1;
ea = oprom16[1];
- sprintf(buffer, "BNC %04X",pc+1-ea);
+ util::stream_format(stream, "BNC %04X",pc+1-ea);
break;
case 0x22a: /* 1 000 101 010 */
size += 1;
ea = oprom16[1];
- sprintf(buffer, "BNOV %04X",pc+1-ea);
+ util::stream_format(stream, "BNOV %04X",pc+1-ea);
break;
case 0x22b: /* 1 000 101 011 */
size += 1;
ea = oprom16[1];
- sprintf(buffer, "BMI %04X",pc+1-ea);
+ util::stream_format(stream, "BMI %04X",pc+1-ea);
break;
case 0x22c: /* 1 000 101 100 */
size += 1;
ea = oprom16[1];
- sprintf(buffer, "BNZE %04X",pc+1-ea);
+ util::stream_format(stream, "BNZE %04X",pc+1-ea);
break;
case 0x22d: /* 1 000 101 101 */
size += 1;
ea = oprom16[1];
- sprintf(buffer, "BGE %04X",pc+1-ea);
+ util::stream_format(stream, "BGE %04X",pc+1-ea);
break;
case 0x22e: /* 1 000 101 110 */
size += 1;
ea = oprom16[1];
- sprintf(buffer, "BGT %04X",pc+1-ea);
+ util::stream_format(stream, "BGT %04X",pc+1-ea);
break;
case 0x22f: /* 1 000 101 111 */
size += 1;
ea = oprom16[1];
- sprintf(buffer, "BESC %04X",pc+1-ea);
+ util::stream_format(stream, "BESC %04X",pc+1-ea);
break;
case 0x230: /* 1 000 110 000 */
case 0x231: /* 1 000 110 001 */
@@ -959,7 +959,7 @@ CPU_DISASSEMBLE( cp1610 )
case 0x23f: /* 1 000 111 111 */
size += 1;
ea = oprom16[1];
- sprintf(buffer, "BEXT %04X,%01X",pc+1-ea,op&0x0f);
+ util::stream_format(stream, "BEXT %04X,%01X",pc+1-ea,op&0x0f);
break;
case 0x240: /* 1 001 000 000 */
case 0x241: /* 1 001 000 001 */
@@ -971,7 +971,7 @@ CPU_DISASSEMBLE( cp1610 )
case 0x247: /* 1 001 000 111 */
size += 1;
ea = oprom16[1];
- sprintf(buffer, "MVO R%01d,(%04X)",op&0x7,ea);
+ util::stream_format(stream, "MVO R%01d,(%04X)",op&0x7,ea);
break;
case 0x248: /* 1 001 001 000 */
case 0x249: /* 1 001 001 001 */
@@ -1013,7 +1013,7 @@ CPU_DISASSEMBLE( cp1610 )
case 0x26d: /* 1 001 101 101 */
case 0x26e: /* 1 001 101 110 */
case 0x26f: /* 1 001 101 111 */
- sprintf(buffer, "MVO@ R%01d,(R%01d)",op&0x7,(op&0x38)>>3);
+ util::stream_format(stream, "MVO@ R%01d,(R%01d)",op&0x7,(op&0x38)>>3);
break;
case 0x270: /* 1 001 110 000 */
case 0x271: /* 1 001 110 001 */
@@ -1023,7 +1023,7 @@ CPU_DISASSEMBLE( cp1610 )
case 0x275: /* 1 001 110 101 */
case 0x276: /* 1 001 110 110 */
case 0x277: /* 1 001 110 111 */
- sprintf(buffer, "PSHR R%01d",op&0x7);
+ util::stream_format(stream, "PSHR R%01d",op&0x7);
break;
case 0x278: /* 1 001 111 000 */
case 0x279: /* 1 001 111 001 */
@@ -1034,7 +1034,7 @@ CPU_DISASSEMBLE( cp1610 )
case 0x27e: /* 1 001 111 110 */
case 0x27f: /* 1 001 111 111 */
size += 1;
- sprintf(buffer, "MVOI R%01d,(%04X)",op&0x7,pc+1);
+ util::stream_format(stream, "MVOI R%01d,(%04X)",op&0x7,pc+1);
break;
case 0x280: /* 1 010 000 000 */
case 0x281: /* 1 010 000 001 */
@@ -1046,7 +1046,7 @@ CPU_DISASSEMBLE( cp1610 )
case 0x287: /* 1 010 000 111 */
size += 1;
ea = oprom16[1];
- sprintf(buffer, "MVI (%04X),R%01d",ea,op&0x7);
+ util::stream_format(stream, "MVI (%04X),R%01d",ea,op&0x7);
break;
case 0x288: /* 1 010 001 000 */
case 0x289: /* 1 010 001 001 */
@@ -1088,7 +1088,7 @@ CPU_DISASSEMBLE( cp1610 )
case 0x2ad: /* 1 010 101 101 */
case 0x2ae: /* 1 010 101 110 */
case 0x2af: /* 1 010 101 111 */
- sprintf(buffer, "MVI@ (R%01d),R%01d",(op&0x38)>>3,op&0x7);
+ util::stream_format(stream, "MVI@ (R%01d),R%01d",(op&0x38)>>3,op&0x7);
break;
case 0x2b0: /* 1 010 110 000 */
case 0x2b1: /* 1 010 110 001 */
@@ -1098,7 +1098,7 @@ CPU_DISASSEMBLE( cp1610 )
case 0x2b5: /* 1 010 110 101 */
case 0x2b6: /* 1 010 110 110 */
case 0x2b7: /* 1 010 110 111 */
- sprintf(buffer, "PULR R%01d",op&0x7);
+ util::stream_format(stream, "PULR R%01d",op&0x7);
break;
case 0x2b8: /* 1 010 111 000 */
case 0x2b9: /* 1 010 111 001 */
@@ -1110,7 +1110,7 @@ CPU_DISASSEMBLE( cp1610 )
case 0x2bf: /* 1 010 111 111 */
size += 1;
ea = oprom16[1];
- sprintf(buffer, "MVII #%04X,R%01d",ea,op&0x7);
+ util::stream_format(stream, "MVII #%04X,R%01d",ea,op&0x7);
break;
case 0x2c0: /* 1 011 010 000 */
case 0x2c1: /* 1 011 010 001 */
@@ -1122,7 +1122,7 @@ CPU_DISASSEMBLE( cp1610 )
case 0x2c7: /* 1 011 010 111 */
size += 1;
ea = oprom16[1];
- sprintf(buffer, "ADD (%04X),R%01d",ea,op&0x7);
+ util::stream_format(stream, "ADD (%04X),R%01d",ea,op&0x7);
break;
case 0x2c8: /* 1 011 001 000 */
case 0x2c9: /* 1 011 001 001 */
@@ -1172,7 +1172,7 @@ CPU_DISASSEMBLE( cp1610 )
case 0x2f5: /* 1 011 110 101 */
case 0x2f6: /* 1 011 110 110 */
case 0x2f7: /* 1 011 110 111 */
- sprintf(buffer, "ADD@ (R%01d),R%01d",(op&0x38)>>3,op&0x7);
+ util::stream_format(stream, "ADD@ (R%01d),R%01d",(op&0x38)>>3,op&0x7);
break;
case 0x2f8: /* 1 011 111 000 */
case 0x2f9: /* 1 011 111 001 */
@@ -1184,7 +1184,7 @@ CPU_DISASSEMBLE( cp1610 )
case 0x2ff: /* 1 011 111 111 */
size += 1;
ea = oprom16[1];
- sprintf(buffer, "ADDI #%04X,R%01d",ea,op&0x7);
+ util::stream_format(stream, "ADDI #%04X,R%01d",ea,op&0x7);
break;
case 0x300: /* 1 100 000 000 */
case 0x301: /* 1 100 000 001 */
@@ -1196,7 +1196,7 @@ CPU_DISASSEMBLE( cp1610 )
case 0x307: /* 1 100 000 111 */
size += 1;
ea = oprom16[1];
- sprintf(buffer, "SUB (%04X),R%01d",ea,op&0x7);
+ util::stream_format(stream, "SUB (%04X),R%01d",ea,op&0x7);
break;
case 0x308: /* 1 100 001 000 */
case 0x309: /* 1 100 001 001 */
@@ -1246,7 +1246,7 @@ CPU_DISASSEMBLE( cp1610 )
case 0x335: /* 1 100 110 101 */
case 0x336: /* 1 100 110 110 */
case 0x337: /* 1 100 110 111 */
- sprintf(buffer, "SUB@ (R%01d),R%01d",(op&0x38)>>3,op&0x7);
+ util::stream_format(stream, "SUB@ (R%01d),R%01d",(op&0x38)>>3,op&0x7);
break;
case 0x338: /* 1 100 111 000 */
case 0x339: /* 1 100 111 001 */
@@ -1258,7 +1258,7 @@ CPU_DISASSEMBLE( cp1610 )
case 0x33f: /* 1 100 111 111 */
size += 1;
ea = oprom16[1];
- sprintf(buffer, "SUBI #%04X,R%01d",ea,op&0x7);
+ util::stream_format(stream, "SUBI #%04X,R%01d",ea,op&0x7);
break;
case 0x340: /* 1 101 000 000 */
case 0x341: /* 1 101 000 001 */
@@ -1270,7 +1270,7 @@ CPU_DISASSEMBLE( cp1610 )
case 0x347: /* 1 101 000 111 */
size += 1;
ea = oprom16[1];
- sprintf(buffer, "CMP (%04X),R%01d",ea,op&0x7);
+ util::stream_format(stream, "CMP (%04X),R%01d",ea,op&0x7);
break;
case 0x348: /* 1 101 001 000 */
case 0x349: /* 1 101 001 001 */
@@ -1320,7 +1320,7 @@ CPU_DISASSEMBLE( cp1610 )
case 0x375: /* 1 101 110 101 */
case 0x376: /* 1 101 110 110 */
case 0x377: /* 1 101 110 111 */
- sprintf(buffer, "CMP@ (R%01d),R%01d",(op&0x38)>>3,op&0x7);
+ util::stream_format(stream, "CMP@ (R%01d),R%01d",(op&0x38)>>3,op&0x7);
break;
case 0x378: /* 1 101 111 000 */
case 0x379: /* 1 101 111 001 */
@@ -1332,7 +1332,7 @@ CPU_DISASSEMBLE( cp1610 )
case 0x37f: /* 1 101 111 111 */
size += 1;
ea = oprom16[1];
- sprintf(buffer, "CMPI #%04X,R%01d",ea,op&0x7);
+ util::stream_format(stream, "CMPI #%04X,R%01d",ea,op&0x7);
break;
case 0x380: /* 1 110 000 000 */
case 0x381: /* 1 110 000 001 */
@@ -1344,7 +1344,7 @@ CPU_DISASSEMBLE( cp1610 )
case 0x387: /* 1 110 000 111 */
size += 1;
ea = oprom16[1];
- sprintf(buffer, "AND (%04X),R%01d",ea,op&0x7);
+ util::stream_format(stream, "AND (%04X),R%01d",ea,op&0x7);
break;
case 0x388: /* 1 110 001 000 */
case 0x389: /* 1 110 001 001 */
@@ -1394,7 +1394,7 @@ CPU_DISASSEMBLE( cp1610 )
case 0x3b5: /* 1 110 110 101 */
case 0x3b6: /* 1 110 110 110 */
case 0x3b7: /* 1 110 110 111 */
- sprintf(buffer, "AND@ (R%01d),R%01d",(op&0x38)>>3,op&0x7);
+ util::stream_format(stream, "AND@ (R%01d),R%01d",(op&0x38)>>3,op&0x7);
break;
case 0x3b8: /* 1 110 111 000 */
case 0x3b9: /* 1 110 111 001 */
@@ -1406,7 +1406,7 @@ CPU_DISASSEMBLE( cp1610 )
case 0x3bf: /* 1 110 111 111 */
size += 1;
ea = oprom16[1];
- sprintf(buffer, "ANDI #%04X,R%01d",ea,op&0x7);
+ util::stream_format(stream, "ANDI #%04X,R%01d",ea,op&0x7);
break;
case 0x3c0: /* 1 111 000 000 */
case 0x3c1: /* 1 111 000 001 */
@@ -1418,7 +1418,7 @@ CPU_DISASSEMBLE( cp1610 )
case 0x3c7: /* 1 111 000 111 */
size += 1;
ea = oprom16[1];
- sprintf(buffer, "XOR (%04X),R%01d",ea,op&0x7);
+ util::stream_format(stream, "XOR (%04X),R%01d",ea,op&0x7);
break;
case 0x3c8: /* 1 111 001 000 */
case 0x3c9: /* 1 111 001 001 */
@@ -1468,7 +1468,7 @@ CPU_DISASSEMBLE( cp1610 )
case 0x3f5: /* 1 111 110 101 */
case 0x3f6: /* 1 111 110 110 */
case 0x3f7: /* 1 111 110 111 */
- sprintf(buffer, "XOR@ (R%01d),R%01d",(op&0x38)>>3,op&0x7);
+ util::stream_format(stream, "XOR@ (R%01d),R%01d",(op&0x38)>>3,op&0x7);
break;
case 0x3f8: /* 1 111 111 000 */
case 0x3f9: /* 1 111 111 001 */
@@ -1480,11 +1480,21 @@ CPU_DISASSEMBLE( cp1610 )
case 0x3ff: /* 1 111 111 111 */
size += 1;
ea = oprom16[1];
- sprintf(buffer, "XORI #%04X,R%01d",ea,op&0x7);
+ util::stream_format(stream, "XORI #%04X,R%01d",ea,op&0x7);
break;
default:
- sprintf(buffer, "????");
+ util::stream_format(stream, "????");
}
return size;
}
+
+
+CPU_DISASSEMBLE(cp1610)
+{
+ std::ostringstream stream;
+ offs_t result = internal_disasm_cp1610(device, stream, pc, oprom, opram, options);
+ std::string stream_str = stream.str();
+ strcpy(buffer, stream_str.c_str());
+ return result;
+}
diff --git a/src/devices/cpu/cubeqcpu/cubedasm.cpp b/src/devices/cpu/cubeqcpu/cubedasm.cpp
index 034ac4873b2..6d346f9dc7a 100644
--- a/src/devices/cpu/cubeqcpu/cubedasm.cpp
+++ b/src/devices/cpu/cubeqcpu/cubedasm.cpp
@@ -58,7 +58,7 @@ static const char *const dst[] =
SOUND DISASSEMBLY HOOK
***************************************************************************/
-CPU_DISASSEMBLE( cquestsnd )
+static offs_t internal_disasm_cquestsnd(cpu_device *device, std::ostream &stream, offs_t pc, const uint8_t *oprom, const uint8_t *opram, int options)
{
static const char *const jmps[] =
{
@@ -103,7 +103,7 @@ CPU_DISASSEMBLE( cquestsnd )
int _rin = (inslow >> 26) & 1;
- sprintf(buffer, "%s %s %s %x,%x,%c %.2x %s %s %.2x %s %s %s %c %c %c",
+ util::stream_format(stream, "%s %s %s %x,%x,%c %02x %s %s %02x %s %s %s %c %c %c",
ins[i5_3],
src[i2_0],
dst[i8_6],
@@ -125,11 +125,21 @@ CPU_DISASSEMBLE( cquestsnd )
}
+CPU_DISASSEMBLE(cquestsnd)
+{
+ std::ostringstream stream;
+ offs_t result = internal_disasm_cquestsnd(device, stream, pc, oprom, opram, options);
+ std::string stream_str = stream.str();
+ strcpy(buffer, stream_str.c_str());
+ return result;
+}
+
+
/***************************************************************************
ROTATE DISASSEMBLY HOOK
***************************************************************************/
-CPU_DISASSEMBLE( cquestrot )
+static offs_t internal_disasm_cquestrot(cpu_device *device, std::ostream &stream, offs_t pc, const uint8_t *oprom, const uint8_t *opram, int options)
{
static const char *const jmps[] =
{
@@ -204,7 +214,7 @@ CPU_DISASSEMBLE( cquestrot )
// int _sex = (inslow >> 19) & 0x1;
int i2_0 = (inslow >> 16) & 0x7;
- sprintf(buffer, "%s %s,%s %x,%x,%c %d %s %s %s %.2x",
+ util::stream_format(stream, "%s %s,%s %x,%x,%c %d %s %s %s %02x",
ins[i5_3],
src[i2_0],
dst[i8_6],
@@ -220,11 +230,22 @@ CPU_DISASSEMBLE( cquestrot )
return 1 | DASMFLAG_SUPPORTED;
}
+
+CPU_DISASSEMBLE(cquestrot)
+{
+ std::ostringstream stream;
+ offs_t result = internal_disasm_cquestrot(device, stream, pc, oprom, opram, options);
+ std::string stream_str = stream.str();
+ strcpy(buffer, stream_str.c_str());
+ return result;
+}
+
+
/***************************************************************************
LINE DRAWER DISASSEMBLY HOOK
***************************************************************************/
-CPU_DISASSEMBLE( cquestlin )
+static offs_t internal_disasm_cquestlin(cpu_device *device, std::ostream &stream, offs_t pc, const uint8_t *oprom, const uint8_t *opram, int options)
{
static const char *const jmps[] =
{
@@ -288,7 +309,7 @@ CPU_DISASSEMBLE( cquestlin )
int _pbcs = (inslow >> 27) & 0x1;
int i2_0 = (inslow >> 24) & 0x7;
- sprintf(buffer, "%s %s,%s %x,%x %c %s %.2x %s %s %s %s",
+ util::stream_format(stream, "%s %s,%s %x,%x %c %s %02x %s %s %s %s",
ins[i5_3],
src[i2_0],
dst[i8_6],
@@ -304,3 +325,13 @@ CPU_DISASSEMBLE( cquestlin )
return 1 | DASMFLAG_SUPPORTED;
}
+
+
+CPU_DISASSEMBLE(cquestlin)
+{
+ std::ostringstream stream;
+ offs_t result = internal_disasm_cquestlin(device, stream, pc, oprom, opram, options);
+ std::string stream_str = stream.str();
+ strcpy(buffer, stream_str.c_str());
+ return result;
+}
diff --git a/src/devices/cpu/dsp16/dsp16dis.cpp b/src/devices/cpu/dsp16/dsp16dis.cpp
index 136eaab0e22..52b76fee297 100644
--- a/src/devices/cpu/dsp16/dsp16dis.cpp
+++ b/src/devices/cpu/dsp16/dsp16dis.cpp
@@ -248,7 +248,7 @@ bool disasmSIField(const uint8_t& SI)
}
-CPU_DISASSEMBLE( dsp16a )
+static offs_t internal_disasm_dsp16a(cpu_device *device, std::ostream &stream, offs_t pc, const uint8_t *oprom, const uint8_t *opram, int options)
{
uint8_t opSize = 1;
uint32_t dasmflags = 0;
@@ -270,7 +270,7 @@ CPU_DISASSEMBLE( dsp16a )
const uint8_t F1 = (op & 0x01e0) >> 5;
std::string yString = disasmYField(Y);
std::string fString = disasmF1Field(F1, D, S);
- sprintf(buffer, "%s, %s", fString.c_str(), yString.c_str());
+ util::stream_format(stream, "%s, %s", fString, yString);
break;
}
case 0x04: case 0x1c:
@@ -285,7 +285,7 @@ CPU_DISASSEMBLE( dsp16a )
std::string fString = disasmF1Field(F1, D, S);
std::string aString = (opcode == 0x1c) ? "a0" : "a1";
std::string xString = (X) ? "" : "l";
- sprintf(buffer, "%s = %s%s, %s", yString.c_str(), aString.c_str(), xString.c_str(), fString.c_str());
+ util::stream_format(stream, "%s = %s%s, %s", yString, aString, xString, fString);
break;
}
case 0x16:
@@ -297,7 +297,7 @@ CPU_DISASSEMBLE( dsp16a )
const uint8_t F1 = (op & 0x01e0) >> 5;
std::string yString = disasmYField(Y);
std::string fString = disasmF1Field(F1, D, S);
- sprintf(buffer, "%s, x = %s", fString.c_str(), yString.c_str());
+ util::stream_format(stream, "%s, x = %s", fString, yString);
break;
}
case 0x17:
@@ -311,7 +311,7 @@ CPU_DISASSEMBLE( dsp16a )
std::string yString = disasmYField(Y);
std::string fString = disasmF1Field(F1, D, S);
std::string xString = (X ? "y" : "y1");
- sprintf(buffer, "%s, %s = %s", fString.c_str(), xString.c_str(), yString.c_str());
+ util::stream_format(stream, "%s, %s = %s", fString, xString, yString);
break;
}
case 0x1f:
@@ -325,7 +325,7 @@ CPU_DISASSEMBLE( dsp16a )
std::string yString = disasmYField(Y);
std::string fString = disasmF1Field(F1, D, S);
std::string xString = (X ? "*pt++i" : "*pt++");
- sprintf(buffer, "%s, y = %s, x = %s", fString.c_str(), yString.c_str(), xString.c_str());
+ util::stream_format(stream, "%s, y = %s, x = %s", fString, yString, xString);
break;
}
case 0x19: case 0x1b:
@@ -339,8 +339,11 @@ CPU_DISASSEMBLE( dsp16a )
std::string fString = disasmF1Field(F1, D, S);
std::string xString = (X ? "*pt++i" : "*pt++");
std::string aString = (opcode == 0x19) ? "a0" : "a1";
- sprintf(buffer, "%s, y = %s, x = %s", fString.c_str(), aString.c_str(), xString.c_str());
- if (Y != 0x00) sprintf(buffer, "UNKNOWN");
+
+ if (Y != 0x00)
+ util::stream_format(stream, "UNKNOWN");
+ else
+ util::stream_format(stream, "%s, y = %s, x = %s", fString, aString, xString);
break;
}
case 0x14:
@@ -354,7 +357,7 @@ CPU_DISASSEMBLE( dsp16a )
std::string yString = disasmYField(Y);
std::string xString = (X ? "y" : "y1");
std::string fString = disasmF1Field(F1, D, S);
- sprintf(buffer, "%s, %s = %s", fString.c_str(), yString.c_str(), xString.c_str());
+ util::stream_format(stream, "%s, %s = %s", fString, yString, xString);
break;
}
@@ -369,7 +372,7 @@ CPU_DISASSEMBLE( dsp16a )
std::string yString = disasmYField(Y);
std::string atString = (aT ? "a0" : "a1");
std::string fString = disasmF1Field(F1, aT, S);
- sprintf(buffer, "%s, %s = %s", fString.c_str(), atString.c_str(), yString.c_str());
+ util::stream_format(stream, "%s, %s = %s", fString, atString, yString);
break;
}
@@ -385,7 +388,7 @@ CPU_DISASSEMBLE( dsp16a )
std::string zString = disasmZField(Z);
std::string xString = (X ? "y" : "y1");
std::string fString = disasmF1Field(F1, D, S);
- sprintf(buffer, "%s, %s <=> %s", fString.c_str(), xString.c_str(), zString.c_str());
+ util::stream_format(stream, "%s, %s <=> %s", fString, xString, zString);
break;
}
case 0x1d:
@@ -399,7 +402,7 @@ CPU_DISASSEMBLE( dsp16a )
std::string zString = disasmZField(Z);
std::string xString = (X ? "*pt++i" : "*pt++");
std::string fString = disasmF1Field(F1, D, S);
- sprintf(buffer, "%s, %s <=> y, x = %s", fString.c_str(), zString.c_str(), xString.c_str());
+ util::stream_format(stream, "%s, %s <=> y, x = %s", fString, zString, xString);
break;
}
@@ -416,7 +419,7 @@ CPU_DISASSEMBLE( dsp16a )
std::string atString = (aT ? "a0" : "a1");
atString += X ? "" : "1"; // TODO: Figure out unclear wording.
std::string fString = disasmF1Field(F1, aT, S);
- sprintf(buffer, "%s, %s <=> %s", fString.c_str(), zString.c_str(), atString.c_str());
+ util::stream_format(stream, "%s, %s <=> %s", fString, zString, atString);
break;
}
@@ -431,8 +434,8 @@ CPU_DISASSEMBLE( dsp16a )
const uint8_t F2 = (op & 0x01e0) >> 5;
std::string fString = disasmF2Field(F2, D, S);
std::string conString = disasmCONField(CON);
- if (op & 0x0800) sprintf(buffer, "if %s : %s", conString.c_str(), fString.c_str());
- else sprintf(buffer, "ifc %s : %s", conString.c_str(), fString.c_str());
+ if (op & 0x0800) util::stream_format(stream, "if %s : %s", conString, fString);
+ else util::stream_format(stream, "ifc %s : %s", conString, fString);
break;
}
@@ -441,14 +444,14 @@ CPU_DISASSEMBLE( dsp16a )
{
// goto JA
const uint16_t JA = (op & 0x0fff) | (pc & 0xf000);
- sprintf(buffer, "goto 0x%04x", JA);
+ util::stream_format(stream, "goto 0x%04x", JA);
break;
}
case 0x10: case 0x11:
{
// call JA
const uint16_t JA = (op & 0x0fff) | (pc & 0xf000);
- sprintf(buffer, "call 0x%04x", JA);
+ util::stream_format(stream, "call 0x%04x", JA);
break;
}
@@ -458,7 +461,7 @@ CPU_DISASSEMBLE( dsp16a )
// goto B
const uint8_t B = (op & 0x0700) >> 8;
std::string bString = disasmBField(B);
- sprintf(buffer, "%s", bString.c_str());
+ util::stream_format(stream, "%s", bString);
break;
}
@@ -468,10 +471,10 @@ CPU_DISASSEMBLE( dsp16a )
// if CON [goto/call/return]
const uint8_t CON = (op & 0x001f);
std::string conString = disasmCONField(CON);
- sprintf(buffer, "if %s:", conString.c_str());
+ util::stream_format(stream, "if %s:", conString);
// TODO: Test for invalid ops
// icall
- if (op == 0xd40e) sprintf(buffer, "icall");
+ if (op == 0xd40e) util::stream_format(stream, "icall");
break;
}
@@ -482,7 +485,7 @@ CPU_DISASSEMBLE( dsp16a )
const uint8_t R = (op & 0x03f0) >> 4;
const uint8_t S = (op & 0x1000) >> 12;
std::string rString = disasmRField(R);
- sprintf(buffer, "%s = %s", rString.c_str(), (S ? "a1" : "a0"));
+ util::stream_format(stream, "%s = %s", rString, (S ? "a1" : "a0"));
break;
}
case 0x08:
@@ -491,7 +494,7 @@ CPU_DISASSEMBLE( dsp16a )
const uint8_t R = (op & 0x03f0) >> 4;
const uint8_t aT = (op & 0x0400) >> 10;
std::string rString = disasmRField(R);
- sprintf(buffer, "%s = %s", (aT ? "a0" : "a1"), rString.c_str());
+ util::stream_format(stream, "%s = %s", (aT ? "a0" : "a1"), rString);
break;
}
case 0x0f:
@@ -501,7 +504,7 @@ CPU_DISASSEMBLE( dsp16a )
const uint8_t R = (op & 0x03f0) >> 4;
std::string yString = disasmYField(Y);
std::string rString = disasmRField(R);
- sprintf(buffer, "%s = %s", rString.c_str(), yString.c_str());
+ util::stream_format(stream, "%s = %s", rString, yString);
// TODO: Special case the R == [y, y1, or x] case
break;
}
@@ -513,7 +516,7 @@ CPU_DISASSEMBLE( dsp16a )
std::string yString = disasmYField(Y);
std::string rString = disasmRField(R);
// TODO: page 3-31 "special function encoding"
- sprintf(buffer, "%s = %s", yString.c_str(), rString.c_str());
+ util::stream_format(stream, "%s = %s", yString, rString);
break;
}
case 0x0d:
@@ -523,7 +526,7 @@ CPU_DISASSEMBLE( dsp16a )
const uint8_t R = (op & 0x03f0) >> 4;
std::string zString = disasmZField(Z);
std::string rString = disasmRField(R);
- sprintf(buffer, "%s <=> %s", zString.c_str(), rString.c_str());
+ util::stream_format(stream, "%s <=> %s", zString, rString);
break;
}
@@ -533,7 +536,7 @@ CPU_DISASSEMBLE( dsp16a )
// R = N
const uint8_t R = (op & 0x03f0) >> 4;
std::string rString = disasmRField(R);
- sprintf(buffer, "%s = 0x%04x", rString.c_str(), op2);
+ util::stream_format(stream, "%s = 0x%04x", rString, op2);
opSize = 2;
break;
}
@@ -545,7 +548,7 @@ CPU_DISASSEMBLE( dsp16a )
const uint16_t M = (op & 0x01ff);
const uint8_t R = (op & 0x0e00) >> 9;
std::string rString = disasmRImmediateField(R);
- sprintf(buffer, "%s = 0x%04x", rString.c_str(), M);
+ util::stream_format(stream, "%s = 0x%04x", rString, M);
break;
}
@@ -555,27 +558,39 @@ CPU_DISASSEMBLE( dsp16a )
// do|redo K
const uint8_t K = (op & 0x007f);
const uint8_t NI = (op & 0x0780) >> 7;
- sprintf(buffer, "do (next %d inst) %d times", NI, K);
+
// TODO: Limits on K & NI
if (NI == 0x00)
- sprintf(buffer, "redo %d", K);
+ util::stream_format(stream, "redo %d", K);
+ else
+ util::stream_format(stream, "do (next %d inst) %d times", NI, K);
break;
}
// RESERVED
case 0x1e:
{
- sprintf(buffer, "RESERVED");
+ util::stream_format(stream, "RESERVED");
break;
}
// UNKNOWN
default:
{
- sprintf(buffer, "UNKNOWN");
+ util::stream_format(stream, "UNKNOWN");
break;
}
}
return opSize | dasmflags | DASMFLAG_SUPPORTED;
}
+
+
+CPU_DISASSEMBLE(dsp16a)
+{
+ std::ostringstream stream;
+ offs_t result = internal_disasm_dsp16a(device, stream, pc, oprom, opram, options);
+ std::string stream_str = stream.str();
+ strcpy(buffer, stream_str.c_str());
+ return result;
+}
diff --git a/src/mame/drivers/tv910.cpp b/src/mame/drivers/tv910.cpp
new file mode 100644
index 00000000000..2feb8f07043
--- /dev/null
+++ b/src/mame/drivers/tv910.cpp
@@ -0,0 +1,552 @@
+// license:BSD-3-Clause
+// copyright-holders: R. Belmont
+/***************************************************************************
+
+ TeleVideo TV-910 / 910 Plus
+ Preliminary driver by R. Belmont
+
+ Hardware:
+ 6502 CPU
+ 6545 CRTC
+ 6551 ACIA
+
+ IRQ = ACIA wire-OR CRTC VBlank
+ NMI = AY-5-3600 keyboard char present
+
+ TODO:
+ - Character attributes: how is that even possible? (Esc-V brings up test screen)
+ - DIP switches don't all appear to have the expected effects
+ - Keyboard hookup isn't quite right
+
+****************************************************************************/
+
+#include "emu.h"
+#include "cpu/m6502/m6502.h"
+#include "video/mc6845.h"
+#include "machine/mos6551.h"
+#include "machine/kb3600.h"
+#include "bus/rs232/rs232.h"
+
+#define ACIA_TAG "acia1"
+#define CRTC_TAG "crtc"
+#define RS232_TAG "rs232"
+#define KBDC_TAG "ay3600"
+
+#define MASTER_CLOCK (13608000)
+
+class tv910_state : public driver_device
+{
+public:
+ tv910_state(const machine_config &mconfig, device_type type, const char *tag)
+ : driver_device(mconfig, type, tag)
+ , m_maincpu(*this, "maincpu")
+ , m_crtc(*this, CRTC_TAG)
+ , m_vram(*this, "vram")
+ , m_ay3600(*this, KBDC_TAG)
+ , m_kbdrom(*this, "keyboard")
+ , m_kbspecial(*this, "keyb_special")
+ { }
+
+ virtual void machine_start() override;
+ virtual void machine_reset() override;
+
+ MC6845_UPDATE_ROW(crtc_update_row);
+ MC6845_ON_UPDATE_ADDR_CHANGED(crtc_update_addr);
+
+ DECLARE_READ8_MEMBER(charset_r);
+ DECLARE_READ8_MEMBER(kbd_ascii_r);
+ DECLARE_READ8_MEMBER(kbd_flags_r);
+
+ DECLARE_WRITE8_MEMBER(vbl_ack_w);
+ DECLARE_WRITE8_MEMBER(nmi_ack_w);
+ DECLARE_WRITE8_MEMBER(control_w);
+
+ DECLARE_WRITE_LINE_MEMBER(vbl_w);
+ DECLARE_WRITE_LINE_MEMBER(acia_irq_w);
+
+ DECLARE_READ_LINE_MEMBER(ay3600_shift_r);
+ DECLARE_READ_LINE_MEMBER(ay3600_control_r);
+ DECLARE_WRITE_LINE_MEMBER(ay3600_data_ready_w);
+ DECLARE_WRITE_LINE_MEMBER(ay3600_ako_w);
+
+ required_device<m6502_device> m_maincpu;
+ required_device<r6545_1_device> m_crtc;
+ required_shared_ptr<uint8_t> m_vram;
+ required_device<ay3600_device> m_ay3600;
+ required_memory_region m_kbdrom;
+ required_ioport m_kbspecial;
+
+private:
+ uint8_t *m_vramptr, *m_chrrom;
+
+ uint16_t m_lastchar, m_strobe;
+ uint8_t m_transchar;
+ bool m_anykeydown;
+ int m_repeatdelay;
+
+ uint8_t m_control;
+
+ bool m_vbl_irq, m_aica_irq;
+};
+
+static ADDRESS_MAP_START(tv910_mem, AS_PROGRAM, 8, tv910_state)
+ ADDRESS_MAP_UNMAP_HIGH
+ AM_RANGE(0x0000, 0x03ff) AM_RAM
+ AM_RANGE(0x4000, 0x47ff) AM_RAM AM_SHARE("vram") // VRAM
+ AM_RANGE(0x8010, 0x801f) AM_READ(charset_r)
+ AM_RANGE(0x8020, 0x8020) AM_DEVREADWRITE(CRTC_TAG, r6545_1_device, status_r, address_w)
+ AM_RANGE(0x8021, 0x8021) AM_DEVREADWRITE(CRTC_TAG, r6545_1_device, register_r, register_w)
+ AM_RANGE(0x8030, 0x8033) AM_DEVREADWRITE(ACIA_TAG, mos6551_device, read, write)
+ AM_RANGE(0x8040, 0x804f) AM_WRITE(vbl_ack_w)
+ AM_RANGE(0x8050, 0x805f) AM_WRITE(nmi_ack_w)
+ AM_RANGE(0x8060, 0x806f) AM_READ(kbd_ascii_r)
+ AM_RANGE(0x8070, 0x807f) AM_READ(kbd_flags_r)
+ AM_RANGE(0x9000, 0x9000) AM_WRITE(control_w)
+ AM_RANGE(0x9001, 0x9001) AM_READ_PORT("DSW1") // S2 in the operator's manual
+ AM_RANGE(0x9002, 0x9002) AM_READ_PORT("DSW2") // S1 in the operator's manual
+ AM_RANGE(0xf000, 0xffff) AM_ROM AM_REGION("maincpu", 0)
+ADDRESS_MAP_END
+
+WRITE8_MEMBER(tv910_state::control_w)
+{
+ m_control = data;
+ #if 0
+ printf("%02x to control (%c%c%c%c%c)\n",
+ data,
+ (data & 0x10) ? 'U' : 'B',
+ (data & 0x8) ? '6' : '5',
+ (data & 0x4) ? 'X' : ' ',
+ (data & 0x2) ? 'C' : 'c',
+ (data & 1) ? 'B' : ' ');
+ #endif
+}
+
+READ8_MEMBER(tv910_state::charset_r)
+{
+ return 0; // 0 = US (TODO: make this configurable)
+}
+
+WRITE8_MEMBER(tv910_state::nmi_ack_w)
+{
+ m_maincpu->set_input_line(M6502_NMI_LINE, CLEAR_LINE);
+ m_strobe = 0;
+}
+
+READ8_MEMBER(tv910_state::kbd_ascii_r)
+{
+ return m_transchar;
+}
+
+READ8_MEMBER(tv910_state::kbd_flags_r)
+{
+ uint8_t rv = 0;
+
+ //rv |= m_strobe ? 0x40 : 0;
+ //rv |= (m_kbspecial->read() & 0x01) ? 0x00 : 0x40; // caps lock
+ rv |= 0x40; // must be set for keyboard reads to work, but disagrees with docs?
+
+ return rv;
+}
+
+READ_LINE_MEMBER(tv910_state::ay3600_shift_r)
+{
+ // either shift key
+ if (m_kbspecial->read() & 0x06)
+ {
+ return ASSERT_LINE;
+ }
+
+ return CLEAR_LINE;
+}
+
+READ_LINE_MEMBER(tv910_state::ay3600_control_r)
+{
+ if (m_kbspecial->read() & 0x08)
+ {
+ return ASSERT_LINE;
+ }
+
+ return CLEAR_LINE;
+}
+
+WRITE_LINE_MEMBER(tv910_state::ay3600_data_ready_w)
+{
+ if (state == ASSERT_LINE)
+ {
+ uint8_t *decode = m_kbdrom->base();
+
+ m_lastchar = m_ay3600->b_r();
+ m_transchar = decode[m_lastchar];
+ m_strobe = 1;
+
+ m_maincpu->set_input_line(M6502_NMI_LINE, ASSERT_LINE);
+ //printf("new char = %04x (%02x)\n", m_lastchar, m_transchar);
+ }
+}
+
+WRITE_LINE_MEMBER(tv910_state::ay3600_ako_w)
+{
+ m_anykeydown = (state == ASSERT_LINE) ? true : false;
+
+ if (m_anykeydown)
+ {
+ m_repeatdelay = 10;
+ }
+}
+
+/* Input ports */
+
+/*
+Keyboard matrix (thanks to Al Kossow!)
+
+ X0 X1 X2 X3 X4 X5 X6 X7
+Y8 BKTAB FN19 FN18 FN17
+Y7 B 3 E F [ RET ` {
+Y6 . 7 U K BRK SPACE BS HOME
+Y5 V 2 W D P ENTER 0 DEL
+Y4 , 6 Y J ' / 9 DOWN
+Y3 C 1 Q S O ; = CLRSP
+Y2 M 5 T H LEFT 8 UP
+Y1 X ESC TAB A I L - Z
+Y0 N 4 R G LF PRNT \ RIGHT
+*/
+
+static INPUT_PORTS_START( tv910 )
+ PORT_START("X0")
+ PORT_BIT(0x001, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_CODE(KEYCODE_N) PORT_CHAR('N') PORT_CHAR('n')
+ PORT_BIT(0x002, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_CODE(KEYCODE_X) PORT_CHAR('X') PORT_CHAR('x')
+ PORT_BIT(0x004, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_CODE(KEYCODE_M) PORT_CHAR('M') PORT_CHAR('m')
+ PORT_BIT(0x008, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_CODE(KEYCODE_C) PORT_CHAR('C') PORT_CHAR('c')
+ PORT_BIT(0x010, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_CODE(KEYCODE_COMMA) PORT_CHAR(',') PORT_CHAR('<')
+ PORT_BIT(0x020, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_CODE(KEYCODE_V) PORT_CHAR('V') PORT_CHAR('v')
+ PORT_BIT(0x040, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_CODE(KEYCODE_STOP) PORT_CHAR('.') PORT_CHAR('>')
+ PORT_BIT(0x080, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_CODE(KEYCODE_B) PORT_CHAR('B') PORT_CHAR('b')
+ PORT_BIT(0x100, IP_ACTIVE_HIGH, IPT_UNUSED)
+
+ PORT_START("X1")
+ PORT_BIT(0x001, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_CODE(KEYCODE_4) PORT_CHAR('4') PORT_CHAR('$')
+ PORT_BIT(0x002, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Esc") PORT_CODE(KEYCODE_ESC) PORT_CHAR(27)
+ PORT_BIT(0x004, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_CODE(KEYCODE_5) PORT_CHAR('5') PORT_CHAR('%')
+ PORT_BIT(0x008, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_CODE(KEYCODE_1) PORT_CHAR('1') PORT_CHAR('!')
+ PORT_BIT(0x010, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_CODE(KEYCODE_6) PORT_CHAR('6') PORT_CHAR('&')
+ PORT_BIT(0x020, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_CODE(KEYCODE_2) PORT_CHAR('2') PORT_CHAR('\"')
+ PORT_BIT(0x040, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_CODE(KEYCODE_7) PORT_CHAR('7') PORT_CHAR('\'')
+ PORT_BIT(0x080, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_CODE(KEYCODE_3) PORT_CHAR('3') PORT_CHAR('#')
+ PORT_BIT(0x100, IP_ACTIVE_HIGH, IPT_UNUSED)
+
+ PORT_START("X2")
+ PORT_BIT(0x001, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_CODE(KEYCODE_R) PORT_CHAR('R') PORT_CHAR('r')
+ PORT_BIT(0x002, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Tab") PORT_CODE(KEYCODE_TAB) PORT_CHAR(9)
+ PORT_BIT(0x004, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_CODE(KEYCODE_T) PORT_CHAR('T') PORT_CHAR('t')
+ PORT_BIT(0x008, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_CODE(KEYCODE_Q) PORT_CHAR('Q') PORT_CHAR('q')
+ PORT_BIT(0x010, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_CODE(KEYCODE_Y) PORT_CHAR('Y') PORT_CHAR('y')
+ PORT_BIT(0x020, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_CODE(KEYCODE_W) PORT_CHAR('W') PORT_CHAR('w')
+ PORT_BIT(0x040, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_CODE(KEYCODE_U) PORT_CHAR('U') PORT_CHAR('u')
+ PORT_BIT(0x080, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_CODE(KEYCODE_E) PORT_CHAR('E') PORT_CHAR('e')
+ PORT_BIT(0x100, IP_ACTIVE_HIGH, IPT_UNUSED)
+
+ PORT_START("X3")
+ PORT_BIT(0x001, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_CODE(KEYCODE_G) PORT_CHAR('G') PORT_CHAR('g')
+ PORT_BIT(0x002, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_CODE(KEYCODE_A) PORT_CHAR('A') PORT_CHAR('a')
+ PORT_BIT(0x004, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_CODE(KEYCODE_H) PORT_CHAR('H') PORT_CHAR('h')
+ PORT_BIT(0x008, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_CODE(KEYCODE_S) PORT_CHAR('S') PORT_CHAR('s')
+ PORT_BIT(0x010, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_CODE(KEYCODE_J) PORT_CHAR('J') PORT_CHAR('j')
+ PORT_BIT(0x020, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_CODE(KEYCODE_D) PORT_CHAR('D') PORT_CHAR('d')
+ PORT_BIT(0x040, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_CODE(KEYCODE_K) PORT_CHAR('K') PORT_CHAR('k')
+ PORT_BIT(0x080, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_CODE(KEYCODE_F) PORT_CHAR('F') PORT_CHAR('f')
+ PORT_BIT(0x100, IP_ACTIVE_HIGH, IPT_UNUSED)
+
+ PORT_START("X4")
+ /// 001 - LF
+ PORT_BIT(0x002, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_CODE(KEYCODE_I) PORT_CHAR('I') PORT_CHAR('i')
+ PORT_BIT(0x004, IP_ACTIVE_HIGH, IPT_UNUSED)
+ PORT_BIT(0x008, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_CODE(KEYCODE_O) PORT_CHAR('O') PORT_CHAR('o')
+ PORT_BIT(0x010, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_CODE(KEYCODE_QUOTE) PORT_CHAR('\'') PORT_CHAR('\"')
+ PORT_BIT(0x020, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_CODE(KEYCODE_P) PORT_CHAR('P') PORT_CHAR('p')
+ /// 040 - BRK
+ PORT_BIT(0x080, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_CODE(KEYCODE_OPENBRACE) PORT_CHAR('[')
+ /// 100 - BACKTAB
+
+ PORT_START("X5")
+ PORT_BIT(0x001, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_PRTSCR) PORT_CHAR(UCHAR_MAMEKEY(PRTSCR))
+ PORT_BIT(0x002, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_CODE(KEYCODE_L) PORT_CHAR('L') PORT_CHAR('l')
+ PORT_BIT(0x004, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME(UTF8_LEFT) PORT_CODE(KEYCODE_LEFT)
+ PORT_BIT(0x008, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_CODE(KEYCODE_COLON) PORT_CHAR(';') PORT_CHAR(':')
+ PORT_BIT(0x010, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_CODE(KEYCODE_SLASH) PORT_CHAR('/') PORT_CHAR('?')
+ PORT_BIT(0x020, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_CODE(KEYCODE_ENTER_PAD) PORT_CHAR(UCHAR_MAMEKEY(ENTER_PAD))
+ PORT_BIT(0x040, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_CODE(KEYCODE_SPACE) PORT_CHAR(' ')
+ PORT_BIT(0x080, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Return") PORT_CODE(KEYCODE_ENTER) PORT_CHAR(13)
+ PORT_BIT(0x100, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_F19) PORT_CHAR(UCHAR_MAMEKEY(F19))
+
+ PORT_START("X6")
+ PORT_BIT(0x001, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_CODE(KEYCODE_BACKSLASH) PORT_CHAR('\\') PORT_CHAR('|')
+ PORT_BIT(0x002, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_CODE(KEYCODE_MINUS) PORT_CHAR('-') PORT_CHAR('_')
+ PORT_BIT(0x004, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_CODE(KEYCODE_8) PORT_CHAR('8') PORT_CHAR('(')
+ PORT_BIT(0x008, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_CODE(KEYCODE_EQUALS) PORT_CHAR('=') PORT_CHAR('+')
+ PORT_BIT(0x010, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_CODE(KEYCODE_9) PORT_CHAR('9') PORT_CHAR(')')
+ PORT_BIT(0x020, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_CODE(KEYCODE_0) PORT_CHAR('0') PORT_CHAR(')')
+ PORT_BIT(0x040, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Backspace") PORT_CODE(KEYCODE_BACKSPACE) PORT_CHAR(8)
+ PORT_BIT(0x080, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_CODE(KEYCODE_TILDE) PORT_CHAR('`') PORT_CHAR('~')
+ PORT_BIT(0x100, IP_ACTIVE_HIGH, IPT_KEYBOARD ) PORT_CODE(KEYCODE_F18) PORT_CHAR(UCHAR_MAMEKEY(F18))
+
+ PORT_START("X7")
+ PORT_BIT(0x001, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME(UTF8_RIGHT) PORT_CODE(KEYCODE_RIGHT)
+ PORT_BIT(0x002, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_CODE(KEYCODE_Z) PORT_CHAR('Z') PORT_CHAR('z')
+ PORT_BIT(0x004, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME(UTF8_UP) PORT_CODE(KEYCODE_UP)
+/// 008 - CLRSP
+ PORT_BIT(0x010, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME(UTF8_DOWN) PORT_CODE(KEYCODE_DOWN) PORT_CHAR(10) // E0 47
+ PORT_BIT(0x080, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_CODE(KEYCODE_CLOSEBRACE) PORT_CHAR('{')
+
+ PORT_START("X8")
+ PORT_BIT(0x001, IP_ACTIVE_HIGH, IPT_UNUSED)
+ PORT_BIT(0x002, IP_ACTIVE_HIGH, IPT_UNUSED)
+ PORT_BIT(0x004, IP_ACTIVE_HIGH, IPT_UNUSED)
+ PORT_BIT(0x008, IP_ACTIVE_HIGH, IPT_UNUSED)
+ PORT_BIT(0x010, IP_ACTIVE_HIGH, IPT_UNUSED)
+ PORT_BIT(0x020, IP_ACTIVE_HIGH, IPT_UNUSED)
+ PORT_BIT(0x040, IP_ACTIVE_HIGH, IPT_UNUSED)
+ PORT_BIT(0x080, IP_ACTIVE_HIGH, IPT_UNUSED)
+ PORT_BIT(0x100, IP_ACTIVE_HIGH, IPT_UNUSED)
+ PORT_BIT(0x200, IP_ACTIVE_HIGH, IPT_UNUSED)
+
+ PORT_START("keyb_special")
+ PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_KEYBOARD) PORT_NAME("Caps Lock") PORT_CODE(KEYCODE_CAPSLOCK) PORT_TOGGLE
+ PORT_BIT( 0x02, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Left Shift") PORT_CODE(KEYCODE_LSHIFT) PORT_CHAR(UCHAR_SHIFT_1)
+ PORT_BIT( 0x04, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Right Shift") PORT_CODE(KEYCODE_RSHIFT) PORT_CHAR(UCHAR_SHIFT_1)
+ PORT_BIT( 0x08, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Control") PORT_CODE(KEYCODE_LCONTROL) PORT_CHAR(UCHAR_SHIFT_2)
+
+
+ PORT_START("DSW2") // "S1" in the Operator's Manual
+ PORT_DIPNAME( 0x0f, 0x00, "Baud rate" )
+ PORT_DIPSETTING( 0x0, "9600" )
+ PORT_DIPSETTING( 0x1, "50" )
+ PORT_DIPSETTING( 0x2, "75" )
+ PORT_DIPSETTING( 0x3, "110" )
+ PORT_DIPSETTING( 0x4, "135" )
+ PORT_DIPSETTING( 0x5, "150" )
+ PORT_DIPSETTING( 0x6, "300" )
+ PORT_DIPSETTING( 0x7, "600" )
+ PORT_DIPSETTING( 0x8, "1200" )
+ PORT_DIPSETTING( 0x9, "1800" )
+ PORT_DIPSETTING( 0xa, "2400" )
+ PORT_DIPSETTING( 0xb, "3600" )
+ PORT_DIPSETTING( 0xc, "4800" )
+ PORT_DIPSETTING( 0xd, "7200" )
+ PORT_DIPSETTING( 0xe, "9600" )
+ PORT_DIPSETTING( 0xf, "19200" )
+
+ PORT_DIPNAME( 0x10, 0x00, "Data bits" )
+ PORT_DIPSETTING( 0x00, "8 bits" )
+ PORT_DIPSETTING( 0x10, "7 bits" )
+
+ PORT_DIPNAME( 0x20, 0x00, "Parity" )
+ PORT_DIPSETTING( 0x00, "No Parity" )
+ PORT_DIPSETTING( 0x20, "Send Parity" )
+
+ PORT_DIPNAME( 0x40, 0x00, "Parity Type" )
+ PORT_DIPSETTING( 0x00, "Odd Parity" )
+ PORT_DIPSETTING( 0x40, "Even Parity" )
+
+ PORT_DIPNAME( 0x80, 0x00, "Stop Bits" )
+ PORT_DIPSETTING( 0x00, "1 stop bit" )
+ PORT_DIPSETTING( 0x80, "2 stop bits" )
+
+ PORT_START("DSW1") // "S2" in the Operator's Manual
+ PORT_DIPNAME( 0x03, 0x00, "Term Char")
+ PORT_DIPSETTING( 0x0, "0" )
+ PORT_DIPSETTING( 0x1, "1" )
+ PORT_DIPSETTING( 0x2, "2" )
+ PORT_DIPSETTING( 0x3, "3" )
+
+ PORT_DIPNAME( 0x0c, 0x00, "Emulation" )
+ PORT_DIPSETTING( 0x0, "Standard 910" )
+ PORT_DIPSETTING( 0x4, "ADM-3A/5" )
+ PORT_DIPSETTING( 0x8, "ADDS 25" )
+ PORT_DIPSETTING( 0xc, "Hazeltine 1410" )
+
+ PORT_DIPNAME( 0x10, 0x00, "Refresh rate" )
+ PORT_DIPSETTING( 0x00, "60 Hz" )
+ PORT_DIPSETTING( 0x10, "50 Hz" )
+
+ PORT_DIPNAME( 0x60, 0x00, "Cursor type" )
+ PORT_DIPSETTING( 0x00, "Blinking block" )
+ PORT_DIPSETTING( 0x20, "Blinking underline" )
+ PORT_DIPSETTING( 0x40, "Steady block" )
+ PORT_DIPSETTING( 0x60, "Steady underline" )
+
+ PORT_DIPNAME( 0x80, 0x00, "Duplex" )
+ PORT_DIPSETTING( 0x00, "Half Duplex" )
+ PORT_DIPSETTING( 0x80, "Full Duplex" )
+#if 0
+ PORT_DIPNAME( 0x100, 0x000, "Colors" )
+ PORT_DIPSETTING( 0x00, "Black characters on white screen" )
+ PORT_DIPSETTING( 0x100, "White characters on black screen" )
+
+ PORT_DIPNAME( 0x200, 0x200, "Data Set Ready" )
+ PORT_DIPSETTING( 0x00, "DSR connected" )
+ PORT_DIPSETTING( 0x200, "DSR disconnected" )
+#endif
+INPUT_PORTS_END
+
+void tv910_state::machine_start()
+{
+ m_vramptr = m_vram.target();
+ m_chrrom = memregion("graphics")->base();
+}
+
+void tv910_state::machine_reset()
+{
+}
+
+MC6845_ON_UPDATE_ADDR_CHANGED( tv910_state::crtc_update_addr )
+{
+}
+
+WRITE_LINE_MEMBER(tv910_state::vbl_w)
+{
+ // this is ACKed by vbl_ack_w, state going 0 here doesn't ack the IRQ
+ if (state)
+ {
+ m_vbl_irq = true;
+ m_maincpu->set_input_line(M6502_IRQ_LINE, ASSERT_LINE);
+ }
+}
+
+WRITE_LINE_MEMBER(tv910_state::acia_irq_w)
+{
+ m_aica_irq = (state == ASSERT_LINE) ? true : false;
+
+ if (m_aica_irq || m_vbl_irq)
+ {
+ m_maincpu->set_input_line(M6502_IRQ_LINE, ASSERT_LINE);
+ }
+ else
+ {
+ m_maincpu->set_input_line(M6502_IRQ_LINE, CLEAR_LINE);
+ }
+}
+
+WRITE8_MEMBER(tv910_state::vbl_ack_w)
+{
+ m_vbl_irq = false;
+
+ if (m_aica_irq || m_vbl_irq)
+ {
+ m_maincpu->set_input_line(M6502_IRQ_LINE, ASSERT_LINE);
+ }
+ else
+ {
+ m_maincpu->set_input_line(M6502_IRQ_LINE, CLEAR_LINE);
+ }
+}
+
+MC6845_UPDATE_ROW( tv910_state::crtc_update_row )
+{
+ static const uint32_t palette[2] = { 0, 0x00ff00 };
+ uint32_t *p = &bitmap.pix32(y);
+ uint16_t chr_base = ra;
+ int i;
+
+ for ( i = 0; i < x_count; i++ )
+ {
+ uint16_t offset = ( ma + i ) & 0x7ff;
+ uint8_t chr = m_vramptr[ offset ];
+ uint8_t data = m_chrrom[ chr_base + chr * 8 ];
+ uint8_t fg = 1;
+ uint8_t bg = 0;
+
+ if ( i == cursor_x )
+ {
+ if (m_control & 2)
+ {
+ data = 0xFF;
+ }
+ }
+
+ if ((y % 10) >= 8)
+ {
+ *p++ = palette[0];
+ *p++ = palette[0];
+ *p++ = palette[0];
+ *p++ = palette[0];
+ *p++ = palette[0];
+ *p++ = palette[0];
+ *p++ = palette[0];
+ *p++ = palette[0];
+ *p++ = palette[0];
+ }
+ else
+ {
+ *p = palette[( data & 0x80 ) ? fg : bg]; p++;
+ *p = palette[( data & 0x40 ) ? fg : bg]; p++;
+ *p = palette[( data & 0x20 ) ? fg : bg]; p++;
+ *p = palette[( data & 0x10 ) ? fg : bg]; p++;
+ *p = palette[( data & 0x08 ) ? fg : bg]; p++;
+ *p = palette[( data & 0x04 ) ? fg : bg]; p++;
+ *p = palette[( data & 0x02 ) ? fg : bg]; p++;
+ *p = palette[( data & 0x01 ) ? fg : bg]; p++;
+ }
+ }
+}
+
+static MACHINE_CONFIG_START( tv910, tv910_state )
+ /* basic machine hardware */
+ MCFG_CPU_ADD("maincpu", M6502, MASTER_CLOCK/8)
+ MCFG_CPU_PROGRAM_MAP(tv910_mem)
+
+ MCFG_SCREEN_ADD("screen", RASTER)
+ MCFG_SCREEN_RAW_PARAMS(MASTER_CLOCK, 882, 0, 720, 370, 0, 350 ) // not real values
+ MCFG_SCREEN_UPDATE_DEVICE( CRTC_TAG, r6545_1_device, screen_update )
+
+ MCFG_MC6845_ADD(CRTC_TAG, R6545_1, "screen", MASTER_CLOCK/8)
+ MCFG_MC6845_SHOW_BORDER_AREA(false)
+ MCFG_MC6845_CHAR_WIDTH(8)
+ MCFG_MC6845_UPDATE_ROW_CB(tv910_state, crtc_update_row)
+ MCFG_MC6845_ADDR_CHANGED_CB(tv910_state, crtc_update_addr)
+ MCFG_MC6845_OUT_VSYNC_CB(WRITELINE(tv910_state, vbl_w))
+
+ MCFG_DEVICE_ADD(KBDC_TAG, AY3600, 0)
+ MCFG_AY3600_MATRIX_X0(IOPORT("X0"))
+ MCFG_AY3600_MATRIX_X1(IOPORT("X1"))
+ MCFG_AY3600_MATRIX_X2(IOPORT("X2"))
+ MCFG_AY3600_MATRIX_X3(IOPORT("X3"))
+ MCFG_AY3600_MATRIX_X4(IOPORT("X4"))
+ MCFG_AY3600_MATRIX_X5(IOPORT("X5"))
+ MCFG_AY3600_MATRIX_X6(IOPORT("X6"))
+ MCFG_AY3600_MATRIX_X7(IOPORT("X7"))
+ MCFG_AY3600_MATRIX_X8(IOPORT("X8"))
+ MCFG_AY3600_SHIFT_CB(READLINE(tv910_state, ay3600_shift_r))
+ MCFG_AY3600_CONTROL_CB(READLINE(tv910_state, ay3600_control_r))
+ MCFG_AY3600_DATA_READY_CB(WRITELINE(tv910_state, ay3600_data_ready_w))
+ MCFG_AY3600_AKO_CB(WRITELINE(tv910_state, ay3600_ako_w))
+
+ MCFG_DEVICE_ADD(ACIA_TAG, MOS6551, 0)
+ MCFG_MOS6551_XTAL(XTAL_1_8432MHz)
+ MCFG_MOS6551_IRQ_HANDLER(WRITELINE(tv910_state, acia_irq_w))
+ MCFG_MOS6551_TXD_HANDLER(DEVWRITELINE(RS232_TAG, rs232_port_device, write_txd))
+ MCFG_MOS6551_RTS_HANDLER(DEVWRITELINE(RS232_TAG, rs232_port_device, write_rts))
+ MCFG_MOS6551_DTR_HANDLER(DEVWRITELINE(RS232_TAG, rs232_port_device, write_dtr))
+
+ MCFG_RS232_PORT_ADD(RS232_TAG, default_rs232_devices, nullptr)
+ MCFG_RS232_RXD_HANDLER(DEVWRITELINE(ACIA_TAG, mos6551_device, write_rxd))
+ MCFG_RS232_DCD_HANDLER(DEVWRITELINE(ACIA_TAG, mos6551_device, write_dcd))
+ MCFG_RS232_DSR_HANDLER(DEVWRITELINE(ACIA_TAG, mos6551_device, write_dsr))
+ MCFG_RS232_CTS_HANDLER(DEVWRITELINE(ACIA_TAG, mos6551_device, write_cts))
+
+MACHINE_CONFIG_END
+
+/* ROM definition */
+ROM_START( tv910 )
+ ROM_REGION(0x1000, "maincpu", 0)
+ ROM_LOAD( "1800000-020e_a38_9182.bin", 0x000000, 0x001000, CRC(ae71dd7f) SHA1(a12da9329e28a4a8e3c902f795059251311d2856) )
+
+ ROM_REGION(0x2000, "graphics", 0)
+ ROM_LOAD( "1800000-016a_a17_85ae.bin", 0x000000, 0x001000, CRC(835445b7) SHA1(dde94fb6531dadce48e19bf551f45f61bedf905b) )
+
+ ROM_REGION(0x1000, "keyboard", 0)
+ ROM_LOAD( "1800000-019b_bell_a2_43d6.bin", 0x000000, 0x000800, CRC(de954a77) SHA1(c4f7c19799c15d12d89f08dc31064fc6be9befb0) )
+ROM_END
+
+/* Driver */
+/* YEAR NAME PARENT COMPAT MACHINE INPUT STATE INIT COMPANY FULLNAME FLAGS */
+COMP( 1981, tv910, 0, 0, tv910, tv910, driver_device, 0, "TeleVideo", "TV910", MACHINE_NOT_WORKING | MACHINE_NO_SOUND )
diff --git a/src/mame/drivers/vis.cpp b/src/mame/drivers/vis.cpp
index cc965a53def..d94fe9334c6 100644
--- a/src/mame/drivers/vis.cpp
+++ b/src/mame/drivers/vis.cpp
@@ -9,6 +9,7 @@
#include "sound/volt_reg.h"
#include "video/pc_vga.h"
#include "bus/isa/isa_cards.h"
+#include "machine/8042kbdc.h"
class vis_audio_device : public device_t,
public device_isa16_card_interface
@@ -596,10 +597,16 @@ ADDRESS_MAP_END
static ADDRESS_MAP_START( at16_io, AS_IO, 16, vis_state )
ADDRESS_MAP_UNMAP_HIGH
+ AM_RANGE(0x0000, 0x001f) AM_DEVREADWRITE8("mb:dma8237_1", am9517a_device, read, write, 0xffff)
AM_RANGE(0x0026, 0x0027) AM_READWRITE8(unk_r, unk_w, 0xffff)
+ AM_RANGE(0x0020, 0x003f) AM_DEVREADWRITE8("mb:pic8259_master", pic8259_device, read, write, 0xffff)
+ AM_RANGE(0x0040, 0x005f) AM_DEVREADWRITE8("mb:pit8254", pit8254_device, read, write, 0xffff)
+ AM_RANGE(0x0060, 0x0065) AM_DEVREADWRITE8("kbdc", kbdc8042_device, data_r, data_w, 0xffff)
AM_RANGE(0x006a, 0x006b) AM_READ8(unk2_r, 0x00ff)
AM_RANGE(0x0092, 0x0093) AM_READWRITE8(sysctl_r, sysctl_w, 0x00ff)
- AM_RANGE(0x0000, 0x00ff) AM_DEVICE("mb", at_mb_device, map)
+ AM_RANGE(0x0080, 0x009f) AM_DEVREADWRITE8("mb", at_mb_device, page8_r, page8_w, 0xffff)
+ AM_RANGE(0x00a0, 0x00bf) AM_DEVREADWRITE8("mb:pic8259_slave", pic8259_device, read, write, 0xffff)
+ AM_RANGE(0x00c0, 0x00df) AM_DEVREADWRITE8("mb:dma8237_2", am9517a_device, read, write, 0x00ff)
AM_RANGE(0x023c, 0x023f) AM_READWRITE8(pad_r, pad_w, 0xffff)
AM_RANGE(0x031a, 0x031b) AM_READ8(unk3_r, 0x00ff)
ADDRESS_MAP_END
@@ -609,6 +616,10 @@ static SLOT_INTERFACE_START(vis_cards)
SLOT_INTERFACE("visvga", VIS_VGA)
SLOT_INTERFACE_END
+static INPUT_PORTS_START(vis)
+ PORT_INCLUDE( at_keyboard )
+INPUT_PORTS_END
+
static MACHINE_CONFIG_START( vis, vis_state )
/* basic machine hardware */
MCFG_CPU_ADD("maincpu", I80286, XTAL_12MHz )
@@ -618,6 +629,15 @@ static MACHINE_CONFIG_START( vis, vis_state )
MCFG_80286_SHUTDOWN(DEVWRITELINE("mb", at_mb_device, shutdown))
MCFG_DEVICE_ADD("mb", AT_MB, 0)
+ // this doesn't have a real keyboard controller
+ MCFG_DEVICE_REMOVE("mb:keybc")
+ MCFG_DEVICE_REMOVE("mb:pc_kbdc")
+
+ MCFG_DEVICE_ADD("kbdc", KBDC8042, 0)
+ MCFG_KBDC8042_KEYBOARD_TYPE(KBDC8042_AT386)
+ MCFG_KBDC8042_SYSTEM_RESET_CB(INPUTLINE("maincpu", INPUT_LINE_RESET))
+ MCFG_KBDC8042_GATE_A20_CB(INPUTLINE("maincpu", INPUT_LINE_A20))
+ MCFG_KBDC8042_INPUT_BUFFER_FULL_CB(DEVWRITELINE("mb:pic8259_master", pic8259_device, ir1_w))
MCFG_ISA16_SLOT_ADD("mb:isabus", "mcd", pc_isa16_cards, "mcd", true)
MCFG_ISA16_SLOT_ADD("mb:isabus", "visaudio", vis_cards, "visaudio", true)
@@ -630,5 +650,5 @@ ROM_START(vis)
ROM_LOAD( "p513bk1b.bin", 0x80000, 0x80000, CRC(e18239c4) SHA1(a0262109e10a07a11eca43371be9978fff060bc5))
ROM_END
-COMP ( 1992, vis, 0, 0, vis, 0, driver_device, 0, "Tandy/Memorex", "Video Information System MD-2500", MACHINE_NOT_WORKING )
+COMP ( 1992, vis, 0, 0, vis, vis, driver_device, 0, "Tandy/Memorex", "Video Information System MD-2500", MACHINE_NOT_WORKING )
diff --git a/src/mame/mame.lst b/src/mame/mame.lst
index f4fcb4bbc10..6f6c7a0e716 100644
--- a/src/mame/mame.lst
+++ b/src/mame/mame.lst
@@ -36036,6 +36036,9 @@ pyuuta // 1982 Tomy Pyuuta
pyuutajr // 1982 Tomy Pyuuta Jr.
tutor // 1983? Tomy Tutor
+@source:tv910.cpp
+tv910 //
+
@source:tv950.cpp
tv950 //
diff --git a/src/mame/mess.flt b/src/mame/mess.flt
index 5c7420e6625..e2e9a8511db 100644
--- a/src/mame/mess.flt
+++ b/src/mame/mess.flt
@@ -630,6 +630,7 @@ ts803.cpp
ts816.cpp
tsispch.cpp
tutor.cpp
+tv910.cpp
tv950.cpp
tv990.cpp
tvc.cpp
diff --git a/src/osd/modules/sound/xaudio2_sound.cpp b/src/osd/modules/sound/xaudio2_sound.cpp
index 61c05a91eb0..da5907cc462 100644
--- a/src/osd/modules/sound/xaudio2_sound.cpp
+++ b/src/osd/modules/sound/xaudio2_sound.cpp
@@ -9,7 +9,7 @@
#include "sound_module.h"
#include "modules/osdmodule.h"
-#if defined(OSD_WINDOWS)
+#if defined(OSD_WINDOWS) || defined(OSD_UWP)
// standard windows headers
#define WIN32_LEAN_AND_MEAN