layo 1.0.0 → 1.1.0

data/README.mkd

@@ -5,7 +5,7 @@ Layo is a LOLCODE interpreter written in Ruby. It tries to conform to the
 everything described there. I purposely did not use any parser generators
 such as `Racc` for this project.
 
-Latest version is 1.0.0
+Latest version is 1.1.0
 
 # Usage
 
@@ -16,20 +16,43 @@ gem install layo
 layo program.lol
 ```
 
-If you don't want to install the gem, you can download sources, unzip somewhere
- and run from project's root:
+If you don't want to install the gem, you can download sources, extract somewhere
+ and run from the project's root:
 
 `bin/layo program.lol`
 
+Layo treats source files as UTF-8 encoded, if your file contains non-ascii
+characters, be sure to encode it as UTF-8.
+
+Without arguments Layo works in interactive mode, i.e. it executes statements
+read from a standard input. A sample session:
+
+```
+[galymzhan@g8host layo]$ bin/layo
+Layo version 1.1.0
+Press Control-C to exit
+ > VISIBLE "HAI WORLD!"
+HAI WORLD!
+ > I HAS A animal ITZ "cat"
+ > BOTH SAEM animal AN "cat", O RLY?
+YA RLY, VISIBLE "I HAV A CAT"
+NO WAI, VISIBLE "J00 SUX"
+OIC
+I HAV A CAT
+ > ^CExiting
+```
+
 Oh, and there are tests too. In order to run them, you have to install `mocha`:
-`gem install mocha`. Then go to project's root and execute `rake test`.
+`gem install mocha`. Then go to the project's root and execute `rake test`.
 
 # Requirements
 
 * Ruby >= 1.9.2
 * [Mocha](http://mocha.rubyforge.org/) for development
 
-# Example program
+# LOLCODE examples
+
+Classical hello world:
 
 ```
 HAI 1.2
