/src/capstonenext/SStream.c

Source
/* 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';
  }
#else
  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++;
  }
#else
  ss->buffer[ss->index] = '\0';
#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;
  }
#else
  ss->buffer[ss->index] = '\0';
#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-10-12 06:32

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