Class: Parser::Lexer

Inherits:
Object
  • Object
show all
Defined in:
lib/parser/lexer-F0.rb,
lib/parser/lexer-F1.rb

Overview

line 3 “lib/parser/lexer.rl”

BEFORE YOU START ===

Read the Ruby Hacking Guide chapter 11, available in English at whitequark.org/blog/2013/04/01/ruby-hacking-guide-ch-11-finite-state-lexer/

Remember two things about Ragel scanners:

1) Longest match wins.

2) If two matches have the same length, the first
   in source code wins.

General rules of making Ragel and Bison happy:

* `p` (position) and `@te` contain the index of the character
  they're pointing to ("current"), plus one. `@ts` contains the index
  of the corresponding character. The code for extracting matched token is:

     @source_buffer.slice(@ts...@te)

* If your input is `foooooooobar` and the rule is:

     'f' 'o'+

  the result will be:

     foooooooobar
     ^ ts=0   ^ p=te=9

* A Ragel lexer action should not emit more than one token, unless
  you know what you are doing.

* All Ragel commands (fnext, fgoto, ...) end with a semicolon.

* If an action emits the token and transitions to another state, use
  these Ragel commands:

     emit($whatever)
     fnext $next_state; fbreak;

  If you perform `fgoto` in an action which does not emit a token nor
  rewinds the stream pointer, the parser's side-effectful,
  context-sensitive lookahead actions will break in a hard to detect
  and debug way.

* If an action does not emit a token:

     fgoto $next_state;

* If an action features lookbehind, i.e. matches characters with the
  intent of passing them to another action:

     p = @ts - 1
     fgoto $next_state;

  or, if the lookbehind consists of a single character:

     fhold; fgoto $next_state;

* Ragel merges actions. So, if you have `e_lparen = '(' %act` and
  `c_lparen = '('` and a lexer action `e_lparen | c_lparen`, the result
  _will_ invoke the action `act`.

  e_something stands for "something with **e**mbedded action".

* EOF is explicit and is matched by `c_eof`. If you want to introspect
  the state of the lexer, add this rule to the state:

     c_eof => do_eof;

