diff --git a/src/devices/cpu/i386/i386.cpp b/src/devices/cpu/i386/i386.cpp
index e6bd927d7de..46daedf256d 100644
--- a/src/devices/cpu/i386/i386.cpp
+++ b/src/devices/cpu/i386/i386.cpp
@@ -3993,7 +3993,11 @@ bool i386_device::memory_translate(address_spacenum spacenum, int intention, off
 
 offs_t i386_device::disasm_disassemble(char *buffer, offs_t pc, const uint8_t *oprom, const uint8_t *opram, uint32_t options)
 {
-	return i386_dasm_one(buffer, pc, oprom, m_sreg[CS].d ? 32 : 16);
+	std::ostringstream stream;
+	offs_t result = i386_dasm_one(stream, pc, oprom, m_sreg[CS].d ? 32 : 16);
+	std::string stream_str = stream.str();
+	strcpy(buffer, stream_str.c_str());
+	return result;
 }
 
 
diff --git a/src/devices/cpu/i386/i386dasm.cpp b/src/devices/cpu/i386/i386dasm.cpp
index 5f5d58fcb07..e25819437f5 100644
--- a/src/devices/cpu/i386/i386dasm.cpp
+++ b/src/devices/cpu/i386/i386dasm.cpp
@@ -1984,7 +1984,7 @@ static uint64_t pc;
 static uint8_t modrm;
 static uint32_t segment;
 static offs_t dasm_flags;
-static char modrm_string[256];
+static std::string modrm_string;
 static uint8_t rex, regex, sibex, rmex;
 static uint8_t pre0f;
 static uint8_t curmode;
@@ -2097,7 +2097,7 @@ static char *shexstring(uint32_t value, int digits, bool always)
 	return buffer;
 }
 
-static char* handle_sib_byte( char* s, uint8_t mod )
+static void handle_sib_byte(std::ostream &stream, uint8_t mod)
 {
 	uint32_t i32;
 	uint8_t scale, i, base;
@@ -2109,19 +2109,18 @@ static char* handle_sib_byte( char* s, uint8_t mod )
 
 	if (base == 5 && mod == 0) {
 		i32 = FETCH32();
-		s += sprintf( s, "%s", hexstring(i32, 0) );
+		util::stream_format(stream, "%s", hexstring(i32, 0));
 	} else if (base != 5 || mod != 3)
-		s += sprintf( s, "%s", i386_reg[address_size][base] );
+		util::stream_format(stream, "%s", i386_reg[address_size][base]);
 
 	if ( i != 4 ) {
-		s += sprintf( s, "+%s", i386_reg[address_size][i] );
+		util::stream_format(stream, "+%s", i386_reg[address_size][i]);
 		if (scale)
-			s += sprintf( s, "*%d", 1 << scale );
+			util::stream_format(stream, "*%d", 1 << scale);
 	}
-	return s;
 }
 
-static void handle_modrm(char* s)
+static void handle_modrm(std::ostream &stream)
 {
 	int8_t disp8;
 	int16_t disp16;
@@ -2137,85 +2136,92 @@ static void handle_modrm(char* s)
 
 	switch(segment)
 	{
-		case SEG_CS: s += sprintf( s, "cs:" ); break;
-		case SEG_DS: s += sprintf( s, "ds:" ); break;
-		case SEG_ES: s += sprintf( s, "es:" ); break;
-		case SEG_FS: s += sprintf( s, "fs:" ); break;
-		case SEG_GS: s += sprintf( s, "gs:" ); break;
-		case SEG_SS: s += sprintf( s, "ss:" ); break;
+		case SEG_CS: util::stream_format(stream, "cs:"); break;
+		case SEG_DS: util::stream_format(stream, "ds:"); break;
+		case SEG_ES: util::stream_format(stream, "es:"); break;
+		case SEG_FS: util::stream_format(stream, "fs:"); break;
+		case SEG_GS: util::stream_format(stream, "gs:"); break;
+		case SEG_SS: util::stream_format(stream, "ss:"); break;
 	}
 
-	s += sprintf( s, "[" );
+	util::stream_format(stream, "[" );
 	if( address_size == 2 ) {
 		if ((rm & 7) == 4)
-			s = handle_sib_byte( s, mod );
+			handle_sib_byte(stream, mod );
 		else if ((rm & 7) == 5 && mod == 0) {
 			disp32 = FETCHD32();
-			s += sprintf( s, "rip%s", shexstring(disp32, 0, true) );
+			util::stream_format(stream, "rip%s", shexstring(disp32, 0, true));
 		} else
-			s += sprintf( s, "%s", i386_reg[2][rm]);
+			util::stream_format(stream, "%s", i386_reg[2][rm]);
 		if( mod == 1 ) {
 			disp8 = FETCHD();
 			if (disp8 != 0)
-				s += sprintf( s, "%s", shexstring((int32_t)disp8, 0, true) );
+				util::stream_format(stream, "%s", shexstring((int32_t)disp8, 0, true) );
 		} else if( mod == 2 ) {
 			disp32 = FETCHD32();
 			if (disp32 != 0)
-				s += sprintf( s, "%s", shexstring(disp32, 0, true) );
+				util::stream_format(stream, "%s", shexstring(disp32, 0, true) );
 		}
 	} else if (address_size == 1) {
 		if ((rm & 7) == 4)
-			s = handle_sib_byte( s, mod );
+			handle_sib_byte(stream, mod );
 		else if ((rm & 7) == 5 && mod == 0) {
 			disp32 = FETCHD32();
 			if (curmode == 64)
-				s += sprintf( s, "eip%s", shexstring(disp32, 0, true) );
+				util::stream_format(stream, "eip%s", shexstring(disp32, 0, true) );
 			else
-				s += sprintf( s, "%s", hexstring(disp32, 0) );
+				util::stream_format(stream, "%s", hexstring(disp32, 0) );
 		} else
-			s += sprintf( s, "%s", i386_reg[1][rm]);
+			util::stream_format(stream, "%s", i386_reg[1][rm]);
 		if( mod == 1 ) {
 			disp8 = FETCHD();
 			if (disp8 != 0)
-				s += sprintf( s, "%s", shexstring((int32_t)disp8, 0, true) );
+				util::stream_format(stream, "%s", shexstring((int32_t)disp8, 0, true) );
 		} else if( mod == 2 ) {
 			disp32 = FETCHD32();
 			if (disp32 != 0)
-				s += sprintf( s, "%s", shexstring(disp32, 0, true) );
+				util::stream_format(stream, "%s", shexstring(disp32, 0, true) );
 		}
 	} else {
 		switch( rm )
 		{
-			case 0: s += sprintf( s, "bx+si" ); break;
-			case 1: s += sprintf( s, "bx+di" ); break;
-			case 2: s += sprintf( s, "bp+si" ); break;
-			case 3: s += sprintf( s, "bp+di" ); break;
-			case 4: s += sprintf( s, "si" ); break;
-			case 5: s += sprintf( s, "di" ); break;
+			case 0: util::stream_format(stream, "bx+si" ); break;
+			case 1: util::stream_format(stream, "bx+di" ); break;
+			case 2: util::stream_format(stream, "bp+si" ); break;
+			case 3: util::stream_format(stream, "bp+di" ); break;
+			case 4: util::stream_format(stream, "si" ); break;
+			case 5: util::stream_format(stream, "di" ); break;
 			case 6:
 				if( mod == 0 ) {
 					disp16 = FETCHD16();
-					s += sprintf( s, "%s", hexstring((unsigned) (uint16_t) disp16, 0) );
+					util::stream_format(stream, "%s", hexstring((unsigned) (uint16_t) disp16, 0) );
 				} else {
-					s += sprintf( s, "bp" );
+					util::stream_format(stream, "bp" );
 				}
 				break;
-			case 7: s += sprintf( s, "bx" ); break;
+			case 7: util::stream_format(stream, "bx" ); break;
 		}
 		if( mod == 1 ) {
 			disp8 = FETCHD();
 			if (disp8 != 0)
-				s += sprintf( s, "%s", shexstring((int32_t)disp8, 0, true) );
+				util::stream_format(stream, "%s", shexstring((int32_t)disp8, 0, true) );
 		} else if( mod == 2 ) {
 			disp16 = FETCHD16();
 			if (disp16 != 0)
-				s += sprintf( s, "%s", shexstring((int32_t)disp16, 0, true) );
+				util::stream_format(stream, "%s", shexstring((int32_t)disp16, 0, true) );
 		}
 	}
-	s += sprintf( s, "]" );
+	util::stream_format(stream, "]" );
 }
 
