xiacc 0.1

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

@@ -0,0 +1,25 @@
+class Object
+
+  def isGraphSearchProgress?; false; end
+  def continueParse?; false; end
+  def equivalentKid; nil; end
+  def hasParseChildren?; false; end
+  def isParseTreeNode?; false; end
+  def parseTreeViewerRepresentation; nil; end
+  def simplifyParseTree; end
+  def valueIn( context ); self; end
+  def isGraphSearchProgress?; false; end
+  def isCollection?; false; end
+  def isFiniteAutomatonState?; false; end
+  def tokenDestinationDisplay; nil; end
+
+  def error( str )
+    print "\nFatal error: ""#{str}""  from object class: ""#{self.class.to_s}"" and id #{self.object_id.to_s}\n\n"
+    print "Stack trace:\n"
+    for i in 1..caller.size
+      print caller[ i ] + "\n" 
+    end
+    exit
+  end
+
+end

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

@@ -0,0 +1,19 @@
+require 'set'
+
+class Set
+
+  def addAll( items )
+    items.each { |item| add( item ) }
+  end
+
+  def deleteLike( object )
+    each { |o| delete( o ) if o.eql?( object ) }
+  end
+
+  def includeLike?( object )
+    #print "-includeLike-\n"
+    each { |o| return true if o.eql?( object ) }
+    return false
+  end
+
+end

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

@@ -0,0 +1,38 @@
+class String
+
+  def as_a
+    return to_a
+  end
+
+  def to_a
+    a = Array.new
+    strip!
+    each( " " ) { |item| a.push( item ) }
+    a
+  end
+
+  def substr( beg, endi )
+    retval = String.new
+
+    if beg > length or endi < 0 or beg > endi
+      return
+    end
+
+    if endi > length
+      endi = length
+    end
+
+    index = beg
+    (endi - beg).times do
+      retval = retval << self[index]
+      index = index + 1
+    end
+
+    retval
+  end
+
+  def eql?( another )
+    return true if self.hash == another.hash
+  end
+  
+end

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

