loxxy 0.0.3

data/README.md

@@ -0,0 +1,60 @@
+# Loxxy
+
+A Ruby implementation of the [Lox programming language](https://craftinginterpreters.com/the-lox-language.html),
+a simple language used in Bob Nystrom's online book [Crafting Interpreters](https://craftinginterpreters.com/).
+
+## Purpose of this project:
+- To deliver an open source example of a programming language fully implemented in Ruby  
+  (from the scanner, parser, code generation).
+- The implementation should be mature enough to run (LoxLox)[https://github.com/benhoyt/loxlox],  
+  a Lox interpreter written in Lox.
+
+## Roadmap
+- [DONE] Scanner (tokenizer)
+- [STARTED] Recognizer
+- [TODO] Parser
+- [TODO] Interpreter or transpiler
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'loxxy'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install loxxy
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Other Lox implementations in Ruby
+An impressive list of Lox implementations can be found [here](https://github.com/munificent/craftinginterpreters/wiki/Lox-implementations
+
+For Ruby, ther is the [lox](https://github.com/rdodson41/ruby-lox) gem.
+There are other Ruby-based projects as well:  
+- [SlowLox](https://github.com/ArminKleinert/SlowLox), described as a "1-to-1 conversion of JLox to Ruby"
+- [rulox](https://github.com/LevitatingBusinessMan/rulox)
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/famished_tiger/loxxy.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/lib/loxxy.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require_relative './loxxy/version'
+
+module Loxxy
+  class Error < StandardError; end
+  # Your code goes here...
+end

data/lib/loxxy/datatype/all_datatypes.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative 'false'
+require_relative 'lx_string'
+require_relative 'nil'
+require_relative 'number'
+require_relative 'true'

data/lib/loxxy/datatype/boolean.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative 'builtin_datatype'
+
+module Loxxy
+  module Datatype
+    # Abstract class that generalizes a Lox boolean value.
+    # An instance acts merely as a wrapper around a Ruby representation
+    # of the value.
+    class Boolean < BuiltinDatatype
+    end # class
+  end # module
+end # module

data/lib/loxxy/datatype/builtin_datatype.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Loxxy
+  module Datatype
+    # Abstract class that generalizes a value from a Lox built-in data types.
+    # An instance acts merely as a wrapper around a Ruby representation
+    # of the value.
+    class BuiltinDatatype
+      # @return [Object] The Ruby representation
+      attr_reader :value
+      
+      # Constructor. Initialize a Lox value from one of its built-in data type.
+      def initialize(aValue)
+        @value = validated_value(aValue)
+      end
+      
+      
+      protected
+      
+      def validated_value(aValue)
+        aValue
+      end
+    end # class
+  end # module
+end # module

data/lib/loxxy/datatype/false.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'singleton' # Use the Singleton design pattern
+require_relative 'boolean'
+
+module Loxxy
+  module Datatype
+    # Class for representing a Lox false value.
+    class False < Boolean
+      include Singleton # Make a singleton class
+      
+      # Build the sole instance
+      def initialize
+        super(false)
+      end
+    end # class
+    
+    False.instance.freeze  # Make the sole instance immutable
+  end # module
+end # module

data/lib/loxxy/datatype/lx_string.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative 'builtin_datatype'
+
+module Loxxy
+  module Datatype
+    # Class for representing a Lox string of characters value.
+    class LXString < BuiltinDatatype
+
+      # Build the sole instance
+      def initialize(aValue)
+        super(aValue)
+      end
+
+      protected
+
+      def validated_value(aValue)
+        unless aValue.is_a?(String)
+          raise StandardError, "Invalid number value #{aValue}"
+        end
+
+        # Remove double quotes delimiter
+        aValue.gsub(/(^")|("$)/, '')  
+      end
+    end # class
+  end # module
+end # module

data/lib/loxxy/datatype/nil.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'singleton' # Use the Singleton design pattern
+require_relative 'builtin_datatype'
+
+module Loxxy
+  module Datatype
+    # Class for representing a Lox nil "value".
+    class Nil < BuiltinDatatype
+      include Singleton # Make a singleton class
+      
+      # Build the sole instance
+      def initialize
+        super(nil)
+      end
+    end # class
+    
+    Nil.instance.freeze  # Make the sole instance immutable
+  end # module
+end # module

data/lib/loxxy/datatype/number.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative 'builtin_datatype'
+
+module Loxxy
+  module Datatype
+    # Class for representing a Lox numeric value.
+    class Number < BuiltinDatatype
+
+      # Build the sole instance
+      def initialize(aValue)
+        super(aValue)
+      end
+
+      protected
+
+      def validated_value(aValue)
+        case aValue
+          when Integer
+            result = aValue
+          when Numeric
+            result = aValue
+          when /^-?\d+$/
+            result = aValue.to_i
+          when /^-?\d+\.\d+$/
+            result = aValue.to_f
+          else
+            raise StandardError, "Invalid number value #{aValue}"
+        end
+
+        result
+      end
+    end # class
+  end # module
+end # module

data/lib/loxxy/datatype/true.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'singleton' # Use the Singleton design pattern
+require_relative 'boolean'
+
+module Loxxy
+  module Datatype
+    # Class for representing a Lox true value.
+    class True < Boolean
+      include Singleton # Make a singleton class
+      
+      # Build the sole instance
+      def initialize
+        super(true)
+      end      
+    end # class
+    
+    True.instance.freeze  # Make the sole instance immutable
+  end # module
+end # module

data/lib/loxxy/front_end/grammar.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+
+require 'rley' # Load the gem
+
+module Loxxy
+  module FrontEnd
+    ########################################
+    # Grammar for Lox language
+    # Authoritave grammar at:
+    #   https://craftinginterpreters.com/appendix-i.html
+    builder = Rley::Syntax::GrammarBuilder.new do
+      # Punctuators, separators...
+      add_terminals('LEFT_PAREN', 'RIGHT_PAREN', 'LEFT_BRACE', 'RIGHT_BRACE')
+      add_terminals('COMMA', 'DOT', 'MINUS', 'PLUS')
+      add_terminals('SEMICOLON', 'SLASH', 'STAR')
+      add_terminals('BANG', 'BANG_EQUAL', 'EQUAL', 'EQUAL_EQUAL')
+      add_terminals('GREATER', 'GREATER_EQUAL', 'LESS', 'LESS_EQUAL')
+
+      # Keywords and literals
+      add_terminals('AND', 'CLASS', 'ELSE', 'FALSE')
+      add_terminals('FUN', 'FOR', 'IDENTIFIER', 'IF')
+      add_terminals('NIL', 'NUMBER', 'OR', 'PRINT')
+      add_terminals('RETURN', 'STRING', 'SUPER', 'THIS')
+      add_terminals('TRUE', 'VAR', 'WHILE')
+      add_terminals('EOF')
+
+      # Top-level rule that matches an entire Lox program
+      rule('program' => 'declaration_star EOF')
+
+      # Declarations: bind an identifier to something
+      rule('declaration_star' => 'declaration_star declaration')
+      rule('declaration_star' => [])
+      rule('declaration' => 'classDecl')
+      rule('declaration' => 'funDecl')
+      rule('declaration' => 'varDecl')
+      rule('declaration' => 'statement')
+
+      rule('classDecl' => 'CLASS classNaming class_body')
+      rule('classNaming' => 'IDENTIFIER LESS IDENTIFIER')
+      rule('classNaming' => 'IDENTIFIER')
+      rule('class_body' => 'LEFT_BRACE function_star RIGHT_BRACE')
+      rule('function_star' => 'function_star function')
+      rule('function_star' => [])
+
+      rule('funDecl' => 'FUN function')
+
+      rule('varDecl' => 'VAR IDENTIFIER SEMICOLON')
+      rule('varDecl' => 'VAR IDENTIFIER EQUAL expression SEMICOLON')
+
+      # Statements: produce side effects, but don't introduce bindings
+      rule('statement' => 'exprStmt')
+      rule('statement' => 'forStmt')
+      rule('statement' => 'ifStmt')
+      rule('statement' => 'printStmt')
+      rule('statement' => 'returnStmt')
+      rule('statement' => 'whileStmt')
+      rule('statement' => 'block')
+
+      rule('exprStmt' => 'expression SEMICOLON')
+
+      rule('forStmt' => 'FOR LEFT_PAREN forControl RIGHT_PAREN statement')
+      rule('forControl' => 'forInitialization forTest forUpdate')
+      rule('forInitialization' => 'varDecl')
+      rule('forInitialization' => 'exprStmt')
+      rule('forInitialization' => 'SEMICOLON')
+      rule('forTest' => 'expression_opt SEMICOLON')
+      rule('forUpdate' => 'expression_opt')
+
+      rule('ifStmt' => 'IF ifCondition statement elsePart_opt')
+      rule('ifCondition' => 'LEFT_PAREN expression RIGHT_PAREN')
+      rule('elsePart_opt' => 'ELSE statement')
+      rule('elsePart_opt' => [])
+
+      rule('printStmt' => 'PRINT expression SEMICOLON')
+      rule('returnStmt' => 'RETURN expression_opt SEMICOLON')
+      rule('whileStmt' => 'WHILE LEFT_PAREN expression RIGHT_PAREN statement')
+      rule('block' => 'LEFT_BRACE declaration_star RIGHT_BRACE')
+
+      # Expressions: produce values
+      rule('expression_opt' => 'expression')
+      rule('expression_opt' => [])
+      rule('expression' => 'assignment')
+      rule('assignment' => 'owner_opt IDENTIFIER EQUAL assignment')
+      rule('assignment' => 'logic_or')
+      rule('owner_opt' => 'call DOT')
+      rule('owner_opt' => [])
+      rule('logic_or' => 'logic_and disjunct_star')
+      rule('disjunct_star' => 'disjunct_star OR logic_and')
+      rule('disjunct_star' => [])
+      rule('logic_and' => 'equality conjunct_star')
+      rule('conjunct_star' => 'conjunct_star AND equality')
+      rule('conjunct_star' => [])
+      rule('equality' => 'comparison equalityTest_star')
+      rule('equalityTest_star' => 'equalityTest_star equalityTest comparison')
+      rule('equalityTest_star' => [])
+      rule('equalityTest' => 'BANG_EQUAL')
+      rule('equalityTest' => 'EQUAL_EQUAL')
+      rule('comparison' => 'term comparisonTest_star')
+      rule('comparisonTest_star' => 'comparisonTest_star comparisonTest term')
+      rule('comparisonTest_star' => [])
+      rule('comparisonTest' => 'GREATER')
+      rule('comparisonTest' => 'GREATER_EQUAL')
+      rule('comparisonTest' => 'LESS')
+      rule('comparisonTest' => 'LESS_EQUAL')
+      rule('term' => 'factor additive_star')
+      rule('additive_star' => 'additive_star additionOp factor')
+      rule('additive_star' => [])
+      rule('additionOp' => 'MINUS')
+      rule('additionOp' => 'PLUS')
+      rule('factor' => 'unary multiplicative_star')
+      rule('multiplicative_star' => 'multiplicative_star multOp unary')
+      rule('multiplicative_star' => [])
+      rule('multOp' => 'SLASH')
+      rule('multOp' => 'STAR')
+      rule('unary' => 'unaryOp unary')
+      rule('unary' => 'call')
+      rule('unaryOp' => 'BANG')
+      rule('unaryOp' => 'MINUS')
+      rule('call' => 'primary refinement_star')
+      rule('refinement_star' => 'refinement_star refinement')
+      rule('refinement_star' => [])
+      rule('refinement' => 'LEFT_PAREN arguments_opt RIGHT_PAREN')
+      rule('refinement' => 'DOT IDENTIFIER')
+      rule('primary' => 'TRUE')
+      rule('primary' => 'FALSE')
+      rule('primary' => 'NIL')
+      rule('primary' => 'THIS')
+      rule('primary' => 'NUMBER')
+      rule('primary' => 'STRING')
+      rule('primary' => 'IDENTIFIER')
+      rule('primary' => 'LEFT_PAREN expression RIGHT_PAREN')
+      rule('primary' => 'SUPER DOT IDENTIFIER')
+      
+      # Utility rules
+      rule('function' => 'IDENTIFIER LEFT_PAREN params_opt RIGHT_PAREN block')
+      rule('params_opt' => 'parameters')
+      rule('params_opt' => [])
+      rule('parameters' => 'parameters COMMA IDENTIFIER')
+      rule('parameters' => 'IDENTIFIER')
+      rule('arguments_opt' => 'arguments')
+      rule('arguments_opt' => [])
+      rule('arguments' => 'arguments COMMA expression')
+      rule('arguments' => 'expression')
+      
+    end
+
+  # And now build the grammar and make it accessible via a constant
+  # @return [Rley::Syntax::Grammar]
+  Grammar = builder.grammar
+  end # module
+end # module

data/lib/loxxy/front_end/literal.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'rley'
+
+module Loxxy
+  module FrontEnd
+    # The superclass for all tokens that have a data value.
+    class Literal < Rley::Lexical::Token
+      # @return [Datatype] The value expressed in one of the Lox datatype.
+      attr_reader :value
+
+      # Constructor.
+      # @param aValue [Datatype::BuiltinDatatype] the Lox data value
+      # @param theLexeme [String] the lexeme (= piece of text from input)
+      # @param aTerminal [Rley::Syntax::Terminal, String]
+      #   The terminal symbol corresponding to the lexeme.
+      # @param aPosition [Rley::Lexical::Position] The position of lexeme 
+      #   in input text.
+      def initialize(aValue, aLexeme, aTerminal, aPosition)
+        super(aLexeme, aTerminal, aPosition)
+        @value = aValue
+      end
+    end # class
+  end # module
+end # module

data/lib/loxxy/front_end/parser.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative 'scanner'
+require_relative 'grammar'
+
+module Loxxy
+  module FrontEnd
+    class Parser
+      attr_reader(:engine)
+
+      def initialize
+        # Create a Rley facade object
+        @engine = Rley::Engine.new do |cfg|
+          cfg.diagnose = true
+          # cfg.repr_builder = SkmBuilder
+        end
+
+        # Step 1. Load Lox grammar
+        @engine.use_grammar(Loxxy::FrontEnd::Grammar)
+      end
+
+      # Parse the given Lox program into a parse tree.
+      # @param source [String] Lox program to parse
+      # @return [Rley::ParseTree] A parse tree equivalent to the Lox input.
+      def parse(source)
+        lexer = Scanner.new(source)
+        result = engine.parse(lexer.tokens)
+
+        unless result.success?
+          # Stop if the parse failed...
+          line1 = "Parsing failed\n"
+          line2 = "Reason: #{result.failure_reason.message}"
+          raise StandardError, line1 + line2
+        end
+
+        return engine.convert(result) # engine.to_ptree(result)
+      end
+    end # class
+  end # module
+end # module