/src/capstonenext/SStream.c

Source (jump to first uncovered line)
/* Capstone Disassembly Engine */
/* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2019 */

#include <stdarg.h>
#if defined(CAPSTONE_HAS_OSXKERNEL)
#include <Availability.h>
#include <libkern/libkern.h>
#include <i386/limits.h>
#else
#include <stdio.h>
#include <limits.h>
#endif
#include <string.h>

#include <capstone/platform.h>

#include "SStream.h"
#include "cs_priv.h"
#include "utils.h"

void SStream_Init(SStream *ss)
{
  assert(ss);
  ss->index = 0;
  memset(ss->buffer, 0, sizeof(ss->buffer));
  ss->is_closed = false;
  ss->markup_stream = false;
  ss->prefixed_by_markup = false;
  ss->unsigned_num = false;
}

void SStream_opt_unum(SStream *ss, bool print_unsigned_numbers)
{
  assert(ss);
  ss->unsigned_num = print_unsigned_numbers;
}

/// Returns the a pointer to the internal string buffer of the stream.
/// For reading only.
const char *SStream_rbuf(const SStream *ss) {
  assert(ss);
  return ss->buffer;
}

/// Searches in the stream for the first (from the left) occurrence of @elem and replaces
/// it with @repl. It returns the pointer *after* the replaced character
/// or NULL if no character was replaced.
///
/// It will never replace the final \0 byte in the stream buffer.
const char *SStream_replc(const SStream *ss, char elem, char repl) {
  assert(ss);
  char *found = strchr(ss->buffer, elem);
  if (!found || found == ss->buffer + (SSTREAM_BUF_LEN - 1)) {
    return NULL;
  }
  *found = repl;
  found++;
  return found;
}

/// Searches in the stream for the first (from the left) occurrence of @chr and replaces
/// it with @rstr.
void SStream_replc_str(SStream *ss, char chr, const char *rstr) {
  assert(ss && rstr);
  char *found = strchr(ss->buffer, chr);
  if (!found || found == ss->buffer + (SSTREAM_BUF_LEN - 1)) {
    return;
  }
  size_t post_len = strlen(found + 1);
  size_t buf_str_len = strlen(ss->buffer);
  size_t repl_len = strlen(rstr);
  if (repl_len - 1 + buf_str_len >= SSTREAM_BUF_LEN) {
    return;
  }
  memmove(found + repl_len, found + 1, post_len);
  memcpy(found, rstr, repl_len);
  ss->index = strlen(ss->buffer);
}

/// Removes the space characters '\t' and ' ' from the beginning of the stream buffer.
void SStream_trimls(SStream *ss) {
  assert(ss);
  size_t buf_off = 0;
  /// Remove leading spaces
  while (ss->buffer[buf_off] == ' ' || ss->buffer[buf_off] == '\t') {
    buf_off++;
  }
  if (buf_off > 0) {
    memmove(ss->buffer, ss->buffer + buf_off, SSTREAM_BUF_LEN - buf_off);
    ss->index -= buf_off;
  }
}

/// Extract the mnemonic to @mnem_buf and the operand string into @op_str_buf from the stream buffer.
/// The mnemonic is everything up until the first ' ' or '\t' character.
/// The operand string is everything after the first ' ' or '\t' sequence.
void SStream_extract_mnem_opstr(const SStream *ss, char *mnem_buf, size_t mnem_buf_size, char *op_str_buf, size_t op_str_buf_size) {
  assert(ss && mnem_buf && mnem_buf_size > 0 && op_str_buf && op_str_buf_size > 0);
  size_t off = 0;
  // Copy all non space chars to as mnemonic.
  while (ss->buffer[off] && ss->buffer[off] != ' ' && ss->buffer[off] != '\t') {
    if (off < mnem_buf_size - 1) {
      // Only copy if there is space left.
      mnem_buf[off] = ss->buffer[off];
    }
    off++;
  }
  if (!ss->buffer[off]) {
    return;
  }

  // Iterate until next non space char.
  do {
    off++;
  } while (ss->buffer[off] && (ss->buffer[off] == ' ' || ss->buffer[off] == '\t'));

  if (!ss->buffer[off]) {
    return;
  }

  // Copy all follow up characters as op_str
  const char *ss_op_str = ss->buffer + off;
  off = 0;
  while (ss_op_str[off] && off < op_str_buf_size - 1) {
    op_str_buf[off] = ss_op_str[off];
    off++;
  }
}

/// Empty the stream @ss to given @file (stdin/stderr).
/// @file can be NULL. Then the buffer content is not emitted.
void SStream_Flush(SStream *ss, FILE *file)
{
  assert(ss);
  if (file) {
    fprintf(file, "%s\n", ss->buffer);
  }
  SStream_Init(ss);
}

