xiacc 0.1

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

@@ -0,0 +1,41 @@
+module XI
+  require 'nist/xiacc/collection_exclusion_comparator'
+
+  # what a mighty long name
+  class RestrictedCollectionExclusionComparator < CollectionExclusionComparator
+    
+    attr :filterBlock
+
+    def initialize
+      super
+      @filterBlock = Proc.new { |a| return true }
+    end
+
+    def RestrictedCollectionExclusionComparator.alternativeInitialize( anArray, classCollection )
+      rcec = RestrictedCollectionExclusionComparator.new
+      rcec.collection = anArray
+      rcec.setClasses( classCollection )
+      rcec
+    end
+    
+    def RestrictedCollectionExclusionComparator.alternativeInitialize2( aCollection, oneArgBlock )
+      rcec = RestriectedCollectionExclusionComparator.new
+      rcec.collection = aCollection
+      rcec.filterBlock = oneArgBlock
+      rcec
+    end
+
+    def setClasses( aCollection )
+      @filterBlock = Proc.new { |arg| aCollection.include?( arg.class ) }
+    end
+    
+    def equal?(anObject)
+      retval = false
+      if self == anObject or ( @filterBlock.call( anObject ) and !@collection.include?( anObject ) )
+	retval = true
+      end
+      retval
+    end
+
+  end
+end

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

@@ -0,0 +1,40 @@
+module XI
+
+  require 'stringio'
+  require 'nist/xiacc/CCObjectAddon'
+
+  class Shortcut
+
+    # the reason for shortcuts is as follows:
+    # say there is a production A -> B d B
+    # then there is no way to easily refer (without it being ugly)
+    # to the first or second B... shortcuts make it easy:
+    # A -> B.first d B.second
+    # now we can refer to the first B as 'first' and the second
+    # B as 'second' 
+
+    attr :index, true   # the index of the object in the production
+    attr :object, true  # the name of the object in the production
+    # i.e.: A -> B.d     B is the 'object' here
+    attr :name, true    # the aliased name of the object in the production
+    # i.e.: A -> B.d     d is the 'alias' of B
+    attr :value, true   # the value.. any object
+    # i.e.: if number = /[[:digit:]]/
+    # and   A -> number.num   then  'value' is the value of number
+
+    def initialize( index, object, name, value )
+      @index, @object, @name, @value = index, object, name, value
+      self
+    end
+
+    def printOn( stream )
+      stream << " <<a Shortcut index: #{@index.to_s} object: #{@object.to_s} name: #{@name.to_s} value: #{@value.to_s}>> "
+      stream
+    end
+
+    def to_s
+      printOn( StringIO.new ).string
+    end
+
+  end
+end

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

@@ -0,0 +1,46 @@
+module XI
+
+  require 'stringio'
+  require 'nist/xiacc/GrammarSymbol'
+
+  class Terminal < GrammarSymbol 
+
+    include Comparable
+
+    #attr :value, true
+    attr :description, true # either a String or a Regexp
+
+    def Terminal.nameAndValue( aSymbol, anObject )
+      t = Terminal.new
+      t.name = aSymbol
+      t.value = anObject
+      t.description = nil
+      t
+    end
+
+    #def hash
+    #  super
+    #end
+
+    #def ==( anObject )
+    #  print "IN EQUAL EQUAL\n"
+    #  if self.eql?( anObject ) or @value == anObject
+    #    return true
+    #  end
+    #  return false
+    #end
+
+    def isTerminal?; true; end
+    
+    #def to_s
+    #  return printOn( StringIO.new ).string
+    #end
+
+    #def printOn( aStream )
+    #  super( aStream )
+    #  aStream << "a <Terminal> " << @value
+    #  aStream
+    #end
+
+  end
+end

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

@@ -0,0 +1,16 @@
+module XI
+
+  require 'nist/xiacc/CCObjectAddon'
+
+  class TerminalDescription
+
+    attr :terminal, true
+    attr :description, true
+
+    def TerminalDescription.terminalNameAndDescription( terminalName, description )
+      @terminal = Terminal.nameAndValue( terminalName, "" )
+      @description = description
+    end
+
+  end
+end

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

