rubasteme 0.1.0

data/examples/sicp_scheme/primitives.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module SicpScheme
+
+  # primitive procedure for SICP Scheme
+
+  module Primitives
+    def cons(obj1, obj2)
+      [obj1, obj2]
+    end
+
+    def pair?(obj)
+      obj.instance_of?(Array)
+    end
+
+    def car(lis)
+      lis[0]
+    end
+
+    def cdr(lis)
+      lis[1..-1]
+    end
+
+    def list(*args)
+      args
+    end
+
+    def append(*args)
+      if args.empty?
+        []
+      else
+        args[0] + append(*args[1..-1])
+      end
+    end
+
+    def write(obj)
+      print obj
+    end
+
+    def display(obj)
+      write(obj)
+      print "\n"
+    end
+
+    def zero?(obj)
+      eqv?(obj, 0)
+    end
+
+    def a_calc(op, *args)
+      case args.size
+      when 0
+        0
+      when 1
+        args[0]
+      else
+        a_calc(op, args[0].send(op, args[1]), *args[2..-1])
+      end
+    end
+
+    def add(*args)
+      a_calc(:+, *args)
+    end
+
+    def subtract(*args)
+      a_calc(:-, *args)
+    end
+
+    def mul(*args)
+      a_calc(:*, *args)
+    end
+
+    def div(*args)
+      a_calc(:/, *args)
+    end
+
+    def mod(*args)
+      a_calc(:%, *args)
+    end
+
+    def scm_true
+      [:ast_boolean, "#t"]
+    end
+
+    def scm_false
+      [:ast_boolean, "#f"]
+    end
+
+    def c_calc(op, *args)
+      case args.size
+      when 0, 1
+        raise ArgumentError, args.to_s
+      when 2
+        args[0].send(op, args[1]) ? scm_true : scm_false
+      else
+        args[0].send(op, args[1]) and c_calc(op, *args[1..-1]) ? scm_true : scm_false
+      end
+    end
+
+    def lt?(*args)
+      c_calc(:<, *args)
+    end
+
+    def le?(*args)
+      c_calc(:<=, *args)
+    end
+
+    def gt?(*args)
+      c_calc(:>, *args)
+    end
+
+    def ge?(*args)
+      c_calc(:>=, *args)
+    end
+
+    def same_value?(*args)
+      c_calc(:==, *args)
+    end
+
+    def eqv?(obj1, obj2)
+      obj1 == obj2 ? scm_true : scm_false
+    end
+  end
+end

data/examples/sicp_scheme/printer.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module SicpScheme
+  class Printer
+    def initialize
+    end
+
+    def print(scm_obj)
+      pp scm_obj
+    end
+  end
+end

data/exe/rubasteme

@@ -0,0 +1,88 @@
+#!/usr/bin/env ruby
+
+require "pp"
+require "rubasteme"
+
+def version
+  "Rubasteme version: #{Rubasteme::VERSION} (#{Rubasteme::RELEASE})"
+end
+
+def usage
+  puts <<HELP
+usage:
+    rubasteme [option] [FILE]
+
+Reads the given files as a sequence of tokens, then print AST nodes.
+If no FILE is specified, then tries to read from the standard input.
+
+option:
+    -o, --output-file OUTPUT_FILE : specify the output file
+    -t, --format-type TYPE : specify the output format
+    -d, --debug   : specify to run verbosely
+    -v, --version : print version
+    -h, --help    : show this message
+
+input format:
+    Specify one of the following names:
+        ast, array
+HELP
+end
+
+def opt_parse(args, opts = {})
+  files = []
+  while args.size > 0
+    arg = args.shift
+    case arg
+    when "-o", "--output-file"
+      opts[:output_file] = args.shift
+    when "-t", "--format-type"
+      format_type = args.shift
+      raise ArgumentError, "not specified as format type" if format_type.nil?
+      opts[:format_type] = format_type.intern
+    when "-d", "--debug"
+      opts[:verbose] = true
+    when "-v", "--version"
+      puts version
+      exit 0
+    when "-h", "--help"
+      puts usage
+      exit 0
+    else                        # must be a filename
+      files << arg if arg
+    end
+  end
+  args.concat(files)
+  opts
+end
+
+opts = opt_parse(ARGV)
+if opts[:verbose]
+  puts version
+  format = opts[:format_type] || "default (token)"
+  puts "Input format: #{format}"
+  ofname = opts[:output_file] || "STDOUT"
+  puts "Output file: #{ofname}"
+end
+
+lines = []
+if ARGV.size > 0
+  lines = ARGF.entries.map{|s| s.delete_suffix("\n")}
+else
+  lines = STDIN.readlines(chomp: true)
+end
+
+tokens = lines.map{|e| Kernel.eval(e)}
+lexer = Rubasteme.lexer(tokens)
+parser = Rubasteme.parser(lexer)
+ast = parser.parse
+
+output = ""
+PP.pp(ast.to_a, output)
+
+form = opts[:format_type] || :token
+of = STDOUT
+of = File.open(opts[:output_file], "w") if opts[:output_file]
+
+of.puts(output)
+
+of.close