/**
 * Open the output stream. Every write attempt is accepted again.
 */
void SStream_Open(SStream *ss) {
  assert(ss);
  ss->is_closed = false;
}

/**
 * Closes the output stream. Every write attempt is ignored.
 */
void SStream_Close(SStream *ss) {
  assert(ss);
  ss->is_closed = true;
}

/**
 * Copy the string \p s to the buffer of \p ss and terminate it with a '\\0' byte.
 */
void SStream_concat0(SStream *ss, const char *s)
{
#ifndef CAPSTONE_DIET
  assert(ss && s);
  SSTREAM_RETURN_IF_CLOSED(ss);
  if (s[0] == '\0')
    return;
  unsigned int len = (unsigned int) strlen(s);

  SSTREAM_OVERFLOW_CHECK(ss, len);

  memcpy(ss->buffer + ss->index, s, len);
  ss->index += len;
  ss->buffer[ss->index] = '\0';
  if (ss->markup_stream && ss->prefixed_by_markup) {
    SSTREAM_OVERFLOW_CHECK(ss, 1);
    ss->buffer[ss->index] = '>';
    ss->index += 1;
    ss->buffer[ss->index] = '\0';
  }
#endif
}

/**
 * Copy the single char \p c to the buffer of \p ss.
 */
void SStream_concat1(SStream *ss, const char c)
{
#ifndef CAPSTONE_DIET
  assert(ss);
  SSTREAM_RETURN_IF_CLOSED(ss);
  if (c == '\0')
    return;

  SSTREAM_OVERFLOW_CHECK(ss, 1);

  ss->buffer[ss->index] = c;
  ss->index++;
  ss->buffer[ss->index] = '\0';
  if (ss->markup_stream && ss->prefixed_by_markup) {
    SSTREAM_OVERFLOW_CHECK(ss, 1);
    ss->buffer[ss->index] = '>';
    ss->index++;
  }
#endif
}

/**
 * Copy all strings given to the buffer of \p ss according to formatting \p fmt.
 */
void SStream_concat(SStream *ss, const char *fmt, ...)
{
#ifndef CAPSTONE_DIET
  assert(ss && fmt);
  SSTREAM_RETURN_IF_CLOSED(ss);
  va_list ap;
  int ret;

  va_start(ap, fmt);
  ret = cs_vsnprintf(ss->buffer + ss->index, sizeof(ss->buffer) - (ss->index + 1), fmt, ap);
  va_end(ap);
  ss->index += ret;
  if (ss->markup_stream && ss->prefixed_by_markup) {
    SSTREAM_OVERFLOW_CHECK(ss, 1);
    ss->buffer[ss->index] = '>';
    ss->index += 1;
  }
#endif
}

// print number with prefix #
void printInt64Bang(SStream *ss, int64_t val)
{
  assert(ss);
  if (ss->unsigned_num) {
    printUInt64Bang(ss, val);
    return;
  }
  SSTREAM_RETURN_IF_CLOSED(ss);
  SStream_concat1(ss, '#');
  printInt64(ss, val);
}

void printUInt64Bang(SStream *ss, uint64_t val)
{
  assert(ss);
  SSTREAM_RETURN_IF_CLOSED(ss);
  SStream_concat1(ss, '#');
  printUInt64(ss, val);
}

// print number
void printInt64(SStream *ss, int64_t val)
{
  assert(ss);
  if (ss->unsigned_num) {
    printUInt64(ss, val);
    return;
  }
  SSTREAM_RETURN_IF_CLOSED(ss);
  if (val >= 0) {
    if (val > HEX_THRESHOLD)
      SStream_concat(ss, "0x%"PRIx64, val);
    else
      SStream_concat(ss, "%"PRIu64, val);
  } else {
    if (val < -HEX_THRESHOLD) {
      if (val == INT64_MIN)
        SStream_concat(ss, "-0x%"PRIx64, (uint64_t) INT64_MAX + 1);
      else
        SStream_concat(ss, "-0x%"PRIx64, (uint64_t)-val);
    } else
      SStream_concat(ss, "-%"PRIu64, -val);
  }
}

void printUInt64(SStream *ss, uint64_t val)
{
  assert(ss);
  SSTREAM_RETURN_IF_CLOSED(ss);
  if (val > HEX_THRESHOLD)
    SStream_concat(ss, "0x%"PRIx64, val);
  else
    SStream_concat(ss, "%"PRIu64, val);
}

// print number in decimal mode
void printInt32BangDec(SStream *ss, int32_t val)
{
  assert(ss);
  SSTREAM_RETURN_IF_CLOSED(ss);
  if (val >= 0)
    SStream_concat(ss, "#%" PRIu32, val);
  else {
    if (val == INT32_MIN)
      SStream_concat(ss, "#-%" PRIu32, val);
    else
      SStream_concat(ss, "#-%" PRIu32, (uint32_t)-val);
  }
}

