/src/jq/src/jv_print.c

Source
#include <assert.h>
#include <stdio.h>
#include <float.h>
#include <string.h>

#ifdef WIN32
#include <windows.h>
#include <io.h>
#include <fileapi.h>
#endif

#include "jv.h"
#include "jv_dtoa.h"
#include "jv_dtoa_tsd.h"
#include "jv_unicode.h"
#include "jv_alloc.h"
#include "jv_private.h"
#include "util.h"

#ifndef MAX_PRINT_DEPTH
#define MAX_PRINT_DEPTH (10000)
#endif

#define ESC "\033"
#define COL(c) (ESC "[" c "m")
#define COLRESET (ESC "[0m")

// Color table. See https://en.wikipedia.org/wiki/ANSI_escape_code#Colors
// for how to choose these. The order is same as jv_kind definition, and
// the last color is used for object keys.
#define DEFAULT_COLORS \
  {COL("0;90"),    COL("0;39"),      COL("0;39"),     COL("0;39"),\
   COL("0;32"),    COL("1;39"),      COL("1;39"),     COL("1;34")};
static const char *const default_colors[] = DEFAULT_COLORS;
static const char *colors[] = DEFAULT_COLORS;
#define COLORS_LEN (sizeof(colors) / sizeof(colors[0]))
#define FIELD_COLOR (colors[7])

static char *colors_buf = NULL;
int jq_set_colors(const char *code_str) {
  if (code_str == NULL)
    return 1;

  // the start of each color code in the env var, and the byte after the end of the last one
  const char *codes[COLORS_LEN + 1];
  size_t num_colors;
  // must be initialized before `goto default_colors`, used later to loop over every color
  size_t ci = 0;

  for (num_colors = 0;; num_colors++) {
    codes[num_colors] = code_str;
    code_str += strspn(code_str, "0123456789;");
    if (code_str[0] == '\0' || num_colors + 1 >= COLORS_LEN) {
      break;
    } else if (code_str[0] != ':') {
      return 0; // invalid character
    }
    code_str++;
  }
  if (codes[num_colors] != code_str) {
    // count the last color and store its end (plus one byte for consistency with starts)
    // an empty last color would be ignored (for cases like "" and "0:")
    num_colors++;
    codes[num_colors] = code_str + 1;
  } else if (num_colors == 0) {
    if (colors_buf != NULL) {
      jv_mem_free(colors_buf);
      colors_buf = NULL;
    }
    goto default_colors;
  }

  colors_buf = jv_mem_realloc(
    colors_buf,
    // add ESC '[' 'm' to each string
    // '\0' is already included in difference of codes
    codes[num_colors] - codes[0] + 3 * num_colors
  );
  char *cb = colors_buf;
  for (; ci < num_colors; ci++) {
    colors[ci] = cb;
    size_t len = codes[ci + 1] - 1 - codes[ci];

    cb[0] = ESC[0];
    cb[1] = '[';
    memcpy(cb + 2, codes[ci], len);
    cb[2 + len] = 'm';
    cb[3 + len] = '\0';

    cb += len + 4;
  }
  default_colors:
  for (; ci < COLORS_LEN; ci++)
    colors[ci] = default_colors[ci];
  return 1;
}

static void put_buf(const char *s, int len, FILE *fout, jv *strout, int is_tty) {
  if (strout) {
    *strout = jv_string_append_buf(*strout, s, len);
  } else {
#ifdef WIN32
  /* See util.h */
  if (is_tty) {
    wchar_t *ws;
    size_t wl;
    if (len == -1)
      len = strlen(s);
    wl = MultiByteToWideChar(CP_UTF8, 0, s, len, NULL, 0);
    ws = jv_mem_calloc(wl + 1, sizeof(*ws));
    if (!ws)
      return;
    wl = MultiByteToWideChar(CP_UTF8, 0, s, len, ws, wl + 1);
    ws[wl] = 0;
    WriteConsoleW((HANDLE)_get_osfhandle(fileno(fout)), ws, wl, NULL, NULL);
    free(ws);
  } else
    fwrite(s, 1, len, fout);
#else
  fwrite(s, 1, len, fout);
#endif
  }
}

static void put_char(char c, FILE* fout, jv* strout, int T) {
  put_buf(&c, 1, fout, strout, T);
}

static void put_str(const char* s, FILE* fout, jv* strout, int T) {
  put_buf(s, strlen(s), fout, strout, T);
}

static void put_indent(int n, int flags, FILE* fout, jv* strout, int T) {
  if (flags & JV_PRINT_TAB) {
    while (n--)
      put_char('\t', fout, strout, T);
  } else {
    n *= ((flags & (JV_PRINT_SPACE0 | JV_PRINT_SPACE1 | JV_PRINT_SPACE2)) >> 8);
    while (n--)
      put_char(' ', fout, strout, T);
  }
}