-static char* handle_param(char* s, uint32_t param)
+static void handle_modrm(std::string &buffer)
+{
+	std::stringstream stream;
+	handle_modrm(stream);
+	buffer = stream.str();
+}
+
+static void handle_param(std::ostream &stream, uint32_t param)
 {
 	uint8_t i8;
 	uint16_t i16;
@@ -2229,194 +2235,194 @@ static char* handle_param(char* s, uint32_t param)
 	switch(param)
 	{
 		case PARAM_REG:
-			s += sprintf( s, "%s", i386_reg[operand_size][MODRM_REG1 | regex] );
+			util::stream_format(stream, "%s", i386_reg[operand_size][MODRM_REG1 | regex] );
 			break;
 
 		case PARAM_REG8:
-			s += sprintf( s, "%s", (rex ? i386_reg8rex : i386_reg8)[MODRM_REG1 | regex] );
+			util::stream_format(stream, "%s", (rex ? i386_reg8rex : i386_reg8)[MODRM_REG1 | regex] );
 			break;
 
 		case PARAM_REG16:
-			s += sprintf( s, "%s", i386_reg[0][MODRM_REG1 | regex] );
+			util::stream_format(stream, "%s", i386_reg[0][MODRM_REG1 | regex] );
 			break;
 
 		case PARAM_REG32:
-			s += sprintf( s, "%s", i386_reg[1][MODRM_REG1 | regex] );
+			util::stream_format(stream, "%s", i386_reg[1][MODRM_REG1 | regex] );
 			break;
 
 		case PARAM_REG3264:
-			s += sprintf( s, "%s", i386_reg[(operand_size == 2) ? 2 : 1][MODRM_REG1 | regex] );
+			util::stream_format(stream, "%s", i386_reg[(operand_size == 2) ? 2 : 1][MODRM_REG1 | regex] );
 			break;
 
 		case PARAM_MMX:
 			if (pre0f == 0x66 || pre0f == 0xf2 || pre0f == 0xf3)
-				s += sprintf( s, "xmm%d", MODRM_REG1 | regex );
+				util::stream_format(stream, "xmm%d", MODRM_REG1 | regex );
 			else
-				s += sprintf( s, "mm%d", MODRM_REG1 | regex );
+				util::stream_format(stream, "mm%d", MODRM_REG1 | regex );
 			break;
 
 		case PARAM_MMX2:
 			if (pre0f == 0x66 || pre0f == 0xf2 || pre0f == 0xf3)
-				s += sprintf( s, "xmm%d", MODRM_REG2 | regex );
+				util::stream_format(stream, "xmm%d", MODRM_REG2 | regex );
 			else
-				s += sprintf( s, "mm%d", MODRM_REG2 | regex );
+				util::stream_format(stream, "mm%d", MODRM_REG2 | regex );
 			break;
 
 		case PARAM_XMM:
-			s += sprintf( s, "xmm%d", MODRM_REG1 | regex );
+			util::stream_format(stream, "xmm%d", MODRM_REG1 | regex );
 			break;
 
 		case PARAM_REGORXMM:
 			if (pre0f != 0xf2 && pre0f != 0xf3)
-				s += sprintf( s, "xmm%d", MODRM_REG1 | regex );
+				util::stream_format(stream, "xmm%d", MODRM_REG1 | regex );
 			else
-				s += sprintf( s, "%s", i386_reg[(operand_size == 2) ? 2 : 1][MODRM_REG1 | regex] );
+				util::stream_format(stream, "%s", i386_reg[(operand_size == 2) ? 2 : 1][MODRM_REG1 | regex] );
 			break;
 
 		case PARAM_REG2_32:
-			s += sprintf( s, "%s", i386_reg[1][MODRM_REG2 | rmex] );
+			util::stream_format(stream, "%s", i386_reg[1][MODRM_REG2 | rmex] );
 			break;
 
 		case PARAM_RM:
 		case PARAM_RMPTR:
 			if( modrm >= 0xc0 ) {
-				s += sprintf( s, "%s", i386_reg[operand_size][MODRM_REG2 | rmex] );
+				util::stream_format(stream, "%s", i386_reg[operand_size][MODRM_REG2 | rmex] );
 			} else {
 				if (param == PARAM_RMPTR)
 				{
 					if( operand_size == 2 )
-						s += sprintf( s, "qword ptr " );
+						util::stream_format(stream, "qword ptr " );
 					else if (operand_size == 1)
-						s += sprintf( s, "dword ptr " );
+						util::stream_format(stream, "dword ptr " );
 					else
-						s += sprintf( s, "word ptr " );
+						util::stream_format(stream, "word ptr " );
 				}
-				s += sprintf( s, "%s", modrm_string );
+				util::stream_format(stream, "%s", modrm_string );
 			}
 			break;
 
 		case PARAM_RM8:
 		case PARAM_RMPTR8:
 			if( modrm >= 0xc0 ) {
-				s += sprintf( s, "%s", (rex ? i386_reg8rex : i386_reg8)[MODRM_REG2 | rmex] );
+				util::stream_format(stream, "%s", (rex ? i386_reg8rex : i386_reg8)[MODRM_REG2 | rmex] );
 			} else {
 				if (param == PARAM_RMPTR8)
-					s += sprintf( s, "byte ptr " );
-				s += sprintf( s, "%s", modrm_string );
+					util::stream_format(stream, "byte ptr " );
+				util::stream_format(stream, "%s", modrm_string );
 			}
 			break;
 
 		case PARAM_RM16:
 		case PARAM_RMPTR16:
 			if( modrm >= 0xc0 ) {
-				s += sprintf( s, "%s", i386_reg[0][MODRM_REG2 | rmex] );
+				util::stream_format(stream, "%s", i386_reg[0][MODRM_REG2 | rmex] );
 			} else {
 				if (param == PARAM_RMPTR16)
-					s += sprintf( s, "word ptr " );
-				s += sprintf( s, "%s", modrm_string );
+					util::stream_format(stream, "word ptr " );
+				util::stream_format(stream, "%s", modrm_string );
 			}
 			break;
 
 		case PARAM_RM32:
 		case PARAM_RMPTR32:
 			if( modrm >= 0xc0 ) {
-				s += sprintf( s, "%s", i386_reg[1][MODRM_REG2 | rmex] );
+				util::stream_format(stream, "%s", i386_reg[1][MODRM_REG2 | rmex] );
 			} else {
 				if (param == PARAM_RMPTR32)
-					s += sprintf( s, "dword ptr " );
-				s += sprintf( s, "%s", modrm_string );
+					util::stream_format(stream, "dword ptr " );
+				util::stream_format(stream, "%s", modrm_string );
 			}
 			break;
 
 		case PARAM_RMXMM:
 			if( modrm >= 0xc0 ) {
 				if (pre0f != 0xf2 && pre0f != 0xf3)
-					s += sprintf( s, "xmm%d", MODRM_REG2 | rmex );
+					util::stream_format(stream, "xmm%d", MODRM_REG2 | rmex );
 				else
-					s += sprintf( s, "%s", i386_reg[(operand_size == 2) ? 2 : 1][MODRM_REG2 | rmex] );
+					util::stream_format(stream, "%s", i386_reg[(operand_size == 2) ? 2 : 1][MODRM_REG2 | rmex] );
 			} else {
 				if (param == PARAM_RMPTR32)
-					s += sprintf( s, "dword ptr " );
-				s += sprintf( s, "%s", modrm_string );
+					util::stream_format(stream, "dword ptr " );
+				util::stream_format(stream, "%s", modrm_string );
 			}
 			break;
 
 		case PARAM_M64:
 		case PARAM_M64PTR:
 			if( modrm >= 0xc0 ) {
-				s += sprintf( s, "???" );
+				util::stream_format(stream, "???" );
 			} else {
 				if (param == PARAM_M64PTR)
-					s += sprintf( s, "qword ptr " );
-				s += sprintf( s, "%s", modrm_string );
+					util::stream_format(stream, "qword ptr " );
+				util::stream_format(stream, "%s", modrm_string );
 			}
 			break;
 
 		case PARAM_MMXM:
 			if( modrm >= 0xc0 ) {
 				if (pre0f == 0x66 || pre0f == 0xf2 || pre0f == 0xf3)
-					s += sprintf( s, "xmm%d", MODRM_REG2 | rmex );
+					util::stream_format(stream, "xmm%d", MODRM_REG2 | rmex );
 				else
-					s += sprintf( s, "mm%d", MODRM_REG2 | rmex );
+					util::stream_format(stream, "mm%d", MODRM_REG2 | rmex );
 			} else {
-				s += sprintf( s, "%s", modrm_string );
+				util::stream_format(stream, "%s", modrm_string );
 			}
 			break;
 
 		case PARAM_XMMM:
 			if( modrm >= 0xc0 ) {
-				s += sprintf( s, "xmm%d", MODRM_REG2 | rmex );
+				util::stream_format(stream, "xmm%d", MODRM_REG2 | rmex );
 			} else {
-				s += sprintf( s, "%s", modrm_string );
+				util::stream_format(stream, "%s", modrm_string );
 			}
 			break;
 
 		case PARAM_I4:
 			i8 = FETCHD();
-			s += sprintf( s, "%d", i8 & 0x0f );
+			util::stream_format(stream, "%d", i8 & 0x0f );
 			break;
 
 		case PARAM_I8:
 			i8 = FETCHD();
-			s += sprintf( s, "%s", shexstring((int8_t)i8, 0, false) );
+			util::stream_format(stream, "%s", shexstring((int8_t)i8, 0, false) );
 			break;
 
 		case PARAM_I16:
 			i16 = FETCHD16();
-			s += sprintf( s, "%s", shexstring((int16_t)i16, 0, false) );
+			util::stream_format(stream, "%s", shexstring((int16_t)i16, 0, false) );
 			break;
 
 		case PARAM_UI8:
 			i8 = FETCHD();
-			s += sprintf( s, "%s", shexstring((uint8_t)i8, 0, false) );
+			util::stream_format(stream, "%s", shexstring((uint8_t)i8, 0, false) );
 			break;
 
 		case PARAM_UI16:
 			i16 = FETCHD16();
-			s += sprintf( s, "%s", shexstring((uint16_t)i16, 0, false) );
+			util::stream_format(stream, "%s", shexstring((uint16_t)i16, 0, false) );
 			break;
 
 		case PARAM_IMM64:
 			if (operand_size == 2) {
 				uint32_t lo32 = FETCHD32();
 				i32 = FETCHD32();
-				s += sprintf( s, "%s", hexstring64(lo32, i32) );
+				util::stream_format(stream, "%s", hexstring64(lo32, i32) );
 			} else if( operand_size ) {
 				i32 = FETCHD32();
-				s += sprintf( s, "%s", hexstring(i32, 0) );
+				util::stream_format(stream, "%s", hexstring(i32, 0) );
 			} else {
 				i16 = FETCHD16();
-				s += sprintf( s, "%s", hexstring(i16, 0) );
+				util::stream_format(stream, "%s", hexstring(i16, 0) );
 			}
 			break;
 
 		case PARAM_IMM:
 			if( operand_size ) {
 				i32 = FETCHD32();
-				s += sprintf( s, "%s", hexstring(i32, 0) );
+				util::stream_format(stream, "%s", hexstring(i32, 0) );
 			} else {
 				i16 = FETCHD16();
-				s += sprintf( s, "%s", hexstring(i16, 0) );
+				util::stream_format(stream, "%s", hexstring(i16, 0) );
 			}
 			break;
 
@@ -2424,114 +2430,113 @@ static char* handle_param(char* s, uint32_t param)
 			if( operand_size ) {
 				addr = FETCHD32();
 				ptr = FETCHD16();
-				s += sprintf( s, "%s:", hexstring(ptr, 4) );
-				s += sprintf( s, "%s", hexstring(addr, 0) );
+				util::stream_format(stream, "%s:", hexstring(ptr, 4) );
+				util::stream_format(stream, "%s", hexstring(addr, 0) );
 			} else {
 				addr = FETCHD16();
 				ptr = FETCHD16();
-				s += sprintf( s, "%s:", hexstring(ptr, 4) );
-				s += sprintf( s, "%s", hexstring(addr, 0) );
+				util::stream_format(stream, "%s:", hexstring(ptr, 4) );
+				util::stream_format(stream, "%s", hexstring(addr, 0) );
 			}
 			break;
 
 		case PARAM_REL:
 			if( operand_size ) {
 				d32 = FETCHD32();
-				s += sprintf( s, "%s", hexstringpc(pc + d32) );
+				util::stream_format(stream, "%s", hexstringpc(pc + d32) );
 			} else {
 				/* make sure to keep the relative offset within the segment */
 				d16 = FETCHD16();
-				s += sprintf( s, "%s", hexstringpc((pc & 0xFFFF0000) | ((pc + d16) & 0x0000FFFF)) );
+				util::stream_format(stream, "%s", hexstringpc((pc & 0xFFFF0000) | ((pc + d16) & 0x0000FFFF)) );
 			}
 			break;
 
 		case PARAM_REL8:
 			d8 = FETCHD();
-			s += sprintf( s, "%s", hexstringpc(pc + d8) );
+			util::stream_format(stream, "%s", hexstringpc(pc + d8) );
 			break;
 
 		case PARAM_MEM_OFFS:
 			switch(segment)
 			{
-				case SEG_CS: s += sprintf( s, "cs:" ); break;
-				case SEG_DS: s += sprintf( s, "ds:" ); break;
-				case SEG_ES: s += sprintf( s, "es:" ); break;
-				case SEG_FS: s += sprintf( s, "fs:" ); break;
-				case SEG_GS: s += sprintf( s, "gs:" ); break;
-				case SEG_SS: s += sprintf( s, "ss:" ); break;
+				case SEG_CS: util::stream_format(stream, "cs:" ); break;
+				case SEG_DS: util::stream_format(stream, "ds:" ); break;
+				case SEG_ES: util::stream_format(stream, "es:" ); break;
+				case SEG_FS: util::stream_format(stream, "fs:" ); break;
+				case SEG_GS: util::stream_format(stream, "gs:" ); break;
+				case SEG_SS: util::stream_format(stream, "ss:" ); break;
 			}
 
 			if( address_size ) {
 				i32 = FETCHD32();
-				s += sprintf( s, "[%s]", hexstring(i32, 0) );
+				util::stream_format(stream, "[%s]", hexstring(i32, 0) );
 			} else {
 				i16 = FETCHD16();
-				s += sprintf( s, "[%s]", hexstring(i16, 0) );
+				util::stream_format(stream, "[%s]", hexstring(i16, 0) );
 			}
 			break;
 
 		case PARAM_PREIMP:
 			switch(segment)
 			{
-				case SEG_CS: s += sprintf( s, "cs:" ); break;
-				case SEG_DS: s += sprintf( s, "ds:" ); break;
-				case SEG_ES: s += sprintf( s, "es:" ); break;
-				case SEG_FS: s += sprintf( s, "fs:" ); break;
-				case SEG_GS: s += sprintf( s, "gs:" ); break;
-				case SEG_SS: s += sprintf( s, "ss:" ); break;
+				case SEG_CS: util::stream_format(stream, "cs:" ); break;
+				case SEG_DS: util::stream_format(stream, "ds:" ); break;
+				case SEG_ES: util::stream_format(stream, "es:" ); break;
+				case SEG_FS: util::stream_format(stream, "fs:" ); break;
+				case SEG_GS: util::stream_format(stream, "gs:" ); break;
+				case SEG_SS: util::stream_format(stream, "ss:" ); break;
 			}
 			break;
 
 		case PARAM_SREG:
-			s += sprintf( s, "%s", i386_sreg[MODRM_REG1] );
+			util::stream_format(stream, "%s", i386_sreg[MODRM_REG1] );
 			break;
 
 		case PARAM_CREG:
-			s += sprintf( s, "cr%d", MODRM_REG1 | regex );
+			util::stream_format(stream, "cr%d", MODRM_REG1 | regex );
 			break;
 
 		case PARAM_TREG:
-			s += sprintf( s, "tr%d", MODRM_REG1 | regex );
+			util::stream_format(stream, "tr%d", MODRM_REG1 | regex );
 			break;
 
 		case PARAM_DREG:
-			s += sprintf( s, "dr%d", MODRM_REG1 | regex );
+			util::stream_format(stream, "dr%d", MODRM_REG1 | regex );
 			break;
 
 		case PARAM_1:
-			s += sprintf( s, "1" );
+			util::stream_format(stream, "1" );
 			break;
 
 		case PARAM_DX:
-			s += sprintf( s, "dx" );
+			util::stream_format(stream, "dx" );
 			break;
 
 		case PARAM_XMM0:
-			s += sprintf( s, "xmm0" );
+			util::stream_format(stream, "xmm0" );
 			break;
 
-		case PARAM_AL: s += sprintf( s, "al" ); break;
-		case PARAM_CL: s += sprintf( s, "cl" ); break;
-		case PARAM_DL: s += sprintf( s, "dl" ); break;
-		case PARAM_BL: s += sprintf( s, "bl" ); break;
-		case PARAM_AH: s += sprintf( s, "ah" ); break;
-		case PARAM_CH: s += sprintf( s, "ch" ); break;
-		case PARAM_DH: s += sprintf( s, "dh" ); break;
-		case PARAM_BH: s += sprintf( s, "bh" ); break;
+		case PARAM_AL: util::stream_format(stream, "al" ); break;
+		case PARAM_CL: util::stream_format(stream, "cl" ); break;
+		case PARAM_DL: util::stream_format(stream, "dl" ); break;
+		case PARAM_BL: util::stream_format(stream, "bl" ); break;
+		case PARAM_AH: util::stream_format(stream, "ah" ); break;
+		case PARAM_CH: util::stream_format(stream, "ch" ); break;
+		case PARAM_DH: util::stream_format(stream, "dh" ); break;
+		case PARAM_BH: util::stream_format(stream, "bh" ); break;
 
-		case PARAM_EAX: s += sprintf( s, "%s", i386_reg[operand_size][0 | rmex] ); break;
-		case PARAM_ECX: s += sprintf( s, "%s", i386_reg[operand_size][1 | rmex] ); break;
-		case PARAM_EDX: s += sprintf( s, "%s", i386_reg[operand_size][2 | rmex] ); break;
-		case PARAM_EBX: s += sprintf( s, "%s", i386_reg[operand_size][3 | rmex] ); break;
-		case PARAM_ESP: s += sprintf( s, "%s", i386_reg[operand_size][4 | rmex] ); break;
-		case PARAM_EBP: s += sprintf( s, "%s", i386_reg[operand_size][5 | rmex] ); break;
-		case PARAM_ESI: s += sprintf( s, "%s", i386_reg[operand_size][6 | rmex] ); break;
-		case PARAM_EDI: s += sprintf( s, "%s", i386_reg[operand_size][7 | rmex] ); break;
+		case PARAM_EAX: util::stream_format(stream, "%s", i386_reg[operand_size][0 | rmex] ); break;
+		case PARAM_ECX: util::stream_format(stream, "%s", i386_reg[operand_size][1 | rmex] ); break;
+		case PARAM_EDX: util::stream_format(stream, "%s", i386_reg[operand_size][2 | rmex] ); break;
+		case PARAM_EBX: util::stream_format(stream, "%s", i386_reg[operand_size][3 | rmex] ); break;
+		case PARAM_ESP: util::stream_format(stream, "%s", i386_reg[operand_size][4 | rmex] ); break;
+		case PARAM_EBP: util::stream_format(stream, "%s", i386_reg[operand_size][5 | rmex] ); break;
+		case PARAM_ESI: util::stream_format(stream, "%s", i386_reg[operand_size][6 | rmex] ); break;
+		case PARAM_EDI: util::stream_format(stream, "%s", i386_reg[operand_size][7 | rmex] ); break;
 	}
-	return s;
 }
 
