json 2.7.6 → 2.8.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1,101 +1,105 @@
1
1
  # frozen_string_literal: true
2
2
  module JSON
3
- MAP = {
4
- "\x0" => '\u0000',
5
- "\x1" => '\u0001',
6
- "\x2" => '\u0002',
7
- "\x3" => '\u0003',
8
- "\x4" => '\u0004',
9
- "\x5" => '\u0005',
10
- "\x6" => '\u0006',
11
- "\x7" => '\u0007',
12
- "\b" => '\b',
13
- "\t" => '\t',
14
- "\n" => '\n',
15
- "\xb" => '\u000b',
16
- "\f" => '\f',
17
- "\r" => '\r',
18
- "\xe" => '\u000e',
19
- "\xf" => '\u000f',
20
- "\x10" => '\u0010',
21
- "\x11" => '\u0011',
22
- "\x12" => '\u0012',
23
- "\x13" => '\u0013',
24
- "\x14" => '\u0014',
25
- "\x15" => '\u0015',
26
- "\x16" => '\u0016',
27
- "\x17" => '\u0017',
28
- "\x18" => '\u0018',
29
- "\x19" => '\u0019',
30
- "\x1a" => '\u001a',
31
- "\x1b" => '\u001b',
32
- "\x1c" => '\u001c',
33
- "\x1d" => '\u001d',
34
- "\x1e" => '\u001e',
35
- "\x1f" => '\u001f',
36
- '"' => '\"',
37
- '\\' => '\\\\',
38
- }.freeze # :nodoc:
39
-
40
- ESCAPE_PATTERN = /[\/"\\\x0-\x1f]/n # :nodoc:
41
-
42
- SCRIPT_SAFE_MAP = MAP.merge(
43
- '/' => '\\/',
44
- "\u2028".b => '\u2028',
45
- "\u2029".b => '\u2029',
46
- ).freeze
47
-
48
- SCRIPT_SAFE_ESCAPE_PATTERN = Regexp.union(ESCAPE_PATTERN, "\u2028".b, "\u2029".b)
49
-
50
- # Convert a UTF8 encoded Ruby string _string_ to a JSON string, encoded with
51
- # UTF16 big endian characters as \u????, and return it.
52
- def utf8_to_json(string, script_safe = false) # :nodoc:
53
- string = string.b
54
- if script_safe
55
- string.gsub!(SCRIPT_SAFE_ESCAPE_PATTERN) { SCRIPT_SAFE_MAP[$&] || $& }
56
- else
57
- string.gsub!(ESCAPE_PATTERN) { MAP[$&] || $& }
58
- end
59
- string.force_encoding(::Encoding::UTF_8)
60
- string
61
- end
3
+ module TruffleRuby
4
+ module Generator
5
+ MAP = {
6
+ "\x0" => '\u0000',
7
+ "\x1" => '\u0001',
8
+ "\x2" => '\u0002',
9
+ "\x3" => '\u0003',
10
+ "\x4" => '\u0004',
11
+ "\x5" => '\u0005',
12
+ "\x6" => '\u0006',
13
+ "\x7" => '\u0007',
14
+ "\b" => '\b',
15
+ "\t" => '\t',
16
+ "\n" => '\n',
17
+ "\xb" => '\u000b',
18
+ "\f" => '\f',
19
+ "\r" => '\r',
20
+ "\xe" => '\u000e',
21
+ "\xf" => '\u000f',
22
+ "\x10" => '\u0010',
23
+ "\x11" => '\u0011',
24
+ "\x12" => '\u0012',
25
+ "\x13" => '\u0013',
26
+ "\x14" => '\u0014',
27
+ "\x15" => '\u0015',
28
+ "\x16" => '\u0016',
29
+ "\x17" => '\u0017',
30
+ "\x18" => '\u0018',
31
+ "\x19" => '\u0019',
32
+ "\x1a" => '\u001a',
33
+ "\x1b" => '\u001b',
34
+ "\x1c" => '\u001c',
35
+ "\x1d" => '\u001d',
36
+ "\x1e" => '\u001e',
37
+ "\x1f" => '\u001f',
38
+ '"' => '\"',
39
+ '\\' => '\\\\',
40
+ }.freeze # :nodoc:
41
+
42
+ ESCAPE_PATTERN = /[\/"\\\x0-\x1f]/n # :nodoc:
43
+
44
+ SCRIPT_SAFE_MAP = MAP.merge(
45
+ '/' => '\\/',
46
+ "\u2028".b => '\u2028',
47
+ "\u2029".b => '\u2029',
48
+ ).freeze
49
+
50
+ SCRIPT_SAFE_ESCAPE_PATTERN = Regexp.union(ESCAPE_PATTERN, "\u2028".b, "\u2029".b)
51
+
52
+ # Convert a UTF8 encoded Ruby string _string_ to a JSON string, encoded with
53
+ # UTF16 big endian characters as \u????, and return it.
54
+ def utf8_to_json(string, script_safe = false) # :nodoc:
55
+ string = string.b
56
+ if script_safe
57
+ string.gsub!(SCRIPT_SAFE_ESCAPE_PATTERN) { SCRIPT_SAFE_MAP[$&] || $& }
58
+ else
59
+ string.gsub!(ESCAPE_PATTERN) { MAP[$&] || $& }
60
+ end
61
+ string.force_encoding(::Encoding::UTF_8)
62
+ string
63
+ end
62
64
 
63
- def utf8_to_json_ascii(string, script_safe = false) # :nodoc:
64
- string = string.b
65
- map = script_safe ? SCRIPT_SAFE_MAP : MAP
66
- string.gsub!(/[\/"\\\x0-\x1f]/n) { map[$&] || $& }
67
- string.gsub!(/(
68
- (?:
69
- [\xc2-\xdf][\x80-\xbf] |
70
- [\xe0-\xef][\x80-\xbf]{2} |
71
- [\xf0-\xf4][\x80-\xbf]{3}
72
- )+ |
73
- [\x80-\xc1\xf5-\xff] # invalid
74
- )/nx) { |c|
75
- c.size == 1 and raise GeneratorError, "invalid utf8 byte: '#{c}'"
76
- s = c.encode(::Encoding::UTF_16BE, ::Encoding::UTF_8).unpack('H*')[0]
77
- s.force_encoding(::Encoding::ASCII_8BIT)
78
- s.gsub!(/.{4}/n, '\\\\u\&')
79
- s.force_encoding(::Encoding::UTF_8)
80
- }
81
- string.force_encoding(::Encoding::UTF_8)
82
- string
83
- rescue => e
84
- raise GeneratorError.wrap(e)
85
- end
65
+ def utf8_to_json_ascii(string, script_safe = false) # :nodoc:
66
+ string = string.b
67
+ map = script_safe ? SCRIPT_SAFE_MAP : MAP
68
+ string.gsub!(/[\/"\\\x0-\x1f]/n) { map[$&] || $& }
69
+ string.gsub!(/(
70
+ (?:
71
+ [\xc2-\xdf][\x80-\xbf] |
72
+ [\xe0-\xef][\x80-\xbf]{2} |
73
+ [\xf0-\xf4][\x80-\xbf]{3}
74
+ )+ |
75
+ [\x80-\xc1\xf5-\xff] # invalid
76
+ )/nx) { |c|
77
+ c.size == 1 and raise GeneratorError, "invalid utf8 byte: '#{c}'"
78
+ s = c.encode(::Encoding::UTF_16BE, ::Encoding::UTF_8).unpack('H*')[0]
79
+ s.force_encoding(::Encoding::BINARY)
80
+ s.gsub!(/.{4}/n, '\\\\u\&')
81
+ s.force_encoding(::Encoding::UTF_8)
82
+ }
83
+ string.force_encoding(::Encoding::UTF_8)
84
+ string
85
+ rescue => e
86
+ raise GeneratorError.wrap(e)
87
+ end
86
88
 
87
- def valid_utf8?(string)
88
- encoding = string.encoding
89
- (encoding == Encoding::UTF_8 || encoding == Encoding::ASCII) &&
90
- string.valid_encoding?
91
- end
92
- module_function :utf8_to_json, :utf8_to_json_ascii, :valid_utf8?
89
+ def valid_utf8?(string)
90
+ encoding = string.encoding
91
+ (encoding == Encoding::UTF_8 || encoding == Encoding::ASCII) &&
92
+ string.valid_encoding?
93
+ end
94
+ module_function :utf8_to_json, :utf8_to_json_ascii, :valid_utf8?
93
95
 
94
- module Pure
95
- module Generator
96
96
  # This class is used to create State instances, that are use to hold data
97
97
  # while generating a JSON text from a Ruby data structure.
98
98
  class State
99
+ def self.generate(obj, opts = nil)
100
+ new(opts).generate(obj)
101
+ end
102
+
99
103
  # Creates a State object from _opts_, which ought to be Hash to create
100
104
  # a new State instance configured by _opts_, something else to create
101
105
  # an unconfigured instance. If _opts_ is a State object, it is just
@@ -130,7 +134,7 @@ module JSON
130
134
  # * *allow_nan*: true if NaN, Infinity, and -Infinity should be
131
135
  # generated, otherwise an exception is thrown, if these values are
132
136
  # encountered. This options defaults to false.
133
- def initialize(opts = {})
137
+ def initialize(opts = nil)
134
138
  @indent = ''
135
139
  @space = ''
136
140
  @space_before = ''
@@ -138,10 +142,12 @@ module JSON
138
142
  @array_nl = ''
139
143
  @allow_nan = false
140
144
  @ascii_only = false
141
- @script_safe = false
142
- @strict = false
145
+ @depth = 0
143
146
  @buffer_initial_length = 1024
144
- configure opts
147
+ @script_safe = false
148
+ @strict = false
149
+ @max_nesting = 100
150
+ configure(opts) if opts
145
151
  end
146
152
 
147
153
  # This string is used to indent levels in the JSON text.
@@ -294,27 +300,25 @@ module JSON
294
300
  else
295
301
  result = obj.to_json(self)
296
302
  end
297
- JSON.valid_utf8?(result) or raise GeneratorError,
303
+ JSON::TruffleRuby::Generator.valid_utf8?(result) or raise GeneratorError,
298
304
  "source sequence #{result.inspect} is illegal/malformed utf-8"
299
305
  result
300
306
  end
301
307
 
302
308
  # Handles @allow_nan, @buffer_initial_length, other ivars must be the default value (see above)
303
309
  private def generate_json(obj, buf)
304
- klass = obj.class
305
- if klass == Hash
310
+ case obj
311
+ when Hash
306
312
  buf << '{'
307
313
  first = true
308
314
  obj.each_pair do |k,v|
309
315
  buf << ',' unless first
310
316
 
311
317
  key_str = k.to_s
312
- if key_str.is_a?(::String)
313
- if key_str.class == ::String
314
- fast_serialize_string(key_str, buf)
315
- else
316
- generate_json(key_str, buf)
317
- end
318
+ if key_str.class == String
319
+ fast_serialize_string(key_str, buf)
320
+ elsif key_str.is_a?(String)
321
+ generate_json(key_str, buf)
318
322
  else
319
323
  raise TypeError, "#{k.class}#to_s returns an instance of #{key_str.class}, expected a String"
320
324
  end
@@ -324,7 +328,7 @@ module JSON
324
328
  first = false
325
329
  end
326
330
  buf << '}'
327
- elsif klass == Array
331
+ when Array
328
332
  buf << '['
329
333
  first = true
330
334
  obj.each do |e|
@@ -333,9 +337,13 @@ module JSON
333
337
  first = false
334
338
  end
335
339
  buf << ']'
336
- elsif klass == String
337
- fast_serialize_string(obj, buf)
338
- elsif klass == Integer
340
+ when String
341
+ if obj.class == String
342
+ fast_serialize_string(obj, buf)
343
+ else
344
+ buf << obj.to_json(self)
345
+ end
346
+ when Integer
339
347
  buf << obj.to_s
340
348
  else
341
349
  # Note: Float is handled this way since Float#to_s is slow anyway
@@ -344,24 +352,23 @@ module JSON
344
352
  end
345
353
 
346
354
  # Assumes !@ascii_only, !@script_safe
347
- if Regexp.method_defined?(:match?)
348
- private def fast_serialize_string(string, buf) # :nodoc:
349
- buf << '"'
350
- string = string.encode(::Encoding::UTF_8) unless string.encoding == ::Encoding::UTF_8
351
- raise GeneratorError, "source sequence is illegal/malformed utf-8" unless string.valid_encoding?
352
-
353
- if /["\\\x0-\x1f]/n.match?(string)
354
- buf << string.gsub(/["\\\x0-\x1f]/n, MAP)
355
- else
356
- buf << string
355
+ private def fast_serialize_string(string, buf) # :nodoc:
356
+ buf << '"'
357
+ unless string.encoding == ::Encoding::UTF_8
358
+ begin
359
+ string = string.encode(::Encoding::UTF_8)
360
+ rescue Encoding::UndefinedConversionError => error
361
+ raise GeneratorError, error.message
357
362
  end
358
- buf << '"'
359
363
  end
360
- else
361
- # Ruby 2.3 compatibility
362
- private def fast_serialize_string(string, buf) # :nodoc:
363
- buf << string.to_json(self)
364
+ raise GeneratorError, "source sequence is illegal/malformed utf-8" unless string.valid_encoding?
365
+
366
+ if /["\\\x0-\x1f]/n.match?(string)
367
+ buf << string.gsub(/["\\\x0-\x1f]/n, MAP)
368
+ else
369
+ buf << string
364
370
  end
371
+ buf << '"'
365
372
  end
366
373
 
367
374
  # Return the value returned by method +name+.
@@ -417,9 +424,15 @@ module JSON
417
424
  end
418
425
 
419
426
  def json_transform(state)
427
+ depth = state.depth += 1
428
+
429
+ if empty?
430
+ state.depth -= 1
431
+ return '{}'
432
+ end
433
+
420
434
  delim = ",#{state.object_nl}"
421
435
  result = +"{#{state.object_nl}"
422
- depth = state.depth += 1
423
436
  first = true
424
437
  indent = !state.object_nl.empty?
425
438
  each { |key, value|
@@ -427,8 +440,8 @@ module JSON
427
440
  result << state.indent * depth if indent
428
441
 
429
442
  key_str = key.to_s
430
- key_json = if key_str.is_a?(::String)
431
- key_str = key_str.to_json(state)
443
+ if key_str.is_a?(String)
444
+ key_json = key_str.to_json(state)
432
445
  else
433
446
  raise TypeError, "#{key.class}#to_s returns an instance of #{key_str.class}, expected a String"
434
447
  end
@@ -467,6 +480,13 @@ module JSON
467
480
  private
468
481
 
469
482
  def json_transform(state)
483
+ depth = state.depth += 1
484
+
485
+ if empty?
486
+ state.depth -= 1
487
+ return '[]'
488
+ end
489
+
470
490
  result = '['.dup
471
491
  if state.array_nl.empty?
472
492
  delim = ","
@@ -474,7 +494,7 @@ module JSON
474
494
  result << state.array_nl
475
495
  delim = ",#{state.array_nl}"
476
496
  end
477
- depth = state.depth += 1
497
+
478
498
  first = true
479
499
  indent = !state.array_nl.empty?
480
500
  each { |value|
@@ -539,10 +559,12 @@ module JSON
539
559
  string = encode(::Encoding::UTF_8)
540
560
  end
541
561
  if state.ascii_only?
542
- %("#{JSON.utf8_to_json_ascii(string, state.script_safe)}")
562
+ %("#{JSON::TruffleRuby::Generator.utf8_to_json_ascii(string, state.script_safe)}")
543
563
  else
544
- %("#{JSON.utf8_to_json(string, state.script_safe)}")
564
+ %("#{JSON::TruffleRuby::Generator.utf8_to_json(string, state.script_safe)}")
545
565
  end
566
+ rescue Encoding::UndefinedConversionError => error
567
+ raise ::JSON::GeneratorError, error.message
546
568
  end
547
569
 
548
570
  # Module that holds the extending methods if, the String module is
data/lib/json/version.rb CHANGED
@@ -1,5 +1,5 @@
1
1
  # frozen_string_literal: true
2
2
 
3
3
  module JSON
4
- VERSION = '2.7.6'
4
+ VERSION = '2.8.1'
5
5
  end
data/lib/json.rb CHANGED
@@ -378,13 +378,13 @@ require 'json/common'
378
378
  # json1 = JSON.generate(ruby)
379
379
  # ruby1 = JSON.parse(json1, create_additions: true)
380
380
  # # Make a nice display.
381
- # display = <<EOT
382
- # Generated JSON:
383
- # Without addition: #{json0} (#{json0.class})
384
- # With addition: #{json1} (#{json1.class})
385
- # Parsed JSON:
386
- # Without addition: #{ruby0.inspect} (#{ruby0.class})
387
- # With addition: #{ruby1.inspect} (#{ruby1.class})
381
+ # display = <<~EOT
382
+ # Generated JSON:
383
+ # Without addition: #{json0} (#{json0.class})
384
+ # With addition: #{json1} (#{json1.class})
385
+ # Parsed JSON:
386
+ # Without addition: #{ruby0.inspect} (#{ruby0.class})
387
+ # With addition: #{ruby1.inspect} (#{ruby1.class})
388
388
  # EOT
389
389
  # puts display
390
390
  #
@@ -562,13 +562,13 @@ require 'json/common'
562
562
  # json1 = JSON.generate(foo1)
563
563
  # obj1 = JSON.parse(json1, create_additions: true)
564
564
  # # Make a nice display.
565
- # display = <<EOT
566
- # Generated JSON:
567
- # Without custom addition: #{json0} (#{json0.class})
568
- # With custom addition: #{json1} (#{json1.class})
569
- # Parsed JSON:
570
- # Without custom addition: #{obj0.inspect} (#{obj0.class})
571
- # With custom addition: #{obj1.inspect} (#{obj1.class})
565
+ # display = <<~EOT
566
+ # Generated JSON:
567
+ # Without custom addition: #{json0} (#{json0.class})
568
+ # With custom addition: #{json1} (#{json1.class})
569
+ # Parsed JSON:
570
+ # Without custom addition: #{obj0.inspect} (#{obj0.class})
571
+ # With custom addition: #{obj1.inspect} (#{obj1.class})
572
572
  # EOT
573
573
  # puts display
574
574
  #
@@ -583,10 +583,5 @@ require 'json/common'
583
583
  #
584
584
  module JSON
585
585
  require 'json/version'
586
-
587
- begin
588
- require 'json/ext'
589
- rescue LoadError
590
- require 'json/pure'
591
- end
586
+ require 'json/ext'
592
587
  end
metadata CHANGED
@@ -1,14 +1,14 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: json
3
3
  version: !ruby/object:Gem::Version
4
- version: 2.7.6
4
+ version: 2.8.1
5
5
  platform: ruby
6
6
  authors:
7
7
  - Florian Frank
8
8
  autorequire:
9
9
  bindir: bin
10
10
  cert_chain: []
11
- date: 2024-11-04 00:00:00.000000000 Z
11
+ date: 2024-11-06 00:00:00.000000000 Z
12
12
  dependencies: []
13
13
  description: This is a JSON implementation as a Ruby extension in C.
14
14
  email: flori@ping.de
@@ -27,10 +27,8 @@ files:
27
27
  - ext/json/ext/fbuffer/fbuffer.h
28
28
  - ext/json/ext/generator/extconf.rb
29
29
  - ext/json/ext/generator/generator.c
30
- - ext/json/ext/generator/generator.h
31
30
  - ext/json/ext/parser/extconf.rb
32
31
  - ext/json/ext/parser/parser.c
33
- - ext/json/ext/parser/parser.h
34
32
  - ext/json/ext/parser/parser.rl
35
33
  - json.gemspec
36
34
  - lib/json.rb
@@ -52,9 +50,7 @@ files:
52
50
  - lib/json/ext.rb
53
51
  - lib/json/ext/generator/state.rb
54
52
  - lib/json/generic_object.rb
55
- - lib/json/pure.rb
56
- - lib/json/pure/generator.rb
57
- - lib/json/pure/parser.rb
53
+ - lib/json/truffle_ruby/generator.rb
58
54
  - lib/json/version.rb
59
55
  homepage: https://ruby.github.io/json
60
56
  licenses:
@@ -78,7 +74,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
78
74
  requirements:
79
75
  - - ">="
80
76
  - !ruby/object:Gem::Version
81
- version: '2.3'
77
+ version: '2.7'
82
78
  required_rubygems_version: !ruby/object:Gem::Requirement
83
79
  requirements:
84
80
  - - ">="
@@ -1,118 +0,0 @@
1
- #ifndef _GENERATOR_H_
2
- #define _GENERATOR_H_
3
-
4
- #include <math.h>
5
- #include <ctype.h>
6
-
7
- #include "ruby.h"
8
-
9
- /* This is the fallback definition from Ruby 3.4 */
10
- #ifndef RBIMPL_STDBOOL_H
11
- #if defined(__cplusplus)
12
- # if defined(HAVE_STDBOOL_H) && (__cplusplus >= 201103L)
13
- # include <cstdbool>
14
- # endif
15
- #elif defined(HAVE_STDBOOL_H)
16
- # include <stdbool.h>
17
- #elif !defined(HAVE__BOOL)
18
- typedef unsigned char _Bool;
19
- # define bool _Bool
20
- # define true ((_Bool)+1)
21
- # define false ((_Bool)+0)
22
- # define __bool_true_false_are_defined
23
- #endif
24
- #endif
25
-
26
- static char *fstrndup(const char *ptr, unsigned long len);
27
-
28
- /* ruby api and some helpers */
29
-
30
- typedef struct JSON_Generator_StateStruct {
31
- char *indent;
32
- long indent_len;
33
- char *space;
34
- long space_len;
35
- char *space_before;
36
- long space_before_len;
37
- char *object_nl;
38
- long object_nl_len;
39
- char *array_nl;
40
- long array_nl_len;
41
- long max_nesting;
42
- char allow_nan;
43
- char ascii_only;
44
- char script_safe;
45
- char strict;
46
- long depth;
47
- long buffer_initial_length;
48
- } JSON_Generator_State;
49
-
50
- #define GET_STATE_TO(self, state) \
51
- TypedData_Get_Struct(self, JSON_Generator_State, &JSON_Generator_State_type, state)
52
-
53
- #define GET_STATE(self) \
54
- JSON_Generator_State *state; \
55
- GET_STATE_TO(self, state)
56
-
57
-
58
- static VALUE mHash_to_json(int argc, VALUE *argv, VALUE self);
59
- static VALUE mArray_to_json(int argc, VALUE *argv, VALUE self);
60
- #ifdef RUBY_INTEGER_UNIFICATION
61
- static VALUE mInteger_to_json(int argc, VALUE *argv, VALUE self);
62
- #else
63
- static VALUE mFixnum_to_json(int argc, VALUE *argv, VALUE self);
64
- static VALUE mBignum_to_json(int argc, VALUE *argv, VALUE self);
65
- #endif
66
- static VALUE mFloat_to_json(int argc, VALUE *argv, VALUE self);
67
- static VALUE mString_included_s(VALUE self, VALUE modul);
68
- static VALUE mString_to_json(int argc, VALUE *argv, VALUE self);
69
- static VALUE mString_to_json_raw_object(VALUE self);
70
- static VALUE mString_to_json_raw(int argc, VALUE *argv, VALUE self);
71
- static VALUE mString_Extend_json_create(VALUE self, VALUE o);
72
- static VALUE mTrueClass_to_json(int argc, VALUE *argv, VALUE self);
73
- static VALUE mFalseClass_to_json(int argc, VALUE *argv, VALUE self);
74
- static VALUE mNilClass_to_json(int argc, VALUE *argv, VALUE self);
75
- static VALUE mObject_to_json(int argc, VALUE *argv, VALUE self);
76
- static void State_free(void *state);
77
- static VALUE cState_s_allocate(VALUE klass);
78
- static void generate_json(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj);
79
- static void generate_json_object(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj);
80
- static void generate_json_array(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj);
81
- static void generate_json_string(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj);
82
- static void generate_json_null(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj);
83
- static void generate_json_false(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj);
84
- static void generate_json_true(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj);
85
- #ifdef RUBY_INTEGER_UNIFICATION
86
- static void generate_json_integer(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj);
87
- #endif
88
- static void generate_json_fixnum(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj);
89
- static void generate_json_bignum(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj);
90
- static void generate_json_float(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj);
91
- static VALUE cState_partial_generate(VALUE self, VALUE obj, void (*func)(FBuffer *buffer, VALUE Vstate, JSON_Generator_State *state, VALUE obj));
92
- static VALUE cState_generate(VALUE self, VALUE obj);
93
- static VALUE cState_from_state_s(VALUE self, VALUE opts);
94
- static VALUE cState_indent(VALUE self);
95
- static VALUE cState_indent_set(VALUE self, VALUE indent);
96
- static VALUE cState_space(VALUE self);
97
- static VALUE cState_space_set(VALUE self, VALUE space);
98
- static VALUE cState_space_before(VALUE self);
99
- static VALUE cState_space_before_set(VALUE self, VALUE space_before);
100
- static VALUE cState_object_nl(VALUE self);
101
- static VALUE cState_object_nl_set(VALUE self, VALUE object_nl);
102
- static VALUE cState_array_nl(VALUE self);
103
- static VALUE cState_array_nl_set(VALUE self, VALUE array_nl);
104
- static VALUE cState_max_nesting(VALUE self);
105
- static VALUE cState_max_nesting_set(VALUE self, VALUE depth);
106
- static VALUE cState_allow_nan_p(VALUE self);
107
- static VALUE cState_ascii_only_p(VALUE self);
108
- static VALUE cState_depth(VALUE self);
109
- static VALUE cState_depth_set(VALUE self, VALUE depth);
110
- static VALUE cState_script_safe(VALUE self);
111
- static VALUE cState_script_safe_set(VALUE self, VALUE depth);
112
- static VALUE cState_strict(VALUE self);
113
- static VALUE cState_strict_set(VALUE self, VALUE strict);
114
- static FBuffer *cState_prepare_buffer(VALUE self);
115
-
116
- static const rb_data_type_t JSON_Generator_State_type;
117
-
118
- #endif
@@ -1,60 +0,0 @@
1
- #ifndef _PARSER_H_
2
- #define _PARSER_H_
3
-
4
- #include "ruby.h"
5
-
6
- #ifndef MAYBE_UNUSED
7
- # define MAYBE_UNUSED(x) x
8
- #endif
9
-
10
- #define option_given_p(opts, key) (rb_hash_lookup2(opts, key, Qundef) != Qundef)
11
-
12
- typedef struct JSON_ParserStruct {
13
- VALUE Vsource;
14
- char *source;
15
- long len;
16
- char *memo;
17
- VALUE create_id;
18
- int max_nesting;
19
- int allow_nan;
20
- int parsing_name;
21
- int symbolize_names;
22
- int freeze;
23
- VALUE object_class;
24
- VALUE array_class;
25
- VALUE decimal_class;
26
- int create_additions;
27
- VALUE match_string;
28
- FBuffer *fbuffer;
29
- } JSON_Parser;
30
-
31
- #define GET_PARSER \
32
- GET_PARSER_INIT; \
33
- if (!json->Vsource) rb_raise(rb_eTypeError, "uninitialized instance")
34
- #define GET_PARSER_INIT \
35
- JSON_Parser *json; \
36
- TypedData_Get_Struct(self, JSON_Parser, &JSON_Parser_type, json)
37
-
38
- #define MinusInfinity "-Infinity"
39
- #define EVIL 0x666
40
-
41
- static uint32_t unescape_unicode(const unsigned char *p);
42
- static int convert_UTF32_to_UTF8(char *buf, uint32_t ch);
43
- static char *JSON_parse_object(JSON_Parser *json, char *p, char *pe, VALUE *result, int current_nesting);
44
- static char *JSON_parse_value(JSON_Parser *json, char *p, char *pe, VALUE *result, int current_nesting);
45
- static char *JSON_parse_integer(JSON_Parser *json, char *p, char *pe, VALUE *result);
46
- static char *JSON_parse_float(JSON_Parser *json, char *p, char *pe, VALUE *result);
47
- static char *JSON_parse_array(JSON_Parser *json, char *p, char *pe, VALUE *result, int current_nesting);
48
- static VALUE json_string_unescape(char *string, char *stringEnd, int intern, int symbolize);
49
- static char *JSON_parse_string(JSON_Parser *json, char *p, char *pe, VALUE *result);
50
- static VALUE convert_encoding(VALUE source);
51
- static VALUE cParser_initialize(int argc, VALUE *argv, VALUE self);
52
- static VALUE cParser_parse(VALUE self);
53
- static void JSON_mark(void *json);
54
- static void JSON_free(void *json);
55
- static VALUE cJSON_parser_s_allocate(VALUE klass);
56
- static VALUE cParser_source(VALUE self);
57
-
58
- static const rb_data_type_t JSON_Parser_type;
59
-
60
- #endif