void printInt32Bang(SStream *ss, int32_t val)
{
  assert(ss);
  if (ss->unsigned_num) {
    printUInt32Bang(ss, val);
    return;
  }
  SSTREAM_RETURN_IF_CLOSED(ss);
  SStream_concat1(ss, '#');
  printInt32(ss, val);
}

void printUInt8(SStream *ss, uint8_t val)
{
  assert(ss);
  if (val > HEX_THRESHOLD)
    SStream_concat(ss, "0x%"PRIx8, val);
  else
    SStream_concat(ss, "%"PRIu8, val);
}

void printUInt16(SStream *ss, uint16_t val)
{
  assert(ss);
  if (val > HEX_THRESHOLD)
    SStream_concat(ss, "0x%"PRIx16, val);
  else
    SStream_concat(ss, "%"PRIu16, val);
}

void printInt8(SStream *ss, int8_t val)
{
  assert(ss);
  if (ss->unsigned_num) {
    printUInt8(ss, val);
    return;
  }
  SSTREAM_RETURN_IF_CLOSED(ss);
  if (val >= 0) {
    if (val > HEX_THRESHOLD)
      SStream_concat(ss, "0x%" PRIx8, val);
    else
      SStream_concat(ss, "%" PRId8, val);
  } else {
    if (val < -HEX_THRESHOLD) {
      if (val == INT8_MIN)
        SStream_concat(ss, "-0x%" PRIx8, (uint8_t) INT8_MAX + 1);
      else
        SStream_concat(ss, "-0x%" PRIx8, (int8_t)-val);
    } else
      SStream_concat(ss, "-%" PRIu8, -val);
  }
}

void printInt16(SStream *ss, int16_t val)
{
  assert(ss);
  if (ss->unsigned_num) {
    printUInt16(ss, val);
    return;
  }
  SSTREAM_RETURN_IF_CLOSED(ss);
  if (val >= 0) {
    if (val > HEX_THRESHOLD)
      SStream_concat(ss, "0x%" PRIx16, val);
    else
      SStream_concat(ss, "%" PRId16, val);
  } else {
    if (val < -HEX_THRESHOLD) {
      if (val == INT16_MIN)
        SStream_concat(ss, "-0x%" PRIx16, (uint16_t) INT16_MAX + 1);
      else
        SStream_concat(ss, "-0x%" PRIx16, (int16_t)-val);
    } else
      SStream_concat(ss, "-%" PRIu16, -val);
  }
}

void printInt16HexOffset(SStream *ss, int16_t val)
{
  assert(ss);
  if (ss->unsigned_num) {
    printUInt16(ss, val);
    return;
  }
  SSTREAM_RETURN_IF_CLOSED(ss);
  if (val >= 0) {
    SStream_concat(ss, "+0x%" PRIx16, val);
  } else {
    if (val == INT16_MIN)
      SStream_concat(ss, "-0x%" PRIx16,
               (uint16_t)INT16_MAX + 1);
    else
      SStream_concat(ss, "-0x%" PRIx16, (int16_t)-val);
  }
}


void printInt32(SStream *ss, int32_t val)
{
  assert(ss);
  if (ss->unsigned_num) {
    printUInt32(ss, val);
    return;
  }
  SSTREAM_RETURN_IF_CLOSED(ss);
  if (val >= 0) {
    if (val > HEX_THRESHOLD)
      SStream_concat(ss, "0x%" PRIx32, val);
    else
      SStream_concat(ss, "%" PRId32, val);
  } else {
    if (val < -HEX_THRESHOLD) {
      if (val == INT32_MIN)
        SStream_concat(ss, "-0x%" PRIx32, (uint32_t) INT32_MAX + 1);
      else
        SStream_concat(ss, "-0x%" PRIx32, (int32_t)-val);
    } else {
      SStream_concat(ss, "-%" PRIu32, (uint32_t)-val);
    }
  }
}

void printInt32HexOffset(SStream *ss, int32_t val)
{
  assert(ss);
  if (ss->unsigned_num) {
    printUInt32(ss, val);
    return;
  }
  SSTREAM_RETURN_IF_CLOSED(ss);
  if (val >= 0) {
    SStream_concat(ss, "+0x%" PRIx32, val);
  } else {
    if (val == INT32_MIN)
      SStream_concat(ss, "-0x%" PRIx32,
               (uint32_t)INT32_MAX + 1);
    else
      SStream_concat(ss, "-0x%" PRIx32, (int32_t)-val);
  }
}

void printInt32Hex(SStream *ss, int32_t val)
{
  assert(ss);
  SSTREAM_RETURN_IF_CLOSED(ss);
  if (val >= 0) {
    SStream_concat(ss, "0x%" PRIx32, val);
  } else {
    if (val == INT32_MIN)
      SStream_concat(ss, "-0x%" PRIx32,
               (uint32_t)INT32_MAX + 1);
    else
      SStream_concat(ss, "-0x%" PRIx32, (int32_t)-val);
  }
}

