Class: Racc::Parser

Inherits:
Object
  • Object
show all
Defined in:
lib/sportdb/parser/parser_runtime.rb

Direct Known Subclasses

RaccMatchParser

Instance Method Summary collapse

Instance Method Details

#_racc_do_parse_rb(arg, in_debug) ⇒ Object 



87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
 
# File 'lib/sportdb/parser/parser_runtime.rb', line 87

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 



229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
 
# File 'lib/sportdb/parser/parser_runtime.rb', line 229

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



132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
 
# File 'lib/sportdb/parser/parser_runtime.rb', line 132

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 



42
43
44
45
46
47
48
49
50
51
52
53
54
 
# File 'lib/sportdb/parser/parser_runtime.rb', line 42

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 



30
31
32
33
34
35
36
37
38
39
40
 
# File 'lib/sportdb/parser/parser_runtime.rb', line 30

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

#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



71
72
73
 
# File 'lib/sportdb/parser/parser_runtime.rb', line 71

def do_parse
    _racc_do_parse_rb(_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) 


83
84
85
 
# File 'lib/sportdb/parser/parser_runtime.rb', line 83

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:



285
286
287
288
 
# File 'lib/sportdb/parser/parser_runtime.rb', line 285

def on_error(t, val, vstack)
  raise ParseError, sprintf("parse error on value %s (%s)",
                            val.inspect, token_to_str(t) || '?')
end

#racc_accept ⇒ Object 



334
335
336
337
 
# File 'lib/sportdb/parser/parser_runtime.rb', line 334

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

#racc_e_pop(state, tstack, vstack) ⇒ Object 



339
340
341
342
343
344
 
# File 'lib/sportdb/parser/parser_runtime.rb', line 339

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 



346
347
348
349
350
 
# File 'lib/sportdb/parser/parser_runtime.rb', line 346

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 



352
353
354
355
356
357
358
359
 
# File 'lib/sportdb/parser/parser_runtime.rb', line 352

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 



361
362
363
364
365
366
 
# File 'lib/sportdb/parser/parser_runtime.rb', line 361

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



308
309
310
311
312
313
 
# File 'lib/sportdb/parser/parser_runtime.rb', line 308

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 



321
322
323
324
325
326
327
328
329
330
331
332
 
# File 'lib/sportdb/parser/parser_runtime.rb', line 321

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 



315
316
317
318
319
 
# File 'lib/sportdb/parser/parser_runtime.rb', line 315

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 



368
369
370
371
 
# File 'lib/sportdb/parser/parser_runtime.rb', line 368

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.



374
375
376
 
# File 'lib/sportdb/parser/parser_runtime.rb', line 374

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



298
299
300
 
# File 'lib/sportdb/parser/parser_runtime.rb', line 298

def yyaccept
  throw :racc_jump, 2
end

#yyerrok ⇒ Object

Leave error recovering mode.



303
304
305
 
# File 'lib/sportdb/parser/parser_runtime.rb', line 303

def yyerrok
  @racc_error_status = 0
end

#yyerror ⇒ Object

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



292
293
294
 
# File 'lib/sportdb/parser/parser_runtime.rb', line 292

def yyerror
  throw :racc_jump, 1
end