fOOrth 0.6.4 → 0.6.5

data/lib/fOOrth/library/introspection/context.rb

@@ -0,0 +1,36 @@
+# coding: utf-8
+
+#* library/introspection/context.rb - Context support for introspection.
+module XfOOrth
+
+  #Get information about this compiler context.
+  class Context
+
+    #Get introspection info.
+    def get_info
+      results = [["Level", depth]]
+
+      @data.each do |key, value|
+        results << ["", ""]
+
+        if value.is_a?(AbstractWordSpec)
+          results << ["Name", SymbolMap.unmap(key)]
+          results << ["Mapping", key]
+          results.concat(value.get_info)
+        else
+          results << ["Name",  key]
+          results << ["Value", value]
+        end
+
+      end
+
+      if (prev = self.previous)
+        results << ["", ""]
+        results.concat(prev.get_info)
+      end
+
+      results
+    end
+  end
+
+end

data/lib/fOOrth/library/introspection/object.rb

@@ -0,0 +1,69 @@
+# coding: utf-8
+
+#* library/introspection/object.rb - Object support for introspection.
+class Object
+
+  #Map the symbol to a specification or nil if there is no mapping.
+  def map_foorth_exclusive_info(symbol, shallow=nil)
+    if (foorth_has_exclusive? && (spec = foorth_exclusive[symbol]))
+      [spec, [["Object", foorth_name], ["Scope", "Exclusive"]]]
+    elsif !shallow
+      self.class.map_foorth_shared_info(symbol)
+    else
+      [nil, nil]
+    end
+  end
+
+  #Get introspection info.
+  def get_info
+    results = [["Type", foorth_name]]
+
+    unless (vars = instance_variables).empty?
+      results.concat([["", ""], ["Data", "Instance"], ["", ""]])
+
+      vars.sort.each do |name|
+        var_name = XfOOrth::SymbolMap.unmap(name[1..-1].to_sym) || name
+        results << [var_name, instance_variable_get(name)]
+      end
+    end
+
+    if foorth_has_exclusive?
+      results.concat([["", ""], ["Methods", "Exclusive"]])
+
+      foorth_exclusive.extract_method_names(:all).sort.each do |name|
+        symbol, info = XfOOrth::SymbolMap.map_info(name)
+        results.concat([["", ""], ["Name", name], info])
+        spec, info = map_foorth_exclusive_info(symbol, :shallow)
+        results.concat(info).concat(spec.get_info)
+      end
+    end
+
+    results
+  end
+
+  #Investigate a method of this object.
+  def foorth_method_info(name)
+    symbol, results = XfOOrth::SymbolMap.map_info(name)
+    found = false
+
+    if symbol
+      spec, info = map_foorth_exclusive_info(symbol)
+
+      if spec && !spec.has_tag?(:stub)
+        (results << ["", ""]).concat(info).concat(spec.get_info)
+        found = true
+      end
+
+      results << ["Scope", "not found."] unless found
+    end
+
+    results
+  end
+
+  #Get the lineage of this object.
+  def lineage
+    foorth_name + " < " + self.class.lineage
+  end
+
+
+end

data/lib/fOOrth/library/introspection/string.rb

@@ -0,0 +1,28 @@
+# coding: utf-8
+
+#* library/introspection/string.rb - String support for introspection.
+class String
+
+  #Scan all classes for information about a method.
+  def foorth_method_scan
+    symbol, results = XfOOrth::SymbolMap.map_info(self)
+    found = false
+
+    symbol && $FOORTH_GLOBALS.values
+      .select {|entry| entry.has_tag?(:class)}
+      .collect {|spec| spec.new_class}
+      .sort {|a,b| a.foorth_name <=> b.foorth_name}
+      .each do |klass|
+        spec, info = klass.map_foorth_shared_info(symbol, :shallow)
+        found |= spec && (results << ["", ""]).concat(info).concat(spec.get_info)
+
+        spec, info = klass.map_foorth_exclusive_info(symbol, :shallow)
+        found |= spec && (results << ["", ""]).concat(info).concat(spec.get_info)
+      end
+
+    results << ["Scope", "not found in any class."] if symbol && !found
+
+    results
+  end
+
+end

data/lib/fOOrth/library/introspection/symbol_map.rb