-static void handle_fpu(char *s, uint8_t op1, uint8_t op2)
+static void handle_fpu(std::ostream &stream, uint8_t op1, uint8_t op2)
 {
 	switch (op1 & 0x7)
 	{
@@ -2544,28 +2549,28 @@ static void handle_fpu(char *s, uint8_t op1, uint8_t op2)
 				handle_modrm( modrm_string );
 				switch ((op2 >> 3) & 0x7)
 				{
-					case 0: sprintf(s, "fadd    dword ptr %s", modrm_string); break;
-					case 1: sprintf(s, "fmul    dword ptr %s", modrm_string); break;
-					case 2: sprintf(s, "fcom    dword ptr %s", modrm_string); break;
-					case 3: sprintf(s, "fcomp   dword ptr %s", modrm_string); break;
-					case 4: sprintf(s, "fsub    dword ptr %s", modrm_string); break;
-					case 5: sprintf(s, "fsubr   dword ptr %s", modrm_string); break;
-					case 6: sprintf(s, "fdiv    dword ptr %s", modrm_string); break;
-					case 7: sprintf(s, "fdivr   dword ptr %s", modrm_string); break;
+					case 0: util::stream_format(stream, "fadd    dword ptr %s", modrm_string); break;
+					case 1: util::stream_format(stream, "fmul    dword ptr %s", modrm_string); break;
+					case 2: util::stream_format(stream, "fcom    dword ptr %s", modrm_string); break;
+					case 3: util::stream_format(stream, "fcomp   dword ptr %s", modrm_string); break;
+					case 4: util::stream_format(stream, "fsub    dword ptr %s", modrm_string); break;
+					case 5: util::stream_format(stream, "fsubr   dword ptr %s", modrm_string); break;
+					case 6: util::stream_format(stream, "fdiv    dword ptr %s", modrm_string); break;
+					case 7: util::stream_format(stream, "fdivr   dword ptr %s", modrm_string); break;
 				}
 			}
 			else
 			{
 				switch ((op2 >> 3) & 0x7)
 				{
-					case 0: sprintf(s, "fadd    st(0),st(%d)", op2 & 0x7); break;
-					case 1: sprintf(s, "fmul    st(0),st(%d)", op2 & 0x7); break;
-					case 2: sprintf(s, "fcom    st(0),st(%d)", op2 & 0x7); break;
-					case 3: sprintf(s, "fcomp   st(0),st(%d)", op2 & 0x7); break;
-					case 4: sprintf(s, "fsub    st(0),st(%d)", op2 & 0x7); break;
-					case 5: sprintf(s, "fsubr   st(0),st(%d)", op2 & 0x7); break;
-					case 6: sprintf(s, "fdiv    st(0),st(%d)", op2 & 0x7); break;
-					case 7: sprintf(s, "fdivr   st(0),st(%d)", op2 & 0x7); break;
+					case 0: util::stream_format(stream, "fadd    st(0),st(%d)", op2 & 0x7); break;
+					case 1: util::stream_format(stream, "fmul    st(0),st(%d)", op2 & 0x7); break;
+					case 2: util::stream_format(stream, "fcom    st(0),st(%d)", op2 & 0x7); break;
+					case 3: util::stream_format(stream, "fcomp   st(0),st(%d)", op2 & 0x7); break;
+					case 4: util::stream_format(stream, "fsub    st(0),st(%d)", op2 & 0x7); break;
+					case 5: util::stream_format(stream, "fsubr   st(0),st(%d)", op2 & 0x7); break;
+					case 6: util::stream_format(stream, "fdiv    st(0),st(%d)", op2 & 0x7); break;
+					case 7: util::stream_format(stream, "fdivr   st(0),st(%d)", op2 & 0x7); break;
 				}
 			}
 			break;
@@ -2580,14 +2585,14 @@ static void handle_fpu(char *s, uint8_t op1, uint8_t op2)
 				handle_modrm( modrm_string );
 				switch ((op2 >> 3) & 0x7)
 				{
-					case 0: sprintf(s, "fld     dword ptr %s", modrm_string); break;
-					case 1: sprintf(s, "??? (FPU)"); break;
-					case 2: sprintf(s, "fst     dword ptr %s", modrm_string); break;
-					case 3: sprintf(s, "fstp    dword ptr %s", modrm_string); break;
-					case 4: sprintf(s, "fldenv  word ptr %s", modrm_string); break;
-					case 5: sprintf(s, "fldcw   word ptr %s", modrm_string); break;
-					case 6: sprintf(s, "fstenv  word ptr %s", modrm_string); break;
-					case 7: sprintf(s, "fstcw   word ptr %s", modrm_string); break;
+					case 0: util::stream_format(stream, "fld     dword ptr %s", modrm_string); break;
+					case 1: util::stream_format(stream, "??? (FPU)"); break;
+					case 2: util::stream_format(stream, "fst     dword ptr %s", modrm_string); break;
+					case 3: util::stream_format(stream, "fstp    dword ptr %s", modrm_string); break;
+					case 4: util::stream_format(stream, "fldenv  word ptr %s", modrm_string); break;
+					case 5: util::stream_format(stream, "fldcw   word ptr %s", modrm_string); break;
+					case 6: util::stream_format(stream, "fstenv  word ptr %s", modrm_string); break;
+					case 7: util::stream_format(stream, "fstcw   word ptr %s", modrm_string); break;
 				}
 			}
 			else
