python 0.0.1

data/lib/python/parser/identifier.rb

@@ -0,0 +1,22 @@
+require 'python/parser/combinator'
+
+module Python
+  module Parser
+    class IdentifierParser < Combinator
+      parser :identifier do # -> String
+        token(xid_start >> proc{|head|
+          many(xid_continue) >> proc{|rests|
+            ret(head + rests.inject("", &:+))
+          }})
+      end
+
+      parser :xid_start do # -> Char (1-lenght String)
+        any_char("A".."Z") | any_char("a".."z") | char("_")
+      end
+
+      parser :xid_continue do # -> Char (1-lenght String)
+        xid_start | any_char("0".."9")
+      end
+    end
+  end
+end

data/lib/python/parser/indent_converter.rb

@@ -0,0 +1,52 @@
+module Python
+  module Parser
+    class IndentConverter
+      IndentConversionError = Class.new(RuntimeError)
+
+      INDENT = "$I"
+      DEDENT = "$D"
+      NEWLINE = "\n"
+
+      def convert(str)
+        stack = [0]
+        converted_lines = []
+        lines = str.gsub("\r\n", "\n").gsub("\r", "\n").split("\n") + [""]
+        lines.each do |line|
+          ilevel = indent_level(line)
+          if ilevel > stack.last
+            stack << ilevel
+            converted_lines << convert_line(line, INDENT)
+          elsif ilevel < stack.last
+            dedent_livel = 0
+            while ilevel < stack.last
+              dedent_livel += 1
+              stack.pop
+            end
+            unless ilevel == stack.last
+              raise IndentConversionError.new
+            end
+            converted_lines << convert_line(line, DEDENT * dedent_livel)
+          else
+            converted_lines << convert_line(line, "")
+          end
+        end
+        converted_lines.join(NEWLINE) + NEWLINE
+      end
+
+      def indent_level(line)
+        line.chars.take_while{|c| c == "\s" || c == "\t"}.inject(0) do |acc, c|
+          case c
+          when "\s"
+            acc + 1
+          when "\t"
+            acc - (acc % 8) + 8
+          end
+        end
+      end
+
+      def convert_line(line, token)
+        token + line.chars.drop_while{|c| c == "\s" || c == "\t"}.inject("", &:+)
+      end
+    end
+  end
+end

data/lib/python/parser/integer.rb

@@ -0,0 +1,28 @@
+require 'python/parser/combinator'
+
+module Python
+  module Parser
+    class IntegerParser < Combinator
+      parser :integer do # -> Integer
+        token(decimalinteger)
+      end
+
+      parser :decimalinteger do # -> Integer
+        nonzero = nonzerodigit >> proc{|head|
+          many(digit) >> proc{|tail|
+            ret((head + tail.inject("", &:+)).to_i)
+          }}
+        zero = many1(char("0")) >> proc{|zs| ret(0)}
+        nonzero | zero
+      end
+
+      parser :nonzerodigit do # -> Char (1-length String)
+        any_char("1".."9")
+      end
+
+      parser :digit do # -> Char (1-length String)
+        any_char("0".."9")
+      end
+    end
+  end
+end

data/lib/python/parser/statement.rb