* If you proceed past EOF, the lexer will complain:

     NoMethodError: undefined method `ord' for nil:NilClass

Defined Under Namespace

Modules: Explanation Classes: Dedenter, Literal, StackState

Constant Summary collapse

LEX_STATES =
{
  :line_begin    => lex_en_line_begin,
  :expr_dot      => lex_en_expr_dot,
  :expr_fname    => lex_en_expr_fname,
  :expr_value    => lex_en_expr_value,
  :expr_beg      => lex_en_expr_beg,
  :expr_mid      => lex_en_expr_mid,
  :expr_arg      => lex_en_expr_arg,
  :expr_cmdarg   => lex_en_expr_cmdarg,
  :expr_end      => lex_en_expr_end,
  :expr_endarg   => lex_en_expr_endarg,
  :expr_endfn    => lex_en_expr_endfn,
  :expr_labelarg => lex_en_expr_labelarg,

  :inside_string => lex_en_inside_string
}

Class Attribute Summary collapse

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(version) ⇒ Lexer

Returns a new instance of Lexer.



8383
8384
8385
8386
8387
8388
8389
8390
8391
8392
8393
8394
8395
8396
8397
8398
8399
8400
8401
8402
8403
8404
8405
8406
8407
8408
8409
8410
8411
8412
# File 'lib/parser/lexer-F0.rb', line 8383

def initialize(version)
  @version    = version
  @static_env = nil
  @context    = nil

  @tokens     = nil
  @comments   = nil

  @_lex_actions =
    if self.class.respond_to?(:_lex_actions, true)
      self.class.send :_lex_actions
    else
      []
    end

  @emit_integer = lambda { |chars, p| emit(:tINTEGER,   chars); p }
  @emit_rational = lambda { |chars, p| emit(:tRATIONAL,  Rational(chars)); p }
  @emit_imaginary = lambda { |chars, p| emit(:tIMAGINARY, Complex(0, chars)); p }
  @emit_imaginary_rational = lambda { |chars, p| emit(:tIMAGINARY, Complex(0, Rational(chars))); p }
  @emit_integer_re = lambda { |chars, p| emit(:tINTEGER,   chars, @ts, @te - 2); p - 2 }
  @emit_integer_if = lambda { |chars, p| emit(:tINTEGER,   chars, @ts, @te - 2); p - 2 }
  @emit_integer_rescue = lambda { |chars, p| emit(:tINTEGER,   chars, @ts, @te - 6); p - 6 }

  @emit_float = lambda { |chars, p| emit(:tFLOAT,     Float(chars)); p }
  @emit_imaginary_float = lambda { |chars, p| emit(:tIMAGINARY, Complex(0, Float(chars))); p }
  @emit_float_if =     lambda { |chars, p| emit(:tFLOAT,     Float(chars), @ts, @te - 2); p - 2 }
  @emit_float_rescue = lambda { |chars, p| emit(:tFLOAT,     Float(chars), @ts, @te - 6); p - 6 }

  reset
end

Class Attribute Details

._lex_actionsObject



87
88
89
# File 'lib/parser/lexer-F0.rb', line 87

def _lex_actions
  @_lex_actions
end

._lex_eof_transObject



8197
8198
8199
# File 'lib/parser/lexer-F0.rb', line 8197

def _lex_eof_trans
  @_lex_eof_trans
end

._lex_from_state_actionsObject



8100
8101
8102
# File 'lib/parser/lexer-F0.rb', line 8100

def _lex_from_state_actions
  @_lex_from_state_actions
end

._lex_index_offsetsObject



594
595
596
# File 'lib/parser/lexer-F0.rb', line 594

def _lex_index_offsets
  @_lex_index_offsets
end

._lex_indiciesObject



691
692
693
# File 'lib/parser/lexer-F0.rb', line 691

def _lex_indicies
  @_lex_indicies
end

._lex_key_spansObject



497
498
499
# File 'lib/parser/lexer-F0.rb', line 497

def _lex_key_spans
  @_lex_key_spans
end

._lex_to_state_actionsObject



8003
8004
8005
# File 'lib/parser/lexer-F0.rb', line 8003

def _lex_to_state_actions
  @_lex_to_state_actions
end

._lex_trans_actionsObject



7855
7856
7857
# File 'lib/parser/lexer-F0.rb', line 7855

def _lex_trans_actions
  @_lex_trans_actions
end

._lex_trans_keysObject



220
221
222
# File 'lib/parser/lexer-F0.rb', line 220

def _lex_trans_keys
  @_lex_trans_keys
end

._lex_trans_targsObject



7707
7708
7709
# File 'lib/parser/lexer-F0.rb', line 7707

def _lex_trans_targs
  @_lex_trans_targs
end

.lex_en_expr_argObject



8319
8320
8321
# File 'lib/parser/lexer-F0.rb', line 8319

def lex_en_expr_arg
  @lex_en_expr_arg
end

.lex_en_expr_begObject



8335
8336
8337
# File 'lib/parser/lexer-F0.rb', line 8335

def lex_en_expr_beg
  @lex_en_expr_beg
end

.lex_en_expr_cmdargObject



8323
8324
8325
# File 'lib/parser/lexer-F0.rb', line 8323

def lex_en_expr_cmdarg
  @lex_en_expr_cmdarg
end

.lex_en_expr_dotObject



8315
8316
8317
# File 'lib/parser/lexer-F0.rb', line 8315

def lex_en_expr_dot
  @lex_en_expr_dot
end

.lex_en_expr_endObject



8347
8348
8349
# File 'lib/parser/lexer-F0.rb', line 8347

def lex_en_expr_end
  @lex_en_expr_end
end

.lex_en_expr_endargObject



8327
8328
8329
# File 'lib/parser/lexer-F0.rb', line 8327

def lex_en_expr_endarg
  @lex_en_expr_endarg
end

.lex_en_expr_endfnObject



8311
8312
8313
# File 'lib/parser/lexer-F0.rb', line 8311

def lex_en_expr_endfn
  @lex_en_expr_endfn
end

.lex_en_expr_fnameObject



8307
8308
8309
# File 'lib/parser/lexer-F0.rb', line 8307

def lex_en_expr_fname
  @lex_en_expr_fname
end

.lex_en_expr_labelargObject



8339
8340
8341
# File 'lib/parser/lexer-F0.rb', line 8339

def lex_en_expr_labelarg
  @lex_en_expr_labelarg
end

.lex_en_expr_midObject



8331
8332
8333
# File 'lib/parser/lexer-F0.rb', line 8331

def lex_en_expr_mid
  @lex_en_expr_mid
end

.lex_en_expr_valueObject



8343
8344
8345
# File 'lib/parser/lexer-F0.rb', line 8343

def lex_en_expr_value
  @lex_en_expr_value
end

.lex_en_expr_variableObject



8303
8304
8305
# File 'lib/parser/lexer-F0.rb', line 8303

def lex_en_expr_variable
  @lex_en_expr_variable
end

.lex_en_inside_stringObject



8363
8364
8365
# File 'lib/parser/lexer-F0.rb', line 8363

def lex_en_inside_string
  @lex_en_inside_string
end

.lex_en_leading_dotObject



8351
8352
8353
# File 'lib/parser/lexer-F0.rb', line 8351

def lex_en_leading_dot
  @lex_en_leading_dot
end

.lex_en_line_beginObject



8359
8360
8361
# File 'lib/parser/lexer-F0.rb', line 8359

def lex_en_line_begin
  @lex_en_line_begin
end

.lex_en_line_commentObject



8355
8356
8357
# File 'lib/parser/lexer-F0.rb', line 8355

def lex_en_line_comment
  @lex_en_line_comment
end

.lex_errorObject



8298
8299
8300
# File 'lib/parser/lexer-F0.rb', line 8298

def lex_error
  @lex_error
end

.lex_startObject



8294
8295
8296
# File 'lib/parser/lexer-F0.rb', line 8294

def lex_start
  @lex_start
end

Instance Attribute Details

#cmdargObject



8377
8378
8379
# File 'lib/parser/lexer-F0.rb', line 8377

def cmdarg
  @cmdarg
end

#cmdarg_stackObject (readonly)



8381
8382
8383
# File 'lib/parser/lexer-F0.rb', line 8381

def cmdarg_stack
  @cmdarg_stack
end

#command_startObject



8377
8378
8379
# File 'lib/parser/lexer-F0.rb', line 8377

def command_start
  @command_start
end

#commentsObject



8379
8380
8381
# File 'lib/parser/lexer-F0.rb', line 8379

def comments
  @comments
end

#condObject



8377
8378
8379
# File 'lib/parser/lexer-F0.rb', line 8377

def cond
  @cond
end

#cond_stackObject (readonly)



8381
8382
8383
# File 'lib/parser/lexer-F0.rb', line 8381

def cond_stack
  @cond_stack
end

#contextObject



8377
8378
8379
# File 'lib/parser/lexer-F0.rb', line 8377

def context
  @context
end

#diagnosticsObject



8373
8374
8375
# File 'lib/parser/lexer-F0.rb', line 8373

def diagnostics
  @diagnostics
end

#force_utf32Object



8375
8376
8377
# File 'lib/parser/lexer-F0.rb', line 8375

def force_utf32
  @force_utf32
end

#lambda_stackObject (readonly)



8381
8382
8383
# File 'lib/parser/lexer-F0.rb', line 8381

def lambda_stack
  @lambda_stack
end

#paren_nestObject (readonly)



8381
8382
8383
# File 'lib/parser/lexer-F0.rb', line 8381

def paren_nest
  @paren_nest
end

#source_bufferObject

%



8371
8372
8373
# File 'lib/parser/lexer-F0.rb', line 8371

def source_buffer
  @source_buffer
end

#static_envObject



8374
8375
8376
# File 'lib/parser/lexer-F0.rb', line 8374

def static_env
  @static_env
end

#tokensObject



8379
8380
8381
# File 'lib/parser/lexer-F0.rb', line 8379

def tokens
  @tokens
end

#versionObject (readonly)



8381
8382
8383
# File 'lib/parser/lexer-F0.rb', line 8381

def version
  @version
end

Instance Method Details

#advanceObject

Return next token: [type, value].



8543
8544
8545
8546
8547
8548
8549
8550
8551
8552
8553
8554
8555
8556
8557
8558
8559
8560
8561
8562
8563
8564
8565
8566
8567
8568
8569
8570
8571
8572
8573
8574
8575
8576
8577
8578
8579
8580
8581
8582
8583
8584
8585
8586
8587
8588
8589
8590
8591
8592
8593
8594
8595
8596
8597
8598
8599
8600
8601
8602
8603
8604
8605
8606
8607
8608
8609
8610
8611
8612
8613
8614
8615
8616
8617
8618
8619
8620
8621
8622
8623
8624
8625
8626
8627
8628
8629
8630
8631
8632
8633
8634
8635
8636
8637
8638
8639
8640
8641
8642
8643
8644
8645
8646
8647
8648
8649
8650
8651
8652
8653
8654
8655
8656
8657
8658
8659
8660
8661
8662
8663
8664
8665
8666
8667
8668
8669
8670
8671
8672
8673
8674
8675
8676
8677
8678
8679
8680
8681
8682
8683
8684
8685
8686
8687
8688
8689
8690
8691
8692
8693
8694
8695
8696
8697
8698
8699
8700
8701
8702
8703
8704
8705
8706
8707
8708
8709
8710
8711
8712
8713
8714
8715
8716
8717
8718
8719
8720
8721
8722
8723
8724
8725
8726
8727
8728
8729
8730
8731
8732
8733
8734
8735
8736
8737
8738
8739
8740
8741
8742
8743
8744
8745
8746
8747
8748
8749
8750
8751
8752
8753
8754
8755
8756
8757
8758
8759
8760
8761
8762
8763
8764
8765
8766
8767
8768
8769
8770
8771
8772
8773
8774
8775
8776
8777
8778
8779
8780
8781
8782
8783
8784
8785
8786
8787
8788
8789
8790
8791
8792
8793
8794
8795
8796
8797
8798
8799
8800
8801
8802
8803
8804
8805
8806
8807
8808
8809
8810
8811
8812
8813
8814
8815
8816
8817
8818
8819
8820
8821
8822
8823
8824
8825
8826
8827
8828
8829
8830
8831
8832
8833
8834
8835
8836
8837
8838
8839
8840
8841
8842
8843
8844
8845
8846
8847
8848
8849
8850
8851
8852
8853
8854
8855
8856
8857
8858
8859
8860
8861
8862
8863
8864
8865
8866
8867
8868
8869
8870
8871
8872
8873
8874
8875
8876
8877
8878
8879
8880
8881
8882
8883
8884
8885
8886
8887
8888
8889
8890
8891
8892
8893
8894
8895
8896
8897
8898
8899
8900
8901
8902
8903
8904
8905
8906
8907
8908
8909
8910
8911
8912
8913
8914
8915
8916
8917
8918
8919
8920
8921
8922
8923
8924
8925
8926
8927
8928
8929
8930
8931
8932
8933
8934
8935
8936
8937
8938
8939
8940
8941
8942
8943
8944
8945
8946
8947
8948
8949
8950
8951
8952
8953
8954
8955
8956
8957
8958
8959
8960
8961
8962
8963
8964
8965
8966
8967
8968
8969
8970
8971
8972
8973
8974
8975
8976
8977
8978
8979
8980
8981
8982
8983
8984
8985
8986
8987
8988
8989
8990
8991
8992
8993
8994
8995
8996
8997
8998
8999
9000
9001
9002
9003
9004
9005
9006
9007
9008
9009
9010
9011
9012
9013
9014
9015
9016
9017
9018
9019
9020
9021
9022
9023
9024
9025
9026
9027
9028
9029
9030
9031
9032
9033
9034
9035
9036
9037
9038
9039
9040
9041
9042
9043
9044
9045
9046
9047
9048
9049
9050
9051
9052
9053
9054
9055
9056
9057
9058
9059
9060
9061
9062
9063
9064
9065
9066
9067
9068
9069
9070
9071
9072
9073
9074
9075
9076
9077
9078
9079
9080
9081
9082
9083
9084
9085
9086
9087
9088
9089
9090
9091
9092
9093
9094
9095
9096
9097
9098
9099
9100
9101
9102
9103
9104
9105
9106
9107
9108
9109
9110
9111
9112
9113
9114
9115
9116
9117
9118
9119
9120
9121
9122
9123
9124
9125
9126
9127
9128
9129
9130
9131
9132
9133
9134
9135
9136
9137
9138
9139
9140
9141
9142
9143
9144
9145
9146
9147
9148
9149
9150
9151
9152
9153
9154
9155
9156
9157
9158
9159
9160
9161
9162
9163
9164
9165
9166
9167
9168
9169
9170
9171
9172
9173
9174
9175
9176
9177
9178
9179
9180
9181
9182
9183
9184
9185
9186
9187
9188
9189
9190
9191
9192
9193
9194
9195
9196
9197
9198
9199
9200
9201
9202
9203
9204
9205
9206
9207
9208
9209
9210
9211
9212
9213
9214
9215
9216
9217
9218
9219
9220
9221
9222
9223
9224
9225
9226
9227
9228
9229
9230
9231
9232
9233
9234
9235
9236
9237
9238
9239
9240
9241
9242
9243
9244
9245
9246
9247
9248
9249
9250
9251
9252
9253
9254
9255
9256
9257
9258
9259
9260
9261
9262
9263
9264
9265
9266
9267
9268
9269
9270
9271
9272
9273
9274
9275
9276
9277
9278
9279
9280
9281
9282
9283
9284
9285
9286
9287
9288
9289
9290
9291
9292
9293
9294
9295
9296
9297
9298
9299
9300
9301
9302
9303
9304
9305
9306
9307
9308
9309
9310
9311
9312
9313
9314
9315
9316
9317
9318
9319
9320
9321
9322
9323
9324
9325
9326
9327
9328
9329
9330
9331
9332
9333
9334
9335
9336
9337
9338
9339
9340
9341
9342
9343
9344
9345
9346
9347
9348
9349
9350
9351
9352
9353
9354
9355
9356
9357
9358
9359
9360
9361
9362
9363
9364
9365
9366
9367
9368
9369
9370
9371
9372
9373
9374
9375
9376
9377
9378
9379
9380
9381
9382
9383
9384
9385
9386
9387
9388
9389
9390
9391
9392
9393
9394
9395
9396
9397
9398
9399
9400
9401
9402
9403
9404
9405
9406
9407
9408
9409
9410
9411
9412
9413
9414
9415
9416
9417
9418
9419
9420
9421
9422
9423
9424
9425
9426
9427
9428
9429
9430
9431
9432
9433
9434
9435
9436
9437
9438
9439
9440
9441
9442
9443
9444
9445
9446
9447
9448
9449
9450
9451
9452
9453
9454
9455
9456
9457
9458
9459
9460
9461
9462
9463
9464
9465
9466
9467
9468
9469
9470
9471
9472
9473
9474
9475
9476
9477
9478
9479
9480
9481
9482
9483
9484
9485
9486
9487
9488
9489
9490
9491
9492
9493
9494
9495
9496
9497
9498
9499
9500
9501
9502
9503
9504
9505
9506
9507
9508
9509
9510
9511
9512
9513
9514
9515
9516
9517
9518
9519
9520
9521
9522
9523
9524
9525
9526
9527
9528
9529
9530
9531
9532
9533
9534
9535
9536
9537
9538
9539
9540
9541
9542
9543
9544
9545
9546
9547
9548
9549
9550
9551
9552
9553
9554
9555
9556
9557
9558
9559
9560
9561
9562
9563
9564
9565
9566
9567
9568
9569
9570
9571
9572
9573
9574
9575
9576
9577
9578
9579
9580
9581
9582
9583
9584
9585
9586
9587
9588
9589
9590
9591
9592
9593
9594
9595
9596
9597
9598
9599
9600
9601
9602
9603
9604
9605
9606
9607
9608
9609
9610
9611
9612
9613
9614
9615
9616
9617
9618
9619
9620
9621
9622
9623
9624
9625
9626
9627
9628
9629
9630
9631
9632
9633
9634
9635
9636
9637
9638
9639
9640
9641
9642
9643
9644
9645
9646
9647
9648
9649
9650
9651
9652
9653
9654
9655
9656
9657
9658
9659
9660
9661
9662
9663
9664
9665
9666
9667
9668
9669
9670
9671
9672
9673
9674
9675
9676
9677
9678
9679
9680
9681
9682
9683
9684
9685
9686
9687
9688
9689
9690
9691
9692
9693
9694
9695
9696
9697
9698
9699
9700
9701
9702
9703
9704
9705
9706
9707
9708
9709
9710
9711
9712
9713
9714
9715
9716
9717
9718
9719
9720
9721
9722
9723
9724
9725
9726
9727
9728
9729
9730
9731
9732
9733
9734
9735
9736
9737
9738
9739
9740
9741
9742
9743
9744
9745
9746
9747
9748
9749
9750
9751
9752
9753
9754
9755
9756
9757
9758
9759
9760
9761
9762
9763
9764
9765
9766
9767
9768
9769
9770
9771
9772
9773
9774
9775
9776
9777
9778
9779
9780
9781
9782
9783
9784
9785
9786
9787
9788
9789
9790
9791
9792
9793
9794
9795
9796
9797
9798
9799
9800
9801
9802
9803
9804
9805
9806
9807
9808
9809
9810
9811
9812
9813
9814
9815
9816
9817
9818
9819
9820
9821
9822
9823
9824
9825
9826
9827
9828
9829
9830
9831
9832
9833
9834
9835
9836
9837
9838
9839
9840
9841
9842
9843
9844
9845
9846
9847
9848
9849
9850
9851
9852
9853
9854
9855
9856
9857
9858
9859
9860
9861
9862
9863
9864
9865
9866
9867
9868
9869
9870
9871
9872
9873
9874
9875
9876
9877
9878
9879
9880
9881
9882
9883
9884
9885
9886
9887
9888
9889
9890
9891
9892
9893
9894
9895
9896
9897
9898
9899
9900
9901
9902
9903
9904
9905
9906
9907
9908
9909
9910
9911
9912
9913
9914
9915
9916
9917
9918
9919
9920
9921
9922
9923
9924
9925
9926
9927
9928
9929
9930
9931
9932
9933
9934
9935
9936
9937
9938
9939
9940
9941
9942
9943
9944
9945
9946
9947
9948
9949
9950
9951
9952
9953
9954
9955
9956
9957
9958
9959
9960
9961
9962
9963
9964
9965
9966
9967
9968
9969
9970
9971
9972
9973
9974
9975
9976
9977
9978
9979
9980
9981
9982
9983
9984
9985
9986
9987
9988
9989
9990
9991
9992
9993
9994
9995
9996
9997
9998
9999
10000
10001
10002
10003
10004
10005
10006
10007
10008
10009
10010
10011
10012
10013
10014
10015
10016
10017
10018
10019
10020
10021
10022
10023
10024
10025
10026
10027
10028
10029
10030
10031
10032
10033
10034
10035
10036
10037
10038
10039
10040
10041
10042
10043
10044
10045
10046
10047
10048
10049
10050
10051
10052
10053
10054
10055
10056
10057
10058
10059
10060
10061
10062
10063
10064
10065
10066
10067
10068
10069
10070
10071
10072
10073
10074
10075
10076
10077
10078
10079
10080
10081
10082
10083
10084
10085
10086
10087
10088
10089
10090
10091
10092
10093
10094
10095
10096
10097
10098
10099
10100
10101
10102
10103
10104
10105
10106
10107
10108
10109
10110
10111
10112
10113
10114
10115
10116
10117
10118
10119
10120
10121
10122
10123
10124
10125
10126
10127
10128
10129
10130
10131
10132
10133
10134
10135
10136
10137
10138
10139
10140
10141
10142
10143
10144
10145
10146
10147
10148
10149
10150
10151
10152
10153
10154
10155
10156
10157
10158
10159
10160
10161
10162
10163
10164
10165
10166
10167
10168
10169
10170
10171
10172
10173
10174
10175
10176
10177
10178
10179
10180
10181
10182
10183
10184
10185
10186
10187
10188
10189
10190
10191
10192
10193
10194
10195
10196
10197
10198
10199
10200
10201
10202
10203
10204
10205
10206
10207
10208
10209
10210
10211
10212
10213
10214
10215
10216
10217
10218
10219
10220
10221
10222
10223
10224
10225
10226
10227
10228
10229
10230
10231
10232
10233
10234
10235
10236
10237
10238
10239
10240
10241
10242
10243
10244
10245
10246
10247
10248
10249
10250
10251
10252
10253
10254
10255
10256
10257
10258
10259
10260
10261
10262
10263
10264
10265
10266
10267
10268
10269
10270
10271
10272
10273
10274
10275
10276
10277
10278
10279
10280
10281
10282
10283
10284
10285
10286
10287
10288
10289
10290
10291
10292
10293
10294
10295
10296
10297
10298
10299
10300
10301
10302
10303
10304
10305
10306
10307
10308
10309
10310
10311
10312
10313
10314
10315
10316
10317
10318
10319
10320
10321
10322
10323
10324
10325
10326
10327
10328
10329
10330
10331
10332
10333
10334
10335
10336
10337
10338
10339
10340
10341
10342
10343
10344
10345
10346
10347
10348
10349
10350
10351
10352
10353
10354
10355
10356
10357
10358
10359
10360
10361
10362
10363
10364
10365
10366
10367
10368
10369
10370
10371
10372
10373
10374
10375
10376
10377
10378
10379
10380
10381
10382
10383
10384
10385
10386
10387
10388
10389
10390
10391
10392
10393
10394
10395
10396
10397
10398
10399
10400
10401
10402
10403
10404
10405
10406
10407
10408
10409
10410
10411
10412
10413
10414
10415
10416
10417
10418
10419
10420
10421
10422
10423
10424
10425
10426
10427
10428
10429
10430
10431
10432
10433
10434
10435
10436
10437
10438
10439
10440
10441
10442
10443
10444
10445
10446
10447
10448
10449
10450
10451
10452
10453
10454
10455
10456
10457
10458
10459
10460
10461
10462
10463
10464
10465
10466
10467
10468
10469
10470
10471
10472
10473
10474
10475
10476
10477
10478
10479
10480
10481
10482
10483
10484
10485
10486
10487
10488
10489
10490
10491
10492
10493
10494
10495
10496
10497
10498
10499
10500
10501
10502
10503
10504
10505
10506
10507
10508
10509
10510
10511
10512
10513
10514
10515
10516
10517
10518
10519
10520
10521
10522
10523
10524
10525
10526
10527
10528
10529
10530
10531
10532
10533
10534
10535
10536
10537
10538
10539
10540
10541
10542
10543
10544
10545
10546
10547
10548
10549
10550
10551
10552
10553
10554
10555
10556
10557
10558
10559
10560
10561
10562
10563
10564
10565
10566
10567
10568
10569
10570
10571
10572
10573
10574
10575
10576
10577
10578
10579
10580
10581
10582
10583
10584
10585
10586
10587
10588
10589
10590
10591
10592
10593
10594
10595
10596
10597
10598
10599
10600
10601
10602
10603
10604
10605
10606
10607
10608
10609
10610
10611
10612
10613
10614
10615
10616
10617
10618
10619
10620
10621
10622
10623
10624
10625
10626
10627
10628
10629
10630
10631
10632
10633
10634
10635
10636
10637
10638
10639
10640
10641
10642
10643
10644
10645
10646
10647
10648
10649
10650
10651
10652
10653
10654
10655
10656
10657
10658
10659
10660
10661
10662
10663
10664
10665
10666
10667
10668
10669
10670
10671
10672
10673
10674
10675
10676
10677
10678
10679
10680
10681
10682
10683
10684
10685
10686
10687
10688
10689
10690
10691
10692
10693
10694
10695
10696
10697
10698
10699
10700
10701
10702
10703
10704
10705
10706
10707
10708
10709
10710
10711
10712
10713
10714
10715
10716
10717
10718
10719
10720
10721
10722
10723
10724
10725
10726
10727
10728
10729
10730
10731
10732
10733
10734
10735
10736
10737
10738
10739
10740
10741
10742
10743
10744
10745
10746
10747
10748
10749
10750
10751
10752
10753
10754
10755
10756
10757
10758
10759
10760
10761
10762
10763
10764
10765
10766
10767
10768
10769
10770
10771
10772
10773
10774
10775
10776
10777
10778
10779
10780
10781
10782
10783
10784
10785
10786
10787
10788
10789
10790
10791
10792
10793
10794
10795
10796
10797
10798
10799
10800
10801
10802
10803
10804
10805
10806
10807
10808
10809
10810
10811
10812
10813
10814
10815
10816
10817
10818
10819
10820
10821
10822
10823
10824
10825
10826
10827
10828
10829
10830
10831
10832
10833
10834
10835
10836
10837
10838
10839
10840
10841
10842
10843
10844
10845
10846
10847
10848
10849
10850
10851
10852
10853
10854
10855
10856
10857
10858
10859
10860
10861
10862
10863
10864
10865
10866
10867
10868
10869
10870
10871
10872
10873
10874
10875
10876
10877
10878
10879
10880
10881
10882
10883
10884
10885
10886
10887
10888
10889
10890
10891
10892
10893
10894
10895
10896
10897
10898
10899
10900
10901
10902
10903
10904
10905
10906
10907
10908
10909
10910
10911
10912
10913
10914
10915
10916
10917
10918
10919
10920
10921
10922
10923
10924
10925
10926
10927
10928
10929
10930
10931
10932
10933
10934
10935
10936
10937
10938
10939
10940
10941
10942
10943
10944
10945
10946
10947
10948
10949
10950
10951
10952
10953
10954
10955
10956
10957
10958
10959
10960
10961
10962
10963
10964
10965
10966
10967
10968
10969
10970
10971
10972
10973
10974
10975
10976
10977
10978
10979
10980
10981
10982
10983
10984
10985
10986
10987
10988
10989
10990
10991
10992
10993
10994
10995
10996
10997
10998
10999
11000
11001
11002
11003
11004
11005
11006
11007
11008
11009
11010
11011
11012
11013
11014
11015
11016
11017
11018
11019
11020
11021
11022
11023
11024
11025
11026
11027
11028
11029
11030
11031
11032
11033
11034
11035
11036
11037
11038
11039
11040
11041
11042
11043
11044
11045
11046
11047
11048
11049
11050
11051
11052
11053
11054
11055
11056
11057
11058
11059
11060
11061
11062
11063
11064
11065
11066
11067
11068
11069
11070
11071
11072
11073
11074
11075
11076
11077
11078
11079
11080
11081
11082
11083
11084
11085
11086
11087
11088
11089
11090
11091
11092
11093
11094
11095
11096
11097
11098
11099
11100
11101
11102
11103
11104
11105
11106
11107
11108
11109
11110
11111
11112
11113
11114
11115
11116
11117
11118
11119
11120
11121
11122
11123
11124
11125
11126
11127
11128
11129
11130
11131
11132
11133
11134
11135
11136
11137
11138
11139
11140
11141
11142
11143
11144
11145
11146
11147
11148
11149
11150
11151
11152
11153
11154
11155
11156
11157
11158
11159
11160
11161
11162
11163
11164
11165
11166
11167
11168
11169
11170
11171
11172
11173
11174
11175
11176
11177
11178
11179
11180
11181
11182
11183
11184
11185
11186
11187
11188
11189
11190
11191
11192
11193
11194
11195
11196
11197
11198
11199
11200
11201
11202
11203
11204
11205
11206
11207
11208
11209
11210
11211
11212
11213
11214
11215
11216
11217
11218
11219
11220
11221
11222
11223
11224
11225
11226
11227
11228
11229
11230
11231
11232
11233
11234
11235
11236
11237
11238
11239
11240
11241
11242
11243
11244
11245
11246
11247
11248
11249
11250
11251
11252
11253
11254
11255
11256
11257
11258
11259
11260
11261
11262
11263
11264
11265
11266
11267
11268
11269
11270
11271
11272
11273
11274
11275
11276
11277
11278
11279
11280
11281
11282
11283
11284
11285
11286
11287
11288
11289
11290
11291
11292
11293
11294
11295
11296
11297
11298
11299
11300
11301
11302
11303
11304
11305
11306
11307
11308
11309
11310
11311
11312
11313
11314
11315
11316
11317
11318
11319
11320
11321
11322
11323
11324
11325
11326
11327
11328
11329
11330
11331
11332
11333
11334
11335
11336
11337
11338
11339
11340
11341
11342
11343
11344
11345
11346
11347
11348
11349
11350
11351
11352
11353
11354
11355
11356
11357
11358
11359
11360
11361
11362
11363
11364
11365
11366
11367
11368
11369
11370
11371
11372
11373
11374
11375
11376
11377
11378
11379
11380
11381
11382
11383
11384
11385
11386
11387
11388
11389
11390
11391
11392
11393
11394
11395
11396
11397
11398
11399
11400
11401
11402
11403
11404
11405
11406
11407
11408
11409
11410
11411
11412
11413
11414
11415
11416
11417
11418
11419
11420
11421
11422
11423
11424
11425
11426
11427
11428
11429
11430
11431
11432
11433
11434
11435
11436
11437
11438
11439
11440
11441
11442
11443
11444
11445
11446
11447
11448
11449
11450
11451
11452
11453
11454
11455
11456
11457
11458
11459
11460
11461
11462
11463
11464
11465
11466
11467
11468
11469
11470
11471
11472
11473
11474
11475
11476
11477
11478
11479
11480
11481
11482
11483
11484
11485
11486
11487
11488
11489
11490
11491
11492
11493
11494
11495
11496
11497
11498
11499
11500
11501
11502
11503
11504
11505
11506
11507
11508
11509
11510
11511
11512
11513
11514
11515
11516
11517
11518
11519
11520
11521
11522
11523
11524
11525
11526
11527
11528
11529
11530
11531
11532
11533
11534
11535
11536
11537
11538
11539
11540
11541
11542
11543
11544
11545
11546
11547
11548
11549
11550
11551
11552
11553
11554
11555
11556
11557
11558
11559
11560
11561
11562
11563
11564
11565
11566
11567
11568
11569
11570
11571
11572
11573
11574
11575
11576
11577
11578
11579
11580
11581
11582
11583
11584
11585
11586
11587
11588
11589
11590
11591
11592
11593
11594
11595
11596
11597
11598
11599
11600
11601
11602
11603
11604
11605
11606
11607
11608
11609
11610
11611
11612
11613
11614
11615
11616
11617
11618
11619
11620
11621
11622
11623
11624
11625
11626
11627
11628
11629
11630
11631
11632
11633
11634
11635
11636
11637
11638
11639
11640
11641
11642
11643
11644
11645
11646
11647
11648
11649
11650
11651
11652
11653
11654
11655
11656
11657
11658
11659
11660
11661
11662
11663
11664
11665
11666
11667
11668
11669
11670
11671
11672
11673
11674
11675
11676
11677
11678
11679
11680
11681
11682
11683
11684
11685
11686
11687
11688
11689
11690
11691
11692
11693
11694
11695
11696
11697
11698
11699
11700
11701
11702
11703
11704
11705
11706
11707
11708
11709
11710
11711
11712
11713
11714
11715
11716
11717
11718
11719
11720
11721
11722
11723
11724
11725
11726
11727
11728
11729
11730
11731
11732
11733
11734
11735
11736
11737
11738
11739
11740
11741
11742
11743
11744
11745
11746
11747
11748
11749
11750
11751
11752
11753
11754
11755
11756
11757
11758
11759
11760
11761
11762
11763
11764
11765
11766
11767
11768
11769
11770
11771
11772
11773
11774
11775
11776
11777
11778
11779
11780
11781
11782
11783
11784
11785
11786
11787
11788
11789
11790
11791
11792
11793
11794
11795
11796
11797
11798
11799
11800
11801
11802
11803
11804
11805
11806
11807
11808
11809
11810
11811
11812
11813
11814
11815
11816
11817
11818
11819
11820
11821
11822
11823
11824
11825
11826
11827
11828
11829
11830
11831
11832
11833
11834
11835
11836
11837
11838
11839
11840
11841
11842
11843
11844
11845
11846
11847
11848
11849
11850
11851
11852
11853
11854
11855
11856
11857
11858
11859
11860
11861
11862
11863
11864
11865
11866
11867
11868
11869
11870
11871
11872
11873
11874
11875
11876
11877
11878
11879
11880
11881
11882
11883
11884
11885
11886
11887
11888
11889
11890
11891
11892
11893
11894
11895
11896
11897
11898
11899
11900
11901
11902
11903
11904
11905
11906
11907
11908
11909
11910
11911
11912
11913
11914
11915
11916
11917
11918
11919
11920
11921
11922
11923
11924
11925
11926
11927
11928
11929
11930
11931
11932
11933
11934
11935
11936
11937
11938
11939
11940
11941
11942
11943
11944
11945
11946
11947
11948
11949
11950
11951
11952
11953
11954
11955
11956
11957
11958
11959
11960
11961
11962
11963
11964
11965
11966
11967
11968
11969
11970
11971
11972
11973
11974
11975
11976
11977
11978
11979
11980
11981
11982
11983
11984
11985
11986
11987
11988
11989
11990
11991
11992
11993
11994
11995
11996
11997
11998
11999
12000
12001
12002
12003
12004
12005
12006
12007
12008
12009
12010
12011
12012
12013
12014
12015
12016
12017
12018
12019
12020
12021
12022
12023
12024
12025
12026
12027
12028
12029
12030
12031
12032
12033
12034
12035
12036
12037
12038
12039
12040
12041
12042
12043
12044
12045
12046
12047
12048
12049
12050
12051
12052
12053
12054
12055
12056
12057
12058
12059
12060
12061
12062
12063
12064
12065
12066
12067
12068
12069
12070
12071
12072
12073
12074
12075
12076
12077
12078
12079
12080
12081
12082
12083
12084
12085
12086
12087
12088
12089
12090
12091
12092
12093
12094
12095
12096
12097
12098
12099
12100
12101
12102
12103
12104
12105
12106
12107
12108
12109
12110
12111
12112
12113
12114
12115
12116
12117
12118
12119
12120
12121
12122
12123
12124
12125
12126
12127
12128
12129
12130
12131
12132
12133
12134
12135
12136
12137
12138
12139
12140
12141
12142
12143
12144
12145
12146
12147
12148
12149
12150
12151
12152
12153
12154
12155
12156
12157
12158
12159
12160
12161
12162
12163
12164
12165
12166
12167
12168
12169
12170
12171
12172
12173
12174
12175
12176
12177
12178
12179
12180
12181
12182
12183
12184
12185
12186
12187
12188
12189
12190
12191
12192
12193
12194
12195
12196
12197
12198
12199
12200
12201
12202
12203
12204
12205
12206
12207
12208
12209
12210
12211
12212
12213
12214
12215
12216
12217
12218
12219
12220
12221
12222
12223
12224
12225
12226
12227
12228
12229
12230
12231
12232
12233
12234
12235
12236
12237
12238
12239
12240
12241
12242
12243
12244
12245
12246
12247
12248
12249
12250
12251
12252
12253
12254
12255
12256
12257
12258
12259
12260
12261
12262
12263
12264
12265
12266
12267
12268
12269
12270
12271
12272
12273
12274
12275
12276
12277
12278
12279
12280
12281
12282
12283
12284
12285
12286
12287
12288
12289
12290
12291
12292
12293
12294
12295
12296
12297
12298
12299
12300
12301
12302
12303
12304
12305
12306
12307
12308
12309
12310
12311
12312
12313
12314
12315
12316
12317
12318
12319
12320
12321
12322
12323
12324
12325
12326
12327
12328
12329
12330
12331
12332
12333
12334
12335
12336
12337
12338
12339
12340
12341
12342
12343
12344
12345
12346
12347
12348
12349
12350
12351
12352
12353
12354
12355
12356
12357
12358
12359
12360
12361
12362
12363
12364
12365
12366
12367
12368
12369
12370
12371
12372
12373
12374
12375
12376
12377
12378
12379
12380
12381
12382
12383
12384
12385
12386
12387
12388
12389
12390
12391
12392
12393
12394
12395
12396
12397
12398
12399
12400
12401
12402
12403
12404
12405
12406
12407
12408
12409
12410
12411
12412
12413
12414
12415
12416
12417
12418
12419
12420
12421
12422
12423
12424
12425
12426
12427
12428
12429
12430
12431
12432
12433
12434
12435
12436
12437
12438
12439
12440
12441
12442
12443
12444
12445
12446
12447
12448
12449
12450
12451
12452
12453
12454
12455
12456
12457
12458
12459
12460
12461
12462
12463
12464
12465
12466
12467
12468
12469
12470
12471
12472
12473
12474
12475
12476
12477
12478
12479
12480
12481
12482
12483
12484
12485
12486
12487
12488
12489
12490
12491
12492
12493
12494
12495
12496
12497
12498
12499
12500
12501
12502
12503
12504
12505
12506
12507
12508
12509
12510
12511
12512
12513
12514
12515
12516
12517
12518
12519
12520
12521
12522
12523
12524
12525
12526
12527
12528
12529
12530
12531
12532
12533
12534
12535
12536
12537
12538
12539
12540
12541
12542
12543
12544
12545
12546
12547
12548
12549
12550
12551
12552
12553
12554
12555
12556
12557
12558
12559
12560
12561
12562
12563
12564
12565
12566
12567
12568
12569
12570
12571
12572
12573
12574
12575
12576
12577
12578
12579
12580
12581
12582
12583
12584
12585
12586
12587
12588
12589
12590
12591
12592
12593
12594
12595
12596
12597
12598
12599
12600
12601
12602
12603
12604
12605
12606
12607
12608
12609
12610
12611
12612
12613
12614
12615
12616
12617
12618
12619
12620
12621
12622
12623
12624
12625
12626
12627
12628
12629
12630
12631
12632
12633
12634
12635
12636
12637
12638
12639
12640
12641
12642
12643
12644
12645
12646
12647
12648
12649
12650
12651
12652
12653
12654
12655
12656
12657
12658
12659
12660
12661
12662
12663
12664
12665
12666
12667
12668
12669
12670
12671
12672
12673
12674
12675
12676
12677
12678
12679
12680
12681
12682
12683
12684
12685
12686
12687
12688
12689
12690
12691
12692
# File 'lib/parser/lexer-F0.rb', line 8543

def advance
  unless @token_queue.empty?
    return @token_queue.shift
  end

  # Ugly, but dependent on Ragel output. Consider refactoring it somehow.
  klass = self.class
  _lex_trans_keys         = klass.send :_lex_trans_keys
  _lex_key_spans          = klass.send :_lex_key_spans
  _lex_index_offsets      = klass.send :_lex_index_offsets
  _lex_indicies           = klass.send :_lex_indicies
  _lex_trans_targs        = klass.send :_lex_trans_targs
  _lex_trans_actions      = klass.send :_lex_trans_actions
  _lex_to_state_actions   = klass.send :_lex_to_state_actions
  _lex_from_state_actions = klass.send :_lex_from_state_actions
  _lex_eof_trans          = klass.send :_lex_eof_trans
  _lex_actions            = @_lex_actions

  pe = @source_pts.size + 2
  p, eof = @p, pe

  cmd_state = @command_start
  @command_start = false

  
# line 8568 "lib/parser/lexer-F0.rb"
begin # ragel flat
	testEof = false
	_slen, _trans, _keys, _inds, _acts, _nacts = nil
	_goto_level = 0
	_resume = 10
	_eof_trans = 15
	_again = 20
	_test_eof = 30
	_out = 40
	while true
	_trigger_goto = false
	if _goto_level <= 0
	if p == pe
_goto_level = _test_eof
next
	end
	if  @cs == 0
_goto_level = _out
next
	end
	end
	if _goto_level <= _resume
	_acts = _lex_from_state_actions[ @cs]
	_nacts = _lex_actions[_acts]
	_acts += 1
	while _nacts > 0
_nacts -= 1
_acts += 1
case _lex_actions[_acts - 1]
	when 52 then
# line 1 "NONE"
begin
 @ts = p
end
# line 8603 "lib/parser/lexer-F0.rb"
end # from state action switch
	end
	if _trigger_goto
next
	end
	_keys =  @cs << 1
	_inds = _lex_index_offsets[ @cs]
	_slen = _lex_key_spans[ @cs]
	_wide = ( (@source_pts[p] || 0))
	_trans = if (   _slen > 0 && 
	_lex_trans_keys[_keys] <= _wide && 
	_wide <= _lex_trans_keys[_keys + 1] 
    ) then
	_lex_indicies[ _inds + _wide - _lex_trans_keys[_keys] ] 
 else 
	_lex_indicies[ _inds + _slen ]
 end
	end
	if _goto_level <= _eof_trans
@cs = _lex_trans_targs[_trans]
	if _lex_trans_actions[_trans] != 0
_acts = _lex_trans_actions[_trans]
_nacts = _lex_actions[_acts]
_acts += 1
while _nacts > 0
	_nacts -= 1
	_acts += 1
	case _lex_actions[_acts - 1]
	when 0 then
# line 539 "lib/parser/lexer.rl"
begin

  # Record position of a newline for precise location reporting on tNL
  # tokens.
  #
  # This action is embedded directly into c_nl, as it is idempotent and
  # there are no cases when we need to skip it.
  @newline_s = p
		end
	when 1 then
# line 673 "lib/parser/lexer.rl"
begin
 @num_xfrm = @emit_integer 		end
	when 2 then
# line 674 "lib/parser/lexer.rl"
begin
 @num_xfrm = @emit_rational 		end
	when 3 then
# line 675 "lib/parser/lexer.rl"
begin
 @num_xfrm = @emit_imaginary 		end
	when 4 then
# line 676 "lib/parser/lexer.rl"
begin
 @num_xfrm = @emit_imaginary_rational 		end
	when 5 then
# line 677 "lib/parser/lexer.rl"
begin
 @num_xfrm = @emit_integer_re 		end
	when 6 then
# line 678 "lib/parser/lexer.rl"
begin
 @num_xfrm = @emit_integer_if 		end
	when 7 then
# line 679 "lib/parser/lexer.rl"
begin
 @num_xfrm = @emit_integer_rescue 		end
	when 8 then
# line 682 "lib/parser/lexer.rl"
begin
 @num_xfrm = @emit_float 		end
	when 9 then
# line 683 "lib/parser/lexer.rl"
begin
 @num_xfrm = @emit_imaginary_float 		end
	when 10 then
# line 684 "lib/parser/lexer.rl"
begin
 @num_xfrm = @emit_float_if 		end
	when 11 then
# line 688 "lib/parser/lexer.rl"
begin
 @num_xfrm = @emit_rational 		end
	when 12 then
# line 689 "lib/parser/lexer.rl"
begin
 @num_xfrm = @emit_imaginary_rational 		end
	when 13 then
# line 690 "lib/parser/lexer.rl"
begin
 @num_xfrm = @emit_float_rescue 		end
	when 14 then
# line 696 "lib/parser/lexer.rl"
begin

  e_lbrace
		end
	when 15 then
# line 700 "lib/parser/lexer.rl"
begin

  if @strings.close_interp_on_current_literal(p)
    p = p - 1;
     @cs = 128;
    	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

  end

  @paren_nest -= 1
		end
	when 16 then
# line 723 "lib/parser/lexer.rl"
begin

  p = on_newline(p)
		end
	when 17 then
# line 733 "lib/parser/lexer.rl"
begin
 @sharp_s = p - 1 		end
	when 18 then
# line 736 "lib/parser/lexer.rl"
begin
 emit_comment_from_range(p, pe) 		end
	when 19 then
# line 777 "lib/parser/lexer.rl"
begin
 tm = p 		end
	when 20 then
# line 778 "lib/parser/lexer.rl"
begin
 tm = p - 2 		end
	when 21 then
# line 783 "lib/parser/lexer.rl"
begin
 tm = p 		end
	when 22 then
# line 784 "lib/parser/lexer.rl"
begin
 tm = p - 2 		end
	when 23 then
# line 785 "lib/parser/lexer.rl"
begin
 tm = p - 2 		end
	when 24 then
# line 786 "lib/parser/lexer.rl"
begin
 tm = p - 2 		end
	when 25 then
# line 787 "lib/parser/lexer.rl"
begin
 tm = p - 3 		end
	when 26 then
# line 792 "lib/parser/lexer.rl"
begin
 tm = p - 2 		end
	when 27 then
# line 797 "lib/parser/lexer.rl"
begin
 tm = p - 2 		end
	when 28 then
# line 803 "lib/parser/lexer.rl"
begin

  @cond.push(false); @cmdarg.push(false)

  @paren_nest += 1
		end
	when 29 then
# line 809 "lib/parser/lexer.rl"
begin

  @paren_nest -= 1
		end
	when 30 then
# line 816 "lib/parser/lexer.rl"
begin

  @cond.push(false); @cmdarg.push(false)

  @paren_nest += 1

  if version?(18)
    @command_start = true
  end
		end
	when 31 then
# line 826 "lib/parser/lexer.rl"
begin

  @paren_nest -= 1
		end
	when 32 then
# line 1061 "lib/parser/lexer.rl"
begin
 tm = p 		end
	when 33 then
# line 1074 "lib/parser/lexer.rl"
begin
 tm = p 		end
	when 34 then
# line 1102 "lib/parser/lexer.rl"
begin
 tm = p 		end
	when 35 then
# line 1299 "lib/parser/lexer.rl"
begin
 heredoc_e      = p 		end
	when 36 then
# line 1300 "lib/parser/lexer.rl"
begin
 new_herebody_s = p 		end
	when 37 then
# line 1400 "lib/parser/lexer.rl"
begin
 tm = p - 1; diag_msg = :ivar_name 		end
	when 38 then
# line 1401 "lib/parser/lexer.rl"
begin
 tm = p - 2; diag_msg = :cvar_name 		end
	when 39 then
# line 1488 "lib/parser/lexer.rl"
begin
 tm = p 		end
	when 40 then
# line 1595 "lib/parser/lexer.rl"
begin
 ident_tok = tok; ident_ts = @ts; ident_te = @te; 		end
	when 41 then
# line 1781 "lib/parser/lexer.rl"
begin
 @num_base = 16; @num_digits_s = p 		end
	when 42 then
# line 1782 "lib/parser/lexer.rl"
begin
 @num_base = 10; @num_digits_s = p 		end
	when 43 then
# line 1783 "lib/parser/lexer.rl"
begin
 @num_base = 8;  @num_digits_s = p 		end
	when 44 then
# line 1784 "lib/parser/lexer.rl"
begin
 @num_base = 2;  @num_digits_s = p 		end
	when 45 then
# line 1785 "lib/parser/lexer.rl"
begin
 @num_base = 10; @num_digits_s = @ts 		end
	when 46 then
# line 1786 "lib/parser/lexer.rl"
begin
 @num_base = 8;  @num_digits_s = @ts 		end
	when 47 then
# line 1787 "lib/parser/lexer.rl"
begin
 @num_suffix_s = p 		end
	when 48 then
# line 1830 "lib/parser/lexer.rl"
begin
 @num_suffix_s = p 		end
	when 49 then
# line 1831 "lib/parser/lexer.rl"
begin
 @num_suffix_s = p 		end
	when 50 then
# line 2034 "lib/parser/lexer.rl"
begin
 tm = p 		end
	when 53 then
# line 1 "NONE"
begin
 @te = p+1
end
	when 54 then
# line 848 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin 
      emit_global_var

       @cs = (stack_pop); 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

     end
end
	when 55 then
# line 848 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin 
      emit_global_var

       @cs = (stack_pop); 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

     end
end
	when 56 then
# line 855 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin 
      emit_class_var

       @cs = (stack_pop); 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

     end
end
	when 57 then
# line 862 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin 
      emit_instance_var

       @cs = (stack_pop); 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

     end
end
	when 58 then
# line 880 "lib/parser/lexer.rl"
begin
 @act = 4;		end
	when 59 then
# line 884 "lib/parser/lexer.rl"
begin
 @act = 5;		end
	when 60 then
# line 888 "lib/parser/lexer.rl"
begin
 @act = 6;		end
	when 61 then
# line 880 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin  emit_table(KEYWORDS_BEGIN);
          @cs = 247; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end
end
end
	when 62 then
# line 888 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin  emit(:tIDENTIFIER)
          @cs = 247; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end
end
end
	when 63 then
# line 892 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin  p = @ts - 1
          @cs = 516; 	begin
 @stack[ @top] =  @cs
 @top+= 1
 @cs = 129
_trigger_goto = true
_goto_level = _again
break
	end
end
end
	when 64 then
# line 901 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin  emit_table(PUNCTUATION)
          @cs = 247; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end
end
end
	when 65 then
# line 905 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin  p = p - 1; p = p - 1; 	begin
 @cs = 516
_trigger_goto = true
_goto_level = _again
break
	end
end
end
	when 66 then
# line 911 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin 
      if version?(23)
        type, delimiter = tok[0..-2], tok[-1].chr
        @strings.push_literal(type, delimiter, @ts)
        	begin
 @cs = 128
_trigger_goto = true
_goto_level = _again
break
	end

      else
        p = @ts - 1
        	begin
 @cs = 516
_trigger_goto = true
_goto_level = _again
break
	end

      end
     end
end
	when 67 then
# line 925 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin  p = p - 1; 	begin
 @cs = 516
_trigger_goto = true
_goto_level = _again
break
	end
end
end
	when 68 then
# line 566 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin 
  # Sit at EOF indefinitely. #advance would return $eof each time.
  # This allows to feed the lexer more data if needed; this is only used
  # in tests.
  #
  # Note that this action is not embedded into e_eof like e_nl and e_bs
  # below. This is due to the fact that scanner state at EOF is observed
  # by tests, and encapsulating it in a rule would break the introspection.
  p = p - 1; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

 end
end
	when 69 then
# line 880 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin  emit_table(KEYWORDS_BEGIN);
          @cs = 247; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end
end
end
	when 70 then
# line 884 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin  emit(:tCONSTANT)
          @cs = 247; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end
end
end
	when 71 then
# line 888 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin  emit(:tIDENTIFIER)
          @cs = 247; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end
end
end
	when 72 then
# line 892 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin  p = @ts - 1
          @cs = 516; 	begin
 @stack[ @top] =  @cs
 @top+= 1
 @cs = 129
_trigger_goto = true
_goto_level = _again
break
	end
end
end
	when 73 then
# line 901 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin  emit_table(PUNCTUATION)
          @cs = 247; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end
end
end
	when 74 then
# line 908 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin  p = p - 1; 	begin
 @cs = 345
_trigger_goto = true
_goto_level = _again
break
	end
end
end
	when 75 then
# line 922 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1;		end
	when 76 then
# line 925 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin  p = p - 1; 	begin
 @cs = 516
_trigger_goto = true
_goto_level = _again
break
	end
end
end
	when 77 then
# line 901 "lib/parser/lexer.rl"
begin
 begin p = (( @te))-1; end
 begin  emit_table(PUNCTUATION)
          @cs = 247; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end
end
end
	when 78 then
# line 925 "lib/parser/lexer.rl"
begin
 begin p = (( @te))-1; end
 begin  p = p - 1; 	begin
 @cs = 516
_trigger_goto = true
_goto_level = _again
break
	end
end
end
	when 79 then
# line 1 "NONE"
begin
	case  @act
	when 4 then
	begin begin p = (( @te))-1; end
 emit_table(KEYWORDS_BEGIN);
          @cs = 247; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end
 end
	when 5 then
	begin begin p = (( @te))-1; end
 emit(:tCONSTANT)
          @cs = 247; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end
 end
	when 6 then
	begin begin p = (( @te))-1; end
 emit(:tIDENTIFIER)
          @cs = 247; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end
 end
end 
	end
	when 80 then
# line 937 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin  emit(:tLABEL, tok(@ts, @te - 2), @ts, @te - 1)
         p = p - 1;  @cs = 501; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end
end
end
	when 81 then
# line 941 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin 
      if @version >= 31 && @context.in_argdef
        emit(:tBDOT3, '...'.freeze)
        # emit(:tNL, "\n".freeze, @te - 1, @te)
         @cs = 516; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

      else
        p -= 3;
        	begin
 @cs = 516
_trigger_goto = true
_goto_level = _again
break
	end

      end
     end
end
	when 82 then
# line 955 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin  p = p - 1; 	begin
 @cs = 516
_trigger_goto = true
_goto_level = _again
break
	end
end
end
	when 83 then
# line 566 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin 
  # Sit at EOF indefinitely. #advance would return $eof each time.
  # This allows to feed the lexer more data if needed; this is only used
  # in tests.
  #
  # Note that this action is not embedded into e_eof like e_nl and e_bs
  # below. This is due to the fact that scanner state at EOF is observed
  # by tests, and encapsulating it in a rule would break the introspection.
  p = p - 1; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

 end
end
	when 84 then
# line 952 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1;		end
	when 85 then
# line 955 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin  p = p - 1; 	begin
 @cs = 516
_trigger_goto = true
_goto_level = _again
break
	end
end
end
	when 86 then
# line 955 "lib/parser/lexer.rl"
begin
 begin p = (( @te))-1; end
 begin  p = p - 1; 	begin
 @cs = 516
_trigger_goto = true
_goto_level = _again
break
	end
end
end
	when 87 then
# line 981 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin  emit_table(PUNCTUATION)
          @cs = 276; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end
end
end
	when 88 then
# line 987 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin  p = p - 1; 	begin
 @cs = 516
_trigger_goto = true
_goto_level = _again
break
	end
end
end
	when 89 then
# line 566 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin 
  # Sit at EOF indefinitely. #advance would return $eof each time.
  # This allows to feed the lexer more data if needed; this is only used
  # in tests.
  #
  # Note that this action is not embedded into e_eof like e_nl and e_bs
  # below. This is due to the fact that scanner state at EOF is observed
  # by tests, and encapsulating it in a rule would break the introspection.
  p = p - 1; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

 end
end
	when 90 then
# line 966 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin  emit(:tCONSTANT)
          @cs = (arg_or_cmdarg(cmd_state)); 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end
end
end
	when 91 then
# line 970 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin  emit(:tIDENTIFIER)
          @cs = (arg_or_cmdarg(cmd_state)); 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end
end
end
	when 92 then
# line 974 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin  emit(:tFID, tok(@ts, tm), @ts, tm)
          @cs = (arg_or_cmdarg(cmd_state)); p = tm - 1; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end
end
end
	when 93 then
# line 981 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin  emit_table(PUNCTUATION)
          @cs = 276; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end
end
end
	when 94 then
# line 984 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1;		end
	when 95 then
# line 987 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin  p = p - 1; 	begin
 @cs = 516
_trigger_goto = true
_goto_level = _again
break
	end
end
end
	when 96 then
# line 1065 "lib/parser/lexer.rl"
begin
 @act = 33;		end
	when 97 then
# line 1075 "lib/parser/lexer.rl"
begin
 @act = 34;		end
	when 98 then
# line 1114 "lib/parser/lexer.rl"
begin
 @act = 39;		end
	when 99 then
# line 1119 "lib/parser/lexer.rl"
begin
 @act = 40;		end
	when 100 then
# line 1047 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin 
      # Unlike expr_beg as invoked in the next rule, do not warn
      p = @ts - 1
      	begin
 @cs = 516
_trigger_goto = true
_goto_level = _again
break
	end

     end
end
	when 101 then
# line 1065 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin 
      check_ambiguous_slash(tm)

      p = tm - 1
      	begin
 @cs = 345
_trigger_goto = true
_goto_level = _again
break
	end

     end
end
	when 102 then
# line 1086 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin  p = p - 1; p = p - 1; 	begin
 @cs = 345
_trigger_goto = true
_goto_level = _again
break
	end
end
end
	when 103 then
# line 1094 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin  p = @ts - 1; 	begin
 @cs = 345
_trigger_goto = true
_goto_level = _again
break
	end
end
end
	when 104 then
# line 1103 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin  p = tm - 1; 	begin
 @cs = 516
_trigger_goto = true
_goto_level = _again
break
	end
end
end
	when 105 then
# line 1114 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin 
      p = @ts - 1
      	begin
 @cs = 516
_trigger_goto = true
_goto_level = _again
break
	end

     end
end
	when 106 then
# line 1128 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin  p = p - 1; 	begin
 @cs = 345
_trigger_goto = true
_goto_level = _again
break
	end
end
end
	when 107 then
# line 566 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin 
  # Sit at EOF indefinitely. #advance would return $eof each time.
  # This allows to feed the lexer more data if needed; this is only used
  # in tests.
  #
  # Note that this action is not embedded into e_eof like e_nl and e_bs
  # below. This is due to the fact that scanner state at EOF is observed
  # by tests, and encapsulating it in a rule would break the introspection.
  p = p - 1; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

 end
end
	when 108 then
# line 1003 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin 
      if version?(18)
        emit(:tLPAREN2, '('.freeze, @te - 1, @te)
         @cs = 508; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

      else
        emit(:tLPAREN_ARG, '('.freeze, @te - 1, @te)
         @cs = 345; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

      end
     end
end
	when 109 then
# line 1016 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin  emit(:tLPAREN2, '('.freeze)
          @cs = 345; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end
end
end
	when 110 then
# line 1022 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin  emit(:tLBRACK, '['.freeze, @te - 1, @te)
          @cs = 345; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end
end
end
	when 111 then
# line 1028 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin 
      if @lambda_stack.last == @paren_nest
        @lambda_stack.pop
        emit(:tLAMBEG, '{'.freeze, @te - 1, @te)
      else
        emit(:tLCURLY, '{'.freeze, @te - 1, @te)
      end
      @command_start = true
      @paren_nest += 1
       @cs = 508; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

     end
end
	when 112 then
# line 1056 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin  p = p - 1; 	begin
 @cs = 345
_trigger_goto = true
_goto_level = _again
break
	end
end
end
	when 113 then
# line 1075 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin 
      diagnostic :warning, :ambiguous_prefix, { :prefix => tok(tm, @te) },
                 range(tm, @te)

      p = tm - 1
      	begin
 @cs = 345
_trigger_goto = true
_goto_level = _again
break
	end

     end
end
	when 114 then
# line 1091 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin  p = p - 1; 	begin
 @cs = 345
_trigger_goto = true
_goto_level = _again
break
	end
end
end
	when 115 then
# line 1114 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin 
      p = @ts - 1
      	begin
 @cs = 516
_trigger_goto = true
_goto_level = _again
break
	end

     end
end
	when 116 then
# line 1119 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1;		end
	when 117 then
# line 1122 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin  	begin
 @cs = 516
_trigger_goto = true
_goto_level = _again
break
	end
end
end
	when 118 then
# line 1125 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin  p = p - 1; 	begin
 @cs = 516
_trigger_goto = true
_goto_level = _again
break
	end
end
end
	when 119 then
# line 1128 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin  p = p - 1; 	begin
 @cs = 345
_trigger_goto = true
_goto_level = _again
break
	end
end
end
	when 120 then
# line 1119 "lib/parser/lexer.rl"
begin
 begin p = (( @te))-1; end
end
	when 121 then
# line 1128 "lib/parser/lexer.rl"
begin
 begin p = (( @te))-1; end
 begin  p = p - 1; 	begin
 @cs = 345
_trigger_goto = true
_goto_level = _again
break
	end
end
end
	when 122 then
# line 1 "NONE"
begin
	case  @act
	when 33 then
	begin begin p = (( @te))-1; end

      check_ambiguous_slash(tm)

      p = tm - 1
      	begin
 @cs = 345
_trigger_goto = true
_goto_level = _again
break
	end

    end
	when 34 then
	begin begin p = (( @te))-1; end

      diagnostic :warning, :ambiguous_prefix, { :prefix => tok(tm, @te) },
                 range(tm, @te)

      p = tm - 1
      	begin
 @cs = 345
_trigger_goto = true
_goto_level = _again
break
	end

    end
	when 39 then
	begin begin p = (( @te))-1; end

      p = @ts - 1
      	begin
 @cs = 516
_trigger_goto = true
_goto_level = _again
break
	end

    end
	else
	begin begin p = (( @te))-1; end
end
end 
	end
	when 123 then
# line 1151 "lib/parser/lexer.rl"
begin
 @act = 46;		end
	when 124 then
# line 1164 "lib/parser/lexer.rl"
begin
 @act = 47;		end
	when 125 then
# line 1164 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin  p = @ts - 1
         	begin
 @cs = 276
_trigger_goto = true
_goto_level = _again
break
	end
end
end
	when 126 then
# line 566 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin 
  # Sit at EOF indefinitely. #advance would return $eof each time.
  # This allows to feed the lexer more data if needed; this is only used
  # in tests.
  #
  # Note that this action is not embedded into e_eof like e_nl and e_bs
  # below. This is due to the fact that scanner state at EOF is observed
  # by tests, and encapsulating it in a rule would break the introspection.
  p = p - 1; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

 end
end
	when 127 then
# line 1141 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin 
      emit(:tLPAREN_ARG, '('.freeze, @te - 1, @te)
      if version?(18)
         @cs = 508; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

      else
         @cs = 345; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

      end
     end
end
	when 128 then
# line 1164 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin  p = @ts - 1
         	begin
 @cs = 276
_trigger_goto = true
_goto_level = _again
break
	end
end
end
	when 129 then
# line 1164 "lib/parser/lexer.rl"
begin
 begin p = (( @te))-1; end
 begin  p = @ts - 1
         	begin
 @cs = 276
_trigger_goto = true
_goto_level = _again
break
	end
end
end
	when 130 then
# line 1 "NONE"
begin
	case  @act
	when 46 then
	begin begin p = (( @te))-1; end

      if @cond.active?
        emit(:kDO_COND, 'do'.freeze, @te - 2, @te)
      else
        emit(:kDO, 'do'.freeze, @te - 2, @te)
      end
       @cs = 508; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

    end
	when 47 then
	begin begin p = (( @te))-1; end
 p = @ts - 1
         	begin
 @cs = 276
_trigger_goto = true
_goto_level = _again
break
	end
 end
end 
	end
	when 131 then
# line 1200 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin  emit_do(true)
          @cs = 508; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end
end
end
	when 132 then
# line 1206 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin  p = p - 1; 	begin
 @cs = 516
_trigger_goto = true
_goto_level = _again
break
	end
end
end
	when 133 then
# line 566 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin 
  # Sit at EOF indefinitely. #advance would return $eof each time.
  # This allows to feed the lexer more data if needed; this is only used
  # in tests.
  #
  # Note that this action is not embedded into e_eof like e_nl and e_bs
  # below. This is due to the fact that scanner state at EOF is observed
  # by tests, and encapsulating it in a rule would break the introspection.
  p = p - 1; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

 end
end
	when 134 then
# line 1187 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin 
      if @lambda_stack.last == @paren_nest
        @lambda_stack.pop
        emit(:tLAMBEG, '{'.freeze)
      else
        emit(:tLBRACE_ARG, '{'.freeze)
      end
      @paren_nest += 1
      @command_start = true
       @cs = 508; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

     end
end
	when 135 then
# line 1203 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1;		end
	when 136 then
# line 1206 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin  p = p - 1; 	begin
 @cs = 516
_trigger_goto = true
_goto_level = _again
break
	end
end
end
	when 137 then
# line 1218 "lib/parser/lexer.rl"
begin
 @act = 54;		end
	when 138 then
# line 1222 "lib/parser/lexer.rl"
begin
 @act = 55;		end
	when 139 then
# line 1230 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin  p = p - 1; 	begin
 @cs = 345
_trigger_goto = true
_goto_level = _again
break
	end
end
end
	when 140 then
# line 566 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin 
  # Sit at EOF indefinitely. #advance would return $eof each time.
  # This allows to feed the lexer more data if needed; this is only used
  # in tests.
  #
  # Note that this action is not embedded into e_eof like e_nl and e_bs
  # below. This is due to the fact that scanner state at EOF is observed
  # by tests, and encapsulating it in a rule would break the introspection.
  p = p - 1; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

 end
end
	when 141 then
# line 1222 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin  p = @ts - 1; 	begin
 @cs = 345
_trigger_goto = true
_goto_level = _again
break
	end
end
end
	when 142 then
# line 1224 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1;		end
	when 143 then
# line 1227 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin  p = p - 1; 	begin
 @cs = 516
_trigger_goto = true
_goto_level = _again
break
	end
end
end
	when 144 then
# line 1230 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin  p = p - 1; 	begin
 @cs = 345
_trigger_goto = true
_goto_level = _again
break
	end
end
end
	when 145 then
# line 1 "NONE"
begin
	case  @act
	when 54 then
	begin begin p = (( @te))-1; end
 emit_table(KEYWORDS)
          @cs = 345; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end
 end
	when 55 then
	begin begin p = (( @te))-1; end
 p = @ts - 1; 	begin
 @cs = 345
_trigger_goto = true
_goto_level = _again
break
	end
 end
end 
	end
	when 146 then
# line 1245 "lib/parser/lexer.rl"
begin
 @act = 60;		end
	when 147 then
# line 1348 "lib/parser/lexer.rl"
begin
 @act = 67;		end
	when 148 then
# line 1442 "lib/parser/lexer.rl"
begin
 @act = 76;		end
	when 149 then
# line 1483 "lib/parser/lexer.rl"
begin
 @act = 80;		end
	when 150 then
# line 1489 "lib/parser/lexer.rl"
begin
 @act = 81;		end
	when 151 then
# line 1495 "lib/parser/lexer.rl"
begin
 @act = 82;		end
	when 152 then
# line 1586 "lib/parser/lexer.rl"
begin
 @act = 86;		end
	when 153 then
# line 831 "lib/parser/lexer.rl"
begin
 @act = 87;		end
	when 154 then
# line 1632 "lib/parser/lexer.rl"
begin
 @act = 91;		end
	when 155 then
# line 1245 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin 
      emit(:tUNARY_NUM, tok(@ts, @ts + 1), @ts, @ts + 1)
      p = p - 1;  @cs = 516; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

     end
end
	when 156 then
# line 1262 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin 
      type = delimiter = tok[0].chr
      @strings.push_literal(type, delimiter, @ts)

      p = p - 1;
      	begin
 @cs = 128
_trigger_goto = true
_goto_level = _again
break
	end

     end
end
	when 157 then
# line 1272 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin 
      type, delimiter = @source_buffer.slice(@ts, 1).chr, tok[-1].chr
      @strings.push_literal(type, delimiter, @ts)
      	begin
 @cs = 128
_trigger_goto = true
_goto_level = _again
break
	end

     end
end
	when 158 then
# line 1280 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin 
      type, delimiter = tok[0..-2], tok[-1].chr
      @strings.push_literal(type, delimiter, @ts)
      	begin
 @cs = 128
_trigger_goto = true
_goto_level = _again
break
	end

     end
end
	when 159 then
# line 1357 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin 
      p = p - 1; p = p - 1;
      emit(:tSYMBEG, tok(@ts, @ts + 1), @ts, @ts + 1)
      	begin
 @cs = 134
_trigger_goto = true
_goto_level = _again
break
	end

     end
end
	when 160 then
# line 1365 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin 
      type, delimiter = tok, tok[-1].chr
      @strings.push_literal(type, delimiter, @ts);

      	begin
 @cs = 128
_trigger_goto = true
_goto_level = _again
break
	end

     end
end
	when 161 then
# line 1375 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin 
      emit(:tSYMBOL, tok(@ts + 1, @ts + 2))
       @cs = 516; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

     end
end
	when 162 then
# line 1389 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin 
      gvar_name = tok(@ts + 1)

      if @version >= 33 && gvar_name.start_with?('$0') && gvar_name.length > 2
        diagnostic :error, :gvar_name, { :name => gvar_name }, range(@ts + 1, @te)
      end

      emit(:tSYMBOL, gvar_name, @ts)
       @cs = 516; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

     end
end
	when 163 then
# line 1416 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin 
      p, next_state = @strings.read_character_constant(@ts)
      p = p - 1; # Ragel will do `p += 1` to consume input, prevent it

      # If strings lexer founds a character constant (?a) emit it,
      # otherwise read ternary operator
      if @token_queue.empty?
        	begin
 @cs = (next_state)
_trigger_goto = true
_goto_level = _again
break
	end

      else
         @cs = (next_state);
        	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

      end
     end
end
	when 164 then
# line 1431 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin 
      diagnostic :fatal, :incomplete_escape, nil, range(@ts, @ts + 1)
     end
end
	when 165 then
# line 1483 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin  emit_table(PUNCTUATION_BEGIN)
         	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end
end
end
	when 166 then
# line 1504 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin 
      p = p - 1;

      if version?(18)
        ident = tok(@ts, @te - 2)

        emit((@source_buffer.slice(@ts, 1) =~ /[A-Z]/) ? :tCONSTANT : :tIDENTIFIER,
             ident, @ts, @te - 2)
        p = p - 1; # continue as a symbol

        if !@static_env.nil? && @static_env.declared?(ident)
           @cs = 516;
        else
           @cs = (arg_or_cmdarg(cmd_state));
        end
      else
        emit(:tLABEL, tok(@ts, @te - 2), @ts, @te - 1)
         @cs = 501;
      end

      	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

     end
end
	when 167 then
# line 1542 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin 
      # Here we scan and conditionally emit "\n":
      # + if it's there
      #   + and emitted we do nothing
      #   + and not emitted we return `p` to "\n" to process it on the next scan
      # + if it's not there we do nothing
      followed_by_nl = @te - 1 == @newline_s
      nl_emitted = false
      dots_te = followed_by_nl ? @te - 1 : @te

      if @version >= 30
        if @lambda_stack.any? && @lambda_stack.last + 1 == @paren_nest
          # To reject `->(...)` like `->...`
          emit(:tDOT3, '...'.freeze, @ts, dots_te)
        else
          emit(:tBDOT3, '...'.freeze, @ts, dots_te)

          if @version >= 31 && followed_by_nl && @context.in_argdef
            emit(:tNL, @te - 1, @te)
            nl_emitted = true
          end
        end
      elsif @version >= 27
        emit(:tBDOT3, '...'.freeze, @ts, dots_te)
      else
        emit(:tDOT3, '...'.freeze, @ts, dots_te)
      end

      if followed_by_nl && !nl_emitted
        # return "\n" to process it on the next scan
        p = p - 1;
      end

       @cs = 345; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

     end
end
	when 168 then
# line 1597 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin 
      emit(:tIDENTIFIER, ident_tok, ident_ts, ident_te)
      p = ident_te - 1

      if !@static_env.nil? && @static_env.declared?(ident_tok) && @version < 25
         @cs = 247;
      else
         @cs = 307;
      end
      	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

     end
end
	when 169 then
# line 1616 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin 
      p = @ts - 1
      @cs_before_block_comment = @cs
      	begin
 @cs = 710
_trigger_goto = true
_goto_level = _again
break
	end

     end
end
	when 170 then
# line 1632 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin  p = @ts - 1; 	begin
 @cs = 516
_trigger_goto = true
_goto_level = _again
break
	end
end
end
	when 171 then
# line 566 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin 
  # Sit at EOF indefinitely. #advance would return $eof each time.
  # This allows to feed the lexer more data if needed; this is only used
  # in tests.
  #
  # Note that this action is not embedded into e_eof like e_nl and e_bs
  # below. This is due to the fact that scanner state at EOF is observed
  # by tests, and encapsulating it in a rule would break the introspection.
  p = p - 1; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

 end
end
	when 172 then
# line 1245 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin 
      emit(:tUNARY_NUM, tok(@ts, @ts + 1), @ts, @ts + 1)
      p = p - 1;  @cs = 516; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

     end
end
	when 173 then
# line 1252 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin  emit(:tSTAR, '*'.freeze)
         	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end
end
end
	when 174 then
# line 1287 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin 
      diagnostic :fatal, :string_eof, nil, range(@ts, @ts + 1)
     end
end
	when 175 then
# line 1301 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin 
      tok(@ts, heredoc_e) =~ /^<<(-?)(~?)(["'`]?)(.*)\3$/m

      indent      = !$1.empty? || !$2.empty?
      dedent_body = !$2.empty?
      type        =  $3.empty? ? '<<"'.freeze : ('<<'.freeze + $3)
      delimiter   =  $4

      if @version >= 27
        if delimiter.count("\n") > 0 || delimiter.count("\r") > 0
          diagnostic :error, :unterminated_heredoc_id, nil, range(@ts, @ts + 1)
        end
      elsif @version >= 24
        if delimiter.count("\n") > 0
          if delimiter.end_with?("\n")
            diagnostic :warning, :heredoc_id_ends_with_nl, nil, range(@ts, @ts + 1)
            delimiter = delimiter.rstrip
          else
            diagnostic :fatal, :heredoc_id_has_newline, nil, range(@ts, @ts + 1)
          end
        end
      end

      if dedent_body && version?(18, 19, 20, 21, 22)
        emit(:tLSHFT, '<<'.freeze, @ts, @ts + 2)
        p = @ts + 1
         @cs = 345; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

      else
        @strings.push_literal(type, delimiter, @ts, heredoc_e, indent, dedent_body);
        @strings.herebody_s ||= new_herebody_s

        p = @strings.herebody_s - 1
         @cs = 128;
      end
     end
