Racc::Parser

    # File lib/racc/parser.rb, line 62
62:     def Parser.racc_runtime_type
63:       Racc_Runtime_Type
64:     end

     # File lib/racc/parser.rb, line 106
106:     def _racc_do_parse_rb(arg, in_debug)
107:       action_table, action_check, action_default, action_pointer,
108:       goto_table,   goto_check,   goto_default,   goto_pointer,
109:       nt_base,      reduce_table, token_table,    shift_n,
110:       reduce_n,     use_result,   * = arg
111: 
112:       _racc_init_sysvars
113:       tok = act = i = nil
114:       nerr = 0
115: 
116:       catch(:racc_end_parse) {
117:         while true
118:           if i = action_pointer[@racc_state[1]]
119:             if @racc_read_next
120:               if @racc_t != 0   # not EOF
121:                 tok, @racc_val = next_token()
122:                 unless tok      # EOF
123:                   @racc_t = 0
124:                 else
125:                   @racc_t = (token_table[tok] or 1)   # error token
126:                 end
127:                 racc_read_token(@racc_t, tok, @racc_val) if @yydebug
128:                 @racc_read_next = false
129:               end
130:             end
131:             i += @racc_t
132:             unless i >= 0 and
133:                    act = action_table[i] and
134:                    action_check[i] == @racc_state[1]
135:               act = action_default[@racc_state[1]]
136:             end
137:           else
138:             act = action_default[@racc_state[1]]
139:           end
140:           while act = _racc_evalact(act, arg)
141:             ;
142:           end
143:         end
144:       }
145:     end

     # File lib/racc/parser.rb, line 305
305:     def _racc_do_reduce(arg, act)
306:       action_table, action_check, action_default, action_pointer,
307:       goto_table,   goto_check,   goto_default,   goto_pointer,
308:       nt_base,      reduce_table, token_table,    shift_n,
309:       reduce_n,     use_result,   * = arg
310:       state = @racc_state
311:       vstack = @racc_vstack
312:       tstack = @racc_tstack
313: 
314:       i = act * 3
315:       len       = reduce_table[i]
316:       reduce_to = reduce_table[i+1]
317:       method_id = reduce_table[i+2]
318:       void_array = []
319: 
320:       tmp_t = tstack[-len, len] if @yydebug
321:       tmp_v = vstack[-len, len]
322:       tstack[-len, len] = void_array if @yydebug
323:       vstack[-len, len] = void_array
324:       state[-len, len]  = void_array
325: 
326:       # tstack must be updated AFTER method call
327:       if use_result
328:         vstack.push __send__(method_id, tmp_v, vstack, tmp_v[0])
329:       else
330:         vstack.push __send__(method_id, tmp_v, vstack)
331:       end
332:       tstack.push reduce_to
333: 
334:       racc_reduce(tmp_t, reduce_to, tstack, vstack) if @yydebug
335: 
336:       k1 = reduce_to - nt_base
337:       if i = goto_pointer[k1]
338:         i += state[1]
339:         if i >= 0 and (curstate = goto_table[i]) and goto_check[i] == k1
340:           return curstate
341:         end
342:       end
343:       goto_default[k1]
344:     end

     # File lib/racc/parser.rb, line 210
