basic101 0.1.0

data/lib/basic101/program.rb

@@ -0,0 +1,100 @@
+module Basic101
+
+  class Program
+
+    include Enumerable
+
+    include Identity
+
+    attr_reader :statements
+
+    def self.load_file(source_path)
+      File.open(source_path, 'r') do |file|
+        load(file)
+      end
+    end
+
+    def self.load(source_file)
+      source = source_file.read
+      parser = Parser.new
+      transform = Transform.new
+      tree = parser.parse(source)
+      transform.apply(tree)
+    rescue Parslet::ParseFailed => error
+      line_number, column_number =
+        error.cause.source.line_and_column(error.cause.pos)
+      line = source.lines[line_number - 1]
+      raise SyntaxError.new(line, line_number, column_number, error.message)
+    end
+
+    def initialize(lines = [])
+      @statements = []
+      @line_number_index = {}
+      lines.each do |line|
+        @line_number_index[line.line_number] = @statements.size
+        @statements += line.statements
+      end
+      set_statement_indices
+      link_if_statements
+    end
+
+    def statement_count
+      @statements.size
+    end
+
+    def [](i)
+      @statements[i]
+    end
+
+    def index_of_line(line_number)
+      index = @line_number_index[line_number]
+      unless index
+        raise UndefinedLineNumberError, "Undefined line number #{line_number}"
+      end
+      index
+    end
+
+    def data_items(starting_line_number = nil)
+      if starting_line_number
+        statements = @statements.select do |statement|
+          statement.line_number >= starting_line_number
+        end
+      else
+        statements = @statements
+      end
+      statements.flat_map(&:data_items)
+    end
+
+    protected
+
+    def state
+      [@statements]
+    end
+
+    private
+
+    def link_if_statements
+      stack = []
+      @statements.each do |statement|
+        case statement
+        when IfStatement
+          stack.push statement
+        when ElseStatement
+          if_statement = stack.last
+          if_statement.else_statement = statement
+        when EndifStatement
+          if_statement = stack.pop
+          if_statement.end_statement = statement
+        end
+      end
+    end
+
+    def set_statement_indices
+      @statements.each.with_index do |statement, i|
+        statement.index = i
+      end
+    end
+
+  end
+
+end

data/lib/basic101/program_counter.rb

@@ -0,0 +1,52 @@
+module Basic101
+
+  class ProgramCounter
+
+    def initialize(program)
+      @program = program
+      @index = 0
+      @stack = []
+    end
+
+    def goto_next_statement
+      @index += 1
+    end
+
+    def end?
+      @index >= @program.statement_count
+    end
+
+    def goto_index(index)
+      @index = index
+    end
+
+    def goto_index_after(index)
+      goto_index(index + 1)
+    end
+
+    def goto_line(line_number)
+      goto_index @program.index_of_line(line_number)
+    end
+
+    def gosub_line(line_number)
+      @stack.push @index
+      goto_line line_number
+    end
+
+    def goto_end
+      @index = @program.statement_count + 1
+    end
+
+    def return
+      index = @stack.pop
+      raise ReturnWithoutGosub unless index
+      @index = index
+    end
+
+    def current_statement
+      @program[@index]
+    end
+
+  end
+
+end

data/lib/basic101/prompt_delimeter.rb

@@ -0,0 +1,13 @@
+module Basic101
+
+  class PromptDelimeter
+
+    include Identity
+
+    def print(output)
+      output.print '? '
+    end
+
+  end
+
+end

data/lib/basic101/randomize_statement.rb

@@ -0,0 +1,13 @@
+require_relative 'statement'
+
+module Basic101
+
+  class RandomizeStatement < Statement
+
+    def execute(runtime)
+      srand
+    end
+
+  end
+
+end

data/lib/basic101/read_statement.rb

@@ -0,0 +1,25 @@
+require_relative 'statement'
+
+module Basic101
+
+  class ReadStatement < Statement
+
+    def initialize(references)
+      @references = references
+    end
+
+    def execute(runtime)
+      @references.each do |reference|
+        reference.assign(runtime, runtime.get_data_item)
+      end
+    end
+
+    protected
+
+    def state
+      @references
+    end
+
+  end
+
+end

data/lib/basic101/reference.rb

@@ -0,0 +1,25 @@
+require_relative 'identity'
+
+module Basic101
+
+  class Reference
+
+    include Identity
+
+    def initialize(identifier)
+      @identifier = identifier
+    end
+
+    def input(input_reader)
+      @identifier.input(input_reader)
+    end
+
+    protected
+
+    def state
+      [@identifier]
+    end
+
+  end
+
+end