end
	when 176 then
# line 1348 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin 
      diagnostic :error, :unterminated_heredoc_id, nil, range(@ts, @ts + 1)
     end
end
	when 177 then
# line 1381 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin 
      emit(:tSYMBOL, tok(@ts + 1, tm), @ts, tm)
      p = tm - 1
       @cs = 516; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

     end
end
	when 178 then
# line 1389 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin 
      gvar_name = tok(@ts + 1)

      if @version >= 33 && gvar_name.start_with?('$0') && gvar_name.length > 2
        diagnostic :error, :gvar_name, { :name => gvar_name }, range(@ts + 1, @te)
      end

      emit(:tSYMBOL, gvar_name, @ts)
       @cs = 516; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

     end
end
	when 179 then
# line 1403 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin 
      emit_colon_with_digits(p, tm, diag_msg)

       @cs = 516; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

     end
end
	when 180 then
# line 1431 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin 
      diagnostic :fatal, :incomplete_escape, nil, range(@ts, @ts + 1)
     end
end
	when 181 then
# line 1459 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin 
      if @lambda_stack.last == @paren_nest
        @lambda_stack.pop
        @command_start = true
        emit(:tLAMBEG, '{'.freeze)
      else
        emit(:tLBRACE, '{'.freeze)
      end
      @paren_nest += 1
      	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

     end
