modl 0.3.25 → 0.3.27

data/lib/modl/parser/parsed.rb

@@ -1,1470 +0,0 @@
-# frozen_string_literal: true
-
-# The MIT License (MIT)
-#
-# Copyright (c) 2019 NUM Technology Ltd
-#
-# 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.
-
-require 'modl/parser/MODLParserBaseListener'
-require 'modl/parser/global_parse_context'
-require 'modl/parser/ref_processor'
-require 'modl/parser/unicode_escapes'
-require 'modl/parser/substitutions'
-require 'modl/parser/file_importer'
-require 'antlr4/runtime/parse_cancellation_exception'
-require 'modl/parser/sutil'
-require 'modl/parser/modl_class'
-require 'modl/parser/modl_method'
-require 'modl/parser/modl_index'
-require 'modl/parser/modl_keylist'
-require 'modl/parser/evaluator'
-require 'cgi'
-require 'net/http'
-
-module MODL
-  module Parser
-    # This class represents a MODL parse tree for a given MODL object.
-    # It tries to process the parse tree as it is generated as much as
-    # possible to save revisiting nodes unnecessarily.
-    #
-    # Many of the method names are generated by ANTLR4 so are not ruby style.
-    class Parsed < MODL::Parser::MODLParserBaseListener
-      attr_accessor :structures
-      attr_accessor :global
-
-      def initialize(global = nil)
-        @global = global
-        @structures = []
-      end
-
-      def enterModl(ctx)
-
-        @global = GlobalParseContext.new if @global.nil?
-
-        ctx_modl_structure = ctx.modl_structure
-        ctx_modl_structure.each do |str|
-          structure = ParsedStructure.new @global
-          str.enter_rule(structure)
-          @structures << structure
-        end
-
-        @structures = @global.structures + @structures
-
-        @global
-      end
-
-      def self.additional_string_processing(text)
-        # Special case for a possibly empty graved string ``
-        unless text.nil?
-          match_data = /^`([^`]*)`$/.match text
-          return match_data[1] if match_data&.length&.positive?
-        end
-        text
-      end
-
-      # Class to represent a parsed grammar object
-      class ParsedMap < MODL::Parser::MODLParserBaseListener
-        attr_accessor :mapItems
-
-        def initialize(global)
-          @global = global
-          @mapItems = []
-        end
-
-        def find_property(key)
-          if key.is_a? Integer
-            return @mapItems[key]
-          else
-            @mapItems.each do |mi|
-              return mi.pair if mi.pair.key == key
-            end
-          end
-        end
-
-        def enterModl_map(ctx)
-          modl_map_item = ctx.modl_map_item
-          return if modl_map_item.nil?
-
-          modl_map_item.each do |mi|
-            map_item = ParsedMapItem.new @global
-            mi.enter_rule(map_item)
-            @mapItems << map_item
-          end
-        end
-
-        def extract_hash
-          result = {}
-          @mapItems.each do |i|
-            i_hash = i.extract_hash
-            next unless i_hash.is_a? Hash
-
-            i_hash.keys.each do |k|
-              result[k] = i_hash[k]
-            end
-          end
-          result.is_a?(Array) && result.length == 1 ? result[0] : result
-        end
-
-      end
-
-      # Class to represent a parsed grammar object
-      class ParsedMapItem < MODL::Parser::MODLParserBaseListener
-        attr_accessor :pair
-        attr_accessor :mapConditional
-
-        def initialize(global)
-          @global = global
-        end
-
-        def enterModl_map_item(ctx)
-          modl_pair = ctx.modl_pair
-          unless modl_pair.nil?
-            @pair = ParsedPair.new @global
-            modl_pair.enter_rule(@pair)
-          end
-          modl_map_conditional = ctx.modl_map_conditional
-          return if modl_map_conditional.nil?
-
-          @mapConditional = ParsedMapConditional.new @global
-          modl_map_conditional.enter_rule(@mapConditional)
-        end
-
-        def extract_hash
-          return @pair.extract_hash if @pair
-          return @mapConditional.extract_hash if @mapConditional
-        end
-
-      end
-
-      # Class to represent a parsed grammar object
-      class ParsedStructure < MODL::Parser::MODLParserBaseListener
-        attr_accessor :array
-        attr_accessor :pair
-        attr_accessor :top_level_conditional
-        attr_accessor :map
-
-        def initialize(global)
-          @global = global
-        end
-
-        def enterModl_structure(ctx)
-          modl_pair = ctx.modl_pair
-          modl_top_level_conditional = ctx.modl_top_level_conditional
-          modl_map = ctx.modl_map
-          modl_array = ctx.modl_array
-
-          if !modl_pair.nil?
-            @pair = ParsedPair.new @global
-            modl_pair.enter_rule(@pair)
-          elsif !modl_top_level_conditional.nil?
-            @top_level_conditional = ParsedTopLevelConditional.new @global
-            modl_top_level_conditional.enter_rule(@top_level_conditional)
-          elsif !modl_map.nil?
-            @map = ParsedMap.new @global
-            modl_map.enter_rule(@map)
-          elsif !modl_array.nil?
-            @array = ParsedArray.new @global
-            modl_array.enter_rule(@array)
-          end
-        end
-
-        def extract_hash
-          return @array.extract_hash if @array
-          return @pair.extract_hash if @pair
-          return @top_level_conditional.extract_hash if @top_level_conditional
-          return @map.extract_hash if @map
-        end
-      end
-
-      # Class to represent a parsed grammar object
-      class ParsedPair < MODL::Parser::MODLParserBaseListener
-        attr_accessor :key
-        attr_accessor :map
-        attr_accessor :array
-        attr_accessor :valueItem
-        attr_accessor :key_lists
-        attr_accessor :type # A string set to the type of pair that we have found bases on its key
-        attr_accessor :text # The simple text value rather than the object
-        attr_accessor :final
-        attr_accessor :loaded # For *load instructions so we don't load twice
-
-
-        def initialize(global)
-          @global = global
-          @needs_defref = true
-          @final = false
-          @file_importer = FileImporter.instance
-          @loaded = false
-          @array = nil
-          @map = nil
-        end
-
-        def find_property(key)
-          return self if key == @key
-
-          return @map.find_property(key) if @map
-          return @array.find_property(key) if @array
-          return @valueItem.find_property(key) if @valueItem
-        end
-
-        # Set the appropriate field base on the value type
-        def set_value(value)
-          if value.is_a? Array
-            @map = nil
-            @array = ParsedArray.new @global
-            @array.abstractArrayItems = []
-            value.each do |item|
-              array_item = ParsedArrayItem.new @global
-              array_item.arrayValueItem = ParsedArrayValueItem.new @global
-              array_item.arrayValueItem.primitive = ParsedPrimitive.new(@global)
-              array_item.arrayValueItem.primitive.string = ParsedString.new(item)
-              array_item.arrayValueItem.primitive.text = item
-              @array.abstractArrayItems << array_item
-            end
-            @valueItem = nil
-            @text = @array.extract_hash
-            return
-          elsif value.is_a?(ParsedPair)
-            @map = value.map ? value.map : nil
-            @array = value.array ? value.array : nil
-            @valueItem = value.valueItem ? value.valueItem : nil
-            return
-          elsif value.is_a?(TrueClass) || value.is_a?(FalseClass)
-            @map = nil
-            @array = nil
-            @valueItem = ParsedValueItem.new @global
-            @valueItem.value = ParsedValue.new @global
-            @valueItem.value.primitive = ParsedPrimitive.new(@global)
-            if value
-              @valueItem.value.primitive.trueVal = ParsedTrue.instance
-            else
-              @valueItem.value.primitive.falseVal = ParsedFalse.instance
-            end
-            @valueItem.value.primitive.text = value
-            @valueItem.value.text = value
-            @text = value
-            return
-          end
-          value = value.extract_hash unless value.is_a?(String) || value.is_a?(Integer)
-          @map = nil
-          @array = nil
-          @valueItem = ParsedValueItem.new @global
-          @valueItem.value = ParsedString.new(value)
-          @text = value
-        end
-
-        # Convert this object to a simple hash ready for JSON.generate
-        def extract_hash
-
-          value = @array.extract_hash if @array
-          value = @valueItem.extract_hash if @valueItem
-          value = @map.extract_hash if @map
-
-          @text = value
-
-          return if @type == 'index'
-          return if @type == 'hidden'
-          return if @type == 'version'
-          return if @type == 'class'
-          return if @type == 'method'
-          return if @type == 'import'
-          return if @type == 'allow'
-          return if @type == 'expect'
-
-          formatted_key = Substitutions.process UnicodeEscapes.process @key
-          {formatted_key => @text}
-        end
-
-        def enterModl_pair(ctx)
-          @type = 'pair' # default the type to an ordinary pair
-
-          ctx_string = ctx.STRING
-          @key = ctx_string.to_s unless ctx_string.nil?
-          ctx_quoted = ctx.QUOTED
-          unless ctx_quoted.nil?
-            @key = ctx_quoted.to_s
-            @key = Sutil.toptail(@key) # remove the quotes
-          end
-
-          raise InterpreterError, 'Invalid key - null, true, or false keys are not allowed.' if @key.nil?
-
-          if @key.include?('%') || @key.include?('`')
-            @key, new_value = RefProcessor.deref @key, @global
-            unless @key.is_a?(String)
-              raise InterpreterError, "Error: '" + @key.to_s + "' is an invalid key." if new_value.nil?
-              @key = new_value.is_a?(String) ? new_value : new_value.text
-            end
-            raise InterpreterError, "Error: '" + @key.to_s + "' should de-ref to a string." unless key.is_a?(String)
-          end
-
-          @final = true if @key.upcase == @key
-
-          modl_array = ctx.modl_array
-          modl_map = ctx.modl_map
-          modl_value_item = ctx.modl_value_item
-
-          if !modl_array.nil?
-            @array = ParsedArray.new @global
-            modl_array.enter_rule(@array)
-          elsif !modl_map.nil?
-            @map = ParsedMap.new @global
-            modl_map.enter_rule(@map)
-          elsif !modl_value_item.nil?
-            @valueItem = ParsedValueItem.new @global
-            modl_value_item.enter_rule(@valueItem)
-          end
-
-          set_pair_type
-          raise InterpreterError, 'Invalid keyword: ' + @key if @type == 'pair' && @key.start_with?('*')
-
-          validate_key if @type == 'pair' || @type == 'hidden'
-
-          # Type-specific processing
-          case @type
-          when 'class'
-            ClassExtractor.extract(self, @global)
-          when 'id'
-            extract_value
-          when 'name'
-            extract_value
-          when 'superclass'
-            extract_value
-          when 'allow'
-            extract_value
-          when 'keylist'
-            KeylistExtractor.extract(self, @valueItem) if @valueItem
-            KeylistExtractor.extract(self, @array) if @array
-          when 'version'
-            extract_value
-
-            raise InterpreterError, 'Invalid MODL version: ' + @valueItem.value.primitive.text if @valueItem.value.primitive.number.nil?
-            raise InterpreterError, 'Invalid MODL version: ' + @valueItem.value.primitive.number.num.to_s if @valueItem.value.primitive.number.num.is_a? Float
-            raise InterpreterError, 'Invalid MODL version: ' + @valueItem.value.primitive.number.num.to_s if @valueItem.value.primitive.number.num.zero?
-            raise InterpreterError, 'MODL version should be on the first line if specified.' if @global.has_pairs?
-            @global.syntax_version = @valueItem.value.primitive.number.num
-
-          when 'method'
-            MethodExtractor.extract(self, @global)
-          when 'transform'
-            extract_transform @valueItem
-          when 'import'
-            files = @valueItem.extract_hash if @valueItem
-            files = @array.extract_hash if @array
-            @file_importer.import_files files, @global unless @global.in_condition?
-          when 'index'
-            IndexExtractor.extract(self, @global)
-          when 'hidden'
-            extract_value
-          else
-            extract_value
-          end
-
-          return if @global.in_condition? # Don't store pairs in conditionals until we evaluate the conditions
-
-          if @key.start_with? '_'
-            k = Sutil.tail(@key)
-            existing = @global.pair(k)
-            raise InterpreterError, 'Already defined ' + k + ' as final.' if existing&.final && @type != "import"
-            raise InterpreterError, 'Cannot load multiple files after *LOAD instruction' if existing&.final && @type == "import"
-
-            @global.pair(k, self)
-          end
-          existing = @global.pair(@key)
-          raise InterpreterError, 'Already defined ' + @key + ' as final.' if existing&.final && @type != "import"
-          raise InterpreterError, 'Cannot load multiple files after *LOAD instruction' if existing&.final && @type == "import"
-
-          @global.pair(@key, self)
-        end
-
-        private
-
-        def extract_value
-          item = @valueItem
-          @text = item.value.text if item.is_a?(ParsedValueItem) && item.value
-          @text = item.valueItem.value.text if item.is_a?(ParsedPair)
-          invoke_deref
-        end
-
-        def extract_transform item
-          @transform = item.value.primitive.string.string
-        end
-
-        def validate_key
-          invalid_chars = "£!$@-+'*#^&"
-          invalid_chars.each_char do |c|
-            next unless @key.include?(c)
-
-            raise InterpreterError, 'Invalid key - "' + c + '" character not allowed: ' + @key
-          end
-
-          key = @key.start_with?('_') ? Sutil.tail(@key) : @key
-          raise InterpreterError, 'Invalid key - "' + key + '" - entirely numeric keys are not allowed: ' + @key if key == key.to_i.to_s
-        end
-
-        def invoke_deref
-          return unless @needs_defref && !@text.nil? && @text.is_a?(String) && @text.include?('%')
-
-          @needs_defref = false
-          @text, new_value = RefProcessor.deref @text, @global
-
-          if new_value.is_a? ParsedMap
-            @map = new_value
-            @valueItem = nil
-            @array = nil
-          elsif new_value.is_a? ParsedArray
-            @array = new_value
-            @valueItem = nil
-            @map = nil
-          elsif new_value.is_a? ParsedValueItem
-            @valueItem = new_value
-          elsif new_value.nil?
-            set_value @text
-          elsif new_value.is_a? ParsedPair
-            set_value @text if @text
-            set_value new_value if @text.nil?
-          elsif new_value.is_a? String
-            set_value @text
-          else
-            set_value(new_value)
-          end
-        end
-
-        # Set the pair type if its a 'special' type
-        def set_pair_type
-          @type = 'class' if @key == '*c' || @key == '*class'
-          if @key == '*C' || @key == '*CLASS'
-            @type = 'class'
-            @key = @key.downcase
-          end
-          @type = 'id' if @key == '*i' || @key == '*id'
-          @type = 'name' if @key == '*n' || @key == '*name'
-          @type = 'name' if @key == '*N' || @key == '*NAME'
-          @type = 'superclass' if @key == '*S' || @key == '*SUPERCLASS'
-          @type = 'superclass' if @key == '*s' || @key == '*superclass'
-          @type = 'keylist' if @key == '*a' || @key == '*assign'
-          @type = 'version' if @key == '*V' || @key == '*VERSION'
-          @type = 'method' if @key == '*m' || @key == '*method'
-          @type = 'transform' if @key == '*t' || @key == '*transform'
-          if @key == '*L' || @key == '*LOAD'
-            @key = @key.downcase
-            @type = 'import'
-            if @array
-              @global.freeze_max_files(@array.abstractArrayItems.length)
-            elsif @valueItem&.value&.array
-              @global.freeze_max_files(@valueItem&.value&.array.abstractArrayItems.length)
-            elsif @valueItem&.value&.nbArray
-              @global.freeze_max_files(@valueItem&.value&.nbArray.arrayItems.length)
-            else
-              @global.freeze_max_files(1)
-            end
-          end
-          if @key == '*l' || @key == '*load'
-            @type = 'import'
-          end
-          @type = 'index' if @key == '?'
-          @type = 'hidden' if @key.start_with? '_'
-          @type = 'allow' if @key.downcase == '*allow'
-          @type = 'expect' if @key.downcase == '*expect'
-        end
-      end
-
-      # Class to represent a parsed grammar object
-      class ParsedArrayValueItem < MODL::Parser::MODLParserBaseListener
-        attr_accessor :map
-        attr_accessor :array
-        attr_accessor :pair
-        attr_accessor :primitive
-        attr_accessor :text # The simple text value rather than the object
-
-        def initialize(global)
-          @global = global
-        end
-
-        def find_property(key)
-          return @map.find_property(key) if @map
-          return @array.find_property(key) if @array
-          return @nbArray.find_property(key) if @nbArray
-          return @pair.find_property(key) if @pair
-          return @primitive.find_property(key) if @primitive
-        end
-
-        def extract_hash
-          return @map.extract_hash if @map
-          return @array.extract_hash if @array
-          return @nbArray.extract_hash if @nbArray
-          return @pair.extract_hash if @pair
-          return @primitive.extract_hash if @primitive
-
-          @text
-        end
-
-        def enterModl_array_value_item(ctx)
-          @text = nil
-          modl_map = ctx.modl_map
-          modl_array = ctx.modl_array
-          modl_pair = ctx.modl_pair
-          modl_primitive = ctx.modl_primitive
-
-          if !modl_map.nil?
-            @map = ParsedMap.new @global
-            modl_map.enter_rule(@map)
-          elsif !modl_array.nil?
-            @array = ParsedArray.new @global
-            modl_array.enter_rule(@array)
-          elsif !modl_pair.nil?
-            @pair = ParsedPair.new @global
-            modl_pair.enter_rule(@pair)
-          elsif !modl_primitive.nil?
-            @primitive = ParsedPrimitive.new @global
-            modl_primitive.enter_rule(@primitive)
-            @text = @primitive.text
-          end
-
-          # ignoring comments!
-        end
-      end
-
-      # Class to represent a parsed grammar object
-      class ParsedValueItem < MODL::Parser::MODLParserBaseListener
-        attr_accessor :value
-        attr_accessor :valueConditional
-
-        def initialize(global)
-          @global = global
-        end
-
-        def find_property(key)
-          @value.find_property(key) if @value
-        end
-
-        def enterModl_value_item(ctx)
-          modl_value_conditional = ctx.modl_value_conditional
-          unless modl_value_conditional.nil?
-            @valueConditional = ParsedValueConditional.new @global
-            modl_value_conditional.enter_rule(@valueConditional)
-          end
-          modl_value = ctx.modl_value
-          return if modl_value.nil?
-          @value = ParsedValue.new @global
-          modl_value.enter_rule(@value)
-        end
-
-        def extract_hash
-          return @value.extract_hash if @value
-          return @valueConditional.extract_hash if @valueConditional
-        end
-
-      end
-
-      # Class to represent a parsed grammar object
-      class ParsedValue < MODL::Parser::MODLParserBaseListener
-        attr_accessor :map
-        attr_accessor :array
-        attr_accessor :nbArray
-        attr_accessor :pair
-        attr_accessor :primitive
-        attr_accessor :text # The simple text value rather than the object
-
-        def initialize(global)
-          @global = global
-        end
-
-        def find_property(key)
-          return @map.find_property(key) if @map
-          return @array.find_property(key) if @array
-          return @nbArray.find_property(key) if @nbArray
-          return @pair.find_property(key) if @pair
-          return @primitive.find_property(key) if @primitive
-        end
-
-        def extract_hash
-          return @map.extract_hash if @map
-          return @array.extract_hash if @array
-          return @nbArray.extract_hash if @nbArray
-          return @pair.extract_hash if @pair
-          return @primitive.extract_hash if @primitive
-
-          @text
-        end
-
-        def evaluate
-          return @primitive.evaluate if @primitive
-
-          true
-        end
-
-        def value_obj
-          return @map if @map
-          return @array if @array
-          return @nbArray if @nbArray
-          return @pair if @pair
-          return @primitive if @primitive
-        end
-
-        def enterModl_value(ctx)
-          modl_map = ctx.modl_map
-          modl_nb_array = ctx.modl_nb_array
-          modl_array = ctx.modl_array
-          modl_pair = ctx.modl_pair
-          modl_primitive = ctx.modl_primitive
-
-          if !modl_map.nil?
-            @map = ParsedMap.new @global
-            modl_map.enter_rule(@map)
-          elsif !modl_nb_array.nil?
-            @nbArray = ParsedNbArray.new @global
-            modl_nb_array.enter_rule(@nbArray)
-          elsif !modl_array.nil?
-            @array = ParsedArray.new @global
-            modl_array.enter_rule(@array)
-          elsif !modl_pair.nil?
-            @pair = ParsedPair.new @global
-            modl_pair.enter_rule(@pair)
-          elsif !modl_primitive.nil?
-            @primitive = ParsedPrimitive.new @global
-            modl_primitive.enter_rule(@primitive)
-            @text = @primitive.text
-          end
-          # ignoring comments!
-        end
-      end
-
-      # Class to represent a parsed grammar object
-      class ParsedPrimitive < MODL::Parser::MODLParserBaseListener
-        attr_accessor :quoted
-        attr_accessor :number
-        attr_accessor :trueVal
-        attr_accessor :falseVal
-        attr_accessor :nilVal
-        attr_accessor :string
-        attr_accessor :constant
-        attr_accessor :text # The simple text value rather than the object
-
-        def initialize(global)
-          @global = global
-          @constant = false
-        end
-
-        def find_property(key)
-          if @string
-            user_method = @global.user_method(key)
-            if user_method
-              return user_method.run(@string.string)
-            end
-            StandardMethods.run_method(key, Substitutions.process(UnicodeEscapes.process(@string.string)))
-          end
-        end
-
-        def extract_hash
-          result, _ignore = RefProcessor.deref(@text, @global) unless @constant
-          result = @text if @constant
-          Substitutions.process UnicodeEscapes.process result
-        end
-
-        def evaluate
-          return false if @nilVal
-          return false if @falseVal
-
-          true
-        end
-
-        def value_obj
-          return @quoted if @quoted
-          return @number if @number
-          return @trueVal if @trueVal
-          return @falseVal if @falseVal
-          return @nilVal if @nilVal
-          return @string if @string
-
-          @text
-        end
-
-        def enterModl_primitive(ctx)
-          ctx_number = ctx.NUMBER
-          ctx_string = ctx.STRING
-          ctx_quoted = ctx.QUOTED
-          ctx_null = ctx.NULL
-          ctx_true = ctx.TRUE
-          ctx_false = ctx.FALSE
-
-          if !ctx_number.nil?
-            @number = ParsedNumber.new(ctx_number.text)
-            @text = @number.num
-          elsif !ctx_string.nil?
-            @text = ctx_string.text
-
-            @constant = @text.start_with?('`') && !@text.include?('%') && !@text.include?('`.')
-            @string = ParsedString.new(@text)
-            @text = @string.string
-          elsif !ctx_quoted.nil?
-            @constant = true
-            @text = Sutil.toptail ctx_quoted.text
-            @quoted = ParsedQuoted.new(@text)
-          elsif !ctx_null.nil?
-            @nilVal = ParsedNull.instance
-            @text = nil
-          elsif !ctx_true.nil?
-            @trueVal = ParsedTrue.instance
-            @text = true
-          elsif !ctx_false.nil?
-            @falseVal = ParsedFalse.instance
-            @text = false
-          end
-          # ignoring comments!
-        end
-      end
-
-      # Class to represent a parsed grammar object
-      class ParsedString
-        attr_accessor :string
-
-        def initialize(string)
-          @string = string
-        end
-
-        def text
-          @string
-        end
-
-        def extract_hash
-          @string = Substitutions.process UnicodeEscapes.process @string
-        end
-      end
-
-      # Class to represent a parsed grammar object
-      class ParsedNumber
-        attr_accessor :num
-
-        def initialize(string)
-          @num = string.include?('.') ? string.to_f : string.to_i
-        end
-      end
-
-      # Class to represent a parsed grammar object
-      class ParsedQuoted
-        attr_accessor :string
-
-        def initialize(string)
-          @string = string
-        end
-      end
-
-      # Class to represent a parsed grammar object
-      class ParsedConditionTest < MODL::Parser::MODLParserBaseListener
-        attr_accessor :subConditionList
-
-        def initialize(global)
-          @global = global
-          @subConditionList = []
-        end
-
-        def evaluate
-          result = false
-          @subConditionList.each do |s|
-            last_operator = s.b.a
-            should_negate = s.b.b
-
-            partial = s.a.evaluate
-            case last_operator
-            when '&'
-              result &= should_negate ? !partial : partial
-            when '|'
-              result |= should_negate ? !partial : partial
-            else
-              result |= should_negate ? !partial : partial
-            end
-          end
-          result
-        end
-
-        def enterModl_condition_test(ctx)
-          ctx_children = ctx.children
-          unless ctx_children.empty?
-            last_operator = nil
-            should_negate = false
-            ctx_children.each do |child|
-              if child.is_a? MODLParser::Modl_condition_groupContext
-                condition_group = ParsedConditionGroup.new @global
-                child.enter_rule(condition_group)
-
-                p2 = OpenStruct.new
-                p2.a = last_operator
-                p2.b = should_negate
-
-                p1 = OpenStruct.new
-                p1.a = condition_group
-                p1.b = p2
-
-                @subConditionList << p1
-
-                last_operator = nil
-                should_negate = false
-              elsif child.is_a? MODLParser::Modl_conditionContext
-                condition = ParsedCondition.new @global
-                child.enter_rule(condition)
-                p2 = OpenStruct.new
-                p2.a = last_operator
-                p2.b = should_negate
-
-                p1 = OpenStruct.new
-                p1.a = condition
-                p1.b = p2
-
-                @subConditionList << p1
-
-                last_operator = nil
-                should_negate = false
-              else
-                if child.text == '!'
-                  should_negate = true
-                else
-                  last_operator = child.text
-                end
-              end
-            end
-          end
-        end
-      end
-
-      # Class to represent a parsed grammar object
-      class ParsedConditionGroup < MODL::Parser::MODLParserBaseListener
-        attr_accessor :conditionsTestList
-
-        def initialize(global)
-          @global = global
-          @conditionsTestList = []
-        end
-
-        def evaluate
-          result = false
-          @conditionsTestList.each do |s|
-            partial = s.a.evaluate
-            result |= partial
-          end
-          result
-        end
-
-        def enterModl_condition_group(ctx)
-          ctx_children = ctx.children
-          return if ctx_children.empty?
-
-          last_operator = nil
-          ctx_children.each do |child|
-            if child.is_a? MODLParser::Modl_condition_testContext
-              condition_test = ParsedConditionTest.new @global
-              child.enter_rule(condition_test)
-              p = OpenStruct.new
-              p.a = condition_test
-              p.b = last_operator
-              @conditionsTestList << p
-              last_operator = nil
-            else
-              last_operator = child.text if (child.text != '') && (child.text != '}')
-            end
-          end
-        end
-      end
-
-      # Class to represent a parsed grammar object
-      class ParsedCondition < MODL::Parser::MODLParserBaseListener
-        attr_accessor :values
-        attr_accessor :operator
-        attr_accessor :text
-
-        def initialize(global)
-          @global = global
-          @values = []
-        end
-
-        def evaluate
-          Evaluator.evaluate(@global, self)
-        end
-
-        def enterModl_condition(ctx)
-          modl_operator = ctx.modl_operator
-          @operator = modl_operator.text unless modl_operator.nil?
-          modl_value = ctx.modl_value
-          modl_value.each do |v|
-            value = ParsedValue.new @global
-            v.enter_rule(value)
-            @values << value
-          end
-          ctx_string = ctx.STRING
-          if !ctx_string.nil?
-            @text = Parsed.additional_string_processing(ctx_string.text)
-            @string = ParsedString.new(@text)
-            @text = @string.string
-          end
-        end
-      end
-
-      # Class to represent a parsed grammar object
-      class ParsedMapConditionalReturn < MODL::Parser::MODLParserBaseListener
-        attr_accessor :mapItems
-
-        def initialize(global)
-          @global = global
-          @mapItems = []
-        end
-
-        def extract_hash
-          @mapItems[0].extract_hash
-        end
-
-        def enterModl_map_conditional_return(ctx)
-          modl_map_item = ctx.modl_map_item
-          return if modl_map_item.empty?
-
-          modl_map_item.each do |mi|
-            map_item = ParsedMapItem.new @global
-            mi.enter_rule(map_item)
-            @mapItems << map_item
-          end
-        end
-      end
-
-      # Class to represent a parsed grammar object
-      class ParsedMapConditional < MODL::Parser::MODLParserBaseListener
-        attr_accessor :conditionTests
-        attr_accessor :mapConditionalReturns
-
-        def initialize(global)
-          @global = global
-          @conditionTests = []
-          @mapConditionalReturns = []
-        end
-
-        def extract_hash
-          return @mapConditionalReturns[0].extract_hash if @result
-
-          @mapConditionalReturns[1].extract_hash if @mapConditionalReturns.length > 1
-        end
-
-        def enterModl_map_conditional(ctx)
-          i = 0
-          modl_condition_test = ctx.modl_condition_test
-          ctx_modl_map_conditional_return = ctx.modl_map_conditional_return
-
-          while i < modl_condition_test.size
-            condition_test = ParsedConditionTest.new @global
-            ctx.modl_condition_test_i(i).enter_rule(condition_test)
-
-            conditional_return = ParsedMapConditionalReturn.new @global
-            ctx.modl_map_conditional_return_i(i).enter_rule(conditional_return)
-            @conditionTests[i] = condition_test
-            @mapConditionalReturns[i] = conditional_return
-
-            if ctx_modl_map_conditional_return.size > modl_condition_test.size
-              i += 1
-              conditional_return = ParsedMapConditionalReturn.new @global
-              ctx.modl_map_conditional_return_i(ctx_modl_map_conditional_return.size - 1).enter_rule(conditional_return)
-              @mapConditionalReturns[i] = conditional_return
-            end
-            i += 1
-          end
-          @result = @conditionTests[0].evaluate
-        end
-      end
-
-      # Class to represent a parsed grammar object
-      class ParsedTopLevelConditionalReturn < MODL::Parser::MODLParserBaseListener
-        attr_accessor :structures
-
-        def initialize(global)
-          @global = global
-          @structures = []
-        end
-
-        def extract_hash
-          return @structures[0].extract_hash if @structures.length == 1
-
-          result = []
-          @structures.each do |s|
-            hash = s.extract_hash
-            result << hash unless hash.nil?
-          end
-          return result unless result.length == 1
-          return result[0] if result.length == 1
-        end
-
-        def enterModl_top_level_conditional_return(ctx)
-          modl_structure = ctx.modl_structure
-          return if modl_structure.empty?
-
-          modl_structure.each do |str|
-            structure = ParsedStructure.new @global
-            str.enter_rule(structure)
-            @structures << structure
-          end
-        end
-      end
-
-      # Class to represent a parsed grammar object
-      class ParsedTopLevelConditional < MODL::Parser::MODLParserBaseListener
-        attr_accessor :conditionTests
-        attr_accessor :topLevelConditionalReturns
-
-        def initialize(global)
-          @global = global
-          @topLevelConditionalReturns = []
-          @conditionTests = []
-          @file_importer = FileImporter.instance
-        end
-
-        def extract_hash
-          @conditionTests.each_index do |i|
-            next unless @conditionTests[i].evaluate
-
-            item = @topLevelConditionalReturns[i]
-            if item.structures[0].pair
-              key = item.structures[0].pair.key
-              key = Sutil.tail(key) if key[0] == '_'
-              pair = item.structures[0].pair
-              @global.pair(key, pair)
-
-              if key.downcase.start_with? '*l'
-                files = pair.valueItem.extract_hash if pair.valueItem
-                files = pair.array.extract_hash if pair.array
-                unless pair.loaded
-                  @file_importer.import_files files, @global
-                  pair.loaded = true
-                end
-              end
-            end
-            item.structures = OrphanHandler.adopt(@global, item.structures)
-            return item.extract_hash
-          end
-          return unless @topLevelConditionalReturns.length > @conditionTests.length
-
-          last_item = @topLevelConditionalReturns[-1]
-          if last_item.structures[0].pair
-            key = last_item.structures[0].pair.key
-            key = Sutil.tail(key) if key[0] == '_'
-            pair = last_item.structures[0].pair
-            @global.pair(key, pair)
-
-            if key.downcase.start_with? '*l'
-              files = pair.valueItem.extract_hash if pair.valueItem
-              files = pair.array.extract_hash if pair.array
-              unless pair.loaded
-                @file_importer.import_files files, @global
-                pair.loaded = true
-              end
-            end
-          end
-          last_item.extract_hash
-        end
-
-        def enterModl_top_level_conditional(ctx)
-          @global.enter_condition
-          i = 0
-          modl_condition_test = ctx.modl_condition_test
-          ctx_modl_top_level_conditional_return = ctx.modl_top_level_conditional_return
-
-          while i < modl_condition_test.size
-            condition_test = ParsedConditionTest.new @global
-            ctx.modl_condition_test_i(i).enter_rule(condition_test)
-
-            conditional_return = ParsedTopLevelConditionalReturn.new @global
-            ctx.modl_top_level_conditional_return_i(i).enter_rule(conditional_return)
-            @conditionTests[i] = condition_test
-            @topLevelConditionalReturns[i] = conditional_return
-            i += 1
-          end
-          if ctx_modl_top_level_conditional_return.size > modl_condition_test.size
-            conditional_return = ParsedTopLevelConditionalReturn.new @global
-            ctx.modl_top_level_conditional_return_i(ctx_modl_top_level_conditional_return.size - 1).enter_rule(conditional_return)
-            @topLevelConditionalReturns[i] = conditional_return
-          end
-          extract_hash
-          @global.exit_condition
-        end
-      end
-
-      # Class to represent a parsed grammar object
-      class ParsedArrayConditionalReturn < MODL::Parser::MODLParserBaseListener
-        attr_accessor :arrayItems
-
-        def initialize(global)
-          @global = global
-          @arrayItems = []
-        end
-
-        def extract_hash
-          @arrayItems[0].arrayValueItem.text
-        end
-
-        def enterModl_array_conditional_return(ctx)
-          modl_array_item = ctx.modl_array_item
-          return if modl_array_item.empty?
-
-          modl_array_item.each do |ai|
-            array_item = ParsedArrayItem.new @global
-            ai.enter_rule(array_item)
-            @arrayItems << array_item
-          end
-        end
-      end
-
-      # Class to represent a parsed grammar object
-      class ParsedArrayConditional < MODL::Parser::MODLParserBaseListener
-        attr_accessor :conditionTest
-        attr_accessor :arrayConditionalReturns
-
-        def initialize(global)
-          @global = global
-          @conditionTests = []
-          @arrayConditionalReturns = []
-        end
-
-        def extract_hash
-          result = @conditionTests[0].evaluate
-          return @arrayConditionalReturns[0].extract_hash if result
-          @arrayConditionalReturns[1].extract_hash
-        end
-
-        def enterModl_array_conditional(ctx)
-          i = 0
-          ctx_modl_condition_test = ctx.modl_condition_test
-          ctx_modl_array_conditional_return = ctx.modl_array_conditional_return
-
-          while i < ctx_modl_condition_test.size
-            condition_test = ParsedConditionTest.new @global
-            ctx.modl_condition_test_i(i).enter_rule(condition_test)
-
-            conditional_return = ParsedArrayConditionalReturn.new @global
-            ctx.modl_array_conditional_return_i(i).enter_rule(conditional_return)
-            @conditionTests[i] = condition_test
-            @arrayConditionalReturns[i] = conditional_return
-
-            if ctx_modl_array_conditional_return.size > ctx_modl_condition_test.size
-              i += 1
-              condition_test = ParsedConditionTest.new @global
-              conditional_return = ParsedArrayConditionalReturn.new @global
-              ctx.modl_array_conditional_return_i(ctx_modl_array_conditional_return.size - 1).enter_rule(conditional_return)
-              @conditionTests[i] = condition_test
-              @arrayConditionalReturns[i] = conditional_return
-            end
-
-
-            i += 1
-          end
-        end
-      end
-
-      # Class to represent a parsed grammar object
-      class ParsedValueConditionalReturn < MODL::Parser::MODLParserBaseListener
-        attr_accessor :valueItems
-
-        def initialize(global)
-          @global = global
-          @valueItems = []
-        end
-
-        def extract_hash
-          return @valueItems[0].value.text if @valueItems[0].value.text
-
-          return @valueItems[0].value.extract_hash
-        end
-
-        def enterModl_value_conditional_return(ctx)
-          modl_value_item = ctx.modl_value_item
-          return if modl_value_item.empty?
-
-          modl_value_item.each do |vi|
-            valueItem = ParsedValueItem.new @global
-            vi.enter_rule(valueItem)
-            @valueItems << valueItem
-          end
-        end
-      end
-
-      # Class to represent a parsed grammar object
-      class ParsedValueConditional < MODL::Parser::MODLParserBaseListener
-        attr_accessor :conditionTests
-        attr_accessor :valueConditionalReturns
-
-        def initialize(global)
-          @global = global
-          @conditionTests = []
-          @valueConditionalReturns = []
-        end
-
-        def extract_hash
-          return @result if @valueConditionalReturns.length == 0
-          return @valueConditionalReturns[0].extract_hash if @result
-          return @valueConditionalReturns[1].extract_hash
-        end
-
-        def enterModl_value_conditional(ctx)
-          i = 0
-          ctx_modl_condition_test = ctx.modl_condition_test
-          ctx_modl_value_conditional_return = ctx.modl_value_conditional_return
-
-          while i < ctx_modl_condition_test.size
-            condition_test = ParsedConditionTest.new @global
-            ctx.modl_condition_test_i(i).enter_rule(condition_test)
-
-            @conditionTests[i] = condition_test
-
-            break if ctx.modl_value_conditional_return_i(i).nil?
-
-            conditional_return = ParsedValueConditionalReturn.new @global
-
-            ctx.modl_value_conditional_return_i(i).enter_rule(conditional_return)
-
-            @valueConditionalReturns[i] = conditional_return
-
-            if ctx_modl_value_conditional_return.size > ctx_modl_condition_test.size
-              condition_test = ParsedConditionTest.new @global
-              conditional_return = ParsedValueConditionalReturn.new @global
-              ctx.modl_value_conditional_return_i(ctx_modl_value_conditional_return.size - 1).enter_rule(conditional_return)
-              @conditionTests[i + 1] = condition_test
-              @valueConditionalReturns[i + 1] = conditional_return
-            end
-
-            i += 1
-          end
-          @result = @conditionTests[0].evaluate
-        end
-      end
-
-      # Class to represent a parsed grammar object
-      class ParsedNbArray < MODL::Parser::MODLParserBaseListener
-        attr_accessor :arrayItems
-
-        def initialize(global)
-          @global = global
-          @arrayItems = []
-        end
-
-        def find_property(key)
-          if key.is_a? Integer
-            return @arrayItems[key].arrayValueItem
-          else
-            @arrayItems.each do |mi|
-              return mi.arrayValueItem.pair if mi.arrayValueItem.pair && mi.arrayValueItem.pair.key == key
-            end
-            nil
-          end
-        end
-
-        def extract_hash
-          result = []
-
-          @arrayItems.each do |i|
-            result << i.extract_hash
-          end
-
-          result
-        end
-
-        def enterModl_nb_array(ctx)
-          i = 0
-          previous = nil
-          ctx_children = ctx.children
-          ctx_children.each do |pt|
-            if pt.is_a? MODLParser::Modl_array_itemContext
-              array_item = ParsedArrayItem.new @global
-              pt.enter_rule(array_item)
-              @arrayItems[i] = array_item
-              i += 1
-            elsif pt.is_a? Antlr4::Runtime::TerminalNode
-              if !previous.nil? && previous.is_a?(Antlr4::Runtime::TerminalNode) && pt.is_a?(Antlr4::Runtime::TerminalNode)
-                # If we get here then we have two terminal nodes in a row, so we need to output something unless # the terminal symbols are newlines
-                #
-                prev_symbol = previous.symbol.type
-                current_symbol = pt.symbol.type
-
-                if prev_symbol == MODLLexer::COLON && current_symbol == MODLLexer::COLON
-                  array_item = Parsed.handle_empty_array_item
-                  @arrayItems[i] = array_item
-                  i += 1
-                end
-              end
-            end
-            previous = pt
-          end
-        end
-      end
-
-      def self.handle_empty_array_item
-        # Create something for the blank array item
-        #
-        # The problem is that we might not have any context to tell us what type we need to create
-        # so this currently defaults to the nil value
-        #
-        # TODO : Is there a way to know the type to create or is nil always acceptable?
-        array_item = ParsedArrayItem.new @global
-        array_item.arrayValueItem = ParsedArrayValueItem.new @global
-        array_item.arrayValueItem.primitive = ParsedPrimitive.new @global
-        array_item.arrayValueItem.primitive.nilVal = ParsedNull.instance
-        array_item
-      end
-
-      # Class to represent a parsed grammar object
-      class ParsedArray < MODL::Parser::MODLParserBaseListener
-        # We now have a list of < array_item | nb_array >
-        attr_accessor :abstractArrayItems
-
-        def initialize(global)
-          @global = global
-          @abstractArrayItems = []
-        end
-
-        def find_property(key)
-          if key.is_a? Integer
-            return @abstractArrayItems[key]
-          else
-            @abstractArrayItems.each do |mi|
-              return mi.arrayValueItem.pair if mi.arrayValueItem.pair && mi.arrayValueItem.pair.key == key
-            end
-            nil
-          end
-        end
-
-        def extract_hash
-          result = []
-
-          abstractArrayItems.each do |i|
-            result << i.extract_hash
-          end
-
-          result
-        end
-
-        def enterModl_array(ctx)
-          # Create the new abstractArrayItems list first, sized to the total of array_item.size and nb_array.size
-          i = 0
-          previous = nil
-          ctx_children = ctx.children
-          ctx_children.each do |pt|
-            if pt.is_a? MODLParser::Modl_array_itemContext
-              array_item = ParsedArrayItem.new @global
-              pt.enter_rule(array_item)
-              @abstractArrayItems[i] = array_item
-              i += 1
-            elsif pt.is_a? MODLParser::Modl_nb_arrayContext
-              nb_array = ParsedNbArray.new @global
-              pt.enter_rule(nb_array)
-              @abstractArrayItems[i] = nb_array
-              i += 1
-            elsif pt.is_a? Antlr4::Runtime::TerminalNode
-              if !previous.nil? && previous.is_a?(Antlr4::Runtime::TerminalNode) && pt.is_a?(Antlr4::Runtime::TerminalNode)
-
-                # If we get here then we have two terminal nodes in a row, so we need to output something unless # the terminal symbols are newlines
-                #
-                prev_symbol = previous.symbol.type
-                current_symbol = pt.symbol.type
-
-                if prev_symbol == MODLLexer::LSBRAC && current_symbol == MODLLexer::RSBRAC
-                  next # This allows empty arrays
-                end
-
-                if prev_symbol == MODLLexer::STRUCT_SEP && current_symbol == MODLLexer::STRUCT_SEP
-
-                  # Create something for the blank array item
-                  #
-                  # The problem is that we might not have any context to tell us what type we need to create
-                  # so this currently defaults to the nil
-                  #
-                  # TODO : Is there a way to know the type to create or is nil always acceptable?
-                  array_item = Parsed.handle_empty_array_item
-
-                  @abstractArrayItems[i] = array_item
-                  i += 1
-                end
-              end
-            end
-            previous = pt
-          end
-        end
-      end
-
-      # Class to represent a parsed grammar object
-      class ParsedArrayItem < MODL::Parser::MODLParserBaseListener
-        attr_accessor :arrayValueItem
-        attr_accessor :arrayConditional
-
-        def initialize(global)
-          @global = global
-        end
-
-        def find_property(key)
-          return @arrayValueItem.find_property(key)
-        end
-
-        def enterModl_array_item(ctx)
-          ctx_modl_array_conditional = ctx.modl_array_conditional
-          unless ctx_modl_array_conditional.nil?
-            @arrayConditional = ParsedArrayConditional.new @global
-            ctx_modl_array_conditional.enter_rule(@arrayConditional)
-          end
-          ctx_modl_array_value_item = ctx.modl_array_value_item
-          unless ctx_modl_array_value_item.nil?
-            @arrayValueItem = ParsedArrayValueItem.new @global
-            ctx_modl_array_value_item.enter_rule(@arrayValueItem)
-          end
-        end
-
-        def extract_hash
-          return @arrayValueItem.extract_hash if @arrayValueItem
-          return @arrayConditional.extract_hash if @arrayConditional
-        end
-
-      end
-
-      # Singleton class to represent a true value
-      class ParsedTrue < MODL::Parser::MODLParserBaseListener
-        include Singleton
-      end
-
-      # Singleton class to represent a false value
-      class ParsedFalse < MODL::Parser::MODLParserBaseListener
-        include Singleton
-      end
-
-      # Singleton class to represent a null value
-      class ParsedNull < MODL::Parser::MODLParserBaseListener
-        include Singleton
-      end
-
-      # Convert the parse tree to a simpler structure suitable for JSON.generate.
-      def extract_hash
-        result = []
-        if @structures.length.positive?
-          @structures.each do |s|
-            value = s.extract_hash
-            result << value unless value.nil?
-          end
-        else
-          result = {}
-        end
-        case result.length
-        when 0
-          return nil
-        when 1
-          return result[0]
-        end
-        result
-      end
-    end
-  end
-end