@@ -2595,41 +2600,41 @@ static void handle_fpu(char *s, uint8_t op1, uint8_t op2)
 				switch (op2 & 0x3f)
 				{
 					case 0x00: case 0x01: case 0x02: case 0x03: case 0x04: case 0x05: case 0x06: case 0x07:
-						sprintf(s, "fld     st(0),st(%d)", op2 & 0x7); break;
+						util::stream_format(stream, "fld     st(0),st(%d)", op2 & 0x7); break;
 
 					case 0x08: case 0x09: case 0x0a: case 0x0b: case 0x0c: case 0x0d: case 0x0e: case 0x0f:
-						sprintf(s, "fxch    st(0),st(%d)", op2 & 0x7); break;
+						util::stream_format(stream, "fxch    st(0),st(%d)", op2 & 0x7); break;
 
-					case 0x10: sprintf(s, "fnop"); break;
-					case 0x20: sprintf(s, "fchs"); break;
-					case 0x21: sprintf(s, "fabs"); break;
-					case 0x24: sprintf(s, "ftst"); break;
-					case 0x25: sprintf(s, "fxam"); break;
-					case 0x28: sprintf(s, "fld1"); break;
-					case 0x29: sprintf(s, "fldl2t"); break;
-					case 0x2a: sprintf(s, "fldl2e"); break;
-					case 0x2b: sprintf(s, "fldpi"); break;
-					case 0x2c: sprintf(s, "fldlg2"); break;
-					case 0x2d: sprintf(s, "fldln2"); break;
-					case 0x2e: sprintf(s, "fldz"); break;
-					case 0x30: sprintf(s, "f2xm1"); break;
-					case 0x31: sprintf(s, "fyl2x"); break;
-					case 0x32: sprintf(s, "fptan"); break;
-					case 0x33: sprintf(s, "fpatan"); break;
-					case 0x34: sprintf(s, "fxtract"); break;
-					case 0x35: sprintf(s, "fprem1"); break;
-					case 0x36: sprintf(s, "fdecstp"); break;
-					case 0x37: sprintf(s, "fincstp"); break;
-					case 0x38: sprintf(s, "fprem"); break;
-					case 0x39: sprintf(s, "fyl2xp1"); break;
-					case 0x3a: sprintf(s, "fsqrt"); break;
-					case 0x3b: sprintf(s, "fsincos"); break;
-					case 0x3c: sprintf(s, "frndint"); break;
-					case 0x3d: sprintf(s, "fscale"); break;
-					case 0x3e: sprintf(s, "fsin"); break;
-					case 0x3f: sprintf(s, "fcos"); break;
+					case 0x10: util::stream_format(stream, "fnop"); break;
+					case 0x20: util::stream_format(stream, "fchs"); break;
+					case 0x21: util::stream_format(stream, "fabs"); break;
+					case 0x24: util::stream_format(stream, "ftst"); break;
+					case 0x25: util::stream_format(stream, "fxam"); break;
+					case 0x28: util::stream_format(stream, "fld1"); break;
+					case 0x29: util::stream_format(stream, "fldl2t"); break;
+					case 0x2a: util::stream_format(stream, "fldl2e"); break;
+					case 0x2b: util::stream_format(stream, "fldpi"); break;
+					case 0x2c: util::stream_format(stream, "fldlg2"); break;
+					case 0x2d: util::stream_format(stream, "fldln2"); break;
+					case 0x2e: util::stream_format(stream, "fldz"); break;
+					case 0x30: util::stream_format(stream, "f2xm1"); break;
+					case 0x31: util::stream_format(stream, "fyl2x"); break;
+					case 0x32: util::stream_format(stream, "fptan"); break;
+					case 0x33: util::stream_format(stream, "fpatan"); break;
+					case 0x34: util::stream_format(stream, "fxtract"); break;
+					case 0x35: util::stream_format(stream, "fprem1"); break;
+					case 0x36: util::stream_format(stream, "fdecstp"); break;
+					case 0x37: util::stream_format(stream, "fincstp"); break;
+					case 0x38: util::stream_format(stream, "fprem"); break;
+					case 0x39: util::stream_format(stream, "fyl2xp1"); break;
+					case 0x3a: util::stream_format(stream, "fsqrt"); break;
+					case 0x3b: util::stream_format(stream, "fsincos"); break;
+					case 0x3c: util::stream_format(stream, "frndint"); break;
+					case 0x3d: util::stream_format(stream, "fscale"); break;
+					case 0x3e: util::stream_format(stream, "fsin"); break;
+					case 0x3f: util::stream_format(stream, "fcos"); break;
 
-					default: sprintf(s, "??? (FPU)"); break;
+					default: util::stream_format(stream, "??? (FPU)"); break;
 				}
 			}
 			break;