@@ -37,6 +60,8 @@ VISIBLE "Hello world!"
 KTHXBYE
 ```
 
+For more examples see `examples` and `spec/source` directories.
+
 # Grammar
 
 Layo uses the following context-free grammar in Extended Backus-Naur Form

data/bin/layo

@@ -5,18 +5,22 @@ $:.unshift File.join(File.dirname(__FILE__), *%w[.. lib])
 require 'layo'
 
 if ARGV.empty?
-  puts 'Usage: layo [filename]'
-  exit
-end
-raise "File #{ARGV[0]} does not exist" unless File.exists?(ARGV[0])
-File.open(ARGV[0]) do |f|
-  parser = Layo::Parser.new(Layo::Tokenizer.new(Layo::Lexer.new(f)))
-  interpreter = Layo::Interpreter.new
-  begin
-    interpreter.interpret(parser.parse)
-  rescue Layo::SyntaxError => e
-    $stderr.puts "Syntax error: #{e}"
-  rescue Layo::RuntimeError => e
-    $stderr.puts "Runtime error: #{e}"
+  parser = Layo::Parser.new(Layo::Tokenizer.new(Layo::Lexer.new(STDIN)))
+  interpreter = Layo::InteractiveInterpreter.new(parser)
+  puts "Layo version #{Layo::VERSION}"
+  interpreter.interpret
+else
+  raise "File #{ARGV[0]} does not exist" unless File.exists?(ARGV[0])
+  File.open(ARGV[0]) do |f|
+    f.set_encoding(Encoding::UTF_8)
+    parser = Layo::Parser.new(Layo::Tokenizer.new(Layo::Lexer.new(f)))
+    interpreter = Layo::Interpreter.new
+    begin
+      interpreter.interpret(parser.parse)
+    rescue Layo::SyntaxError => e
+      $stderr.puts "Syntax error: #{e}"
+    rescue Layo::RuntimeError => e
+      $stderr.puts "Runtime error: #{e}"
+    end
   end
 end

data/examples/1.lol

@@ -0,0 +1,27 @@
+OBTW
+
+This is solution for the Problem 1 from Project Euler: http://projecteuler.net/problem=1
+
+Problem description:
+If we list all the natural numbers below 10 that are multiples of 3 or 5, 
+we get 3, 5, 6 and 9. The sum of these multiples is 23.
+Find the sum of all the multiples of 3 or 5 below 1000.
+
+TLDR
+
+HAI 1.2
+
+I HAS A result ITZ 0
+
+IM IN YR loop UPPIN YR i TIL BOTH SAEM i AN 1000 
+  EITHER OF ...
+    BOTH SAEM MOD OF i AN 3 AN 0 ...
+    AN BOTH SAEM MOD OF i AN 5 AN 0
+  O RLY?
+    YA RLY
+      result R SUM OF result AN i
+  OIC
+IM OUTTA YR loop
+
+VISIBLE "Result: " result
+KTHXBYE

data/examples/2.lol

@@ -0,0 +1,37 @@
+OBTW
+
+This is solution for the Problem 2 from Project Euler: http://projecteuler.net/problem=2
+
+Problem description:
+Each new term in the Fibonacci sequence is generated by adding the previous 
+two terms. By starting with 1 and 2, the first 10 terms will be:
+
+1, 2, 3, 5, 8, 13, 21, 34, 55, 89, ...
+
+By considering the terms in the Fibonacci sequence whose values do not exceed 
+four million, find the sum of the even-valued terms.
+
+TLDR
+
+HAI 1.2
+I HAS A a ITZ 1
+I HAS A b ITZ 2
+I HAS A result ITZ 2
+
+IM IN YR loop
+  b R SUM OF a AN b
+  a R DIFF OF b AN a
+  BOTH SAEM 0 AN MOD OF b AN 2, O RLY?
+    YA RLY
+      result R SUM OF result AN b
+  OIC
+
+  DIFFRINT b AN SMALLR OF b AN 4000000, O RLY?
+    YA RLY
+      GTFO
+  OIC
+IM OUTTA YR loop
+
+VISIBLE "Result: " result
+
+KTHXBYE

data/examples/3.lol

@@ -0,0 +1,30 @@
+OBTW
+This is solution for the '99 Bottles Of Beer' challenge from Code Golf:
+http://codegolf.com/99-bottles-of-beer
+TLDR
+
+HAI 1.2
+
+BTW recursive approach
+HOW DUZ I bottle YR count
+  BOTH SAEM count AN 1, O RLY?
+    YA RLY
+      VISIBLE "1 bottle of beer on the wall, 1 bottle of beer.:)" ...
+        "Go to the store and buy some more, 99 bottles of beer on the wall."
+    NO WAI
+      I HAS A newCount ITZ DIFF OF count AN 1
+      BOTH SAEM newCount AN 1, O RLY?
+        YA RLY
+          I HAS A s ITZ "1 bottle"
+        NO WAI
+          I HAS A s ITZ ":{newCount} bottles"
+      OIC
+      VISIBLE ":{count} bottles of beer on the wall, :{count} bottles of beer.:)" ...
+        "Take one down and pass it around, :{s} of beer on the wall.:)"
+      bottle newCount
+  OIC
+IF U SAY SO
+
+bottle 99
+
+KTHXBYE

data/layo.gemspec

@@ -2,11 +2,12 @@ require 'base64'
 
 Gem::Specification.new do |s|
   s.name = 'layo'
-  s.version = '1.0.0'
+  s.version = '1.1.0'
   s.summary = 'LOLCODE interpreter written in plain Ruby'
   s.description = <<-EOF
     Layo is a LOLCODE interpreter written in plain Ruby. It tries to conform to
     the LOLCODE 1.2 specification and supports everything described there.
+    Supports interactive mode.
   EOF
   s.required_ruby_version = '>= 1.9.2'
   s.add_development_dependency 'mocha', '~> 0.10.0'

data/lib/layo.rb

@@ -6,6 +6,12 @@ require_relative 'layo/peekable'
 require_relative 'layo/lexer'
 require_relative 'layo/tokenizer'
 require_relative 'layo/parser'
+require_relative 'layo/base_interpreter'
 require_relative 'layo/interpreter'
+require_relative 'layo/interactive_interpreter'
 require_relative 'layo/ast'
 require_relative 'layo/unicode'
+
+module Layo
+  VERSION = '1.1.0'
+end

data/lib/layo/base_interpreter.rb

@@ -0,0 +1,348 @@
+module Layo
+  class BaseInterpreter
+    attr_accessor :input, :output
+
+    def initialize(input = STDIN, output = STDOUT)
+      @input, @output = input, output
+    end
+
+    def create_variable_table
+      table = Hash.new do |hash, key|
+        raise RuntimeError, "Variable '#{key}' is not declared"
+      end
+      table['IT'] = { type: :noob, value: nil}
+      table
+    end
+
+    # Initializes empty function and variable tables
+    def init_tables
+      @functions = {}
+      @vtable = create_variable_table
+    end
+
+    # Runs piece of code inside guard to catch :break and :return thrown by
+    # illegal statements. Also assigns line numbers to RuntimeError's
+    def with_guard(&block)
+      begin
+        illegal = true
+        catch(:break) do
+          catch(:return) do
+            block.call
+            illegal = false
+          end
+          raise RuntimeError, "Illegal return statement" if illegal
+        end
+        raise RuntimeError, "Illegal break statement" if illegal
+      rescue RuntimeError => e
+        e.line = @stmt_line
+        raise e
+      end
+    end
+
+    def eval_block(block)
+      block.each do |stmt|
+        @stmt_line = stmt.line
+        send("eval_#{stmt.type}_stmt", stmt)
+      end
+    end
+
+    def eval_assignment_stmt(stmt)
+      # We should access by variable name first to ensure that it is defined
+      @vtable[stmt.identifier]
+      @vtable[stmt.identifier] = eval_expr(stmt.expression)
+    end
+
+    def eval_break_stmt(stmt)
+      throw :break
+    end
+
+    def eval_cast_stmt(stmt)
+      var = @vtable[stmt.identifier]
+      var[:value] = cast(var, stmt.to, false)
+      var[:type] = stmt.to
+    end
+
+    def eval_declaration_stmt(stmt)
+      if @vtable.has_key?(stmt.identifier)
+        raise RuntimeError, "Variable '#{stmt.identifier}' is already declared"
+      end
+      @vtable[stmt.identifier] = { type: :noob, value: nil }
+      unless stmt.initialization.nil?
+        @vtable[stmt.identifier] = eval_expr(stmt.initialization)
+      end
+    end
+
+    def eval_expression_stmt(stmt)
+      @vtable['IT'] = eval_expr(stmt.expression)
+    end
+
+
+    def eval_condition_stmt(stmt)
+      if cast(@vtable['IT'], :troof)
+        # if block
+        eval_block(stmt.then)
+      else
+        # else if blocks
+        condition_met = false
+        stmt.elseif.each do |elseif|
+          condition = eval_expr(elseif[:condition])
+          if condition_met = cast(condition, :troof)
+            eval_block(elseif[:block])
+            break
+          end
+        end
+        unless condition_met || stmt.else.nil?
+          # else block
+          eval_block(stmt.else)
+        end
+      end
+    end
+
+    def eval_input_stmt(stmt)
+      @vtable[stmt.identifier] = { type: :yarn, value: @input.gets }
+    end
+
+    def eval_loop_stmt(stmt)
+      unless stmt.op.nil?
+        # Backup any local variable if its name is the same as the counter
+        # variable's name
+        if @vtable.has_key?(stmt.counter)
+          var_backup = @vtable[stmt.counter]
+        end
+        @vtable[stmt.counter] = { type: :numbr, value: 0 }
+        update_op = if stmt.op == :uppin
+          lambda { @vtable[stmt.counter][:value] += 1 }
+        elsif stmt.op == :nerfin
+          lambda { @vtable[stmt.counter][:value] -= 1 }
+        else
+          lambda {
+            @vtable[stmt.counter] = call_func(stmt.op, [@vtable[stmt.counter]])
+          }
+        end
+      end
+
+      catch :break do
+        while true
+          unless stmt.guard.nil?
+            condition_met = cast(eval_expr(stmt.guard[:expression]), :troof)
+            if (stmt.guard[:type] == :wile && !condition_met) or
+               (stmt.guard[:type] == :til && condition_met)
+               throw :break
+            end
+          end
+          eval_block(stmt.block)
+          update_op.call if update_op
+        end
+      end
+      # Restore backed up variable
+      unless stmt.op.nil? || var_backup.nil?
+        @vtable[stmt.counter] = var_backup
+      end
+    end
+
+    def eval_print_stmt(stmt)
+      text = ''
+      # todo rewrite using map or similar
+      stmt.expressions.each do |expr|
+        text << cast(eval_expr(expr), :yarn)
+      end
+      text << "\n" unless stmt.suppress
+      @output.print(text)
+    end
+
+    def eval_return_stmt(stmt)
+      throw :return, eval_expr(stmt.expression)
+    end
+
+    def eval_switch_stmt(stmt)
+      stmt.cases.combination(2) do |c|
+        raise RuntimeError, 'Literals must be unique' if c[0] == c[1]
+      end
+      case_found = false
+      it = @vtable['IT']
+      stmt.cases.each do |kase|
+        unless case_found
+          literal = eval_expr(kase[:expression])
+          if it == literal
+            case_found = true
+          end
+        end
+        if case_found
+          breaked = true
+          catch :break do
+            eval_block(kase[:block])
+            breaked = false
+          end
+          break if breaked
+        end
+      end
+      unless case_found || stmt.default.nil?
+        catch :break do
+          eval_block(stmt.default)
+        end
+      end
+    end
+
+    # Casts given variable 'var' into type 'to'
+    # Returns only value part of the variable, type will be 'to' anyway
+    def cast(var, to, implicit = true)
+      return var[:value] if var[:type] == to
+      return nil if to == :noob
+      case var[:type]
+        when :noob
+          if implicit && to != :troof
+            raise RuntimeError, "NOOB cannot be implicitly cast into #{to.to_s.upcase}"
+          end
+          return false if to == :troof
+          return 0 if to == :numbr
+          return 0.0 if to == :numbar
+          return ''
+        when :troof
+          return (var[:value] ? 1 : 0) if to == :numbr
+          return (var[:value] ? 1.0 : 0.0) if to == :numbar
+          return (var[:value] ? 'WIN' : 'FAIL')
+        when :numbr
+          return (var[:value].zero? ? false : true) if to == :troof
+          return var[:value].to_f if to == :numbar
+          return var[:value].to_s
+        when :numbar
+          return (var[:value].zero? ? false : true) if to == :troof
+          return var[:value].to_int if to == :numbr
+          # Truncate to 2 digits after decimal point
+          return ((var[:value] * 100).floor / 100.0).to_s
+        else
+          return !var[:value].empty? if to == :troof
+          if to == :numbr
+            return var[:value].to_i if var[:value].lol_integer?
+            raise RuntimeError, "'#{var[:value]}' is not a valid integer"
+          end
+          return var[:value].to_f if var[:value].lol_float?
+          raise RuntimeError, "'#{var[:value]}' is not a valid float"
+      end
+    end
+
+    def eval_expr(expr)
+      send("eval_#{expr.type}_expr", expr)
+    end
+
+    def eval_binary_expr(expr)
+      l = eval_expr(expr.left)
+      r = eval_expr(expr.right)
+      methods = {
+        :sum_of => :+, :diff_of => :-, :produkt_of => :*, :quoshunt_of => :/,
+        :mod_of => :modulo, :both_of => :&, :either_of => :|, :won_of => :^,
+        :both_saem => :==, :diffrint => :!=
+      }
+      case expr.operator
+        when :sum_of, :diff_of, :produkt_of, :quoshunt_of, :mod_of, :biggr_of, :smallr_of
+          type = l[:type] == :numbar || r[:type] == :numbar ||
+            (l[:type] == :yarn && l[:value].lol_float?) ||
+            (r[:type] == :yarn && r[:value].lol_float?) ? :numbar : :numbr
+          l, r = cast(l, type), cast(r, type)
+          if expr.operator == :biggr_of
+            value = [l, r].max
+          elsif expr.operator == :smallr_of
+            value = [l, r].min
+          else
+            value = l.send(methods[expr.operator], r)
+          end
+        when :both_saem, :diffrint
+          type = :troof
+          if (l[:type] == :numbr && r[:type] == :numbar) ||
+            (l[:type] == :numbar && r[:type] == :numbr)
+            l, r = cast(l, :numbar), cast(r, :numbar)
+          elsif l[:type] != r[:type]
+            raise RuntimeError, 'Operands must have same type'
+          end
+          value = l.send(methods[expr.operator], r)
+        else
+          type = :troof
+          l, r = cast(l, :troof), cast(r, :troof)
+          value = l.send(methods[expr.operator], r)
+      end
+      { type: type, value: value }
+    end
+
+    def eval_cast_expr(expr)
+      casted_expr = eval_expr(expr.being_casted)
+      { type: expr.to, value: cast(casted_expr, expr.to, false) }
+    end
+
+    def eval_constant_expr(expr)
+      mapping = { boolean: :troof, string: :yarn, integer: :numbr, float: :numbar }
+      value = expr.vtype == :string ? interpolate_string(expr.value) : expr.value
+      { type: mapping[expr.vtype], value: value }
+    end
+
+    def eval_function_expr(expr)
+      parameters = []
+      expr.parameters.each do |param|
+        parameters << eval_expr(param)
+      end
+      call_func(expr.name, parameters)
+    end
+
+    def call_func(name, arguments)
+      function = @functions[name]
+      # Replace variable table by 'clean' variable table inside functions
+      old_table = @vtable
+      @vtable = create_variable_table
+      function[:args].each_index do |index|
+        @vtable[function[:args][index]] = arguments[index]
+      end
+      retval = nil
+      retval = catch :return do
+        breaked = true
+        catch(:break) do
+          eval_block(function[:block])
+          breaked = false
+        end
+        retval = { type: :noob, value: nil } if breaked
+      end
+      retval = @vtable['IT'] if retval.nil?
+      @vtable = old_table
+      retval
+    end
+
+    def eval_nary_expr(expr)
+      case expr.operator
+        when :all_of
+          type, value = :troof, true
+          expr.expressions.each do |operand|
+            unless cast(eval_expr(operand), :troof)
+              value = false
+              break
+            end
+          end
+        when :any_of
+          type, value = :troof, false
+          expr.expressions.each do |operand|
+            if cast(eval_expr(operand), :troof)
+              value = true
+              break
+            end
+          end
+        when :smoosh
+          type, value = :yarn, ''
+          expr.expressions.each do |operand|
+            value << cast(eval_expr(operand), :yarn)
+          end
+      end
+      { type: type, value: value }
+    end
+
+    def eval_unary_expr(expr)
+      # the only unary op in LOLCODE is NOT
+      { type: :troof, value: !cast(eval_expr(expr.expression), :troof) }
+    end
+
+    def eval_variable_expr(expr)
+      @vtable[expr.name]
+    end
+
+    # Interpolates values of variables in the string
+    def interpolate_string(str)
+      str.gsub(/:\{([a-zA-Z]\w*)\}/) { cast(@vtable[$1], :yarn, false) }
+    end
+  end
+end

data/lib/layo/interactive_interpreter.rb

@@ -0,0 +1,42 @@
+module Layo
+  class InteractiveInterpreter < BaseInterpreter
+    attr_accessor :parser
+
+    def initialize(parser)
+      @parser = parser
+      super
+    end
+
+    def interpret
+      init_tables
+      @stmt_line = 1
+      @output.puts 'Press Control-C to exit'
+      while true
+        begin
+          @output.print ' > '
+          break if @parser.tokenizer.try(:eof)
+          begin
+            statement = @parser.parse_statement
+            with_guard { send("eval_#{statement.type}_stmt", statement) }
+          end until @parser.tokenizer.lexer.buffer_empty?
+        rescue Layo::SyntaxError => e
+          @parser.tokenizer.reset
+          @parser.tokenizer.lexer.reset
+          $stderr.puts "Syntax error: #{e}"
+        rescue Layo::RuntimeError => e
+          $stderr.puts "Runtime error: #{e}"
+        rescue Interrupt
+          @output.puts 'Exiting'
+          break
+        end
+      end
+    end
+
+    def eval_function_stmt(stmt)
+      if @functions.has_key?(stmt.name)
+        raise RuntimeError, "Function '#{stmt.name}' is already declared"
+      end
+      @functions[stmt.name] = { args: stmt.args, block: stmt.block }
+    end
+  end
+end

data/lib/layo/interpreter.rb

@@ -1,16 +1,10 @@
 module Layo
-  class Interpreter
-    attr_accessor :input, :output
-
-    def initialize(input = STDIN, output = STDOUT)
-      @input, @output = input, output
-    end
-
+  class Interpreter < BaseInterpreter
     # Interprets program given as an AST node
     def interpret(program)
       # We should gather all function definitions along with their bodies
       # beforehand so we could call them wherever a call appears
-      @functions = {}
+      init_tables
       program.block.each do |statement|
         if statement.type == 'function'
           @functions[statement.name] = {
@@ -21,340 +15,11 @@ module Layo
       eval_program(program)
     end
 
-    def create_variable_table
-      table = Hash.new do |hash, key|
-        raise RuntimeError, "Variable '#{key}' is not declared"
-      end
-      table['IT'] = { type: :noob, value: nil}
-      table
-    end
-
     def eval_program(program)
-      @vtable = create_variable_table
-      begin
-        illegal = true
-        catch(:break) do
-          catch(:return) do
-            eval_block(program.block)
-            illegal = false
-          end
-          raise RuntimeError, "Illegal return statement" if illegal
-        end
-        raise RuntimeError, "Illegal break statement" if illegal
-      rescue RuntimeError => e
-        e.line = @stmt_line
-        raise e
-      end
-    end
-
-    def eval_block(block)
-      block.each do |stmt|
-        @stmt_line = stmt.line
-        send("eval_#{stmt.type}_stmt", stmt)
-      end
-    end
-
-    def eval_assignment_stmt(stmt)
-      # We should access by variable name first to ensure that it is defined
-      @vtable[stmt.identifier]
-      @vtable[stmt.identifier] = eval_expr(stmt.expression)
-    end
-
-    def eval_break_stmt(stmt)
-      throw :break
-    end
-
-    def eval_cast_stmt(stmt)
-      var = @vtable[stmt.identifier]
-      var[:value] = cast(var, stmt.to, false)
-      var[:type] = stmt.to
-    end
-
-    def eval_declaration_stmt(stmt)
-      if @vtable.has_key?(stmt.identifier)
-        raise RuntimeError, "Variable '#{stmt.identifier}' is already declared"
-      end
-      @vtable[stmt.identifier] = { type: :noob, value: nil }
-      unless stmt.initialization.nil?
-        @vtable[stmt.identifier] = eval_expr(stmt.initialization)
-      end
-    end
-
-    def eval_expression_stmt(stmt)
-      @vtable['IT'] = eval_expr(stmt.expression)
+      with_guard { eval_block(program.block) }
     end
 
+    # Don't do anything because function table is already ready
     def eval_function_stmt(stmt); end
-
-    def eval_condition_stmt(stmt)
-      if cast(@vtable['IT'], :troof)
-        # if block
-        eval_block(stmt.then)
-      else
-        # else if blocks
-        condition_met = false
-        stmt.elseif.each do |elseif|
-          condition = eval_expr(elseif[:condition])
-          if condition_met = cast(condition, :troof)
-            eval_block(elseif[:block])
-            break
-          end
-        end
-        unless condition_met || stmt.else.nil?
-          # else block
-          eval_block(stmt.else)
-        end
-      end
-    end
-
-    def eval_input_stmt(stmt)
-      @vtable[stmt.identifier] = { type: :yarn, value: @input.gets }
-    end
-
-    def eval_loop_stmt(stmt)
-      unless stmt.op.nil?
-        # Backup any local variable if its name is the same as the counter
-        # variable's name
-        if @vtable.has_key?(stmt.counter)
-          var_backup = @vtable[stmt.counter]
-        end
-        @vtable[stmt.counter] = { type: :numbr, value: 0 }
-        update_op = if stmt.op == :uppin
-          lambda { @vtable[stmt.counter][:value] += 1 }
-        elsif stmt.op == :nerfin
-          lambda { @vtable[stmt.counter][:value] -= 1 }
-        else
-          lambda {
-            @vtable[stmt.counter] = call_func(stmt.op, [@vtable[stmt.counter]])
-          }
-        end
-      end
-
-      catch :break do
-        while true
-          unless stmt.guard.nil?
-            condition_met = cast(eval_expr(stmt.guard[:expression]), :troof)
-            if (stmt.guard[:type] == :wile && !condition_met) or
-               (stmt.guard[:type] == :til && condition_met)
-               throw :break
-            end
-          end
-          eval_block(stmt.block)
-          update_op.call if update_op
-        end
-      end
-      # Restore backed up variable
-      unless stmt.op.nil? || var_backup.nil?
-        @vtable[stmt.counter] = var_backup
-      end
-    end
-
-    def eval_print_stmt(stmt)
-      text = ''
-      # todo rewrite using map or similar
-      stmt.expressions.each do |expr|
-        text << cast(eval_expr(expr), :yarn)
-      end
-      if stmt.suppress
-        @output.print text
-      else
-        @output.puts text
-      end
-    end
-
-    def eval_return_stmt(stmt)
-      throw :return, eval_expr(stmt.expression)
-    end
-
-    def eval_switch_stmt(stmt)
-      stmt.cases.combination(2) do |c|
-        raise RuntimeError, 'Literals must be unique' if c[0] == c[1]
-      end
-      case_found = false
-      it = @vtable['IT']
-      stmt.cases.each do |kase|
-        unless case_found
-          literal = eval_expr(kase[:expression])
-          if it == literal
-            case_found = true
-          end
-        end
-        if case_found
-          breaked = true
-          catch :break do
-            eval_block(kase[:block])
-            breaked = false
-          end
-          break if breaked
-        end
-      end
-      unless case_found || stmt.default.nil?
-        catch :break do
-          eval_block(stmt.default)
-        end
-      end
-    end
-
-    # Casts given variable 'var' into type 'to'
-    # Returns only value part of the variable, type will be 'to' anyway
-    def cast(var, to, implicit = true)
-      return var[:value] if var[:type] == to
-      return nil if to == :noob
-      case var[:type]
-        when :noob
-          if implicit && to != :troof
-            raise RuntimeError, "NOOB cannot be implicitly cast into #{to.to_s.upcase}"
-          end
-          return false if to == :troof
-          return 0 if to == :numbr
-          return 0.0 if to == :numbar
-          return ''
-        when :troof
-          return (var[:value] ? 1 : 0) if to == :numbr
-          return (var[:value] ? 1.0 : 0.0) if to == :numbar
-          return (var[:value] ? 'WIN' : 'FAIL')
-        when :numbr
-          return (var[:value].zero? ? false : true) if to == :troof
-          return var[:value].to_f if to == :numbar
-          return var[:value].to_s
-        when :numbar
-          return (var[:value].zero? ? false : true) if to == :troof
-          return var[:value].to_int if to == :numbr
-          # Truncate to 2 digits after decimal point
-          return ((var[:value] * 100).floor / 100.0).to_s
-        else
-          return !var[:value].empty? if to == :troof
-          if to == :numbr
-            return var[:value].to_i if var[:value].lol_integer?
-            raise RuntimeError, "'#{var[:value]}' is not a valid integer"
-          end
-          return var[:value].to_f if var[:value].lol_float?
-          raise RuntimeError, "'#{var[:value]}' is not a valid float"
-      end
-    end
-
-    def eval_expr(expr)
-      send("eval_#{expr.type}_expr", expr)
-    end
-
-    def eval_binary_expr(expr)
-      l = eval_expr(expr.left)
-      r = eval_expr(expr.right)
-      methods = {
-        :sum_of => :+, :diff_of => :-, :produkt_of => :*, :quoshunt_of => :/,
-        :mod_of => :modulo, :both_of => :&, :either_of => :|, :won_of => :^,
-        :both_saem => :==, :diffrint => :!=
-      }
-      case expr.operator
-        when :sum_of, :diff_of, :produkt_of, :quoshunt_of, :mod_of, :biggr_of, :smallr_of
-          type = l[:type] == :numbar || r[:type] == :numbar ||
-            (l[:type] == :yarn && l[:value].lol_float?) ||
-            (r[:type] == :yarn && r[:value].lol_float?) ? :numbar : :numbr
-          l, r = cast(l, type), cast(r, type)
-          if expr.operator == :biggr_of
-            value = [l, r].max
-          elsif expr.operator == :smallr_of
-            value = [l, r].min
-          else
-            value = l.send(methods[expr.operator], r)
-          end
-        when :both_saem, :diffrint
-          type = :troof
-          if (l[:type] == :numbr && r[:type] == :numbar) ||
-            (l[:type] == :numbar && r[:type] == :numbr)
-            l, r = cast(l, :numbar), cast(r, :numbar)
-          elsif l[:type] != r[:type]
-            raise RuntimeError, 'Operands must have same type'
-          end
-          value = l.send(methods[expr.operator], r)
-        else
-          type = :troof
-          l, r = cast(l, :troof), cast(r, :troof)
-          value = l.send(methods[expr.operator], r)
-      end
-      { type: type, value: value }
-    end
-
-    def eval_cast_expr(expr)
-      casted_expr = eval_expr(expr.being_casted)
-      { type: expr.to, value: cast(casted_expr, expr.to, false) }
-    end
-
-    def eval_constant_expr(expr)
-      mapping = { boolean: :troof, string: :yarn, integer: :numbr, float: :numbar }
-      value = expr.vtype == :string ? interpolate_string(expr.value) : expr.value
-      { type: mapping[expr.vtype], value: value }
-    end
-
-    def eval_function_expr(expr)
-      parameters = []
-      expr.parameters.each do |param|
-        parameters << eval_expr(param)
-      end
-      call_func(expr.name, parameters)
-    end
-
-    def call_func(name, arguments)
-      function = @functions[name]
-      # Replace variable table by 'clean' variable table inside functions
-      old_table = @vtable
-      @vtable = create_variable_table
-      function[:args].each_index do |index|
-        @vtable[function[:args][index]] = arguments[index]
-      end
-      retval = nil
-      retval = catch :return do
-        breaked = true
-        catch(:break) do
-          eval_block(function[:block])
-          breaked = false
-        end
-        retval = { type: :noob, value: nil } if breaked
-      end
-      retval = @vtable['IT'] if retval.nil?
-      @vtable = old_table
-      retval
-    end
-
-    def eval_nary_expr(expr)
-      case expr.operator
-        when :all_of
-          type, value = :troof, true
-          expr.expressions.each do |operand|
-            unless cast(eval_expr(operand), :troof)
-              value = false
-              break
-            end
-          end
-        when :any_of
-          type, value = :troof, false
-          expr.expressions.each do |operand|
-            if cast(eval_expr(operand), :troof)
-              value = true
-              break
-            end
-          end
-        when :smoosh
-          type, value = :yarn, ''
-          expr.expressions.each do |operand|
-            value << cast(eval_expr(operand), :yarn)
-          end
-      end
-      { type: type, value: value }
-    end
-
-    def eval_unary_expr(expr)
-      # the only unary op in LOLCODE is NOT
-      { type: :troof, value: !cast(eval_expr(expr.expression), :troof) }
-    end
-
-    def eval_variable_expr(expr)
-      @vtable[expr.name]
-    end
-
-    # Interpolates values of variables in the string
-    def interpolate_string(str)
-      str.gsub(/:\{([a-zA-Z]\w*)\}/) { cast(@vtable[$1], :yarn, false) }
-    end
   end
 end

data/lib/layo/lexer.rb

@@ -38,7 +38,7 @@ module Layo
     def next_item
       return @last_lexeme if @last_lexeme[0].nil?
       while true
-        @line = next_line if @line_no.zero? || @pos > @line.length - 1
+        @line = next_line if buffer_empty?
         if @line.nil?
           lexeme = [nil, @line_no, 1]
           break
@@ -158,5 +158,10 @@ module Layo
           end
         end
     end
+
+    # Returns true if input buffer is fully processed
+    def buffer_empty?
+      @line_no.zero? || @pos > @line.length - 1
+    end
   end
 end

data/lib/layo/parser.rb

@@ -100,9 +100,13 @@ module Layo
       nil
     end
 
-    def parse_statement(name)
+    def parse_statement(name = nil)
       token = @tokenizer.peek
       @tokenizer.unpeek
+      name = next_statement unless name
+      unless name
+        raise SyntaxError.new(token[:line], token[:pos], 'Expected statement')
+      end
       statement = send("parse_#{name}_statement".to_sym)
       expect_token(:newline)
       statement.line = token[:line]

data/lib/layo/tokenizer.rb

@@ -69,8 +69,6 @@ module Layo
         end
         root[lexemes.last] = { match: t.gsub(' ', '_').downcase.to_sym }
       end
-      @token_table[:list]["\n"] = { match: :newline }
-      @token_table[:list]['!'] = { match: :exclamation }
     end
 
     def match_longest(lexeme, root)
@@ -98,6 +96,10 @@ module Layo
         token = { type: :float, data: lexeme[0].to_f }
       elsif lexeme[0].lol_boolean?
         token = { type: :boolean, data: (lexeme[0] == 'WIN') }
+      elsif lexeme[0] == '!'
+        token = { type: :exclamation }
+      elsif lexeme[0] == "\n"
+        token = { type: :newline }
       else
         # Try to match keyword
         token_type = match_longest(lexeme[0], @token_table)

data/spec/interpreter_spec.rb

@@ -13,6 +13,7 @@ describe Interpreter do
     mask = File.join(File.dirname(__FILE__), 'source', '**', '*.lol')
     Dir.glob(mask).each do |source_filename|
       lexer = Lexer.new(File.new(source_filename))
+      lexer.input.set_encoding(Encoding::UTF_8)
       parser = Parser.new(Tokenizer.new(lexer))
       @interpreter.output.string = ''
 
@@ -49,4 +50,17 @@ describe Interpreter do
       infile.close if infile.instance_of?(File)
     end
   end
+
+  describe "#eval_print_stmt" do
+    it "should print trailing newline" do
+      string = Ast::Expression.new('constant', { vtype: :string, value: "a\n" })
+      stmt = Ast::Statement.new('print', {
+        expressions: [string], suppress: false
+      })
+
+      @interpreter.eval_print_stmt(stmt)
+
+      @interpreter.output.string.must_equal "a\n\n"
+    end
+  end
 end

data/spec/source/statements/input.out

@@ -1 +1,2 @@
 Alisa
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: layo
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-01-10 00:00:00.000000000 Z
+date: 2012-01-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mocha
-  requirement: &78148240 !ruby/object:Gem::Requirement
+  requirement: &70607720 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: 0.10.0
   type: :development
   prerelease: false
-  version_requirements: *78148240
+  version_requirements: *70607720
 description: ! "    Layo is a LOLCODE interpreter written in plain Ruby. It tries
   to conform to\n    the LOLCODE 1.2 specification and supports everything described
-  there.\n"
+  there.\n    Supports interactive mode.\n"
 email: kozhayev@gmail.com
 executables:
 - layo
@@ -36,6 +36,9 @@ files:
 - Rakefile
 - UnicodeData.txt
 - bin/layo
+- examples/1.lol
+- examples/2.lol
+- examples/3.lol
 - layo.gemspec
 - lib/layo.rb
 - lib/layo/ast.rb
@@ -44,6 +47,8 @@ files:
 - lib/layo/ast/node.rb
 - lib/layo/ast/program.rb
 - lib/layo/ast/statement.rb
+- lib/layo/base_interpreter.rb
+- lib/layo/interactive_interpreter.rb
 - lib/layo/interpreter.rb
 - lib/layo/lexer.rb
 - lib/layo/parser.rb