end
	when 182 then
# line 1473 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin  emit(:tLBRACK, '['.freeze)
         	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end
end
end
	when 183 then
# line 1478 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin  emit(:tLPAREN, '('.freeze)
         	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end
end
end
	when 184 then
# line 1483 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin  emit_table(PUNCTUATION_BEGIN)
         	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end
end
end
	when 185 then
# line 1489 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin  emit(:kRESCUE, 'rescue'.freeze, @ts, tm)
         p = tm - 1
          @cs = 321; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end
end
end
	when 186 then
# line 1531 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin 
      if @version >= 27
        emit(:tBDOT2)
      else
        emit(:tDOT2)
      end

       @cs = 345; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

     end
end
	when 187 then
# line 1542 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin 
      # Here we scan and conditionally emit "\n":
      # + if it's there
      #   + and emitted we do nothing
      #   + and not emitted we return `p` to "\n" to process it on the next scan
      # + if it's not there we do nothing
      followed_by_nl = @te - 1 == @newline_s
      nl_emitted = false
      dots_te = followed_by_nl ? @te - 1 : @te

      if @version >= 30
        if @lambda_stack.any? && @lambda_stack.last + 1 == @paren_nest
          # To reject `->(...)` like `->...`
          emit(:tDOT3, '...'.freeze, @ts, dots_te)
        else
          emit(:tBDOT3, '...'.freeze, @ts, dots_te)

          if @version >= 31 && followed_by_nl && @context.in_argdef
            emit(:tNL, @te - 1, @te)
            nl_emitted = true
          end
        end
      elsif @version >= 27
        emit(:tBDOT3, '...'.freeze, @ts, dots_te)
      else
        emit(:tDOT3, '...'.freeze, @ts, dots_te)
      end

      if followed_by_nl && !nl_emitted
        # return "\n" to process it on the next scan
        p = p - 1;
      end

       @cs = 345; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

     end