data/lib/basic101/remark_statement.rb

@@ -0,0 +1,12 @@
+require_relative 'statement'
+
+module Basic101
+
+  class RemarkStatement < Statement
+
+    def execute(runtime)
+    end
+
+  end
+
+end

data/lib/basic101/restore_statement.rb

@@ -0,0 +1,23 @@
+require_relative 'statement'
+
+module Basic101
+
+  class RestoreStatement < Statement
+
+    def initialize(line_number)
+      @line_number = line_number
+    end
+
+    def execute(runtime)
+      runtime.restore(@line_number.to_i)
+    end
+
+    protected
+
+    def state
+      [@line_number]
+    end
+
+  end
+
+end

data/lib/basic101/return_statement.rb

@@ -0,0 +1,16 @@
+require_relative 'statement'
+
+module Basic101
+
+  class ReturnStatement < Statement
+
+    def initialize
+    end
+
+    def execute(runtime)
+      runtime.return
+    end
+
+  end
+
+end

data/lib/basic101/right_function.rb

@@ -0,0 +1,19 @@
+module Basic101
+
+  class RightFunction < Function
+
+    def name
+      'RIGHT$'
+    end
+
+    def call(runtime, args)
+      check_args args, [BasicString, BasicNumeric]
+      string, count = *args
+      string = string.eval(runtime).to_string
+      count = count.eval(runtime).to_integer
+      string.right(count)
+    end
+
+  end
+
+end

data/lib/basic101/rnd_function.rb

@@ -0,0 +1,24 @@
+module Basic101
+
+  class RndFunction < Function
+
+    def initialize
+      @rand = 0
+    end
+
+    def name
+      'RND'
+    end
+
+    def call(runtime, args)
+      check_args args, [BasicNumeric]
+      new_number = args.first.eval(runtime).to_f > 0
+      if new_number
+        @rand = runtime.rand
+      end
+      BasicFloat.new(@rand)
+    end
+
+  end
+
+end

data/lib/basic101/runtime.rb

@@ -0,0 +1,132 @@
+module Basic101
+
+  class Runtime
+
+    attr_reader :input
+    attr_reader :output
+    attr_reader :for_stack
+
+    def initialize(args = {})
+      @output = Output.new(args.fetch(:output_file, $stdout))
+      @input = Input.new(@output, args.fetch(:input_file, $stdin))
+      @program = args.fetch(:program, Program.new)
+      @functions = Functions.new
+      @for_stack = ForStack.new
+      @random = Random.new(0)
+      @transcript = NullTranscript.new
+    end
+
+    def transcript=(transcript)
+      @transcript = transcript
+      @output.transcript = @transcript
+      @input.transcript = @transcript
+    end
+
+    def randomize
+      @random = Random.new
+    end
+
+    def rand
+      @random.rand
+    end
+
+    def goto_line(line_number)
+      @program_counter.goto_line(line_number)
+    end
+
+    def gosub_line(line_number)
+      @program_counter.gosub_line(line_number)
+    end
+
+    def return
+      @program_counter.return
+    end
+
+    def goto_index(index)
+      @program_counter.goto_index(index)
+    end
+
+    def goto_index_after(index)
+      @program_counter.goto_index_after(index)
+    end
+
+    def end_program
+      @program_counter.goto_end
+    end
+
+    def run
+      transcribe_errors do
+        reset
+        begin
+          while !@program_counter.end?
+            statement = @program_counter.current_statement
+            begin
+              @program_counter.goto_next_statement
+              statement.execute(self)
+            rescue StandardError => e
+              statement.raise_error_with_line_number(e)
+            end
+          end
+        end
+      end
+    end
+
+    def transcribe_errors
+      begin
+        yield
+      rescue Parslet::ParseFailed => e
+        @transcript.save_output_lines e
+        raise
+      rescue Basic101::Error => e
+        @transcript.save_output_lines e
+        raise
+      end
+    end
+
+    def function_exists?(identifier)
+      @functions.has_function?(identifier)
+    end
+
+    def call_function(identifier, argument_values)
+      @functions.call(self, identifier, argument_values)
+    end
+
+    def add_function(function)
+      @functions.add_function(function)
+    end
+
+    def get_scalar(identifier)
+      @scalars[identifier.to_s] ||= BasicInteger.new(0)
+    end
+
+    def set_scalar(identifier, value)
+      @scalars[identifier.to_s] = value
+    end
+
+    def get_array(identifier, num_dimensions) 
+      @arrays[identifier.to_s] ||=
+        BasicArray.new(num_dimensions, identifier.default)
+    end
+
+    def get_data_item
+      data_item = @data_items.shift
+      raise OutOfDataError unless data_item
+      data_item
+    end
+
+    def restore(line_number = nil)
+      @data_items = @program.data_items(line_number)
+    end
+
+    private
+
+    def reset
+      @scalars = {}
+      @arrays = {}
+      @program_counter = ProgramCounter.new(@program)
+      restore
+    end
+
+  end
+
+end