static void jvp_dump_string(jv str, int ascii_only, FILE* F, jv* S, int T) {
  assert(jv_get_kind(str) == JV_KIND_STRING);
  const char* i = jv_string_value(str);
  const char* end = i + jv_string_length_bytes(jv_copy(str));
  const char* cstart;
  int c = 0;
  char buf[32];
  put_char('"', F, S, T);
  while ((i = jvp_utf8_next((cstart = i), end, &c))) {
    assert(c != -1);
    int unicode_escape = 0;
    if (0x20 <= c && c <= 0x7E) {
      // printable ASCII
      if (c == '"' || c == '\\') {
        put_char('\\', F, S, T);
      }
      put_char(c, F, S, T);
    } else if (c < 0x20 || c == 0x7F) {
      // ASCII control character
      switch (c) {
      case '\b':
        put_char('\\', F, S, T);
        put_char('b', F, S, T);
        break;
      case '\t':
        put_char('\\', F, S, T);
        put_char('t', F, S, T);
        break;
      case '\r':
        put_char('\\', F, S, T);
        put_char('r', F, S, T);
        break;
      case '\n':
        put_char('\\', F, S, T);
        put_char('n', F, S, T);
        break;
      case '\f':
        put_char('\\', F, S, T);
        put_char('f', F, S, T);
        break;
      default:
        unicode_escape = 1;
        break;
      }
    } else {
      if (ascii_only) {
        unicode_escape = 1;
      } else {
        put_buf(cstart, i - cstart, F, S, T);
      }
    }
    if (unicode_escape) {
      if (c <= 0xffff) {
        snprintf(buf, sizeof(buf), "\\u%04x", c);
      } else {
        c -= 0x10000;
        snprintf(buf, sizeof(buf), "\\u%04x\\u%04x",
                0xD800 | ((c & 0xffc00) >> 10),
                0xDC00 | (c & 0x003ff));
      }
      put_str(buf, F, S, T);
    }
  }
  assert(c != -1);
  put_char('"', F, S, T);
}

static void put_refcnt(struct dtoa_context* C, int refcnt, FILE *F, jv* S, int T){
  char buf[JVP_DTOA_FMT_MAX_LEN];
  put_char(' ', F, S, T);
  put_char('(', F, S, T);
  put_str(jvp_dtoa_fmt(C, buf, refcnt), F, S, T);
  put_char(')', F, S, T);
}