end
	when 188 then
# line 1586 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin  p = @ts - 1
         	begin
 @cs = 516
_trigger_goto = true
_goto_level = _again
break
	end
end
end
	when 189 then
# line 831 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin 
  emit(:tIDENTIFIER)

  if !@static_env.nil? && @static_env.declared?(tok)
     @cs = 247; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

  elsif @version >= 33 && tok =~ /\A_[1-9]\z/
     @cs = 247; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

  else
     @cs = (arg_or_cmdarg(cmd_state)); 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

  end
 end
end
	when 190 then
# line 1613 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1;		end
	when 191 then
# line 1616 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin 
      p = @ts - 1
      @cs_before_block_comment = @cs
      	begin
 @cs = 710
_trigger_goto = true
_goto_level = _again
break
	end

     end
end
	when 192 then
# line 1632 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin  p = @ts - 1; 	begin
 @cs = 516
_trigger_goto = true
_goto_level = _again
break
	end
end
end
	when 193 then
# line 1287 "lib/parser/lexer.rl"
begin
 begin p = (( @te))-1; end
 begin 
      diagnostic :fatal, :string_eof, nil, range(@ts, @ts + 1)
     end
end
	when 194 then
# line 1348 "lib/parser/lexer.rl"
begin
 begin p = (( @te))-1; end
 begin 
      diagnostic :error, :unterminated_heredoc_id, nil, range(@ts, @ts + 1)
     end
