gloo 0.5.4 → 0.7.2

data/lib/gloo/core/tokens.rb

@@ -11,78 +11,85 @@ module Gloo
 
       attr_reader :cmd, :tokens
 
+      # ---------------------------------------------------------------------
+      #    Constructor
+      # ---------------------------------------------------------------------
+
+      #
       # Set up the tokens.
+      # The command string is parsed into tokens during creation.
+      #
       def initialize( cmd_string )
         @cmd = cmd_string
         @tokens = []
         tokenize @cmd
       end
 
-      # Create a list of token from the given string.
-      def tokenize( str )
-        if str.index( '"' )
-          i = str.index( '"' )
-          j = str.index( '"', i + 1 )
-          j ||= str.length
-
-          tokenize( str[ 0..i - 1 ] ) if i > 1
-          @tokens << str[ i..j ]
-          tokenize( str[ j + 1..-1 ] ) if j + 1 < str.length
-        elsif str.index( "'" )
-          i = str.index( "'" )
-          j = str.index( "'", i + 1 )
-          j ||= str.length
-
-          tokenize( str[ 0..i - 1 ] ) if i > 1
-          @tokens << str[ i..j ]
-          tokenize( str[ j + 1..-1 ] ) if j + 1 < str.length
-        else
-          str.strip.split( ' ' ).each { |t| @tokens << t }
-        end
-      end
+      # ---------------------------------------------------------------------
+      #    Public functions
+      # ---------------------------------------------------------------------
 
+      #
       # Get the number of tokens
+      #
       def token_count
         return @tokens.size
       end
 
+      #
       # Get the verb (the first word)
+      #
       def verb
         return first
       end
 
+      #
       # Get all tokens except the first.
+      #
       def params
         return @tokens[ 1..-1 ]
       end
 
+      #
       # Get the first token.
+      #
       def first
         return @tokens.first if @tokens
       end
 
+      #
       # Get the last token.
+      #
       def last
         return @tokens.last if @tokens
       end
 
+      #
       # Get the second token.
+      #
       def second
         return @tokens[ 1 ] if @tokens&.size&.positive?
       end
 
+      #
+      # Get the token at the the requested index.
+      #
       def at( index )
         return @tokens[ index ] if @tokens && @tokens.size >= index
       end
 
+      #
       # Get the index of the given token.
+      #
       def index_of( token )
         return nil unless @tokens
 
         return @tokens.find_index { |o| o.casecmp( token ).zero? }
       end
 
+      #
       # Get the list of tokens after the given token
+      #
       def tokens_after( token )
         i = index_of token
         return @tokens[ i + 1..-1 ] if i && @tokens && @tokens.size > ( i + 1 )
@@ -90,7 +97,9 @@ module Gloo
         return nil
       end
 
+      #
       # Get the expression after the given token
+      #
       def expr_after( token )
         str = ''
         tokens_after( token ).each do |t|
@@ -100,7 +109,9 @@ module Gloo
         return str
       end
 
+      #
       # Get the item after a given token.
+      #
       def after_token( token )
         i = index_of token
         return @tokens[ i + 1 ] if i && @tokens && @tokens.size > ( i + 1 )
@@ -108,7 +119,9 @@ module Gloo
         return nil
       end
 
+      #
       # Get the item after a given token.
+      #
       def before_token( token )
         i = index_of token
         return @tokens[ 0..i - 1 ] if i && @tokens && @tokens.size >= i
@@ -116,6 +129,37 @@ module Gloo
         return nil
       end
 
+      # ---------------------------------------------------------------------
+      #    Private functions
+      # ---------------------------------------------------------------------
+
+      private
+
+      #
+      # Create a list of token from the given string.
+      #
+      def tokenize( str )
+        if str.index( '"' )
+          i = str.index( '"' )
+          j = str.index( '"', i + 1 )
+          j ||= str.length
+
+          tokenize( str[ 0..i - 1 ] ) if i > 1
+          @tokens << str[ i..j ]
+          tokenize( str[ j + 1..-1 ] ) if j + 1 < str.length
+        elsif str.index( "'" )
+          i = str.index( "'" )
+          j = str.index( "'", i + 1 )
+          j ||= str.length
+
+          tokenize( str[ 0..i - 1 ] ) if i > 1
+          @tokens << str[ i..j ]
+          tokenize( str[ j + 1..-1 ] ) if j + 1 < str.length
+        else
+          str.strip.split( ' ' ).each { |t| @tokens << t }
+        end
+      end
+
     end
   end
 end

