xiacc 0.1

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

@@ -0,0 +1,109 @@
+module XI
+
+  require 'nist/xiacc/CCObjectAddon'
+  require 'nist/xiacc/Production'
+
+  class ParseTreeNode
+
+    attr :children, true
+    attr :production, true
+
+    def intialize
+      super
+      @children = Array.new
+    end
+
+    def ParseTreeNode.productionWithChildren( production, childrenCollection )
+      ptn = ParseTreeNode.new
+      ptn.children = childrenCollection
+      ptn.production = production
+    end
+
+    # accessors
+    def action
+      @production.action
+    end
+
+    # display meths
+    def equivalentKid
+      return nil if !hasParseChildren?
+      
+      kids = @children
+      idx = action
+      
+      return kids.first if kids.size == 1 and idx == nil
+
+      if idx.kind_of?( Fixnum ) 
+	if idx < 1 or idx > kids.size
+	  childIndexOutOfRange
+	  return kids.at( idx )
+	end
+      end
+      
+      nil
+    end
+    
+    def hasParseChildren?
+      return !@children.empty?
+    end
+    
+    def parseTreeViewerRepresentation
+      return @production.to_s
+    end
+    
+    def simplifyParseTree
+      @children.collect! do
+	|child| 
+	kid = child
+	grandkid = kid.equivalentKid
+	while grandkid != nil
+	  kid = grandkid
+	  grandkid = kid.equivalentKid
+	end
+	kid.simplifyParseTree
+      end
+    end
+    
+    #errors
+    def childIndexOutOfRange
+      error( "Child index out of range" )
+    end
+    
+    #operation
+    def valueIn( context )
+      return equivalentKid.valueIn( context ) if equivalentKid != nil
+      return action.call( context, self ) if action != nil
+      
+      @children.collect! do
+	|child|
+	kid = child
+	grandkid = kid.equivalentKid
+	while grandkid != nil
+	  kid = grandkid
+	  grandkid = kid.equivalentKid
+	end
+	kid.valueIn( context )
+      end
+      
+      @children
+    end
+    
+    def valueOf( n, context )
+      if !( n > 0 ) or !( @children.size >= n )
+	childIndexOutOfRange
+      end
+      
+      @children.at( n ).valueIn( context )
+    end
+    
+    #testing
+    def isParseTreeNode?
+      true
+    end
+    
+    def continueParse?
+      true
+    end
+    
+  end
+end

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

