xiacc 0.1

data/xiacc-0.1/lib/nist/xiacc/GrammarString.rb

@@ -0,0 +1,84 @@
+module XI
+  require 'set'
+  require 'nist/xiacc/Epsilon'
+  require 'nist/xiacc/CCObjectAddon'
+  require 'nist/xiacc/CCSetAddon'
+
+  class GrammarString < Array
+    
+    def firstWithinLanguage( aLanguage )
+      #print "-firstWithinLanguage-\n"
+      answer = Set.new
+      epsilon = Epsilon.default
+      allHaveEpsilon = true
+      each do
+	|symbol|
+	newset = aLanguage.unprotectedFirst( symbol )
+	#print "newset for symbol: #{symbol} is: "
+	#newset.each { |item| print "  #{item}  " }
+	#print "\n"
+	containsEpsilon = newset.includeLike?( epsilon )
+	#print "contains epsilon: #{containsEpsilon}\n"
+	allHaveEpsilon = allHaveEpsilon and containsEpsilon
+	if containsEpsilon == true
+	  newset.deleteLike( epsilon )
+	  answer.addAll( newset )
+	else
+	  answer.addAll( newset )
+	  #print "+firstWithinLanguage containsEpsilon == false+\n"
+	  return answer
+	end
+      end
+
+      if allHaveEpsilon == true
+	answer.add( epsilon )
+      end
+      #print "+firstWithinLanguage+\n"
+      answer
+    end
+
+    # printing
+    def printContentsOn( aStream )
+      each { |symbol| symbol.printNameOn( aStream ); aStream << " " }
+    end
+
+    def printOn( aStream )
+      # added this space in here to make more readable
+      aStream << "a " << self.class.to_s << " "
+      printContentsOn( aStream )
+    end
+
+    def indiceesOf( aGrammarSymbol )
+      answer = Array.new
+      lastFound = 0
+      lastFound = index( aGrammarSymbol )
+      answer = self.subArray( lastFound, size )
+      while lastFound != nil
+	answer.push( lastFound )
+	lastFound = answer.index( aGrammarSymbol )
+	answer = answer.subArray( lastFound, answer.size )
+      end
+      answer
+    end
+    
+    # testing
+    def containsNonTerminal?( aGrammarSymbol )
+      each { |sym| if sym == aGrammarSymbol ; return true; end }
+      return false
+    end
+
+    def isEpsilon?
+      each do
+	|symbol| 
+	if symbol != nil
+	  if symbol.isEpsilon? == false 
+	    return false
+	  end
+	end
+      end
+      return true
+    end
+
+  end
+
+end

data/xiacc-0.1/lib/nist/xiacc/GrammarSymbol.rb

@@ -0,0 +1,129 @@
+module XI
+  require 'stringio'
+  require 'nist/xiacc/CCObjectAddon'
+
+  class GrammarSymbol
+
+    attr :name, true
+    attr :value, true   # used for actions
+
+    def GrammarSymbol.name( aSymbol )
+      gs = GrammarSymbol.new
+      gs.name = aSymbol
+      gs
+    end
+
+    def firstWithinLanguage( aLanguage )
+
+      answer = Set.new
+
+      if isTerminal?
+	answer.add( self )
+	return answer
+      end
+
+      productions = aLanguage.productionsFromNonTerminal( self )
+      productions.each do
+	|production|
+	if production.isEpsilon?
+	  answer.add( Epsilon.default )
+	else
+	  if production.expansion.first.class == Terminal or  production.expansion.first.name.to_s != self.name.to_s
+	    firsts = production.expansion.firstWithinLanguage( aLanguage )
+	    answer.addAll( firsts ) if production.expansion.first.to_s != name.to_s
+	  end
+	end
+      end if productions != nil
+      answer
+    end # def firstWithinLanguage
+
+    def followsWithinLanguage( aLanguage )
+      answer = Set.new
+      if aLanguage.startingNonTerminal.equal?( self )
+	answer.add( EndMarker.default )
+      end
+
+      productions = aLanguage.productionsWithExpansionContainingNonTerminal( self )
+      productions = productions.select { |prod| prod.nonTerminal != self }
+
+      epsilon = Epsilon.default
+      productions.each do
+	|production|
+	pe = production.expansion
+	size = pe.size
+	indices = Array.new
+	pe.size.times { |idx| indices.push( idx ) if pe[ idx ] == self }
+	indices.each do
+	  |idx|
+	  if idx == size - 1
+	    aLanguage.follow( production.nonTerminal ).each { |object| answer.add( object ) }
+	  else
+	    nextSymbol = pe[ idx + 1 ]
+	    first = aLanguage.first( nextSymbol )
+	    if first.include?( epsilon )
+	      first.delete( epsilon )
+	      first.each { |object| answer.add( object ) }
+	      aLanguage.follow( production.nonTerminal ).each { |object| answer.add( object ) }
+	    else
+	      answer.addAll( first )
+	    end
+	  end
+	end
+      end
+      answer
+    end
+
+    def printNameOn( aStream )
+      aStream << @name
+    end
+
+    def printOn( aStream )
+      printNameOn( aStream )
+    end
+
+    def to_s 
+      return self.printOn( StringIO.new ).string
+    end
+
+    # testing
+    def isTerminal?
+      error( "A subclass should have implemented this: grammar_symbol#isTerminal?" )
+    end
+
+    def isEndMarker?
+      false
+    end
+
+    def isEpsilon?
+      false
+    end
+    
+    def isNonTerminal?
+      !isTerminal?
+    end  
+
+    def hash
+      @name.hash
+    end
+
+    def eql?( another )
+      return true if self.hash == another.hash
+      return false
+    end
+
+    def <=>( another )
+      if another == nil
+	return 1
+      end
+
+      if @name < another.name
+	return -1
+      elsif @name > another.name
+	return 1
+      else
+	return 0
+      end
+    end
+
+  end
+end