210:     def _racc_evalact(act, arg)
211:       action_table, action_check, action_default, action_pointer,
212:       goto_table,   goto_check,   goto_default,   goto_pointer,
213:       nt_base,      reduce_table, token_table,    shift_n,
214:       reduce_n,     use_result,   * = arg
215:       nerr = 0   # tmp
216: 
217:       if act > 0 and act < shift_n
218:         #
219:         # shift
220:         #
221:         if @racc_error_status > 0
222:           @racc_error_status -= 1 unless @racc_t == 1   # error token
223:         end
224:         @racc_vstack.push @racc_val
225:         @racc_state.push act
226:         @racc_read_next = true
227:         if @yydebug
228:           @racc_tstack.push @racc_t
229:           racc_shift @racc_t, @racc_tstack, @racc_vstack
230:         end
231: 
232:       elsif act < 0 and act > -reduce_n
233:         #
234:         # reduce
235:         #
236:         code = catch(:racc_jump) {
237:           @racc_state.push _racc_do_reduce(arg, act)
238:           false
239:         }
240:         if code
241:           case code
242:           when 1 # yyerror
243:             @racc_user_yyerror = true   # user_yyerror
244:             return -reduce_n
245:           when 2 # yyaccept
246:             return shift_n
247:           else
248:             raise '[Racc Bug] unknown jump code'
249:           end
250:         end
251: 
252:       elsif act == shift_n
253:         #
254:         # accept
255:         #
256:         racc_accept if @yydebug
257:         throw :racc_end_parse, @racc_vstack[0]
258: 
259:       elsif act == -reduce_n
260:         #
261:         # error
262:         #
263:         case @racc_error_status
264:         when 0
265:           unless arg[21]    # user_yyerror
266:             nerr += 1
267:             on_error @racc_t, @racc_val, @racc_vstack
268:           end
269:         when 3
270:           if @racc_t == 0   # is $
271:             throw :racc_end_parse, nil
272:           end
273:           @racc_read_next = true
274:         end
275:         @racc_user_yyerror = false
276:         @racc_error_status = 3
277:         while true
278:           if i = action_pointer[@racc_state[1]]
279:             i += 1   # error token
280:             if  i >= 0 and
281:                 (act = action_table[i]) and
282:                 action_check[i] == @racc_state[1]
283:               break
284:             end
285:           end
286:           throw :racc_end_parse, nil if @racc_state.size <= 1
287:           @racc_state.pop
288:           @racc_vstack.pop
289:           if @yydebug
290:             @racc_tstack.pop
291:             racc_e_pop @racc_state, @racc_tstack, @racc_vstack
292:           end
293:         end
294:         return act
295: 
296:       else
297:         raise "[Racc Bug] unknown action #{act.inspect}"
298:       end
299: 
300:       racc_next_state(@racc_state[1], @racc_state) if @yydebug
301: 
302:       nil
303:     end

    # File lib/racc/parser.rb, line 80
80:     def _racc_init_sysvars
81:       @racc_state  = [0]
82:       @racc_tstack = []
83:       @racc_vstack = []
84: 
85:       @racc_t = nil
86:       @racc_val = nil
87: 
88:       @racc_read_next = true
89: 
90:       @racc_user_yyerror = false
91:       @racc_error_status = 0
92:     end

    # File lib/racc/parser.rb, line 68
68:     def _racc_setup
69:       @yydebug = false unless self.class::Racc_debug_parser
70:       @yydebug = false unless defined?(@yydebug)
71:       if @yydebug
72:         @racc_debug_out = $stderr unless defined?(@racc_debug_out)
73:         @racc_debug_out ||= $stderr
74:       end
75:       arg = self.class::Racc_arg
76:       arg[13] = true if arg.size < 14
77:       arg
78:     end

     # File lib/racc/parser.rb, line 155
155:     def _racc_yyparse_rb(recv, mid, arg, c_debug)
156:       action_table, action_check, action_default, action_pointer,
157:       goto_table,   goto_check,   goto_default,   goto_pointer,
158:       nt_base,      reduce_table, token_table,    shift_n,
159:       reduce_n,     use_result,   * = arg
160: 
161:       _racc_init_sysvars
162:       nerr = 0
163: 
164:       catch(:racc_end_parse) {
165:         until i = action_pointer[@racc_state[1]]
166:           while act = _racc_evalact(action_default[@racc_state[1]], arg)
167:             ;
168:           end
169:         end
170:         recv.__send__(mid) do |tok, val|
171:           unless tok
172:             @racc_t = 0
173:           else
174:             @racc_t = (token_table[tok] or 1)   # error token
175:           end
176:           @racc_val = val
177:           @racc_read_next = false
178: 
179:           i += @racc_t
180:           unless i >= 0 and
181:                  act = action_table[i] and
182:                  action_check[i] == @racc_state[1]
183:             act = action_default[@racc_state[1]]
184:           end
185:           while act = _racc_evalact(act, arg)
186:             ;
187:           end
188: 
189:           while !(i = action_pointer[@racc_state[1]]) ||
190:                 ! @racc_read_next ||
191:                 @racc_t == 0  # $
192:             unless i and i += @racc_t and
193:                    i >= 0 and
194:                    act = action_table[i] and
195:                    action_check[i] == @racc_state[1]
196:               act = action_default[@racc_state[1]]
197:             end
198:             while act = _racc_evalact(act, arg)
199:               ;
200:             end
201:           end
202:         end
203:       }
204:     end

     # File lib/racc/parser.rb, line 98
 98:     def do_parse
 99:       __send__(Racc_Main_Parsing_Routine, _racc_setup(), false)