static void jv_dump_term(struct dtoa_context* C, jv x, int flags, int indent, FILE* F, jv* S) {
  char buf[JVP_DTOA_FMT_MAX_LEN];
  const char* color = 0;
  double refcnt = (flags & JV_PRINT_REFCOUNT) ? jv_get_refcnt(x) - 1 : -1;
  if ((flags & JV_PRINT_COLOR) && jv_get_kind(x) != JV_KIND_INVALID) {
    color = colors[(int)jv_get_kind(x) - 1];
    put_str(color, F, S, flags & JV_PRINT_ISATTY);
  }
  if (indent > MAX_PRINT_DEPTH) {
    put_str("<skipped: too deep>", F, S, flags & JV_PRINT_ISATTY);
  } else switch (jv_get_kind(x)) {
  default:
  case JV_KIND_INVALID:
    if (flags & JV_PRINT_INVALID) {
      jv msg = jv_invalid_get_msg(jv_copy(x));
      if (jv_get_kind(msg) == JV_KIND_STRING) {
        put_str("<invalid:", F, S, flags & JV_PRINT_ISATTY);
        jvp_dump_string(msg, flags | JV_PRINT_ASCII, F, S, flags & JV_PRINT_ISATTY);
        put_char('>', F, S, flags & JV_PRINT_ISATTY);
      } else {
        put_str("<invalid>", F, S, flags & JV_PRINT_ISATTY);
      }
    } else {
      assert(0 && "Invalid value");
    }
    break;
  case JV_KIND_NULL:
    put_str("null", F, S, flags & JV_PRINT_ISATTY);
    break;
  case JV_KIND_FALSE:
    put_str("false", F, S, flags & JV_PRINT_ISATTY);
    break;
  case JV_KIND_TRUE:
    put_str("true", F, S, flags & JV_PRINT_ISATTY);
    break;
  case JV_KIND_NUMBER: {
    if (jvp_number_is_nan(x)) {
      jv_dump_term(C, jv_null(), flags, indent, F, S);
    } else {
#ifdef USE_DECNUM
      const char * literal_data = jv_number_get_literal(x);
      if (literal_data) {
        put_str(literal_data, F, S, flags & JV_PRINT_ISATTY);
      } else {
#endif
        double d = jv_number_value(x);
        if (d != d) {
          // JSON doesn't have NaN, so we'll render it as "null"
          put_str("null", F, S, flags & JV_PRINT_ISATTY);
        } else {
          // Normalise infinities to something we can print in valid JSON
          if (d > DBL_MAX) d = DBL_MAX;
          if (d < -DBL_MAX) d = -DBL_MAX;
          put_str(jvp_dtoa_fmt(C, buf, d), F, S, flags & JV_PRINT_ISATTY);
        }
      }
#ifdef USE_DECNUM
    }
#endif
    break;
  }
  case JV_KIND_STRING:
    jvp_dump_string(x, flags & JV_PRINT_ASCII, F, S, flags & JV_PRINT_ISATTY);
    if (flags & JV_PRINT_REFCOUNT)
      put_refcnt(C, refcnt, F, S, flags & JV_PRINT_ISATTY);
    break;
  case JV_KIND_ARRAY: {
    if (jv_array_length(jv_copy(x)) == 0) {
      put_str("[]", F, S, flags & JV_PRINT_ISATTY);
      break;
    }
    put_char('[', F, S, flags & JV_PRINT_ISATTY);
    jv_array_foreach(x, i, elem) {
      if (i!=0) {
        if (color) put_str(color, F, S, flags & JV_PRINT_ISATTY);
        put_char(',', F, S, flags & JV_PRINT_ISATTY);
      }
      if (color) put_str(COLRESET, F, S, flags & JV_PRINT_ISATTY);
      if (flags & JV_PRINT_PRETTY) {
        put_char('\n', F, S, flags & JV_PRINT_ISATTY);
        put_indent(indent + 1, flags, F, S, flags & JV_PRINT_ISATTY);
      }
      jv_dump_term(C, elem, flags, indent + 1, F, S);
    }
    if (flags & JV_PRINT_PRETTY) {
      put_char('\n', F, S, flags & JV_PRINT_ISATTY);
      put_indent(indent, flags, F, S, flags & JV_PRINT_ISATTY);
    }
    if (color) put_str(color, F, S, flags & JV_PRINT_ISATTY);
    put_char(']', F, S, flags & JV_PRINT_ISATTY);
    if (flags & JV_PRINT_REFCOUNT)
      put_refcnt(C, refcnt, F, S, flags & JV_PRINT_ISATTY);
    break;
  }
  case JV_KIND_OBJECT: {
    if (jv_object_length(jv_copy(x)) == 0) {
      put_str("{}", F, S, flags & JV_PRINT_ISATTY);
      break;
    }
    put_char('{', F, S, flags & JV_PRINT_ISATTY);
    int first = 1;
    int i = 0;
    jv keyset = jv_null();
    while (1) {
      jv key, value;
      if (flags & JV_PRINT_SORTED) {
        if (first) {
          keyset = jv_keys(jv_copy(x));
          i = 0;
        } else {
          i++;
        }
        if (i >= jv_array_length(jv_copy(keyset))) {
          jv_free(keyset);
          break;
        }
        key = jv_array_get(jv_copy(keyset), i);
        value = jv_object_get(jv_copy(x), jv_copy(key));
      } else {
        if (first) {
          i = jv_object_iter(x);
        } else {
          i = jv_object_iter_next(x, i);
        }
        if (!jv_object_iter_valid(x, i)) break;
        key = jv_object_iter_key(x, i);
        value = jv_object_iter_value(x, i);
      }

      if (!first) {
        if (color) put_str(color, F, S, flags & JV_PRINT_ISATTY);
        put_char(',', F, S, flags & JV_PRINT_ISATTY);
      }
      if (color) put_str(COLRESET, F, S, flags & JV_PRINT_ISATTY);
      if (flags & JV_PRINT_PRETTY) {
        put_char('\n', F, S, flags & JV_PRINT_ISATTY);
        put_indent(indent + 1, flags, F, S, flags & JV_PRINT_ISATTY);
      }

      first = 0;
      if (color) put_str(FIELD_COLOR, F, S, flags & JV_PRINT_ISATTY);
      jvp_dump_string(key, flags & JV_PRINT_ASCII, F, S, flags & JV_PRINT_ISATTY);
      jv_free(key);
      if (color) put_str(COLRESET, F, S, flags & JV_PRINT_ISATTY);

      if (color) put_str(color, F, S, flags & JV_PRINT_ISATTY);
      put_char(':', F, S, flags & JV_PRINT_ISATTY);
      if (color) put_str(COLRESET, F, S, flags & JV_PRINT_ISATTY);
      if (flags & JV_PRINT_PRETTY) {
        put_char(' ', F, S, flags & JV_PRINT_ISATTY);
      }

      jv_dump_term(C, value, flags, indent + 1, F, S);
    }
    if (flags & JV_PRINT_PRETTY) {
      put_char('\n', F, S, flags & JV_PRINT_ISATTY);
      put_indent(indent, flags, F, S, flags & JV_PRINT_ISATTY);
    }
    if (color) put_str(color, F, S, flags & JV_PRINT_ISATTY);
    put_char('}', F, S, flags & JV_PRINT_ISATTY);
    if (flags & JV_PRINT_REFCOUNT)
      put_refcnt(C, refcnt, F, S, flags & JV_PRINT_ISATTY);
  }
  }
  jv_free(x);
  if (color) {
    put_str(COLRESET, F, S, flags & JV_PRINT_ISATTY);
  }
}