@@ -2644,14 +2649,14 @@ static void handle_fpu(char *s, uint8_t op1, uint8_t op2)
 				handle_modrm( modrm_string );
 				switch ((op2 >> 3) & 0x7)
 				{
-					case 0: sprintf(s, "fiadd   dword ptr %s", modrm_string); break;
-					case 1: sprintf(s, "fimul   dword ptr %s", modrm_string); break;
-					case 2: sprintf(s, "ficom   dword ptr %s", modrm_string); break;
-					case 3: sprintf(s, "ficomp  dword ptr %s", modrm_string); break;
-					case 4: sprintf(s, "fisub   dword ptr %s", modrm_string); break;
-					case 5: sprintf(s, "fisubr  dword ptr %s", modrm_string); break;
-					case 6: sprintf(s, "fidiv   dword ptr %s", modrm_string); break;
-					case 7: sprintf(s, "fidivr  dword ptr %s", modrm_string); break;
+					case 0: util::stream_format(stream, "fiadd   dword ptr %s", modrm_string); break;
+					case 1: util::stream_format(stream, "fimul   dword ptr %s", modrm_string); break;
+					case 2: util::stream_format(stream, "ficom   dword ptr %s", modrm_string); break;
+					case 3: util::stream_format(stream, "ficomp  dword ptr %s", modrm_string); break;
+					case 4: util::stream_format(stream, "fisub   dword ptr %s", modrm_string); break;
+					case 5: util::stream_format(stream, "fisubr  dword ptr %s", modrm_string); break;
+					case 6: util::stream_format(stream, "fidiv   dword ptr %s", modrm_string); break;
+					case 7: util::stream_format(stream, "fidivr  dword ptr %s", modrm_string); break;
 				}
 			}
 			else
@@ -2659,20 +2664,20 @@ static void handle_fpu(char *s, uint8_t op1, uint8_t op2)
 				switch (op2 & 0x3f)
 				{
 					case 0x00: case 0x01: case 0x02: case 0x03: case 0x04: case 0x05: case 0x06: case 0x07:
-						sprintf(s, "fcmovb  st(0),st(%d)", op2 & 0x7); break;
+						util::stream_format(stream, "fcmovb  st(0),st(%d)", op2 & 0x7); break;
 
 					case 0x08: case 0x09: case 0x0a: case 0x0b: case 0x0c: case 0x0d: case 0x0e: case 0x0f:
-						sprintf(s, "fcmove  st(0),st(%d)", op2 & 0x7); break;
+						util::stream_format(stream, "fcmove  st(0),st(%d)", op2 & 0x7); break;
 
 					case 0x10: case 0x11: case 0x12: case 0x13: case 0x14: case 0x15: case 0x16: case 0x17:
-						sprintf(s, "fcmovbe st(0),st(%d)", op2 & 0x7); break;
+						util::stream_format(stream, "fcmovbe st(0),st(%d)", op2 & 0x7); break;
 
 					case 0x18: case 0x19: case 0x1a: case 0x1b: case 0x1c: case 0x1d: case 0x1e: case 0x1f:
-						sprintf(s, "fcmovu  st(0),st(%d)", op2 & 0x7); break;
+						util::stream_format(stream, "fcmovu  st(0),st(%d)", op2 & 0x7); break;
 					case 0x29:
-						sprintf(s, "fucompp"); break;
+						util::stream_format(stream, "fucompp"); break;
 
-					default: sprintf(s, "??? (FPU)"); break;
+					default: util::stream_format(stream, "??? (FPU)"); break;
 
 				}
 			}
@@ -2688,14 +2693,14 @@ static void handle_fpu(char *s, uint8_t op1, uint8_t op2)
 				handle_modrm( modrm_string );
 				switch ((op2 >> 3) & 0x7)
 				{
-					case 0: sprintf(s, "fild    dword ptr %s", modrm_string); break;
-					case 1: sprintf(s, "fisttp  dword ptr %s", modrm_string); break;
-					case 2: sprintf(s, "fist    dword ptr %s", modrm_string); break;
-					case 3: sprintf(s, "fistp   dword ptr %s", modrm_string); break;
-					case 4: sprintf(s, "??? (FPU)"); break;
-					case 5: sprintf(s, "fld     tword ptr %s", modrm_string); break;
-					case 6: sprintf(s, "??? (FPU)"); break;
-					case 7: sprintf(s, "fstp    tword ptr %s", modrm_string); break;
+					case 0: util::stream_format(stream, "fild    dword ptr %s", modrm_string); break;
+					case 1: util::stream_format(stream, "fisttp  dword ptr %s", modrm_string); break;
+					case 2: util::stream_format(stream, "fist    dword ptr %s", modrm_string); break;
+					case 3: util::stream_format(stream, "fistp   dword ptr %s", modrm_string); break;
+					case 4: util::stream_format(stream, "??? (FPU)"); break;
+					case 5: util::stream_format(stream, "fld     tword ptr %s", modrm_string); break;
+					case 6: util::stream_format(stream, "??? (FPU)"); break;
+					case 7: util::stream_format(stream, "fstp    tword ptr %s", modrm_string); break;
 				}
 			}
 			else
@@ -2703,27 +2708,27 @@ static void handle_fpu(char *s, uint8_t op1, uint8_t op2)
 				switch (op2 & 0x3f)
 				{
 					case 0x00: case 0x01: case 0x02: case 0x03: case 0x04: case 0x05: case 0x06: case 0x07:
-						sprintf(s, "fcmovnb st(0),st(%d)", op2 & 0x7); break;
+						util::stream_format(stream, "fcmovnb st(0),st(%d)", op2 & 0x7); break;
 
 					case 0x08: case 0x09: case 0x0a: case 0x0b: case 0x0c: case 0x0d: case 0x0e: case 0x0f:
-						sprintf(s, "fcmovne st(0),st(%d)", op2 & 0x7); break;
+						util::stream_format(stream, "fcmovne st(0),st(%d)", op2 & 0x7); break;
 
 					case 0x10: case 0x11: case 0x12: case 0x13: case 0x14: case 0x15: case 0x16: case 0x17:
-						sprintf(s, "fcmovnbe st(0),st(%d)", op2 & 0x7); break;
+						util::stream_format(stream, "fcmovnbe st(0),st(%d)", op2 & 0x7); break;
 
 					case 0x18: case 0x19: case 0x1a: case 0x1b: case 0x1c: case 0x1d: case 0x1e: case 0x1f:
-						sprintf(s, "fcmovnu st(0),st(%d)", op2 & 0x7); break;
+						util::stream_format(stream, "fcmovnu st(0),st(%d)", op2 & 0x7); break;
 
-					case 0x22: sprintf(s, "fclex"); break;
-					case 0x23: sprintf(s, "finit"); break;
+					case 0x22: util::stream_format(stream, "fclex"); break;
+					case 0x23: util::stream_format(stream, "finit"); break;
 
 					case 0x28: case 0x29: case 0x2a: case 0x2b: case 0x2c: case 0x2d: case 0x2e: case 0x2f:
-						sprintf(s, "fucomi  st(0),st(%d)", op2 & 0x7); break;
+						util::stream_format(stream, "fucomi  st(0),st(%d)", op2 & 0x7); break;
 
 					case 0x30: case 0x31: case 0x32: case 0x33: case 0x34: case 0x35: case 0x36: case 0x37:
-						sprintf(s, "fcomi   st(0),st(%d)", op2 & 0x7); break;
+						util::stream_format(stream, "fcomi   st(0),st(%d)", op2 & 0x7); break;
 
-					default: sprintf(s, "??? (FPU)"); break;
+					default: util::stream_format(stream, "??? (FPU)"); break;
 				}
 			}
 			break;