void printUInt32Bang(SStream *ss, uint32_t val)
{
  assert(ss);
  SSTREAM_RETURN_IF_CLOSED(ss);
  SStream_concat1(ss, '#');
  printUInt32(ss, val);
}

void printUInt32(SStream *ss, uint32_t val)
{
  assert(ss);
  SSTREAM_RETURN_IF_CLOSED(ss);
  if (val > HEX_THRESHOLD)
    SStream_concat(ss, "0x%x", val);
  else
    SStream_concat(ss, "%u", val);
}

void printFloat(SStream *ss, float val)
{
  assert(ss);
  SSTREAM_RETURN_IF_CLOSED(ss);
  SStream_concat(ss, "%e", val);
}

void printFloatBang(SStream *ss, float val)
{
  assert(ss);
  SSTREAM_RETURN_IF_CLOSED(ss);
  SStream_concat(ss, "#%e", val);
}

void printExpr(SStream *ss, uint64_t val)
{
  assert(ss);
  SSTREAM_RETURN_IF_CLOSED(ss);
  SStream_concat(ss, "%"PRIu64, val);
}

SStream *markup_OS(SStream *OS, SStreamMarkup style) {
  assert(OS);

  if (OS->is_closed || !OS->markup_stream) {
    return OS;
  }
  OS->markup_stream = false; // Disable temporarily.
  switch (style) {
  default:
    SStream_concat0(OS, "<UNKNOWN:");
    return OS;
  case Markup_Immediate:
    SStream_concat0(OS, "<imm:");
    break;
  case Markup_Register:
    SStream_concat0(OS, "<reg:");
    break;
  case Markup_Target:
    SStream_concat0(OS, "<tar:");
    break;
  case Markup_Memory:
    SStream_concat0(OS, "<mem:");
    break;
  }
  OS->markup_stream = true;
  OS->prefixed_by_markup = true;
  return OS;
}

Coverage Report

Created: 2025-07-04 06:11

