modl 0.0.2 → 0.3.0

data/lib/modl/parser/parser.rb

@@ -0,0 +1,42 @@
+require 'modl/parser/throwing_error_listener'
+require 'modl/parser/parsed'
+
+module Modl
+  module Parser
+
+    # This class converts the input string into a Modl:Parser::Parsed object for further processing.
+    class Parser
+      def self.parse(str, global = nil)
+        begin
+          lexer = Modl::Parser::MODLLexer.new(Antlr4::Runtime::CharStreams.from_string(str, 'String'))
+          lexer.remove_error_listeners
+          lexer.add_error_listener ThrowingErrorListener.instance
+
+          tokens = Antlr4::Runtime::CommonTokenStream.new(lexer)
+
+          parser = Modl::Parser::MODLParser.new(tokens)
+          parser.remove_error_listeners
+          parser.add_error_listener ThrowingErrorListener.instance
+
+          global = GlobalParseContext.new if global.nil?
+
+          parsed = Parsed.new(global)
+          parser.modl.enter_rule(parsed)
+          parsed
+        rescue StandardError => e
+          puts e.message
+          puts e.backtrace
+
+          if global.syntax_version > global.interpreter_syntax_version
+            raise InterpreterError, 'MODL Version ' +
+                global.interpreter_syntax_version.to_s +
+                ' interpreter cannot process this MODL Version ' +
+                global.syntax_version.to_s + ' file.'
+          end
+
+          raise InterpreterError, 'Parser Error: ' + e.message
+        end
+      end
+    end
+  end
+end

data/lib/modl/parser/ref_processor.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require 'modl/parser/parsed'
+require 'punycode'
+require 'modl/parser/sutil'
+
+module Modl
+  module Parser
+    # Convert MODL reference to the replacement value
+    class RefProcessor
+
+      NESTED_SEPARATOR = '.'
+      MATCHER = Regexp.new('((`?\%[0-9][0-9.][a-zA-Z0-9.(),]*`?)|(`?\%[0-9][0-9]*`?)|(`?\%[_a-zA-Z][_a-zA-Z0-9.%(),]*`?)|(`.*`\.[_a-zA-Z0-9.(),%]+)|(`.*`))')
+
+      def self.trivial_reject(str)
+        # do a fast check to see if we need to deref - save processing the regex if we don't have to.
+        str.is_a?(String) && (str.nil? || str.include?('%') || str.include?('`'))
+      end
+
+      # Check str for references and process them.
+      # Return the processed string and a new_value if there is one.
+      def self.deref(str, global)
+        obj = str
+        obj, new_value = split_by_ref_tokens str, global if trivial_reject(str)
+        [obj, new_value]
+      end
+
+      # Process the next %ref token
+      def self.split_by_ref_tokens(str, global)
+        new_value = nil
+
+        text = str
+        original = str
+
+        new_value, str = process_tokens(global, original, str, text) if new_value.nil?
+
+        [str, new_value]
+      end
+
+      private
+
+      def self.process_tokens(global, original, str, text)
+        new_value = nil
+        loop do
+          match = MATCHER.match(text.to_s)
+          break if match.nil?
+
+          ref = match[0]
+          text = Sutil.after(text, ref)
+          new_value, remainder = expand(global, ref)
+          ref = Sutil.until(ref, remainder)
+          if new_value.is_a?(String)
+            str = str.sub(ref, new_value)
+          elsif new_value.is_a?(Parsed::ParsedArrayItem)
+            nv_text = new_value.arrayValueItem.text
+            str = if ref == str
+                    nv_text
+                  else
+                    str.sub(ref, nv_text.to_s)
+                  end
+            new_value = nil
+          elsif new_value.is_a?(Modl::Parser::MODLParserBaseListener)
+            if new_value.text
+              str = if ref == str
+                      new_value.text
+                    else
+                      str.sub(ref, new_value.text.to_s)
+                    end
+              new_value = nil
+            else
+              str = nil
+            end
+          else
+            new_value = nil
+            raise InterpreterError, 'Cannot resolve reference in : "' + str + '"' if str == original
+          end
+        end
+        return new_value, str
+      end
+
+      def self.expand(global, ref)
+        result = nil
+        prev = nil
+
+        degraved = Sutil.replace(ref, '`', '')
+
+        parts = Sutil.tail(degraved).split('.') if degraved[0] == '%'
+        parts = degraved.split('.') unless degraved[0] == '%'
+
+        if degraved.include?('%')
+          resolved = 0
+          parts.each do |p|
+            if p.include?('%')
+              p, _ignore = expand(global, p)
+              if p.is_a?(Modl::Parser::MODLParserBaseListener)
+                p = p.text
+              end
+            end
+            n = p.to_i
+            result = if n.to_s == p
+                       # Numeric ref
+                       result.nil? ? global.index_value(n, degraved) : result.find_property(n)
+                     else
+                       # String ref
+                       if result.is_a? String
+                         StandardMethods.run_method(p, result)
+                       elsif result.is_a? Array
+                         nil
+                       else
+                         result.nil? ? global.pair(p) : result.find_property(p)
+                       end
+                     end
+            break if result.nil?
+
+            prev = result
+            resolved += 1
+          end
+          if prev.nil?
+            remainder = ''
+            prev = degraved
+          else
+            remainder = resolved < parts.length ? '.' + parts[resolved..parts.length].join('.') : ''
+          end
+          [prev, remainder]
+        else
+          # Remove the graves if there are any.
+          result = parts[0]
+          i = 1
+          while i < parts.length
+            result = StandardMethods.run_method(parts[i], result)
+            i += 1
+          end
+          [result, '']
+        end
+      end
+
+    end
+  end
+end