@@ -0,0 +1,90 @@
+module XI
+
+  require 'stringio'
+  require 'nist/xiacc/Lexer'
+
+  class TextLexer < Lexer
+
+    attr :ignoreWhitespace, true
+    attr :endMarker, true  # like ; in c
+
+    def initialize( descs = nil, em = nil )
+      super( descs )
+      self.ignoreWhitespace = true
+      self.endMarker = em
+    end
+
+    def lexAll( i = nil, num = -1 )
+      #print "input up here: #{self.input}\n"
+      matches = 0
+      i and ( self.input = i )
+
+      stripWhitespace if ignoreWhitespace
+
+      segToTest = self.input
+      #print "input: |#{self.input}| endMarker: |#{self.endMarker}|\n"
+      #stopPosition = self.input.rindex( self.endMarker )
+      if ( self.input[ 0 ] != nil and self.endMarker and ( String.new( "" ) << self.input[ 0 ] ) == endMarker.to_s )
+	#print "got here\n"
+	self.input = self.input[ self.endMarker.size, self.input.size - 1 ]
+      end
+
+      stopPosition = self.input.index( ';' )
+      #print "stopPoint: #{stopPosition} input0: #{String.new("") << self.input[0]} ;: #{String.new(";")}\n"
+
+      if self.endMarker
+	stripWhitespace
+	#print "input here: |#{self.input}|\n"
+	segToTest = self.input[ 0 .. stopPosition - 1 ] if stopPosition
+      end
+
+      if segToTest
+	#print "segToTest: |#{segToTest}|\n"
+	self.descriptions.each do
+	  |description|
+	  regex = description.first
+	  name = description.last
+	  #print "matching with name: #{name} regex: #{regex}\n"
+	  if ( matchData = regex.match( segToTest ) )
+	    next if matchData[ 0 ] == "" or self.input.index( matchData[ 0 ] ) > 0
+	    #print "size: #{matchData.size} regex: #{regex}\n"
+	    matchedString = matchData[ 0 ]
+	    #print "**matchedString: #{matchedString}\n"
+	    #print "input (0): #{input}\n"
+	    self.input = self.input[ matchedString.size .. self.input.size - 1 ]
+	    #print "input (1): #{input}\n"	  
+	    #self.input = self.input[ self.endMarker.size .. self.input.size ] if self.endMarker
+	    #print "input (2): #{input}\n"
+	    #return [ matchedString ]
+	    #print "creating terminal with name: #{name} value: #{matchedString}\n"
+	    return Terminal.nameAndValue( name, matchedString )
+	  end
+	end
+      end
+      #print "Returning new array\n"
+      EndMarker.default
+      #Epsilon.default
+    end
+
+    def nextToken; lexAll( nil, 1 ); end
+    def printOn( stream ); stream << "a TextLexer: "; end
+    def to_s; printOn( StringIO.new ).string; end
+    
+    def stripWhitespace
+      return if self.input[ 0 ] == nil
+      input0 = ( String.new( "" ) << self.input[ 0 ] )
+      while ( input0 == " " or input0 == "\t" or input0 == "\n" )
+	self.input = self.input[ 1 .. self.input.size - 1 ] 
+	input0 = ( String.new( "" ) << self.input[ 0 ] )
+      end
+
+      inputE = ( String.new( "" ) << self.input[ -1 ] )
+      while ( inputE == " " or inputE == "\t" or inputE == "\n" )
+	self.input = self.input[ 0 .. self.input.size - 2 ] 
+	inputE = ( String.new( "" ) << self.input[ -1 ] )
+      end
+    end
+
+  end
+
+end

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

@@ -0,0 +1,38 @@
+module XI
+
+  require 'nist/xiacc/LexerGenerator'
+  require 'nist/xiacc/Language'
+
+  class TextLexerGenerator < LexerGenerator
+    
+    attr :endMarker, true
+
+    def initialize( lang = Language.new, em = nil )
+      super( lang )
+      self.endMarker = em
+    end
+
+    def generateLexer
+      terminals = self.language.terminalDict
+      
+      rs = Array.new
+      terminals.each_value do
+	|terminal|
+	#print "Terminal's class: #{terminal.class} name: #{terminal.name}\n"
+	if terminal.description
+	  toPush = terminal.description 
+	  name = terminal.name
+	else
+	  toPush = Regexp.new( Regexp.escape( terminal.name ) )
+	  name = terminal.name
+	end
+	#print "toPush: #{toPush.to_s}\n"
+	rs.push( [ toPush, name ] )
+      end
+      
+      lexer = TextLexer.new( rs, self.endMarker )
+      lexer
+    end
+
+  end
+end

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