@@ -0,0 +1,86 @@
+require 'python/parser/combinator'
+require 'python/syntax'
+require 'python/parser/identifier'
+
+module Python
+  module Parser
+    class StatementParser < Combinator
+
+      NEWLINE = token_str("\n")
+      INDENT = token_str("$I")
+      DEDENT = token_str("$D")
+
+      parser :file_input do # -> StatementList
+        many(NEWLINE | statement) >> proc{|stmts|
+          ret(Syntax::StatementList.new(stmts.select{|stmt| stmt.is_a?(Syntax::Statement)}))
+        }
+      end
+
+      parser :suite do # -> StatementList
+        stmt_list - NEWLINE | NEWLINE + INDENT + many1(statement) - many(NEWLINE) - DEDENT >> proc{|stmts|
+          ret(Syntax::StatementList.new(stmts))
+        }
+      end
+
+      parser :statement do # -> Statement
+        compound_stmt | stmt_list - NEWLINE
+      end
+
+      parser :compound_stmt do # -> Statement
+        classdef | funcdef
+      end
+
+      parser :funcdef do # -> Statement
+        token_str("def") + IdentifierParser.identifier - token_str("(") >> proc{|funcname|
+          separator_allow_empty(IdentifierParser.identifier, ",") - token_str(")") - token_str(":") >> proc{|params|
+            suite >> proc{|stmt|
+              ret(Syntax::Def.new(funcname, stmt, params))
+            }}}
+      end
+
+      parser :classdef do # -> Statement
+        token_str("class") + IdentifierParser.identifier >> proc{|classname|
+          ((token_str("(") + separator(ExpressionParser.expression, ",") - token_str(")")) | ret([])) - token_str(":") >> proc{|base_exps|
+            suite >> proc{|stmt|
+              ret(Syntax::ClassDef.new(classname, stmt, base_exps))
+            }}}
+      end
+
+      parser :stmt_list do # -> StatementList
+        separator(simple_stmt, ";") - (token_str(";") | ret(nil)) >> proc{|stmts|
+          ret(Syntax::StatementList.new(stmts))
+        }
+      end
+
+      parser :simple_stmt do # -> Statement
+        assignment_stmt | return_stmt | expression_stmt
+      end
+
+      parser :assignment_stmt do # -> Statement
+        ((IdentifierParser.identifier - token_str("=")) | (ExpressionParser::primary - token_str("="))) >> proc{|target|
+          ExpressionParser.expression >> proc{|exp|
+            case target
+            when String
+              ret(Syntax::AssignIdentifier.new(target, exp))
+            when Syntax::AttrRef
+              ret(Syntax::AssignAttr.new(target.receiver, target.attrname, exp))
+            else
+              p target
+              failure
+            end
+          }}
+      end
+
+      parser :return_stmt do # -> Statement
+        token_str("return") + (ExpressionParser.expression | ret(nil)) >> proc{|exp|
+            ret(Syntax::Return.new(exp))
+        }
+      end
+
+      parser :expression_stmt do
+        ExpressionParser.expression
+      end
+
+    end
+  end
+end

data/lib/python/pyobject.rb

@@ -0,0 +1,129 @@
+module Python
+  class PyObject < Hash
+    def initialize(attr={})
+      self.merge!(attr)
+    end
+
+    def make_instance(entity=nil, &entity_proc)
+      PyObject.new(:class => self, :entity => entity || entity_proc)
+    end
+
+    def entity
+      self[:entity]
+    end
+
+    def call(*args)
+      if self[:entity] && self[:entity].is_a?(Proc)
+        self[:entity].call(*args)
+      else
+        call_special_method("__call__", *args)
+      end
+    end
+
+    def call_special_method(method_name, *args)
+      get_special_attr(method_name).call(*args)
+    end
+
+    def get_special_attr(name)
+      if !self[:class]
+        raise "failed to get special attr #{name} from #{self}: #{self} doesn't have class"
+      elsif cls = self[:class].base_traverse{|cls| cls[name] && cls[name].datadescriptor?}
+        cls[name].get_get_method.call(cls[name], self, self[:class])
+      elsif cls = self[:class].base_traverse{|cls| cls[name]}
+        if cls[name].descriptor?
+          cls[name].get_get_method.call(cls[name], self, self[:class])
+        else
+          cls[name]
+        end
+      else
+        raise "failed to get special attr #{name} from #{self}: #{name} is not found"
+      end
+    end
+
+    def has_special_attr?(name)
+      get_special_attr(name)
+    rescue
+      nil
+    end
+
+    def get_attr(name)
+      if !self[:class]
+        raise "failed to get attr #{name} from #{self}: #{self} doesn't have class"
+      elsif cls = self[:class].base_traverse{|cls| cls[name] && cls[name].datadescriptor?}
+        cls[name].get_get_method.call(cls[name], self, self[:class])
+      elsif owner = self.base_traverse{|owner| owner[name]}
+        owner[name]
+      elsif cls = self[:class].base_traverse{|cls| cls[name]}
+        if cls[name].descriptor?
+          cls[name].get_get_method.call(cls[name], self, self[:class])
+        else
+          cls[name]
+        end
+      else
+        raise "failed to get attr #{name} from #{self}: #{name} is not found"
+      end
+    end
+
+    def has_attr?(name)
+      get_attr(name)
+    rescue
+      nil
+    end
+
+    def set_attr(name, pyobj)
+      if !self[:class]
+        raise "failed to set attr #{name} on #{self}: #{self} doesn't have class"
+      elsif cls = self[:class].base_traverse{|cls| cls[name] && cls[name].datadescriptor?}
+        cls[name].get_set_method.call(cls[name], self, pyobj)
+      else
+        self[name] = pyobj
+      end
+    end
+
+    def get_get_method
+      cls = self[:class].base_traverse{|cls| cls["__get__"]}
+      cls["__get__"]
+    end
+
+    def descriptor?
+      self[:class] && self[:class].base_traverse{|cls| cls["__get__"]}
+    end
+
+    def get_set_method
+      cls = self[:class].base_traverse{|cls| cls["__set__"] || cls["__delete__"]}
+      unless cls["__set__"]
+        raise "cannot set data on datadescriptor '#{cls}'"
+      else
+        cls["__set__"]
+      end
+    end
+
+    def datadescriptor?
+      descriptor? && self[:class].base_traverse{|cls| cls["__set__"] || cls["__delete__"]}
+    end
+
+    def base_traverse(&proc)
+      queue = [self]
+      until queue.empty?
+        cls = queue.pop
+        if judge = proc.call(cls)
+          return cls
+        end
+        queue += (cls[:bases] || [])
+      end
+      return nil
+    end
+
+    def inspect
+      if self[:name]
+        self[:name]
+      elsif self[:entity]
+        self[:entity].to_s
+      elsif self[:class] && self[:class][:name]
+        "<instance of:#{self[:class][:name]}"
+      else
+        super
+      end
+    end
+  end
+end