data/lib/rubasteme.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "rbscmlex"
+
+module Rubasteme
+
+  def self.lexer(obj)
+    Rbscmlex::Lexer.new(obj)
+  end
+
+  require_relative "rubasteme/error"
+  require_relative "rubasteme/utils"
+  require_relative "rubasteme/ast"
+  require_relative "rubasteme/parser"
+  require_relative "rubasteme/version"
+end

data/lib/rubasteme/ast.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Rubasteme
+
+  def self.write(ast_node, of = STDOUT)
+    of.puts ast_node.to_s
+  end
+
+  module AST
+
+    AST_NODE_TYPE = [           # :nodoc:
+      # leaf
+      :ast_empty_list,
+      :ast_boolean,
+      :ast_identifier,
+      :ast_character,
+      :ast_string,
+      :ast_number,
+      :ast_dot,
+      # branch
+      :ast_program,
+      :ast_list,
+      :ast_quotation,
+      :ast_procedure_call,
+      :ast_lambda_expression,
+      :ast_formals,
+      :ast_conditional,
+      :ast_assignment,
+      :ast_identifier_definition,
+      :ast_cond,
+      :ast_cond_clause,
+      :ast_case,
+      :ast_and,
+      :ast_or,
+      :ast_when,
+      :ast_unless,
+      :ast_let,
+      :ast_let_star,
+      :ast_letrec,
+      :ast_letrec_star,
+      :ast_bindings,
+      :ast_bind_spec,
+      :ast_begin,
+      :ast_do,
+      :ast_iteration_bindings,
+      :ast_test_and_do_result,
+      :ast_iteration_spec,
+      # misc.
+      :ast_illegal,
+    ]
+
+    def self.instantiate(ast_node_type, literal)
+      type_name = Utils.camel_case(ast_node_type.to_s.delete_prefix("ast_"))
+      klass = AST.const_get("#{type_name}Node")
+
+      if klass.nil? or klass == IllegalNode
+        IllegalNode.new(ast_node_type, literal)
+      else
+        klass.new(literal)
+      end
+    end
+
+    class Node
+      def initialize(_literal = nil)
+      end
+
+      def type
+        klass_name = self.class.name.split("::")[-1]
+        type_name = Utils.snake_case(klass_name.delete_suffix("Node"))
+        "ast_#{type_name}".intern
+      end
+
+      def to_a; []; end
+      def to_s; to_a.to_s; end
+    end
+
+    require_relative "ast/leaf_node"
+    require_relative "ast/branch_node"
+
+    class IllegalNode < Node
+      def initialize(type, literal)
+        super(literal)
+        @given_type = type
+        @literal = literal
+      end
+
+      def to_a
+        [type, @given_type, @literal]
+      end
+    end
+
+  end
+end

data/lib/rubasteme/ast/branch_node.rb