@@ -0,0 +1,343 @@
+module XI
+
+  require 'set'
+  require 'pp'
+	require 'nist/xiacc/LRParserGenerator'
+  require 'nist/xiacc/ParserWarning'
+  require 'nist/xiacc/ParserActionAccept'
+  require 'nist/xiacc/ParserActionReduce'
+  require 'nist/xiacc/ParserActionShift'
+  require 'nist/xiacc/CanonicalLRParserItem'
+  require 'nist/xiacc/DebugParserState'
+  require 'nist/xiacc/ItemSet'
+  require 'nist/xiacc/ParserTransition'
+  require 'nist/xiacc/ParserActionPreAccept'
+
+  class CanonicalLRParserGenerator < LRParserGenerator
+
+    # instance creation
+    def CanonicalLRParserGenerator.language( lang )
+      LRParserGenerator.language( lang )
+    end
+
+    # operation
+    def closureOfItemSet( aSet )
+      closureOfItemSetExcluding( aSet, Array.new )
+    end
+
+    def generateStates
+      # generateStates: corresponds to the first part of "procedure items(G');" 
+      # on page 232, Dragon Book..
+      terminals = @language.terminals.reject { |terminal| terminal.isEpsilon? }
+      nonTerminals = @language.nonTerminals
+      # Generate the S', or AugmentedState .. which is needed for certain LR grammars
+      # newStates is really "C" in the DB
+      newStates = [ generateInitialState ]
+      while !newStates.empty?
+	# Go through each state, and find states that are linked to it via terminal
+	# and non-terminal transitions. Even though nothing is added in this method,
+	# there are side effects in other methods which populate the states' 
+	# terminal and non-terminal transition objects.
+	#print "hello  "
+	startingStates = newStates
+	newStates = Array.new
+	terminalStates = self.newStatesFromStatesUsingTerminals( startingStates, terminals )
+	#print "got #{terminalStates.size} terminalStates\n"
+	newStates.addAll( terminalStates )
+	nonTerminalStates = self.newStatesFromStatesUsingNonTerminals( startingStates, nonTerminals )
+	newStates.addAll( nonTerminalStates )
+      end
+    end
+
+    def goToGrammarSymbol( symbol, items )
+      # goToGrammarSymbol: defined on page 232 of the Dragon Book:
+      # "function goto(I, X);"
+
+      j = items.class.new
+      items.each do 
+	# item => LRParserItem
+	|item|
+	# give symbols to the right of index.. or the dot
+	remaining = item.remainingGrammarSymbols
+	if !remaining.empty? and remaining.first.equal?( symbol )
+	  cologne = item.clone
+	  #cologne = Marshal.load( Marshal.dump( item ) )
+	  cologne.advance
+	  j.push( cologne )
+	end
+      end
+      #print "Going to grammar symbol (function goto): #{symbol.to_s}\n"
+      #print "Before closure, j is: #{j.join( "  \n\t\t  " )}\n"
+      closure = closureOfItemSet( j )
+      #print "Closure is: #{closure.join( "  \n\t\t   " )}\n"
+      closure
+    end
+
+    def newStatesFromStatesUsingTerminals( inputStates, terminals )
+      answer = Array.new
+      inputStates.each do 
+	|sourceState|
+	transitions = Array.new
+	grabContext = false
+	shortcut = nil
+	action = nil
+	# get the items for a state
+	#print "\nSourceState: #{sourceState.to_s}"
+	sourceStateItems = itemsForState( sourceState )
+	terminals.each do 
+	  |terminal|
+	  destinationStateItems = goToGrammarSymbol( terminal, sourceStateItems )
+	  #print "From a terminal: #{terminal.to_s} we get DestinationStateItems: #{destinationStateItems.join( "\n\t" )}\n"
+	  if !destinationStateItems.empty?
+	    # create a state for the destinationStateItems if one doesn't exist
+	    destinationState = testAbsenseForStateForItems( destinationStateItems ) { state = createStateForItems( destinationStateItems ) ; answer.push( state ) ; state }
+	  end
+
+	  transition = ParserTransition.alternativeInitialize( sourceState, terminal, destinationState )
+	  # is this transition a shift/accept/reduce? ... action is the answer
+	  # FFFFF
+	  parserAction = parserActionForTransition( transition, sourceStateItems )
+	  if parserAction != nil
+	    stateItems = Array.new # empty
+	    if parserAction.class == ParserActionPreAccept and sourceStateItems.size == 1 and sourceStateItems.first.production.expansion[ sourceStateItems.first.index - 1 ].class == NonTerminal
+	      stateItems = sourceStateItems 
+	    end
+
+	    stateItems = destinationStateItems if parserAction.class != ParserActionPreAccept
+	    actions = Array.new
+	    #print "STATE ITEMS SIZE: #{stateItems.size}\n"
+	    stateItems.each do
+	      |item|
+	      grabContext = false
+	      #print "looking at item: #{item}\n"
+	      action = self.actionForItem( item )
+	      actions.push( action ) if action != nil and !actions.include?( action )
+	      #print "got an action: |#{action}|\n"
+	      shortcut = self.shortcutForItem( item )
+	      parserAction.grabContext = true if shortcut and parserAction.class != ParserActionPreAccept
+	      parserAction.shortcuts.push( shortcut ) if shortcut and !parserAction.shortcuts.include?( shortcut )
+	      #break if action != nil # and shortcut != nil
+	    end # stateItems.each
+	    destinationState.actions = actions if parserAction.class != ParserActionPreAccept and destinationState != nil
+	    #print "*****************************************************************\n"
+	    #print "StateItems: \"#{sourceStateItems.join( "\" " )}\n" if parserAction.class != ParserActionPreAccept
+	    #print "StateItems: #{sourceStateItems.to_s}\n" if parserAction.class == ParserActionPreAccept
+	    #print "DestinationState: #{destinationState.to_s}\n" if destinationState != nil
+	    #print "action is: #{action.to_s}\n" if action != nil
+	    #print "parserAction's class: #{parserAction.class.to_s}\n"
+	    #print "*****************************************************************\n\n\n"
+	    #print "parser action's action: #{parserAction.action.to_s}\n" if parserAction != nil
+	    #transitions[ terminal ] = parserAction
+	    transitions.push( [ terminal, parserAction ] )
+	  end # if parserAction
+	end # terminsls.each
+
+	sourceState.terminalTransitions = transitions
+
+      end # inputStates.each
+      answer
+    end
+
+    def newStatesFromStatesUsingNonTerminals( inputStates, nonTerminals )
+      # newStatesFromStatesUsingNonTerminals: corresponds to "procedure items(G');" 
+      # on page 232, Dragon Book..
+      # note that the non-terminals are passed in, and they are used instead of the 
+      # generic "grammar symbol X" in the Dragon Book
+      #print "+newStatesFromStatesUsingNonTerminals+\n"
+
+      answer = Array.new
+      action = nil
+      inputStates.each do
+	|state|
+	#print "State: <<#{state.to_s}>>\n"
+	transitions = Hash.new
+	items = itemsForState( state )
+	#items.each { |item| print "\t#{item.to_s}\n" }
+	items.each do
+	  |item|
+	  firsts = item.production.nonTerminal.firstWithinLanguage( @language )
+	end
+	nonTerminals.each do
+	  |symbol|
+	  #print "Looking at transition nonterminal: #{symbol.to_s}\n"
+	  newItems = goToGrammarSymbol( symbol, items )
+	  if !newItems.empty?
+	    destination = testAbsenseForStateForItems( newItems ) { newState = createStateForItems( newItems ) ; answer.push( newState ) ; newState }
+	    #print "Destination: #{destination.to_s}\n"
+	    parserAction = ParserActionShift.nextState( destination )
+	    
+	    ## assign the action and shortcuts
+	    #action = nil
+	    actions = Array.new
+	    newItems.each do
+	      |item|
+	      grabContext = false
+	      action = actionForItem( item )
+	      actions.push( action ) if action != nil and !actions.include?( action )
+	      shortcut = shortcutForItem( item )
+	      parserAction.shortcuts.push( shortcut ) if shortcut != nil and !parserAction.shortcuts.include?( shortcut )
+	      parserAction.grabContext = true if shortcut != nil
+	    end
+	    destination.actions = actions if parserAction.class != ParserActionPreAccept
+	    transitions[ symbol ] = parserAction
+	  end
+	end
+	state.nonTerminalTransitions = transitions
+      end
+      answer
+    end
+    
+    # operation (action calculation)
+    # FFFF
+    def parserActionForTransition( parserTransition, sourceStateItems )
+      # figure out if there needs to be an action inserted into the ParserAction
+      # if sourceStateItems.
+      symbol = parserTransition.symbol
+      #print "looking at symbol: #{symbol}\n"
+      #print "sourceSTateItems class: #{sourceStateItems.class}\n"
+      reduceItems = sourceStateItems.endItemsWithLookahead( symbol )
+      #print "reduceItems: #{reduceItems.join( " " )}\n"
+      shift = sourceStateItems.includesNextSymbol?( symbol )
+      accept = ( symbol.isEndMarker? and reduceItems.containsProduction?( @language.startProduction ) ) == true
+      reduce = ( !accept and !reduceItems.empty? ) == true
+      
+      if !shift and !reduce and !accept
+	return nil
+      elsif shift and !reduce and !accept
+	return shiftActionForTransition( parserTransition )
+      elsif !shift and !reduce and accept
+	action = ParserActionPreAccept.new
+	action.acceptState = DebugParserState.new
+	action.acceptState.terminalTransitions[ EndMarker.default ] = ParserActionAccept.new
+	return action
+      elsif !shift and reduce and !accept
+	return reduceActionForTransition( parserTransition, reduceItems )
+      elsif shift and reduce and !accept
+	return shiftReduceConflictActionForTransition( parserTransition, reduceItems )
+      end
+      
+      self.error( "This is not an LR(1) language: unhandled shift/reduce/accept conflict" )
+    end
+
+    def reduceActionForTransition( parserTransition, reduceItems )
+      @warnings.push( ParserWarning.alternativeInitialize( "ReduceReduceConflict", parserTransition, reduceItems ) ) if reduceItems.size > 1
+      return ParserActionReduce.production( reduceItems.first.production )
+    end
+    
+    def shiftActionForTransition( aParserTransition )
+      # XXXXXXX destinationState here is an array... ? i don't think it should be
+      return ParserActionShift.nextState( aParserTransition.destinationState )
+    end
+    
+    def shiftReduceConflictActionForTransition( aParserTransition, reduceItems )
+      @warnings.push( ParserWarning.alternativeInitialize( "ShiftReduceConflict", aParserTransition, reduceItems ) )
+      return shiftActionForTransition( aParserTransition )
+    end
+    
+    
+    # operation (experimental)
+    def generateItemSets
+      answer = Set.new
+      seedItem = eval( itemClass ).new( @language.startProduction, 0, EndMarker, default )
+      answer.add( closureOfItemSet( ItemSet.with( seedItem ) ) )
+      grammarSymbols = @language.grammarSymbols
+      dictionaryOfPreviousTest = Hash.new
+      grammarSymbols.each do
+	|symbol|
+	dictionaryOfPreviousTests[ symbol ] = Set.new
+      end
+      unfinishedTests = unfinishedTestsFromItems( dictionaryOfPreviousTests, answer )
+      while !unfinishedTests.empty?
+	unfinishedTests.each_pair do
+	  |symbol, untestedSets|
+	  testedSets = dictionaryOfPreviousTests[ symbol ]
+	  untestedSets.each do
+	    |untestedSet|
+	    newSet = goToGrammarSymbol( symbol, untestedSet )
+	    if !newset.empty?
+	      answer.add( newSet )
+	    end
+	  end
+	end
+      end
+      answer
+    end
+    
+    def unfinishedTestsFromItems( dictionaryOfPrevioustests, allKnownItemSets )
+      answer = Hash.new
+      dictionaryOfPreviousTests.each_pair do
+	|symbol, previouslyTestedItemSets|
+	akis = Marshal.load( Marshal.dump( allKnownItemSets ) )
+	unTestedItemSets = akis - previouslyTestedItemSets
+	if unTestedItemSets.empty? == false
+	  answer[ symbol ] = unTestedItemSets
+	end
+      end
+      answer
+    end
+    
+    def closureOfItemSetExcluding( included, excluded )
+      # Corresponds to "Function closure(I);" on page 232, of the Dragon Book
+      # included, excluded => Sets of LRParserItems
+      newItem = ItemSet.new
+      ( included - excluded ).each do
+	|item|
+	remaining = item.remainingGrammarSymbols
+	if remaining.size > 0 and ( ( f = remaining.shift ).class == NonTerminal )
+	  newRemaining = remaining.clone # Marshal.load( Marshal.dump( remaining ) )
+	  newRemaining.push( item.lookahead )
+	  firsts = newRemaining.firstWithinLanguage( @language )
+	  firsts = firsts.select { |i| i.kind_of?( Terminal ) }
+	  ( @language.productionsFromNonTerminal( f ) ).each do
+	    |production|
+	    firsts.each do
+	      |first|
+	      newItem.push( itemClass.alternativeInitialize( production, 0, first ) )
+	      #newItem.push( itemClass.alternativeInitialize( production, 0, EndMarker.default ) )
+	    end
+	  end
+	end
+      end
+      
+      if !newItem.empty?
+	#print "DOING IT AGAIN\n"
+	excluded.addAll( included )
+	#print "newItem - excluded: #{newItem - excluded}\n"
+	newItem = closureOfItemSet( newItem - excluded )
+      end
+
+      included.addAll( newItem )
+      included.uniq!
+      #print "included: #{included.to_s}\n"
+      #print "\n+closureOfItemSetExcluding+\n"
+      included
+    end
+    
+    # query
+    def itemClass
+      CanonicalLRParserItem
+    end
+    
+    def stateClass
+      DebugParserState
+    end
+    
+    def states
+      @stateKeyedDictionary.keys
+    end
+
+    def actionForItem( item )
+      #print "item is: #{item.to_s} index: #{item.index} ITEM CLASS: #{item.class} actions: #{item.production.actions.size} keys: #{item.production.actions.keys} has_key: #{item.production.actions.has_key?( item.index )}\n"
+      #exit
+      return item.production.actions[ item.index ] if item.production.actions.has_key?( item.index )
+    end
+
+    def shortcutForItem( item )
+      items = item.production.shortcuts.select { |shortcut| shortcut.index == item.index - 1 }
+      #print "ITEMS SIZE: #{items.size}\n"
+      return nil if items.size == 0
+      items.first
+    end
+    
+  end
+end

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

@@ -0,0 +1,49 @@
+module XI
+  require 'stringio'
+  require 'nist/xiacc/LRParserItem'
+
+  class CanonicalLRParserItem < LRParserItem
+
+    attr :lookahead, true  # a GrammarSymbol
+
+    def initialize
+      super
+    end
+
+    def CanonicalLRParserItem.alternativeInitialize( aProduction, positiveInteger, aGrammarItem )
+      item = CanonicalLRParserItem.new
+      item.production = aProduction
+      item.index = positiveInteger
+      item.lookahead = aGrammarItem
+      item
+    end
+
+    def ==( anotherInstance )
+      if super == anotherInstance and @lookahead.equal?( anotherInstance.lookahead )
+	return true
+      else
+	return false
+      end
+    end
+    
+    def eql?( another )
+      return true if self.hash == another.hash
+      return false
+    end
+
+    def hash
+      return super.hash + @lookahead.hash
+    end
+
+    def printOn( aStream )
+      super( aStream )
+      aStream << " , "
+      @lookahead.printNameOn( aStream )
+    end
+
+    def to_s
+      return printOn( StringIO.new ).string
+    end
+
+  end
+end