/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-08-28 06:43

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.24M	{
23	3.24M	assert(ss);
24	3.24M	ss->index = 0;
25	3.24M	memset(ss->buffer, 0, sizeof(ss->buffer));
26	3.24M	ss->is_closed = false;
27	3.24M	ss->markup_stream = false;
28	3.24M	ss->prefixed_by_markup = false;
29	3.24M	ss->unsigned_num = false;
30	3.24M	}
31
32		void SStream_opt_unum(SStream *ss, bool print_unsigned_numbers)
33	3.14M	{
34	3.14M	assert(ss);
35	3.14M	ss->unsigned_num = print_unsigned_numbers;
36	3.14M	}
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	128k	{
42	128k	assert(ss);
43	128k	return ss->buffer;
44	128k	}
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	107k	{
53	107k	assert(ss);
54	107k	char *found = strchr(ss->buffer, elem);
55	107k	if (!found \|\| found == ss->buffer + (SSTREAM_BUF_LEN - 1)) {
56	107k	return NULL;
57	107k	}
58	0	*found = repl;
59	0	found++;
60	0	return found;
61	107k	}
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	31.8k	{
67	31.8k	assert(ss && rstr);
68	31.8k	char *found = strchr(ss->buffer, chr);
69	31.8k	if (!found \|\| found == ss->buffer + (SSTREAM_BUF_LEN - 1)) {
70	0	return;
71	0	}
72	31.8k	size_t post_len = strlen(found + 1);
73	31.8k	size_t buf_str_len = strlen(ss->buffer);
74	31.8k	size_t repl_len = strlen(rstr);
75	31.8k	if (repl_len - 1 + buf_str_len >= SSTREAM_BUF_LEN) {
76	0	return;
77	0	}
78	31.8k	memmove(found + repl_len, found + 1, post_len);
79	31.8k	memcpy(found, rstr, repl_len);
80	31.8k	ss->index = strlen(ss->buffer);
81	31.8k	}
82
83		/// Removes the space characters '\t' and ' ' from the beginning of the stream buffer.
84		void SStream_trimls(SStream *ss)
85	3.25M	{
86	3.25M	assert(ss);
87	3.25M	size_t buf_off = 0;
88		/// Remove leading spaces
89	3.31M	while (ss->buffer[buf_off] == ' ' \|\| ss->buffer[buf_off] == '\t') {
90	59.7k	buf_off++;
91	59.7k	}
92	3.25M	if (buf_off > 0) {
93	59.7k	memmove(ss->buffer, ss->buffer + buf_off,
94	59.7k	SSTREAM_BUF_LEN - buf_off);
95	59.7k	ss->index -= buf_off;
96	59.7k	}
97	3.25M	}
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	3.14M	{
106	3.14M	assert(ss && mnem_buf && mnem_buf_size > 0 && op_str_buf &&
107	3.14M	op_str_buf_size > 0);
108	3.14M	size_t off = 0;
109		// Copy all non space chars to as mnemonic.
110	18.1M	while (ss->buffer[off] && ss->buffer[off] != ' ' &&
111	18.1M	ss->buffer[off] != '\t') {
112	14.9M	if (off < mnem_buf_size - 1) {
113		// Only copy if there is space left.
114	14.9M	mnem_buf[off] = ss->buffer[off];
115	14.9M	}
116	14.9M	off++;
117	14.9M	}
118	3.14M	if (!ss->buffer[off]) {
119	133k	return;
120	133k	}
121
122		// Iterate until next non space char.
123	3.03M	do {
124	3.03M	off++;
125	3.03M	} while (ss->buffer[off] &&
126	3.03M	(ss->buffer[off] == ' ' \|\| ss->buffer[off] == '\t'));
127
128	3.01M	if (!ss->buffer[off]) {
129	39.6k	return;
130	39.6k	}
131
132		// Copy all follow up characters as op_str
133	2.97M	const char *ss_op_str = ss->buffer + off;
134	2.97M	off = 0;
135	43.6M	while (ss_op_str[off] && off < op_str_buf_size - 1) {
136	40.6M	op_str_buf[off] = ss_op_str[off];
137	40.6M	off++;
138	40.6M	}
139	2.97M	}
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	32.3k	{
145	32.3k	assert(ss);
146	32.3k	if (file) {
147	0	fprintf(file, "%s\n", ss->buffer);
148	0	}
149	32.3k	SStream_Init(ss);
150	32.3k	}
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	18.8M	{
175	18.8M	#ifndef CAPSTONE_DIET
176	18.8M	assert(ss && s);
177	18.8M	SSTREAM_RETURN_IF_CLOSED(ss);
178	18.8M	if (s[0] == '\0')
179	5.80M	return;
180	13.0M	unsigned int len = (unsigned int)strlen(s);
181
182	13.0M	SSTREAM_OVERFLOW_CHECK(ss, len);
183
184	13.0M	memcpy(ss->buffer + ss->index, s, len);
185	13.0M	ss->index += len;
186	13.0M	ss->buffer[ss->index] = '\0';
187	13.0M	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	13.0M	#endif
194	13.0M	}
195
196		/**
197		* Copy the single char \p c to the buffer of \p ss.
198		*/
199		void SStream_concat1(SStream *ss, const char c)
200	2.22M	{
201	2.22M	#ifndef CAPSTONE_DIET
202	2.22M	assert(ss);
203	2.22M	SSTREAM_RETURN_IF_CLOSED(ss);
204	2.22M	if (c == '\0')
205	26.5k	return;
206
207	2.19M	SSTREAM_OVERFLOW_CHECK(ss, 1);
208
209	2.19M	ss->buffer[ss->index] = c;
210	2.19M	ss->index++;
211	2.19M	ss->buffer[ss->index] = '\0';
212	2.19M	if (ss->markup_stream && ss->prefixed_by_markup) {
213	0	SSTREAM_OVERFLOW_CHECK(ss, 1);
214	0	ss->buffer[ss->index] = '>';
215	0	ss->index++;
216	0	}
217	2.19M	#endif
218	2.19M	}
219
220		/**
221		* Copy all strings given to the buffer of \p ss according to formatting \p fmt.
222		*/
223		void SStream_concat(SStream ss, const char fmt, ...)
224	8.34M	{
225	8.34M	#ifndef CAPSTONE_DIET
226	8.34M	assert(ss && fmt);
227	8.34M	SSTREAM_RETURN_IF_CLOSED(ss);
228	8.34M	va_list ap;
229	8.34M	int ret;
230
231	8.34M	va_start(ap, fmt);
232	8.34M	ret = cs_vsnprintf(ss->buffer + ss->index,
233	8.34M	sizeof(ss->buffer) - (ss->index + 1), fmt, ap);
234	8.34M	va_end(ap);
235	8.34M	ss->index += ret;
236	8.34M	if (ss->markup_stream && ss->prefixed_by_markup) {
237	0	SSTREAM_OVERFLOW_CHECK(ss, 1);
238	0	ss->buffer[ss->index] = '>';
239	0	ss->index += 1;
240	0	}
241	8.34M	#endif
242	8.34M	}
243
244		// print number with prefix #
245		void printInt64Bang(SStream *ss, int64_t val)
246	81.2k	{
247	81.2k	assert(ss);
248	81.2k	if (ss->unsigned_num) {
249	0	printUInt64Bang(ss, val);
250	0	return;
251	0	}
252	81.2k	SSTREAM_RETURN_IF_CLOSED(ss);
253	81.2k	SStream_concat1(ss, '#');
254	81.2k	printInt64(ss, val);
255	81.2k	}
256
257		void printUInt64Bang(SStream *ss, uint64_t val)
258	15.2k	{
259	15.2k	assert(ss);
260	15.2k	SSTREAM_RETURN_IF_CLOSED(ss);
261	15.2k	SStream_concat1(ss, '#');
262	15.2k	printUInt64(ss, val);
263	15.2k	}
264
265		// print number
266		void printInt64(SStream *ss, int64_t val)
267	749k	{
268	749k	assert(ss);
269	749k	if (ss->unsigned_num) {
270	0	printUInt64(ss, val);
271	0	return;
272	0	}
273	749k	SSTREAM_RETURN_IF_CLOSED(ss);
274	749k	if (val >= 0) {
275	689k	if (val > HEX_THRESHOLD)
276	438k	SStream_concat(ss, "0x%" PRIx64, val);
277	251k	else
278	251k	SStream_concat(ss, "%" PRIu64, val);
279	689k	} else {
280	59.4k	if (val < -HEX_THRESHOLD) {
281	54.4k	if (val == INT64_MIN)
282	70	SStream_concat(ss, "-0x%" PRIx64,
283	70	(uint64_t)INT64_MAX + 1);
284	54.3k	else
285	54.3k	SStream_concat(ss, "-0x%" PRIx64,
286	54.3k	(uint64_t)-val);
287	54.4k	} else
288	4.96k	SStream_concat(ss, "-%" PRIu64, -val);
289	59.4k	}
290	749k	}
291
292		void printUInt64(SStream *ss, uint64_t val)
293	194k	{
294	194k	assert(ss);
295	194k	SSTREAM_RETURN_IF_CLOSED(ss);
296	194k	if (val > HEX_THRESHOLD)
297	131k	SStream_concat(ss, "0x%" PRIx64, val);
298	63.0k	else
299	63.0k	SStream_concat(ss, "%" PRIu64, val);
300	194k	}
301
302		// print number in decimal mode
303		void printInt32BangDec(SStream *ss, int32_t val)
304		{
305		assert(ss);
306		SSTREAM_RETURN_IF_CLOSED(ss);
307		if (val >= 0)
308		SStream_concat(ss, "#%" PRIu32, val);
309		else {
310		if (val == INT32_MIN)
311		SStream_concat(ss, "#-%" PRIu32, val);
312		else
313		SStream_concat(ss, "#-%" PRIu32, (uint32_t)-val);
314		}
315		}
316
317		void printInt32Bang(SStream *ss, int32_t val)
318	196k	{
319	196k	assert(ss);
320	196k	if (ss->unsigned_num) {
321	0	printUInt32Bang(ss, val);
322	0	return;
323	0	}
324	196k	SSTREAM_RETURN_IF_CLOSED(ss);
325	196k	SStream_concat1(ss, '#');
326	196k	printInt32(ss, val);
327	196k	}
328
329		void printUInt8(SStream *ss, uint8_t val)
330	0	{
331	0	assert(ss);
332	0	if (val > HEX_THRESHOLD)
333	0	SStream_concat(ss, "0x%" PRIx8, val);
334	0	else
335	0	SStream_concat(ss, "%" PRIu8, val);
336	0	}
337
338		void printUInt16(SStream *ss, uint16_t val)
339	0	{
340	0	assert(ss);
341	0	if (val > HEX_THRESHOLD)
342	0	SStream_concat(ss, "0x%" PRIx16, val);
343	0	else
344	0	SStream_concat(ss, "%" PRIu16, val);
345	0	}
346
347		void printInt8(SStream *ss, int8_t val)
348	1.62k	{
349	1.62k	assert(ss);
350	1.62k	if (ss->unsigned_num) {
351	0	printUInt8(ss, val);
352	0	return;
353	0	}
354	1.62k	SSTREAM_RETURN_IF_CLOSED(ss);
355	1.62k	if (val >= 0) {
356	839	if (val > HEX_THRESHOLD)
357	762	SStream_concat(ss, "0x%" PRIx8, val);
358	77	else
359	77	SStream_concat(ss, "%" PRId8, val);
360	839	} else {
361	789	if (val < -HEX_THRESHOLD) {
362	227	if (val == INT8_MIN)
363	34	SStream_concat(ss, "-0x%" PRIx8,
364	34	(uint8_t)INT8_MAX + 1);
365	193	else
366	193	SStream_concat(ss, "-0x%" PRIx8, (int8_t)-val);
367	227	} else
368	562	SStream_concat(ss, "-%" PRIu8, -val);
369	789	}
370	1.62k	}
371
372		void printInt16(SStream *ss, int16_t val)
373	2.26k	{
374	2.26k	assert(ss);
375	2.26k	if (ss->unsigned_num) {
376	0	printUInt16(ss, val);
377	0	return;
378	0	}
379	2.26k	SSTREAM_RETURN_IF_CLOSED(ss);
380	2.26k	if (val >= 0) {
381	1.39k	if (val > HEX_THRESHOLD)
382	986	SStream_concat(ss, "0x%" PRIx16, val);
383	406	else
384	406	SStream_concat(ss, "%" PRId16, val);
385	1.39k	} else {
386	869	if (val < -HEX_THRESHOLD) {
387	621	if (val == INT16_MIN)
388	115	SStream_concat(ss, "-0x%" PRIx16,
389	115	(uint16_t)INT16_MAX + 1);
390	506	else
391	506	SStream_concat(ss, "-0x%" PRIx16,
392	506	(int16_t)-val);
393	621	} else
394	248	SStream_concat(ss, "-%" PRIu16, -val);
395	869	}
396	2.26k	}
397
398		void printInt16HexOffset(SStream *ss, int16_t val)
399	7.13k	{
400	7.13k	assert(ss);
401	7.13k	if (ss->unsigned_num) {
402	0	printUInt16(ss, val);
403	0	return;
404	0	}
405	7.13k	SSTREAM_RETURN_IF_CLOSED(ss);
406	7.13k	if (val >= 0) {
407	5.22k	SStream_concat(ss, "+0x%" PRIx16, val);
408	5.22k	} else {
409	1.90k	if (val == INT16_MIN)
410	15	SStream_concat(ss, "-0x%" PRIx16,
411	15	(uint16_t)INT16_MAX + 1);
412	1.89k	else
413	1.89k	SStream_concat(ss, "-0x%" PRIx16, (int16_t)-val);
414	1.90k	}
415	7.13k	}
416
417		void printInt32(SStream *ss, int32_t val)
418	269k	{
419	269k	assert(ss);
420	269k	if (ss->unsigned_num) {
421	0	printUInt32(ss, val);
422	0	return;
423	0	}
424	269k	SSTREAM_RETURN_IF_CLOSED(ss);
425	269k	if (val >= 0) {
426	197k	if (val > HEX_THRESHOLD)
427	113k	SStream_concat(ss, "0x%" PRIx32, val);
428	83.5k	else
429	83.5k	SStream_concat(ss, "%" PRId32, val);
430	197k	} else {
431	71.5k	if (val < -HEX_THRESHOLD) {
432	66.7k	if (val == INT32_MIN)
433	71	SStream_concat(ss, "-0x%" PRIx32,
434	71	(uint32_t)INT32_MAX + 1);
435	66.6k	else
436	66.6k	SStream_concat(ss, "-0x%" PRIx32,
437	66.6k	(int32_t)-val);
438	66.7k	} else {
439	4.80k	SStream_concat(ss, "-%" PRIu32, (uint32_t)-val);
440	4.80k	}
441	71.5k	}
442	269k	}
443
444		void printInt32HexOffset(SStream *ss, int32_t val)
445	977	{
446	977	assert(ss);
447	977	if (ss->unsigned_num) {
448	0	printUInt32(ss, val);
449	0	return;
450	0	}
451	977	SSTREAM_RETURN_IF_CLOSED(ss);
452	977	if (val >= 0) {
453	801	SStream_concat(ss, "+0x%" PRIx32, val);
454	801	} else {
455	176	if (val == INT32_MIN)
456	18	SStream_concat(ss, "-0x%" PRIx32,
457	18	(uint32_t)INT32_MAX + 1);
458	158	else
459	158	SStream_concat(ss, "-0x%" PRIx32, (int32_t)-val);
460	176	}
461	977	}
462
463		void printInt32Hex(SStream *ss, int32_t val)
464	5.03k	{
465	5.03k	assert(ss);
466	5.03k	SSTREAM_RETURN_IF_CLOSED(ss);
467	5.03k	if (val >= 0) {
468	3.02k	SStream_concat(ss, "0x%" PRIx32, val);
469	3.02k	} else {
470	2.00k	if (val == INT32_MIN)
471	19	SStream_concat(ss, "-0x%" PRIx32,
472	19	(uint32_t)INT32_MAX + 1);
473	1.98k	else
474	1.98k	SStream_concat(ss, "-0x%" PRIx32, (int32_t)-val);
475	2.00k	}
476	5.03k	}
477
478		void printUInt32Bang(SStream *ss, uint32_t val)
479	200k	{
480	200k	assert(ss);
481	200k	SSTREAM_RETURN_IF_CLOSED(ss);
482	200k	SStream_concat1(ss, '#');
483	200k	printUInt32(ss, val);
484	200k	}
485
486		void printUInt32(SStream *ss, uint32_t val)
487	299k	{
488	299k	assert(ss);
489	299k	SSTREAM_RETURN_IF_CLOSED(ss);
490	299k	if (val > HEX_THRESHOLD)
491	229k	SStream_concat(ss, "0x%x", val);
492	69.7k	else
493	69.7k	SStream_concat(ss, "%u", val);
494	299k	}
495
496		void printFloat(SStream *ss, float val)
497	0	{
498	0	assert(ss);
499	0	SSTREAM_RETURN_IF_CLOSED(ss);
500	0	SStream_concat(ss, "%e", val);
501	0	}
502
503		void printFloatBang(SStream *ss, float val)
504	529	{
505	529	assert(ss);
506	529	SSTREAM_RETURN_IF_CLOSED(ss);
507	529	SStream_concat(ss, "#%e", val);
508	529	}
509
510		void printExpr(SStream *ss, uint64_t val)
511	0	{
512	0	assert(ss);
513	0	SSTREAM_RETURN_IF_CLOSED(ss);
514	0	SStream_concat(ss, "%" PRIu64, val);
515	0	}
516
517		SStream markup_OS(SStream OS, SStreamMarkup style)
518	641k	{
519	641k	assert(OS);
520
521	641k	if (OS->is_closed \|\| !OS->markup_stream) {
522	641k	return OS;
523	641k	}
524	0	OS->markup_stream = false; // Disable temporarily.
525	0	switch (style) {
526	0	default:
527	0	SStream_concat0(OS, "<UNKNOWN:");
528	0	return OS;
529	0	case Markup_Immediate:
530	0	SStream_concat0(OS, "<imm:");
531	0	break;
532	0	case Markup_Register:
533	0	SStream_concat0(OS, "<reg:");
534	0	break;
535	0	case Markup_Target:
536	0	SStream_concat0(OS, "<tar:");
537	0	break;
538	0	case Markup_Memory:
539	0	SStream_concat0(OS, "<mem:");
540	0	break;
541	0	}
542	0	OS->markup_stream = true;
543	0	OS->prefixed_by_markup = true;
544	0	return OS;
545	0	}