data/xiacc-0.1/lib/nist/xiacc/GraphSearch.rb

@@ -0,0 +1,129 @@
+module XI
+
+  require 'nist/xiacc/CCObjectAddon'
+  require 'nist/xiacc/GraphSearchProgress'
+  require 'nist/xiacc/CCArrayAddon'
+  require 'nist/xiacc/CCSetAddon'
+
+  class GraphSearch
+
+    attr :fetchBlock, true
+    attr :predecessors, true    # Hash { FiniteAutomatonState => Array[ FiniteAutomatonState ]
+    attr :progressTracker, true # GraphSearchProgress
+    attr :unfinished,      true # Array
+    attr :userData,     true
+    attr :visited,    true # Set
+
+    #initialization
+    def initialize
+      @visited =  Array.new
+      @unfinished =  Array.new
+      @predecessors =  Hash.new   
+      #@progressTracker = GraphSearchProgress.new
+    end
+    
+    # Initialize the predecessor to a single vertex
+    def initializePredecessorsOf( vertex )
+      setPredecessors( vertex, Array.new )
+    end
+    
+    # Initialize the predecessors to a set of vertices
+    def initializePredecessorsOfVertices( vertices )
+      vertices.each { |vertex| 
+	initializePredecessorsOf( vertex ) 
+      }
+    end
+    
+    def addNewUnfinished( vertex )
+      error( "A subclass should have implemented this: graph_search#addNewUnfinished" )
+    end
+    
+    # Set the start vertices (no predecessors here)
+    def addStartVertices( vertices )
+      print "DOH DOH DOOH\n"
+      addVertices( vertices, nil )
+    end
+    
+    # For each vertex in vertices, add the vertex with
+    # pred as its predecessor
+    def addVertices( vertices, predecessor )
+      #print "HERE, vertices size: #{vertices.size}\n" 
+      #exit
+      vertices.each { |vertex| 
+	print "adding vertex: #{vertex.to_s}\n"
+	addVertex( vertex, predecessor ) 
+      }    
+    end
+    
+    # Assign the predecessor of vertex to be predecessor, and 
+    # add vertex to the search path
+    def addVertex( vertex, predecessor )
+      print "\n\nin addVertex: #{vertex.to_s} \nwho called me: #{caller.first.to_s}\n"
+      print "visited: {  #{@visited.join( " \n\t    " )}}\n"
+      setPredecessorOf( vertex, predecessor )
+      if !@visited.include?( vertex )
+	print "VISITED didn't include me, so adding\n"
+	addNewUnfinished( vertex )
+	@visited.push( vertex )
+      end
+    end
+    
+    # Set the predecessor of vertex to be predecessor
+    def setPredecessorOf( vertex, predecessor )
+      @predecessors[ vertex ] = Array.new if @predecessors[ vertex ] == nil
+      @predecessors[ vertex ].push( predecessor )
+    end
+    
+    # Used while searching -- generally finds the next node in the tree
+    def fetchVerticesFrom( vertex ); @fetchBlock.call( vertex, self ); end
+
+    # Are there any nodes left in the search?
+    def hasUnfinished?; !@unfinished.empty?; end
+
+    # Increment the progress tracker
+    def incrementProgress; @progressTracker.increment; end
+
+    # Find the next unfinished node in the search path
+    def nextUnfinished; @unfinished.shift; end
+    
+    # Assign the predecessor(s) of vertex to be object(s)
+    def setPredecessors( vertex, objects )
+      print "setting predecessor of vertex: #{vertex.to_s} to state: #{objects.to_s}\n"
+      @predecessors[ vertex ] = Array.new if @predecessors[ vertex ] == nil
+      @predecessors[ vertex ].addAll( objects )
+    end
+
+    # Traverse the tree, and assign predecessors to nodes
+    def search
+      while hasUnfinished?
+	print "\n\nSEARCH::while hasUnfinished?\n"
+	print "!!@@@@@@@@@@!! engine's predecessors are: \n"
+	predecessors.each_pair { |key,value| print "state: #{key.to_s} \n pred: #{value.to_s}\n" }
+
+	print "unfinished: {  #{unfinished.join( " \n\t\t" )}}\n"
+	n = nextUnfinished
+	print "n is: #{n.to_s}\n"
+	vertices = fetchVerticesFrom( n )
+	print "vertices are: #{vertices.to_s}\n"
+	return false if !vertices
+	addVertices( vertices, n )
+      end
+      true
+    end
+    
+    # Search from a single vertex
+    def searchFrom( vertex ); searchFromAll( [ vertex ] ); end
+    
+    # Search from a group of vertices
+    def searchFromAll( vertices )
+      addStartVertices( vertices )
+      search 
+    end
+
+    # What's the current percent done?
+    def percent?
+      @progressTracker.percent?
+    end
+    
+  end
+end

