[フレーム]

Class: Racc::Parser

Inherits:
Object show all
Defined in:
opal/stdlib/racc/parser.rb

Constant Summary

Racc_Runtime_Version = 
'1.4.6'
Racc_Runtime_Revision = 
%w$originalRevision:1.8$[1]
Racc_Runtime_Core_Version_R = 
'1.4.6'
Racc_Runtime_Core_Revision_R = 
%w$originalRevision:1.8$[1]
Racc_Main_Parsing_Routine =

DISABLED: opal has no racc/cparse begin require 'racc/cparse'

Racc_Runtime_Core_Version_C = (defined in extension)

Racc_Runtime_Core_Revision_C = Racc_Runtime_Core_Id_C.split[2] unless new.respond_to?(:_racc_do_parse_c, true) raise LoadError, 'old cparse.so' end if Racc_No_Extensions raise LoadError, 'selecting ruby version of racc runtime core' end

Racc_Main_Parsing_Routine = :_racc_do_parse_c # :nodoc: Racc_YY_Parse_Method = :_racc_yyparse_c # :nodoc: Racc_Runtime_Core_Version = Racc_Runtime_Core_Version_C # :nodoc: Racc_Runtime_Core_Revision = Racc_Runtime_Core_Revision_C # :nodoc: Racc_Runtime_Type = 'c' # :nodoc: rescue LoadError

:_racc_do_parse_rb
Racc_YY_Parse_Method = 
:_racc_yyparse_rb
Racc_Runtime_Core_Version = 
Racc_Runtime_Core_Version_R
Racc_Runtime_Core_Revision = 
Racc_Runtime_Core_Revision_R
Racc_Runtime_Type = 
'ruby'

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.racc_runtime_type ⇒ Object

end

218
219
220
# File 'opal/stdlib/racc/parser.rb', line 218
def Parser .racc_runtime_type # :nodoc:
 Racc_Runtime_Type 
end

Instance Method Details

#_racc_do_parse_rb(arg, in_debug) ⇒ Object 

279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
# File 'opal/stdlib/racc/parser.rb', line 279
def _racc_do_parse_rb(arg, in_debug)
 action_table, action_check, action_default, action_pointer,
 _, _, _, _,
 _, _, token_table, _,
 _, _, * = arg
 _racc_init_sysvars
 tok = act = i = nil
 catch(:racc_end_parse) {
 while true
 if i = action_pointer[@racc_state[-1]]
 if @racc_read_next
 if @racc_t != 0 # not EOF
 tok, @racc_val = next_token()
 unless tok # EOF
 @racc_t = 0
 else
 @racc_t = (token_table[tok] or 1) # error token
 end
 racc_read_token(@racc_t, tok, @racc_val) if @yydebug
 @racc_read_next = false
 end
 end
 i += @racc_t
 unless i >= 0 and
 act = action_table[i] and
 action_check[i] == @racc_state[-1]
 act = action_default[@racc_state[-1]]
 end
 else
 act = action_default[@racc_state[-1]]
 end
 while act = _racc_evalact(act, arg)
 ;
 end
 end
 }
end

#_racc_do_reduce(arg, act) ⇒ Object 

477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
# File 'opal/stdlib/racc/parser.rb', line 477
def _racc_do_reduce(arg, act)
 _, _, _, _,
 goto_table, goto_check, goto_default, goto_pointer,
 nt_base, reduce_table, _, _,
 _, use_result, * = arg
 state = @racc_state
 vstack = @racc_vstack
 tstack = @racc_tstack
 i = act * -3
 len = reduce_table[i]
 reduce_to = reduce_table[i+1]
 method_id = reduce_table[i+2]
 void_array = []
 tmp_t = tstack[-len, len] if @yydebug
 tmp_v = vstack[-len, len]
 tstack[-len, len] = void_array if @yydebug
 vstack[-len, len] = void_array
 state[-len, len] = void_array
 # tstack must be updated AFTER method call
 if use_result
 vstack.push __send__(method_id, tmp_v, vstack, tmp_v[0])
 else
 vstack.push __send__(method_id, tmp_v, vstack)
 end
 tstack.push reduce_to
 racc_reduce(tmp_t, reduce_to, tstack, vstack) if @yydebug
 k1 = reduce_to - nt_base
 if i = goto_pointer[k1]
 i += state[-1]
 if i >= 0 and (curstate = goto_table[i]) and goto_check[i] == k1
 return curstate
 end
 end
 goto_default[k1]