@@ -0,0 +1,514 @@
+# frozen_string_literal: true
+
+module Rubasteme
+
+  module AST
+
+    class BranchNode < Node
+      def initialize(initial_size = nil)
+        super(nil)
+        @nodes = initial_size.nil? ? [] : Array.new(initial_size)
+      end
+
+      def size
+        @nodes.size
+      end
+
+      def to_a
+        [type].concat(@nodes.map(&:to_a))
+      end
+
+      include Enumerable
+
+      def each(&blk)
+        if block_given?
+          @nodes.each(&blk)
+          self
+        else
+          @nodes.each
+        end
+      end
+
+      def [](index)
+        @nodes[index]
+      end
+
+      def []=(index, node)
+        @nodes[index] = node
+      end
+
+      def <<(node)
+        @nodes << node
+      end
+    end
+
+    class ProgramNode < BranchNode
+      def initialize(_ = nil)
+        super(nil)
+      end
+    end
+
+    class VectorNode < BranchNode
+      def initialize(_ = nil)
+        super(nil)
+      end
+    end
+
+    class ListNode < BranchNode
+      def initialize(_ = nil)
+        super(nil)
+      end
+    end
+
+    class QuotationNode < ListNode
+      def initialize(_ = nil)
+        super(nil)
+      end
+    end
+
+    class ProcedureCallNode < ListNode
+      def initialize(_ = nil)
+        # @nodes = [<operator>, <operand>*]
+        super(1)
+      end
+
+      def operator
+        @nodes[0]
+      end
+
+      def operator=(node)
+        @nodes[0] = node
+      end
+
+      def operands
+        @nodes[1..-1]
+      end
+
+      def add_operand(node)
+        @nodes << node
+      end
+    end
+
+    class LambdaExpressionNode < ListNode
+      def initialize(_ = nil)
+        # @nodes = [<formals>, <body>, ...]
+        super(1)
+      end
+
+      def formals
+        @nodes[0]
+      end
+
+      def formals=(node)
+        @nodes[0] = node
+      end
+
+      def body
+        @nodes[1..-1]
+      end
+
+      def body=(nodes)
+        nodes.each_with_index { |node, i|
+          @nodes[i + 1] = node
+        }
+      end
+    end
+
+    class FormalsNode < ListNode
+      def initialize(_ = nil)
+        # @nodes = [<identifier 1>, <identifier 2>, ... ]
+        super(nil)
+      end
+
+      def add_identifier(node)
+        @nodes << node
+      end
+    end
+
+    class ConditionalNode < ListNode
+      def initialize(_ = nil)
+        # @nodes = [<test>, <consequent>] or
+        #          [<test>, <consequent>, <alternate>]
+        super(1)
+      end
+
+      def test
+        @nodes[0]
+      end
+
+      def test=(node)
+        @nodes[0] = node
+      end
+
+      def consequent
+        @nodes[1]
+      end
+
+      def consequent=(node)
+        @nodes[1] = node
+      end
+
+      def alternate
+        @nodes[2]
+      end
+
+      def alternate=(node)
+        @nodes[2] = node
+      end
+
+      def alternate?
+        !@nodes[2].nil?
+      end
+    end
+
+    class AssignmentNode < ListNode
+      def initialize(_ = nil)
+        # @nodes = [<identifier>, <expression>]
+        super(2)
+      end
+
+      def identifier
+        @nodes[0]
+      end
+
+      def identifier=(node)
+        @nodes[0] = node
+      end
+
+      def expression
+        @nodes[1]
+      end
+
+      def expression=(node)
+        @nodes[1] = node
+      end
+    end
+
+    class IdentifierDefinitionNode < ListNode
+      def initialize(_ = nil)
+        # @nodes = [<identifier>, <expression>]
+        #   <expression> might be a lambda expression.
+        super(2)
+      end
+
+      def identifier
+        @nodes[0]
+      end
+
+      def identifier=(node)
+        @nodes[0] = node
+      end
+
+      def expression
+        @nodes[1]
+      end
+
+      def expression=(node)
+        @nodes[1] = node
+      end
+
+      def def_formals
+        lambda? ? expression.formals : nil
+      end
+
+      def body
+        lambda? ? expression.body : nil
+      end
+
+      private
+
+      def lambda?
+        expression.type == :ast_lambda_expression
+      end
+    end
+
+    class CondNode < ListNode
+      def initialize(_ = nil)
+        super(nil)
+      end
+
+      def cond_clause
+        @nodes[0..-1]
+      end
+
+      def add_clause(node)
+        @nodes << node
+      end
+    end
+
+    class CondClauseNode < ListNode
+      # @nodes = [<test>, <sequence>]
+      def initialize(_ = nil)
+        super(nil)
+      end
+
+      def test
+        @nodes[0]
+      end
+
+      def test=(node)
+        @nodes[0] = node
+      end
+
+      def sequence
+        @nodes[1..-1]
+      end
+
+      def add_expression(node)
+        @nodes << node
+      end
+    end
+
+    class AndNode < ListNode
+      def initialize(_ = nil)
+        # @nodes = [<test>, ...]
+        super(nil)
+      end
+    end
+
+    class OrNode < ListNode
+      def initialize(_ = nil)
+        # @nodes = [<test>, ...]
+        super(nil)
+      end
+    end
+
+    class TestAndSequenceNode < ListNode
+      def initialize(_ = nil)
+        super(1)
+      end
+
+      def test
+        @nodes[0]
+      end
+
+      def test=(node)
+        @nodes[0] = node
+      end
+
+      def sequence
+        @nodes[1..-1]
+      end
+
+      def add_sequence(node)
+        @nodes << node
+      end
+    end
+
+    class WhenNode < TestAndSequenceNode
+    end
+
+    class UnlessNode < TestAndSequenceNode
+    end
+
+    class LetNode < ListNode
+      def initialize(_ = nil)
+        # @nodes = [<bindings>, <body>, ...] or
+        #          [<identifier>, <bindings>, <body>, ...]
+        super(1)
+      end
+
+      def identifier
+        named_let? ? @nodes[0] : nil
+      end
+
+      def identifier=(node)
+        @nodes.insert(0, node) if node.type == :ast_identifier
+      end
+
+      def bindings
+        named_let? ? @nodes[1] : @nodes[0]
+      end
+
+      def bindings=(node)
+        if named_let?
+          @nodes[1] = node
+        else
+          @nodes[0] = node
+        end
+      end
+
+      def body
+        named_let? ? @nodes[2..-1] : @nodes[1..-1]
+      end
+
+      def body=(nodes)
+        start_pos = named_let? ? 2 : 1
+        nodes.each_with_index { |node, i|
+          @nodes[start_pos + i] = node
+        }
+      end
+
+      private
+
+      def named_let?
+        @nodes[0].nil? ? false : @nodes[0].type == :ast_identifier
+      end
+    end
+
+    class LetBaseNode < ListNode
+      def initialize(_ = nil)
+        # @nodes = [<bindings>, <body>, ...]
+        super(1)
+      end
+
+      def bindings
+        @nodes[0]
+      end
+
+      def bindings=(node)
+        @nodes[0] = node
+      end
+
+      def body
+        @nodes[1..-1]
+      end
+
+      def body=(nodes)
+        nodes.each_with_index { |node, i|
+          @nodes[1 + i] = node
+        }
+      end
+    end
+
+    class LetStarNode < LetBaseNode
+    end
+
+    class LetrecNode < LetBaseNode
+    end
+
+    class LetrecStarNode < LetBaseNode
+    end
+
+    class BindingsNode < ListNode
+      def initialize(_ = nil)
+        # @nodes = [<bind spec 1>, <bind spec 2> , ...]
+        super(nil)
+      end
+
+      def add_bind_spec(node)
+        @nodes << node
+      end
+    end
+
+    class BindSpecNode < ListNode
+      def initialize(_ = nil)
+        super(2)
+      end
+
+      def identifier
+        @nodes[0]
+      end
+
+      def identifier=(node)
+        @nodes[0] = node
+      end
+
+      def expression
+        @nodes[1]
+      end
+
+      def expression=(node)
+        @nodes[1] = node
+      end
+    end
+
+    class BeginNode < ListNode
+      def initialize(_ = nil)
+        super(nil)
+      end
+    end
+
+    class DoNode < ListNode
+      def initialize(_ = nil)
+        # @nodes = [<iteration bindings>, <test and do result>, <command>, ...]
+        super(2)
+      end
+
+      def iteration_bindings
+        @nodes[0]
+      end
+
+      def iteration_bindings=(node)
+        @nodes[0] = node
+      end
+
+      def test_and_do_result
+        @nodes[1]
+      end
+
+      def test_and_do_result=(node)
+        @nodes[1] = node
+      end
+
+      def commands
+        @nodes[2..-1]
+      end
+
+      def add_command(node)
+        @nodes << node
+      end
+    end
+
+    class IterationBindingsNode < ListNode
+      def initialize(_ = nil)
+        super(nil)
+      end
+
+      def add_iteration_spec(node)
+        @nodes << node
+      end
+    end
+
+    class TestAndDoResultNode < ListNode
+      def initialize(_ = nil)
+        super(1)
+      end
+
+      def test
+        @nodes[0]
+      end
+
+      def test=(node)
+        @nodes[0] = node
+      end
+
+      def add_expression(node)
+        @nodes << node
+      end
+    end
+
+    class IterationSpecNode < ListNode
+      def initialize(_ = nil)
+        # @nodes = [<identifier>, <init>, <step>]
+        super(3)
+      end
+
+      def identifier
+        @nodes[0]
+      end
+
+      def identifier=(node)
+        @nodes[0] = node
+      end
+
+      def init
+        @nodes[1]
+      end
+
+      def init=(node)
+        @nodes[1] = node
+      end
+
+      def step
+        @nodes[2]
+      end
+
+      def step=(node)
+        @nodes[2] = node
+      end
+    end
+
+  end                           # end of AST
+
+end