Regenerate the Java parser

byroot · byroot · commit db89486fff9b · 2025-09-18T10:53:16.000+02:00
diff --git a/java/src/json/ext/ParserConfig.java b/java/src/json/ext/ParserConfig.java
@@ -301,11 +301,11 @@ private RaiseException unexpectedToken(ThreadContext context, int absStart, int
             return parsingError(context, "unexpected token at '", absStart, absEnd);
         }
 
-
+        
 // line 328 "ParserConfig.rl"
 
 
-
+        
 // line 310 "ParserConfig.java"
 private static byte[] init__JSON_value_actions_0()
 {
@@ -427,14 +427,14 @@ void parseValue(ThreadContext context, ParserResult res, int p, int pe) {
             int cs;
             IRubyObject result = null;
 
-
+            
 // line 432 "ParserConfig.java"
 	{
 	cs = JSON_value_start;
 	}
 
 // line 441 "ParserConfig.rl"
-
+            
 // line 439 "ParserConfig.java"
 	{
 	int _klen;
@@ -671,7 +671,7 @@ else if ( data[p] > _JSON_value_trans_keys[_mid+1] )
             }
         }
 
-
+        
 // line 676 "ParserConfig.java"
 private static byte[] init__JSON_integer_actions_0()
 {
@@ -733,15 +733,15 @@ private static byte[] init__JSON_integer_index_offsets_0()
 private static final byte _JSON_integer_index_offsets[] = init__JSON_integer_index_offsets_0();
 
 
-private static byte[] init__JSON_integer_indices_0()
+private static byte[] init__JSON_integer_indicies_0()
 {
 	return new byte [] {
 	    0,    2,    3,    1,    2,    3,    1,    1,    4,    1,    3,    4,
 	    0
 	};
 }
 
-private static final byte _JSON_integer_indices[] = init__JSON_integer_indices_0();
+private static final byte _JSON_integer_indicies[] = init__JSON_integer_indicies_0();
 
 
 private static byte[] init__JSON_integer_trans_targs_0()
@@ -787,15 +787,15 @@ void parseInteger(ThreadContext context, ParserResult res, int p, int pe) {
         int parseIntegerInternal(int p, int pe) {
             int cs;
 
-
+            
 // line 792 "ParserConfig.java"
 	{
 	cs = JSON_integer_start;
 	}
 
 // line 480 "ParserConfig.rl"
             int memo = p;
-
+            
 // line 800 "ParserConfig.java"
 	{
 	int _klen;
@@ -866,7 +866,7 @@ else if ( data[p] > _JSON_integer_trans_keys[_mid+1] )
 	}
 	} while (false);
 
-	_trans = _JSON_integer_indices[_trans];
+	_trans = _JSON_integer_indicies[_trans];
 	cs = _JSON_integer_trans_targs[_trans];
 
 	if ( _JSON_integer_trans_actions[_trans] != 0 ) {
@@ -922,7 +922,7 @@ RubyInteger bytesToInum(Ruby runtime, ByteList num) {
             return ConvertBytes.byteListToInum(runtime, num, 10, true);
         }
 
-
+        
 // line 927 "ParserConfig.java"
 private static byte[] init__JSON_float_actions_0()
 {
@@ -986,7 +986,7 @@ private static byte[] init__JSON_float_index_offsets_0()
 private static final byte _JSON_float_index_offsets[] = init__JSON_float_index_offsets_0();
 
 
-private static byte[] init__JSON_float_indices_0()
+private static byte[] init__JSON_float_indicies_0()
 {
 	return new byte [] {
 	    0,    2,    3,    1,    2,    3,    1,    4,    5,    5,    1,    6,
@@ -995,7 +995,7 @@ private static byte[] init__JSON_float_indices_0()
 	};
 }
 
-private static final byte _JSON_float_indices[] = init__JSON_float_indices_0();
+private static final byte _JSON_float_indicies[] = init__JSON_float_indicies_0();
 
 
 private static byte[] init__JSON_float_trans_targs_0()
@@ -1043,15 +1043,15 @@ void parseFloat(ThreadContext context, ParserResult res, int p, int pe) {
         int parseFloatInternal(int p, int pe) {
             int cs;
 
-
+            
 // line 1048 "ParserConfig.java"
 	{
 	cs = JSON_float_start;
 	}
 
 // line 533 "ParserConfig.rl"
             int memo = p;
-
+            
 // line 1056 "ParserConfig.java"
 	{
 	int _klen;
@@ -1122,7 +1122,7 @@ else if ( data[p] > _JSON_float_trans_keys[_mid+1] )
 	}
 	} while (false);
 
-	_trans = _JSON_float_indices[_trans];
+	_trans = _JSON_float_indicies[_trans];
 	cs = _JSON_float_trans_targs[_trans];
 
 	if ( _JSON_float_trans_actions[_trans] != 0 ) {
@@ -1168,7 +1168,7 @@ else if ( data[p] > _JSON_float_trans_keys[_mid+1] )
             return p;
         }
 
-
+        
 // line 1173 "ParserConfig.java"
 private static byte[] init__JSON_string_actions_0()
 {
@@ -1232,7 +1232,7 @@ private static byte[] init__JSON_string_index_offsets_0()
 private static final byte _JSON_string_index_offsets[] = init__JSON_string_index_offsets_0();
 
 
-private static byte[] init__JSON_string_indices_0()
+private static byte[] init__JSON_string_indicies_0()
 {
 	return new byte [] {
 	    0,    1,    2,    3,    1,    0,    4,    1,    0,    5,    5,    5,
@@ -1241,7 +1241,7 @@ private static byte[] init__JSON_string_indices_0()
 	};
 }
 
-private static final byte _JSON_string_indices[] = init__JSON_string_indices_0();
+private static final byte _JSON_string_indicies[] = init__JSON_string_indicies_0();
 
 
 private static byte[] init__JSON_string_trans_targs_0()
@@ -1278,15 +1278,15 @@ void parseString(ThreadContext context, ParserResult res, int p, int pe) {
             int cs;
             IRubyObject result = null;
 
-
+            
 // line 1283 "ParserConfig.java"
 	{
 	cs = JSON_string_start;
 	}
 
 // line 581 "ParserConfig.rl"
             int memo = p;
-
+            
 // line 1291 "ParserConfig.java"
 	{
 	int _klen;
@@ -1357,7 +1357,7 @@ else if ( data[p] > _JSON_string_trans_keys[_mid+1] )
 	}
 	} while (false);
 
-	_trans = _JSON_string_indices[_trans];
+	_trans = _JSON_string_indicies[_trans];
 	cs = _JSON_string_trans_targs[_trans];
 
 	if ( _JSON_string_trans_actions[_trans] != 0 ) {
@@ -1429,7 +1429,7 @@ else if ( data[p] > _JSON_string_trans_keys[_mid+1] )
             }
         }
 
-
+        
 // line 1434 "ParserConfig.java"
 private static byte[] init__JSON_array_actions_0()
 {
@@ -1549,7 +1549,7 @@ private static short[] init__JSON_array_index_offsets_0()
 private static final short _JSON_array_index_offsets[] = init__JSON_array_index_offsets_0();
 
 
-private static byte[] init__JSON_array_indices_0()
+private static byte[] init__JSON_array_indicies_0()
 {
 	return new byte [] {
 	    0,    1,    0,    0,    2,    2,    3,    2,    2,    2,    4,    2,
@@ -1565,7 +1565,7 @@ private static byte[] init__JSON_array_indices_0()
 	};
 }
 
-private static final byte _JSON_array_indices[] = init__JSON_array_indices_0();
+private static final byte _JSON_array_indicies[] = init__JSON_array_indicies_0();
 
 
 private static byte[] init__JSON_array_trans_targs_0()
@@ -1610,14 +1610,14 @@ void parseArray(ThreadContext context, ParserResult res, int p, int pe) {
 
             IRubyObject result = RubyArray.newArray(context.runtime);
 
-
+            
 // line 1615 "ParserConfig.java"
 	{
 	cs = JSON_array_start;
 	}
 
 // line 650 "ParserConfig.rl"
-
+            
 // line 1622 "ParserConfig.java"
 	{
 	int _klen;
@@ -1660,7 +1660,7 @@ else if ( _widec > _JSON_array_cond_keys[_mid+1] )
 				switch ( _JSON_array_cond_spaces[_JSON_array_cond_offsets[cs] + ((_mid - _keys)>>1)] ) {
 	case 0: {
 		_widec = 65536 + (data[p] - 0);
-		if (
+		if ( 
 // line 608 "ParserConfig.rl"
  config.allowTrailingComma  ) _widec += 65536;
 		break;
@@ -1720,7 +1720,7 @@ else if ( _widec > _JSON_array_trans_keys[_mid+1] )
 	}
 	} while (false);
 
-	_trans = _JSON_array_indices[_trans];
+	_trans = _JSON_array_indicies[_trans];
 	cs = _JSON_array_trans_targs[_trans];
 
 	if ( _JSON_array_trans_actions[_trans] != 0 ) {
@@ -1779,7 +1779,7 @@ else if ( _widec > _JSON_array_trans_keys[_mid+1] )
             }
         }
 
-
+        
 // line 1784 "ParserConfig.java"
 private static byte[] init__JSON_object_actions_0()
 {
@@ -1906,7 +1906,7 @@ private static short[] init__JSON_object_index_offsets_0()
 private static final short _JSON_object_index_offsets[] = init__JSON_object_index_offsets_0();
 
 
-private static byte[] init__JSON_object_indices_0()
+private static byte[] init__JSON_object_indicies_0()
 {
 	return new byte [] {
 	    0,    1,    0,    0,    2,    3,    4,    0,    1,    5,    5,    6,
@@ -1923,7 +1923,7 @@ private static byte[] init__JSON_object_indices_0()
 	};
 }
 
-private static final byte _JSON_object_indices[] = init__JSON_object_indices_0();
+private static final byte _JSON_object_indicies[] = init__JSON_object_indicies_0();
 
 
 private static byte[] init__JSON_object_trans_targs_0()
@@ -1973,14 +1973,14 @@ void parseObject(ThreadContext context, ParserResult res, int p, int pe) {
             // allocator test at OptionsReader#getClass
             IRubyObject result = RubyHash.newHash(context.runtime);
 
-
+            
 // line 1978 "ParserConfig.java"
 	{
 	cs = JSON_object_start;
 	}
 
 // line 737 "ParserConfig.rl"
-
+            
 // line 1985 "ParserConfig.java"
 	{
 	int _klen;
@@ -2023,7 +2023,7 @@ else if ( _widec > _JSON_object_cond_keys[_mid+1] )
 				switch ( _JSON_object_cond_spaces[_JSON_object_cond_offsets[cs] + ((_mid - _keys)>>1)] ) {
 	case 0: {
 		_widec = 65536 + (data[p] - 0);
-		if (
+		if ( 
 // line 665 "ParserConfig.rl"
  config.allowTrailingComma  ) _widec += 65536;
 		break;
@@ -2083,7 +2083,7 @@ else if ( _widec > _JSON_object_trans_keys[_mid+1] )
 	}
 	} while (false);
 
-	_trans = _JSON_object_indices[_trans];
+	_trans = _JSON_object_indicies[_trans];
 	cs = _JSON_object_trans_targs[_trans];
 
 	if ( _JSON_object_trans_actions[_trans] != 0 ) {
@@ -2174,7 +2174,7 @@ else if ( _widec > _JSON_object_trans_keys[_mid+1] )
             res.update(config.onLoad(context, result), p + 1);
         }
 
-
+        
 // line 2179 "ParserConfig.java"
 private static byte[] init__JSON_actions_0()
 {
@@ -2238,7 +2238,7 @@ private static byte[] init__JSON_index_offsets_0()
 private static final byte _JSON_index_offsets[] = init__JSON_index_offsets_0();
 
 
-private static byte[] init__JSON_indices_0()
+private static byte[] init__JSON_indicies_0()
 {
 	return new byte [] {
 	    0,    0,    2,    2,    3,    2,    2,    2,    2,    2,    2,    2,
@@ -2248,7 +2248,7 @@ private static byte[] init__JSON_indices_0()
 	};
 }
 
-private static final byte _JSON_indices[] = init__JSON_indices_0();
+private static final byte _JSON_indicies[] = init__JSON_indicies_0();
 
 
 private static byte[] init__JSON_trans_targs_0()
@@ -2287,7 +2287,7 @@ public IRubyObject parseImplementation(ThreadContext context) {
             IRubyObject result = null;
             ParserResult res = new ParserResult();
 
-
+            
 // line 2292 "ParserConfig.java"
 	{
 	cs = JSON_start;
@@ -2296,7 +2296,7 @@ public IRubyObject parseImplementation(ThreadContext context) {
 // line 776 "ParserConfig.rl"
             p = byteList.begin();
             pe = p + byteList.length();
-
+            
 // line 2301 "ParserConfig.java"
 	{
 	int _klen;
@@ -2367,7 +2367,7 @@ else if ( data[p] > _JSON_trans_keys[_mid+1] )
 	}
 	} while (false);
 
-	_trans = _JSON_indices[_trans];
+	_trans = _JSON_indicies[_trans];
 	cs = _JSON_trans_targs[_trans];
 
 	if ( _JSON_trans_actions[_trans] != 0 ) {

Original file line number	Diff line number	Diff line change
`@@ -301,11 +301,11 @@ private RaiseException unexpectedToken(ThreadContext context, int absStart, int`
`301`	`301`	`return parsingError(context, "unexpected token at '", absStart, absEnd);`
`302`	`302`	`}`
`303`	`303`
`304`		`-`
	`304`	`+`
`305`	`305`	`// line 328 "ParserConfig.rl"`
`306`	`306`
`307`	`307`
`308`		`-`
	`308`	`+`
`309`	`309`	`// line 310 "ParserConfig.java"`
`310`	`310`	`private static byte[] init__JSON_value_actions_0()`
`311`	`311`	`{`
`@@ -427,14 +427,14 @@ void parseValue(ThreadContext context, ParserResult res, int p, int pe) {`
`427`	`427`	`int cs;`
`428`	`428`	`IRubyObject result = null;`
`429`	`429`
`430`		`-`
	`430`	`+`
`431`	`431`	`// line 432 "ParserConfig.java"`
`432`	`432`	`{`
`433`	`433`	`cs = JSON_value_start;`
`434`	`434`	`}`
`435`	`435`
`436`	`436`	`// line 441 "ParserConfig.rl"`
`437`		`-`
	`437`	`+`
`438`	`438`	`// line 439 "ParserConfig.java"`
`439`	`439`	`{`
`440`	`440`	`int _klen;`
`@@ -671,7 +671,7 @@ else if ( data[p] > _JSON_value_trans_keys[_mid+1] )`
`671`	`671`	`}`
`672`	`672`	`}`
`673`	`673`
`674`		`-`
	`674`	`+`
`675`	`675`	`// line 676 "ParserConfig.java"`
`676`	`676`	`private static byte[] init__JSON_integer_actions_0()`
`677`	`677`	`{`
`@@ -733,15 +733,15 @@ private static byte[] init__JSON_integer_index_offsets_0()`
`733`	`733`	`private static final byte _JSON_integer_index_offsets[] = init__JSON_integer_index_offsets_0();`
`734`	`734`
`735`	`735`
`736`		`-private static byte[] init__JSON_integer_indices_0()`
	`736`	`+private static byte[] init__JSON_integer_indicies_0()`
`737`	`737`	`{`
`738`	`738`	`return new byte [] {`
`739`	`739`	`0, 2, 3, 1, 2, 3, 1, 1, 4, 1, 3, 4,`
`740`	`740`	`0`
`741`	`741`	`};`
`742`	`742`	`}`
`743`	`743`
`744`		`-private static final byte _JSON_integer_indices[] = init__JSON_integer_indices_0();`
	`744`	`+private static final byte _JSON_integer_indicies[] = init__JSON_integer_indicies_0();`
`745`	`745`
`746`	`746`
`747`	`747`	`private static byte[] init__JSON_integer_trans_targs_0()`
`@@ -787,15 +787,15 @@ void parseInteger(ThreadContext context, ParserResult res, int p, int pe) {`
`787`	`787`	`int parseIntegerInternal(int p, int pe) {`
`788`	`788`	`int cs;`
`789`	`789`
`790`		`-`
	`790`	`+`
`791`	`791`	`// line 792 "ParserConfig.java"`
`792`	`792`	`{`
`793`	`793`	`cs = JSON_integer_start;`
`794`	`794`	`}`
`795`	`795`
`796`	`796`	`// line 480 "ParserConfig.rl"`
`797`	`797`	`int memo = p;`
`798`		`-`
	`798`	`+`
`799`	`799`	`// line 800 "ParserConfig.java"`
`800`	`800`	`{`
`801`	`801`	`int _klen;`
`@@ -866,7 +866,7 @@ else if ( data[p] > _JSON_integer_trans_keys[_mid+1] )`
`866`	`866`	`}`
`867`	`867`	`} while (false);`
`868`	`868`
`869`		`- _trans = _JSON_integer_indices[_trans];`
	`869`	`+ _trans = _JSON_integer_indicies[_trans];`
`870`	`870`	`cs = _JSON_integer_trans_targs[_trans];`
`871`	`871`
`872`	`872`	`if ( _JSON_integer_trans_actions[_trans] != 0 ) {`
`@@ -922,7 +922,7 @@ RubyInteger bytesToInum(Ruby runtime, ByteList num) {`
`922`	`922`	`return ConvertBytes.byteListToInum(runtime, num, 10, true);`
`923`	`923`	`}`
`924`	`924`
`925`		`-`
	`925`	`+`
`926`	`926`	`// line 927 "ParserConfig.java"`
`927`	`927`	`private static byte[] init__JSON_float_actions_0()`
`928`	`928`	`{`
`@@ -986,7 +986,7 @@ private static byte[] init__JSON_float_index_offsets_0()`
`986`	`986`	`private static final byte _JSON_float_index_offsets[] = init__JSON_float_index_offsets_0();`
`987`	`987`
`988`	`988`
`989`		`-private static byte[] init__JSON_float_indices_0()`
	`989`	`+private static byte[] init__JSON_float_indicies_0()`
`990`	`990`	`{`
`991`	`991`	`return new byte [] {`
`992`	`992`	`0, 2, 3, 1, 2, 3, 1, 4, 5, 5, 1, 6,`
`@@ -995,7 +995,7 @@ private static byte[] init__JSON_float_indices_0()`
`995`	`995`	`};`
`996`	`996`	`}`
`997`	`997`
`998`		`-private static final byte _JSON_float_indices[] = init__JSON_float_indices_0();`
	`998`	`+private static final byte _JSON_float_indicies[] = init__JSON_float_indicies_0();`
`999`	`999`
`1000`	`1000`
`1001`	`1001`	`private static byte[] init__JSON_float_trans_targs_0()`
`@@ -1043,15 +1043,15 @@ void parseFloat(ThreadContext context, ParserResult res, int p, int pe) {`
`1043`	`1043`	`int parseFloatInternal(int p, int pe) {`
`1044`	`1044`	`int cs;`
`1045`	`1045`
`1046`		`-`
	`1046`	`+`
`1047`	`1047`	`// line 1048 "ParserConfig.java"`
`1048`	`1048`	`{`
`1049`	`1049`	`cs = JSON_float_start;`
`1050`	`1050`	`}`
`1051`	`1051`
`1052`	`1052`	`// line 533 "ParserConfig.rl"`
`1053`	`1053`	`int memo = p;`
`1054`		`-`
	`1054`	`+`
`1055`	`1055`	`// line 1056 "ParserConfig.java"`
`1056`	`1056`	`{`
`1057`	`1057`	`int _klen;`
`@@ -1122,7 +1122,7 @@ else if ( data[p] > _JSON_float_trans_keys[_mid+1] )`
`1122`	`1122`	`}`
`1123`	`1123`	`} while (false);`
`1124`	`1124`
`1125`		`- _trans = _JSON_float_indices[_trans];`
	`1125`	`+ _trans = _JSON_float_indicies[_trans];`
`1126`	`1126`	`cs = _JSON_float_trans_targs[_trans];`
`1127`	`1127`
`1128`	`1128`	`if ( _JSON_float_trans_actions[_trans] != 0 ) {`
`@@ -1168,7 +1168,7 @@ else if ( data[p] > _JSON_float_trans_keys[_mid+1] )`
`1168`	`1168`	`return p;`
`1169`	`1169`	`}`
`1170`	`1170`
`1171`		`-`
	`1171`	`+`
`1172`	`1172`	`// line 1173 "ParserConfig.java"`
`1173`	`1173`	`private static byte[] init__JSON_string_actions_0()`
`1174`	`1174`	`{`
`@@ -1232,7 +1232,7 @@ private static byte[] init__JSON_string_index_offsets_0()`
`1232`	`1232`	`private static final byte _JSON_string_index_offsets[] = init__JSON_string_index_offsets_0();`
`1233`	`1233`
`1234`	`1234`
`1235`		`-private static byte[] init__JSON_string_indices_0()`
	`1235`	`+private static byte[] init__JSON_string_indicies_0()`
`1236`	`1236`	`{`
`1237`	`1237`	`return new byte [] {`
`1238`	`1238`	`0, 1, 2, 3, 1, 0, 4, 1, 0, 5, 5, 5,`
`@@ -1241,7 +1241,7 @@ private static byte[] init__JSON_string_indices_0()`
`1241`	`1241`	`};`
`1242`	`1242`	`}`
`1243`	`1243`
`1244`		`-private static final byte _JSON_string_indices[] = init__JSON_string_indices_0();`
	`1244`	`+private static final byte _JSON_string_indicies[] = init__JSON_string_indicies_0();`
`1245`	`1245`
`1246`	`1246`
`1247`	`1247`	`private static byte[] init__JSON_string_trans_targs_0()`
`@@ -1278,15 +1278,15 @@ void parseString(ThreadContext context, ParserResult res, int p, int pe) {`
`1278`	`1278`	`int cs;`
`1279`	`1279`	`IRubyObject result = null;`
`1280`	`1280`
`1281`		`-`
	`1281`	`+`
`1282`	`1282`	`// line 1283 "ParserConfig.java"`
`1283`	`1283`	`{`
`1284`	`1284`	`cs = JSON_string_start;`
`1285`	`1285`	`}`
`1286`	`1286`
`1287`	`1287`	`// line 581 "ParserConfig.rl"`
`1288`	`1288`	`int memo = p;`
`1289`		`-`
	`1289`	`+`
`1290`	`1290`	`// line 1291 "ParserConfig.java"`
`1291`	`1291`	`{`
`1292`	`1292`	`int _klen;`
`@@ -1357,7 +1357,7 @@ else if ( data[p] > _JSON_string_trans_keys[_mid+1] )`
`1357`	`1357`	`}`
`1358`	`1358`	`} while (false);`
`1359`	`1359`
`1360`		`- _trans = _JSON_string_indices[_trans];`
	`1360`	`+ _trans = _JSON_string_indicies[_trans];`
`1361`	`1361`	`cs = _JSON_string_trans_targs[_trans];`
`1362`	`1362`
`1363`	`1363`	`if ( _JSON_string_trans_actions[_trans] != 0 ) {`
`@@ -1429,7 +1429,7 @@ else if ( data[p] > _JSON_string_trans_keys[_mid+1] )`
`1429`	`1429`	`}`
`1430`	`1430`	`}`
`1431`	`1431`
`1432`		`-`
	`1432`	`+`
`1433`	`1433`	`// line 1434 "ParserConfig.java"`
`1434`	`1434`	`private static byte[] init__JSON_array_actions_0()`
`1435`	`1435`	`{`
`@@ -1549,7 +1549,7 @@ private static short[] init__JSON_array_index_offsets_0()`
`1549`	`1549`	`private static final short _JSON_array_index_offsets[] = init__JSON_array_index_offsets_0();`
`1550`	`1550`
`1551`	`1551`
`1552`		`-private static byte[] init__JSON_array_indices_0()`
	`1552`	`+private static byte[] init__JSON_array_indicies_0()`
`1553`	`1553`	`{`
`1554`	`1554`	`return new byte [] {`
`1555`	`1555`	`0, 1, 0, 0, 2, 2, 3, 2, 2, 2, 4, 2,`
`@@ -1565,7 +1565,7 @@ private static byte[] init__JSON_array_indices_0()`
`1565`	`1565`	`};`
`1566`	`1566`	`}`
`1567`	`1567`
`1568`		`-private static final byte _JSON_array_indices[] = init__JSON_array_indices_0();`
	`1568`	`+private static final byte _JSON_array_indicies[] = init__JSON_array_indicies_0();`
`1569`	`1569`
`1570`	`1570`
`1571`	`1571`	`private static byte[] init__JSON_array_trans_targs_0()`
`@@ -1610,14 +1610,14 @@ void parseArray(ThreadContext context, ParserResult res, int p, int pe) {`
`1610`	`1610`
`1611`	`1611`	`IRubyObject result = RubyArray.newArray(context.runtime);`
`1612`	`1612`
`1613`		`-`
	`1613`	`+`
`1614`	`1614`	`// line 1615 "ParserConfig.java"`
`1615`	`1615`	`{`
`1616`	`1616`	`cs = JSON_array_start;`
`1617`	`1617`	`}`
`1618`	`1618`
`1619`	`1619`	`// line 650 "ParserConfig.rl"`
`1620`		`-`
	`1620`	`+`
`1621`	`1621`	`// line 1622 "ParserConfig.java"`
`1622`	`1622`	`{`
`1623`	`1623`	`int _klen;`
`@@ -1660,7 +1660,7 @@ else if ( _widec > _JSON_array_cond_keys[_mid+1] )`
`1660`	`1660`	`switch ( _JSON_array_cond_spaces[_JSON_array_cond_offsets[cs] + ((_mid - _keys)>>1)] ) {`
`1661`	`1661`	`case 0: {`
`1662`	`1662`	`_widec = 65536 + (data[p] - 0);`
`1663`		`- if (`
	`1663`	`+ if (`
`1664`	`1664`	`// line 608 "ParserConfig.rl"`
`1665`	`1665`	`config.allowTrailingComma ) _widec += 65536;`
`1666`	`1666`	`break;`
`@@ -1720,7 +1720,7 @@ else if ( _widec > _JSON_array_trans_keys[_mid+1] )`
`1720`	`1720`	`}`
`1721`	`1721`	`} while (false);`
`1722`	`1722`
`1723`		`- _trans = _JSON_array_indices[_trans];`
	`1723`	`+ _trans = _JSON_array_indicies[_trans];`
`1724`	`1724`	`cs = _JSON_array_trans_targs[_trans];`
`1725`	`1725`
`1726`	`1726`	`if ( _JSON_array_trans_actions[_trans] != 0 ) {`
`@@ -1779,7 +1779,7 @@ else if ( _widec > _JSON_array_trans_keys[_mid+1] )`
`1779`	`1779`	`}`
`1780`	`1780`	`}`
`1781`	`1781`
`1782`		`-`
	`1782`	`+`
`1783`	`1783`	`// line 1784 "ParserConfig.java"`
`1784`	`1784`	`private static byte[] init__JSON_object_actions_0()`
`1785`	`1785`	`{`
`@@ -1906,7 +1906,7 @@ private static short[] init__JSON_object_index_offsets_0()`
`1906`	`1906`	`private static final short _JSON_object_index_offsets[] = init__JSON_object_index_offsets_0();`
`1907`	`1907`
`1908`	`1908`
`1909`		`-private static byte[] init__JSON_object_indices_0()`
	`1909`	`+private static byte[] init__JSON_object_indicies_0()`
`1910`	`1910`	`{`
`1911`	`1911`	`return new byte [] {`
`1912`	`1912`	`0, 1, 0, 0, 2, 3, 4, 0, 1, 5, 5, 6,`
`@@ -1923,7 +1923,7 @@ private static byte[] init__JSON_object_indices_0()`
`1923`	`1923`	`};`
`1924`	`1924`	`}`
`1925`	`1925`
`1926`		`-private static final byte _JSON_object_indices[] = init__JSON_object_indices_0();`
	`1926`	`+private static final byte _JSON_object_indicies[] = init__JSON_object_indicies_0();`
`1927`	`1927`
`1928`	`1928`
`1929`	`1929`	`private static byte[] init__JSON_object_trans_targs_0()`
`@@ -1973,14 +1973,14 @@ void parseObject(ThreadContext context, ParserResult res, int p, int pe) {`
`1973`	`1973`	`// allocator test at OptionsReader#getClass`
`1974`	`1974`	`IRubyObject result = RubyHash.newHash(context.runtime);`
`1975`	`1975`
`1976`		`-`
	`1976`	`+`
`1977`	`1977`	`// line 1978 "ParserConfig.java"`
`1978`	`1978`	`{`
`1979`	`1979`	`cs = JSON_object_start;`
`1980`	`1980`	`}`
`1981`	`1981`
`1982`	`1982`	`// line 737 "ParserConfig.rl"`
`1983`		`-`
	`1983`	`+`
`1984`	`1984`	`// line 1985 "ParserConfig.java"`
`1985`	`1985`	`{`
`1986`	`1986`	`int _klen;`
`@@ -2023,7 +2023,7 @@ else if ( _widec > _JSON_object_cond_keys[_mid+1] )`
`2023`	`2023`	`switch ( _JSON_object_cond_spaces[_JSON_object_cond_offsets[cs] + ((_mid - _keys)>>1)] ) {`
`2024`	`2024`	`case 0: {`
`2025`	`2025`	`_widec = 65536 + (data[p] - 0);`
`2026`		`- if (`
	`2026`	`+ if (`
`2027`	`2027`	`// line 665 "ParserConfig.rl"`
`2028`	`2028`	`config.allowTrailingComma ) _widec += 65536;`
`2029`	`2029`	`break;`
`@@ -2083,7 +2083,7 @@ else if ( _widec > _JSON_object_trans_keys[_mid+1] )`
`2083`	`2083`	`}`
`2084`	`2084`	`} while (false);`
`2085`	`2085`
`2086`		`- _trans = _JSON_object_indices[_trans];`
	`2086`	`+ _trans = _JSON_object_indicies[_trans];`
`2087`	`2087`	`cs = _JSON_object_trans_targs[_trans];`
`2088`	`2088`
`2089`	`2089`	`if ( _JSON_object_trans_actions[_trans] != 0 ) {`
`@@ -2174,7 +2174,7 @@ else if ( _widec > _JSON_object_trans_keys[_mid+1] )`
`2174`	`2174`	`res.update(config.onLoad(context, result), p + 1);`
`2175`	`2175`	`}`
`2176`	`2176`
`2177`		`-`
	`2177`	`+`
`2178`	`2178`	`// line 2179 "ParserConfig.java"`
`2179`	`2179`	`private static byte[] init__JSON_actions_0()`
`2180`	`2180`	`{`
`@@ -2238,7 +2238,7 @@ private static byte[] init__JSON_index_offsets_0()`
`2238`	`2238`	`private static final byte _JSON_index_offsets[] = init__JSON_index_offsets_0();`
`2239`	`2239`
`2240`	`2240`
`2241`		`-private static byte[] init__JSON_indices_0()`
	`2241`	`+private static byte[] init__JSON_indicies_0()`
`2242`	`2242`	`{`
`2243`	`2243`	`return new byte [] {`
`2244`	`2244`	`0, 0, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2,`
`@@ -2248,7 +2248,7 @@ private static byte[] init__JSON_indices_0()`
`2248`	`2248`	`};`
`2249`	`2249`	`}`
`2250`	`2250`
`2251`		`-private static final byte _JSON_indices[] = init__JSON_indices_0();`
	`2251`	`+private static final byte _JSON_indicies[] = init__JSON_indicies_0();`
`2252`	`2252`
`2253`	`2253`
`2254`	`2254`	`private static byte[] init__JSON_trans_targs_0()`
`@@ -2287,7 +2287,7 @@ public IRubyObject parseImplementation(ThreadContext context) {`
`2287`	`2287`	`IRubyObject result = null;`
`2288`	`2288`	`ParserResult res = new ParserResult();`
`2289`	`2289`
`2290`		`-`
	`2290`	`+`
`2291`	`2291`	`// line 2292 "ParserConfig.java"`
`2292`	`2292`	`{`
`2293`	`2293`	`cs = JSON_start;`
`@@ -2296,7 +2296,7 @@ public IRubyObject parseImplementation(ThreadContext context) {`
`2296`	`2296`	`// line 776 "ParserConfig.rl"`
`2297`	`2297`	`p = byteList.begin();`
`2298`	`2298`	`pe = p + byteList.length();`
`2299`		`-`
	`2299`	`+`
`2300`	`2300`	`// line 2301 "ParserConfig.java"`
`2301`	`2301`	`{`
`2302`	`2302`	`int _klen;`
`@@ -2367,7 +2367,7 @@ else if ( data[p] > _JSON_trans_keys[_mid+1] )`
`2367`	`2367`	`}`
`2368`	`2368`	`} while (false);`
`2369`	`2369`
`2370`		`- _trans = _JSON_indices[_trans];`
	`2370`	`+ _trans = _JSON_indicies[_trans];`
`2371`	`2371`	`cs = _JSON_trans_targs[_trans];`
`2372`	`2372`
`2373`	`2373`	`if ( _JSON_trans_actions[_trans] != 0 ) {`