test.rb

require 'whittle'

class Parser < Whittle::Parser
  rule("class")

  rule("(")
  rule(")")

  rule("{")
  rule("}")

  rule("[")
  rule("]")

  rule(",")

  rule(:int => /[0-9]+/).as { |i| Integer(i) }
  rule(:identifier => /[a-zA-Z_][a-zA-Z0-9_]*/)

  rule(:wsp => /\s+/).skip!

  rule(:array_expr) do |r|
    r["[", :arg_list, "]"].as { |_, list, _| list }
  end

  rule(:arg) do |r|
    r[:int]
    r[:identifier]
    r[:array_expr]
  end

  rule(:arg_list) do |r|
    r[].as                     { [] }
    r[:arg_list, ",", :arg].as { |list, _, arg| list << arg }
    r[:arg].as                 { |arg| [arg] }
  end

  rule(:method_inv) do |r|
    r[:identifier, "(", :arg_list, ")"].as { |id, _, args, _| { :func_name => id, :args => args } }
  end

  rule(:method_inv_list) do |r|
    r[].as                              { [] }
    r[:method_inv_list, :method_inv].as { |list, inv| list << inv }
    r[:method_inv].as                   { |inv| [inv] }
  end

  rule(:class_def) do |r|
    r["class", :identifier, "{", :method_inv_list, "}"].as do |_, id, _, inv_list, _|
      inv_list.map { |inv| { :class => id }.merge(inv) }
    end
  end

  rule(:prog) do |r|
    r[:class_def]
  end

  start(:prog)
end

prog = <<-PROG
class FromToExp {
  pct_move(inst1,[0,1])
  pct_turn(inst2,[3,4,5])
}
PROG

require 'pp'
pp Parser.new.parse(prog)

# => 
# [{:class=>"FromToExp", :func_name=>"pct_move", :args=>["inst1", [0, 1]]},
# {:class=>"FromToExp", :func_name=>"pct_turn", :args=>["inst2", [3, 4, 5]]}]