omnium 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c8dab1a91f7d1e12c0bb73a14952497bf6abad7ce6c09b1fa6d1122fb6a65f1d
-  data.tar.gz: e793ae1711b80f8e3c0825188ba945d7a9ff99839459129d91914209dc3db54e
+  metadata.gz: ea2b969a43198c92ed63117aea179c8f9b538f2bfc61f5217fc2211dd71a7190
+  data.tar.gz: 488b260b9b96f9168e1289f9c38a1d4316a1900ae866f0b14b43c2468601f2fd
 SHA512:
-  metadata.gz: 0776f6230d75cf5225a8aec85d88a5eec5896eb87f3859320cd42b075cfee0ff703e31cb9103c5ee37001cb8d6fb04643e08ea8cd23b3fb1a564412b624b9601
-  data.tar.gz: 4f46cc5e2d05fec10a94877de924679c0370310879bc99bf79602298c3228536661df4d10f8c2a3cfee6f1d296628e595fcbe4e1801f3244940e8abea0f9c555
+  metadata.gz: a7a227a21c5397bc15641dc0af6e749a40f8f1430b779063c1be79d3c0dd02884ad45abb11faf93a25545e1185846284841d614be5c114e2db4e64985531a0cb
+  data.tar.gz: d380605399e2bd7f311031d4d79cd7490623d74585af52c0c2ff39a4283f0608c593d1aaa80cfd9d35062c5148c4398a8d9dbf9ee1ed832a989ae6df9a2f182a