data/lib/modl/parser/substitutions.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Modl
+  module Parser
+    # Escape-sequence replacements for MODL files.
+    class Substitutions
+
+      @@subs = [
+          ['~\\', '\\'],
+          ['\\\\', '\\'],
+          ['~~', '~'],
+          ['\\~', '~'],
+          ['~(', '('],
+          ['\\(', '('],
+          ['~)', ')'],
+          ['\\)', ')'],
+          ['~[', '['],
+          ['\\[', '['],
+          ['~]', ']'],
+          ['\\]', ']'],
+          ['~{', '{'],
+          ['\\{', '{'],
+          ['~}', '}'],
+          ['\\}', '}'],
+          ['~;', ';'],
+          ['\\;', ';'],
+          ['~:', ':'],
+          ['\\:', ':'],
+          ['~`', '`'],
+          ['\\`', '`'],
+          ['~"', '"'],
+          ['\\"', '"'],
+          ['~=', '='],
+          ['\\=', '='],
+          ['~/', '/'],
+          ['\\/', '/'],
+          ['<', '<'],
+          ['\\<', '<'],
+          ['~>', '>'],
+          ['\\>', '>'],
+          ['~&', '&'],
+          ['\\&', '&'],
+          ['!', '!'],
+          ['\\!', '!'],
+          ['~|', '|'],
+          ['\\|', '|'],
+          ['\\t', "\t"],
+          ['\\n', "\n"],
+          ['\\b', "\b"],
+          ['\\f', "\f"],
+          ['\\r', "\r"]
+      ]
+
+      # Replace all escape sequences in the supplied string and return the new value.
+      def self.process(str)
+        @@subs.each do |s|
+          loop do
+            prev = str
+            str = str.sub(s[0], s[1])
+            break unless str && str != prev
+          end
+        end
+        str
+      end
+    end
+  end
+end

data/lib/modl/parser/sutil.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Sutil
+  # Remove the first n characters from a string
+  def self.tail(str, n = 1)
+    return if n.negative?
+
+    str&.slice(n, str.length)
+  end
+
+  # Keep the first n characters of a string
+  def self.head(str, n = nil)
+    return if str.nil?
+
+    n = str.length - 1 if n.nil? # Strip last char by default
+
+    str&.slice(0, n)
+  end
+
+  # Keep everything until char c
+  def self.until(str, c)
+    return str if c.nil? || c.empty?
+
+    i = str.index(c)
+    i ? str&.slice(0, i) : str
+  end
+
+  # Get everything after char c
+  def self.after(str, c)
+    return if str.nil?
+    return str if c.nil?
+
+    i = str.index(c)
+    return '' if i.nil?
+
+    str.slice(i + c.length, str.length)
+  end
+
+  # Get everything between ch1 and ch2
+  # ch1 and ch2 must be different and ch1 must be before ch2 in the string
+  # e.g. Sutil.between('func(p1,p2)', '(', ')') returns 'p1,p2'
+  def self.between(str, ch1, ch2)
+    return if str.nil?
+    return str if ch1.nil? || ch2.nil? || ch1 == '' || ch2 == ''
+    return str if str.length < 3
+
+    first = str.index(ch1)
+    second = str.rindex(ch2)
+    if first > second
+      tmp = first
+      first = second
+      second = tmp
+    end
+    return str if first == second
+
+    str.slice(first + 1, second - first - 1)
+  end
+
+  # Remove the first and last chars from a string.
+  def self.toptail(str)
+    return str if str.nil?
+    return '' if str.length < 3
+
+    str&.slice(1, str.length - 2)
+  end
+
+  def self.replace(str, old, new)
+    return str if old.nil? || new.nil? || old.empty? || old == new
+
+    result = str
+    loop do
+      break unless result.include?(old)
+
+      result = result.sub(old, new)
+    end
+    result
+  end
+end

data/lib/modl/parser/throwing_error_listener.rb

@@ -0,0 +1,20 @@
+require 'antlr4/runtime/parse_cancellation_exception'
+
+module Modl::Parser
+  class ThrowingErrorListener
+    include Singleton
+
+    def syntax_error(_recognizer, _offending_symbol, _line, _char_position_in_line, _msg, _e)
+      raise Antlr4::Runtime::ParseCancellationException, 'line' + _line.to_s + ':' + _char_position_in_line.to_s + ' ' + _msg.to_s
+    end
+
+    def report_ambiguity(_recognizer, _dfa, _start_index, _stop_index, _exact, _ambig_ilts, _configs)
+    end
+
+    def report_attempting_full_context(_recognizer, _dfa, _start_index, _stop_index, _conflicting_alts, _configs)
+    end
+
+    def report_context_sensitivity(_recognizer, _dfa, _start_index, _stop_index, _prediction, _configs)
+    end
+  end
+end

