Ruby  2.7.1p83(2020-03-31revisiona0c7c23c9cec0d0ffcba012279cd652d28ad5bf3)
generator.c
Go to the documentation of this file.
1 #include "../fbuffer/fbuffer.h"
2 #include "generator.h"
3 
4 #ifdef HAVE_RUBY_ENCODING_H
5 static VALUE CEncoding_UTF_8;
6 static ID i_encoding, i_encode;
7 #endif
8 
9 static VALUE mJSON, mExt, mGenerator, cState, mGeneratorMethods, mObject,
10  mHash, mArray,
11 #ifdef RUBY_INTEGER_UNIFICATION
12  mInteger,
13 #else
14  mFixnum, mBignum,
15 #endif
16  mFloat, mString, mString_Extend,
17  mTrueClass, mFalseClass, mNilClass, eGeneratorError,
18  eNestingError,
19  i_SAFE_STATE_PROTOTYPE;
20 
21 static ID i_to_s, i_to_json, i_new, i_indent, i_space, i_space_before,
22  i_object_nl, i_array_nl, i_max_nesting, i_allow_nan, i_ascii_only,
23  i_pack, i_unpack, i_create_id, i_extend, i_key_p,
24  i_aref, i_send, i_respond_to_p, i_match, i_keys, i_depth,
25  i_buffer_initial_length, i_dup;
26 
27 /*
28  * Copyright 2001-2004 Unicode, Inc.
29  *
30  * Disclaimer
31  *
32  * This source code is provided as is by Unicode, Inc. No claims are
33  * made as to fitness for any particular purpose. No warranties of any
34  * kind are expressed or implied. The recipient agrees to determine
35  * applicability of information provided. If this file has been
36  * purchased on magnetic or optical media from Unicode, Inc., the
37  * sole remedy for any claim will be exchange of defective media
38  * within 90 days of receipt.
39  *
40  * Limitations on Rights to Redistribute This Code
41  *
42  * Unicode, Inc. hereby grants the right to freely use the information
43  * supplied in this file in the creation of products supporting the
44  * Unicode Standard, and to make copies of this file in any form
45  * for internal or external distribution as long as this notice
46  * remains attached.
47  */
48 
49 /*
50  * Index into the table below with the first byte of a UTF-8 sequence to
51  * get the number of trailing bytes that are supposed to follow it.
52  * Note that *legal* UTF-8 values can't have 4 or 5-bytes. The table is
53  * left as-is for anyone who may want to do such conversion, which was
54  * allowed in earlier algorithms.
55  */
56 static const char trailingBytesForUTF8[256] = {
57  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
58  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
59  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
60  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
61  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
62  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
63  1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
64  2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, 3,3,3,3,3,3,3,3,4,4,4,4,5,5,5,5
65 };
66 
67 /*
68  * Magic values subtracted from a buffer value during UTF8 conversion.
69  * This table contains as many values as there might be trailing bytes
70  * in a UTF-8 sequence.
71  */
72 static const UTF32 offsetsFromUTF8[6] = { 0x00000000UL, 0x00003080UL, 0x000E2080UL,
73  0x03C82080UL, 0xFA082080UL, 0x82082080UL };
74 
75 /*
76  * Utility routine to tell whether a sequence of bytes is legal UTF-8.
77  * This must be called with the length pre-determined by the first byte.
78  * If not calling this from ConvertUTF8to*, then the length can be set by:
79  * length = trailingBytesForUTF8[*source]+1;
80  * and the sequence is illegal right away if there aren't that many bytes
81  * available.
82  * If presented with a length > 4, this returns 0. The Unicode
83  * definition of UTF-8 goes up to 4-byte sequences.
84  */
85 static unsigned char isLegalUTF8(const UTF8 *source, unsigned long length)
86 {
87  UTF8 a;
88  const UTF8 *srcptr = source+length;
89  switch (length) {
90  default: return 0;
91  /* Everything else falls through when "1"... */
92  case 4: if ((a = (*--srcptr)) < 0x80 || a > 0xBF) return 0;
93  case 3: if ((a = (*--srcptr)) < 0x80 || a > 0xBF) return 0;
94  case 2: if ((a = (*--srcptr)) > 0xBF) return 0;
95 
96  switch (*source) {
97  /* no fall-through in this inner switch */
98  case 0xE0: if (a < 0xA0) return 0; break;
99  case 0xED: if (a > 0x9F) return 0; break;
100  case 0xF0: if (a < 0x90) return 0; break;
101  case 0xF4: if (a > 0x8F) return 0; break;
102  default: if (a < 0x80) return 0;
103  }
104 
105  case 1: if (*source >= 0x80 && *source < 0xC2) return 0;
106  }
107  if (*source > 0xF4) return 0;
108  return 1;
109 }
110 
111 /* Escapes the UTF16 character and stores the result in the buffer buf. */
112 static void unicode_escape(char *buf, UTF16 character)
113 {
114  const char *digits = "0123456789abcdef";
115 
116  buf[2] = digits[character >> 12];
117  buf[3] = digits[(character >> 8) & 0xf];
118  buf[4] = digits[(character >> 4) & 0xf];
119  buf[5] = digits[character & 0xf];
120 }
121 
122 /* Escapes the UTF16 character and stores the result in the buffer buf, then
123  * the buffer buf is appended to the FBuffer buffer. */
124 static void unicode_escape_to_buffer(FBuffer *buffer, char buf[6], UTF16
125  character)
126 {
127  unicode_escape(buf, character);
128  fbuffer_append(buffer, buf, 6);
129 }
130 
131 /* Converts string to a JSON string in FBuffer buffer, where all but the ASCII
132  * and control characters are JSON escaped. */
133 static void convert_UTF8_to_JSON_ASCII(FBuffer *buffer, VALUE string)
134 {
135  const UTF8 *source = (UTF8 *) RSTRING_PTR(string);
136  const UTF8 *sourceEnd = source + RSTRING_LEN(string);
137  char buf[6] = { '\\', 'u' };
138 
139  while (source < sourceEnd) {
140  UTF32 ch = 0;
141  unsigned short extraBytesToRead = trailingBytesForUTF8[*source];
142  if (source + extraBytesToRead >= sourceEnd) {
143  rb_raise(rb_path2class("JSON::GeneratorError"),
144  "partial character in source, but hit end");
145  }
146  if (!isLegalUTF8(source, extraBytesToRead+1)) {
147  rb_raise(rb_path2class("JSON::GeneratorError"),
148  "source sequence is illegal/malformed utf-8");
149  }
150  /*
151  * The cases all fall through. See "Note A" below.
152  */
153  switch (extraBytesToRead) {
154  case 5: ch += *source++; ch <<= 6; /* remember, illegal UTF-8 */
155  case 4: ch += *source++; ch <<= 6; /* remember, illegal UTF-8 */
156  case 3: ch += *source++; ch <<= 6;
157  case 2: ch += *source++; ch <<= 6;
158  case 1: ch += *source++; ch <<= 6;
159  case 0: ch += *source++;
160  }
161  ch -= offsetsFromUTF8[extraBytesToRead];
162 
163  if (ch <= UNI_MAX_BMP) { /* Target is a character <= 0xFFFF */
164  /* UTF-16 surrogate values are illegal in UTF-32 */
165  if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_LOW_END) {
166 #if UNI_STRICT_CONVERSION
167  source -= (extraBytesToRead+1); /* return to the illegal value itself */
168  rb_raise(rb_path2class("JSON::GeneratorError"),
169  "source sequence is illegal/malformed utf-8");
170 #else
171  unicode_escape_to_buffer(buffer, buf, UNI_REPLACEMENT_CHAR);
172 #endif
173  } else {
174  /* normal case */
175  if (ch >= 0x20 && ch <= 0x7f) {
176  switch (ch) {
177  case '\\':
178  fbuffer_append(buffer, "\\\\", 2);
179  break;
180  case '"':
181  fbuffer_append(buffer, "\\\"", 2);
182  break;
183  default:
184  fbuffer_append_char(buffer, (char)ch);
185  break;
186  }
187  } else {
188  switch (ch) {
189  case '\n':
190  fbuffer_append(buffer, "\\n", 2);
191  break;
192  case '\r':
193  fbuffer_append(buffer, "\\r", 2);
194  break;
195  case '\t':
196  fbuffer_append(buffer, "\\t", 2);
197  break;
198  case '\f':
199  fbuffer_append(buffer, "\\f", 2);
200  break;
201  case '\b':
202  fbuffer_append(buffer, "\\b", 2);
203  break;
204  default:
205  unicode_escape_to_buffer(buffer, buf, (UTF16) ch);
206  break;
207  }
208  }
209  }
210  } else if (ch > UNI_MAX_UTF16) {
211 #if UNI_STRICT_CONVERSION
212  source -= (extraBytesToRead+1); /* return to the start */
213  rb_raise(rb_path2class("JSON::GeneratorError"),
214  "source sequence is illegal/malformed utf8");
215 #else
216  unicode_escape_to_buffer(buffer, buf, UNI_REPLACEMENT_CHAR);
217 #endif
218  } else {
219  /* target is a character in range 0xFFFF - 0x10FFFF. */
220  ch -= halfBase;
221  unicode_escape_to_buffer(buffer, buf, (UTF16)((ch >> halfShift) + UNI_SUR_HIGH_START));
222  unicode_escape_to_buffer(buffer, buf, (UTF16)((ch & halfMask) + UNI_SUR_LOW_START));
223  }
224  }
225  RB_GC_GUARD(string);
226 }
227 
228 /* Converts string to a JSON string in FBuffer buffer, where only the
229  * characters required by the JSON standard are JSON escaped. The remaining
230  * characters (should be UTF8) are just passed through and appended to the
231  * result. */
232 static void convert_UTF8_to_JSON(FBuffer *buffer, VALUE string)
233 {
234  const char *ptr = RSTRING_PTR(string), *p;
235  unsigned long len = RSTRING_LEN(string), start = 0, end = 0;
236  const char *escape = NULL;
237  int escape_len;
238  unsigned char c;
239  char buf[6] = { '\\', 'u' };
240  int ascii_only = rb_enc_str_asciionly_p(string);
241 
242  for (start = 0, end = 0; end < len;) {
243  p = ptr + end;
244  c = (unsigned char) *p;
245  if (c < 0x20) {
246  switch (c) {
247  case '\n':
248  escape = "\\n";
249  escape_len = 2;
250  break;
251  case '\r':
252  escape = "\\r";
253  escape_len = 2;
254  break;
255  case '\t':
256  escape = "\\t";
257  escape_len = 2;
258  break;
259  case '\f':
260  escape = "\\f";
261  escape_len = 2;
262  break;
263  case '\b':
264  escape = "\\b";
265  escape_len = 2;
266  break;
267  default:
268  unicode_escape(buf, (UTF16) *p);
269  escape = buf;
270  escape_len = 6;
271  break;
272  }
273  } else {
274  switch (c) {
275  case '\\':
276  escape = "\\\\";
277  escape_len = 2;
278  break;
279  case '"':
280  escape = "\\\"";
281  escape_len = 2;
282  break;
283  default:
284  {
285  unsigned short clen = 1;
286  if (!ascii_only) {
287  clen += trailingBytesForUTF8[c];
288  if (end + clen > len) {
289  rb_raise(rb_path2class("JSON::GeneratorError"),
290  "partial character in source, but hit end");
291  }
292  if (!isLegalUTF8((UTF8 *) p, clen)) {
293  rb_raise(rb_path2class("JSON::GeneratorError"),
294  "source sequence is illegal/malformed utf-8");
295  }
296  }
297  end += clen;
298  }
299  continue;
300  break;
301  }
302  }
303  fbuffer_append(buffer, ptr + start, end - start);
304  fbuffer_append(buffer, escape, escape_len);
305  start = ++end;
306  escape = NULL;
307  }
308  fbuffer_append(buffer, ptr + start, end - start);
309 }
310 
311 static char *fstrndup(const char *ptr, unsigned long len) {
312  char *result;
313  if (len <= 0) return NULL;
314  result = ALLOC_N(char, len);
315  memcpy(result, ptr, len);
316  return result;
317 }
318 
319 /*
320  * Document-module: JSON::Ext::Generator
321  *
322  * This is the JSON generator implemented as a C extension. It can be
323  * configured to be used by setting
324  *
325  * JSON.generator = JSON::Ext::Generator
326  *
327  * with the method generator= in JSON.
328  *
329  */
330 
331 /*
332  * call-seq: to_json(state = nil)
333  *
334  * Returns a JSON string containing a JSON object, that is generated from
335  * this Hash instance.
336  * _state_ is a JSON::State object, that can also be used to configure the
337  * produced JSON string output further.
338  */
339 static VALUE mHash_to_json(int argc, VALUE *argv, VALUE self)
340 {
341  GENERATE_JSON(object);
342 }
343 
344 /*
345  * call-seq: to_json(state = nil)
346  *
347  * Returns a JSON string containing a JSON array, that is generated from
348  * this Array instance.
349  * _state_ is a JSON::State object, that can also be used to configure the
350  * produced JSON string output further.
351  */
352 static VALUE mArray_to_json(int argc, VALUE *argv, VALUE self) {
353  GENERATE_JSON(array);
354 }
355 
356 #ifdef RUBY_INTEGER_UNIFICATION
357 /*
358  * call-seq: to_json(*)
359  *
360  * Returns a JSON string representation for this Integer number.
361  */
362 static VALUE mInteger_to_json(int argc, VALUE *argv, VALUE self)
363 {
364  GENERATE_JSON(integer);
365 }
366 
367 #else
368 /*
369  * call-seq: to_json(*)
370  *
371  * Returns a JSON string representation for this Integer number.
372  */
373 static VALUE mFixnum_to_json(int argc, VALUE *argv, VALUE self)
374 {
375  GENERATE_JSON(fixnum);
376 }
377 
378 /*
379  * call-seq: to_json(*)
380  *
381  * Returns a JSON string representation for this Integer number.
382  */
383 static VALUE mBignum_to_json(int argc, VALUE *argv, VALUE self)
384 {
385  GENERATE_JSON(bignum);
386 }
387 #endif
388 
389 /*
390  * call-seq: to_json(*)
391  *
392  * Returns a JSON string representation for this Float number.
393  */
394 static VALUE mFloat_to_json(int argc, VALUE *argv, VALUE self)
395 {
396  GENERATE_JSON(float);
397 }
398 
399 /*
400  * call-seq: String.included(modul)
401  *
402  * Extends _modul_ with the String::Extend module.
403  */
404 static VALUE mString_included_s(VALUE self, VALUE modul) {
405  VALUE result = rb_funcall(modul, i_extend, 1, mString_Extend);
406  return result;
407 }
408 
409 /*
410  * call-seq: to_json(*)
411  *
412  * This string should be encoded with UTF-8 A call to this method
413  * returns a JSON string encoded with UTF16 big endian characters as
414  * \u????.
415  */
416 static VALUE mString_to_json(int argc, VALUE *argv, VALUE self)
417 {
418  GENERATE_JSON(string);
419 }
420 
421 /*
422  * call-seq: to_json_raw_object()
423  *
424  * This method creates a raw object hash, that can be nested into
425  * other data structures and will be generated as a raw string. This
426  * method should be used, if you want to convert raw strings to JSON
427  * instead of UTF-8 strings, e. g. binary data.
428  */
429 static VALUE mString_to_json_raw_object(VALUE self)
430 {
431  VALUE ary;
432  VALUE result = rb_hash_new();
433  rb_hash_aset(result, rb_funcall(mJSON, i_create_id, 0), rb_class_name(rb_obj_class(self)));
434  ary = rb_funcall(self, i_unpack, 1, rb_str_new2("C*"));
435  rb_hash_aset(result, rb_str_new2("raw"), ary);
436  return result;
437 }
438 
439 /*
440  * call-seq: to_json_raw(*args)
441  *
442  * This method creates a JSON text from the result of a call to
443  * to_json_raw_object of this String.
444  */
445 static VALUE mString_to_json_raw(int argc, VALUE *argv, VALUE self)
446 {
447  VALUE obj = mString_to_json_raw_object(self);
449  return mHash_to_json(argc, argv, obj);
450 }
451 
452 /*
453  * call-seq: json_create(o)
454  *
455  * Raw Strings are JSON Objects (the raw bytes are stored in an array for the
456  * key "raw"). The Ruby String can be created by this module method.
457  */
458 static VALUE mString_Extend_json_create(VALUE self, VALUE o)
459 {
460  VALUE ary;
461  Check_Type(o, T_HASH);
462  ary = rb_hash_aref(o, rb_str_new2("raw"));
463  return rb_funcall(ary, i_pack, 1, rb_str_new2("C*"));
464 }
465 
466 /*
467  * call-seq: to_json(*)
468  *
469  * Returns a JSON string for true: 'true'.
470  */
471 static VALUE mTrueClass_to_json(int argc, VALUE *argv, VALUE self)
472 {
473  GENERATE_JSON(true);
474 }
475 
476 /*
477  * call-seq: to_json(*)
478  *
479  * Returns a JSON string for false: 'false'.
480  */
481 static VALUE mFalseClass_to_json(int argc, VALUE *argv, VALUE self)
482 {
483  GENERATE_JSON(false);
484 }
485 
486 /*
487  * call-seq: to_json(*)
488  *
489  * Returns a JSON string for nil: 'null'.
490  */
491 static VALUE mNilClass_to_json(int argc, VALUE *argv, VALUE self)
492 {
493  GENERATE_JSON(null);
494 }
495 
496 /*
497  * call-seq: to_json(*)
498  *
499  * Converts this object to a string (calling #to_s), converts
500  * it to a JSON string, and returns the result. This is a fallback, if no
501  * special method #to_json was defined for some object.
502  */
503 static VALUE mObject_to_json(int argc, VALUE *argv, VALUE self)
504 {
505  VALUE state;
506  VALUE string = rb_funcall(self, i_to_s, 0);
507  rb_scan_args(argc, argv, "01", &state);
508  Check_Type(string, T_STRING);
509  state = cState_from_state_s(cState, state);
510  return cState_partial_generate(state, string);
511 }
512 
513 static void State_free(void *ptr)
514 {
515  JSON_Generator_State *state = ptr;
516  if (state->indent) ruby_xfree(state->indent);
517  if (state->space) ruby_xfree(state->space);
518  if (state->space_before) ruby_xfree(state->space_before);
519  if (state->object_nl) ruby_xfree(state->object_nl);
520  if (state->array_nl) ruby_xfree(state->array_nl);
521  if (state->array_delim) fbuffer_free(state->array_delim);
522  if (state->object_delim) fbuffer_free(state->object_delim);
523  if (state->object_delim2) fbuffer_free(state->object_delim2);
524  ruby_xfree(state);
525 }
526 
527 static size_t State_memsize(const void *ptr)
528 {
529  const JSON_Generator_State *state = ptr;
530  size_t size = sizeof(*state);
531  if (state->indent) size += state->indent_len + 1;
532  if (state->space) size += state->space_len + 1;
533  if (state->space_before) size += state->space_before_len + 1;
534  if (state->object_nl) size += state->object_nl_len + 1;
535  if (state->array_nl) size += state->array_nl_len + 1;
536  if (state->array_delim) size += FBUFFER_CAPA(state->array_delim);
537  if (state->object_delim) size += FBUFFER_CAPA(state->object_delim);
538  if (state->object_delim2) size += FBUFFER_CAPA(state->object_delim2);
539  return size;
540 }
541 
542 #ifdef NEW_TYPEDDATA_WRAPPER
543 static const rb_data_type_t JSON_Generator_State_type = {
544  "JSON/Generator/State",
545  {NULL, State_free, State_memsize,},
546 #ifdef RUBY_TYPED_FREE_IMMEDIATELY
547  0, 0,
549 #endif
550 };
551 #endif
552 
553 static VALUE cState_s_allocate(VALUE klass)
554 {
555  JSON_Generator_State *state;
557  &JSON_Generator_State_type, state);
558 }
559 
560 /*
561  * call-seq: configure(opts)
562  *
563  * Configure this State instance with the Hash _opts_, and return
564  * itself.
565  */
566 static VALUE cState_configure(VALUE self, VALUE opts)
567 {
568  VALUE tmp;
569  GET_STATE(self);
570  tmp = rb_check_convert_type(opts, T_HASH, "Hash", "to_hash");
571  if (NIL_P(tmp)) tmp = rb_convert_type(opts, T_HASH, "Hash", "to_h");
572  opts = tmp;
573  tmp = rb_hash_aref(opts, ID2SYM(i_indent));
574  if (RTEST(tmp)) {
575  unsigned long len;
576  Check_Type(tmp, T_STRING);
577  len = RSTRING_LEN(tmp);
578  state->indent = fstrndup(RSTRING_PTR(tmp), len + 1);
579  state->indent_len = len;
580  }
581  tmp = rb_hash_aref(opts, ID2SYM(i_space));
582  if (RTEST(tmp)) {
583  unsigned long len;
584  Check_Type(tmp, T_STRING);
585  len = RSTRING_LEN(tmp);
586  state->space = fstrndup(RSTRING_PTR(tmp), len + 1);
587  state->space_len = len;
588  }
589  tmp = rb_hash_aref(opts, ID2SYM(i_space_before));
590  if (RTEST(tmp)) {
591  unsigned long len;
592  Check_Type(tmp, T_STRING);
593  len = RSTRING_LEN(tmp);
594  state->space_before = fstrndup(RSTRING_PTR(tmp), len + 1);
595  state->space_before_len = len;
596  }
597  tmp = rb_hash_aref(opts, ID2SYM(i_array_nl));
598  if (RTEST(tmp)) {
599  unsigned long len;
600  Check_Type(tmp, T_STRING);
601  len = RSTRING_LEN(tmp);
602  state->array_nl = fstrndup(RSTRING_PTR(tmp), len + 1);
603  state->array_nl_len = len;
604  }
605  tmp = rb_hash_aref(opts, ID2SYM(i_object_nl));
606  if (RTEST(tmp)) {
607  unsigned long len;
608  Check_Type(tmp, T_STRING);
609  len = RSTRING_LEN(tmp);
610  state->object_nl = fstrndup(RSTRING_PTR(tmp), len + 1);
611  state->object_nl_len = len;
612  }
613  tmp = ID2SYM(i_max_nesting);
614  state->max_nesting = 100;
615  if (option_given_p(opts, tmp)) {
616  VALUE max_nesting = rb_hash_aref(opts, tmp);
617  if (RTEST(max_nesting)) {
618  Check_Type(max_nesting, T_FIXNUM);
619  state->max_nesting = FIX2LONG(max_nesting);
620  } else {
621  state->max_nesting = 0;
622  }
623  }
624  tmp = ID2SYM(i_depth);
625  state->depth = 0;
626  if (option_given_p(opts, tmp)) {
627  VALUE depth = rb_hash_aref(opts, tmp);
628  if (RTEST(depth)) {
629  Check_Type(depth, T_FIXNUM);
630  state->depth = FIX2LONG(depth);
631  } else {
632  state->depth = 0;
633  }
634  }
635  tmp = ID2SYM(i_buffer_initial_length);
636  if (option_given_p(opts, tmp)) {
637  VALUE buffer_initial_length = rb_hash_aref(opts, tmp);
638  if (RTEST(buffer_initial_length)) {
639  long initial_length;
640  Check_Type(buffer_initial_length, T_FIXNUM);
641  initial_length = FIX2LONG(buffer_initial_length);
642  if (initial_length > 0) state->buffer_initial_length = initial_length;
643  }
644  }
645  tmp = rb_hash_aref(opts, ID2SYM(i_allow_nan));
646  state->allow_nan = RTEST(tmp);
647  tmp = rb_hash_aref(opts, ID2SYM(i_ascii_only));
648  state->ascii_only = RTEST(tmp);
649  return self;
650 }
651 
652 static void set_state_ivars(VALUE hash, VALUE state)
653 {
654  VALUE ivars = rb_obj_instance_variables(state);
655  int i = 0;
656  for (i = 0; i < RARRAY_LEN(ivars); i++) {
657  VALUE key = rb_funcall(rb_ary_entry(ivars, i), i_to_s, 0);
658  long key_len = RSTRING_LEN(key);
659  VALUE value = rb_iv_get(state, StringValueCStr(key));
660  rb_hash_aset(hash, rb_str_intern(rb_str_substr(key, 1, key_len - 1)), value);
661  }
662 }
663 
664 /*
665  * call-seq: to_h
666  *
667  * Returns the configuration instance variables as a hash, that can be
668  * passed to the configure method.
669  */
670 static VALUE cState_to_h(VALUE self)
671 {
672  VALUE result = rb_hash_new();
673  GET_STATE(self);
674  set_state_ivars(result, self);
675  rb_hash_aset(result, ID2SYM(i_indent), rb_str_new(state->indent, state->indent_len));
676  rb_hash_aset(result, ID2SYM(i_space), rb_str_new(state->space, state->space_len));
677  rb_hash_aset(result, ID2SYM(i_space_before), rb_str_new(state->space_before, state->space_before_len));
678  rb_hash_aset(result, ID2SYM(i_object_nl), rb_str_new(state->object_nl, state->object_nl_len));
679  rb_hash_aset(result, ID2SYM(i_array_nl), rb_str_new(state->array_nl, state->array_nl_len));
680  rb_hash_aset(result, ID2SYM(i_allow_nan), state->allow_nan ? Qtrue : Qfalse);
681  rb_hash_aset(result, ID2SYM(i_ascii_only), state->ascii_only ? Qtrue : Qfalse);
682  rb_hash_aset(result, ID2SYM(i_max_nesting), LONG2FIX(state->max_nesting));
683  rb_hash_aset(result, ID2SYM(i_depth), LONG2FIX(state->depth));
684  rb_hash_aset(result, ID2SYM(i_buffer_initial_length), LONG2FIX(state->buffer_initial_length));
685  return result;
686 }
687 
688 /*
689 * call-seq: [](name)
690 *
691 * Returns the value returned by method +name+.
692 */
693 static VALUE cState_aref(VALUE self, VALUE name)
694 {
695  name = rb_funcall(name, i_to_s, 0);
696  if (RTEST(rb_funcall(self, i_respond_to_p, 1, name))) {
697  return rb_funcall(self, i_send, 1, name);
698  } else {
700  }
701 }
702 
703 /*
704 * call-seq: []=(name, value)
705 *
706 * Sets the attribute name to value.
707 */
708 static VALUE cState_aset(VALUE self, VALUE name, VALUE value)
709 {
710  VALUE name_writer;
711 
712  name = rb_funcall(name, i_to_s, 0);
713  name_writer = rb_str_cat2(rb_str_dup(name), "=");
714  if (RTEST(rb_funcall(self, i_respond_to_p, 1, name_writer))) {
715  return rb_funcall(self, i_send, 2, name_writer, value);
716  } else {
718  }
719  return Qnil;
720 }
721 
726  int iter;
727 };
728 
729 static int
730 json_object_i(VALUE key, VALUE val, VALUE _arg)
731 {
732  struct hash_foreach_arg *arg = (struct hash_foreach_arg *)_arg;
733  FBuffer *buffer = arg->buffer;
734  JSON_Generator_State *state = arg->state;
735  VALUE Vstate = arg->Vstate;
736 
737  char *object_nl = state->object_nl;
738  long object_nl_len = state->object_nl_len;
739  char *indent = state->indent;
740  long indent_len = state->indent_len;
741  char *delim = FBUFFER_PTR(state->object_delim);
742  long delim_len = FBUFFER_LEN(state->object_delim);
743  char *delim2 = FBUFFER_PTR(state->object_delim2);
744  long delim2_len = FBUFFER_LEN(state->object_delim2);
745  long depth = state->depth;
746  int j;
747  VALUE klass, key_to_s;
748 
749  if (arg->iter > 0) fbuffer_append(buffer, delim, delim_len);
750  if (object_nl) {
751  fbuffer_append(buffer, object_nl, object_nl_len);
752  }
753  if (indent) {
754  for (j = 0; j < depth; j++) {
755  fbuffer_append(buffer, indent, indent_len);
756  }
757  }
758 
759  klass = CLASS_OF(key);
760  if (klass == rb_cString) {
761  key_to_s = key;
762  } else if (klass == rb_cSymbol) {
763  key_to_s = rb_id2str(SYM2ID(key));
764  } else {
765  key_to_s = rb_funcall(key, i_to_s, 0);
766  }
767  Check_Type(key_to_s, T_STRING);
768  generate_json(buffer, Vstate, state, key_to_s);
769  fbuffer_append(buffer, delim2, delim2_len);
770  generate_json(buffer, Vstate, state, val);
771 
772  arg->iter++;
773  return ST_CONTINUE;
774 }
775 
776 static void generate_json_object(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj)
777 {
778  char *object_nl = state->object_nl;
779  long object_nl_len = state->object_nl_len;
780  char *indent = state->indent;
781  long indent_len = state->indent_len;
782  long max_nesting = state->max_nesting;
783  long depth = ++state->depth;
784  int j;
785  struct hash_foreach_arg arg;
786 
787  if (max_nesting != 0 && depth > max_nesting) {
788  fbuffer_free(buffer);
789  rb_raise(eNestingError, "nesting of %ld is too deep", --state->depth);
790  }
791  fbuffer_append_char(buffer, '{');
792 
793  arg.buffer = buffer;
794  arg.state = state;
795  arg.Vstate = Vstate;
796  arg.iter = 0;
797  rb_hash_foreach(obj, json_object_i, (VALUE)&arg);
798 
799  depth = --state->depth;
800  if (object_nl) {
801  fbuffer_append(buffer, object_nl, object_nl_len);
802  if (indent) {
803  for (j = 0; j < depth; j++) {
804  fbuffer_append(buffer, indent, indent_len);
805  }
806  }
807  }
808  fbuffer_append_char(buffer, '}');
809 }
810 
811 static void generate_json_array(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj)
812 {
813  char *array_nl = state->array_nl;
814  long array_nl_len = state->array_nl_len;
815  char *indent = state->indent;
816  long indent_len = state->indent_len;
817  long max_nesting = state->max_nesting;
818  char *delim = FBUFFER_PTR(state->array_delim);
819  long delim_len = FBUFFER_LEN(state->array_delim);
820  long depth = ++state->depth;
821  int i, j;
822  if (max_nesting != 0 && depth > max_nesting) {
823  fbuffer_free(buffer);
824  rb_raise(eNestingError, "nesting of %ld is too deep", --state->depth);
825  }
826  fbuffer_append_char(buffer, '[');
827  if (array_nl) fbuffer_append(buffer, array_nl, array_nl_len);
828  for(i = 0; i < RARRAY_LEN(obj); i++) {
829  if (i > 0) fbuffer_append(buffer, delim, delim_len);
830  if (indent) {
831  for (j = 0; j < depth; j++) {
832  fbuffer_append(buffer, indent, indent_len);
833  }
834  }
835  generate_json(buffer, Vstate, state, rb_ary_entry(obj, i));
836  }
837  state->depth = --depth;
838  if (array_nl) {
839  fbuffer_append(buffer, array_nl, array_nl_len);
840  if (indent) {
841  for (j = 0; j < depth; j++) {
842  fbuffer_append(buffer, indent, indent_len);
843  }
844  }
845  }
846  fbuffer_append_char(buffer, ']');
847 }
848 
849 #ifdef HAVE_RUBY_ENCODING_H
850 static int enc_utf8_compatible_p(rb_encoding *enc)
851 {
852  if (enc == rb_usascii_encoding()) return 1;
853  if (enc == rb_utf8_encoding()) return 1;
854  return 0;
855 }
856 #endif
857 
858 static void generate_json_string(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj)
859 {
860  fbuffer_append_char(buffer, '"');
861 #ifdef HAVE_RUBY_ENCODING_H
862  if (!enc_utf8_compatible_p(rb_enc_get(obj))) {
863  obj = rb_str_encode(obj, CEncoding_UTF_8, 0, Qnil);
864  }
865 #endif
866  if (state->ascii_only) {
867  convert_UTF8_to_JSON_ASCII(buffer, obj);
868  } else {
869  convert_UTF8_to_JSON(buffer, obj);
870  }
871  fbuffer_append_char(buffer, '"');
872 }
873 
874 static void generate_json_null(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj)
875 {
876  fbuffer_append(buffer, "null", 4);
877 }
878 
879 static void generate_json_false(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj)
880 {
881  fbuffer_append(buffer, "false", 5);
882 }
883 
884 static void generate_json_true(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj)
885 {
886  fbuffer_append(buffer, "true", 4);
887 }
888 
889 static void generate_json_fixnum(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj)
890 {
891  fbuffer_append_long(buffer, FIX2LONG(obj));
892 }
893 
894 static void generate_json_bignum(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj)
895 {
896  VALUE tmp = rb_funcall(obj, i_to_s, 0);
897  fbuffer_append_str(buffer, tmp);
898 }
899 
900 #ifdef RUBY_INTEGER_UNIFICATION
901 static void generate_json_integer(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj)
902 {
903  if (FIXNUM_P(obj))
904  generate_json_fixnum(buffer, Vstate, state, obj);
905  else
906  generate_json_bignum(buffer, Vstate, state, obj);
907 }
908 #endif
909 static void generate_json_float(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj)
910 {
911  double value = RFLOAT_VALUE(obj);
912  char allow_nan = state->allow_nan;
913  VALUE tmp = rb_funcall(obj, i_to_s, 0);
914  if (!allow_nan) {
915  if (isinf(value)) {
916  fbuffer_free(buffer);
917  rb_raise(eGeneratorError, "%u: %"PRIsVALUE" not allowed in JSON", __LINE__, RB_OBJ_STRING(tmp));
918  } else if (isnan(value)) {
919  fbuffer_free(buffer);
920  rb_raise(eGeneratorError, "%u: %"PRIsVALUE" not allowed in JSON", __LINE__, RB_OBJ_STRING(tmp));
921  }
922  }
923  fbuffer_append_str(buffer, tmp);
924 }
925 
926 static void generate_json(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj)
927 {
928  VALUE tmp;
929  VALUE klass = CLASS_OF(obj);
930  if (klass == rb_cHash) {
931  generate_json_object(buffer, Vstate, state, obj);
932  } else if (klass == rb_cArray) {
933  generate_json_array(buffer, Vstate, state, obj);
934  } else if (klass == rb_cString) {
935  generate_json_string(buffer, Vstate, state, obj);
936  } else if (obj == Qnil) {
937  generate_json_null(buffer, Vstate, state, obj);
938  } else if (obj == Qfalse) {
939  generate_json_false(buffer, Vstate, state, obj);
940  } else if (obj == Qtrue) {
941  generate_json_true(buffer, Vstate, state, obj);
942  } else if (FIXNUM_P(obj)) {
943  generate_json_fixnum(buffer, Vstate, state, obj);
944  } else if (RB_TYPE_P(obj, T_BIGNUM)) {
945  generate_json_bignum(buffer, Vstate, state, obj);
946  } else if (klass == rb_cFloat) {
947  generate_json_float(buffer, Vstate, state, obj);
948  } else if (rb_respond_to(obj, i_to_json)) {
949  tmp = rb_funcall(obj, i_to_json, 1, Vstate);
950  Check_Type(tmp, T_STRING);
951  fbuffer_append_str(buffer, tmp);
952  } else {
953  tmp = rb_funcall(obj, i_to_s, 0);
954  Check_Type(tmp, T_STRING);
955  generate_json_string(buffer, Vstate, state, tmp);
956  }
957 }
958 
959 static FBuffer *cState_prepare_buffer(VALUE self)
960 {
961  FBuffer *buffer;
962  GET_STATE(self);
963  buffer = fbuffer_alloc(state->buffer_initial_length);
964 
965  if (state->object_delim) {
966  fbuffer_clear(state->object_delim);
967  } else {
968  state->object_delim = fbuffer_alloc(16);
969  }
970  fbuffer_append_char(state->object_delim, ',');
971  if (state->object_delim2) {
972  fbuffer_clear(state->object_delim2);
973  } else {
974  state->object_delim2 = fbuffer_alloc(16);
975  }
977  fbuffer_append_char(state->object_delim2, ':');
978  if (state->space) fbuffer_append(state->object_delim2, state->space, state->space_len);
979 
980  if (state->array_delim) {
981  fbuffer_clear(state->array_delim);
982  } else {
983  state->array_delim = fbuffer_alloc(16);
984  }
985  fbuffer_append_char(state->array_delim, ',');
986  if (state->array_nl) fbuffer_append(state->array_delim, state->array_nl, state->array_nl_len);
987  return buffer;
988 }
989 
990 static VALUE cState_partial_generate(VALUE self, VALUE obj)
991 {
992  FBuffer *buffer = cState_prepare_buffer(self);
993  GET_STATE(self);
994  generate_json(buffer, self, state, obj);
995  return fbuffer_to_s(buffer);
996 }
997 
998 /*
999  * call-seq: generate(obj)
1000  *
1001  * Generates a valid JSON document from object +obj+ and returns the
1002  * result. If no valid JSON document can be created this method raises a
1003  * GeneratorError exception.
1004  */
1005 static VALUE cState_generate(VALUE self, VALUE obj)
1006 {
1007  VALUE result = cState_partial_generate(self, obj);
1008  GET_STATE(self);
1009  (void)state;
1010  return result;
1011 }
1012 
1013 /*
1014  * call-seq: new(opts = {})
1015  *
1016  * Instantiates a new State object, configured by _opts_.
1017  *
1018  * _opts_ can have the following keys:
1019  *
1020  * * *indent*: a string used to indent levels (default: ''),
1021  * * *space*: a string that is put after, a : or , delimiter (default: ''),
1022  * * *space_before*: a string that is put before a : pair delimiter (default: ''),
1023  * * *object_nl*: a string that is put at the end of a JSON object (default: ''),
1024  * * *array_nl*: a string that is put at the end of a JSON array (default: ''),
1025  * * *allow_nan*: true if NaN, Infinity, and -Infinity should be
1026  * generated, otherwise an exception is thrown, if these values are
1027  * encountered. This options defaults to false.
1028  * * *ascii_only*: true if only ASCII characters should be generated. This
1029  * ontions defaults to false.
1030  * * *buffer_initial_length*: sets the initial length of the generator's
1031  * internal buffer.
1032  */
1033 static VALUE cState_initialize(int argc, VALUE *argv, VALUE self)
1034 {
1035  VALUE opts;
1036  GET_STATE(self);
1037  state->max_nesting = 100;
1039  rb_scan_args(argc, argv, "01", &opts);
1040  if (!NIL_P(opts)) cState_configure(self, opts);
1041  return self;
1042 }
1043 
1044 /*
1045  * call-seq: initialize_copy(orig)
1046  *
1047  * Initializes this object from orig if it can be duplicated/cloned and returns
1048  * it.
1049 */
1050 static VALUE cState_init_copy(VALUE obj, VALUE orig)
1051 {
1052  JSON_Generator_State *objState, *origState;
1053 
1054  if (obj == orig) return obj;
1055  GET_STATE_TO(obj, objState);
1056  GET_STATE_TO(orig, origState);
1057  if (!objState) rb_raise(rb_eArgError, "unallocated JSON::State");
1058 
1059  MEMCPY(objState, origState, JSON_Generator_State, 1);
1060  objState->indent = fstrndup(origState->indent, origState->indent_len);
1061  objState->space = fstrndup(origState->space, origState->space_len);
1062  objState->space_before = fstrndup(origState->space_before, origState->space_before_len);
1063  objState->object_nl = fstrndup(origState->object_nl, origState->object_nl_len);
1064  objState->array_nl = fstrndup(origState->array_nl, origState->array_nl_len);
1065  if (origState->array_delim) objState->array_delim = fbuffer_dup(origState->array_delim);
1066  if (origState->object_delim) objState->object_delim = fbuffer_dup(origState->object_delim);
1067  if (origState->object_delim2) objState->object_delim2 = fbuffer_dup(origState->object_delim2);
1068  return obj;
1069 }
1070 
1071 /*
1072  * call-seq: from_state(opts)
1073  *
1074  * Creates a State object from _opts_, which ought to be Hash to create a
1075  * new State instance configured by _opts_, something else to create an
1076  * unconfigured instance. If _opts_ is a State object, it is just returned.
1077  */
1078 static VALUE cState_from_state_s(VALUE self, VALUE opts)
1079 {
1080  if (rb_obj_is_kind_of(opts, self)) {
1081  return opts;
1082  } else if (rb_obj_is_kind_of(opts, rb_cHash)) {
1083  return rb_funcall(self, i_new, 1, opts);
1084  } else {
1085  VALUE prototype = rb_const_get(mJSON, i_SAFE_STATE_PROTOTYPE);
1086  return rb_funcall(prototype, i_dup, 0);
1087  }
1088 }
1089 
1090 /*
1091  * call-seq: indent()
1092  *
1093  * Returns the string that is used to indent levels in the JSON text.
1094  */
1095 static VALUE cState_indent(VALUE self)
1096 {
1097  GET_STATE(self);
1099 }
1100 
1101 /*
1102  * call-seq: indent=(indent)
1103  *
1104  * Sets the string that is used to indent levels in the JSON text.
1105  */
1106 static VALUE cState_indent_set(VALUE self, VALUE indent)
1107 {
1108  unsigned long len;
1109  GET_STATE(self);
1110  Check_Type(indent, T_STRING);
1111  len = RSTRING_LEN(indent);
1112  if (len == 0) {
1113  if (state->indent) {
1115  state->indent = NULL;
1116  state->indent_len = 0;
1117  }
1118  } else {
1120  state->indent = fstrndup(RSTRING_PTR(indent), len);
1121  state->indent_len = len;
1122  }
1123  return Qnil;
1124 }
1125 
1126 /*
1127  * call-seq: space()
1128  *
1129  * Returns the string that is used to insert a space between the tokens in a JSON
1130  * string.
1131  */
1132 static VALUE cState_space(VALUE self)
1133 {
1134  GET_STATE(self);
1136 }
1137 
1138 /*
1139  * call-seq: space=(space)
1140  *
1141  * Sets _space_ to the string that is used to insert a space between the tokens in a JSON
1142  * string.
1143  */
1144 static VALUE cState_space_set(VALUE self, VALUE space)
1145 {
1146  unsigned long len;
1147  GET_STATE(self);
1148  Check_Type(space, T_STRING);
1149  len = RSTRING_LEN(space);
1150  if (len == 0) {
1151  if (state->space) {
1153  state->space = NULL;
1154  state->space_len = 0;
1155  }
1156  } else {
1157  if (state->space) ruby_xfree(state->space);
1158  state->space = fstrndup(RSTRING_PTR(space), len);
1159  state->space_len = len;
1160  }
1161  return Qnil;
1162 }
1163 
1164 /*
1165  * call-seq: space_before()
1166  *
1167  * Returns the string that is used to insert a space before the ':' in JSON objects.
1168  */
1169 static VALUE cState_space_before(VALUE self)
1170 {
1171  GET_STATE(self);
1173 }
1174 
1175 /*
1176  * call-seq: space_before=(space_before)
1177  *
1178  * Sets the string that is used to insert a space before the ':' in JSON objects.
1179  */
1180 static VALUE cState_space_before_set(VALUE self, VALUE space_before)
1181 {
1182  unsigned long len;
1183  GET_STATE(self);
1184  Check_Type(space_before, T_STRING);
1185  len = RSTRING_LEN(space_before);
1186  if (len == 0) {
1187  if (state->space_before) {
1189  state->space_before = NULL;
1190  state->space_before_len = 0;
1191  }
1192  } else {
1194  state->space_before = fstrndup(RSTRING_PTR(space_before), len);
1196  }
1197  return Qnil;
1198 }
1199 
1200 /*
1201  * call-seq: object_nl()
1202  *
1203  * This string is put at the end of a line that holds a JSON object (or
1204  * Hash).
1205  */
1206 static VALUE cState_object_nl(VALUE self)
1207 {
1208  GET_STATE(self);
1210 }
1211 
1212 /*
1213  * call-seq: object_nl=(object_nl)
1214  *
1215  * This string is put at the end of a line that holds a JSON object (or
1216  * Hash).
1217  */
1218 static VALUE cState_object_nl_set(VALUE self, VALUE object_nl)
1219 {
1220  unsigned long len;
1221  GET_STATE(self);
1222  Check_Type(object_nl, T_STRING);
1223  len = RSTRING_LEN(object_nl);
1224  if (len == 0) {
1225  if (state->object_nl) {
1227  state->object_nl = NULL;
1228  }
1229  } else {
1231  state->object_nl = fstrndup(RSTRING_PTR(object_nl), len);
1232  state->object_nl_len = len;
1233  }
1234  return Qnil;
1235 }
1236 
1237 /*
1238  * call-seq: array_nl()
1239  *
1240  * This string is put at the end of a line that holds a JSON array.
1241  */
1242 static VALUE cState_array_nl(VALUE self)
1243 {
1244  GET_STATE(self);
1246 }
1247 
1248 /*
1249  * call-seq: array_nl=(array_nl)
1250  *
1251  * This string is put at the end of a line that holds a JSON array.
1252  */
1253 static VALUE cState_array_nl_set(VALUE self, VALUE array_nl)
1254 {
1255  unsigned long len;
1256  GET_STATE(self);
1257  Check_Type(array_nl, T_STRING);
1258  len = RSTRING_LEN(array_nl);
1259  if (len == 0) {
1260  if (state->array_nl) {
1262  state->array_nl = NULL;
1263  }
1264  } else {
1266  state->array_nl = fstrndup(RSTRING_PTR(array_nl), len);
1267  state->array_nl_len = len;
1268  }
1269  return Qnil;
1270 }
1271 
1272 
1273 /*
1274 * call-seq: check_circular?
1275 *
1276 * Returns true, if circular data structures should be checked,
1277 * otherwise returns false.
1278 */
1279 static VALUE cState_check_circular_p(VALUE self)
1280 {
1281  GET_STATE(self);
1282  return state->max_nesting ? Qtrue : Qfalse;
1283 }
1284 
1285 /*
1286  * call-seq: max_nesting
1287  *
1288  * This integer returns the maximum level of data structure nesting in
1289  * the generated JSON, max_nesting = 0 if no maximum is checked.
1290  */
1291 static VALUE cState_max_nesting(VALUE self)
1292 {
1293  GET_STATE(self);
1294  return LONG2FIX(state->max_nesting);
1295 }
1296 
1297 /*
1298  * call-seq: max_nesting=(depth)
1299  *
1300  * This sets the maximum level of data structure nesting in the generated JSON
1301  * to the integer depth, max_nesting = 0 if no maximum should be checked.
1302  */
1303 static VALUE cState_max_nesting_set(VALUE self, VALUE depth)
1304 {
1305  GET_STATE(self);
1306  Check_Type(depth, T_FIXNUM);
1307  return state->max_nesting = FIX2LONG(depth);
1308 }
1309 
1310 /*
1311  * call-seq: allow_nan?
1312  *
1313  * Returns true, if NaN, Infinity, and -Infinity should be generated, otherwise
1314  * returns false.
1315  */
1316 static VALUE cState_allow_nan_p(VALUE self)
1317 {
1318  GET_STATE(self);
1319  return state->allow_nan ? Qtrue : Qfalse;
1320 }
1321 
1322 /*
1323  * call-seq: ascii_only?
1324  *
1325  * Returns true, if only ASCII characters should be generated. Otherwise
1326  * returns false.
1327  */
1328 static VALUE cState_ascii_only_p(VALUE self)
1329 {
1330  GET_STATE(self);
1331  return state->ascii_only ? Qtrue : Qfalse;
1332 }
1333 
1334 /*
1335  * call-seq: depth
1336  *
1337  * This integer returns the current depth of data structure nesting.
1338  */
1339 static VALUE cState_depth(VALUE self)
1340 {
1341  GET_STATE(self);
1342  return LONG2FIX(state->depth);
1343 }
1344 
1345 /*
1346  * call-seq: depth=(depth)
1347  *
1348  * This sets the maximum level of data structure nesting in the generated JSON
1349  * to the integer depth, max_nesting = 0 if no maximum should be checked.
1350  */
1351 static VALUE cState_depth_set(VALUE self, VALUE depth)
1352 {
1353  GET_STATE(self);
1354  Check_Type(depth, T_FIXNUM);
1355  state->depth = FIX2LONG(depth);
1356  return Qnil;
1357 }
1358 
1359 /*
1360  * call-seq: buffer_initial_length
1361  *
1362  * This integer returns the current initial length of the buffer.
1363  */
1364 static VALUE cState_buffer_initial_length(VALUE self)
1365 {
1366  GET_STATE(self);
1368 }
1369 
1370 /*
1371  * call-seq: buffer_initial_length=(length)
1372  *
1373  * This sets the initial length of the buffer to +length+, if +length+ > 0,
1374  * otherwise its value isn't changed.
1375  */
1376 static VALUE cState_buffer_initial_length_set(VALUE self, VALUE buffer_initial_length)
1377 {
1378  long initial_length;
1379  GET_STATE(self);
1380  Check_Type(buffer_initial_length, T_FIXNUM);
1381  initial_length = FIX2LONG(buffer_initial_length);
1382  if (initial_length > 0) {
1383  state->buffer_initial_length = initial_length;
1384  }
1385  return Qnil;
1386 }
1387 
1388 /*
1389  *
1390  */
1391 void Init_generator(void)
1392 {
1393 #undef rb_intern
1394  rb_require("json/common");
1395 
1396  mJSON = rb_define_module("JSON");
1397  mExt = rb_define_module_under(mJSON, "Ext");
1398  mGenerator = rb_define_module_under(mExt, "Generator");
1399 
1400  eGeneratorError = rb_path2class("JSON::GeneratorError");
1401  eNestingError = rb_path2class("JSON::NestingError");
1402  rb_gc_register_mark_object(eGeneratorError);
1403  rb_gc_register_mark_object(eNestingError);
1404 
1405  cState = rb_define_class_under(mGenerator, "State", rb_cObject);
1406  rb_define_alloc_func(cState, cState_s_allocate);
1407  rb_define_singleton_method(cState, "from_state", cState_from_state_s, 1);
1408  rb_define_method(cState, "initialize", cState_initialize, -1);
1409  rb_define_method(cState, "initialize_copy", cState_init_copy, 1);
1410  rb_define_method(cState, "indent", cState_indent, 0);
1411  rb_define_method(cState, "indent=", cState_indent_set, 1);
1412  rb_define_method(cState, "space", cState_space, 0);
1413  rb_define_method(cState, "space=", cState_space_set, 1);
1414  rb_define_method(cState, "space_before", cState_space_before, 0);
1415  rb_define_method(cState, "space_before=", cState_space_before_set, 1);
1416  rb_define_method(cState, "object_nl", cState_object_nl, 0);
1417  rb_define_method(cState, "object_nl=", cState_object_nl_set, 1);
1418  rb_define_method(cState, "array_nl", cState_array_nl, 0);
1419  rb_define_method(cState, "array_nl=", cState_array_nl_set, 1);
1420  rb_define_method(cState, "max_nesting", cState_max_nesting, 0);
1421  rb_define_method(cState, "max_nesting=", cState_max_nesting_set, 1);
1422  rb_define_method(cState, "check_circular?", cState_check_circular_p, 0);
1423  rb_define_method(cState, "allow_nan?", cState_allow_nan_p, 0);
1424  rb_define_method(cState, "ascii_only?", cState_ascii_only_p, 0);
1425  rb_define_method(cState, "depth", cState_depth, 0);
1426  rb_define_method(cState, "depth=", cState_depth_set, 1);
1427  rb_define_method(cState, "buffer_initial_length", cState_buffer_initial_length, 0);
1428  rb_define_method(cState, "buffer_initial_length=", cState_buffer_initial_length_set, 1);
1429  rb_define_method(cState, "configure", cState_configure, 1);
1430  rb_define_alias(cState, "merge", "configure");
1431  rb_define_method(cState, "to_h", cState_to_h, 0);
1432  rb_define_alias(cState, "to_hash", "to_h");
1433  rb_define_method(cState, "[]", cState_aref, 1);
1434  rb_define_method(cState, "[]=", cState_aset, 2);
1435  rb_define_method(cState, "generate", cState_generate, 1);
1436 
1437  mGeneratorMethods = rb_define_module_under(mGenerator, "GeneratorMethods");
1438  mObject = rb_define_module_under(mGeneratorMethods, "Object");
1439  rb_define_method(mObject, "to_json", mObject_to_json, -1);
1440  mHash = rb_define_module_under(mGeneratorMethods, "Hash");
1441  rb_define_method(mHash, "to_json", mHash_to_json, -1);
1442  mArray = rb_define_module_under(mGeneratorMethods, "Array");
1443  rb_define_method(mArray, "to_json", mArray_to_json, -1);
1444 #ifdef RUBY_INTEGER_UNIFICATION
1445  mInteger = rb_define_module_under(mGeneratorMethods, "Integer");
1446  rb_define_method(mInteger, "to_json", mInteger_to_json, -1);
1447 #else
1448  mFixnum = rb_define_module_under(mGeneratorMethods, "Fixnum");
1449  rb_define_method(mFixnum, "to_json", mFixnum_to_json, -1);
1450  mBignum = rb_define_module_under(mGeneratorMethods, "Bignum");
1451  rb_define_method(mBignum, "to_json", mBignum_to_json, -1);
1452 #endif
1453  mFloat = rb_define_module_under(mGeneratorMethods, "Float");
1454  rb_define_method(mFloat, "to_json", mFloat_to_json, -1);
1455  mString = rb_define_module_under(mGeneratorMethods, "String");
1456  rb_define_singleton_method(mString, "included", mString_included_s, 1);
1457  rb_define_method(mString, "to_json", mString_to_json, -1);
1458  rb_define_method(mString, "to_json_raw", mString_to_json_raw, -1);
1459  rb_define_method(mString, "to_json_raw_object", mString_to_json_raw_object, 0);
1460  mString_Extend = rb_define_module_under(mString, "Extend");
1461  rb_define_method(mString_Extend, "json_create", mString_Extend_json_create, 1);
1462  mTrueClass = rb_define_module_under(mGeneratorMethods, "TrueClass");
1463  rb_define_method(mTrueClass, "to_json", mTrueClass_to_json, -1);
1464  mFalseClass = rb_define_module_under(mGeneratorMethods, "FalseClass");
1465  rb_define_method(mFalseClass, "to_json", mFalseClass_to_json, -1);
1466  mNilClass = rb_define_module_under(mGeneratorMethods, "NilClass");
1467  rb_define_method(mNilClass, "to_json", mNilClass_to_json, -1);
1468 
1469  i_to_s = rb_intern("to_s");
1470  i_to_json = rb_intern("to_json");
1471  i_new = rb_intern("new");
1472  i_indent = rb_intern("indent");
1473  i_space = rb_intern("space");
1474  i_space_before = rb_intern("space_before");
1475  i_object_nl = rb_intern("object_nl");
1476  i_array_nl = rb_intern("array_nl");
1477  i_max_nesting = rb_intern("max_nesting");
1478  i_allow_nan = rb_intern("allow_nan");
1479  i_ascii_only = rb_intern("ascii_only");
1480  i_depth = rb_intern("depth");
1481  i_buffer_initial_length = rb_intern("buffer_initial_length");
1482  i_pack = rb_intern("pack");
1483  i_unpack = rb_intern("unpack");
1484  i_create_id = rb_intern("create_id");
1485  i_extend = rb_intern("extend");
1486  i_key_p = rb_intern("key?");
1487  i_aref = rb_intern("[]");
1488  i_send = rb_intern("__send__");
1489  i_respond_to_p = rb_intern("respond_to?");
1490  i_match = rb_intern("match");
1491  i_keys = rb_intern("keys");
1492  i_dup = rb_intern("dup");
1493 #ifdef HAVE_RUBY_ENCODING_H
1494  CEncoding_UTF_8 = rb_funcall(rb_path2class("Encoding"), rb_intern("find"), 1, rb_str_new2("utf-8"));
1495  i_encoding = rb_intern("encoding");
1496  i_encode = rb_intern("encode");
1497 #endif
1498  i_SAFE_STATE_PROTOTYPE = rb_intern("SAFE_STATE_PROTOTYPE");
1499 }
rb_cArray
VALUE rb_cArray
Definition: array.c:27
JSON_Generator_StateStruct::object_nl
char * object_nl
Definition: generator.h:65
i
uint32_t i
Definition: rb_mjit_min_header-2.7.1.h:5464
ID
unsigned long ID
Definition: ruby.h:103
ruby_xfree
void ruby_xfree(void *x)
Definition: gc.c:10169
rb_str_concat
VALUE rb_str_concat(VALUE, VALUE)
Definition: string.c:3065
obj
const VALUE VALUE obj
Definition: rb_mjit_min_header-2.7.1.h:5742
TypedData_Make_Struct
#define TypedData_Make_Struct(klass, type, data_type, sval)
Definition: ruby.h:1244
Check_Type
#define Check_Type(v, t)
Definition: ruby.h:595
rb_str_new2
#define rb_str_new2
Definition: intern.h:903
FBUFFER_CAPA
#define FBUFFER_CAPA(fb)
Definition: fbuffer.h:57
klass
VALUE klass
Definition: rb_mjit_min_header-2.7.1.h:13259
JSON_Generator_StateStruct::object_delim
FBuffer * object_delim
Definition: generator.h:70
rb_hash_new
VALUE rb_hash_new(void)
Definition: hash.c:1523
rb_gc_register_mark_object
void rb_gc_register_mark_object(VALUE obj)
Definition: gc.c:7065
rb_define_module_under
VALUE rb_define_module_under(VALUE outer, const char *name)
Definition: class.c:797
UNI_REPLACEMENT_CHAR
#define UNI_REPLACEMENT_CHAR
Definition: generator.h:33
JSON_Generator_StateStruct::object_nl_len
long object_nl_len
Definition: generator.h:66
rb_funcall
#define rb_funcall(recv, mid, argc,...)
Definition: rb_mjit_min_header-2.7.1.h:6585
hash_foreach_arg::state
JSON_Generator_State * state
Definition: generator.c:724
RSTRING_PTR
#define RSTRING_PTR(str)
Definition: ruby.h:1009
RB_OBJ_STRING
#define RB_OBJ_STRING(obj)
Definition: bigdecimal.c:99
rb_str_substr
VALUE rb_str_substr(VALUE, long, long)
Definition: string.c:2584
rb_attr_get
VALUE rb_attr_get(VALUE, ID)
Definition: variable.c:1084
rb_hash_aref
VALUE rb_hash_aref(VALUE hash, VALUE key)
Definition: hash.c:2032
VALUE
unsigned long VALUE
Definition: ruby.h:102
rb_eArgError
VALUE rb_eArgError
Definition: error.c:923
rb_intern
#define rb_intern(str)
RB_TYPE_P
#define RB_TYPE_P(obj, type)
Definition: ruby.h:560
hash_foreach_arg
Definition: generator.c:722
rb_enc_get
rb_encoding * rb_enc_get(VALUE obj)
Definition: encoding.c:872
rb_check_convert_type
VALUE rb_check_convert_type(VALUE, int, const char *, const char *)
Tries to convert an object into another type.
Definition: object.c:2941
JSON_Generator_StateStruct::depth
long depth
Definition: generator.h:75
rb_define_module
VALUE rb_define_module(const char *name)
Definition: class.c:772
rb_cFloat
RUBY_EXTERN VALUE rb_cFloat
Definition: ruby.h:2028
isinf
#define isinf(__x)
Definition: rb_mjit_min_header-2.7.1.h:3673
option_given_p
#define option_given_p(opts, key)
Definition: generator.h:23
arg
VALUE arg
Definition: rb_mjit_min_header-2.7.1.h:5601
rb_str_dup
VALUE rb_str_dup(VALUE)
Definition: string.c:1516
rb_str_cat2
#define rb_str_cat2
Definition: intern.h:912
rb_define_singleton_method
void rb_define_singleton_method(VALUE obj, const char *name, VALUE(*func)(ANYARGS), int argc)
Defines a singleton method for obj.
Definition: class.c:1755
rb_define_method
void rb_define_method(VALUE klass, const char *name, VALUE(*func)(ANYARGS), int argc)
Definition: class.c:1551
JSON_Generator_StateStruct
Definition: generator.h:58
ptr
struct RIMemo * ptr
Definition: debug.c:74
rb_str_new
#define rb_str_new(str, len)
Definition: rb_mjit_min_header-2.7.1.h:6116
Qfalse
#define Qfalse
Definition: ruby.h:467
JSON_Generator_StateStruct::array_nl_len
long array_nl_len
Definition: generator.h:68
rb_id2str
#define rb_id2str(id)
Definition: vm_backtrace.c:30
NULL
#define NULL
Definition: _sdbm.c:101
char
#define char
Definition: rb_mjit_min_header-2.7.1.h:2876
UNI_SUR_LOW_END
#define UNI_SUR_LOW_END
Definition: generator.h:42
JSON_Generator_StateStruct::buffer_initial_length
long buffer_initial_length
Definition: generator.h:76
PRIsVALUE
#define PRIsVALUE
Definition: ruby.h:166
hash_foreach_arg::buffer
FBuffer * buffer
Definition: generator.c:723
FIX2LONG
#define FIX2LONG(x)
Definition: ruby.h:394
ID2SYM
#define ID2SYM(x)
Definition: ruby.h:414
rb_obj_instance_variables
#define rb_obj_instance_variables(object)
Definition: generator.h:20
GET_STATE
#define GET_STATE(self)
Definition: generator.h:82
rb_define_alias
void rb_define_alias(VALUE klass, const char *name1, const char *name2)
Defines an alias of a method.
Definition: class.c:1800
rb_respond_to
int rb_respond_to(VALUE, ID)
Definition: vm_method.c:2190
ALLOC_N
#define ALLOC_N(type, n)
Definition: ruby.h:1663
rb_raise
void rb_raise(VALUE exc, const char *fmt,...)
Definition: error.c:2669
rb_ary_entry
VALUE rb_ary_entry(VALUE ary, long offset)
Definition: array.c:1512
JSON_Generator_StateStruct::array_delim
FBuffer * array_delim
Definition: generator.h:69
void
void
Definition: rb_mjit_min_header-2.7.1.h:13278
rb_obj_class
VALUE rb_obj_class(VALUE)
Equivalent to Object#class in Ruby.
Definition: object.c:217
UTF8
unsigned char UTF8
Definition: generator.h:31
rb_encoding
const typedef OnigEncodingType rb_encoding
Definition: encoding.h:115
rb_str_intern
VALUE rb_str_intern(VALUE)
Definition: symbol.c:710
rb_iv_get
VALUE rb_iv_get(VALUE, const char *)
Definition: variable.c:3294
JSON_Generator_StateStruct::allow_nan
char allow_nan
Definition: generator.h:73
T_FIXNUM
#define T_FIXNUM
Definition: ruby.h:535
FBUFFER_INITIAL_LENGTH_DEFAULT
#define FBUFFER_INITIAL_LENGTH_DEFAULT
Definition: fbuffer.h:53
JSON_Generator_StateStruct::indent
char * indent
Definition: generator.h:59
UNI_SUR_LOW_START
#define UNI_SUR_LOW_START
Definition: generator.h:41
rb_cSymbol
RUBY_EXTERN VALUE rb_cSymbol
Definition: ruby.h:2046
UNI_SUR_HIGH_START
#define UNI_SUR_HIGH_START
Definition: generator.h:39
hash_foreach_arg::iter
int iter
Definition: generator.c:726
GET_STATE_TO
#define GET_STATE_TO(self, state)
Definition: generator.h:79
isnan
#define isnan(x)
Definition: win32.h:369
rb_require
VALUE rb_require(const char *)
Definition: load.c:1117
size
int size
Definition: encoding.c:58
Init_generator
void Init_generator(void)
Definition: generator.c:1391
JSON_Generator_StateStruct::max_nesting
long max_nesting
Definition: generator.h:72
FIXNUM_P
#define FIXNUM_P(f)
Definition: ruby.h:396
rb_hash_foreach
void rb_hash_foreach(VALUE hash, rb_foreach_func *func, VALUE farg)
Definition: hash.c:1483
StringValueCStr
#define StringValueCStr(v)
Definition: ruby.h:604
rb_cHash
VALUE rb_cHash
Definition: hash.c:92
key
key
Definition: openssl_missing.h:181
T_HASH
#define T_HASH
Definition: ruby.h:531
CLASS_OF
#define CLASS_OF(v)
Definition: ruby.h:484
RARRAY_LEN
#define RARRAY_LEN(a)
Definition: ruby.h:1070
rb_scan_args
#define rb_scan_args(argc, argvp, fmt,...)
Definition: rb_mjit_min_header-2.7.1.h:6372
UNI_MAX_UTF16
#define UNI_MAX_UTF16
Definition: generator.h:35
rb_cObject
RUBY_EXTERN VALUE rb_cObject
Definition: ruby.h:2010
buf
unsigned char buf[MIME_BUF_SIZE]
Definition: nkf.c:4322
JSON_Generator_StateStruct::object_delim2
FBuffer * object_delim2
Definition: generator.h:71
T_BIGNUM
#define T_BIGNUM
Definition: ruby.h:533
JSON_Generator_StateStruct::space_before
char * space_before
Definition: generator.h:63
argv
char ** argv
Definition: ruby.c:223
UTF32
unsigned long UTF32
Definition: generator.h:29
ST_CONTINUE
@ ST_CONTINUE
Definition: st.h:99
rb_utf8_encoding
rb_encoding * rb_utf8_encoding(void)
Definition: encoding.c:1328
rb_convert_type
VALUE rb_convert_type(VALUE, int, const char *, const char *)
Converts an object into another type.
Definition: object.c:2900
RUBY_TYPED_FREE_IMMEDIATELY
#define RUBY_TYPED_FREE_IMMEDIATELY
Definition: ruby.h:1207
UTF16
unsigned short UTF16
Definition: generator.h:30
MEMCPY
#define MEMCPY(p1, p2, type, n)
Definition: ruby.h:1753
rb_hash_aset
VALUE rb_hash_aset(VALUE hash, VALUE key, VALUE val)
Definition: hash.c:2847
rb_cString
RUBY_EXTERN VALUE rb_cString
Definition: ruby.h:2044
NIL_P
#define NIL_P(v)
Definition: ruby.h:482
memcpy
void * memcpy(void *__restrict, const void *__restrict, size_t)
JSON_Generator_StateStruct::ascii_only
char ascii_only
Definition: generator.h:74
argc
int argc
Definition: ruby.c:222
FBufferStruct
Definition: fbuffer.h:46
JSON_Generator_StateStruct::array_nl
char * array_nl
Definition: generator.h:67
rb_data_type_struct
Definition: ruby.h:1148
RFLOAT_VALUE
#define RFLOAT_VALUE(v)
Definition: ruby.h:966
FBUFFER_PTR
#define FBUFFER_PTR(fb)
Definition: fbuffer.h:55
JSON_Generator_StateStruct::space_len
long space_len
Definition: generator.h:62
JSON_Generator_StateStruct::space_before_len
long space_before_len
Definition: generator.h:64
rb_path2class
VALUE rb_path2class(const char *)
Definition: variable.c:268
Qtrue
#define Qtrue
Definition: ruby.h:468
rb_class_name
VALUE rb_class_name(VALUE)
Definition: variable.c:274
len
uint8_t len
Definition: escape.c:17
GENERATE_JSON
#define GENERATE_JSON(type)
Definition: generator.h:86
FBUFFER_LEN
#define FBUFFER_LEN(fb)
Definition: fbuffer.h:56
LONG2FIX
#define LONG2FIX(i)
Definition: ruby.h:265
rb_ivar_set
VALUE rb_ivar_set(VALUE, ID, VALUE)
Definition: variable.c:1300
rb_intern_str
#define rb_intern_str(string)
Definition: generator.h:16
T_STRING
#define T_STRING
Definition: ruby.h:528
rb_define_class_under
VALUE rb_define_class_under(VALUE outer, const char *name, VALUE super)
Defines a class under the namespace of outer.
Definition: class.c:698
rb_str_encode
VALUE rb_str_encode(VALUE str, VALUE to, int ecflags, VALUE ecopts)
Definition: transcode.c:2870
rb_enc_str_asciionly_p
int rb_enc_str_asciionly_p(VALUE)
Definition: string.c:678
Qnil
#define Qnil
Definition: ruby.h:469
RB_GC_GUARD
#define RB_GC_GUARD(v)
Definition: ruby.h:585
RSTRING_LEN
#define RSTRING_LEN(str)
Definition: ruby.h:1005
generator.h
hash_foreach_arg::Vstate
VALUE Vstate
Definition: generator.c:725
JSON_Generator_StateStruct::indent_len
long indent_len
Definition: generator.h:60
JSON_Generator_StateStruct::space
char * space
Definition: generator.h:61
rb_obj_is_kind_of
VALUE rb_obj_is_kind_of(VALUE, VALUE)
Determines if obj is a kind of c.
Definition: object.c:692
rb_define_alloc_func
void rb_define_alloc_func(VALUE, rb_alloc_func_t)
RTEST
#define RTEST(v)
Definition: ruby.h:481
SYM2ID
#define SYM2ID(x)
Definition: ruby.h:415
UNI_MAX_BMP
#define UNI_MAX_BMP
Definition: generator.h:34
rb_usascii_encoding
rb_encoding * rb_usascii_encoding(void)
Definition: encoding.c:1340
name
const char * name
Definition: nkf.c:208
rb_const_get
VALUE rb_const_get(VALUE, ID)
Definition: variable.c:2387