@@ -0,0 +1,19 @@
+# coding: utf-8
+
+#* library/introspection/symbol_map.rb - Mapping support for introspection.
+module XfOOrth
+
+  #* library/introspection/symbol_map.rb - Mapping support for introspection.
+  module SymbolMap
+
+    #Get mapping info for a method name.
+    def self.map_info(name)
+      symbol = map(name)
+      target = symbol ? symbol.to_s : "not found."
+      [symbol,  [["Name", name], ["Mapping", target]]]
+    end
+
+  end
+
+end
+

data/lib/fOOrth/library/introspection/vm.rb

@@ -0,0 +1,70 @@
+# coding: utf-8
+
+#* library/introspection/vm.rb - Virtual Machine support for introspection.
+module XfOOrth
+
+  #* library/introspection/vm.rb - Virtual Machine support for introspection.
+  class VirtualMachine
+
+    #Get introspection info.
+    def get_info
+      results = [["Name",    foorth_name],
+                 ["Ruby",    self.to_s],
+                 ["Stack",   @data_stack.inspect],
+                 ["Nesting", @context.depth],
+                 ["Quotes",  @quotes],
+                 ["Debug",   @debug],
+                 ["Show",    @show_stack],
+                 ["Start",   @start_time]]
+
+      if (source  = @parser && @parser.source)
+        results << ["Source", source.source_name]
+        results << ["Buffer", source.read_buffer.inspect]
+      end
+
+      names = instance_variables.map do |sym|
+        if (name = XfOOrth::SymbolMap.unmap(sym.to_s[1..-1].to_sym))
+          [name, sym]
+        end
+      end
+
+      names.compact!
+
+      unless names.empty?
+        results.concat([["", ""], ["Data", "Instance"], ["", ""]])
+
+        names.each do |name, sym|
+          results << [name, instance_variable_get(sym)]
+        end
+      end
+
+      unless @data.empty?
+        results.concat([["", ""], ["Data", "Thread"], ["", ""]])
+
+        @data
+          .keys
+          .map{|symbol| [SymbolMap.unmap(symbol), symbol]}
+          .sort{|a,b| a[0] <=> b[0]}
+          .map{|name, symbol| [name, @data[symbol]]}
+          .each do |name, value|
+            results << [name, value.inspect]
+          end
+      end
+
+      if foorth_has_exclusive?
+        results.concat([["", ""], ["Methods", "Exclusive"]])
+
+        foorth_exclusive.extract_method_names(:all).sort.each do |name|
+          symbol, info = SymbolMap.map_info(name)
+          results.concat([["", ""], ["Name", name], info])
+          spec, info = map_foorth_exclusive_info(symbol, :shallow)
+          results.concat(info).concat(spec.get_info)
+        end
+      end
+
+      results
+    end
+
+  end
+
+end

data/lib/fOOrth/library/introspection/word_specs.rb

@@ -0,0 +1,18 @@
+# coding: utf-8
+
+#* library/introspection/word_specs.rb - WordSpec support for introspection.
+module XfOOrth
+
+  #Get information about this word spec.
+  class AbstractWordSpec
+
+    #Get introspection info.
+    def get_info
+      [["Spec"  , self.class.foorth_name],
+       ["Tags"  , tags.join(' ')],
+       ["Builds", builds],
+       ["Does"  , does.inspect]]
+    end
+  end
+
+end

data/lib/fOOrth/library/introspection_library.rb