data/lib/modl/parser/version.rb

@@ -0,0 +1,5 @@
+module Modl
+  module Parser
+    VERSION = "0.3.0"
+  end
+end

data/modl.gemspec

@@ -0,0 +1,32 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "modl/parser/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "modl"
+  spec.version       = Modl::Parser::VERSION
+  spec.authors       = ["Tony Walmsley"]
+  spec.email         = ["tony@aosd.co.uk"]
+
+  spec.summary       = %q{The ANTLR4 Lexer and Parser for MODL generated using the Ruby language target.}
+  spec.description   = %q{Contains the base Lexer, Parser, and supporting classes for a MODL parser.}
+  spec.homepage      = "https://github.com/MODLanguage/ruby-interpreter"
+  spec.license       = "MIT"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  #spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency 'antlr4-runtime', '>= 0.0.1'
+  spec.add_runtime_dependency 'antlr4-runtime', '>= 0.0.1'
+  spec.add_runtime_dependency 'punycode4r', '>= 0.2.0'
+end

metadata

@@ -1,23 +1,150 @@
 --- !ruby/object:Gem::Specification
 name: modl
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.3.0
 platform: ruby
 authors:
-- Elliott Brown
+- Tony Walmsley
 autorequire: 
-bindir: bin
+bindir: exe
 cert_chain: []
-date: 2017-10-24 00:00:00.000000000 Z
-dependencies: []
-description: A MODL interpreter
-email: gem@modl.uk
+date: 2019-05-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: antlr4-runtime
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+- !ruby/object:Gem::Dependency
+  name: antlr4-runtime
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+- !ruby/object:Gem::Dependency
+  name: punycode4r
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+description: Contains the base Lexer, Parser, and supporting classes for a MODL parser.
+email:
+- tony@aosd.co.uk
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/modl.rb
-homepage: http://rubygems.org/gems/modl
+- ".gitignore"
+- ".idea/vcs.xml"
+- ".rspec"
+- ".rubocop.yml"
+- ".travis.yml"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- grammar_tests/1.modl
+- grammar_tests/2.modl
+- grammar_tests/3.modl
+- grammar_tests/a.modl
+- grammar_tests/b.modl
+- grammar_tests/base_tests.json
+- grammar_tests/c.modl
+- grammar_tests/demo_config.modl
+- grammar_tests/error_tests.json
+- grammar_tests/import_config.modl
+- grammar_tests/test_import_dir/nested_import1.txt
+- grammar_tests/test_import_dir/nested_import2.txt
+- grammar_tests/test_import_dir/nested_import3.txt
+- grammar_tests/test_import_dir/test_import.txt
+- lib/modl/interpreter.rb
+- lib/modl/parser/MODLLexer.interp
+- lib/modl/parser/MODLLexer.rb
+- lib/modl/parser/MODLLexer.tokens
+- lib/modl/parser/MODLParser.interp
+- lib/modl/parser/MODLParser.rb
+- lib/modl/parser/MODLParser.tokens
+- lib/modl/parser/MODLParserBaseListener.rb
+- lib/modl/parser/MODLParserBaseVisitor.rb
+- lib/modl/parser/MODLParserListener.rb
+- lib/modl/parser/MODLParserVisitor.rb
+- lib/modl/parser/class_processor.rb
+- lib/modl/parser/evaluator.rb
+- lib/modl/parser/file_importer.rb
+- lib/modl/parser/global_parse_context.rb
+- lib/modl/parser/instruction_processor.rb
+- lib/modl/parser/interpreter.rb
+- lib/modl/parser/modl_class.rb
+- lib/modl/parser/modl_index.rb
+- lib/modl/parser/modl_keylist.rb
+- lib/modl/parser/modl_method.rb
+- lib/modl/parser/object_cache.rb
+- lib/modl/parser/parsed.rb
+- lib/modl/parser/parser.rb
+- lib/modl/parser/ref_processor.rb
+- lib/modl/parser/substitutions.rb
+- lib/modl/parser/sutil.rb
+- lib/modl/parser/throwing_error_listener.rb
+- lib/modl/parser/version.rb
+- modl.gemspec
+homepage: https://github.com/MODLanguage/ruby-interpreter
 licenses:
 - MIT
 metadata: {}
@@ -37,8 +164,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.12
+rubygems_version: 2.7.9
 signing_key: 
 specification_version: 4
-summary: MODL
+summary: The ANTLR4 Lexer and Parser for MODL generated using the Ruby language target.
 test_files: []

data/lib/modl.rb

@@ -1,5 +0,0 @@
-class Modl
-  def self.hi
-    puts "MODL"
-  end
-end