end

#_racc_evalact(act, arg) ⇒ Object

common

384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
# File 'opal/stdlib/racc/parser.rb', line 384
def _racc_evalact(act, arg)
 action_table, action_check, _, action_pointer,
 _, _, _, _,
 _, _, _, shift_n, reduce_n,
 _, _, * = arg
 if act > 0 and act < shift_n
 #
 # shift
 #
 if @racc_error_status > 0
 @racc_error_status -= 1 unless @racc_t == 1 # error token
 end
 @racc_vstack.push @racc_val
 @racc_state.push act
 @racc_read_next = true
 if @yydebug
 @racc_tstack.push @racc_t
 racc_shift @racc_t, @racc_tstack, @racc_vstack
 end
 elsif act < 0 and act > -reduce_n
 #
 # reduce
 #
 code = catch(:racc_jump) {
 @racc_state.push _racc_do_reduce(arg, act)
 false
 }
 if code
 case code
 when 1 # yyerror
 @racc_user_yyerror = true # user_yyerror
 return -reduce_n
 when 2 # yyaccept
 return shift_n
 else
 raise '[Racc Bug] unknown jump code'
 end
 end
 elsif act == shift_n
 #
 # accept
 #
 racc_accept if @yydebug
 throw :racc_end_parse, @racc_vstack[0]
 elsif act == -reduce_n
 #
 # error
 #
 case @racc_error_status
 when 0
 unless arg[21] # user_yyerror
 on_error @racc_t, @racc_val, @racc_vstack
 end
 when 3
 if @racc_t == 0 # is $
 throw :racc_end_parse, nil
 end
 @racc_read_next = true
 end
 @racc_user_yyerror = false
 @racc_error_status = 3
 while true
 if i = action_pointer[@racc_state[-1]]
 i += 1 # error token
 if i >= 0 and
 (act = action_table[i]) and
 action_check[i] == @racc_state[-1]
 break
 end
 end
 throw :racc_end_parse, nil if @racc_state.size <= 1
 @racc_state.pop
 @racc_vstack.pop
 if @yydebug
 @racc_tstack.pop
 racc_e_pop @racc_state, @racc_tstack, @racc_vstack
 end
 end
 return act
 else
 raise "[Racc Bug] unknown action #{act.inspect}"
 end
 racc_next_state(@racc_state[-1], @racc_state) if @yydebug
 nil
end

#_racc_init_sysvars ⇒ Object 

234
235
236
237
238
239
240
241
242
243
244
245
246
# File 'opal/stdlib/racc/parser.rb', line 234
def _racc_init_sysvars
 @racc_state = [0]
 @racc_tstack = []
 @racc_vstack = []
 @racc_t = nil
 @racc_val = nil
 @racc_read_next = true
 @racc_user_yyerror = false
 @racc_error_status = 0
end

#_racc_setup ⇒ Object 

222
223
224
225
226
227
228
229
230
231
232
# File 'opal/stdlib/racc/parser.rb', line 222
def _racc_setup
 @yydebug = false unless self.class::Racc_debug_parser
 @yydebug = false unless defined?(@yydebug)
 if @yydebug
 @racc_debug_out = $stderr unless defined?(@racc_debug_out)
 @racc_debug_out ||= $stderr
 end
 arg = self.class::Racc_arg
 arg[13] = true if arg.size < 14
 arg
