python 0.0.1

data/features/support/env.rb

@@ -0,0 +1,2 @@
+$LOAD_PATH.unshift File.expand_path('../../../lib', __FILE__)
+require 'python'

data/lib/python.rb

@@ -0,0 +1,10 @@
+require "python/version"
+require "python/repl"
+require "python/parser/expression"
+require "python/syntax"
+require "python/builtins"
+require "python/file_interpreter"
+
+module Python
+  # Your code goes here...
+end

data/lib/python/builtins.rb

@@ -0,0 +1,72 @@
+require 'python/pyobject'
+
+module Python
+  module Builtins
+    # Primitive objects
+    Func = PyObject.new(:name => "Func")
+    Int = PyObject.new(:name => "Int")
+    Bool = PyObject.new(:name => "Bool", :bases => [Int])
+
+    None = PyObject.new(:name => "None")
+    True = PyObject.new(:class => Bool, :name => "True", :entity => 1)
+    False = PyObject.new(:class => Bool, :name => "False", :entity => 0)
+
+    Type = PyObject.new(:name => "Type")
+
+
+    # Primitiv functions
+    AddTwoInt = Func.make_instance{|a, b| Int.make_instance(a.entity + b.entity)}
+    SubTwoInt = Func.make_instance{|a, b| Int.make_instance(a.entity - b.entity)}
+    MulTwoInt = Func.make_instance{|a, b| Int.make_instance(a.entity * b.entity)}
+    FloordivTwoInt = Func.make_instance{|a, b| Int.make_instance(a.entity / b.entity)}
+    PosInt = Func.make_instance{|n| Int.make_instance(+ n.entity)}
+    NegInt = Func.make_instance{|n| Int.make_instance(- n.entity)}
+    EQInt = Func.make_instance{|a, b| a.entity == b.entity ? True : False}
+    LTInt = Func.make_instance{|a, b| a.entity < b.entity ? True : False}
+    GTInt = Func.make_instance{|a, b| a.entity > b.entity ? True : False}
+    IntToBool = Func.make_instance{|n| n.entity == 0 ? False : True}
+
+    Print = Func.make_instance{|o| puts(o.inspect)}
+    ClosureCall = Func.make_instance do |f, *args|
+      if f.entity[:rest_param_name]
+        unless f.entity[:fix_param_names].length <= args.length
+          raise Syntax::PyCallError.new
+        end
+      else
+        unless f.entity[:fix_param_names].length == args.length
+          raise Syntax::PyCallError.new
+        end
+      end
+      bind = f.entity[:fix_param_names].zip(args).to_h
+      env = Environment.new(bind.merge(:parent => f.entity[:env]))
+      catch(:return) { f.entity[:stat].eval(env) } || None
+    end
+
+    MakeInstance = Func.make_instance do |cls, *args|
+      if class_having_new = cls.base_traverse{|cls| cls["__new__"]}
+        madeobj = class_having_new["__new__"].call(*args)
+      else
+        madeobj = PyObject.new(:class => cls)
+      end
+      if madeobj[:class] == cls && madeobj.has_special_attr?("__init__")
+        madeobj.call_special_method("__init__", *args)
+      end
+      madeobj
+    end
+
+    # Method binds of primitive functions
+    Func["__get__"] = Func.make_instance{|_self, obj, objtype| Func.make_instance{|*args| _self.call(obj, *args)}}
+    Func["__call__"] = Func.make_instance{|_self, *args| ClosureCall.call(_self, *args)}
+    Int["__add__"] = Func.make_instance{|_self, other| AddTwoInt.call(_self, other)}
+    Int["__sub__"] = Func.make_instance{|_self, other| SubTwoInt.call(_self, other)}
+    Int["__mul__"] = Func.make_instance{|_self, other| MulTwoInt.call(_self, other)}
+    Int["__floordiv__"] = Func.make_instance{|_self, other| FloordivTwoInt.call(_self, other)}
+    Int["__pos__"] = Func.make_instance{|_self| PosInt.call(_self)}
+    Int["__neg__"] = Func.make_instance{|_self| NegInt.call(_self)}
+    Int["__bool__"] = Func.make_instance{|_self| IntToBool.call(_self)}
+    Int["__eq__"] = Func.make_instance{|_self, other| EQInt.call(_self, other)}
+    Int["__lt__"] = Func.make_instance{|_self, other| LTInt.call(_self, other)}
+    Int["__gt__"] = Func.make_instance{|_self, other| GTInt.call(_self, other)}
+    Type["__call__"] = Func.make_instance{|_self, *args| MakeInstance.call(_self, *args)}
+  end
+end

