prism 0.28.0 → 0.29.0

Sign up to get free protection for your applications and to get access to all the features.
data/src/prettyprint.c CHANGED
@@ -1372,20 +1372,20 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
1372
1372
  pm_buffer_append_byte(output_buffer, '\n');
1373
1373
  }
1374
1374
 
1375
- // operator
1375
+ // binary_operator
1376
1376
  {
1377
1377
  pm_buffer_concat(output_buffer, prefix_buffer);
1378
- pm_buffer_append_string(output_buffer, "+-- operator:", 13);
1378
+ pm_buffer_append_string(output_buffer, "+-- binary_operator:", 20);
1379
1379
  pm_buffer_append_byte(output_buffer, ' ');
1380
- prettyprint_constant(output_buffer, parser, cast->operator);
1380
+ prettyprint_constant(output_buffer, parser, cast->binary_operator);
1381
1381
  pm_buffer_append_byte(output_buffer, '\n');
1382
1382
  }
1383
1383
 
1384
- // operator_loc
1384
+ // binary_operator_loc
1385
1385
  {
1386
1386
  pm_buffer_concat(output_buffer, prefix_buffer);
1387
- pm_buffer_append_string(output_buffer, "+-- operator_loc:", 17);
1388
- pm_location_t *location = &cast->operator_loc;
1387
+ pm_buffer_append_string(output_buffer, "+-- binary_operator_loc:", 24);
1388
+ pm_location_t *location = &cast->binary_operator_loc;
1389
1389
  pm_buffer_append_byte(output_buffer, ' ');
1390
1390
  prettyprint_location(output_buffer, parser, location);
1391
1391
  pm_buffer_append_string(output_buffer, " = \"", 4);
@@ -2031,11 +2031,11 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
2031
2031
  pm_buffer_append_string(output_buffer, "\"\n", 2);
2032
2032
  }
2033
2033
 
2034
- // operator_loc
2034
+ // binary_operator_loc
2035
2035
  {
2036
2036
  pm_buffer_concat(output_buffer, prefix_buffer);
2037
- pm_buffer_append_string(output_buffer, "+-- operator_loc:", 17);
2038
- pm_location_t *location = &cast->operator_loc;
2037
+ pm_buffer_append_string(output_buffer, "+-- binary_operator_loc:", 24);
2038
+ pm_location_t *location = &cast->binary_operator_loc;
2039
2039
  pm_buffer_append_byte(output_buffer, ' ');
2040
2040
  prettyprint_location(output_buffer, parser, location);
2041
2041
  pm_buffer_append_string(output_buffer, " = \"", 4);
@@ -2056,12 +2056,12 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
2056
2056
  prefix_buffer->length = prefix_length;
2057
2057
  }
2058
2058
 
2059
- // operator
2059
+ // binary_operator
2060
2060
  {
2061
2061
  pm_buffer_concat(output_buffer, prefix_buffer);
2062
- pm_buffer_append_string(output_buffer, "+-- operator:", 13);
2062
+ pm_buffer_append_string(output_buffer, "+-- binary_operator:", 20);
2063
2063
  pm_buffer_append_byte(output_buffer, ' ');
2064
- prettyprint_constant(output_buffer, parser, cast->operator);
2064
+ prettyprint_constant(output_buffer, parser, cast->binary_operator);
2065
2065
  pm_buffer_append_byte(output_buffer, '\n');
2066
2066
  }
2067
2067
 
@@ -2290,11 +2290,11 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
2290
2290
  pm_buffer_append_string(output_buffer, "\"\n", 2);
2291
2291
  }
2292
2292
 
2293
- // operator_loc
2293
+ // binary_operator_loc
2294
2294
  {
2295
2295
  pm_buffer_concat(output_buffer, prefix_buffer);
2296
- pm_buffer_append_string(output_buffer, "+-- operator_loc:", 17);
2297
- pm_location_t *location = &cast->operator_loc;
2296
+ pm_buffer_append_string(output_buffer, "+-- binary_operator_loc:", 24);
2297
+ pm_location_t *location = &cast->binary_operator_loc;
2298
2298
  pm_buffer_append_byte(output_buffer, ' ');
2299
2299
  prettyprint_location(output_buffer, parser, location);
2300
2300
  pm_buffer_append_string(output_buffer, " = \"", 4);
@@ -2315,12 +2315,12 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
2315
2315
  prefix_buffer->length = prefix_length;
2316
2316
  }
2317
2317
 