@@ -2738,14 +2743,14 @@ static void handle_fpu(char *s, uint8_t op1, uint8_t op2)
 				handle_modrm( modrm_string );
 				switch ((op2 >> 3) & 0x7)
 				{
-					case 0: sprintf(s, "fadd    qword ptr %s", modrm_string); break;
-					case 1: sprintf(s, "fmul    qword ptr %s", modrm_string); break;
-					case 2: sprintf(s, "fcom    qword ptr %s", modrm_string); break;
-					case 3: sprintf(s, "fcomp   qword ptr %s", modrm_string); break;
-					case 4: sprintf(s, "fsub    qword ptr %s", modrm_string); break;
-					case 5: sprintf(s, "fsubr   qword ptr %s", modrm_string); break;
-					case 6: sprintf(s, "fdiv    qword ptr %s", modrm_string); break;
-					case 7: sprintf(s, "fdivr   qword ptr %s", modrm_string); break;
+					case 0: util::stream_format(stream, "fadd    qword ptr %s", modrm_string); break;
+					case 1: util::stream_format(stream, "fmul    qword ptr %s", modrm_string); break;
+					case 2: util::stream_format(stream, "fcom    qword ptr %s", modrm_string); break;
+					case 3: util::stream_format(stream, "fcomp   qword ptr %s", modrm_string); break;
+					case 4: util::stream_format(stream, "fsub    qword ptr %s", modrm_string); break;
+					case 5: util::stream_format(stream, "fsubr   qword ptr %s", modrm_string); break;
+					case 6: util::stream_format(stream, "fdiv    qword ptr %s", modrm_string); break;
+					case 7: util::stream_format(stream, "fdivr   qword ptr %s", modrm_string); break;
 				}
 			}
 			else
@@ -2753,24 +2758,24 @@ static void handle_fpu(char *s, uint8_t op1, uint8_t op2)
 				switch (op2 & 0x3f)
 				{
 					case 0x00: case 0x01: case 0x02: case 0x03: case 0x04: case 0x05: case 0x06: case 0x07:
-						sprintf(s, "fadd    st(%d),st(0)", op2 & 0x7); break;
+						util::stream_format(stream, "fadd    st(%d),st(0)", op2 & 0x7); break;
 
 					case 0x08: case 0x09: case 0x0a: case 0x0b: case 0x0c: case 0x0d: case 0x0e: case 0x0f:
-						sprintf(s, "fmul    st(%d),st(0)", op2 & 0x7); break;
+						util::stream_format(stream, "fmul    st(%d),st(0)", op2 & 0x7); break;
 
 					case 0x20: case 0x21: case 0x22: case 0x23: case 0x24: case 0x25: case 0x26: case 0x27:
-						sprintf(s, "fsubr   st(%d),st(0)", op2 & 0x7); break;
+						util::stream_format(stream, "fsubr   st(%d),st(0)", op2 & 0x7); break;
 
 					case 0x28: case 0x29: case 0x2a: case 0x2b: case 0x2c: case 0x2d: case 0x2e: case 0x2f:
-						sprintf(s, "fsub    st(%d),st(0)", op2 & 0x7); break;
+						util::stream_format(stream, "fsub    st(%d),st(0)", op2 & 0x7); break;
 
 					case 0x30: case 0x31: case 0x32: case 0x33: case 0x34: case 0x35: case 0x36: case 0x37:
-						sprintf(s, "fdivr   st(%d),st(0)", op2 & 0x7); break;
+						util::stream_format(stream, "fdivr   st(%d),st(0)", op2 & 0x7); break;
 
 					case 0x38: case 0x39: case 0x3a: case 0x3b: case 0x3c: case 0x3d: case 0x3e: case 0x3f:
-						sprintf(s, "fdiv    st(%d),st(0)", op2 & 0x7); break;
+						util::stream_format(stream, "fdiv    st(%d),st(0)", op2 & 0x7); break;
 
-					default: sprintf(s, "??? (FPU)"); break;
+					default: util::stream_format(stream, "??? (FPU)"); break;
 				}
 			}
 			break;
@@ -2785,14 +2790,14 @@ static void handle_fpu(char *s, uint8_t op1, uint8_t op2)
 				handle_modrm( modrm_string );
 				switch ((op2 >> 3) & 0x7)
 				{
-					case 0: sprintf(s, "fld     qword ptr %s", modrm_string); break;
-					case 1: sprintf(s, "fisttp  qword ptr %s", modrm_string); break;
-					case 2: sprintf(s, "fst     qword ptr %s", modrm_string); break;
-					case 3: sprintf(s, "fstp    qword ptr %s", modrm_string); break;
-					case 4: sprintf(s, "frstor  %s", modrm_string); break;
-					case 5: sprintf(s, "??? (FPU)"); break;
-					case 6: sprintf(s, "fsave   %s", modrm_string); break;
-					case 7: sprintf(s, "fstsw   word ptr %s", modrm_string); break;
+					case 0: util::stream_format(stream, "fld     qword ptr %s", modrm_string); break;
+					case 1: util::stream_format(stream, "fisttp  qword ptr %s", modrm_string); break;
+					case 2: util::stream_format(stream, "fst     qword ptr %s", modrm_string); break;
+					case 3: util::stream_format(stream, "fstp    qword ptr %s", modrm_string); break;
+					case 4: util::stream_format(stream, "frstor  %s", modrm_string); break;
+					case 5: util::stream_format(stream, "??? (FPU)"); break;
+					case 6: util::stream_format(stream, "fsave   %s", modrm_string); break;
+					case 7: util::stream_format(stream, "fstsw   word ptr %s", modrm_string); break;
 				}
 			}
 			else
@@ -2800,21 +2805,21 @@ static void handle_fpu(char *s, uint8_t op1, uint8_t op2)
 				switch (op2 & 0x3f)
 				{
 					case 0x00: case 0x01: case 0x02: case 0x03: case 0x04: case 0x05: case 0x06: case 0x07:
-						sprintf(s, "ffree   st(%d)", op2 & 0x7); break;
+						util::stream_format(stream, "ffree   st(%d)", op2 & 0x7); break;
 
 					case 0x10: case 0x11: case 0x12: case 0x13: case 0x14: case 0x15: case 0x16: case 0x17:
-						sprintf(s, "fst     st(%d)", op2 & 0x7); break;
+						util::stream_format(stream, "fst     st(%d)", op2 & 0x7); break;
 
 					case 0x18: case 0x19: case 0x1a: case 0x1b: case 0x1c: case 0x1d: case 0x1e: case 0x1f:
-						sprintf(s, "fstp    st(%d)", op2 & 0x7); break;
+						util::stream_format(stream, "fstp    st(%d)", op2 & 0x7); break;
 
 					case 0x20: case 0x21: case 0x22: case 0x23: case 0x24: case 0x25: case 0x26: case 0x27:
-						sprintf(s, "fucom   st(%d), st(0)", op2 & 0x7); break;
+						util::stream_format(stream, "fucom   st(%d), st(0)", op2 & 0x7); break;
 
 					case 0x28: case 0x29: case 0x2a: case 0x2b: case 0x2c: case 0x2d: case 0x2e: case 0x2f:
-						sprintf(s, "fucomp  st(%d)", op2 & 0x7); break;
+						util::stream_format(stream, "fucomp  st(%d)", op2 & 0x7); break;
 
-					default: sprintf(s, "??? (FPU)"); break;
+					default: util::stream_format(stream, "??? (FPU)"); break;
 				}
 			}
 			break;
@@ -2829,14 +2834,14 @@ static void handle_fpu(char *s, uint8_t op1, uint8_t op2)
 				handle_modrm( modrm_string );
 				switch ((op2 >> 3) & 0x7)
 				{
-					case 0: sprintf(s, "fiadd   word ptr %s", modrm_string); break;
-					case 1: sprintf(s, "fimul   word ptr %s", modrm_string); break;
-					case 2: sprintf(s, "ficom   word ptr %s", modrm_string); break;
-					case 3: sprintf(s, "ficomp  word ptr %s", modrm_string); break;
-					case 4: sprintf(s, "fisub   word ptr %s", modrm_string); break;
-					case 5: sprintf(s, "fisubr  word ptr %s", modrm_string); break;
-					case 6: sprintf(s, "fidiv   word ptr %s", modrm_string); break;
-					case 7: sprintf(s, "fidivr  word ptr %s", modrm_string); break;
+					case 0: util::stream_format(stream, "fiadd   word ptr %s", modrm_string); break;
+					case 1: util::stream_format(stream, "fimul   word ptr %s", modrm_string); break;
+					case 2: util::stream_format(stream, "ficom   word ptr %s", modrm_string); break;
+					case 3: util::stream_format(stream, "ficomp  word ptr %s", modrm_string); break;
+					case 4: util::stream_format(stream, "fisub   word ptr %s", modrm_string); break;
+					case 5: util::stream_format(stream, "fisubr  word ptr %s", modrm_string); break;
+					case 6: util::stream_format(stream, "fidiv   word ptr %s", modrm_string); break;
+					case 7: util::stream_format(stream, "fidivr  word ptr %s", modrm_string); break;
 				}
 			}
 			else
