/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"

static size_t SStream_remaining(SStream *ss)
{
  assert(ss);
  if (ss->index >= SSTREAM_BUF_LEN) {
    ss->index = SSTREAM_BUF_LEN - 1;
    ss->buffer[ss->index] = '\0';
    return 0;
  }
  return SSTREAM_BUF_LEN - ss->index - 1;
}

static void SStream_concat_raw(SStream *ss, const char *s, size_t len)
{
  size_t remaining = SStream_remaining(ss);
  if (len > remaining) {
    len = remaining;
  }
  if (len > 0) {
    memcpy(ss->buffer + ss->index, s, len);
    ss->index += len;
  }
  ss->buffer[ss->index] = '\0';
}

static void SStream_concat1_raw(SStream *ss, char c)
{
  if (SStream_remaining(ss) == 0) {
    return;
  }
  ss->buffer[ss->index] = c;
  ss->index++;
  ss->buffer[ss->index] = '\0';
}

static void SStream_close_markup(SStream *ss)
{
  if (ss->markup_stream && ss->prefixed_by_markup) {
    SStream_concat1_raw(ss, '>');
  }
}

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;

  SStream_concat_raw(ss, s, strlen(s));
  SStream_close_markup(ss);
#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_concat1_raw(ss, c);
  SStream_close_markup(ss);
#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;
  size_t remaining = SStream_remaining(ss);
  if (remaining == 0) {
    return;
  }

  va_start(ap, fmt);
  ret = cs_vsnprintf(ss->buffer + ss->index, remaining + 1, fmt, ap);
  va_end(ap);
  if (ret < 0) {
    ss->buffer[ss->index] = '\0';
    return;
  }
  if ((size_t)ret > remaining) {
    ss->index += remaining;
  } else {
    ss->index += (size_t)ret;
  }
  SStream_close_markup(ss);
#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 printfFloat(SStream *ss, const char *fmt, float val)
{
  assert(ss);
  SSTREAM_RETURN_IF_CLOSED(ss);
  SStream_concat(ss, fmt, 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: 2026-07-16 06:55

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