end

#_racc_yyparse_rb(recv, mid, arg, c_debug) ⇒ Object 

328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
# File 'opal/stdlib/racc/parser.rb', line 328
def _racc_yyparse_rb(recv, mid, arg, c_debug)
 action_table, action_check, action_default, action_pointer,
 _, _, _, _,
 _, _, token_table, _,
 _, _, * = arg
 _racc_init_sysvars
 act = nil
 i = nil
 catch(:racc_end_parse) {
 until i = action_pointer[@racc_state[-1]]
 while act = _racc_evalact(action_default[@racc_state[-1]], arg)
 ;
 end
 end
 recv.__send__(mid) do |tok, val|
 unless tok
 @racc_t = 0
 else
 @racc_t = (token_table[tok] or 1) # error token
 end
 @racc_val = val
 @racc_read_next = false
 i += @racc_t
 unless i >= 0 and
 act = action_table[i] and
 action_check[i] == @racc_state[-1]
 act = action_default[@racc_state[-1]]
 end
 while act = _racc_evalact(act, arg)
 ;
 end
 while not(i = action_pointer[@racc_state[-1]]) or
 not @racc_read_next or
 @racc_t == 0 # $
 unless i and i += @racc_t and
 i >= 0 and
 act = action_table[i] and
 action_check[i] == @racc_state[-1]
 act = action_default[@racc_state[-1]]
 end
 while act = _racc_evalact(act, arg)
 ;
 end
 end
 end
 }
end

#do_parse ⇒ Object

The entry point of the parser. This method is used with #next_token. If Racc wants to get token (and its value), calls next_token.

Example: def parse @q = [[1,1], [2,2], [3,3], [false, '$']] do_parse end

def next_token
 @q.shift
end

263
264
265
# File 'opal/stdlib/racc/parser.rb', line 263
def do_parse
 __send__(Racc_Main_Parsing_Routine , _racc_setup(), false)
end

#next_token ⇒ Object

The method to fetch next token. If you use #do_parse method, you must implement #next_token.

The format of return value is [TOKEN_SYMBOL, VALUE]. +token-symbol+ is represented by Ruby's symbol by default, e.g. :IDENT for 'IDENT'. ";" (String) for ';'.

The final symbol (End of file) must be false.

Raises:

  • (NotImplementedError) 
275
276
277
# File 'opal/stdlib/racc/parser.rb', line 275
def next_token
 raise NotImplementedError, "#{self.class}\#next_token is not defined"
end

#on_error(t, val, vstack) ⇒ Object

This method is called when a parse error is found.

ERROR_TOKEN_ID is an internal ID of token which caused error. You can get string representation of this ID by calling

token_to_str.

ERROR_VALUE is a value of error token.

value_stack is a stack of symbol values. DO NOT MODIFY this object.

This method raises ParseError by default.

If this method returns, parsers enter "error recovering mode".

Raises:

532
533
534
535
# File 'opal/stdlib/racc/parser.rb', line 532
def on_error(t, val, vstack)
 raise ParseError , sprintf("\nparse error on value %s (%s)",
 val.inspect, token_to_str(t) || '?')
end

#racc_accept ⇒ Object 

582
583
584
585
# File 'opal/stdlib/racc/parser.rb', line 582
def racc_accept
 @racc_debug_out.puts 'accept'
 @racc_debug_out.puts
end

#racc_e_pop(state, tstack, vstack) ⇒ Object 

587
588
589
590
591
592
# File 'opal/stdlib/racc/parser.rb', line 587
def racc_e_pop(state, tstack, vstack)
 @racc_debug_out.puts 'error recovering mode: pop token'
 racc_print_states state
 racc_print_stacks tstack, vstack
 @racc_debug_out.puts
end

#racc_next_state(curstate, state) ⇒ Object 

594
595
596
597
598
# File 'opal/stdlib/racc/parser.rb', line 594
def racc_next_state(curstate, state)
 @racc_debug_out.puts "goto #{curstate}"
 racc_print_states state
 @racc_debug_out.puts
