2014-04-29 03:21:04 +00:00
|
|
|
/* Capstone Disassembly Engine */
|
2019-02-26 07:19:51 +00:00
|
|
|
/* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2019 */
|
2013-11-27 04:11:31 +00:00
|
|
|
|
|
|
|
#include <stdarg.h>
|
2015-04-09 17:28:19 +00:00
|
|
|
#if defined(CAPSTONE_HAS_OSXKERNEL)
|
2018-06-14 21:12:26 +00:00
|
|
|
#include <Availability.h>
|
2015-04-09 17:28:19 +00:00
|
|
|
#include <libkern/libkern.h>
|
2018-06-13 21:59:39 +00:00
|
|
|
#include <i386/limits.h>
|
2015-04-09 17:28:19 +00:00
|
|
|
#else
|
2013-11-27 04:11:31 +00:00
|
|
|
#include <stdio.h>
|
2018-06-13 21:59:39 +00:00
|
|
|
#include <limits.h>
|
2015-04-09 17:28:19 +00:00
|
|
|
#endif
|
2014-06-04 10:31:02 +00:00
|
|
|
#include <string.h>
|
2013-11-27 04:11:31 +00:00
|
|
|
|
2016-05-12 04:48:32 +00:00
|
|
|
#include <capstone/platform.h>
|
2016-04-26 01:47:30 +00:00
|
|
|
|
2013-11-27 04:11:31 +00:00
|
|
|
#include "SStream.h"
|
2014-01-15 12:44:03 +00:00
|
|
|
#include "cs_priv.h"
|
2014-08-25 08:47:12 +00:00
|
|
|
#include "utils.h"
|
2013-11-27 04:11:31 +00:00
|
|
|
|
|
|
|
void SStream_Init(SStream *ss)
|
|
|
|
{
|
2023-09-05 04:24:59 +00:00
|
|
|
assert(ss);
|
2013-11-27 04:11:31 +00:00
|
|
|
ss->index = 0;
|
2024-09-18 13:19:42 +00:00
|
|
|
memset(ss->buffer, 0, sizeof(ss->buffer));
|
2023-09-05 04:24:59 +00:00
|
|
|
ss->is_closed = false;
|
2024-09-14 08:57:54 +00:00
|
|
|
ss->markup_stream = false;
|
|
|
|
ss->prefixed_by_markup = false;
|
|
|
|
}
|
|
|
|
|
2024-09-18 13:19:42 +00:00
|
|
|
/// 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++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-09-14 08:57:54 +00:00
|
|
|
/// 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);
|
2023-09-05 04:24:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 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;
|
2013-11-27 04:11:31 +00:00
|
|
|
}
|
|
|
|
|
2023-07-19 09:56:27 +00:00
|
|
|
/**
|
|
|
|
* Copy the string \p s to the buffer of \p ss and terminate it with a '\\0' byte.
|
|
|
|
*/
|
2017-10-22 00:45:40 +00:00
|
|
|
void SStream_concat0(SStream *ss, const char *s)
|
2014-06-04 10:31:02 +00:00
|
|
|
{
|
|
|
|
#ifndef CAPSTONE_DIET
|
2023-09-05 04:24:59 +00:00
|
|
|
SSTREAM_RETURN_IF_CLOSED(ss);
|
2023-07-19 09:56:27 +00:00
|
|
|
if (s[0] == '\0')
|
|
|
|
return;
|
2014-10-22 07:21:43 +00:00
|
|
|
unsigned int len = (unsigned int) strlen(s);
|
2014-10-02 02:17:55 +00:00
|
|
|
|
2024-09-14 08:57:54 +00:00
|
|
|
SSTREAM_OVERFLOW_CHECK(ss, len);
|
|
|
|
|
2014-10-02 02:17:55 +00:00
|
|
|
memcpy(ss->buffer + ss->index, s, len);
|
|
|
|
ss->index += len;
|
|
|
|
ss->buffer[ss->index] = '\0';
|
2024-09-14 08:57:54 +00:00
|
|
|
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';
|
|
|
|
}
|
2014-06-04 10:31:02 +00:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2023-07-19 09:56:27 +00:00
|
|
|
/**
|
|
|
|
* Copy the single char \p c to the buffer of \p ss.
|
|
|
|
*/
|
2019-04-10 06:17:08 +00:00
|
|
|
void SStream_concat1(SStream *ss, const char c)
|
|
|
|
{
|
|
|
|
#ifndef CAPSTONE_DIET
|
2023-09-05 04:24:59 +00:00
|
|
|
SSTREAM_RETURN_IF_CLOSED(ss);
|
2023-07-19 09:56:27 +00:00
|
|
|
if (c == '\0')
|
|
|
|
return;
|
2024-09-14 08:57:54 +00:00
|
|
|
|
|
|
|
SSTREAM_OVERFLOW_CHECK(ss, 1);
|
|
|
|
|
2019-04-10 06:17:08 +00:00
|
|
|
ss->buffer[ss->index] = c;
|
|
|
|
ss->index++;
|
|
|
|
ss->buffer[ss->index] = '\0';
|
2024-09-14 08:57:54 +00:00
|
|
|
if (ss->markup_stream && ss->prefixed_by_markup) {
|
|
|
|
SSTREAM_OVERFLOW_CHECK(ss, 1);
|
|
|
|
ss->buffer[ss->index] = '>';
|
|
|
|
ss->index++;
|
|
|
|
}
|
2019-04-10 06:17:08 +00:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2023-07-19 09:56:27 +00:00
|
|
|
/**
|
|
|
|
* Copy all strings given to the buffer of \p ss according to formatting \p fmt.
|
|
|
|
*/
|
2013-11-27 04:11:31 +00:00
|
|
|
void SStream_concat(SStream *ss, const char *fmt, ...)
|
|
|
|
{
|
2014-02-22 15:26:27 +00:00
|
|
|
#ifndef CAPSTONE_DIET
|
2023-09-05 04:24:59 +00:00
|
|
|
SSTREAM_RETURN_IF_CLOSED(ss);
|
2013-11-27 04:11:31 +00:00
|
|
|
va_list ap;
|
2014-05-12 05:41:49 +00:00
|
|
|
int ret;
|
|
|
|
|
2013-11-27 04:11:31 +00:00
|
|
|
va_start(ap, fmt);
|
2014-05-08 22:44:49 +00:00
|
|
|
ret = cs_vsnprintf(ss->buffer + ss->index, sizeof(ss->buffer) - (ss->index + 1), fmt, ap);
|
2013-11-27 04:11:31 +00:00
|
|
|
va_end(ap);
|
|
|
|
ss->index += ret;
|
2024-09-14 08:57:54 +00:00
|
|
|
if (ss->markup_stream && ss->prefixed_by_markup) {
|
|
|
|
SSTREAM_OVERFLOW_CHECK(ss, 1);
|
|
|
|
ss->buffer[ss->index] = '>';
|
|
|
|
ss->index += 1;
|
|
|
|
}
|
2014-02-22 15:26:27 +00:00
|
|
|
#endif
|
2013-11-27 04:11:31 +00:00
|
|
|
}
|
|
|
|
|
2014-08-25 08:47:12 +00:00
|
|
|
// print number with prefix #
|
|
|
|
void printInt64Bang(SStream *O, int64_t val)
|
|
|
|
{
|
2023-09-05 04:24:59 +00:00
|
|
|
SSTREAM_RETURN_IF_CLOSED(O);
|
2024-09-14 08:57:54 +00:00
|
|
|
SStream_concat1(O, '#');
|
|
|
|
printInt64(O, val);
|
2014-08-25 08:47:12 +00:00
|
|
|
}
|
|
|
|
|
2014-12-12 14:06:06 +00:00
|
|
|
void printUInt64Bang(SStream *O, uint64_t val)
|
|
|
|
{
|
2023-09-05 04:24:59 +00:00
|
|
|
SSTREAM_RETURN_IF_CLOSED(O);
|
2024-09-14 08:57:54 +00:00
|
|
|
SStream_concat1(O, '#');
|
|
|
|
printUInt64(O, val);
|
2014-12-12 14:06:06 +00:00
|
|
|
}
|
|
|
|
|
2014-08-25 08:47:12 +00:00
|
|
|
// print number
|
|
|
|
void printInt64(SStream *O, int64_t val)
|
|
|
|
{
|
2023-09-05 04:24:59 +00:00
|
|
|
SSTREAM_RETURN_IF_CLOSED(O);
|
2014-08-25 08:47:12 +00:00
|
|
|
if (val >= 0) {
|
|
|
|
if (val > HEX_THRESHOLD)
|
|
|
|
SStream_concat(O, "0x%"PRIx64, val);
|
|
|
|
else
|
|
|
|
SStream_concat(O, "%"PRIu64, val);
|
|
|
|
} else {
|
2024-09-14 08:57:54 +00:00
|
|
|
if (val < -HEX_THRESHOLD) {
|
|
|
|
if (val == INT64_MIN)
|
|
|
|
SStream_concat(O, "-0x%"PRIx64, (uint64_t) INT64_MAX + 1);
|
2018-06-02 14:20:13 +00:00
|
|
|
else
|
2018-06-02 08:55:05 +00:00
|
|
|
SStream_concat(O, "-0x%"PRIx64, (uint64_t)-val);
|
2019-02-01 15:03:47 +00:00
|
|
|
} else
|
2014-08-25 08:47:12 +00:00
|
|
|
SStream_concat(O, "-%"PRIu64, -val);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-04-30 05:50:42 +00:00
|
|
|
void printUInt64(SStream *O, uint64_t val)
|
|
|
|
{
|
2023-09-05 04:24:59 +00:00
|
|
|
SSTREAM_RETURN_IF_CLOSED(O);
|
2019-04-30 05:50:42 +00:00
|
|
|
if (val > HEX_THRESHOLD)
|
|
|
|
SStream_concat(O, "0x%"PRIx64, val);
|
|
|
|
else
|
|
|
|
SStream_concat(O, "%"PRIu64, val);
|
|
|
|
}
|
|
|
|
|
2014-11-08 05:58:50 +00:00
|
|
|
// print number in decimal mode
|
|
|
|
void printInt32BangDec(SStream *O, int32_t val)
|
|
|
|
{
|
2023-09-05 04:24:59 +00:00
|
|
|
SSTREAM_RETURN_IF_CLOSED(O);
|
2014-11-08 05:58:50 +00:00
|
|
|
if (val >= 0)
|
2024-09-14 08:57:54 +00:00
|
|
|
SStream_concat(O, "#%" PRIu32, val);
|
2019-02-01 15:03:47 +00:00
|
|
|
else {
|
2024-09-14 08:57:54 +00:00
|
|
|
if (val == INT32_MIN)
|
|
|
|
SStream_concat(O, "#-%" PRIu32, val);
|
2018-06-02 14:20:13 +00:00
|
|
|
else
|
2024-09-14 08:57:54 +00:00
|
|
|
SStream_concat(O, "#-%" PRIu32, (uint32_t)-val);
|
2019-02-01 15:03:47 +00:00
|
|
|
}
|
2014-11-08 05:58:50 +00:00
|
|
|
}
|
|
|
|
|
2014-08-25 08:47:12 +00:00
|
|
|
void printInt32Bang(SStream *O, int32_t val)
|
2024-09-14 08:57:54 +00:00
|
|
|
{
|
|
|
|
SSTREAM_RETURN_IF_CLOSED(O);
|
|
|
|
SStream_concat1(O, '#');
|
|
|
|
printInt32(O, val);
|
|
|
|
}
|
|
|
|
|
|
|
|
void printInt8(SStream *O, int8_t val)
|
2014-08-25 08:47:12 +00:00
|
|
|
{
|
2023-09-05 04:24:59 +00:00
|
|
|
SSTREAM_RETURN_IF_CLOSED(O);
|
2014-08-25 08:47:12 +00:00
|
|
|
if (val >= 0) {
|
|
|
|
if (val > HEX_THRESHOLD)
|
2024-09-14 08:57:54 +00:00
|
|
|
SStream_concat(O, "0x%" PRIx8, val);
|
2014-08-25 08:47:12 +00:00
|
|
|
else
|
2024-09-14 08:57:54 +00:00
|
|
|
SStream_concat(O, "%" PRId8, val);
|
2014-08-25 08:47:12 +00:00
|
|
|
} else {
|
2024-09-14 08:57:54 +00:00
|
|
|
if (val < -HEX_THRESHOLD) {
|
|
|
|
if (val == INT8_MIN)
|
|
|
|
SStream_concat(O, "-0x%" PRIx8, (uint8_t) INT8_MAX + 1);
|
2018-06-02 14:20:13 +00:00
|
|
|
else
|
2024-09-14 08:57:54 +00:00
|
|
|
SStream_concat(O, "-0x%" PRIx8, (int8_t)-val);
|
2019-02-01 15:03:47 +00:00
|
|
|
} else
|
2024-09-14 08:57:54 +00:00
|
|
|
SStream_concat(O, "-%" PRIu8, -val);
|
2014-08-25 08:47:12 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-09-14 08:57:54 +00:00
|
|
|
void printInt16(SStream *O, int16_t val)
|
2014-08-25 08:47:12 +00:00
|
|
|
{
|
2023-09-05 04:24:59 +00:00
|
|
|
SSTREAM_RETURN_IF_CLOSED(O);
|
2014-08-25 08:47:12 +00:00
|
|
|
if (val >= 0) {
|
|
|
|
if (val > HEX_THRESHOLD)
|
2024-09-14 08:57:54 +00:00
|
|
|
SStream_concat(O, "0x%" PRIx16, val);
|
2014-08-25 08:47:12 +00:00
|
|
|
else
|
2024-09-14 08:57:54 +00:00
|
|
|
SStream_concat(O, "%" PRId16, val);
|
2014-08-25 08:47:12 +00:00
|
|
|
} else {
|
2024-09-14 08:57:54 +00:00
|
|
|
if (val < -HEX_THRESHOLD) {
|
|
|
|
if (val == INT16_MIN)
|
|
|
|
SStream_concat(O, "-0x%" PRIx16, (uint16_t) INT16_MAX + 1);
|
2018-06-02 14:20:13 +00:00
|
|
|
else
|
2024-09-14 08:57:54 +00:00
|
|
|
SStream_concat(O, "-0x%" PRIx16, (int16_t)-val);
|
2019-02-01 15:03:47 +00:00
|
|
|
} else
|
2024-09-14 08:57:54 +00:00
|
|
|
SStream_concat(O, "-%" PRIu16, -val);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void printInt32(SStream *O, int32_t val)
|
|
|
|
{
|
|
|
|
SSTREAM_RETURN_IF_CLOSED(O);
|
|
|
|
if (val >= 0) {
|
|
|
|
if (val > HEX_THRESHOLD)
|
|
|
|
SStream_concat(O, "0x%" PRIx32, val);
|
|
|
|
else
|
|
|
|
SStream_concat(O, "%" PRId32, val);
|
|
|
|
} else {
|
|
|
|
if (val < -HEX_THRESHOLD) {
|
|
|
|
SStream_concat(O, "-0x%" PRIx32, (uint32_t)-val);
|
|
|
|
} else {
|
|
|
|
SStream_concat(O, "-%" PRIu32, (uint32_t)-val);
|
|
|
|
}
|
2014-08-25 08:47:12 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void printUInt32Bang(SStream *O, uint32_t val)
|
|
|
|
{
|
2023-09-05 04:24:59 +00:00
|
|
|
SSTREAM_RETURN_IF_CLOSED(O);
|
2024-09-14 08:57:54 +00:00
|
|
|
SStream_concat1(O, '#');
|
|
|
|
printUInt32(O, val);
|
2014-08-25 08:47:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void printUInt32(SStream *O, uint32_t val)
|
|
|
|
{
|
2023-09-05 04:24:59 +00:00
|
|
|
SSTREAM_RETURN_IF_CLOSED(O);
|
2014-08-25 08:47:12 +00:00
|
|
|
if (val > HEX_THRESHOLD)
|
|
|
|
SStream_concat(O, "0x%x", val);
|
|
|
|
else
|
|
|
|
SStream_concat(O, "%u", val);
|
|
|
|
}
|
2023-07-19 09:56:27 +00:00
|
|
|
|
|
|
|
void printFloat(SStream *O, float val)
|
|
|
|
{
|
2023-09-05 04:24:59 +00:00
|
|
|
SSTREAM_RETURN_IF_CLOSED(O);
|
2023-07-19 09:56:27 +00:00
|
|
|
SStream_concat(O, "%e", val);
|
|
|
|
}
|
|
|
|
|
|
|
|
void printFloatBang(SStream *O, float val)
|
|
|
|
{
|
2023-09-05 04:24:59 +00:00
|
|
|
SSTREAM_RETURN_IF_CLOSED(O);
|
2023-07-19 09:56:27 +00:00
|
|
|
SStream_concat(O, "#%e", val);
|
|
|
|
}
|
2024-09-14 08:57:54 +00:00
|
|
|
|
|
|
|
void printExpr(SStream *O, uint64_t val)
|
|
|
|
{
|
|
|
|
SSTREAM_RETURN_IF_CLOSED(O);
|
|
|
|
SStream_concat(O, "%"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;
|
|
|
|
}
|