data/lib/basic101/scalar_reference.rb

@@ -0,0 +1,19 @@
+module Basic101
+
+  class ScalarReference < Reference
+
+    def eval(runtime)
+      if runtime.function_exists?(@identifier)
+        runtime.call_function(@identifier, [])
+      else
+        runtime.get_scalar(@identifier)
+      end
+    end
+
+    def assign(runtime, value)
+      runtime.set_scalar(@identifier, value)
+    end
+
+  end
+
+end

data/lib/basic101/sgn_function.rb

@@ -0,0 +1,17 @@
+module Basic101
+
+  class SgnFunction < Function
+
+    def name
+      'SGN'
+    end
+
+    def call(runtime, args)
+      check_args args, [BasicNumeric]
+      value = args.first.eval(runtime)
+      value.sgn
+    end
+
+  end
+
+end

data/lib/basic101/sin_function.rb

@@ -0,0 +1,17 @@
+module Basic101
+
+  class SinFunction < Function
+
+    def name
+      'SIN'
+    end
+
+    def call(runtime, args)
+      check_args args, [BasicNumeric]
+      value = args.first.eval(runtime)
+      value.sin
+    end
+
+  end
+
+end

data/lib/basic101/sqr_function.rb

@@ -0,0 +1,17 @@
+module Basic101
+
+  class SqrFunction < Function
+
+    def name
+      'SQR'
+    end
+
+    def call(runtime, args)
+      check_args args, [BasicNumeric]
+      value = args.first.eval(runtime)
+      value.sqr
+    end
+
+  end
+
+end

data/lib/basic101/statement.rb

@@ -0,0 +1,36 @@
+require_relative 'identity'
+
+module Basic101
+
+  class Statement
+
+    include Identity
+
+    attr_writer :index
+    attr_writer :line
+
+    def raise_error_with_line_number(exception)
+      message = "Error on line #{@line.line_number}: #{exception}"
+      raise exception, message, exception.backtrace
+    end
+
+    def data_items
+      []
+    end
+
+    def line_number
+      @line.line_number
+    end
+
+    def exec(runtime)
+    end
+
+    protected
+
+    def state
+      []
+    end
+
+  end
+
+end

data/lib/basic101/stop_statement.rb

@@ -0,0 +1,14 @@
+require_relative 'statement'
+
+module Basic101
+
+  class StopStatement < Statement
+
+    def execute(runtime)
+      runtime.output.puts "Break in line #{@line.line_number}"
+      runtime.end_program
+    end
+
+  end
+
+end

data/lib/basic101/str_function.rb

@@ -0,0 +1,16 @@
+module Basic101
+
+  class StrFunction < Function
+
+    def name
+      'STR$'
+    end
+
+    def call(runtime, args)
+      check_args args, [BasicObject]
+      args.first.eval(runtime).str
+    end
+
+  end
+
+end

data/lib/basic101/string_identifier.rb

@@ -0,0 +1,16 @@
+module Basic101
+
+  class StringIdentifier < Identifier
+
+    def input(input_parser)
+      value = input_parser.read_string
+      BasicString.new(value)
+    end
+
+    def default
+      BasicString.new('')
+    end
+
+  end
+
+end

data/lib/basic101/tab.rb

@@ -0,0 +1,18 @@
+module Basic101
+
+  class Tab
+
+    def initialize(column)
+      @column = column
+    end
+
+    def print_string(output)
+      output.tab_to(@column)
+    end
+
+    def print_new_line(output)
+    end
+
+  end
+
+end

data/lib/basic101/tab_function.rb

@@ -0,0 +1,17 @@
+module Basic101
+
+  class TabFunction < Function
+
+    def name
+      'TAB'
+    end
+
+    def call(runtime, args)
+      check_args args, [BasicNumeric]
+      column = args.first.eval(runtime).to_i
+      Tab.new(column)
+    end
+
+  end
+
+end

data/lib/basic101/tan_function.rb

@@ -0,0 +1,17 @@
+module Basic101
+
+  class TanFunction < Function
+
+    def name
+      'TAN'
+    end
+
+    def call(runtime, args)
+      check_args args, [BasicNumeric]
+      value = args.first.eval(runtime)
+      value.tan
+    end
+
+  end
+
+end