Line	Count	Source (jump to first uncovered line)
1		/* Capstone Disassembly Engine */
2		/* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2019 */
3
4		#include <stdarg.h>
5		#if defined(CAPSTONE_HAS_OSXKERNEL)
6		#include <Availability.h>
7		#include <libkern/libkern.h>
8		#include <i386/limits.h>
9		#else
10		#include <stdio.h>
11		#include <limits.h>
12		#endif
13		#include <string.h>
14
15		#include <capstone/platform.h>
16
17		#include "SStream.h"
18		#include "cs_priv.h"
19		#include "utils.h"
20
21		void SStream_Init(SStream *ss)
22	3.14M	{
23	3.14M	assert(ss);
24	3.14M	ss->index = 0;
25	3.14M	memset(ss->buffer, 0, sizeof(ss->buffer));
26	3.14M	ss->is_closed = false;
27	3.14M	ss->markup_stream = false;
28	3.14M	ss->prefixed_by_markup = false;
29	3.14M	ss->unsigned_num = false;
30	3.14M	}
31
32		void SStream_opt_unum(SStream *ss, bool print_unsigned_numbers)
33	3.03M	{
34	3.03M	assert(ss);
35	3.03M	ss->unsigned_num = print_unsigned_numbers;
36	3.03M	}
37
38		/// Returns the a pointer to the internal string buffer of the stream.
39		/// For reading only.
40	143k	const char SStream_rbuf(const SStream ss) {
41	143k	assert(ss);
42	143k	return ss->buffer;
43	143k	}
44
45		/// Searches in the stream for the first (from the left) occurrence of @elem and replaces
46		/// it with @repl. It returns the pointer after the replaced character
47		/// or NULL if no character was replaced.
48		///
49		/// It will never replace the final \0 byte in the stream buffer.
50	93.5k	const char SStream_replc(const SStream ss, char elem, char repl) {
51	93.5k	assert(ss);
52	93.5k	char *found = strchr(ss->buffer, elem);
53	93.5k	if (!found \|\| found == ss->buffer + (SSTREAM_BUF_LEN - 1)) {
54	93.5k	return NULL;
55	93.5k	}
56	0	*found = repl;
57	0	found++;
58	0	return found;
59	93.5k	}
60
61		/// Searches in the stream for the first (from the left) occurrence of @chr and replaces
62		/// it with @rstr.
63	35.2k	void SStream_replc_str(SStream ss, char chr, const char rstr) {
64	35.2k	assert(ss && rstr);
65	35.2k	char *found = strchr(ss->buffer, chr);
66	35.2k	if (!found \|\| found == ss->buffer + (SSTREAM_BUF_LEN - 1)) {
67	0	return;
68	0	}
69	35.2k	size_t post_len = strlen(found + 1);
70	35.2k	size_t buf_str_len = strlen(ss->buffer);
71	35.2k	size_t repl_len = strlen(rstr);
72	35.2k	if (repl_len - 1 + buf_str_len >= SSTREAM_BUF_LEN) {
73	0	return;
74	0	}
75	35.2k	memmove(found + repl_len, found + 1, post_len);
76	35.2k	memcpy(found, rstr, repl_len);
77	35.2k	ss->index = strlen(ss->buffer);
78	35.2k	}
79
80		/// Removes the space characters '\t' and ' ' from the beginning of the stream buffer.
81	3.12M	void SStream_trimls(SStream *ss) {
82	3.12M	assert(ss);
83	3.12M	size_t buf_off = 0;
84		/// Remove leading spaces
85	3.17M	while (ss->buffer[buf_off] == ' ' \|\| ss->buffer[buf_off] == '\t') {
86	45.6k	buf_off++;
87	45.6k	}
88	3.12M	if (buf_off > 0) {
89	45.6k	memmove(ss->buffer, ss->buffer + buf_off, SSTREAM_BUF_LEN - buf_off);
90	45.6k	ss->index -= buf_off;
91	45.6k	}
92	3.12M	}
93
94		/// Extract the mnemonic to @mnem_buf and the operand string into @op_str_buf from the stream buffer.
95		/// The mnemonic is everything up until the first ' ' or '\t' character.
96		/// The operand string is everything after the first ' ' or '\t' sequence.
97	3.03M	void SStream_extract_mnem_opstr(const SStream ss, char mnem_buf, size_t mnem_buf_size, char *op_str_buf, size_t op_str_buf_size) {
98	3.03M	assert(ss && mnem_buf && mnem_buf_size > 0 && op_str_buf && op_str_buf_size > 0);
99	3.03M	size_t off = 0;
100		// Copy all non space chars to as mnemonic.
101	17.2M	while (ss->buffer[off] && ss->buffer[off] != ' ' && ss->buffer[off] != '\t') {
102	14.2M	if (off < mnem_buf_size - 1) {
103		// Only copy if there is space left.
104	14.2M	mnem_buf[off] = ss->buffer[off];
105	14.2M	}
106	14.2M	off++;
107	14.2M	}
108	3.03M	if (!ss->buffer[off]) {
109	136k	return;
110	136k	}
111
112		// Iterate until next non space char.
113	2.91M	do {
114	2.91M	off++;
115	2.91M	} while (ss->buffer[off] && (ss->buffer[off] == ' ' \|\| ss->buffer[off] == '\t'));
116
117	2.89M	if (!ss->buffer[off]) {
118	52.8k	return;
119	52.8k	}
120
121		// Copy all follow up characters as op_str
122	2.84M	const char *ss_op_str = ss->buffer + off;
123	2.84M	off = 0;
124	40.3M	while (ss_op_str[off] && off < op_str_buf_size - 1) {
125	37.4M	op_str_buf[off] = ss_op_str[off];
126	37.4M	off++;
127	37.4M	}
128	2.84M	}
129
130		/// Empty the stream @ss to given @file (stdin/stderr).
131		/// @file can be NULL. Then the buffer content is not emitted.
132		void SStream_Flush(SStream ss, FILE file)
133	36.0k	{
134	36.0k	assert(ss);
135	36.0k	if (file) {
136	0	fprintf(file, "%s\n", ss->buffer);
137	0	}
138	36.0k	SStream_Init(ss);
139	36.0k	}
140
141		/**
142		* Open the output stream. Every write attempt is accepted again.
143		*/
144	0	void SStream_Open(SStream *ss) {
145	0	assert(ss);
146	0	ss->is_closed = false;
147	0	}
148
149		/**
150		* Closes the output stream. Every write attempt is ignored.
151		*/
152	0	void SStream_Close(SStream *ss) {
153	0	assert(ss);
154	0	ss->is_closed = true;
155	0	}
156
157		/**
158		* Copy the string \p s to the buffer of \p ss and terminate it with a '\\0' byte.
159		*/
160		void SStream_concat0(SStream ss, const char s)
161	17.6M	{
162	17.6M	#ifndef CAPSTONE_DIET
163	17.6M	assert(ss && s);
164	17.6M	SSTREAM_RETURN_IF_CLOSED(ss);
165	17.6M	if (s[0] == '\0')
166	5.44M	return;
167	12.1M	unsigned int len = (unsigned int) strlen(s);
168
169	12.1M	SSTREAM_OVERFLOW_CHECK(ss, len);
170
171	12.1M	memcpy(ss->buffer + ss->index, s, len);
172	12.1M	ss->index += len;
173	12.1M	ss->buffer[ss->index] = '\0';
174	12.1M	if (ss->markup_stream && ss->prefixed_by_markup) {
175	0	SSTREAM_OVERFLOW_CHECK(ss, 1);
176	0	ss->buffer[ss->index] = '>';
177	0	ss->index += 1;
178	0	ss->buffer[ss->index] = '\0';
179	0	}
180	12.1M	#endif
181	12.1M	}
182
183		/**
184		* Copy the single char \p c to the buffer of \p ss.
185		*/
186		void SStream_concat1(SStream *ss, const char c)
187	1.90M	{
188	1.90M	#ifndef CAPSTONE_DIET
189	1.90M	assert(ss);
190	1.90M	SSTREAM_RETURN_IF_CLOSED(ss);
191	1.90M	if (c == '\0')
192	18.8k	return;
193
194	1.88M	SSTREAM_OVERFLOW_CHECK(ss, 1);
195
196	1.88M	ss->buffer[ss->index] = c;
197	1.88M	ss->index++;
198	1.88M	ss->buffer[ss->index] = '\0';
199	1.88M	if (ss->markup_stream && ss->prefixed_by_markup) {
200	0	SSTREAM_OVERFLOW_CHECK(ss, 1);
201	0	ss->buffer[ss->index] = '>';
202	0	ss->index++;
203	0	}
204	1.88M	#endif
205	1.88M	}
206
207		/**
208		* Copy all strings given to the buffer of \p ss according to formatting \p fmt.
209		*/
210		void SStream_concat(SStream ss, const char fmt, ...)
211	7.84M	{
212	7.84M	#ifndef CAPSTONE_DIET
213	7.84M	assert(ss && fmt);
214	7.84M	SSTREAM_RETURN_IF_CLOSED(ss);
215	7.84M	va_list ap;
216	7.84M	int ret;
217
218	7.84M	va_start(ap, fmt);
219	7.84M	ret = cs_vsnprintf(ss->buffer + ss->index, sizeof(ss->buffer) - (ss->index + 1), fmt, ap);
220	7.84M	va_end(ap);
221	7.84M	ss->index += ret;
222	7.84M	if (ss->markup_stream && ss->prefixed_by_markup) {
223	0	SSTREAM_OVERFLOW_CHECK(ss, 1);
224	0	ss->buffer[ss->index] = '>';
225	0	ss->index += 1;
226	0	}
227	7.84M	#endif
228	7.84M	}
229
230		// print number with prefix #
231		void printInt64Bang(SStream *ss, int64_t val)
232	70.0k	{
233	70.0k	assert(ss);
234	70.0k	if (ss->unsigned_num) {
235	0	printUInt64Bang(ss, val);
236	0	return;
237	0	}
238	70.0k	SSTREAM_RETURN_IF_CLOSED(ss);
239	70.0k	SStream_concat1(ss, '#');
240	70.0k	printInt64(ss, val);
241	70.0k	}
242
243		void printUInt64Bang(SStream *ss, uint64_t val)
244	10.9k	{
245	10.9k	assert(ss);
246	10.9k	SSTREAM_RETURN_IF_CLOSED(ss);
247	10.9k	SStream_concat1(ss, '#');
248	10.9k	printUInt64(ss, val);
249	10.9k	}
250
251		// print number
252		void printInt64(SStream *ss, int64_t val)
253	681k	{
254	681k	assert(ss);
255	681k	if (ss->unsigned_num) {
256	0	printUInt64(ss, val);
257	0	return;
258	0	}
259	681k	SSTREAM_RETURN_IF_CLOSED(ss);
260	681k	if (val >= 0) {
261	625k	if (val > HEX_THRESHOLD)
262	395k	SStream_concat(ss, "0x%"PRIx64, val);
263	230k	else
264	230k	SStream_concat(ss, "%"PRIu64, val);
265	625k	} else {
266	55.5k	if (val < -HEX_THRESHOLD) {
267	51.0k	if (val == INT64_MIN)
268	77	SStream_concat(ss, "-0x%"PRIx64, (uint64_t) INT64_MAX + 1);
269	50.9k	else
270	50.9k	SStream_concat(ss, "-0x%"PRIx64, (uint64_t)-val);
271	51.0k	} else
272	4.57k	SStream_concat(ss, "-%"PRIu64, -val);
273	55.5k	}
274	681k	}
275
276		void printUInt64(SStream *ss, uint64_t val)
277	169k	{
278	169k	assert(ss);
279	169k	SSTREAM_RETURN_IF_CLOSED(ss);
280	169k	if (val > HEX_THRESHOLD)
281	115k	SStream_concat(ss, "0x%"PRIx64, val);
282	54.3k	else
283	54.3k	SStream_concat(ss, "%"PRIu64, val);
284	169k	}
285
286		// print number in decimal mode
287		void printInt32BangDec(SStream *ss, int32_t val)
288		{
289		assert(ss);
290		SSTREAM_RETURN_IF_CLOSED(ss);
291		if (val >= 0)
292		SStream_concat(ss, "#%" PRIu32, val);
293		else {
294		if (val == INT32_MIN)
295		SStream_concat(ss, "#-%" PRIu32, val);
296		else
297		SStream_concat(ss, "#-%" PRIu32, (uint32_t)-val);
298		}
299		}
300
301		void printInt32Bang(SStream *ss, int32_t val)
302	169k	{
303	169k	assert(ss);
304	169k	if (ss->unsigned_num) {
305	0	printUInt32Bang(ss, val);
306	0	return;
307	0	}
308	169k	SSTREAM_RETURN_IF_CLOSED(ss);
309	169k	SStream_concat1(ss, '#');
310	169k	printInt32(ss, val);
311	169k	}
312
313		void printUInt8(SStream *ss, uint8_t val)
314	0	{
315	0	assert(ss);
316	0	if (val > HEX_THRESHOLD)
317	0	SStream_concat(ss, "0x%"PRIx8, val);
318	0	else
319	0	SStream_concat(ss, "%"PRIu8, val);
320	0	}
321
322		void printUInt16(SStream *ss, uint16_t val)
323	0	{
324	0	assert(ss);
325	0	if (val > HEX_THRESHOLD)
326	0	SStream_concat(ss, "0x%"PRIx16, val);
327	0	else
328	0	SStream_concat(ss, "%"PRIu16, val);
329	0	}
330
331		void printInt8(SStream *ss, int8_t val)
332	1.12k	{
333	1.12k	assert(ss);
334	1.12k	if (ss->unsigned_num) {
335	0	printUInt8(ss, val);
336	0	return;
337	0	}
338	1.12k	SSTREAM_RETURN_IF_CLOSED(ss);
339	1.12k	if (val >= 0) {
340	694	if (val > HEX_THRESHOLD)
341	418	SStream_concat(ss, "0x%" PRIx8, val);
342	276	else
343	276	SStream_concat(ss, "%" PRId8, val);
344	694	} else {
345	432	if (val < -HEX_THRESHOLD) {
346	170	if (val == INT8_MIN)
347	29	SStream_concat(ss, "-0x%" PRIx8, (uint8_t) INT8_MAX + 1);
348	141	else
349	141	SStream_concat(ss, "-0x%" PRIx8, (int8_t)-val);
350	170	} else
351	262	SStream_concat(ss, "-%" PRIu8, -val);
352	432	}
353	1.12k	}
354
355		void printInt16(SStream *ss, int16_t val)
356	2.24k	{
357	2.24k	assert(ss);
358	2.24k	if (ss->unsigned_num) {
359	0	printUInt16(ss, val);
360	0	return;
361	0	}
362	2.24k	SSTREAM_RETURN_IF_CLOSED(ss);
363	2.24k	if (val >= 0) {
364	1.58k	if (val > HEX_THRESHOLD)
365	730	SStream_concat(ss, "0x%" PRIx16, val);
366	856	else
367	856	SStream_concat(ss, "%" PRId16, val);
368	1.58k	} else {
369	663	if (val < -HEX_THRESHOLD) {
370	436	if (val == INT16_MIN)
371	17	SStream_concat(ss, "-0x%" PRIx16, (uint16_t) INT16_MAX + 1);
372	419	else
373	419	SStream_concat(ss, "-0x%" PRIx16, (int16_t)-val);
374	436	} else
375	227	SStream_concat(ss, "-%" PRIu16, -val);
376	663	}
377	2.24k	}
378
379		void printInt16HexOffset(SStream *ss, int16_t val)
380	6.93k	{
381	6.93k	assert(ss);
382	6.93k	if (ss->unsigned_num) {
383	0	printUInt16(ss, val);
384	0	return;
385	0	}
386	6.93k	SSTREAM_RETURN_IF_CLOSED(ss);
387	6.93k	if (val >= 0) {
388	5.13k	SStream_concat(ss, "+0x%" PRIx16, val);
389	5.13k	} else {
390	1.80k	if (val == INT16_MIN)
391	22	SStream_concat(ss, "-0x%" PRIx16,
392	22	(uint16_t)INT16_MAX + 1);
393	1.77k	else
394	1.77k	SStream_concat(ss, "-0x%" PRIx16, (int16_t)-val);
395	1.80k	}
396	6.93k	}
397
398
399		void printInt32(SStream *ss, int32_t val)
400	233k	{
401	233k	assert(ss);
402	233k	if (ss->unsigned_num) {
403	0	printUInt32(ss, val);
404	0	return;
405	0	}
406	233k	SSTREAM_RETURN_IF_CLOSED(ss);
407	233k	if (val >= 0) {
408	173k	if (val > HEX_THRESHOLD)
409	102k	SStream_concat(ss, "0x%" PRIx32, val);
410	71.2k	else
411	71.2k	SStream_concat(ss, "%" PRId32, val);
412	173k	} else {
413	59.9k	if (val < -HEX_THRESHOLD) {
414	55.6k	if (val == INT32_MIN)
415	100	SStream_concat(ss, "-0x%" PRIx32, (uint32_t) INT32_MAX + 1);
416	55.5k	else
417	55.5k	SStream_concat(ss, "-0x%" PRIx32, (int32_t)-val);
418	55.6k	} else {
419	4.26k	SStream_concat(ss, "-%" PRIu32, (uint32_t)-val);
420	4.26k	}
421	59.9k	}
422	233k	}
423
424		void printInt32HexOffset(SStream *ss, int32_t val)
425	1.62k	{
426	1.62k	assert(ss);
427	1.62k	if (ss->unsigned_num) {
428	0	printUInt32(ss, val);
429	0	return;
430	0	}
431	1.62k	SSTREAM_RETURN_IF_CLOSED(ss);
432	1.62k	if (val >= 0) {
433	1.33k	SStream_concat(ss, "+0x%" PRIx32, val);
434	1.33k	} else {
435	289	if (val == INT32_MIN)
436	10	SStream_concat(ss, "-0x%" PRIx32,
437	10	(uint32_t)INT32_MAX + 1);
438	279	else
439	279	SStream_concat(ss, "-0x%" PRIx32, (int32_t)-val);
440	289	}
441	1.62k	}
442
443		void printInt32Hex(SStream *ss, int32_t val)
444	5.11k	{
445	5.11k	assert(ss);
446	5.11k	SSTREAM_RETURN_IF_CLOSED(ss);
447	5.11k	if (val >= 0) {
448	2.78k	SStream_concat(ss, "0x%" PRIx32, val);
449	2.78k	} else {
450	2.33k	if (val == INT32_MIN)
451	481	SStream_concat(ss, "-0x%" PRIx32,
452	481	(uint32_t)INT32_MAX + 1);
453	1.85k	else
454	1.85k	SStream_concat(ss, "-0x%" PRIx32, (int32_t)-val);
455	2.33k	}
456	5.11k	}
457
458		void printUInt32Bang(SStream *ss, uint32_t val)
459	207k	{
460	207k	assert(ss);
461	207k	SSTREAM_RETURN_IF_CLOSED(ss);
462	207k	SStream_concat1(ss, '#');
463	207k	printUInt32(ss, val);
464	207k	}
465
466		void printUInt32(SStream *ss, uint32_t val)
467	290k	{
468	290k	assert(ss);
469	290k	SSTREAM_RETURN_IF_CLOSED(ss);
470	290k	if (val > HEX_THRESHOLD)
471	221k	SStream_concat(ss, "0x%x", val);
472	68.8k	else
473	68.8k	SStream_concat(ss, "%u", val);
474	290k	}
475
476		void printFloat(SStream *ss, float val)
477	0	{
478	0	assert(ss);
479	0	SSTREAM_RETURN_IF_CLOSED(ss);
480	0	SStream_concat(ss, "%e", val);
481	0	}
482
483		void printFloatBang(SStream *ss, float val)
484	439	{
485	439	assert(ss);
486	439	SSTREAM_RETURN_IF_CLOSED(ss);
487	439	SStream_concat(ss, "#%e", val);
488	439	}
489
490		void printExpr(SStream *ss, uint64_t val)
491	0	{
492	0	assert(ss);
493	0	SSTREAM_RETURN_IF_CLOSED(ss);
494	0	SStream_concat(ss, "%"PRIu64, val);
495	0	}
496
497	525k	SStream markup_OS(SStream OS, SStreamMarkup style) {
498	525k	assert(OS);
499
500	525k	if (OS->is_closed \|\| !OS->markup_stream) {
501	525k	return OS;
502	525k	}
503	0	OS->markup_stream = false; // Disable temporarily.
504	0	switch (style) {
505	0	default:
506	0	SStream_concat0(OS, "<UNKNOWN:");
507	0	return OS;
508	0	case Markup_Immediate:
509	0	SStream_concat0(OS, "<imm:");
510	0	break;
511	0	case Markup_Register:
512	0	SStream_concat0(OS, "<reg:");
513	0	break;
514	0	case Markup_Target:
515	0	SStream_concat0(OS, "<tar:");
516	0	break;
517	0	case Markup_Memory:
518	0	SStream_concat0(OS, "<mem:");
519	0	break;
520	0	}
521	0	OS->markup_stream = true;
522	0	OS->prefixed_by_markup = true;
523	0	return OS;
524	0	}