data/lib/python/environment.rb

@@ -0,0 +1,42 @@
+require 'python/builtins'
+
+module Python
+  class Environment < Hash
+    def initialize(initial_attr={})
+      self.merge!(initial_attr)
+    end
+
+    def resolve(name)
+      if self[name]
+        self[name]
+      elsif self[:parent]
+        self[:parent].resolve(name)
+      else
+        case name
+        when "True"
+          Builtins::True
+        when "False"
+          Builtins::False
+        when "None"
+          Builtins::None
+        when "print"
+          Builtins::Print
+        end
+      end
+    end
+
+    def set(name, pyobj)
+      self[name] = pyobj
+    end
+
+    def getlink
+      self
+    end
+  end
+
+  class ClassEnvironment < Environment
+    def getlink
+      self[:parent].getlink
+    end
+  end
+end

data/lib/python/file_interpreter.rb

@@ -0,0 +1,29 @@
+require 'python/parser/statement'
+require 'python/parser/indent_converter'
+require 'python/environment'
+
+module Python
+  class FileInterpreter
+    ParsingError = Class.new(RuntimeError)
+
+    def initialize(code, bind={})
+      @code = code
+      @bind = bind
+    end
+
+    def parse
+      parser = Parser::StatementParser.file_input
+      result = parser.parse(Parser::IndentConverter.new.convert(@code))
+
+      if result.is_a?(Parser::Succeeded) && result.rest == ""
+        result.parsed
+      else
+        raise ParsingError.new
+      end
+    end
+
+    def execute
+      parse().eval(Environment.new(@bind))
+    end
+  end
+end

data/lib/python/parser/combinator.rb