@@ -0,0 +1,208 @@
+module XI
+
+  require 'nist/xiacc/ParseTreeNode'
+  require 'nist/xiacc/InstanceManagerFromSpec'
+  require 'nist/xiacc/CanonicalLRParserGenerator'
+  require 'nist/xiacc/Language'
+
+  class Parser < InstanceManagerFromSpec
+    
+    attr :initialState, true
+    attr :stateStack, true
+    attr :recorder, true
+    attr :accepted, true
+    attr :context, true
+    attr :objects, true
+    attr :lexer, true
+    attr :state, true
+
+    def initialize
+      self.reset
+    end
+    
+    def Parser.initialState( aParserState )
+      parser = Parser.new
+      parser.initialState = aParserState
+      parser
+    end
+
+    def Parser.generatorClass
+      CanonicalLRParserGenerator
+    end
+    
+    def Parser.specClass
+      Language
+    end
+
+    def reset
+      self.accepted = false
+      self.stateStack = Array.new
+      self.objects = Array.new
+      self.state = "GO"
+      self.context = Hash.new
+      #self.lexer = nil
+    end
+
+    def setGenerator( aParserGenerator )
+      self.initialState = aParserGenerator.initialState
+    end
+    
+    def accept
+      self.accepted = true
+    end
+    
+    def currentState
+      retval = nil
+      if !self.stateStack.empty?
+	retval = self.stateStack.first
+      else
+	retval = self.initialState
+      end
+      #print "retval's class: #{retval.class.to_s}\n"
+      retval
+    end
+
+    def done
+      self.objects = [ EndMarker.default ]
+      object = self.objects.shift
+      while object != nil and !self.accepted
+	stepObject( object )
+	while !self.accepted and self.objects.first.continueParse?
+	  stepObject( object )
+	end
+	object = self.objects.shift
+      end
+      self.objects = Array.new
+      self.accepted
+    end
+    
+    def parseAll
+      #print "parserAll's lexer: #{self.lexer.to_s}\n"
+      parseAllHelper( nil )
+    end
+
+    def parseAllHelper( os )
+      #print "lexer: #{self.lexer.to_s}\n"
+      #initialize
+      #print "context here's: #{self.context.to_a.join( " " )}\n"
+      #exit
+      object = self.lexer.nextToken if self.state != "HOLD"
+      retval = object
+      while object != nil
+	#print "parsing object: #{object.to_s}\n"
+	break if self.accepted
+	save = object
+	stepObject( object )
+	stepObject( object ) while !self.accepted and object.continueParse? # self.objects.first.continueParse?
+	object = self.lexer.nextToken if self.state != "HOLD"
+	object = save if self.state == "HOLD"
+	#print "Accepted: #{self.accepted}\n"
+      end
+      #print "got here\n"
+      #exit
+      return retval if done
+      return nil
+    end
+
+    def performPostReductionActionFor( parseTree )
+      #self.self.context.each { |ctxt| parseTree.valueIn( ctxt ) } if self.self.context
+    end
+    
+    def pop
+      self.stateStack.shift
+      #return self.objects.shift
+    end
+    
+    def postReductionStateFor( aNonTerminal )
+      return currentState.postReductionStateFor( aNonTerminal, self.context )
+    end
+    
+    def pushState( parserState, object )
+      #print "pushing state: #{parserState.to_s} object: #{object.to_s}\n"
+      self.stateStack.unshift( parserState )
+      self.objects.unshift( object ) if object != nil
+      #self.objects.unshift( object )
+    end
+    
+    def record
+      self.recorder = ParseRecorder.new
+    end
+    
+    def reduceProduction( production, parseObject, parserState, context )
+      # Description: Reduce (production) caused by (parseObject) while in (parserState)
+      self.recorder.recordStates( self.stateStack )
+      nodeChildren = Array.new
+      # Get rid of production.expansion.size items on the stack for the reduce
+      production.expansion.size.times { pop } # nodeChildren.unshift( pop ) }
+      #print "STATE now: #{self.currentState().class} #{self.currentState().to_s}\n"
+
+      parserAction = currentState.nonTerminalTransitions[ production.nonTerminal ]
+      grabContextSave = parserAction.grabContext
+      parserAction.grabContext = false
+      parserAction.handleState( production.nonTerminal, currentState, self, self.context )
+      parserAction.grabContext = grabContextSave
+
+      self.objects.unshift( parseObject )
+      shortcutNames = Array.new
+      if parserAction.grabContext
+	#print "context[result]: #{context["result"]}\n"
+	if self.context[ "result" ] != nil
+	  #print "currentState: #{currentState.to_s} parseObject: #{parseObject}\n"
+	  items = currentState.items.select { |item| #print "looking at item: #{item.to_s}  production expansion: #{item.production.expansion}\n" ; 
+	      item.production.expansion[ item.index ].eql?( parseObject ) }
+	  if items.size == 0
+	    parserAction.shortcuts.each { |shortcut| shortcutNames.push( shortcut.name ) }
+	  elsif items.size > 0 #and items.first.production.shortcuts != nil # [ items.first.index - 1 ] != nil	  
+	    currentState.items.each do
+	      |item|
+	      #print "looping through item: #{item}      "
+	      #items.first.production.shortcuts.each { |shortcut| shortcutNames.push( shortcut.name ) if shortcut.index == items.first.index - 1 }
+	      item.production.shortcuts.each do
+		|shortcut| 
+		#print "shortcut's index: #{shortcut.index} items.first.index
+		if shortcut.index == item.index - 1
+		  shortcutNames.push( shortcut.name ) 
+		  #print "just pushed shortcut name: #{shortcut.name}    "
+		end
+	      end
+	      #print "\n"
+	    end
+	    # lets assume here that all shortcut's are the same. they should be. 
+	    #sc = sc.first.name
+	  end
+	  
+	  #self.context.delete_if { |key,value| key != "result" }
+	  shortcutNames.each do
+	    |shortcutName| 
+	    #print "context[ shortcutName ]: #{context[shortcutName]} and sc: #{shortcutName}\n"
+	    self.context[ shortcutName ] = self.context[ "result" ]
+	    #print "**shortcutname type: #{self.context[ shortcutName ].class}\n"
+	  end
+	  #print "context is now: #{context}\n"
+	  #exit
+	  #parserAction.shortcuts.each { |sc| sc.value = context[ shortcutNames.first ] }
+	  #context.reject! { |key,value| key != "result" }
+	end
+	#print "Contextttt: #{context.to_s}\n"
+      end
+      # only keep the shortcuts in the context for values that need to be passed on
+      #contextToKeep = Hash.new
+      #context.each_pair { |key,value| contextToKeep[ key ] = value if shortcutNames.include?( key ) or key == "result" }
+      #context = contextToKeep
+      #print "AFTER CLEANING CONTEXT .. IT IS NOW: #{context.to_s}\n"
+      currentState # state
+    end
+
+    def stepObject( parseObject )
+      #print "\n\n************************************************************\n"
+      #print "********************* StepObject *******************************\n"
+      self.recorder.recordState( currentState, parseObject )
+      currentState.parseObject( parseObject, self, self.context )
+      #print "********************* End StepObject ***************************\n"
+      #print "****************************************************************\n"
+    end
+
+  end
+
+end
+  

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