@@ -2844,26 +2849,26 @@ static void handle_fpu(char *s, uint8_t op1, uint8_t op2)
 				switch (op2 & 0x3f)
 				{
 					case 0x00: case 0x01: case 0x02: case 0x03: case 0x04: case 0x05: case 0x06: case 0x07:
-						sprintf(s, "faddp   st(%d)", op2 & 0x7); break;
+						util::stream_format(stream, "faddp   st(%d)", op2 & 0x7); break;
 
 					case 0x08: case 0x09: case 0x0a: case 0x0b: case 0x0c: case 0x0d: case 0x0e: case 0x0f:
-						sprintf(s, "fmulp   st(%d)", op2 & 0x7); break;
+						util::stream_format(stream, "fmulp   st(%d)", op2 & 0x7); break;
 
-					case 0x19: sprintf(s, "fcompp"); break;
+					case 0x19: util::stream_format(stream, "fcompp"); break;
 
 					case 0x20: case 0x21: case 0x22: case 0x23: case 0x24: case 0x25: case 0x26: case 0x27:
-						sprintf(s, "fsubrp  st(%d)", op2 & 0x7); break;
+						util::stream_format(stream, "fsubrp  st(%d)", op2 & 0x7); break;
 
 					case 0x28: case 0x29: case 0x2a: case 0x2b: case 0x2c: case 0x2d: case 0x2e: case 0x2f:
-						sprintf(s, "fsubp   st(%d)", op2 & 0x7); break;
+						util::stream_format(stream, "fsubp   st(%d)", op2 & 0x7); break;
 
 					case 0x30: case 0x31: case 0x32: case 0x33: case 0x34: case 0x35: case 0x36: case 0x37:
-						sprintf(s, "fdivrp  st(%d), st(0)", op2 & 0x7); break;
+						util::stream_format(stream, "fdivrp  st(%d), st(0)", op2 & 0x7); break;
 
 					case 0x38: case 0x39: case 0x3a: case 0x3b: case 0x3c: case 0x3d: case 0x3e: case 0x3f:
-						sprintf(s, "fdivp   st(%d)", op2 & 0x7); break;
+						util::stream_format(stream, "fdivp   st(%d)", op2 & 0x7); break;
 
-					default: sprintf(s, "??? (FPU)"); break;
+					default: util::stream_format(stream, "??? (FPU)"); break;
 				}
 			}
 			break;
@@ -2878,29 +2883,29 @@ static void handle_fpu(char *s, uint8_t op1, uint8_t op2)
 				handle_modrm( modrm_string );
 				switch ((op2 >> 3) & 0x7)
 				{
-					case 0: sprintf(s, "fild    word ptr %s", modrm_string); break;
-					case 1: sprintf(s, "fisttp  word ptr %s", modrm_string); break;
-					case 2: sprintf(s, "fist    word ptr %s", modrm_string); break;
-					case 3: sprintf(s, "fistp   word ptr %s", modrm_string); break;
-					case 4: sprintf(s, "fbld    %s", modrm_string); break;
-					case 5: sprintf(s, "fild    qword ptr %s", modrm_string); break;
-					case 6: sprintf(s, "fbstp   %s", modrm_string); break;
-					case 7: sprintf(s, "fistp   qword ptr %s", modrm_string); break;
+					case 0: util::stream_format(stream, "fild    word ptr %s", modrm_string); break;
+					case 1: util::stream_format(stream, "fisttp  word ptr %s", modrm_string); break;
+					case 2: util::stream_format(stream, "fist    word ptr %s", modrm_string); break;
+					case 3: util::stream_format(stream, "fistp   word ptr %s", modrm_string); break;
+					case 4: util::stream_format(stream, "fbld    %s", modrm_string); break;
+					case 5: util::stream_format(stream, "fild    qword ptr %s", modrm_string); break;
+					case 6: util::stream_format(stream, "fbstp   %s", modrm_string); break;
+					case 7: util::stream_format(stream, "fistp   qword ptr %s", modrm_string); break;
 				}
 			}
 			else
 			{
 				switch (op2 & 0x3f)
 				{
-					case 0x20: sprintf(s, "fstsw   ax"); break;
+					case 0x20: util::stream_format(stream, "fstsw   ax"); break;
 
 					case 0x28: case 0x29: case 0x2a: case 0x2b: case 0x2c: case 0x2d: case 0x2e: case 0x2f:
-						sprintf(s, "fucomip st(%d)", op2 & 0x7); break;
+						util::stream_format(stream, "fucomip st(%d)", op2 & 0x7); break;
 
 					case 0x30: case 0x31: case 0x32: case 0x33: case 0x34: case 0x35: case 0x36: case 0x37:
-						sprintf(s, "fcomip  st(%d),st(0)", op2 & 0x7); break;
+						util::stream_format(stream, "fcomip  st(%d),st(0)", op2 & 0x7); break;
 
-					default: sprintf(s, "??? (FPU)"); break;
+					default: util::stream_format(stream, "??? (FPU)"); break;
 				}
 			}
 			break;
@@ -2908,7 +2913,7 @@ static void handle_fpu(char *s, uint8_t op1, uint8_t op2)
 	}
 }
 
-static void decode_opcode(char *s, const I386_OPCODE *op, uint8_t op1)
+static void decode_opcode(std::ostream &stream, const I386_OPCODE *op, uint8_t op1)
 {
 	int i;
 	uint8_t op2;
@@ -2927,7 +2932,7 @@ static void decode_opcode(char *s, const I386_OPCODE *op, uint8_t op1)
 				sibex = (op1 << 2) & 8;
 				rmex = (op1 << 3) & 8;
 				op2 = FETCH();
-				decode_opcode( s, &i386_opcode_table1[op2], op1 );
+				decode_opcode(stream, &i386_opcode_table1[op2], op1 );
 				return;
 			}
 			break;
@@ -2940,7 +2945,7 @@ static void decode_opcode(char *s, const I386_OPCODE *op, uint8_t op1)
 				operand_prefix = 1;
 			}
 			op2 = FETCH();
-			decode_opcode( s, &i386_opcode_table1[op2], op2 );
+			decode_opcode(stream, &i386_opcode_table1[op2], op2 );
 			return;
 
 		case ADDR_SIZE:
@@ -2954,22 +2959,22 @@ static void decode_opcode(char *s, const I386_OPCODE *op, uint8_t op1)
 				address_prefix = 1;
 			}
 			op2 = FETCH();
-			decode_opcode( s, &i386_opcode_table1[op2], op2 );
+			decode_opcode(stream, &i386_opcode_table1[op2], op2 );
 			return;
 
 		case TWO_BYTE:
 			if (&opcode_ptr[-2] >= opcode_ptr_base)
 				pre0f = opcode_ptr[-2];
 			op2 = FETCHD();
-			decode_opcode( s, &i386_opcode_table2[op2], op1 );
+			decode_opcode(stream, &i386_opcode_table2[op2], op1 );
 			return;
 
 		case THREE_BYTE:
 			op2 = FETCHD();
 			if (opcode_ptr[-2] == 0x38)
-				decode_opcode( s, &i386_opcode_table0F38[op2], op1 );
+				decode_opcode(stream, &i386_opcode_table0F38[op2], op1 );
 			else
-				decode_opcode( s, &i386_opcode_table0F3A[op2], op1 );
+				decode_opcode(stream, &i386_opcode_table0F3A[op2], op1 );
 			return;
 
 		case SEG_CS:
@@ -2981,16 +2986,16 @@ static void decode_opcode(char *s, const I386_OPCODE *op, uint8_t op1)
 			rex = regex = sibex = rmex = 0;
 			segment = op->flags;
 			op2 = FETCH();
-			decode_opcode( s, &i386_opcode_table1[op2], op2 );
+			decode_opcode(stream, &i386_opcode_table1[op2], op2 );
 			return;
 
 		case PREFIX:
 			op2 = FETCH();
 			if ((op2 != 0x0f) && (op2 != 0x90))
-				s += sprintf( s, "%-7s ", op->mnemonic );
+				util::stream_format(stream, "%-7s ", op->mnemonic );
 			if ((op2 == 0x90) && !pre0f)
 				pre0f = op1;
-			decode_opcode( s, &i386_opcode_table1[op2], op2 );
+			decode_opcode(stream, &i386_opcode_table1[op2], op2 );
 			return;
 
 		case GROUP:
@@ -2998,9 +3003,9 @@ static void decode_opcode(char *s, const I386_OPCODE *op, uint8_t op1)
 			for( i=0; i < ARRAY_LENGTH(group_op_table); i++ ) {
 				if( strcmp(op->mnemonic, group_op_table[i].mnemonic) == 0 ) {
 					if (op->flags & GROUP_MOD)
-						decode_opcode( s, &group_op_table[i].opcode[MODRM_MOD], op1 );
+						decode_opcode(stream, &group_op_table[i].opcode[MODRM_MOD], op1 );
 					else
-						decode_opcode( s, &group_op_table[i].opcode[MODRM_REG1], op1 );
+						decode_opcode(stream, &group_op_table[i].opcode[MODRM_REG1], op1 );
 					return;
 				}
 			}