@@ -0,0 +1,206 @@
+module Python
+  module Parser
+    Result = Class.new
+    Failed = Class.new(Result)
+    Succeeded = Class.new(Result)
+
+    class Succeeded
+      attr_reader :parsed, :rest
+      def initialize(parsed, rest)
+        @parsed, @rest = parsed, rest
+      end
+    end
+
+    class Combinator
+      ParserDefinitionError = Class.new(RuntimeError)
+
+      attr_accessor :f
+      def initialize(&proc)
+        @f = proc
+      end
+
+      def parse(inp)
+        @f.call(inp)
+      end
+
+      def >>(proc)
+        self.class.so(self, &proc)
+      end
+
+      def |(other)
+        self.class.either(self, other)
+      end
+
+      def +(other)
+        self.class.discardl(self, other)
+      end
+
+      def -(other)
+        self.class.discardr(self, other)
+      end
+
+      def self.ret(something)
+        new{|inp| Succeeded.new(something, inp)}
+      end
+
+      def self.failure
+        new{|inp| Failed.new}
+      end
+
+      def self.item
+        new{|inp| inp.size == 0 ? Failed.new : Succeeded.new(inp[0], inp[1, inp.size - 1])}
+      end
+
+      def self.so(parser, &proc)
+        new{|inp|
+          case result = parser.parse(inp)
+          when Failed
+            result
+          when Succeeded
+            proc.call(result.parsed).parse(result.rest)
+          else
+            raise "error."
+          end
+        }
+      end
+
+      def self.either(parser1, parser2)
+        new{|inp|
+          case result = parser1.parse(inp)
+          when Failed
+            parser2.parse(inp)
+          when Succeeded
+            result
+          else
+            raise "error."
+          end
+        }
+      end
+
+      def self.discardl(parser1, parser2)
+        parser1 >> proc{parser2}
+      end
+
+      def self.discardr(parser1, parser2)
+        parser1 >> proc{|x|
+          parser2 >> proc{
+            ret(x)
+          }}
+      end
+
+      def self.separator(element_parser, separating_token_str)
+        element_parser >> proc{|x|
+          many(token_str(separating_token_str) + element_parser) >> proc{|xs|
+            ret([x] + xs)
+          }}
+      end
+
+      def self.separator_allow_empty(element_parser, separating_token_str)
+        separator(element_parser, separating_token_str) | ret([])
+      end
+
+      def self.optional(parser)
+        (parser >> proc{|x| ret([x])}) | ret([])
+      end
+
+      def self.many(parser)
+        many1(parser) | ret([])
+      end
+
+      def self.many1(parser)
+        parser >> proc{|x|
+          many(parser) >> proc{|xs|
+            ret([x] + xs)
+          }}
+      end
+
+      def self.sat(&proc)
+        item >> proc{|c|
+          proc.call(c) ? ret(c) : failure
+        }
+      end
+
+      def self.char(char)
+        sat{|c| c == char}
+      end
+
+      def self.any_char(x)
+        case x
+        when String
+          chars = x.cahrs.map{|c| char(c)}
+          if chars.length < 0
+            raise ParserDefinitionError.new
+          else
+            chars.inject(&:|)
+          end
+        when Range
+          chars = x.map{|c| char(c)}
+          if chars.length < 0
+            raise ParserDefinitionError.new
+          else
+            chars.inject(&:|)
+          end
+        else
+          raise ParserDefinitionError.new
+        end
+      end
+
+      def self.string(str)
+        if str.size == 0
+          ret(str)
+        else
+          char(str[0]) >> proc{|c|
+            string(str[1, str.size - 1]) >> proc{
+              ret(str)
+            }
+          }
+        end
+      end
+
+      def self.whitespace
+        many(char("\s") | char("\t")) >> proc{|ws|
+          ret(:whitespace)
+        }
+      end
+
+      def self.token(parser)
+        whitespace >> proc{
+          parser >> proc{|x|
+            whitespace >> proc{
+              ret(x)
+            }}}
+      end
+
+      def self.token_str(str)
+        token(string(str))
+      end
+
+      def self.binopl(parser, op_proc_parser)
+        rest = proc{|a|
+          op_proc_parser >> proc{|f|
+            parser >> proc{|b|
+              rest.call(f.call(a, b))
+            }} | ret(a)
+        }
+        parser >> proc{|a|
+          rest.call(a)
+        }
+      end
+
+      def self.parser(name, &proc)
+        @cache ||= {}
+        spcls = class << self; self end
+        spcls.send(:define_method, name) do |*args|
+          key = [name, args]
+          if @cache[key]
+            return @cache[key]
+          else
+            @cache[key] = self.new{}
+            @cache[key].f = proc.call(*args).f
+            return @cache[key]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/python/parser/expression.rb