data/LICENSE.md

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright 2020 Rónán Duddy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,57 @@
+# Omnium
+
+> "Your talk," I said, "is surely the handiwork of wisdom because not one word of it do I understand."
+
+Omnium is
+1. an ongoing educational project for learning how to write a programming language
+2. an interpreter written in Ruby
+3. a gem
+4. a bicycle
+5. quite the pancake
+
+[![Build Status](https://travis-ci.org/ronanduddy/omnium.svg?branch=master)](https://travis-ci.org/ronanduddy/omnium)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'omnium'
+```
+
+And then execute:
+
+```Shell
+bundle install
+```
+
+Or install it yourself as:
+
+```Shell
+gem install omnium
+```
+
+## Usage
+
+```Shell
+bundle exec omnium hello.om
+{:a=>2, :b=>25, :y=>5.997142857142857}
+```
+
+## Development
+
+After checking out the repo, run `make run filename=hello.om` to run the example program. Then, run `make test` to run all the tests or `make guard` to use guard for testing. You can also run `make irb` for an interactive prompt that will allow you to experiment.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/ronanduddy/omnium. Please read [CODE_OF_CONDUCT.md](CODE_OF_CONDUCT.md) for details on our code of conduct.
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE.md](LICENSE.md) file for details
+
+## Acknowledgments
+
+* Brian O'Nolan
+* [Ruslan Spivak](https://ruslanspivak.com)
+* [Jonathan Blow](https://www.youtube.com/user/jblow888/)

data/lib/omnium.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'omnium/version'
+require 'omnium/common'
+require 'omnium/lexer'
+require 'omnium/parser'
+require 'omnium/interpreter'
+require 'omnium/cli'
+
+module Omnium
+end

data/lib/omnium/cli.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Omnium
+  module CLI
+    require 'omnium/cli/core'
+
+    def self.new(args)
+      CLI::Core.new(args)
+    end
+  end
+end

data/lib/omnium/cli/core.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Omnium
+  module CLI
+    class Core
+      class CLIError < StandardError; end
+
+      def initialize(args)
+        @filename = args&.first
+      end
+
+      def run
+        program = IO.readlines(@filename).join
+
+        interpret(program)
+      rescue TypeError => e
+        raise(CLIError, '@filename is blank.')
+      rescue Errno::ENOENT => e
+        raise(CLIError, "@filename '#{@filename}' does not exist.")
+      end
+
+      private
+
+      def interpret(input)
+        lexer = Lexer.new(input)
+        parser = Parser.new(lexer)
+        interpreter = Interpreter.new(parser)
+        interpreter.interpret
+
+        interpreter.symbol_table
+      end
+    end
+  end
+end

data/lib/omnium/common.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Omnium
+  module Common
+    VALUE_BASED_TOKENS = [
+      { type: :plus, value: '+' },
+      { type: :minus, value: '-' },
+      { type: :multiply, value: '*' },
+      { type: :divide, value: '/' },
+      { type: :left_parenthesis, value: '(' },
+      { type: :right_parenthesis, value: ')' },
+      { type: :semicolon, value: ';' },
+      { type: :dot, value: '.' },
+      { type: :assignment, value: ':=' },
+      { type: :colon, value: ':' },
+      { type: :comma, value: ',' }
+    ].freeze
+
+    PARAMETERISED_TOKENS = [
+      { type: :identifier },
+      { type: :integer }, # int
+      { type: :real } # float
+    ].freeze
+
+    NIL_VALUE_TOKENS = [
+      { type: :eof, value: nil }
+    ].freeze
+
+    TOKENS = {}
+             .merge(value_based: VALUE_BASED_TOKENS)
+             .merge(parameterised: PARAMETERISED_TOKENS)
+             .merge(nil_value: NIL_VALUE_TOKENS)
+
+    RESERVED_KEYWORDS = {
+      program: 'program',
+      var: 'var',
+      int: 'int', # integer
+      float: 'float', # real
+      begin: 'begin',
+      end: 'end'
+    }.freeze
+
+    def token_entity
+      if instance_variable_defined?(:@character)
+        @character # Lexer#character
+      elsif instance_variable_defined?(:@token)
+        @token&.type # Parser::Core#token
+      elsif instance_variable_defined?(:@type)
+        @type # Interpreter#type
+      end
+    end
+
+    def define_token_predicate_method(type, value = nil)
+      define_method("#{type}?") do
+        token_entity == type || (!value.nil? && token_entity == value)
+      end
+    end
+
+    def define_token_type_method(type)
+      define_method("#{type}_token") { type }
+    end
+
+    module_function :token_entity, :define_token_predicate_method, :define_token_type_method
+
+    VALUE_BASED_TOKENS.each do |token|
+      define_token_predicate_method(token[:type], token[:value])
+
+      define_method("#{token[:type]}_token") do |symbol = :type|
+        return token[:type] if symbol == :type
+        return token[:value] if symbol == :value
+
+        raise(ArgumentError, "Invalid argument :#{symbol}")
+      end
+    end
+
+    PARAMETERISED_TOKENS.each do |token|
+      define_token_predicate_method(token[:type])
+      define_token_type_method(token[:type])
+    end
+
+    NIL_VALUE_TOKENS.each do |token|
+      define_token_predicate_method(token[:type])
+      define_token_type_method(token[:type])
+    end
+
+    RESERVED_KEYWORDS.each_pair do |key, _value|
+      define_token_predicate_method(key)
+      define_token_type_method(key)
+    end
+  end
+end

data/lib/omnium/interpreter.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Omnium
+  module Interpreter
+    require 'omnium/interpreter/node_visitor'
+    require 'omnium/interpreter/core'
+
+    def self.new(parser)
+      Interpreter::Core.new(parser)
+    end
+  end
+end

data/lib/omnium/interpreter/core.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Omnium
+  module Interpreter
+    # The visitor pattern is used to traverse the AST. This class may be thought of
+    # as a 'tree visitor'.
+    class Core < NodeVisitor
+      include Common
+
+      class InterpreterError < StandardError; end
+
+      attr_reader :symbol_table, :name
+
+      def initialize(parser)
+        @parser = parser
+        @symbol_table = {}
+        @name = nil
+      end
+
+      def interpret
+        tree = @parser.parse
+        visit(tree)
+      end
+
+      # concrete visitor operations below
+
+      def visit_Program(node)
+        @name = node.name
+        visit(node.block)
+      end
+
+      def visit_Block(node)
+        node.variable_declarations.each do |variable_declaration|
+          visit(variable_declaration)
+        end
+
+        visit(node.compound_statement)
+      end
+
+      def visit_Compound(node)
+        node.children.each { |child| visit(child) }
+      end
+
+      def visit_VariableDeclaration(node)
+        # noop
+      end
+
+      def visit_Assignment(node)
+        symbol_table[node.left.name.intern] = visit(node.right)
+      end
+
+      def visit_Identifier(node)
+        symbol_table.fetch(node.name.intern)
+      rescue KeyError
+        raise(InterpreterError, "Variable '#{node.name}' not found")
+      end
+
+      def visit_DataType(node)
+        # noop
+      end
+
+      def visit_NoOperation(node)
+        # noop
+      end
+
+      def visit_BinaryOperator(node)
+        @type = node.operator.type
+
+        if plus?
+          visit(node.left) + visit(node.right)
+        elsif minus?
+          visit(node.left) - visit(node.right)
+        elsif multiply?
+          visit(node.left) * visit(node.right)
+        elsif divide?
+          visit(node.left) / visit(node.right)
+        end
+      end
+
+      def visit_UnaryOperator(node)
+        @type = node.operator.type
+
+        if plus?
+          +visit(node.operand)
+        elsif minus?
+          -visit(node.operand)
+        end
+      end
+
+      def visit_Number(node)
+        node.value
+      end
+    end
+  end
+end

data/lib/omnium/interpreter/node_visitor.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Omnium
+  module Interpreter
+    # This is to facilite the visitor pattern regards double dispatching.
+    class NodeVisitor
+      def visit(node)
+        method_name = "visit_#{class_name(node)}"
+        send(method_name, node)
+      rescue NameError
+        raise NotImplementedError, "Subclass does not implement #{method_name}"
+      end
+
+      private
+
+      def class_name(node)
+        node.class.name.split('::').last
+      end
+    end
+  end
+end

data/lib/omnium/lexer.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Omnium
+  module Lexer
+    require 'omnium/lexer/token'
+    require 'omnium/lexer/token_helper'
+    require 'omnium/lexer/core'
+
+    def self.new(input)
+      Lexer::Core.new(input)
+    end
+  end
+end

data/lib/omnium/lexer/core.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+# frozen_text_literal: true
+
+module Omnium
+  module Lexer
+    # The lexer returns tokens for a given text.
+    class Core
+      include Common
+      include TokenHelper
+
+      WHITESPACE = ' '
+      COMMENT = '#'
+      NEWLINE = "\n"
+      DECIMAL_POINT = '.'
+
+      INTEGER = /[0-9]/.freeze
+      ALPHA = /[a-zA-Z]/.freeze
+      IDENTIFIER = /[a-zA-Z0-9_]/.freeze
+
+      class LexerError < StandardError; end
+
+      def initialize(text)
+        @text = text
+        @pointer = 0
+      end
+
+      def next_token
+        ignore
+        return new_eof_token if eos?
+
+        (@pointer...@text.length).each do
+          return tokenise
+        end
+      end
+
+      private
+
+      def ignore
+        advance while whitespace? || newline?
+
+        if comment?
+          advance until newline? # comment text
+          ignore if whitespace? || newline? # skip any other junk
+        end
+      end
+
+      def eos?
+        @pointer > @text.length - 1
+      end
+
+      def advance(n = 1)
+        @pointer += n
+      end
+
+      def character
+        @character = @text[@pointer]
+      end
+
+      def peek
+        return nil if eos?
+
+        @text[@pointer + 1]
+      end
+
+      def whitespace?
+        character == WHITESPACE
+      end
+
+      def comment?
+        character == COMMENT
+      end
+
+      def newline?
+        character == NEWLINE
+      end
+
+      def decimal?
+        character == DECIMAL_POINT
+      end
+
+      def number
+        result = ''
+
+        while character =~ INTEGER
+          result += character
+          advance
+        end
+
+        if decimal?
+          result += character
+          advance
+
+          while character =~ INTEGER
+            result += character
+            advance
+          end
+
+          return result.to_f
+        end
+
+        result.to_i
+      end
+
+      def reserved_keyword
+        result = ''
+
+        while character =~ IDENTIFIER
+          result += character
+          advance
+        end
+
+        result
+      end
+
+      def assignment?
+        colon = assignment_token(:value)[0]
+        equals = assignment_token(:value)[1]
+
+        character == colon && peek == equals
+      end
+
+      def word_token(word)
+        if RESERVED_KEYWORDS.include?(word.intern)
+          send("new_#{word}_token")
+        else
+          new_identifier_token(word)
+        end
+      end
+
+      def number_token(num)
+        return new_integer_token(num) if num.is_a? Integer
+
+        new_real_token(num)
+      end
+
+      def tokenise
+        if character =~ ALPHA
+          word_token(reserved_keyword)
+        elsif character =~ INTEGER
+          number_token(number)
+        elsif plus?
+          advance
+          new_plus_token
+        elsif minus?
+          advance
+          new_minus_token
+        elsif multiply?
+          advance
+          new_multiply_token
+        elsif divide?
+          advance
+          new_divide_token
+        elsif left_parenthesis?
+          advance
+          new_left_parenthesis_token
+        elsif right_parenthesis?
+          advance
+          new_right_parenthesis_token
+        elsif assignment?
+          advance(2)
+          new_assignment_token
+        elsif semicolon?
+          advance
+          new_semicolon_token
+        elsif colon?
+          advance
+          new_colon_token
+        elsif comma?
+          advance
+          new_comma_token
+        elsif dot?
+          advance
+          new_dot_token
+        else
+          raise(LexerError, "Error tokenising '#{character}' at position #{@pointer}")
+        end
+      end
+    end
+  end
+end

data/lib/omnium/lexer/token.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Omnium
+  module Lexer
+    # A token is a string with an assigned and identified meaning.
+    class Token
+      attr_reader :type, :value
+
+      def initialize(type, value)
+        @type = type
+        @value = value
+      end
+    end
+  end
+  end

data/lib/omnium/lexer/token_helper.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Omnium
+  module Lexer
+    module TokenHelper
+      include Common
+
+      def define_new_token_method(type, value, arity = 0)
+        method_name = "new_#{type}_token"
+
+        if arity == 0
+          define_method(method_name) { Token.new(type, value) }
+        else
+          define_method(method_name) { |argument| Token.new(type, argument) }
+        end
+      end
+
+      module_function :define_new_token_method
+
+      VALUE_BASED_TOKENS.each do |token|
+        define_new_token_method(token[:type], token[:value])
+      end
+
+      PARAMETERISED_TOKENS.each do |token|
+        define_new_token_method(token[:type], nil, 1)
+      end
+
+      NIL_VALUE_TOKENS.each do |token|
+        define_new_token_method(token[:type], nil)
+      end
+
+      RESERVED_KEYWORDS.each_pair do |key, value|
+        define_new_token_method(key, value)
+      end
+    end
+  end
+end

data/lib/omnium/parser.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Omnium
+  module Parser
+    module AST
+      require 'omnium/parser/ast/base'
+      require 'omnium/parser/ast/assignment'
+      require 'omnium/parser/ast/binary_operator'
+      require 'omnium/parser/ast/block'
+      require 'omnium/parser/ast/compound'
+      require 'omnium/parser/ast/data_type'
+      require 'omnium/parser/ast/identifier'
+      require 'omnium/parser/ast/no_operation'
+      require 'omnium/parser/ast/number'
+      require 'omnium/parser/ast/program'
+      require 'omnium/parser/ast/unary_operator'
+      require 'omnium/parser/ast/variable_declaration'
+    end
+
+    require 'omnium/parser/parse_error_handler'
+    require 'omnium/parser/core'
+
+    def self.new(lexer)
+      Parser::Core.new(lexer)
+    end
+  end
+end

data/lib/omnium/parser/ast/assignment.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Omnium
+  module Parser
+    module AST
+      # This is an assignment statement, for example 'x := 5' or 'y := x'. @left
+      # is a reference to the variable node and @right is a reference to the node
+      # returned by Parser::Core#expr
+      class Assignment < Base
+        attr_reader :left, :operator, :right
+
+        def initialize(left, operator, right)
+          @left = left
+          @operator = operator
+          @right = right
+        end
+      end
+    end
+  end
+end

data/lib/omnium/parser/ast/base.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Omnium
+  # Base class for the abstract syntax tree
+  module Parser
+    module AST
+      class Base
+        # noop...
+      end
+    end
+  end
+end

data/lib/omnium/parser/ast/binary_operator.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Omnium
+  module Parser
+    module AST
+      # Binary operator represents the four binary operations: add, subtract, multiply
+      # and divide. @left and @right are the nodes representing operands (i.e. Number).
+      # @operator represents the operator as a token.
+      class BinaryOperator < Base
+        attr_reader :left, :operator, :right
+
+        def initialize(left, operator, right)
+          @left = left
+          @operator = operator
+          @right = right
+        end
+      end
+    end
+  end
+end

data/lib/omnium/parser/ast/block.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Omnium
+  module Parser
+    module AST
+      # A block represents declarations and compound statements
+      class Block < Base
+        attr_reader :variable_declarations, :compound_statement
+
+        def initialize(variable_declarations, compound_statement)
+          @variable_declarations = variable_declarations
+          @compound_statement = compound_statement
+        end
+      end
+    end
+  end
+end

data/lib/omnium/parser/ast/compound.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Omnium
+  module Parser
+    module AST
+      # This compound statement is for a 'begin ... end' block and therefore
+      # represents a list of statement nodes as @children.
+      class Compound < Base
+        attr_reader :children
+
+        def initialize
+          @children = []
+        end
+
+        def append(nodes)
+          nodes.each { |node| @children << node }
+          self
+        end
+      end
+    end
+  end
+end

data/lib/omnium/parser/ast/data_type.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Omnium
+  module Parser
+    module AST
+      # Int or float for example
+      class DataType < Base
+        attr_reader :value
+
+        def initialize(token)
+          @value = token.value
+        end
+      end
+    end
+  end
+end

data/lib/omnium/parser/ast/identifier.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Omnium
+  module Parser
+    module AST
+      # This node represents a variable or an identifier, accepting an ID token.
+      class Identifier < Base
+        attr_reader :name
+
+        def initialize(token)
+          @token = token # for convenience, though no getter for this
+          @name = token.value
+        end
+      end
+    end
+  end
+end

data/lib/omnium/parser/ast/no_operation.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Omnium
+  module Parser
+    module AST
+      # This class represents no operation, nothing, a noop, an empty statement
+      # such as 'begin end'.
+      class NoOperation < Base
+        # noop
+      end
+    end
+  end
+end

data/lib/omnium/parser/ast/number.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Omnium
+  module Parser
+    module AST
+      # An integer node, which would accept an integer/number token.
+      class Number < Base
+        attr_reader :value
+
+        def initialize(token)
+          @token = token # for convenience, though no getter for this
+          @value = token.value
+        end
+      end
+    end
+  end
+end

data/lib/omnium/parser/ast/program.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Omnium
+  module Parser
+    module AST
+      # Program represents the root node.
+      class Program < Base
+        attr_reader :name, :block
+
+        def initialize(name, block)
+          @name = name
+          @block = block
+        end
+      end
+    end
+  end
+end

data/lib/omnium/parser/ast/unary_operator.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Omnium
+  module Parser
+    module AST
+      # Unary Operator represents a plus or minus on a number e.g. +1 or -5. That is
+      # an operator operating on one operand. @operator represents the unary operator
+      # token (plus or minus) and @operand represents another node (number or expression).
+      class UnaryOperator < Base
+        attr_reader :operator, :operand
+
+        def initialize(operator, operand)
+          @operator = operator
+          @operand = operand
+        end
+      end
+    end
+  end
+end

data/lib/omnium/parser/ast/variable_declaration.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Omnium
+  module Parser
+    module AST
+      # Representative of the declaration of a variable, containing a reference to
+      # the variable identifier_node and it's data type.
+      class VariableDeclaration < Base
+        attr_reader :identifier, :data_type
+
+        def initialize(identifier, data_type)
+          @identifier = identifier
+          @data_type = data_type
+        end
+      end
+    end
+  end
+end

data/lib/omnium/parser/core.rb

@@ -0,0 +1,232 @@
+# frozen_string_literal: true
+
+module Omnium
+  module Parser
+    # The parser will verify the format of a list of tokens (syntax analysis) by
+    # 'recursive-descent'.
+    class Core
+      include Common
+      include ParseErrorHandler
+      include AST
+
+      def initialize(lexer)
+        @lexer = lexer
+        @token = nil
+        @consumed_token = nil
+      end
+
+      def parse
+        @token = @lexer.next_token
+        node = program
+
+        error(expected_type: eof_token, actual_type: @token.type) unless eof?
+
+        node
+      end
+
+      private
+
+      def program
+        # program : PROGRAM variable SEMI block DOT
+        consume(program_token)
+        name = identifier.name
+        consume(semicolon_token)
+        node = Program.new(name, block)
+        consume(dot_token)
+
+        node
+      end
+
+      def block
+        # block : variable_declarations compound_statement
+        Block.new(variable_declarations, compound_statement)
+      end
+
+      def variable_declarations
+        # variable_declarations : VAR (variable_declaration SEMI)+
+        #                       | empty
+        declarations = []
+
+        if var?
+          consume(var_token)
+
+          while identifier?
+            declarations << variable_declaration
+            consume(semicolon_token)
+          end
+        end
+
+        declarations.flatten
+      end
+
+      def variable_declaration
+        # variable_declaration : ID (COMMA ID)* COLON variable_data_type
+        identifiers = [identifier]
+
+        while comma?
+          consume(comma_token)
+          identifiers << identifier
+        end
+
+        consume(colon_token)
+
+        data_type = variable_data_type
+        identifiers.map { |identifier| VariableDeclaration.new(identifier, data_type) }
+      end
+
+      def variable_data_type
+        # variable_data_type : INTEGER
+        #                    | FLOAT
+        if int?
+          consume(int_token)
+        elsif float?
+          consume(float_token)
+        end
+
+        DataType.new(@consumed_token)
+      end
+
+      def compound_statement
+        # compound_statement : BEGIN statement_list END
+        consume(begin_token)
+        nodes = statement_list
+        consume(end_token)
+
+        Compound.new.append(nodes)
+      end
+
+      def statement_list
+        # statement_list : statement
+        #               | statement SEMI statement_list
+        nodes = [statement]
+
+        while semicolon?
+          consume(semicolon_token)
+          nodes << statement
+        end
+
+        error("Invalid identifier found: #{@token.inspect}") if identifier?
+
+        nodes
+      end
+
+      def statement
+        # statement : compound_statement
+        #           | assignment_statement
+        #           | empty
+        if begin?
+          return compound_statement
+        elsif identifier?
+          return assignment_statement
+        end
+
+        empty
+      end
+
+      def assignment_statement
+        # assignment_statement : variable ASSIGN expr
+        left = identifier
+        consume(assignment_token)
+
+        Assignment.new(left, @consumed_token, expr)
+      end
+
+      def identifier
+        # variable : ID
+        node = Identifier.new(@token)
+        consume(identifier_token)
+
+        node
+      end
+
+      def empty
+        # no operation rule
+        NoOperation.new
+      end
+
+      def expr
+        # expr : term ((PLUS | MINUS) term)*
+        node = term
+
+        while plus? || minus?
+          if plus?
+            consume(plus_token)
+          elsif minus?
+            consume(minus_token)
+          end
+
+          node = BinaryOperator.new(node, @consumed_token, term)
+        end
+
+        node
+      end
+
+      def term
+        # term : factor ((MULTIPLY | DIVIDE) factor)*
+        node = factor
+
+        while multiply? || divide?
+          if multiply?
+            consume(multiply_token)
+          elsif divide?
+            consume(divide_token)
+          end
+
+          node = BinaryOperator.new(node, @consumed_token, factor)
+        end
+
+        node
+      end
+
+      def factor
+        # factor : PLUS  factor
+        #        | MINUS factor
+        #        | INTEGER
+        #        | LPAREN expr RPAREN
+        #        | identifier
+        if plus?
+          consume(plus_token)
+          return UnaryOperator.new(@consumed_token, factor)
+        elsif minus?
+          consume(minus_token)
+          return UnaryOperator.new(@consumed_token, factor)
+        elsif integer?
+          consume(integer_token)
+          return Number.new(@consumed_token)
+        elsif real?
+          consume(real_token)
+          return Number.new(@consumed_token)
+        elsif left_parenthesis?
+          consume(left_parenthesis_token)
+          node = expr
+          consume(right_parenthesis_token)
+          return node
+        elsif identifier?
+          return identifier
+        end
+
+        expected_types = [
+          plus_token,
+          minus_token,
+          integer_token,
+          real_token,
+          left_parenthesis_token,
+          right_parenthesis_token,
+          identifier_token
+        ]
+
+        error(expected_type: expected_types, actual_type: @token.type)
+      end
+
+      def consume(type)
+        # verify the type of @token and advance @token to next_token
+        unless type == @token.type
+          error(expected_type: type, actual_type: @token.type)
+        end
+
+        @consumed_token = @token
+        @token = @lexer.next_token
+      end
+    end
+  end
+end

data/lib/omnium/parser/parse_error_handler.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Omnium
+  module Parser
+    # The module responsible for generating ParseErrors
+    module ParseErrorHandler
+      def error(message = nil, expected_type: nil, actual_type: nil)
+        # a dirty sort of arg list...
+        raise ParseError.new(
+          actual_type: actual_type,
+          expected_type: expected_type,
+          message: message
+        )
+      end
+
+      # could possibly break this out if desired...
+      class ParseError < StandardError
+        attr_reader :actual_type, :expected_type
+
+        def initialize(**args)
+          @actual_type = args[:actual_type]
+          @expected_type = args[:expected_type]
+
+          super(args[:message] || default_message)
+        end
+
+        private
+
+        def default_message
+          template = "Expecting token type(s) '%s', got '%s'."
+          format(template, sanitised_expected_type, @actual_type)
+        end
+
+        def sanitised_expected_type
+          return @expected_type.to_s if @expected_type.is_a? Symbol
+
+          @expected_type.join(', ')
+        end
+      end
+    end
+  end
+end

data/lib/omnium/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Omnium
+  VERSION = '0.2.0'
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: omnium
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Rónán Duddy
 autorequire: 
-bindir: bin
+bindir: exe
 cert_chain: []
-date: 2020-06-02 00:00:00.000000000 Z
+date: 2020-12-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: guard
@@ -116,13 +116,44 @@ dependencies:
         version: 0.81.0
 description: That is about the size of it
 email:
-- ronanduddy@live.ie
+- dev@ronanduddy.xyz
 executables:
 - omnium
 extensions: []
-extra_rdoc_files: []
+extra_rdoc_files:
+- README.md
+- LICENSE.md
 files:
-- bin/omnium
+- LICENSE.md
+- README.md
+- exe/omnium
+- lib/omnium.rb
+- lib/omnium/cli.rb
+- lib/omnium/cli/core.rb
+- lib/omnium/common.rb
+- lib/omnium/interpreter.rb
+- lib/omnium/interpreter/core.rb
+- lib/omnium/interpreter/node_visitor.rb
+- lib/omnium/lexer.rb
+- lib/omnium/lexer/core.rb
+- lib/omnium/lexer/token.rb
+- lib/omnium/lexer/token_helper.rb
+- lib/omnium/parser.rb
+- lib/omnium/parser/ast/assignment.rb
+- lib/omnium/parser/ast/base.rb
+- lib/omnium/parser/ast/binary_operator.rb
+- lib/omnium/parser/ast/block.rb
+- lib/omnium/parser/ast/compound.rb
+- lib/omnium/parser/ast/data_type.rb
+- lib/omnium/parser/ast/identifier.rb
+- lib/omnium/parser/ast/no_operation.rb
+- lib/omnium/parser/ast/number.rb
+- lib/omnium/parser/ast/program.rb
+- lib/omnium/parser/ast/unary_operator.rb
+- lib/omnium/parser/ast/variable_declaration.rb
+- lib/omnium/parser/core.rb
+- lib/omnium/parser/parse_error_handler.rb
+- lib/omnium/version.rb
 homepage: https://github.com/ronanduddy/omnium
 licenses:
 - MIT
@@ -135,14 +166,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.7.0
+      version: 2.7.2
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.1.4
 signing_key: 
 specification_version: 4
 summary: Omnium language.