@@ -0,0 +1,78 @@
+# coding: utf-8
+
+require_relative 'introspection/symbol_map'
+require_relative 'introspection/class'
+require_relative 'introspection/object'
+require_relative 'introspection/string'
+require_relative 'introspection/word_specs'
+require_relative 'introspection/context'
+require_relative 'introspection/vm'
+
+#* library/introspection_library.rb - The fOOrth introspection library.
+module XfOOrth
+
+  #Dump the context.
+  VirtualMachine.create_shared_method(')context', VmSpec, [],
+    &lambda {|vm| vm.context.get_info.foorth_bullets(vm) })
+
+  #Dump the context right NOW!.
+  VirtualMachine.create_shared_method(')context!', VmSpec, [:immediate],
+    &lambda {|vm| vm.context.get_info.foorth_bullets(vm) })
+
+  #Dump the virtual machine.
+  VirtualMachine.create_shared_method('.dump', TosSpec, [],
+    &lambda {|vm| get_info.foorth_bullets(vm) })
+
+  #Dump the virtual machine.
+  VirtualMachine.create_shared_method(')vm', VmSpec, [],
+    &lambda {|vm| get_info.foorth_bullets(vm) })
+
+  #Dump the virtual machine right NOW!
+  VirtualMachine.create_shared_method(')vm!', VmSpec, [:immediate],
+    &lambda {|vm| get_info.foorth_bullets(vm) })
+
+  #Map a symbol entry
+  VirtualMachine.create_shared_method(')map"', VmSpec, [], &lambda {|vm|
+    str = vm.pop.to_s
+    puts "#{str} => #{(SymbolMap.map(str).to_s)}"
+  })
+
+  #Unmap a symbol entry
+  VirtualMachine.create_shared_method(')unmap"', VmSpec, [], &lambda {|vm|
+    str = vm.pop.to_s
+    puts "#{str} <= #{(SymbolMap.unmap(str.to_sym).to_s)}"
+  })
+
+  #Get information on a method.
+  Object.create_shared_method('.method_info', TosSpec, [],
+    &lambda{|vm| vm.push(foorth_method_info(vm.pop)) })
+
+  #Get information on a method.
+  Object.create_shared_method(')method_info"', NosSpec, [],
+    &lambda{|vm| foorth_method_info(vm.pop).foorth_bullets(vm) })
+
+  #Scan all classes for information about a method.
+  String.create_shared_method('.method_scan', TosSpec, [],
+    &lambda{|vm| vm.push(foorth_method_scan) })
+
+  #Scan all classes for information about a method.
+  String.create_shared_method(')method_scan"', TosSpec, [],
+    &lambda{|vm| foorth_method_scan.foorth_bullets(vm) })
+
+  #Get this class's lineage in a string.
+  Object.create_shared_method('.lineage', TosSpec, [],
+    &lambda{|vm| vm.push(lineage.freeze) })
+
+  #Print this class's lineage.
+  Object.create_shared_method(')lineage', TosSpec, [],
+    &lambda{|vm| puts lineage })
+
+  #Scan an object for stuff.
+  Object.create_shared_method('.scan', TosSpec, [],
+    &lambda{|vm| vm.push(get_info) })
+
+  #Scan an object for stuff.
+  Object.create_shared_method(')scan', TosSpec, [],
+    &lambda{|vm| get_info.foorth_bullets(vm) })
+
+end

data/lib/fOOrth/library/stack_library.rb

@@ -1,11 +1,9 @@
 # coding: utf-8
 
-require 'thread'
-
-#* library/queue_library.rb - The Queue support fOOrth library.
+#* library/stack_library.rb - The Stack support fOOrth library.
 module XfOOrth
 
-  #Connect the Queue class to the fOOrth class system.
+  #Connect the Stack class to the fOOrth class system.
   stack = Object.create_foorth_subclass('Stack').new_class
 
   #Uses the default implementation of the .new method.

data/lib/fOOrth/library/stdio_library.rb

@@ -1,5 +1,9 @@
 # coding: utf-8
 
+#Load up some pretty printing support.
+require_relative 'formatting/columns'
+require_relative 'formatting/bullets'
+
 #* library/stdio_library.rb - The standard I/O fOOrth library.
 module XfOOrth
 
@@ -53,4 +57,68 @@ module XfOOrth
   # "prompt" [] .accept [string]; gets a string from the console.
   String.create_shared_method('.accept', TosSpec, [],
     &lambda{|vm|  vm.push(MiniReadline.readline(self, true))})