end

#racc_print_stacks(t, v) ⇒ Object 

600
601
602
603
604
605
606
607
# File 'opal/stdlib/racc/parser.rb', line 600
def racc_print_stacks(t, v)
 out = @racc_debug_out
 out.print ' ['
 t.each_index do |i|
 out.print ' (', racc_token2str(t[i]), '', v[i].inspect, ')'
 end
 out.puts ' ]'
end

#racc_print_states(s) ⇒ Object 

609
610
611
612
613
614
# File 'opal/stdlib/racc/parser.rb', line 609
def racc_print_states(s)
 out = @racc_debug_out
 out.print ' ['
 s.each {|st| out.print '', st }
 out.puts ' ]'
end

#racc_read_token(t, tok, val) ⇒ Object

For debugging output

555
556
557
558
559
560
# File 'opal/stdlib/racc/parser.rb', line 555
def racc_read_token(t, tok, val)
 @racc_debug_out.print 'read '
 @racc_debug_out.print tok.inspect, '(', racc_token2str(t), ') '
 @racc_debug_out.puts val.inspect
 @racc_debug_out.puts
end

#racc_reduce(toks, sim, tstack, vstack) ⇒ Object 

568
569
570
571
572
573
574
575
576
577
578
579
580
# File 'opal/stdlib/racc/parser.rb', line 568
def racc_reduce(toks, sim, tstack, vstack)
 out = @racc_debug_out
 out.print 'reduce '
 if toks.empty?
 out.print ' <none>'
 else
 toks.each {|t| out.print '', racc_token2str(t) }
 end
 out.puts " --> #{racc_token2str(sim)}"
 racc_print_stacks tstack, vstack
 @racc_debug_out.puts
end

#racc_shift(tok, tstack, vstack) ⇒ Object 

562
563
564
565
566
# File 'opal/stdlib/racc/parser.rb', line 562
def racc_shift(tok, tstack, vstack)
 @racc_debug_out.puts "shift #{racc_token2str tok}"
 racc_print_stacks tstack, vstack
 @racc_debug_out.puts
end

#racc_token2str(tok) ⇒ Object 

616
617
618
619
# File 'opal/stdlib/racc/parser.rb', line 616
def racc_token2str(tok)
 self.class::Racc_token_to_s_table[tok] or
 raise "[Racc Bug] can't convert token #{tok} to string"
end

#token_to_str(t) ⇒ Object

Convert internal ID of token symbol to the string.

622
623
624
# File 'opal/stdlib/racc/parser.rb', line 622
def token_to_str(t)
 self.class::Racc_token_to_s_table[t]
end

#yyaccept ⇒ Object

Exit parser. Return value is Symbol_Value_Stack[0].

545
546
547
# File 'opal/stdlib/racc/parser.rb', line 545
def yyaccept
 throw :racc_jump, 2
end

#yyerrok ⇒ Object

Leave error recovering mode.

550
551
552
# File 'opal/stdlib/racc/parser.rb', line 550
def yyerrok
 @racc_error_status = 0
end

#yyerror ⇒ Object

Enter error recovering mode. This method does not call #on_error.

539
540
541
# File 'opal/stdlib/racc/parser.rb', line 539
def yyerror
 throw :racc_jump, 1
end

#yyparse(recv, mid) ⇒ Object

Another entry point for the parser. If you use this method, you must implement RECEIVER#METHOD_ID method.

RECEIVER#METHOD_ID is a method to get next token. It must 'yield' the token, which format is [TOKEN-SYMBOL, VALUE].

324
325
326
# File 'opal/stdlib/racc/parser.rb', line 324
def yyparse(recv, mid)
 __send__(Racc_YY_Parse_Method , recv, mid, _racc_setup(), true)
end

AltStyle によって変換されたページ (->オリジナル) /