end
	when 195 then
# line 831 "lib/parser/lexer.rl"
begin
 begin p = (( @te))-1; end
 begin 
  emit(:tIDENTIFIER)

  if !@static_env.nil? && @static_env.declared?(tok)
     @cs = 247; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

  elsif @version >= 33 && tok =~ /\A_[1-9]\z/
     @cs = 247; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

  else
     @cs = (arg_or_cmdarg(cmd_state)); 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

  end
 end
end
	when 196 then
# line 1613 "lib/parser/lexer.rl"
begin
 begin p = (( @te))-1; end
end
	when 197 then
# line 1632 "lib/parser/lexer.rl"
begin
 begin p = (( @te))-1; end
 begin  p = @ts - 1; 	begin
 @cs = 516
_trigger_goto = true
_goto_level = _again
break
	end
end
end
	when 198 then
# line 1 "NONE"
begin
	case  @act
	when 60 then
	begin begin p = (( @te))-1; end

      emit(:tUNARY_NUM, tok(@ts, @ts + 1), @ts, @ts + 1)
      p = p - 1;  @cs = 516; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

    end
	when 67 then
	begin begin p = (( @te))-1; end

      diagnostic :error, :unterminated_heredoc_id, nil, range(@ts, @ts + 1)
    end
	when 76 then
	begin begin p = (( @te))-1; end

      if @version >= 27
        emit(:tPIPE, tok(@ts, @ts + 1), @ts, @ts + 1)
        p = p - 1;
         @cs = 345; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

      else
        p -= 2
        	begin
 @cs = 516
_trigger_goto = true
_goto_level = _again
break
	end

      end
    end
	when 80 then
	begin begin p = (( @te))-1; end
 emit_table(PUNCTUATION_BEGIN)
         	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end
 end
	when 81 then
	begin begin p = (( @te))-1; end
 emit(:kRESCUE, 'rescue'.freeze, @ts, tm)
         p = tm - 1
          @cs = 321; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end
 end
	when 82 then
	begin begin p = (( @te))-1; end
 emit_table(KEYWORDS_BEGIN)
         @command_start = true
          @cs = 508; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end
 end
	when 86 then
	begin begin p = (( @te))-1; end
 p = @ts - 1
         	begin
 @cs = 516
_trigger_goto = true
_goto_level = _again
break
	end
 end
	when 87 then
	begin begin p = (( @te))-1; end

  emit(:tIDENTIFIER)

  if !@static_env.nil? && @static_env.declared?(tok)
     @cs = 247; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

  elsif @version >= 33 && tok =~ /\A_[1-9]\z/
     @cs = 247; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

  else
     @cs = (arg_or_cmdarg(cmd_state)); 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

  end
end
	when 91 then
	begin begin p = (( @te))-1; end
 p = @ts - 1; 	begin
 @cs = 516