data/lib/python/repl.rb

@@ -0,0 +1,47 @@
+require 'python/parser/statement'
+require 'python/environment'
+
+module Python
+  class REPL
+    ParsingError = Class.new(RuntimeError)
+
+    def initialize(output)
+      @output = output
+      @env = Environment.new
+    end
+
+    def start
+      prompt
+    end
+
+    def read_eval_print(code)
+      print(eval(read(code)))
+    end
+
+    def read(code)
+      parser = Parser::StatementParser.stmt_list
+      result = parser.parse(code)
+      if result.is_a?(Parser::Succeeded) && result.rest.chomp == ""
+        result.parsed
+      else
+        raise ParsingError.new
+      end
+    end
+
+    def eval(exp)
+      exp.eval(@env)
+    end
+
+    def print(obj)
+      if obj == nil
+        @output.print ""
+      else
+        @output.puts obj.inspect
+      end
+    end
+
+    def prompt
+      @output.print "python.rb> "
+    end
+  end
+end

data/lib/python/syntax.rb

@@ -0,0 +1,201 @@
+require 'python/pyobject'
+require 'python/builtins'
+
+module Python
+  module Syntax
+    class Statement
+      def attrs
+        []
+      end
+
+      def eval_proc
+        proc{}
+      end
+
+      def initialize(*args)
+        min_argc = attrs.take_while{|attr| attr.is_a?(Symbol)}.count
+        max_argc = attrs.flatten.count
+        unless min_argc <= args.length && args.length <= max_argc
+          raise "Argument error: failed to make instance of #{self.class.name}." +
+                "expected: #{attrs}, actual: #{args}"
+        end
+        attrs.flatten.zip(args).each do |name, val|
+          instance_variable_set("@#{name}".to_sym, val)
+        end
+      end
+
+      def eval(env)
+        instance_exec(env, &eval_proc)
+      end
+
+      def ==(other)
+        self.class == other.class && attrs.flatten.all? do |vname|
+          ivname = "@#{vname}".to_sym
+          self.instance_variable_get(ivname) == other.instance_variable_get(ivname)
+        end
+      end
+    end
+    Expression = Class.new(Statement)
+
+    def self.stmt(*attrs, &eval)
+      define_element_type(Statement, *attrs, &eval)
+    end
+
+    def self.exp(*attrs, &eval)
+      define_element_type(Expression, *attrs, &eval)
+    end
+
+    def self.define_element_type(base, *attrs, &eval_proc)
+      cls = Class.new(base)
+      cls.send(:define_method, :attrs) { attrs }
+      cls.send(:define_method, :eval_proc) { eval_proc }
+      cls.send(:attr_reader, *attrs.flatten)
+      return cls
+    end
+
+    def self.draw_syntax_tree(val, depth=0)
+      case val
+      when  Statement
+        puts ("  " * depth) + "Node<#{val.class.name}>:"
+        val.attrs.flatten.each do |attrname|
+          puts ("  " * (depth + 1)) + "#{attrname}:"
+          draw_syntax_tree(val.instance_variable_get("@#{attrname}".to_sym), depth + 2)
+        end
+      when Array
+        val.each_with_index do |v, i|
+          puts ("  " * (depth + 1)) + "[#{i}]"
+          draw_syntax_tree(v, depth + 2)
+        end
+      else
+        puts ("  " * (depth + 1)) + val.to_s
+      end
+    end
+
+    # Exceptions possibly occurring when evaluating
+    PyBoolizeError = Class.new(RuntimeError)
+    PyNameError = Class.new(RuntimeError)
+    PyCallError = Class.new(RuntimeError)
+
+    def self.pytrue?(object)
+      boolized = object.call_special_method("__bool__")
+      if boolized == Builtins::True
+        return true
+      elsif boolized == Builtins::False
+        return false
+      else
+        raise PyBoolizeError.new
+      end
+    end
+
+    #--------------------
+    # AST-elements of Statements
+    #--------------------
+
+    StatementList = stmt(:stmts) do |env|
+      @stmts.inject(nil) do |acc, stmt|
+        stmt.eval(env)
+      end
+    end
+
+    AssignIdentifier = stmt(:name, :exp) do |env|
+      env.set(@name, @exp.eval(env))
+      nil
+    end
+
+    AssignAttr = stmt(:receiver, :attrname, :exp) do |env|
+      @receiver.eval(env).set_attr(@attrname, @exp.eval(env))
+      nil
+    end
+
+    Def = stmt(:name, :stat, :fix_param_names, [:rest_param_name]) do |env|
+      entity = {:fix_param_names => @fix_param_names,
+                :rest_param_name => @rest_param_name,
+                :stat => @stat,
+                :env => env.getlink}
+      env.set(@name, Builtins::Func.make_instance(entity))
+      nil
+    end
+
+    ClassDef = stmt(:name, :stat, :base_exps) do |env|
+      bases = @base_exps.map{|e| e.eval(env)}
+      klassenv = ClassEnvironment.new(:parent => env)
+      stat.eval(klassenv)
+      klass = PyObject.new(klassenv.merge(:class => Builtins::Type, :bases => bases))
+      env.set(@name, klass)
+      nil
+    end
+
+    Return = stmt([:exp]) do |env|
+      res = if @exp then @exp.eval(env) else Builtins::None end
+      throw :return, res
+    end
+
+    #--------------------
+    # AST-elements of Expressions
+    #--------------------
+
+    Apply = exp(:callee_exp, :arg_exps) do |env|
+      @callee_exp.eval(env).call(*@arg_exps.map{|e| e.eval(env)})
+    end
+
+    AttrRef = exp(:receiver, :attrname) do |env|
+      @receiver.eval(env).get_attr(@attrname)
+    end
+
+    RefIdentifier = exp(:name) do |env|
+      if res = env.resolve(@name)
+        res
+      else
+        raise PyNameError.new("Unbound variable: #{@name}")
+      end
+    end
+
+    Conditional = exp(:cond_exp, :true_exp, :false_exp) do |env|
+      if Syntax.pytrue?(@cond_exp.eval(env))
+        @true_exp.eval(env)
+      else
+        @false_exp.eval(env)
+      end
+    end
+
+    UnaryOp = exp(:op_name, :exp) do |env|
+      @exp.eval(env).call_special_method(@op_name)
+    end
+
+    BinaryOp = exp(:op_name, :left_exp, :right_exp) do |env|
+      left = @left_exp.eval(env)
+      right = @right_exp.eval(env)
+      left.call_special_method(@op_name, right)
+    end
+
+    And = exp(:left_exp, :right_exp) do |env|
+      left = @left_exp.eval(env)
+      if !Syntax.pytrue?(left)
+        left
+      else
+        @right_exp.eval(env)
+      end
+    end
+
+    Or = exp(:left_exp, :right_exp) do |env|
+      left = @left_exp.eval(env)
+      if Syntax.pytrue?(left)
+        left
+      else
+        @right_exp.eval(env)
+      end
+    end
+
+    Not = exp(:cond_exp) do |env|
+      if Syntax.pytrue?(@cond_exp.eval(env))
+        Builtins::False
+      else
+        Builtins::True
+      end
+    end
+
+    LiteralObject = exp(:object) do |env|
+      @object
+    end
+  end
+end