@@ -0,0 +1,41 @@
+module XI
+
+  require 'stringio'
+  require 'nist/xiacc/CCObjectAddon'
+
+  class Transition
+
+    attr :source, true
+    attr :event, true
+    
+    def initialize( source, event )
+      @source, @event = source, event
+    end
+
+    def destinations
+      error( "Corrupt Transition" ) if ( destins = @source.destinations ) == nil
+      destins
+    end
+
+    def eql?( anObject )
+      return false if !anObject.kind_of?( self.class )
+      return ( @source.eql?( anObject.source ) and @event.eql?( anObject.event ) )
+    end
+
+    def hash
+      @source.hash
+    end
+
+    def printOn( stream )
+      @source.printOn( stream )
+      stream << " -> "
+      stream << @event.to_s
+      stream
+    end
+
+    def to_s
+      printOn( StringIO.new ).string
+    end
+
+  end
+end

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

@@ -0,0 +1,97 @@
+module XI
+
+  require 'nist/xiacc/KeyedCollection'
+  require 'nist/xiacc/Association'
+
+  class UnHashedDictionary < KeyedCollection
+
+    attr :associations, true
+
+    def UnHashedDictionary.initializeWithSize( size )
+      uhd = UnHashedDictionary.new
+      uhd.associations = Array.new( size )
+      uhd
+    end
+
+    def keys
+      s = Set.new
+      @associations.collect { |assoc| s.add( assoc.key ) }
+      s
+    end
+
+    def keysAndValuesDo( twoArgumentBlock )
+      @associations.each { |assoc| twoArgumentBlock.call( assoc.key, assoc.value ) }
+    end
+
+    def size
+      @associations.size
+    end
+
+    def values
+      @associations.collect { |assoc| assoc.value }
+    end
+
+    # required by superclasses
+    def testAbsenceAtKey( key, &noArgumentBlock )
+      theAssoc = ""
+      @associations.each do
+	|assoc|
+	if assoc.key == key
+	  theAssoc = assoc
+	end
+      end
+      if theAssoc == ""
+	noArgumentBlock.call
+	return nil
+      else
+	return assoc.value
+      end
+    end
+
+    def addKeyAndValue( key, value )
+      found = false
+      @associations.each do 
+	|assoc|
+	if assoc.key == key
+	  found = true
+	end
+      end
+
+      if found == false
+	a = Association.new
+	a.key = key
+	a.value = value
+	@assocations.add( a )
+      end
+      value
+    end
+
+    def do( &aBlock )
+      # XXXX not sure if this is right, might be backwards
+      each { |val| aBlock.call( val ) }
+    end
+
+    def keysDo( &oneArgumentBlock )
+      @associations.each { |assoc| oneArgumentBlock.call( assoc.key ) }
+    end
+
+    def removeKeyIfAbsent( key, &noArgumentBlock )
+      target = ""
+      @associations.each do 
+	|assoc|
+	if assoc.key == key
+	  target = assoc
+	  break
+	end
+      end
+      
+      if target == ""
+	return noArgumentBlock.call
+      end
+
+      @associations.remove( target )
+      target.value
+    end
+
+  end
+end

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

@@ -0,0 +1,24 @@
+module XI
+
+  require 'nist/xiacc/OrderedCollection'
+
+  class UnHashedSet < OrderedCollection
+
+    def initialize
+      super
+    end
+
+    def add( anObject )
+      if include?( anObject ) == false
+	push( anObject )
+      end
+      anObject 
+    end
+
+    def addAll( aCollection )
+      aCollection.each { |piece| add( piece ) }
+      aCollection
+    end
+
+  end
+end

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

@@ -0,0 +1,22 @@
+module XI
+
+  require 'nist/xiacc/CCObjectAddon'
+
+  class UndefinedObject
+
+    attr :recordObject, true
+    attr :recordParseTree, true
+    attr :recordState, true
+    attr :object, true
+    attr :recordStates, true
+
+    def initialize
+      super
+    end
+
+    def recordState( recordState, object )
+      @recordState = recordState
+      @object = object
+    end
+  end
+end