+
+  symbol = :lines_per_page
+  SymbolMap.add_entry('$lines_per_page', symbol)
+  $lines_per_page = [25]
+  $FOORTH_GLOBALS[symbol] = GlobalVarSpec.new('$lines_per_page', symbol, [])
+
+  symbol = :chars_per_line
+  $chars_per_line = [80]
+  SymbolMap.add_entry('$chars_per_line', :chars_per_line)
+  $FOORTH_GLOBALS[symbol] = GlobalVarSpec.new('$chars_per_line', symbol, [])
+
+  #Show the page length.
+  VirtualMachine.create_shared_method(')pl', MacroSpec,
+    [:macro, 'puts "Page Length = #{$lines_per_page[0]}"; '])
+
+  #Set the page length.
+  VirtualMachine.create_shared_method(')set_pl', MacroSpec,
+    [:macro, 'puts "New Page Length = #{$lines_per_page[0] = vm.pop}"; '])
+
+  #Show the page width.
+  VirtualMachine.create_shared_method(')pw', MacroSpec,
+    [:macro, 'puts "Page Width = #{$chars_per_line[0]}"; '])
+
+  #Set the page width.
+  VirtualMachine.create_shared_method(')set_pw', MacroSpec,
+    [:macro, 'puts "New Page Width = #{$chars_per_line[0] = vm.pop}"; '])
+
+  # [ l 2 3 ... n ] .pp []; pretty print the array!
+  Array.create_shared_method('.pp', TosSpec, [], &lambda {|vm|
+    puts_foorth_columnized($lines_per_page[0], $chars_per_line[0])
+  })
+
+  # [ l 2 3 ... n ] .format_columns []; format to strings with columns.
+  Array.create_shared_method('.format_columns', TosSpec, [], &lambda {|vm|
+    vm.push(foorth_columnize($lines_per_page[0], $chars_per_line[0])
+      .map {|page| page << ""}
+      .flatten[0...-1])
+  })
+
+  # [ l 2 3 ... n ] .print_columns []; pretty print columns.
+  Array.create_shared_method('.print_columns', TosSpec, [], &lambda {|vm|
+    puts_foorth_columnized($lines_per_page[0], $chars_per_line[0])
+  })
+
+  #[["1" "stuff"] ["two" stuff] .format_bullets; format to strings with bullets.
+  Array.create_shared_method('.format_bullets', TosSpec, [], &lambda {|vm|
+    vm.push(foorth_bulletize($chars_per_line[0]))
+  })
+
+  #[["1" "stuff"] ["two" stuff] .print_bullets; pretty print bullet points.
+  Array.create_shared_method('.print_bullets', TosSpec, [], &lambda {|vm|
+    puts_foorth_bullets($chars_per_line[0])
+  })
+
+  #{ "1" "stuff" -> "two" "stuff" -> } .format_bullets; format to strings with bullets.
+  Hash.create_shared_method('.format_bullets', TosSpec, [], &lambda {|vm|
+    vm.push(foorth_bulletize($chars_per_line[0]))
+  })
+
+  #{ "1" "stuff" -> "two" "stuff" -> } .print_bullets; pretty print bullet points.
+  Hash.create_shared_method('.print_bullets', TosSpec, [], &lambda {|vm|
+    puts_foorth_bullets($chars_per_line[0])
+  })
+
 end

data/lib/fOOrth/library/stubs.rb

@@ -69,12 +69,16 @@ module XfOOrth
   Object.create_shared_method(',asm',   TosSpec, [:stub])
   Object.create_shared_method(',asm"',  TosSpec, [:stub])
 
+  #Command stubs
+  Object.create_shared_method(')method_scan"', TosSpec, [:stub])
+
   #Define some "crossover" symbols.
-  SymbolMap.add_entry('.is_class?',     :foorth_is_class?)
-  SymbolMap.add_entry('.to_s',          :to_foorth_s)
-  SymbolMap.add_entry('.strlen',        :foorth_strlen)
-  SymbolMap.add_entry('.strmax',        :foorth_strmax)
-  SymbolMap.add_entry('.strmax2',       :foorth_strmax2)
-  SymbolMap.add_entry('.pp',            :foorth_pretty)
-  SymbolMap.add_entry('.load',          :foorth_load_file)
+  SymbolMap.add_entry('.is_class?',      :foorth_is_class?)
+  SymbolMap.add_entry('.to_s',           :to_foorth_s)
+  SymbolMap.add_entry('.strlen',         :foorth_strlen)
+  SymbolMap.add_entry('.strmax',         :foorth_strmax)
+  SymbolMap.add_entry('.strmax2',        :foorth_strmax2)
+  SymbolMap.add_entry('.print_columns',  :foorth_columns)
+  SymbolMap.add_entry('.print_bullets',  :foorth_bullets)
+  SymbolMap.add_entry('.load',           :foorth_load_file)
 end