data/lib/gloo/core/verb.rb

@@ -13,13 +13,17 @@ module Gloo
 
       attr_reader :tokens, :params
 
+      #
       # Set up the verb.
+      #
       def initialize( tokens, params = [] )
         @tokens = tokens
         @params = params
       end
 
+      #
       # Register verbs when they are loaded.
+      #
       def self.inherited( subclass )
         Dictionary.instance.register_verb( subclass )
       end
@@ -58,6 +62,14 @@ module Gloo
         return self.class.keyword
       end
 
+      #
+      # Generic function to get display value.
+      # Can be used for debugging, etc.
+      #
+      def display_value
+        return self.class.keyword
+      end
+
       # ---------------------------------------------------------------------
       #    Help
       # ---------------------------------------------------------------------

data/lib/gloo/exec/action.rb

@@ -0,0 +1,48 @@
+# Author::    Eric Crane  (mailto:eric.crane@mac.com)
+# Copyright:: Copyright (c) 2020 Eric Crane.  All rights reserved.
+#
+# An action is a message sent to an object with optional parameters.
+#
+
+module Gloo
+  module Exec
+    class Action
+
+      attr_accessor :msg, :to, :params
+
+      #
+      # Set up the action.
+      #
+      def initialize( msg, to, params = nil )
+        @msg = msg
+        @to = to
+        @params = params
+      end
+
+      #
+      # The action is valid if the object can receive
+      # the message specified.
+      #
+      def valid?
+        return @to.can_receive_message?( @msg )
+      end
+
+      #
+      # Execute the action.
+      # Dispatch the message to the object.
+      #
+      def dispatch
+        @to.send_message @msg, @params
+      end
+
+      #
+      # Generic function to get display value.
+      # Can be used for debugging, etc.
+      #
+      def display_value
+        return "#{@msg} -> #{@to.pn}"
+      end
+
+    end
+  end
+end

data/lib/gloo/exec/dispatch.rb

@@ -16,13 +16,23 @@ module Gloo
       # Dispatch the given message to the given object.
       #
       def self.message( msg, to_obj, params = nil )
-        $log.debug "----- Sending message #{msg} to #{to_obj.name}"
+        $log.debug "Dispatch message #{msg} to #{to_obj.name}"
+        a = Gloo::Exec::Action.new msg, to_obj, params
+        Gloo::Exec::Dispatch.action a
+      end
 
-        if to_obj.can_receive_message? msg
-          to_obj.send_message msg, params
-        else
-          $log.warn "Object #{to_obj.name} does not respond to #{msg}"
+      #
+      # Dispatch an action.
+      #
+      def self.action( action )
+        unless action.valid?
+          $log.warn "Object #{action.to.name} does not respond to #{action.msg}"
         end
+
+        $engine.exec_env.push_action action
+        $log.debug "Sending message #{action.msg} to #{action.to.name}"
+        action.dispatch
+        $engine.exec_env.pop_action
       end
 
     end

data/lib/gloo/exec/exec_env.rb

@@ -0,0 +1,74 @@
+# Author::    Eric Crane  (mailto:eric.crane@mac.com)
+# Copyright:: Copyright (c) 2020 Eric Crane.  All rights reserved.
+#
+# The execution environment.
+# The current state of running scripts and messaging.
+#
+
+module Gloo
+  module Exec
+    class ExecEnv
+
+      attr_accessor :verbs, :actions, :scripts, :here
+
+      VERB_STACK = 'verbs'.freeze
+      ACTION_STACK = 'actions'.freeze
+      SCRIPT_STACK = 'scripts'.freeze
+      HERE_STACK = 'here'.freeze
+
+      #
+      # Set up the execution environment.
+      #
+      def initialize
+        $log.debug 'exec env intialized...'
+
+        @verbs = Gloo::Exec::Stack.new VERB_STACK
+        @actions = Gloo::Exec::Stack.new ACTION_STACK
+        @scripts = Gloo::Exec::Stack.new SCRIPT_STACK
+        @here = Gloo::Exec::Stack.new HERE_STACK
+      end
+
+      #
+      # Get the here object.
+      #
+      def here_obj
+        return nil if @here.stack.empty?
+
+        return @here.stack.last
+      end
+
+      #
+      # Push a script onto the stack.
+      #
+      def push_script( script )
+        @scripts.push script
+        @here.push script.obj
+      end
+
+      #
+      # Pop a script off the stack.
+      #
+      def pop_script
+        @scripts.pop
+        @here.pop
+      end
+
+      #
+      # Push an action onto the stack.
+      #
+      def push_action( action )
+        @actions.push action
+        # @here.push action.to
+      end
+
+      #
+      # Pop an action off the stack.
+      #
+      def pop_action
+        @actions.pop
+        # @here.pop
+      end
+
+    end
+  end
+end