_trigger_goto = true
_goto_level = _again
break
	end
 end
end 
	end
	when 199 then
# line 1652 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin  p = p - 1; 	begin
 @cs = 345
_trigger_goto = true
_goto_level = _again
break
	end
end
end
	when 200 then
# line 566 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin 
  # Sit at EOF indefinitely. #advance would return $eof each time.
  # This allows to feed the lexer more data if needed; this is only used
  # in tests.
  #
  # Note that this action is not embedded into e_eof like e_nl and e_bs
  # below. This is due to the fact that scanner state at EOF is observed
  # by tests, and encapsulating it in a rule would break the introspection.
  p = p - 1; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

 end
end
	when 201 then
# line 1640 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1;		end
	when 202 then
# line 1643 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin 
    if @context.in_kwarg
      p = p - 1; 	begin
 @cs = 516
_trigger_goto = true
_goto_level = _again
break
	end

    else
      	begin
 @cs = 710
_trigger_goto = true
_goto_level = _again
break
	end

    end
   end
end
	when 203 then
# line 1652 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin  p = p - 1; 	begin
 @cs = 345
_trigger_goto = true
_goto_level = _again
break
	end
end
end
	when 204 then
# line 1662 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin  p = @ts - 1
         	begin
 @cs = 516
_trigger_goto = true
_goto_level = _again
break
	end
end
end
	when 205 then
# line 1667 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin 
      @strings.push_literal(tok, tok, @ts)
      	begin
 @cs = 128
_trigger_goto = true
_goto_level = _again
break
	end

     end
end
	when 206 then
# line 1678 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin  p = p - 1; 	begin
 @cs = 345
_trigger_goto = true
_goto_level = _again
break
	end
end
end
	when 207 then
# line 566 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin 
  # Sit at EOF indefinitely. #advance would return $eof each time.
  # This allows to feed the lexer more data if needed; this is only used
  # in tests.
  #
  # Note that this action is not embedded into e_eof like e_nl and e_bs
  # below. This is due to the fact that scanner state at EOF is observed
  # by tests, and encapsulating it in a rule would break the introspection.
  p = p - 1; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

 end
end
	when 208 then
# line 1672 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1;		end
	when 209 then
# line 1675 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin  	begin
 @cs = 710
_trigger_goto = true
_goto_level = _again
break
	end
end
end
	when 210 then
# line 1678 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin  p = p - 1; 	begin
 @cs = 345
_trigger_goto = true
_goto_level = _again
break
	end
end
end
	when 211 then
# line 1678 "lib/parser/lexer.rl"
begin
 begin p = (( @te))-1; end
 begin  p = p - 1; 	begin
 @cs = 345
_trigger_goto = true
_goto_level = _again
break
	end
end
end
	when 212 then
# line 1697 "lib/parser/lexer.rl"
begin
 @act = 104;		end
	when 213 then
# line 1726 "lib/parser/lexer.rl"
begin
 @act = 105;		end
	when 214 then
# line 1730 "lib/parser/lexer.rl"
begin
 @act = 106;		end
	when 215 then
# line 1735 "lib/parser/lexer.rl"
begin
 @act = 107;		end
	when 216 then
# line 1740 "lib/parser/lexer.rl"
begin
 @act = 108;		end
	when 217 then
# line 1745 "lib/parser/lexer.rl"
begin
 @act = 109;		end
	when 218 then
# line 1749 "lib/parser/lexer.rl"
begin
 @act = 110;		end
	when 219 then
# line 1760 "lib/parser/lexer.rl"
begin
 @act = 111;		end
	when 220 then
# line 1774 "lib/parser/lexer.rl"
begin
 @act = 112;		end
	when 221 then
# line 1788 "lib/parser/lexer.rl"
begin
 @act = 113;		end
	when 222 then
# line 1806 "lib/parser/lexer.rl"
begin
 @act = 115;		end
	when 223 then
# line 1818 "lib/parser/lexer.rl"
begin
 @act = 116;		end
	when 224 then
# line 1833 "lib/parser/lexer.rl"
begin
 @act = 117;		end
	when 225 then
# line 1862 "lib/parser/lexer.rl"
begin
 @act = 119;		end
	when 226 then
# line 831 "lib/parser/lexer.rl"
begin
 @act = 123;		end
	when 227 then
# line 1884 "lib/parser/lexer.rl"
begin
 @act = 124;		end
	when 228 then
# line 1910 "lib/parser/lexer.rl"
begin
 @act = 126;		end
	when 229 then
# line 1916 "lib/parser/lexer.rl"
begin
 @act = 127;		end
	when 230 then
# line 1689 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin 
      emit(:tLAMBDA, '->'.freeze, @ts, @ts + 2)

      @lambda_stack.push @paren_nest
       @cs = 247; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

     end
end
	when 231 then
# line 1730 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin  emit_singleton_class
          @cs = 508; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end
end
end
	when 232 then
# line 1851 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin 
      type, delimiter = tok, tok[-1].chr
      @strings.push_literal(type, delimiter, @ts, nil, false, false, true);
      	begin
 @cs = 128
_trigger_goto = true
_goto_level = _again
break
	end

     end
end
	when 233 then
# line 1870 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin  p = @ts - 1; 	begin
 @stack[ @top] =  @cs
 @top+= 1
 @cs = 129
_trigger_goto = true
_goto_level = _again
break
	end
end
end
	when 234 then
# line 1877 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin  emit_table(PUNCTUATION)
          @cs = 255; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end
end
end
	when 235 then
# line 1901 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin 
      emit_table(PUNCTUATION)
       @cs = 508; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

     end
end
	when 236 then
# line 1910 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin 
      emit_table(PUNCTUATION);
       @cs = 508; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

     end
end
	when 237 then
# line 1937 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin  emit(:tOP_ASGN, tok(@ts, @te - 1))
          @cs = 345; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end
end
end
	when 238 then
# line 1941 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin  emit(:tEH, '?'.freeze)
          @cs = 508; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end
end
end
	when 239 then
# line 1949 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin 
      if @paren_nest == 0
        diagnostic :warning, :triple_dot_at_eol, nil, range(@ts, @te - 1)
      end

      emit(:tDOT3, '...'.freeze, @ts, @te - 1)
      p = p - 1;
       @cs = 345; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

     end
end
	when 240 then
# line 1960 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin  emit_table(PUNCTUATION)
          @cs = 345; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end
end
end
	when 241 then
# line 1973 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin  emit(:tSEMI, ';'.freeze)
         @command_start = true
          @cs = 508; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end
end
end
	when 242 then
# line 1977 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin 
      diagnostic :error, :bare_backslash, nil, range(@ts, @ts + 1)
      p = p - 1;
     end
end
	when 243 then
# line 1983 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin 
      diagnostic :fatal, :unexpected, { :character => tok.inspect[1..-2] }
     end
end
	when 244 then
# line 566 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin 
  # Sit at EOF indefinitely. #advance would return $eof each time.
  # This allows to feed the lexer more data if needed; this is only used
  # in tests.
  #
  # Note that this action is not embedded into e_eof like e_nl and e_bs
  # below. This is due to the fact that scanner state at EOF is observed
  # by tests, and encapsulating it in a rule would break the introspection.
  p = p - 1; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

 end
end
	when 245 then
# line 1697 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin 
      if @lambda_stack.last == @paren_nest
        @lambda_stack.pop

        if tok == '{'.freeze
          emit(:tLAMBEG, '{'.freeze)
        else # 'do'
          emit(:kDO_LAMBDA, 'do'.freeze)
        end
      else
        if tok == '{'.freeze
          emit(:tLCURLY, '{'.freeze)
        else # 'do'
          emit_do
        end
      end
      if tok == '{'.freeze
        @paren_nest += 1
      end
      @command_start = true

       @cs = 508; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

     end
end
	when 246 then
# line 1726 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin  emit_table(KEYWORDS)
          @cs = 134; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end
end
end
	when 247 then
# line 1730 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin  emit_singleton_class
          @cs = 508; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end
end
end
	when 248 then
# line 1740 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin  emit_table(KEYWORDS)
         @command_start = true
          @cs = 508; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end
end
end
	when 249 then
# line 1788 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin 
      digits = numeric_literal_int

      if version?(18, 19, 20)
        emit(:tINTEGER, digits.to_i(@num_base), @ts, @num_suffix_s)
        p = @num_suffix_s - 1
      else
        p = @num_xfrm.call(digits.to_i(@num_base), p)
      end
      	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

     end
end
	when 250 then
# line 1801 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin 
      diagnostic :error, :no_dot_digit_literal
     end
end
	when 251 then
# line 1833 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin 
      digits = tok(@ts, @num_suffix_s)

      if version?(18, 19, 20)
        emit(:tFLOAT, Float(digits), @ts, @num_suffix_s)
        p = @num_suffix_s - 1
      else
        p = @num_xfrm.call(digits, p)
      end
      	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

     end
end
	when 252 then
# line 1862 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin  emit(:tCONSTANT)
          @cs = (arg_or_cmdarg(cmd_state)); 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end
end
end
	when 253 then
# line 1866 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin  emit(:tCONSTANT, tok(@ts, tm), @ts, tm)
         p = tm - 1; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end
end
end
	when 254 then
# line 1870 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin  p = @ts - 1; 	begin
 @stack[ @top] =  @cs
 @top+= 1
 @cs = 129
_trigger_goto = true
_goto_level = _again
break
	end
end
end
	when 255 then
# line 1877 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin  emit_table(PUNCTUATION)
          @cs = 255; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end
end
end
	when 256 then
# line 831 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin 
  emit(:tIDENTIFIER)

  if !@static_env.nil? && @static_env.declared?(tok)
     @cs = 247; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

  elsif @version >= 33 && tok =~ /\A_[1-9]\z/
     @cs = 247; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

  else
     @cs = (arg_or_cmdarg(cmd_state)); 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

  end
 end
end
	when 257 then
# line 1884 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin 
      if tm == @te
        # Suffix was consumed, e.g. foo!
        emit(:tFID)
      else
        # Suffix was not consumed, e.g. foo!=
        emit(:tIDENTIFIER, tok(@ts, tm), @ts, tm)
        p = tm - 1
      end
       @cs = 276; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

     end
end
	when 258 then
# line 1901 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin 
      emit_table(PUNCTUATION)
       @cs = 508; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

     end
end
	when 259 then
# line 1910 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin 
      emit_table(PUNCTUATION);
       @cs = 508; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

     end
end
	when 260 then
# line 1916 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin  emit_table(PUNCTUATION)
          @cs = 345; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end
end
end
	when 261 then
# line 1920 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin 
      emit_rbrace_rparen_rbrack

      if tok == '}'.freeze || tok == ']'.freeze
        if @version >= 25
           @cs = 516;
        else
           @cs = 313;
        end
      else # )
        # fnext expr_endfn; ?
      end

      	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

     end
end
	when 262 then
# line 1945 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin  emit(:tLBRACK2, '['.freeze)
          @cs = 345; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end
end
end
	when 263 then
# line 1960 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin  emit_table(PUNCTUATION)
          @cs = 345; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end
end
end
	when 264 then
# line 1967 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1;		end
	when 265 then
# line 1970 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin  	begin
 @cs = 696
_trigger_goto = true
_goto_level = _again
break
	end
end
end
	when 266 then
# line 1983 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin 
      diagnostic :fatal, :unexpected, { :character => tok.inspect[1..-2] }
     end
end
	when 267 then
# line 1788 "lib/parser/lexer.rl"
begin
 begin p = (( @te))-1; end
 begin 
      digits = numeric_literal_int

      if version?(18, 19, 20)
        emit(:tINTEGER, digits.to_i(@num_base), @ts, @num_suffix_s)
        p = @num_suffix_s - 1
      else
        p = @num_xfrm.call(digits.to_i(@num_base), p)
      end
      	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

     end
end
	when 268 then
# line 1801 "lib/parser/lexer.rl"
begin
 begin p = (( @te))-1; end
 begin 
      diagnostic :error, :no_dot_digit_literal
     end
end
	when 269 then
# line 1833 "lib/parser/lexer.rl"
begin
 begin p = (( @te))-1; end
 begin 
      digits = tok(@ts, @num_suffix_s)

      if version?(18, 19, 20)
        emit(:tFLOAT, Float(digits), @ts, @num_suffix_s)
        p = @num_suffix_s - 1
      else
        p = @num_xfrm.call(digits, p)
      end
      	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

     end
end
	when 270 then
# line 1983 "lib/parser/lexer.rl"
begin
 begin p = (( @te))-1; end
 begin 
      diagnostic :fatal, :unexpected, { :character => tok.inspect[1..-2] }
     end
end
	when 271 then