@@ -0,0 +1,42 @@
+module XI
+
+  require 'nist/xiacc/CCObjectAddon'
+  require 'nist/xiacc/CCAction'
+
+  class ParserAction
+
+    attr :action, true       # an CCAction
+    attr :grabContext, true  # boolean
+    attr :shortcuts, true     # which shortcut to assign object's value to
+
+    def initialize
+      self.action = nil
+      self.grabContext = false
+      self.shortcuts = Array.new
+    end
+
+    def handleState( object, parserState, parser ); self.error( "Error, handleState should have been defined in a subclass" ); end
+
+    def doContext( parseObject, context )
+      #print "context is nil" if context == nil
+      #print "in doAction... context is: "
+      #context.each_pair { |key,value| print "key: #{key} value: #{value}  " } 
+      #print "\n\n"
+      if self.grabContext
+	self.shortcuts.each do
+	  |shortcut| 
+	  #print "going to grab context for self.shortcut.name: #{shortcut.name}, setting it to: #{parseObject}\n"
+	  context[ shortcut.name ] = parseObject.value
+	end
+	#print "Yipeee setting a context: shortcut is: #{self.shortcut} and object.value: #{object} its type: #{object.class.to_s}\n"
+      end      
+    end
+
+    def printOn( stream )
+      stream << "< a " << self.class.to_s << "  action: <" << action.to_s << "> grabContext: <" << grabContext << "> shortcuts: " << shortcuts.join( " and " ) << ". id: <#{self.id.to_s}> >"
+    end
+
+    def to_s; printOn( StringIO.new ).string; end
+
+  end
+end

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

@@ -0,0 +1,19 @@
+module XI
+
+  require 'nist/xiacc/ParserAction'
+
+  # Tells the parser to accept the input.
+  class ParserActionAccept < ParserAction
+
+    # Handle the current state
+    def handleState( object, parserState, parser, context )
+      #print "ParserActionAccept#handleState\n"
+      #exit
+      #print "Accepting .. object: #{anObject.to_s} state: #{aParserState.to_s}\n"
+      #parser.pushState( acceptState, nil )
+      doContext( object, context )
+      parser.accept
+    end
+
+  end
+end

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

@@ -0,0 +1,18 @@
+module XI
+
+  require 'nist/xiacc/ParserAction'
+
+  class ParserActionPreAccept < ParserAction
+
+    # This class just exists to be able to handle actions before the end
+
+    attr :acceptState, true
+
+    def handleState( object, parserState, parser, context )
+      parser.pushState( @acceptState, object )
+      doContext( object, context )
+    end
+
+  end
+
+end

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

@@ -0,0 +1,40 @@
+module XI
+
+  require 'stringio'
+  require 'nist/xiacc/ParserAction'
+
+  class ParserActionReduce < ParserAction
+    
+    attr :production, true
+
+    def initialize
+      super
+    end
+
+    def ParserActionReduce.production( aProduction )
+      par = ParserActionReduce.new
+      par.production = aProduction
+      par
+    end
+
+    def handleState( parseObject, parserState, parser, context )
+      #print "****reducing production... production is: #{@production} context is: #{context.to_s} object is: #{parseObject.to_s} parser's objects: #{parser.objects.join( "  and  " )} *****\n"
+      #context = Hash.new # nil # .each_pair { |key,value| context[ key ] = nil }
+      #print "************* context now ******** #{context.to_s}***\n"
+      #context = context.reject { |key,value| key != "result" }
+      #print "Doing an action: #{self.to_s}\n"
+      parser.reduceProduction( @production, parseObject, parserState, context )
+      doContext( parseObject, context )
+      #context.each_pair { |key,value| context[ key ] = nil }
+      #context = Hash.new
+      #print "************* context22  now ******** #{context.to_s}**\n"
+    end
+    
+    def printOn( stream )
+      super
+      stream << "  production: " << @production.to_s
+    end
+
+  end
+
+end

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

@@ -0,0 +1,42 @@
+module XI
+
+  require 'stringio'
+  require 'nist/xiacc/ParserAction'
+
+  # Tells the parser to shift the current state
+  class ParserActionShift < ParserAction
+
+    attr :nextState, true
+
+    def initialize
+      super
+    end
+
+    # Basic initialization
+    def ParserActionShift.nextState( aParserState )
+      pas = ParserActionShift.new
+      pas.nextState = aParserState
+      pas
+    end
+
+    # Handle the current state
+    def handleState( object, parserState, parser, context )
+      parser.pushState( self.nextState, object ) if object.class == EndMarker or object.class == Epsilon 
+      parser.pushState( self.nextState, nil ) if object.class != EndMarker and object.class != Epsilon
+      #print "Doing an action: #{self.to_s}\n"
+      #print "parser_action_shift pushed nextState: #{nextState.to_s}\n"
+      # here the next state hasn't been processed yet.. but
+      # we don't want to loose object .. so put it into context
+      doContext( object, context )
+    end
+
+    # Print on a stream
+    def printOn( stream )
+      super
+      #print "nextstate class: #{self.nextState.class.to_s}\n"
+      #self.nextState.each { |state| print state.to_s + " " }
+      #stream << "\n\t nextState: <<" << nextState.to_s << ">> and it's id: <<#{self.nextState.id}>>\n "
+    end
+
+  end
+end