2318
- // operator
2318
+ // binary_operator
2319
2319
  {
2320
2320
  pm_buffer_concat(output_buffer, prefix_buffer);
2321
- pm_buffer_append_string(output_buffer, "+-- operator:", 13);
2321
+ pm_buffer_append_string(output_buffer, "+-- binary_operator:", 20);
2322
2322
  pm_buffer_append_byte(output_buffer, ' ');
2323
- prettyprint_constant(output_buffer, parser, cast->operator);
2323
+ prettyprint_constant(output_buffer, parser, cast->binary_operator);
2324
2324
  pm_buffer_append_byte(output_buffer, '\n');
2325
2325
  }
2326
2326
 
@@ -2507,11 +2507,11 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
2507
2507
  prefix_buffer->length = prefix_length;
2508
2508
  }
2509
2509
 
2510
- // operator_loc
2510
+ // binary_operator_loc
2511
2511
  {
2512
2512
  pm_buffer_concat(output_buffer, prefix_buffer);
2513
- pm_buffer_append_string(output_buffer, "+-- operator_loc:", 17);
2514
- pm_location_t *location = &cast->operator_loc;
2513
+ pm_buffer_append_string(output_buffer, "+-- binary_operator_loc:", 24);
2514
+ pm_location_t *location = &cast->binary_operator_loc;
2515
2515
  pm_buffer_append_byte(output_buffer, ' ');
2516
2516
  prettyprint_location(output_buffer, parser, location);
2517
2517
  pm_buffer_append_string(output_buffer, " = \"", 4);
@@ -2532,12 +2532,12 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
2532
2532
  prefix_buffer->length = prefix_length;
2533
2533
  }
2534
2534
 
2535
- // operator
2535
+ // binary_operator
2536
2536
  {
2537
2537
  pm_buffer_concat(output_buffer, prefix_buffer);
2538
- pm_buffer_append_string(output_buffer, "+-- operator:", 13);
2538
+ pm_buffer_append_string(output_buffer, "+-- binary_operator:", 20);
2539
2539
  pm_buffer_append_byte(output_buffer, ' ');
2540
- prettyprint_constant(output_buffer, parser, cast->operator);
2540
+ prettyprint_constant(output_buffer, parser, cast->binary_operator);
2541
2541
  pm_buffer_append_byte(output_buffer, '\n');
2542
2542
  }
2543
2543
 
@@ -3632,11 +3632,11 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
3632
3632
  pm_buffer_append_string(output_buffer, "\"\n", 2);
3633
3633
  }
3634
3634
 
3635
- // operator_loc
3635
+ // binary_operator_loc
3636
3636
  {
3637
3637
  pm_buffer_concat(output_buffer, prefix_buffer);
3638
- pm_buffer_append_string(output_buffer, "+-- operator_loc:", 17);
3639
- pm_location_t *location = &cast->operator_loc;
3638
+ pm_buffer_append_string(output_buffer, "+-- binary_operator_loc:", 24);
3639
+ pm_location_t *location = &cast->binary_operator_loc;
3640
3640
  pm_buffer_append_byte(output_buffer, ' ');
3641
3641
  prettyprint_location(output_buffer, parser, location);
3642
3642
  pm_buffer_append_string(output_buffer, " = \"", 4);
@@ -3657,12 +3657,12 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
3657
3657
  prefix_buffer->length = prefix_length;
3658
3658
  }
3659
3659
 
3660
- // operator
3660
+ // binary_operator
3661
3661
  {
3662
3662
  pm_buffer_concat(output_buffer, prefix_buffer);
3663
- pm_buffer_append_string(output_buffer, "+-- operator:", 13);
3663
+ pm_buffer_append_string(output_buffer, "+-- binary_operator:", 20);
3664
3664
  pm_buffer_append_byte(output_buffer, ' ');
3665
- prettyprint_constant(output_buffer, parser, cast->operator);
3665
+ prettyprint_constant(output_buffer, parser, cast->binary_operator);
3666
3666
  pm_buffer_append_byte(output_buffer, '\n');
3667
3667
  }
3668
3668
 
@@ -4449,20 +4449,20 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
4449
4449
  }
4450
4450
  }
4451
4451
 
4452
- // operator
4452
+ // binary_operator
4453
4453
  {
4454
4454
  pm_buffer_concat(output_buffer, prefix_buffer);
4455
- pm_buffer_append_string(output_buffer, "+-- operator:", 13);
4455
+ pm_buffer_append_string(output_buffer, "+-- binary_operator:", 20);
4456
4456
  pm_buffer_append_byte(output_buffer, ' ');
4457
- prettyprint_constant(output_buffer, parser, cast->operator);
4457
+ prettyprint_constant(output_buffer, parser, cast->binary_operator);
4458
4458
  pm_buffer_append_byte(output_buffer, '\n');
4459
4459
  }