# line 1 "NONE"
begin
	case  @act
	when 104 then
	begin begin p = (( @te))-1; end

      if @lambda_stack.last == @paren_nest
        @lambda_stack.pop

        if tok == '{'.freeze
          emit(:tLAMBEG, '{'.freeze)
        else # 'do'
          emit(:kDO_LAMBDA, 'do'.freeze)
        end
      else
        if tok == '{'.freeze
          emit(:tLCURLY, '{'.freeze)
        else # 'do'
          emit_do
        end
      end
      if tok == '{'.freeze
        @paren_nest += 1
      end
      @command_start = true

       @cs = 508; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

    end
	when 105 then
	begin begin p = (( @te))-1; end
 emit_table(KEYWORDS)
          @cs = 134; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end
 end
	when 106 then
	begin begin p = (( @te))-1; end
 emit_singleton_class
          @cs = 508; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end
 end
	when 107 then
	begin begin p = (( @te))-1; end
 emit_table(KEYWORDS)
          @cs = 345; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end
 end
	when 108 then
	begin begin p = (( @te))-1; end
 emit_table(KEYWORDS)
         @command_start = true
          @cs = 508; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end
 end
	when 109 then
	begin begin p = (( @te))-1; end
 emit_table(KEYWORDS)
          @cs = 321; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end
 end
	when 110 then
	begin begin p = (( @te))-1; end

      emit_table(KEYWORDS)

      if version?(18) && tok == 'not'.freeze
         @cs = 345; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

      else
         @cs = 276; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

      end
    end
	when 111 then
	begin begin p = (( @te))-1; end

      if version?(18)
        emit(:tIDENTIFIER)

        unless !@static_env.nil? && @static_env.declared?(tok)
           @cs = (arg_or_cmdarg(cmd_state));
        end
      else
        emit(:k__ENCODING__, '__ENCODING__'.freeze)
      end
      	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

    end
	when 112 then
	begin begin p = (( @te))-1; end
 emit_table(KEYWORDS)
         	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end
 end
	when 113 then
	begin begin p = (( @te))-1; end

      digits = numeric_literal_int

      if version?(18, 19, 20)
        emit(:tINTEGER, digits.to_i(@num_base), @ts, @num_suffix_s)
        p = @num_suffix_s - 1
      else
        p = @num_xfrm.call(digits.to_i(@num_base), p)
      end
      	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

    end
	when 115 then
	begin begin p = (( @te))-1; end

      if version?(18, 19, 20)
        diagnostic :error,
                   :trailing_in_number, { :character => tok(@te - 1, @te) },
                   range(@te - 1, @te)
      else
        emit(:tINTEGER, tok(@ts, @te - 1).to_i, @ts, @te - 1)
        p = p - 1; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

      end
    end
	when 116 then
	begin begin p = (( @te))-1; end

      if version?(18, 19, 20)
        diagnostic :error,
                   :trailing_in_number, { :character => tok(@te - 1, @te) },
                   range(@te - 1, @te)
      else
        emit(:tFLOAT, tok(@ts, @te - 1).to_f, @ts, @te - 1)
        p = p - 1; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

      end
    end
	when 117 then
	begin begin p = (( @te))-1; end

      digits = tok(@ts, @num_suffix_s)

      if version?(18, 19, 20)
        emit(:tFLOAT, Float(digits), @ts, @num_suffix_s)
        p = @num_suffix_s - 1
      else
        p = @num_xfrm.call(digits, p)
      end
      	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

    end
	when 119 then
	begin begin p = (( @te))-1; end
 emit(:tCONSTANT)
          @cs = (arg_or_cmdarg(cmd_state)); 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end
 end
	when 123 then
	begin begin p = (( @te))-1; end

  emit(:tIDENTIFIER)

  if !@static_env.nil? && @static_env.declared?(tok)
     @cs = 247; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

  elsif @version >= 33 && tok =~ /\A_[1-9]\z/
     @cs = 247; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

  else
     @cs = (arg_or_cmdarg(cmd_state)); 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

  end
end
	when 124 then
	begin begin p = (( @te))-1; end

      if tm == @te
        # Suffix was consumed, e.g. foo!
        emit(:tFID)
      else
        # Suffix was not consumed, e.g. foo!=
        emit(:tIDENTIFIER, tok(@ts, tm), @ts, tm)
        p = tm - 1
      end
       @cs = 276; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

    end
	when 126 then
	begin begin p = (( @te))-1; end

      emit_table(PUNCTUATION);
       @cs = 508; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

    end
	when 127 then
	begin begin p = (( @te))-1; end
 emit_table(PUNCTUATION)
          @cs = 345; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end
 end
end 
	end
	when 272 then
# line 1999 "lib/parser/lexer.rl"
begin
 @act = 140;		end
	when 273 then
# line 2038 "lib/parser/lexer.rl"
begin
 @act = 144;		end
	when 274 then
# line 2024 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin 
      emit(:tNL, nil, @newline_s, @newline_s + 1)
      if @version < 27
        p = p - 1;  @cs = 710; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

      else
        emit(:tBDOT3)
         @cs = 345; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

      end
     end
end
	when 275 then
# line 2035 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin  p = tm - 1; 	begin
 @cs = 516
_trigger_goto = true
_goto_level = _again
break
	end
end
end
	when 276 then
# line 2038 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin  emit(:tNL, nil, @newline_s, @newline_s + 1)
         p = p - 1;  @cs = 710; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end
end
end
	when 277 then
# line 1999 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin 
      if @version < 27
        # Ruby before 2.7 doesn't support comments before leading dot.
        # If a line after "a" starts with a comment then "a" is a self-contained statement.
        # So in that case we emit a special tNL token and start reading the
        # next line as a separate statement.
        #
        # Note: block comments before leading dot are not supported on any version of Ruby.
        emit(:tNL, nil, @newline_s, @newline_s + 1)
        p = p - 1;  @cs = 710; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

      end
     end
end
	when 278 then
# line 2013 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin 
      emit(:tNL, nil, @newline_s, @newline_s + 1)
      if @version < 27
        p = p - 1;  @cs = 710; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

      else
        emit(:tBDOT2)
         @cs = 345; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

      end
     end
end
	when 279 then
# line 2035 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin  p = tm - 1; 	begin
 @cs = 516
_trigger_goto = true
_goto_level = _again
break
	end
end
end
	when 280 then
# line 2038 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin  emit(:tNL, nil, @newline_s, @newline_s + 1)
         p = p - 1;  @cs = 710; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end
end
end
	when 281 then
# line 1999 "lib/parser/lexer.rl"
begin
 begin p = (( @te))-1; end
 begin 
      if @version < 27
        # Ruby before 2.7 doesn't support comments before leading dot.
        # If a line after "a" starts with a comment then "a" is a self-contained statement.
        # So in that case we emit a special tNL token and start reading the
        # next line as a separate statement.
        #
        # Note: block comments before leading dot are not supported on any version of Ruby.
        emit(:tNL, nil, @newline_s, @newline_s + 1)
        p = p - 1;  @cs = 710; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

      end
     end
end
	when 282 then
# line 2038 "lib/parser/lexer.rl"
begin
 begin p = (( @te))-1; end
 begin  emit(:tNL, nil, @newline_s, @newline_s + 1)
         p = p - 1;  @cs = 710; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end
end
end
	when 283 then
# line 1 "NONE"
begin
	case  @act
	when 140 then
	begin begin p = (( @te))-1; end

      if @version < 27
        # Ruby before 2.7 doesn't support comments before leading dot.
        # If a line after "a" starts with a comment then "a" is a self-contained statement.
        # So in that case we emit a special tNL token and start reading the
        # next line as a separate statement.
        #
        # Note: block comments before leading dot are not supported on any version of Ruby.
        emit(:tNL, nil, @newline_s, @newline_s + 1)
        p = p - 1;  @cs = 710; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

      end
    end
	when 144 then
	begin begin p = (( @te))-1; end
 emit(:tNL, nil, @newline_s, @newline_s + 1)
         p = p - 1;  @cs = 710; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end
 end
end 
	end
	when 284 then
# line 2048 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin 
      emit_comment(@eq_begin_s, @te)
      	begin
 @cs = (@cs_before_block_comment)
_trigger_goto = true
_goto_level = _again
break
	end

     end
end
	when 285 then
# line 2053 "lib/parser/lexer.rl"
begin
 @te = p+1
end
	when 286 then
# line 2048 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin 
      emit_comment(@eq_begin_s, @te)
      	begin
 @cs = (@cs_before_block_comment)
_trigger_goto = true
_goto_level = _again
break
	end

     end
end
	when 287 then
# line 2056 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin 
      diagnostic :fatal, :embedded_document, nil,
                 range(@eq_begin_s, @eq_begin_s + '=begin'.length)
     end
end
	when 288 then
# line 2066 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin  @eq_begin_s = @ts
         	begin
 @cs = 704
_trigger_goto = true
_goto_level = _again
break
	end
end
end
	when 289 then
# line 2070 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin  p = pe - 3  end
end
	when 290 then
# line 2073 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin  cmd_state = true; p = p - 1; 	begin
 @cs = 508
_trigger_goto = true
_goto_level = _again
break
	end
end
end
	when 291 then
# line 566 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin 
  # Sit at EOF indefinitely. #advance would return $eof each time.
  # This allows to feed the lexer more data if needed; this is only used
  # in tests.
  #
  # Note that this action is not embedded into e_eof like e_nl and e_bs
  # below. This is due to the fact that scanner state at EOF is observed
  # by tests, and encapsulating it in a rule would break the introspection.
  p = p - 1; 	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

 end
end
	when 292 then
# line 2063 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1;		end
	when 293 then
# line 2066 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin  @eq_begin_s = @ts
         	begin
 @cs = 704
_trigger_goto = true
_goto_level = _again
break
	end
end
end
	when 294 then
# line 2073 "lib/parser/lexer.rl"
begin
 @te = p
p = p - 1; begin  cmd_state = true; p = p - 1; 	begin
 @cs = 508
_trigger_goto = true
_goto_level = _again
break
	end
end
end
	when 295 then
# line 2073 "lib/parser/lexer.rl"
begin
 begin p = (( @te))-1; end
 begin  cmd_state = true; p = p - 1; 	begin
 @cs = 508
_trigger_goto = true
_goto_level = _again
break
	end
end
end
	when 296 then
# line 2080 "lib/parser/lexer.rl"
begin
 @te = p+1
 begin 
      p, next_state = @strings.advance(p)

      p = p - 1; # Ragel will do `p += 1` to consume input, prevent it
       @cs = (next_state);
      	begin
p += 1
_trigger_goto = true
_goto_level = _out
break
	end

     end
end
# line 12621 "lib/parser/lexer-F0.rb"
	end # action switch
end
	end
	if _trigger_goto
next
	end
	end
	if _goto_level <= _again
	_acts = _lex_to_state_actions[ @cs]
	_nacts = _lex_actions[_acts]
	_acts += 1
	while _nacts > 0
_nacts -= 1
_acts += 1
case _lex_actions[_acts - 1]
	when 51 then
# line 1 "NONE"
begin
 @ts = nil;		end
# line 12641 "lib/parser/lexer-F0.rb"
end # to state action switch
	end
	if _trigger_goto
next
	end
	if  @cs == 0
_goto_level = _out
next
	end
	p += 1
	if p != pe
_goto_level = _resume
next
	end
	end
	if _goto_level <= _test_eof
	if p == eof
	if _lex_eof_trans[ @cs] > 0
_trans = _lex_eof_trans[ @cs] - 1;
_goto_level = _eof_trans
next;
	end
	end
	end
	if _goto_level <= _out
break
	end
	end
	end

# line 281 "lib/parser/lexer.rl"
  # %

  # Ragel creates a local variable called `testEof` but it doesn't use
  # it in any assignment. This dead code is here to swallow the warning.
  # It has no runtime cost because Ruby doesn't produce any instructions from it.
  if false
    testEof
  end

  @p = p

  if @token_queue.any?
    @token_queue.shift
  elsif @cs == klass.lex_error
    [ false, [ '$error'.freeze, range(p - 1, p) ] ]
  else
    eof = @source_pts.size
    [ false, [ '$eof'.freeze,   range(eof, eof) ] ]
  end
end

#dedent_levelObject



8538
8539
8540
# File 'lib/parser/lexer-F0.rb', line 8538

def dedent_level
  @strings.dedent_level
end

#encodingObject



8491
8492
8493
# File 'lib/parser/lexer-F0.rb', line 8491

def encoding
  @source_buffer.source.encoding
end

#pop_cmdargObject



8525
8526
8527
# File 'lib/parser/lexer-F0.rb', line 8525

def pop_cmdarg
  @cmdarg = @cmdarg_stack.pop
end

#pop_condObject



8534
8535
8536
# File 'lib/parser/lexer-F0.rb', line 8534

def pop_cond
  @cond = @cond_stack.pop
end

#push_cmdargObject



8520
8521
8522
8523
# File 'lib/parser/lexer-F0.rb', line 8520

def push_cmdarg
  @cmdarg_stack.push(@cmdarg)
  @cmdarg = StackState.new("cmdarg.#{@cmdarg_stack.count}")
end

#push_condObject



8529
8530
8531
8532
# File 'lib/parser/lexer-F0.rb', line 8529

def push_cond
  @cond_stack.push(@cond)
  @cond = StackState.new("cond.#{@cond_stack.count}")
end

#reset(reset_state = true) ⇒ Object



8414
8415
8416
8417
8418
8419
8420
8421
8422
8423
8424
8425
8426
8427
8428
8429
8430
8431
8432
8433
8434
8435
8436
8437
8438
8439
8440
8441
8442
8443
8444
8445
8446
8447
8448
8449
8450
8451
8452
8453
8454
8455
8456
8457
8458
8459
8460
8461
8462
8463
8464
8465
# File 'lib/parser/lexer-F0.rb', line 8414

def reset(reset_state=true)
  # Ragel state:
  if reset_state
    # Unit tests set state prior to resetting lexer.
    @cs     = self.class.lex_en_line_begin

    @cond   = StackState.new('cond')
    @cmdarg = StackState.new('cmdarg')
    @cond_stack   = []
    @cmdarg_stack = []
  end

  @force_utf32   = false # Set to true by some tests

  @source_pts    = nil # @source as a codepoint array

  @p             = 0   # stream position (saved manually in #advance)
  @ts            = nil # token start
  @te            = nil # token end
  @act           = 0   # next action

  @stack         = []  # state stack
  @top           = 0   # state stack top pointer

  # Lexer state:
  @token_queue   = []

  @eq_begin_s    = nil # location of last encountered =begin
  @sharp_s       = nil # location of last encountered #

  @newline_s     = nil # location of last encountered newline

  @num_base      = nil # last numeric base
  @num_digits_s  = nil # starting position of numeric digits
  @num_suffix_s  = nil # starting position of numeric suffix
  @num_xfrm      = nil # numeric suffix-induced transformation

  # Ruby 1.9 ->() lambdas emit a distinct token if do/{ is
  # encountered after a matching closing parenthesis.
  @paren_nest    = 0
  @lambda_stack  = []

  # If the lexer is in `command state' (aka expr_value)
  # at the entry to #advance, it will transition to expr_cmdarg
  # instead of expr_arg at certain points.
  @command_start = true

  # State before =begin / =end block comment
  @cs_before_block_comment = self.class.lex_en_line_begin

  @strings = Parser::LexerStrings.new(self, @version)
end

#stateObject



8512
8513
8514
# File 'lib/parser/lexer-F0.rb', line 8512

def state
  LEX_STATES.invert.fetch(@cs, @cs)
end

#state=(state) ⇒ Object



8516
8517
8518
# File 'lib/parser/lexer-F0.rb', line 8516

def state=(state)
  @cs = LEX_STATES.fetch(state)
end