racc 1.4.16 → 1.6.0

data/test/assets/intp.y

@@ -1,546 +0,0 @@
-#
-# intp
-#
-
-class Intp::Parser
-
-prechigh
-  nonassoc UMINUS
-  left     '*' '/'
-  left     '+' '-'
-  nonassoc EQ
-preclow
-
-rule
-
-  program   : stmt_list
-                {
-                  result = RootNode.new( val[0] )
-                }
-
-  stmt_list :
-                {
-                  result = []
-                }
-            | stmt_list stmt EOL
-                {
-                  result.push val[1]
-                }
-            | stmt_list EOL
-
-  stmt      : expr
-            | assign
-            | IDENT realprim
-                {
-                  result = FuncallNode.new( @fname, val[0][0],
-                                            val[0][1], [val[1]] )
-                }
-            | if_stmt
-            | while_stmt
-            | defun
-
-  if_stmt   : IF stmt THEN EOL stmt_list else_stmt END
-                {
-                  result = IfNode.new( @fname, val[0][0],
-                                       val[1], val[4], val[5] )
-                }
-
-  else_stmt : ELSE EOL stmt_list
-                {
-                  result = val[2]
-                }
-            |
-                {
-                  result = nil
-                }
-
-  while_stmt: WHILE stmt DO EOL stmt_list END
-                {
-                  result = WhileNode.new(@fname, val[0][0],
-                                          val[1], val[4])
-                }
-
-  defun     : DEF IDENT param EOL stmt_list END
-                {
-                  result = DefNode.new(@fname, val[0][0], val[1][1],
-                      Function.new(@fname, val[0][0], val[2], val[4]))
-                }
-
-  param     : '(' name_list ')'
-                {
-                  result = val[1]
-                }
-            | '(' ')'
-                {
-                  result = []
-                }
-            |
-                {
-                  result = []
-                }
-
-  name_list : IDENT
-                {
-                  result = [ val[0][1] ]
-                }
-            | name_list ',' IDENT
-                {
-                  result.push val[2][1]
-                }
-
-  assign    : IDENT '=' expr
-                {
-                  result = AssignNode.new(@fname, val[0][0], val[0][1], val[2])
-                }
-
-  expr      : expr '+' expr
-                {
-                  result = FuncallNode.new(@fname, val[0].lineno, '+', [val[0], val[2]])
-                }
-            | expr '-' expr
-                {
-                  result = FuncallNode.new(@fname, val[0].lineno, '-', [val[0], val[2]])
-                }
-            | expr '*' expr
-                {
-                  result = FuncallNode.new(@fname, val[0].lineno, '*', [val[0], val[2]])
-                }
-            | expr '/' expr
-                {
-                  result = FuncallNode.new(@fname, val[0].lineno,
-                                            '/', [val[0], val[2]])
-                }
-            | expr EQ expr
-                {
-                  result = FuncallNode.new(@fname, val[0].lineno, '==', [val[0], val[2]])
-                }
-            | primary
-
-  primary   : realprim
-            | '(' expr ')'
-                {
-                  result = val[1]
-                }
-            | '-' expr  =UMINUS
-                {
-                  result = FuncallNode.new(@fname, val[0][0], '-@', [val[1]])
-                }
-
-  realprim  : IDENT
-                {
-                  result = VarRefNode.new(@fname, val[0][0],
-                                           val[0][1])
-                }
-            | NUMBER
-                {
-                  result = LiteralNode.new(@fname, *val[0])
-                }
-            | STRING
-                {
-                  result = StringNode.new(@fname, *val[0])
-                }
-            | TRUE
-                {
-                  result = LiteralNode.new(@fname, *val[0])
-                }
-            | FALSE
-                {
-                  result = LiteralNode.new(@fname, *val[0])
-                }
-            | NIL
-                {
-                  result = LiteralNode.new(@fname, *val[0])
-                }
-            | funcall
-
-  funcall   : IDENT '(' args ')'
-                {
-                  result = FuncallNode.new(@fname, val[0][0], val[0][1], val[2])
-                }
-            | IDENT '(' ')'
-                {
-                  result = FuncallNode.new(@fname, val[0][0], val[0][1], [])
-                }
-
-  args      : expr
-                {
-                  result = val
-                }
-            | args ',' expr
-                {
-                  result.push val[2]
-                }
-
-end
-
----- header
-#
-# intp/parser.rb
-#
-
----- inner
-
-  def initialize
-    @scope = {}
-  end
-
-  RESERVED = {
-    'if'    => :IF,
-    'else'  => :ELSE,
-    'while' => :WHILE,
-    'then'  => :THEN,
-    'do'    => :DO,
-    'def'   => :DEF,
-    'true'  => :TRUE,
-    'false' => :FALSE,
-    'nil'   => :NIL,
-    'end'   => :END
-  }
-
-  RESERVED_V = {
-    'true'  => true,
-    'false' => false,
-    'nil'   => nil
-  }
-
-  def parse(f, fname)
-    @q = []
-    @fname = fname
-    lineno = 1
-    f.each do |line|
-      line.strip!
-      until line.empty?
-        case line
-        when /\A\s+/, /\A\#.*/
-          ;
-        when /\A[a-zA-Z_]\w*/
-          word = $&
-          @q.push [(RESERVED[word] || :IDENT),
-                   [lineno, RESERVED_V.key?(word) ? RESERVED_V[word] : word.intern]]
-        when /\A\d+/
-          @q.push [:NUMBER, [lineno, $&.to_i]]
-        when /\A"(?:[^"\\]+|\\.)*"/, /\A'(?:[^'\\]+|\\.)*'/
-          @q.push [:STRING, [lineno, eval($&)]]
-        when /\A==/
-          @q.push [:EQ, [lineno, '==']]
-        when /\A./
-          @q.push [$&, [lineno, $&]]
-        else
-          raise RuntimeError, 'must not happen'
-        end
-        line = $'
-      end
-      @q.push [:EOL, [lineno, nil]]
-      lineno += 1
-    end
-    @q.push [false, '$']
-    do_parse
-  end
-
-  def next_token
-    @q.shift
-  end
-
-  def on_error(t, v, values)
-    if v
-      line = v[0]
-      v = v[1]
-    else
-      line = 'last'
-    end
-    raise Racc::ParseError, "#{@fname}:#{line}: syntax error on #{v.inspect}"
-  end
-
----- footer
-# intp/node.rb
-
-module Intp
-
-  class IntpError < StandardError; end
-  class IntpArgumentError < IntpError; end
-
-  class Core
-
-    def initialize
-      @ftab = {}
-      @obj = Object.new
-      @stack = []
-      @stack.push Frame.new '(toplevel)'
-    end
-
-    def frame
-      @stack[-1]
-    end
-
-    def define_function(fname, node)
-      raise IntpError, "function #{fname} defined twice" if @ftab.key?(fname)
-      @ftab[fname] = node
-    end
-
-    def call_function_or(fname, args)
-      call_intp_function_or(fname, args) {
-        call_ruby_toplevel_or(fname, args) {
-          yield
-        }
-      }
-    end
-
-    def call_intp_function_or(fname, args)
-      if func = @ftab[fname]
-        frame = Frame.new(fname)
-        @stack.push frame
-        func.call self, frame, args
-        @stack.pop
-      else
-        yield
-      end
-    end
-
-    def call_ruby_toplevel_or(fname, args)
-      if @obj.respond_to? fname, true
-        @obj.send fname, *args
-      else
-        yield
-      end
-    end
-
-  end
-
-  class Frame
-
-    def initialize(fname)
-      @fname = fname
-      @lvars = {}
-    end
-
-    attr :fname
-
-    def lvar?(name)
-      @lvars.key? name
-    end
-
-    def [](key)
-      @lvars[key]
-    end
-
-    def []=(key, val)
-      @lvars[key] = val
-    end
-
-  end
-
-
-  class Node
-
-    def initialize(fname, lineno)
-      @filename = fname
-      @lineno = lineno
-    end
-
-    attr_reader :filename
-    attr_reader :lineno
-
-    def exec_list(intp, nodes)
-      v = nil
-      nodes.each {|i| v = i.evaluate(intp) }
-      v
-    end
-
-    def intp_error!(msg)
-      raise IntpError, "in #{filename}:#{lineno}: #{msg}"
-    end
-
-    def inspect
-      "#{self.class.name}/#{lineno}"
-    end
-
-  end
-
-
-  class RootNode < Node
-
-    def initialize(tree)
-      super nil, nil
-      @tree = tree
-    end
-
-    def evaluate
-      exec_list Core.new, @tree
-    end
-
-  end
-
-
-  class DefNode < Node
-
-    def initialize(file, lineno, fname, func)
-      super file, lineno
-      @funcname = fname
-      @funcobj = func
-    end
-
-    def evaluate(intp)
-      intp.define_function @funcname, @funcobj
-    end
-
-  end
-
-  class FuncallNode < Node
-
-    def initialize(file, lineno, func, args)
-      super file, lineno
-      @funcname = func
-      @args = args
-    end
-
-    def evaluate(intp)
-      args = @args.map {|i| i.evaluate intp }
-      begin
-        intp.call_intp_function_or(@funcname, args) {
-          if args.empty? or not args[0].respond_to?(@funcname)
-            intp.call_ruby_toplevel_or(@funcname, args) {
-              intp_error! "undefined function #{@funcname.id2name}"
-            }
-          else
-            recv = args.shift
-            recv.send @funcname, *args
-          end
-        }
-      rescue IntpArgumentError, ArgumentError
-        intp_error! $!.message
-      end
-    end
-
-  end
-
-  class Function < Node
-
-    def initialize(file, lineno, params, body)
-      super file, lineno
-      @params = params
-      @body = body
-    end
-
-    def call(intp, frame, args)
-      unless args.size == @params.size
-        raise IntpArgumentError,
-          "wrong # of arg for #{frame.fname}() (#{args.size} for #{@params.size})"
-      end
-      args.each_with_index do |v,i|
-        frame[@params[i]] = v
-      end
-      exec_list intp, @body
-    end
-
-  end
-
-
-  class IfNode < Node
-
-    def initialize(fname, lineno, cond, tstmt, fstmt)
-      super fname, lineno
-      @condition = cond
-      @tstmt = tstmt
-      @fstmt = fstmt
-    end
-
-    def evaluate(intp)
-      if @condition.evaluate(intp)
-        exec_list intp, @tstmt
-      else
-        exec_list intp, @fstmt if @fstmt
-      end
-    end
-
-  end
-
-  class WhileNode < Node
-
-    def initialize(fname, lineno, cond, body)
-      super fname, lineno
-      @condition = cond
-      @body = body
-    end
-
-    def evaluate(intp)
-      while @condition.evaluate(intp)
-        exec_list intp, @body
-      end
-    end
-
-  end
-
-
-  class AssignNode < Node
-
-    def initialize(fname, lineno, vname, val)
-      super fname, lineno
-      @vname = vname
-      @val = val
-    end
-
-    def evaluate(intp)
-      intp.frame[@vname] = @val.evaluate(intp)
-    end
-
-  end
-
-  class VarRefNode < Node
-
-    def initialize(fname, lineno, vname)
-      super fname, lineno
-      @vname = vname
-    end
-
-    def evaluate(intp)
-      if intp.frame.lvar?(@vname)
-        intp.frame[@vname]
-      else
-        intp.call_function_or(@vname, []) {
-          intp_error! "unknown method or local variable #{@vname.id2name}"
-        }
-      end
-    end
-
-  end
-
-  class StringNode < Node
-
-    def initialize(fname, lineno, str)
-      super fname, lineno
-      @val = str
-    end
-
-    def evaluate(intp)
-      @val.dup
-    end
-
-  end
-
-  class LiteralNode < Node
-
-    def initialize(fname, lineno, val)
-      super fname, lineno
-      @val = val
-    end
-
-    def evaluate(intp)
-      @val
-    end
-
-  end
-
-end   # module Intp
-
-begin
-  tree = nil
-  fname = 'src.intp'
-  File.open(fname) {|f|
-    tree = Intp::Parser.new.parse(f, fname)
-  }
-  tree.evaluate
-rescue Racc::ParseError, Intp::IntpError, Errno::ENOENT
-  raise ####
-  $stderr.puts "#{File.basename $0}: #{$!}"
-  exit 1
-end

data/test/assets/journey.y

@@ -1,47 +0,0 @@
-class Journey::Parser
-
-token SLASH LITERAL SYMBOL LPAREN RPAREN DOT STAR OR
-
-rule
-  expressions
-    : expressions expression  { result = Cat.new(val.first, val.last) }
-    | expression              { result = val.first }
-    | or
-    ;
-  expression
-    : terminal
-    | group
-    | star
-    ;
-  group
-    : LPAREN expressions RPAREN { result = Group.new(val[1]) }
-    ;
-  or
-    : expressions OR expression { result = Or.new([val.first, val.last]) }
-    ;
-  star
-    : STAR       { result = Star.new(Symbol.new(val.last)) }
-    ;
-  terminal
-    : symbol
-    | literal
-    | slash
-    | dot
-    ;
-  slash
-    : SLASH              { result = Slash.new('/') }
-    ;
-  symbol
-    : SYMBOL             { result = Symbol.new(val.first) }
-    ;
-  literal
-    : LITERAL            { result = Literal.new(val.first) }
-  dot
-    : DOT                { result = Dot.new(val.first) }
-    ;
-
-end
-
----- header
-
-require 'journey/parser_extras'