100:     end

     # File lib/racc/parser.rb, line 102
102:     def next_token
103:       raise NotImplementedError, "#{self.class}\#next_token is not defined"
104:     end

     # File lib/racc/parser.rb, line 346
346:     def on_error(t, val, vstack)
347:       raise ParseError, sprintf("\nparse error on value %s (%s)",
348:                                 val.inspect, token_to_str(t) || '?')
349:     end

     # File lib/racc/parser.rb, line 394
394:     def racc_accept
395:       @racc_debug_out.puts 'accept'
396:       @racc_debug_out.puts
397:     end

     # File lib/racc/parser.rb, line 399
399:     def racc_e_pop(state, tstack, vstack)
400:       @racc_debug_out.puts 'error recovering mode: pop token'
401:       racc_print_states state
402:       racc_print_stacks tstack, vstack
403:       @racc_debug_out.puts
404:     end

     # File lib/racc/parser.rb, line 406
406:     def racc_next_state(curstate, state)
407:       @racc_debug_out.puts  "goto    #{curstate}"
408:       racc_print_states state
409:       @racc_debug_out.puts
410:     end

     # File lib/racc/parser.rb, line 412
412:     def racc_print_stacks(t, v)
413:       out = @racc_debug_out
414:       out.print '        ['
415:       t.each_index do |i|
416:         out.print ' (', racc_token2str(t[i]), ' ', v[i].inspect, ')'
417:       end
418:       out.puts ' ]'
419:     end

     # File lib/racc/parser.rb, line 421
421:     def racc_print_states(s)
422:       out = @racc_debug_out
423:       out.print '        ['
424:       s.each {|st| out.print ' ', st }
425:       out.puts ' ]'
426:     end

     # File lib/racc/parser.rb, line 367
367:     def racc_read_token(t, tok, val)
368:       @racc_debug_out.print 'read    '
369:       @racc_debug_out.print tok.inspect, '(', racc_token2str(t), ') '
370:       @racc_debug_out.puts val.inspect
371:       @racc_debug_out.puts
372:     end

     # File lib/racc/parser.rb, line 380
380:     def racc_reduce(toks, sim, tstack, vstack)
381:       out = @racc_debug_out
382:       out.print 'reduce '
383:       if toks.empty?
384:         out.print ' <none>'
385:       else
386:         toks.each {|t| out.print ' ', racc_token2str(t) }
387:       end
388:       out.puts " --> #{racc_token2str(sim)}"
389:           
390:       racc_print_stacks tstack, vstack
391:       @racc_debug_out.puts
392:     end

     # File lib/racc/parser.rb, line 374
374:     def racc_shift(tok, tstack, vstack)
375:       @racc_debug_out.puts "shift   #{racc_token2str tok}"
376:       racc_print_stacks tstack, vstack
377:       @racc_debug_out.puts
378:     end

     # File lib/racc/parser.rb, line 428
428:     def racc_token2str(tok)
429:       self.class::Racc_token_to_s_table[tok] or
430:           raise "[Racc Bug] can't convert token #{tok} to string"
431:     end

     # File lib/racc/parser.rb, line 433
433:     def token_to_str(t)
434:       self.class::Racc_token_to_s_table[t]
435:     end

     # File lib/racc/parser.rb, line 355
355:     def yyaccept
356:       throw :racc_jump, 2
357:     end

     # File lib/racc/parser.rb, line 359
359:     def yyerrok
360:       @racc_error_status = 0
361:     end

     # File lib/racc/parser.rb, line 351
351:     def yyerror
352:       throw :racc_jump, 1
353:     end

     # File lib/racc/parser.rb, line 151
151:     def yyparse(recv, mid)
152:       __send__(Racc_YY_Parse_Method, recv, mid, _racc_setup(), true)
153:     end