data/xiacc-0.1/lib/nist/xiacc/GraphSearchProgress.rb

@@ -0,0 +1,19 @@
+module XI
+  require 'nist/xiacc/CCObjectAddon'
+
+  class GraphSerachProgress
+
+    attr :max, true
+    attr :progress, true
+
+    def initialize; @progress = 0; end
+    
+    # operations
+    def increment; @progress = @progress + 1; end
+    
+    # query
+    def isGraphSearchProgress?; true; end
+    def percent?; ( 100 * progress / @max ).rounded; end
+
+  end
+end

data/xiacc-0.1/lib/nist/xiacc/InstanceManager.rb

@@ -0,0 +1,101 @@
+module XI
+  require 'nist/xiacc/CCObjectAddon'
+
+  class InstanceManager
+
+    @@instanceRegistry = Hash.new
+
+    attr :name, true
+
+    # instance creation
+    def initialize
+      super
+    end
+
+    # instance creation (low level)
+    def InstanceManager.newNamed( symbol )
+      return name( symbol, buildUsing( symbol ) )
+    end
+
+    def InstanceManager.buildUsing( symbol )
+      self.method( symbol ).call
+    end
+
+    def InstanceManager.defaultNamed( symbol )
+      InstanceManager.name( symbol, nil )
+    end
+
+    def InstanceManager.defaultNamedWithClass( symbol, className )
+      InstanceManager.name( symbol, className )
+    end
+    
+    # instance management
+    def InstanceManager.initializeAll
+      # find all the objects which have classes that subclass this object's class
+      # this seems broken now -- specifying a module in each_object doesn't return
+      # the subclass modules unless they are actually instantiated... so a work-around
+      # method "testSuperclass" is implemented below
+      ObjectSpace.each_object( Class ) do
+	|obj|
+	if obj.to_s != "fatal" and eval( obj.to_s ) != nil
+	  if testSuperclass( InstanceManager, eval( obj.to_s ) )
+	    eval( obj.to_s ).initializeInstanceRegistry
+	  end
+	end
+      end
+    end
+    
+    def InstanceManager.initializeInstanceRegistry
+      instanceRegistry( Hash.new )
+    end
+
+    def InstanceManager.instanceNamed( symbol )
+      @@instanceRegistry[ symbol ]
+    end
+    
+    def InstanceManager.testInstanceNamed( symbol, &errBlock )
+      if @@instanceRegistry[ symbol ] == nil
+	errBlock.call
+      end
+      @@instanceRegistry[ symbol ]
+    end
+
+    def InstanceManager.getInstanceRegistry
+      @@instanceRegistry
+    end
+    
+    def InstanceManager.instanceRegistry( registry )
+      @@instanceRegistry = registry
+    end
+
+    def InstanceManager.name( symbol, instance )
+      instance = instance.new
+      #print "instance's class: #{instance.class.to_s}\n"
+      instance.name = symbol
+      @@instanceRegistry[ symbol ] = instance
+    end
+    
+    def InstanceManager.named( symbol )
+      if InstanceManager.instanceNamed( symbol ) == nil
+	return InstanceManager.newNamed( symbol )
+      end
+    end
+
+    def testSuperclass( superClassName, className )
+      if className.superclass == superClassName
+	return true
+      elsif className == Object
+	return false
+      else
+	return testSubclass( superClassName, className.superclass )
+      end
+    end
+
+    def setGenerator( aGenerator )
+      error( "Subclass responsibility" )
+    end
+
+  end
+
+  
+end