@@ -0,0 +1,125 @@
+require 'python/parser/combinator'
+require 'python/parser/integer'
+require 'python/parser/identifier'
+require 'python/syntax'
+require 'python/builtins'
+
+module Python
+  module Parser
+    class ExpressionParser < Combinator
+
+      parser :expression do
+        conditional_expression
+      end
+
+      parser :conditional_expression do
+        or_test >> proc{|true_exp|
+          token_str("if") + or_test - token_str("else") >> proc{|cond|
+            expression >> proc{|false_exp|
+              ret(Syntax::Conditional.new(cond, true_exp, false_exp))
+            }} | ret(true_exp)
+          }
+      end
+
+      parser :or_test do # -> Expression
+        orop = token_str("or") + ret(proc{|l, r| Syntax::Or.new(l, r)})
+        binopl(and_test, orop)
+      end
+
+      parser :and_test do # -> Expression
+        andop = token_str("and") + ret(proc{|l, r| Syntax::And.new(l, r)})
+        binopl(not_test, andop)
+      end
+
+      parser :not_test do # -> Expression
+        token_str("not") + not_test >> proc{|exp|
+          ret(Syntax::Not.new(exp))
+        } | comparison
+      end
+
+      parser :comparison do # -> Expression
+        a_expr >> proc{|head|
+          many(comp_operator >> proc{|op| a_expr >> proc{|exp| ret([op, exp])}}) >> proc{|tail|
+            if tail.length == 0
+              ret(head)
+            else
+              exps = [head] + tail.map{|op, exp| exp}
+              ops = tail.map{|op, exp| op}
+              comps = exps.each_cons(2).zip(ops).map{|p, op| Syntax::BinaryOp.new(op, p[0], p[1])}
+              ret(comps.inject{|l, r| Syntax::And.new(l, r)})
+            end
+          }
+        }
+      end
+
+      parser :comp_operator do # -> Symbol
+        token_str("==") + ret("__eq__") |
+        token_str(">=") + ret("__ge__") |
+        token_str("<=") + ret("__le__") |
+        token_str("<")  + ret("__lt__") |
+        token_str(">")  + ret("__gt__") |
+        token_str("!=") + ret("__ne__")
+      end
+
+      parser :a_expr do # -> Expression
+        addop = token_str("+") + ret(lambda{|l, r| Syntax::BinaryOp.new("__add__", l, r)})
+        subop = token_str("-") + ret(lambda{|l, r| Syntax::BinaryOp.new("__sub__", l, r)})
+        binopl(m_expr, addop | subop)
+      end
+
+      parser :m_expr do # -> Expression
+        mulop = token_str("*") + ret(proc{|l, r| Syntax::BinaryOp.new("__mul__", l, r)})
+        fdivop = token_str("//") + ret(proc{|l, r| Syntax::BinaryOp.new("__floordiv__", l, r)})
+        binopl(u_expr, mulop | fdivop)
+      end
+
+      parser :u_expr do # -> Expression
+        posop = token_str("+") + ret("__pos__")
+        negop = token_str("-") + ret("__neg__")
+        (posop | negop) >> proc{|op_name|
+          u_expr >> proc{|exp|
+            ret(Syntax::UnaryOp.new(op_name, exp))
+          }} | primary
+      end
+
+      parser :primary do
+        atom >> proc{|at|
+          many(attributeref | call) >> proc{|ps|
+            ret(ps.inject(at){|a, p| p.call(a)})
+          }}
+      end
+
+      parser :attributeref do
+        token_str(".") + IdentifierParser.identifier >> proc{|ident|
+          ret(proc{|receiver| Syntax::AttrRef.new(receiver, ident)})
+        }
+      end
+
+      parser :call do # -> Apply
+        token_str("(") + positional_arguments - token_str(")") >> proc{|args|
+            ret(proc{|callee| Syntax::Apply.new(callee, args)})
+        }
+      end
+
+      parser :positional_arguments do # -> [Expression]
+        separator_allow_empty(expression, ",")
+      end
+
+      parser :atom do
+         identifier | integerliteral | parenth_form
+      end
+
+      parser :identifier do
+        IdentifierParser.identifier >> proc{|ident| ret(Syntax::RefIdentifier.new(ident))}
+      end
+
+      parser :integerliteral do
+        IntegerParser.integer >> proc{|n| ret(Syntax::LiteralObject.new(Builtins::Int.make_instance(n)))}
+      end
+
+      parser :parenth_form do
+        token_str("(") + expression - token_str(")")
+      end
+    end
+  end
+end