data/lib/gloo/exec/runner.rb

@@ -16,9 +16,11 @@ module Gloo
       # is done running.
       #
       def self.go( verb )
-        $log.debug "**** Running verb #{verb.type_display}"
+        $log.debug "running verb #{verb.type_display}"
         $engine.heap.error.start_tracking
+        $engine.exec_env.verbs.push verb
         verb&.run
+        $engine.exec_env.verbs.pop
         $engine.heap.error.clear_if_no_errors
       end
 
@@ -27,7 +29,7 @@ module Gloo
       # Resolve the path_name and then send the run message.
       #
       def self.run( path_name )
-        $log.debug "**** Running script at #{path_name}"
+        $log.debug "running script at #{path_name}"
         pn = Gloo::Core::Pn.new path_name
         o = pn.resolve
 

data/lib/gloo/{core → exec}/script.rb

@@ -5,31 +5,43 @@
 #
 
 module Gloo
-  module Core
+  module Exec
     class Script
 
+      attr_accessor :obj
+
+      #
       # Set up the script.
+      #
       def initialize( obj )
         @obj = obj
       end
 
+      #
       # Run the script.
+      # The script might be a single string or an array
+      # of lines.
+      #
       def run
+        $engine.exec_env.push_script self
+
         if @obj.value.is_a? String
-          run_line @obj.value
+          $engine.parser.run @obj.value
         elsif @obj.value.is_a? Array
           @obj.value.each do |line|
-            run_line line
+            $engine.parser.run line
           end
         end
-      end
 
-      # Run a single line of the script.
-      def run_line( line )
-        i = $engine.parser.parse_immediate line
-        return unless i
+        $engine.exec_env.pop_script
+      end
 
-        i.run
+      #
+      # Generic function to get display value.
+      # Can be used for debugging, etc.
+      #
+      def display_value
+        return @obj.pn
       end
 
     end

data/lib/gloo/exec/stack.rb

@@ -0,0 +1,78 @@
+# Author::    Eric Crane  (mailto:eric.crane@mac.com)
+# Copyright:: Copyright (c) 2020 Eric Crane.  All rights reserved.
+#
+# A stack of items, a call stack.
+#
+
+module Gloo
+  module Exec
+    class Stack
+
+      attr_accessor :stack
+
+      #
+      # Set up the stack.
+      #
+      def initialize( name )
+        @name = name
+        clear_stack
+        $log.debug "#{name} stack intialized..."
+      end
+
+      #
+      # Push an item onto the stack.
+      #
+      def push( obj )
+        $log.debug "#{@name}:push #{obj.display_value}"
+        @stack.push obj
+        self.update_out_file if $settings.debug
+      end
+
+      #
+      # Pop an item from the stack.
+      #
+      def pop
+        o = @stack.pop
+        $log.debug "#{@name}:pop #{o.display_value}"
+        self.update_out_file if $settings.debug
+      end
+
+      #
+      # Get the current size of the call stack.
+      #
+      def size
+        return @stack.size
+      end
+
+      #
+      # Get stack data for output.
+      #
+      def out_data
+        return @stack.map( &:display_value ).join( "\n" )
+      end
+
+      #
+      # Get the file we'll write debug information for the stack.
+      #
+      def out_file
+        return File.join( $settings.debug_path, @name )
+      end
+
+      #
+      # Update the stack trace file.
+      #
+      def update_out_file
+        File.write( self.out_file, self.out_data )
+      end
+
+      #
+      # Clear the stack and the output file.
+      #
+      def clear_stack
+        @stack = []
+        self.update_out_file
+      end
+
+    end
+  end
+end