4460
4460
 
4461
- // operator_loc
4461
+ // binary_operator_loc
4462
4462
  {
4463
4463
  pm_buffer_concat(output_buffer, prefix_buffer);
4464
- pm_buffer_append_string(output_buffer, "+-- operator_loc:", 17);
4465
- pm_location_t *location = &cast->operator_loc;
4464
+ pm_buffer_append_string(output_buffer, "+-- binary_operator_loc:", 24);
4465
+ pm_location_t *location = &cast->binary_operator_loc;
4466
4466
  pm_buffer_append_byte(output_buffer, ' ');
4467
4467
  prettyprint_location(output_buffer, parser, location);
4468
4468
  pm_buffer_append_string(output_buffer, " = \"", 4);
@@ -4827,11 +4827,11 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
4827
4827
  pm_buffer_append_string(output_buffer, "\"\n", 2);
4828
4828
  }
4829
4829
 
4830
- // operator_loc
4830
+ // binary_operator_loc
4831
4831
  {
4832
4832
  pm_buffer_concat(output_buffer, prefix_buffer);
4833
- pm_buffer_append_string(output_buffer, "+-- operator_loc:", 17);
4834
- pm_location_t *location = &cast->operator_loc;
4833
+ pm_buffer_append_string(output_buffer, "+-- binary_operator_loc:", 24);
4834
+ pm_location_t *location = &cast->binary_operator_loc;
4835
4835
  pm_buffer_append_byte(output_buffer, ' ');
4836
4836
  prettyprint_location(output_buffer, parser, location);
4837
4837
  pm_buffer_append_string(output_buffer, " = \"", 4);
@@ -4852,12 +4852,12 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
4852
4852
  prefix_buffer->length = prefix_length;
4853
4853
  }
4854
4854
 
4855
- // operator
4855
+ // binary_operator
4856
4856
  {
4857
4857
  pm_buffer_concat(output_buffer, prefix_buffer);
4858
- pm_buffer_append_string(output_buffer, "+-- operator:", 13);
4858
+ pm_buffer_append_string(output_buffer, "+-- binary_operator:", 20);
4859
4859
  pm_buffer_append_byte(output_buffer, ' ');
4860
- prettyprint_constant(output_buffer, parser, cast->operator);
4860
+ prettyprint_constant(output_buffer, parser, cast->binary_operator);
4861
4861
  pm_buffer_append_byte(output_buffer, '\n');
4862
4862
  }
4863
4863
 
@@ -5744,11 +5744,11 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
5744
5744
  pm_buffer_append_string(output_buffer, "\"\n", 2);
5745
5745
  }
5746
5746
 
5747
- // operator_loc
5747
+ // binary_operator_loc
5748
5748
  {
5749
5749
  pm_buffer_concat(output_buffer, prefix_buffer);
5750
- pm_buffer_append_string(output_buffer, "+-- operator_loc:", 17);
5751
- pm_location_t *location = &cast->operator_loc;
5750
+ pm_buffer_append_string(output_buffer, "+-- binary_operator_loc:", 24);
5751
+ pm_location_t *location = &cast->binary_operator_loc;
5752
5752
  pm_buffer_append_byte(output_buffer, ' ');
5753
5753
  prettyprint_location(output_buffer, parser, location);
5754
5754
  pm_buffer_append_string(output_buffer, " = \"", 4);
@@ -5778,12 +5778,12 @@ prettyprint_node(pm_buffer_t *output_buffer, const pm_parser_t *parser, const pm
5778
5778
  pm_buffer_append_byte(output_buffer, '\n');
5779
5779
  }
5780
5780
 
5781
- // operator
5781
+ // binary_operator
5782
5782
  {
5783
5783
  pm_buffer_concat(output_buffer, prefix_buffer);
5784
- pm_buffer_append_string(output_buffer, "+-- operator:", 13);
5784
+ pm_buffer_append_string(output_buffer, "+-- binary_operator:", 20);
5785
5785
  pm_buffer_append_byte(output_buffer, ' ');
5786
- prettyprint_constant(output_buffer, parser, cast->operator);
5786
+ prettyprint_constant(output_buffer, parser, cast->binary_operator);
5787
5787
  pm_buffer_append_byte(output_buffer, '\n');
5788
5788
  }
5789
5789