void jv_dumpf(jv x, FILE *f, int flags) {
  jv_dump_term(tsd_dtoa_context_get(), x, flags, 0, f, 0);
}

void jv_dump(jv x, int flags) {
  jv_dumpf(x, stdout, flags);
}

/* This one is nice for use in debuggers */
void jv_show(jv x, int flags) {
  if (flags == -1)
    flags = JV_PRINT_PRETTY | JV_PRINT_COLOR | JV_PRINT_INDENT_FLAGS(2);
  jv_dumpf(jv_copy(x), stderr, flags | JV_PRINT_INVALID);
  fflush(stderr);
}

jv jv_dump_string(jv x, int flags) {
  jv s = jv_string("");
  jv_dump_term(tsd_dtoa_context_get(), x, flags, 0, 0, &s);
  return s;
}

char *jv_dump_string_trunc(jv x, char *outbuf, size_t bufsize) {
  assert(bufsize > 0);
  x = jv_dump_string(x, 0);
  const char *str = jv_string_value(x);
  const size_t len = strlen(str);
  if (len > bufsize - 1 && bufsize >= 8) {
    char delim = 0;
    switch (str[0]) {
    case '"': delim = '"'; break;
    case '[': delim = ']'; break;
    case '{': delim = '}'; break;
    }
    size_t l = bufsize - (delim ? 5 : 4);  // "...", delim (if any), '\0'
    const char *s = jvp_utf8_backtrack(str + l, str, NULL);
    if (s) l = s - str;
    memcpy(outbuf, str, l);
    outbuf[l++] = '.';
    outbuf[l++] = '.';
    outbuf[l++] = '.';
    if (delim) outbuf[l++] = delim;
    outbuf[l] = '\0';
  } else {
    size_t l = MIN(len, bufsize - 1);
    memcpy(outbuf, str, l);
    outbuf[l] = '\0';
  }
  jv_free(x);
  return outbuf;
}

Coverage Report

Created: 2026-02-26 06:47