@@ -3008,7 +3013,7 @@ static void decode_opcode(char *s, const I386_OPCODE *op, uint8_t op1)
 
 		case FPU:
 			op2 = FETCHD();
-			handle_fpu( s, op1, op2);
+			handle_fpu(stream, op1, op2);
 			return;
 
 		case MODRM:
@@ -3024,7 +3029,7 @@ static void decode_opcode(char *s, const I386_OPCODE *op, uint8_t op1)
 		const char *mnemonic = op->mnemonic + strlen(op->mnemonic) + 1;
 		if (operand_size == 2)
 			mnemonic += strlen(mnemonic) + 1;
-		s += sprintf( s, "%-7s ", mnemonic );
+		util::stream_format(stream, "%-7s ", mnemonic );
 	}
 	else if (op->flags & VAR_NAME4)
 	{
@@ -3032,32 +3037,32 @@ static void decode_opcode(char *s, const I386_OPCODE *op, uint8_t op1)
 		int which = (pre0f == 0xf3) ? 3 : (pre0f == 0xf2) ? 2 : (pre0f == 0x66) ? 1 : 0;
 		while (which--)
 			mnemonic += strlen(mnemonic) + 1;
-		s += sprintf( s, "%-7s ", mnemonic );
+		util::stream_format(stream, "%-7s ", mnemonic );
 	}
 	else
-		s += sprintf( s, "%-7s ", op->mnemonic );
+		util::stream_format(stream, "%-7s ", op->mnemonic );
 	dasm_flags = op->dasm_flags;
 
 	if( op->param1 != 0 ) {
-		s = handle_param( s, op->param1 );
+		handle_param(stream, op->param1 );
 	}
 
 	if( op->param2 != 0 ) {
-		s += sprintf( s, "," );
-		s = handle_param( s, op->param2 );
+		util::stream_format(stream, "," );
+		handle_param(stream, op->param2 );
 	}
 
 	if( op->param3 != 0 ) {
-		s += sprintf( s, "," );
-		s = handle_param( s, op->param3 );
+		util::stream_format(stream, "," );
+		handle_param(stream, op->param3 );
 	}
 	return;
 
 handle_unknown:
-	sprintf(s, "???");
+	util::stream_format(stream, "???");
 }
 
-int i386_dasm_one_ex(char *buffer, uint64_t eip, const uint8_t *oprom, int mode)
+int i386_dasm_one_ex(std::ostream &stream, uint64_t eip, const uint8_t *oprom, int mode)
 {
 	uint8_t op;
 
@@ -3101,13 +3106,22 @@ int i386_dasm_one_ex(char *buffer, uint64_t eip, const uint8_t *oprom, int mode)
 
 	op = FETCH();
 
-	decode_opcode( buffer, &i386_opcode_table1[op], op );
+	decode_opcode( stream, &i386_opcode_table1[op], op );
 	return (pc-eip) | dasm_flags | DASMFLAG_SUPPORTED;
 }
 
-int i386_dasm_one(char *buffer, offs_t eip, const uint8_t *oprom, int mode)
+int i386_dasm_one(std::ostream &stream, offs_t eip, const uint8_t *oprom, int mode)
 {
-	return i386_dasm_one_ex(buffer, eip, oprom, mode);
+	return i386_dasm_one_ex(stream, eip, oprom, mode);
+}
+
+static int i386_dasm_one_ex(char *buffer, uint64_t eip, const uint8_t *oprom, int mode)
+{
+	std::ostringstream stream;
+	int result = i386_dasm_one_ex(stream, eip, oprom, mode);
+	std::string stream_str = stream.str();
+	strcpy(buffer, stream_str.c_str());
+	return result;
 }
 
 CPU_DISASSEMBLE( x86_16 )
diff --git a/src/devices/cpu/i386/i386priv.h b/src/devices/cpu/i386/i386priv.h
index 704df9d0f00..0a917c631a3 100644
--- a/src/devices/cpu/i386/i386priv.h
+++ b/src/devices/cpu/i386/i386priv.h
@@ -15,7 +15,7 @@
 #define MMXOP(XX)       mmx_##XX
 #define SSEOP(XX)       sse_##XX
 
-extern int i386_dasm_one(char *buffer, uint32_t pc, const uint8_t *oprom, int mode);
+extern int i386_dasm_one(std::ostream &stream, uint32_t pc, const uint8_t *oprom, int mode);
 
 enum SREGS { ES, CS, SS, DS, FS, GS };
 
diff --git a/src/devices/cpu/i86/i86.cpp b/src/devices/cpu/i86/i86.cpp
index 77566cbd9aa..799ab25685d 100644
--- a/src/devices/cpu/i86/i86.cpp
+++ b/src/devices/cpu/i86/i86.cpp
@@ -510,8 +510,12 @@ void i8086_common_cpu_device::execute_set_input( int inptnum, int state )
 
 offs_t i8086_common_cpu_device::disasm_disassemble(char *buffer, offs_t pc, const uint8_t *oprom, const uint8_t *opram, uint32_t options)
 {
-	extern int i386_dasm_one(char *buffer, offs_t eip, const uint8_t *oprom, int mode);
-	return i386_dasm_one(buffer, pc, oprom, 1);
+	extern int i386_dasm_one(std::ostream &stream, offs_t eip, const uint8_t *oprom, int mode);
+	std::ostringstream stream;
+	offs_t result = i386_dasm_one(stream, pc, oprom, 1);
+	std::string stream_str = stream.str();
+	strcpy(buffer, stream_str.c_str());
+	return result;
 }
 
 uint8_t i8086_common_cpu_device::read_port_byte(uint16_t port)
diff --git a/src/devices/cpu/x86log.cpp b/src/devices/cpu/x86log.cpp
index f8990e51049..07b1bccb7eb 100644
--- a/src/devices/cpu/x86log.cpp
+++ b/src/devices/cpu/x86log.cpp
@@ -20,7 +20,7 @@
 ***************************************************************************/
 
 static void reset_log(x86log_context *log) noexcept;
-extern int i386_dasm_one_ex(char *buffer, uint64_t eip, const uint8_t *oprom, int mode);
+extern int i386_dasm_one_ex(std::ostream &stream, uint64_t eip, const uint8_t *oprom, int mode);
 
 
 
@@ -111,7 +111,7 @@ void x86log_disasm_code_range(x86log_context *log, const char *label, x86code *s
 	/* loop from the start until the cache top */
 	while (cur < stop)
 	{
-		char buffer[100];
+		std::string buffer;
 		int bytes;
 
 		/* skip past any past data ranges */
@@ -129,10 +129,10 @@ void x86log_disasm_code_range(x86log_context *log, const char *label, x86code *s
 			switch (curdata->size)
 			{
 				default:
-				case 1:     sprintf(buffer, "db      %02X", *cur);              break;
-				case 2:     sprintf(buffer, "dw      %04X", *(uint16_t *)cur);    break;
-				case 4:     sprintf(buffer, "dd      %08X", *(uint32_t *)cur);    break;
-				case 8:     sprintf(buffer, "dq      %08X%08X", ((uint32_t *)cur)[1], ((uint32_t *)cur)[0]);    break;
+				case 1:     buffer = string_format("db      %02X", *cur);              break;
+				case 2:     buffer = string_format("dw      %04X", *(uint16_t *)cur);    break;
+				case 4:     buffer = string_format("dd      %08X", *(uint32_t *)cur);    break;
+				case 8:     buffer = string_format("dq      %08X%08X", ((uint32_t *)cur)[1], ((uint32_t *)cur)[0]);    break;
 			}
 		}
 
@@ -146,7 +146,9 @@ void x86log_disasm_code_range(x86log_context *log, const char *label, x86code *s
 		/* otherwise, do a disassembly of the current instruction */
 		else
 		{
-			bytes = i386_dasm_one_ex(buffer, (uintptr_t)cur, cur, sizeof(void *) * 8) & DASMFLAG_LENGTHMASK;
+			std::stringstream strbuffer;
+			bytes = i386_dasm_one_ex(strbuffer, (uintptr_t)cur, cur, sizeof(void *) * 8) & DASMFLAG_LENGTHMASK;
+			buffer = strbuffer.str();
 		}
 
 		/* if we have a matching comment, output it */
@@ -155,12 +157,12 @@ void x86log_disasm_code_range(x86log_context *log, const char *label, x86code *s
 			/* if we have additional matching comments at the same address, output them first */
 			for ( ; curcomment + 1 < lastcomment && cur == curcomment[1].base; curcomment++)
 				x86log_printf(log, "%p: %-50s; %s\n", cur, "", curcomment->string);
-			x86log_printf(log, "%p: %-50s; %s\n", cur, buffer, curcomment->string);
+			x86log_printf(log, "%p: %-50s; %s\n", cur, buffer.c_str(), curcomment->string);
 		}
 
 		/* if we don't, just print the disassembly and move on */
 		else
-			x86log_printf(log, "%p: %s\n", cur, buffer);
+			x86log_printf(log, "%p: %s\n", cur, buffer.c_str());
 
 		/* advance past this instruction */
 		cur += bytes;