Class: Racc::Parser

Inherits:
Object show all
Defined in:
lib/racc/parser.rb,
ext/racc/cparse.c

Constant Summary collapse

Racc_Runtime_Version = 
::Racc::VERSION
Racc_Runtime_Revision = 
'$Id: 2bd697d1146b280d8d3878e21e556ef769484a37 $'
Racc_Runtime_Core_Version_R = 
::Racc::VERSION
Racc_Runtime_Core_Revision_R = 
'$Id: 2bd697d1146b280d8d3878e21e556ef769484a37 $'.split[1]
Racc_Runtime_Core_Version_C = 
rb_str_new2(RACC_VERSION)
Racc_Runtime_Core_Id_C = 
rb_str_new2("$originalId: cparse.c,v 1.8 2006/07/06 11:39:46 aamine Exp $")

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.racc_runtime_type ⇒ Object

:nodoc:



225
226
227
 
# File 'lib/racc/parser.rb', line 225

def Parser.racc_runtime_type # :nodoc:
  Racc_Runtime_Type
end

Instance Method Details

#_racc_do_parse_rb(arg, in_debug) ⇒ Object 



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
318
319
320
321
322
323
 
# File 'lib/racc/parser.rb', line 286

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 



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
517
518
519
520
521
522
523
524
 
# File 'lib/racc/parser.rb', line 484

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



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
476
477
478
479
480
481
482
 
# File 'lib/racc/parser.rb', line 387

def _racc_evalact(act, arg)
  action_table, action_check, _, action_pointer,
  _,            _,            _, _,
  _,            _,            _, shift_n,
  reduce_n,     * = arg
  nerr = 0   # tmp

  if act > 0 and act < shift_n
    #
    # shift
    #
    if @racc_error_status > 0
      @racc_error_status -= 1 unless @racc_t <= 1 # error token or EOF
    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
        nerr += 1
        on_error @racc_t, @racc_val, @racc_vstack
      end
    when 3
      if @racc_t == 0   # is $
        # We're at EOF, and another error occurred immediately after
        # attempting auto-recovery
        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 



241
242
243
244
245
246
247
248
249
250
251
252
253
 
# File 'lib/racc/parser.rb', line 241

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 



229
230
231
232
233
234
235
236
237
238
239
 
# File 'lib/racc/parser.rb', line 229

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 



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
379
380
381
 
# File 'lib/racc/parser.rb', line 334

def _racc_yyparse_rb(recv, mid, arg, c_debug)
  action_table, action_check, action_default, action_pointer,
  _,            _,            _,              _,
  _,            _,            token_table,    * = arg

  _racc_init_sysvars

  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 !(i = action_pointer[@racc_state[-1]]) ||
            ! @racc_read_next ||
            @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



270
271
272
 
# File 'lib/racc/parser.rb', line 270

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) 


282
283
284
 
# File 'lib/racc/parser.rb', line 282

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:



540
541
542
543
 
# File 'lib/racc/parser.rb', line 540

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 



589
590
591
592
 
# File 'lib/racc/parser.rb', line 589

def racc_accept
  @racc_debug_out.puts 'accept'
  @racc_debug_out.puts
end

#racc_e_pop(state, tstack, vstack) ⇒ Object 



594
595
596
597
598
599
 
# File 'lib/racc/parser.rb', line 594

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 



601
602
603
604
605
 
# File 'lib/racc/parser.rb', line 601

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 



607
608
609
610
611
612
613
614
 
# File 'lib/racc/parser.rb', line 607

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 



616
617
618
619
620
621
 
# File 'lib/racc/parser.rb', line 616

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



563
564
565
566
567
568
 
# File 'lib/racc/parser.rb', line 563

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 



576
577
578
579
580
581
582
583
584
585
586
587
 
# File 'lib/racc/parser.rb', line 576

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 



570
571
572
573
574
 
# File 'lib/racc/parser.rb', line 570

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 



623
624
625
626
 
# File 'lib/racc/parser.rb', line 623

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.



629
630
631
 
# File 'lib/racc/parser.rb', line 629

def token_to_str(t)
  self.class::Racc_token_to_s_table[t]
end

#yyaccept ⇒ Object

Exit parser. Return value is Symbol_Value_Stack.



553
554
555
 
# File 'lib/racc/parser.rb', line 553

def yyaccept
  throw :racc_jump, 2
end

#yyerrok ⇒ Object

Leave error recovering mode.



558
559
560
 
# File 'lib/racc/parser.rb', line 558

def yyerrok
  @racc_error_status = 0
end

#yyerror ⇒ Object

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



547
548
549
 
# File 'lib/racc/parser.rb', line 547

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].



330
331
332
 
# File 'lib/racc/parser.rb', line 330

def yyparse(recv, mid)
  __send__(Racc_YY_Parse_Method, recv, mid, _racc_setup(), false)
end