Line	Count	Source
1		#include <assert.h>
2		#include <stdio.h>
3		#include <float.h>
4		#include <string.h>
5
6		#ifdef WIN32
7		#include <windows.h>
8		#include <io.h>
9		#include <fileapi.h>
10		#endif
11
12		#include "jv.h"
13		#include "jv_dtoa.h"
14		#include "jv_dtoa_tsd.h"
15		#include "jv_unicode.h"
16		#include "jv_alloc.h"
17		#include "jv_private.h"
18		#include "util.h"
19
20		#ifndef MAX_PRINT_DEPTH
21	8.79M	#define MAX_PRINT_DEPTH (10000)
22		#endif
23
24	3.28M	#define ESC "\033"
25		#define COL(c) (ESC "[" c "m")
26	3.28M	#define COLRESET (ESC "[0m")
27
28		// Color table. See https://en.wikipedia.org/wiki/ANSI_escape_code#Colors
29		// for how to choose these. The order is same as jv_kind definition, and
30		// the last color is used for object keys.
31		#define DEFAULT_COLORS \
32		{COL("0;90"), COL("0;39"), COL("0;39"), COL("0;39"),\
33		COL("0;32"), COL("1;39"), COL("1;39"), COL("1;34")};
34		static const char *const default_colors[] = DEFAULT_COLORS;
35		static const char *colors[] = DEFAULT_COLORS;
36	0	#define COLORS_LEN (sizeof(colors) / sizeof(colors[0]))
37	2.28k	#define FIELD_COLOR (colors[7])
38
39		static char *colors_buf = NULL;
40	0	int jq_set_colors(const char *code_str) {
41	0	if (code_str == NULL)
42	0	return 1;
43
44		// the start of each color code in the env var, and the byte after the end of the last one
45	0	const char *codes[COLORS_LEN + 1];
46	0	size_t num_colors;
47		// must be initialized before `goto default_colors`, used later to loop over every color
48	0	size_t ci = 0;
49
50	0	for (num_colors = 0;; num_colors++) {
51	0	codes[num_colors] = code_str;
52	0	code_str += strspn(code_str, "0123456789;");
53	0	if (code_str[0] == '\0' \|\| num_colors + 1 >= COLORS_LEN) {
54	0	break;
55	0	} else if (code_str[0] != ':') {
56	0	return 0; // invalid character
57	0	}
58	0	code_str++;
59	0	}
60	0	if (codes[num_colors] != code_str) {
61		// count the last color and store its end (plus one byte for consistency with starts)
62		// an empty last color would be ignored (for cases like "" and "0:")
63	0	num_colors++;
64	0	codes[num_colors] = code_str + 1;
65	0	} else if (num_colors == 0) {
66	0	if (colors_buf != NULL) {
67	0	jv_mem_free(colors_buf);
68	0	colors_buf = NULL;
69	0	}
70	0	goto default_colors;
71	0	}
72
73	0	colors_buf = jv_mem_realloc(
74	0	colors_buf,
75		// add ESC '[' 'm' to each string
76		// '\0' is already included in difference of codes
77	0	codes[num_colors] - codes[0] + 3 * num_colors
78	0	);
79	0	char *cb = colors_buf;
80	0	for (; ci < num_colors; ci++) {
81	0	colors[ci] = cb;
82	0	size_t len = codes[ci + 1] - 1 - codes[ci];
83
84	0	cb[0] = ESC[0];
85	0	cb[1] = '[';
86	0	memcpy(cb + 2, codes[ci], len);
87	0	cb[2 + len] = 'm';
88	0	cb[3 + len] = '\0';
89
90	0	cb += len + 4;
91	0	}
92	0	default_colors:
93	0	for (; ci < COLORS_LEN; ci++)
94	0	colors[ci] = default_colors[ci];
95	0	return 1;
96	0	}
97
98	1.04G	static void put_buf(const char s, int len, FILE fout, jv *strout, int is_tty) {
99	1.04G	if (strout) {
100	235M	strout = jv_string_append_buf(strout, s, len);
101	805M	} else {
102		#ifdef WIN32
103		/* See util.h */
104		if (is_tty) {
105		wchar_t *ws;
106		size_t wl;
107		if (len == -1)
108		len = strlen(s);
109		wl = MultiByteToWideChar(CP_UTF8, 0, s, len, NULL, 0);
110		ws = jv_mem_calloc(wl + 1, sizeof(*ws));
111		if (!ws)
112		return;
113		wl = MultiByteToWideChar(CP_UTF8, 0, s, len, ws, wl + 1);
114		ws[wl] = 0;
115		WriteConsoleW((HANDLE)_get_osfhandle(fileno(fout)), ws, wl, NULL, NULL);
116		free(ws);
117		} else
118		fwrite(s, 1, len, fout);
119		#else
120	805M	fwrite(s, 1, len, fout);
121	805M	#endif
122	805M	}
123	1.04G	}
124
125	950M	static void put_char(char c, FILE* fout, jv* strout, int T) {
126	950M	put_buf(&c, 1, fout, strout, T);
127	950M	}
128
129	26.9M	static void put_str(const char* s, FILE* fout, jv* strout, int T) {
130	26.9M	put_buf(s, strlen(s), fout, strout, T);
131	26.9M	}
132
133	4.63M	static void put_indent(int n, int flags, FILE* fout, jv* strout, int T) {
134	4.63M	if (flags & JV_PRINT_TAB) {
135	437M	while (n--)
136	433M	put_char('\t', fout, strout, T);
137	4.02M	} else {
138	602k	n *= ((flags & (JV_PRINT_SPACE0 \| JV_PRINT_SPACE1 \| JV_PRINT_SPACE2)) >> 8);
139	343M	while (n--)
140	343M	put_char(' ', fout, strout, T);
141	602k	}
142	4.63M	}
143
144	521k	static void jvp_dump_string(jv str, int ascii_only, FILE* F, jv* S, int T) {
145	521k	assert(jv_get_kind(str) == JV_KIND_STRING);
146	521k	const char* i = jv_string_value(str);
147	521k	const char* end = i + jv_string_length_bytes(jv_copy(str));
148	521k	const char* cstart;
149	521k	int c = 0;
150	521k	char buf[32];
151	521k	put_char('"', F, S, T);
152	229M	while ((i = jvp_utf8_next((cstart = i), end, &c))) {
153	228M	assert(c != -1);
154	228M	int unicode_escape = 0;
155	228M	if (0x20 <= c && c <= 0x7E) {
156		// printable ASCII
157	153M	if (c == '"' \|\| c == '\\') {
158	6.69M	put_char('\\', F, S, T);
159	6.69M	}
160	153M	put_char(c, F, S, T);
161	153M	} else if (c < 0x20 \|\| c == 0x7F) {
162		// ASCII control character
163	10.1M	switch (c) {
164	1.64k	case '\b':
165	1.64k	put_char('\\', F, S, T);
166	1.64k	put_char('b', F, S, T);
167	1.64k	break;
168	34.5k	case '\t':
169	34.5k	put_char('\\', F, S, T);
170	34.5k	put_char('t', F, S, T);
171	34.5k	break;
172	4.28k	case '\r':
173	4.28k	put_char('\\', F, S, T);
174	4.28k	put_char('r', F, S, T);
175	4.28k	break;
176	7.46k	case '\n':
177	7.46k	put_char('\\', F, S, T);
178	7.46k	put_char('n', F, S, T);
179	7.46k	break;
180	1.25k	case '\f':
181	1.25k	put_char('\\', F, S, T);
182	1.25k	put_char('f', F, S, T);
183	1.25k	break;
184	10.1M	default:
185	10.1M	unicode_escape = 1;
186	10.1M	break;
187	10.1M	}
188	64.8M	} else {
189	64.8M	if (ascii_only) {
190	2.15M	unicode_escape = 1;
191	62.6M	} else {
192	62.6M	put_buf(cstart, i - cstart, F, S, T);
193	62.6M	}
194	64.8M	}
195	228M	if (unicode_escape) {
196	12.2M	if (c <= 0xffff) {
197	12.2M	snprintf(buf, sizeof(buf), "\\u%04x", c);
198	12.2M	} else {
199	508	c -= 0x10000;
200	508	snprintf(buf, sizeof(buf), "\\u%04x\\u%04x",
201	508	0xD800 \| ((c & 0xffc00) >> 10),
202	508	0xDC00 \| (c & 0x003ff));
203	508	}
204	12.2M	put_str(buf, F, S, T);
205	12.2M	}
206	228M	}
207	521k	assert(c != -1);
208	521k	put_char('"', F, S, T);
209	521k	}
210
211	13.7k	static void put_refcnt(struct dtoa_context* C, int refcnt, FILE F, jv S, int T){
212	13.7k	char buf[JVP_DTOA_FMT_MAX_LEN];
213	13.7k	put_char(' ', F, S, T);
214	13.7k	put_char('(', F, S, T);
215	13.7k	put_str(jvp_dtoa_fmt(C, buf, refcnt), F, S, T);
216	13.7k	put_char(')', F, S, T);
217	13.7k	}
218
219	8.79M	static void jv_dump_term(struct dtoa_context* C, jv x, int flags, int indent, FILE* F, jv* S) {
220	8.79M	char buf[JVP_DTOA_FMT_MAX_LEN];
221	8.79M	const char* color = 0;
222	8.79M	double refcnt = (flags & JV_PRINT_REFCOUNT) ? jv_get_refcnt(x) - 1 : -1;
223	8.79M	if ((flags & JV_PRINT_COLOR) && jv_get_kind(x) != JV_KIND_INVALID) {
224	1.63M	color = colors[(int)jv_get_kind(x) - 1];
225	1.63M	put_str(color, F, S, flags & JV_PRINT_ISATTY);
226	1.63M	}
227	8.79M	if (indent > MAX_PRINT_DEPTH) {
228	0	put_str("<skipped: too deep>", F, S, flags & JV_PRINT_ISATTY);
229	8.79M	} else switch (jv_get_kind(x)) {
230	0	default:
231	0	case JV_KIND_INVALID:
232	0	if (flags & JV_PRINT_INVALID) {
233	0	jv msg = jv_invalid_get_msg(jv_copy(x));
234	0	if (jv_get_kind(msg) == JV_KIND_STRING) {
235	0	put_str("<invalid:", F, S, flags & JV_PRINT_ISATTY);
236	0	jvp_dump_string(msg, flags \| JV_PRINT_ASCII, F, S, flags & JV_PRINT_ISATTY);
237	0	put_char('>', F, S, flags & JV_PRINT_ISATTY);
238	0	} else {
239	0	put_str("<invalid>", F, S, flags & JV_PRINT_ISATTY);
240	0	}
241	0	} else {
242	0	assert(0 && "Invalid value");
243	0	}
244	0	break;
245	8.77k	case JV_KIND_NULL:
246	8.77k	put_str("null", F, S, flags & JV_PRINT_ISATTY);
247	8.77k	break;
248	146k	case JV_KIND_FALSE:
249	146k	put_str("false", F, S, flags & JV_PRINT_ISATTY);
250	146k	break;
251	75.4k	case JV_KIND_TRUE:
252	75.4k	put_str("true", F, S, flags & JV_PRINT_ISATTY);
253	75.4k	break;
254	7.84M	case JV_KIND_NUMBER: {
255	7.84M	if (jvp_number_is_nan(x)) {
256	1.30k	jv_dump_term(C, jv_null(), flags, indent, F, S);
257	7.84M	} else {
258	7.84M	#ifdef USE_DECNUM
259	7.84M	const char * literal_data = jv_number_get_literal(x);
260	7.84M	if (literal_data) {
261	1.54M	put_str(literal_data, F, S, flags & JV_PRINT_ISATTY);
262	6.29M	} else {
263	6.29M	#endif
264	6.29M	double d = jv_number_value(x);
265	6.29M	if (d != d) {
266		// JSON doesn't have NaN, so we'll render it as "null"
267	0	put_str("null", F, S, flags & JV_PRINT_ISATTY);
268	6.29M	} else {
269		// Normalise infinities to something we can print in valid JSON
270	6.29M	if (d > DBL_MAX) d = DBL_MAX;
271	6.29M	if (d < -DBL_MAX) d = -DBL_MAX;
272	6.29M	put_str(jvp_dtoa_fmt(C, buf, d), F, S, flags & JV_PRINT_ISATTY);
273	6.29M	}
274	6.29M	}
275	7.84M	#ifdef USE_DECNUM
276	7.84M	}
277	7.84M	#endif
278	7.84M	break;
279	0	}
280	498k	case JV_KIND_STRING:
281	498k	jvp_dump_string(x, flags & JV_PRINT_ASCII, F, S, flags & JV_PRINT_ISATTY);
282	498k	if (flags & JV_PRINT_REFCOUNT)
283	760	put_refcnt(C, refcnt, F, S, flags & JV_PRINT_ISATTY);
284	498k	break;
285	199k	case JV_KIND_ARRAY: {
286	199k	if (jv_array_length(jv_copy(x)) == 0) {
287	11.9k	put_str("[]", F, S, flags & JV_PRINT_ISATTY);
288	11.9k	break;
289	11.9k	}
290	187k	put_char('[', F, S, flags & JV_PRINT_ISATTY);
291	7.59M	jv_array_foreach(x, i, elem) {
292	7.59M	if (i!=0) {
293	7.40M	if (color) put_str(color, F, S, flags & JV_PRINT_ISATTY);
294	7.40M	put_char(',', F, S, flags & JV_PRINT_ISATTY);
295	7.40M	}
296	7.59M	if (color) put_str(COLRESET, F, S, flags & JV_PRINT_ISATTY);
297	7.59M	if (flags & JV_PRINT_PRETTY) {
298	4.52M	put_char('\n', F, S, flags & JV_PRINT_ISATTY);
299	4.52M	put_indent(indent + 1, flags, F, S, flags & JV_PRINT_ISATTY);
300	4.52M	}
301	7.59M	jv_dump_term(C, elem, flags, indent + 1, F, S);
302	7.59M	}
303	187k	if (flags & JV_PRINT_PRETTY) {
304	101k	put_char('\n', F, S, flags & JV_PRINT_ISATTY);
305	101k	put_indent(indent, flags, F, S, flags & JV_PRINT_ISATTY);
306	101k	}
307	187k	if (color) put_str(color, F, S, flags & JV_PRINT_ISATTY);
308	187k	put_char(']', F, S, flags & JV_PRINT_ISATTY);
309	187k	if (flags & JV_PRINT_REFCOUNT)
310	12.2k	put_refcnt(C, refcnt, F, S, flags & JV_PRINT_ISATTY);
311	187k	break;
312	199k	}
313	18.5k	case JV_KIND_OBJECT: {
314	18.5k	if (jv_object_length(jv_copy(x)) == 0) {
315	7.98k	put_str("{}", F, S, flags & JV_PRINT_ISATTY);
316	7.98k	break;
317	7.98k	}
318	10.5k	put_char('{', F, S, flags & JV_PRINT_ISATTY);
319	10.5k	int first = 1;
320	10.5k	int i = 0;
321	10.5k	jv keyset = jv_null();
322	33.2k	while (1) {
323	33.2k	jv key, value;
324	33.2k	if (flags & JV_PRINT_SORTED) {
325	3.72k	if (first) {
326	933	keyset = jv_keys(jv_copy(x));
327	933	i = 0;
328	2.79k	} else {
329	2.79k	i++;
330	2.79k	}
331	3.72k	if (i >= jv_array_length(jv_copy(keyset))) {
332	933	jv_free(keyset);
333	933	break;
334	933	}
335	2.79k	key = jv_array_get(jv_copy(keyset), i);
336	2.79k	value = jv_object_get(jv_copy(x), jv_copy(key));
337	29.5k	} else {
338	29.5k	if (first) {
339	9.63k	i = jv_object_iter(x);
340	19.9k	} else {
341	19.9k	i = jv_object_iter_next(x, i);
342	19.9k	}
343	29.5k	if (!jv_object_iter_valid(x, i)) break;
344	19.9k	key = jv_object_iter_key(x, i);
345	19.9k	value = jv_object_iter_value(x, i);
346	19.9k	}
347
348	22.6k	if (!first) {
349	12.1k	if (color) put_str(color, F, S, flags & JV_PRINT_ISATTY);
350	12.1k	put_char(',', F, S, flags & JV_PRINT_ISATTY);
351	12.1k	}
352	22.6k	if (color) put_str(COLRESET, F, S, flags & JV_PRINT_ISATTY);
353	22.6k	if (flags & JV_PRINT_PRETTY) {
354	2.72k	put_char('\n', F, S, flags & JV_PRINT_ISATTY);
355	2.72k	put_indent(indent + 1, flags, F, S, flags & JV_PRINT_ISATTY);
356	2.72k	}
357
358	22.6k	first = 0;
359	22.6k	if (color) put_str(FIELD_COLOR, F, S, flags & JV_PRINT_ISATTY);
360	22.6k	jvp_dump_string(key, flags & JV_PRINT_ASCII, F, S, flags & JV_PRINT_ISATTY);
361	22.6k	jv_free(key);
362	22.6k	if (color) put_str(COLRESET, F, S, flags & JV_PRINT_ISATTY);
363
364	22.6k	if (color) put_str(color, F, S, flags & JV_PRINT_ISATTY);
365	22.6k	put_char(':', F, S, flags & JV_PRINT_ISATTY);
366	22.6k	if (color) put_str(COLRESET, F, S, flags & JV_PRINT_ISATTY);
367	22.6k	if (flags & JV_PRINT_PRETTY) {
368	2.72k	put_char(' ', F, S, flags & JV_PRINT_ISATTY);
369	2.72k	}
370
371	22.6k	jv_dump_term(C, value, flags, indent + 1, F, S);
372	22.6k	}
373	10.5k	if (flags & JV_PRINT_PRETTY) {
374	825	put_char('\n', F, S, flags & JV_PRINT_ISATTY);
375	825	put_indent(indent, flags, F, S, flags & JV_PRINT_ISATTY);
376	825	}
377	10.5k	if (color) put_str(color, F, S, flags & JV_PRINT_ISATTY);
378	10.5k	put_char('}', F, S, flags & JV_PRINT_ISATTY);
379	10.5k	if (flags & JV_PRINT_REFCOUNT)
380	715	put_refcnt(C, refcnt, F, S, flags & JV_PRINT_ISATTY);
381	10.5k	}
382	8.79M	}
383	8.79M	jv_free(x);
384	8.79M	if (color) {
385	1.63M	put_str(COLRESET, F, S, flags & JV_PRINT_ISATTY);
386	1.63M	}
387	8.79M	}
388
389	9.26k	void jv_dumpf(jv x, FILE *f, int flags) {
390	9.26k	jv_dump_term(tsd_dtoa_context_get(), x, flags, 0, f, 0);
391	9.26k	}
392
393	9.26k	void jv_dump(jv x, int flags) {
394	9.26k	jv_dumpf(x, stdout, flags);
395	9.26k	}
396
397		/* This one is nice for use in debuggers */
398		void jv_show(jv x, int flags) {
399		if (flags == -1)
400		flags = JV_PRINT_PRETTY \| JV_PRINT_COLOR \| JV_PRINT_INDENT_FLAGS(2);
401		jv_dumpf(jv_copy(x), stderr, flags \| JV_PRINT_INVALID);
402		fflush(stderr);
403		}
404
405	1.16M	jv jv_dump_string(jv x, int flags) {
406	1.16M	jv s = jv_string("");
407	1.16M	jv_dump_term(tsd_dtoa_context_get(), x, flags, 0, 0, &s);
408	1.16M	return s;
409	1.16M	}
410
411	661k	char jv_dump_string_trunc(jv x, char outbuf, size_t bufsize) {
412	661k	assert(bufsize > 0);
413	661k	x = jv_dump_string(x, 0);
414	661k	const char *str = jv_string_value(x);
415	661k	const size_t len = strlen(str);
416	661k	if (len > bufsize - 1 && bufsize >= 8) {
417	440k	char delim = 0;
418	440k	switch (str[0]) {
419	435k	case '"': delim = '"'; break;
420	2.00k	case '[': delim = ']'; break;
421	1.99k	case '{': delim = '}'; break;
422	440k	}
423	440k	size_t l = bufsize - (delim ? 5 : 4); // "...", delim (if any), '\0'
424	440k	const char *s = jvp_utf8_backtrack(str + l, str, NULL);
425	440k	if (s) l = s - str;
426	440k	memcpy(outbuf, str, l);
427	440k	outbuf[l++] = '.';
428	440k	outbuf[l++] = '.';
429	440k	outbuf[l++] = '.';
430	440k	if (delim) outbuf[l++] = delim;
431	440k	outbuf[l] = '\0';
432	440k	} else {
433	221k	size_t l = MIN(len, bufsize - 1);
434	221k	memcpy(outbuf, str, l);
435	221k	outbuf[l] = '\0';
436	221k	}
437	661k	jv_free(x);
438	661k	return outbuf;
439	661k	}