libfalcon-engine1 0.9.6.9-git20120606-2 / usr / lib / falcon / parser / genparser / rules.fal

/*
   FALCON - Generic Parser

   FILE: Rules.fal

   Generic customizable grammar parser.
   -------------------------------------------------------------------
   Author: Giancarlo Niccolai
   Begin: Tue, 17 Aug 2010 15:49:48 +0200

   -------------------------------------------------------------------
   (C) Copyright 2010: the FALCON developers (see list in AUTHORS file)

   See LICENSE file for licensing details.
*/

import Regex from regex 

/*# Base rule.

   An abstract class.
*/
class Rule( nextState, action )
   nextState = nextState
   action = action
   matchLen = 0
   lookAhead = false
   
   function match( text, pos )
      return -1
   end

   function apply( context )
      if self.action: self.action(context)
      return self.matchLen
   end
end

/*#
   @brief Class representing a token rule.

   Token rules are simply fixed length rules
   matching the input text.

   @param token the string matching a fixed token
   @param action the action (function) that should be done when
          hitting the token. The function will be called with
          the token as last parameter.
*/
class TokenRule( token, nextState, action ) from Rule( nextState, action )
   token = token
   separators = " \r\n\t,.!?;:*+-/|^'\"\\#<>()[]"
   
   function match( text, pos )
      t = self.token
      if (pfind = text.find( t, pos ) ) >= 0
         if (pfind == 0 or self.isSep( text[(pfind-1)] )) and \
                  (pfind + t.len() == text.len() or self.isSep( text[(pfind + t.len())] ))
            return pfind
         end
      end
      
      return -1
   end

   function apply( ctx )
      if self.action: self.action( ctx, self.token )
      self.matchLen = self.lookAhead ? 0 : self.token.len()
      return self.matchLen
   end

   function isSep( item )
      return item in self.separators
   end

end


/*#
   Class representing a language token, with look ahead.
*/
class TokenRuleLA( token, nextState, action ) from TokenRule( token, nextState, action )
   lookAhead = true   
end

/*#
   @brief Class representing a tag rule.

   Token rules are simply fixed length rules
   matching the input text.

   @param token the string matching a fixed token
   @param action the action (function) that should be done when
          hitting the token. The function will be called with
          the token as last parameter.
*/
class TagRule( tag, nextState, action ) from Rule( nextState, action )
   token = tag

   function match( text, pos )
      t = self.token
      if (pfind = text.find( t, pos ) ) >= 0
         return pfind
      end

      return -1
   end

   function apply( ctx )
      if self.action: self.action( ctx, self.token )
      self.matchLen = self.token.len()
      return self.matchLen
   end

end


/*#
   @brief Eats blanks
*/
class BlanksRule() from Rule( "#stay" )
   matchLen = 0

   function match( text, pos )
      ipos = pos
      l = text.len()
      while pos < l
         c = text[*pos]
         if (c != 0x20 and c != 0x8 and c != 0x0D and c != 0x0A)
            self.matchLen = pos - ipos
            if self.matchLen > 0: return ipos
         end
         ++pos
      end
      
      return -1
   end

end

/*#
   @brief Regular expression enabled ruler matcher.
   @param token the string matching a fixed token
   @param action the action (function) that should be done when
          hitting the token.

   The function will be called with the token as last parameter.
*/
class ReRule( re, nextState, action ) from Rule( nextState, action )
   anchored = re.startsWith("^")
   token = re
   re = regex.Regex(re)
   grabs = nil
   eol = false
   
   function match( text, pos )
      // can't match "^" past the begin of the line
      if self.anchored and pos > 0: return -1
      re = self.re
      // We need our grabs
      if (rng = re.find( text, pos ))
         g = []
         n = 0
         recapcount = re.capturedCount()
         while n < recapcount
            g += text[re.captured(n)]
            ++n
         end
         self.grabs = g
         return rng[0]
      end

      return -1
   end

   function apply( context )
      g = self.grabs
      if self.action: (.[ self.action context ] + g)()
      self.matchLen = g[0].len()
      // allows eating EOL
      if self.eol: return self.matchLen + 1
      return self.matchLen
   end
end

/*#
   @brief Regular expression enabled ruler matcher -- consuming end of line.
   @param token the string matching a fixed token
   @param action the action (function) that should be done when
          hitting the token.

   The function will be called with the token as last parameter.
*/
class ReRuleEOL( re, nextState, action ) from ReRule( re, nextState, action )
   eol = true
end

/*#
   @brief Regular expression matcher with look ahead
   @param token the string matching a fixed token
   @param action the action (function) that should be done when
          hitting the token.

   The function will be called with the token as last parameter.

   This rule won't indicate how many characters have been matched,
   causing an application of the rule and a state change but not
   discarding the matched characters.
*/
class ReRuleLA( re, nextState, action ) from ReRule( re, nextState, action )
   lookAhead = true
   
   function apply( context )
      g = self.grabs
      if self.action: (.[ self.action context ] + g)()
      return 0
   end
end


/*#
   @brief Empty line rule matcher.

*/
class EmptyLineRule( nextState, action ) from Rule( nextState, action )
   matchLen = 0
   
   function match( text, pos )
      if text.len() == 0: return 0
      return -1
   end
end

/*#
   @brief Matches a single character.

*/
class CharRule( nextState, action ) from Rule( nextState, action )
   grabbedChar = " "
   matchLen = 1

   function match( text, pos )
      if text.len() > pos
         self.grabbedChar = text[pos]
         return pos
      end
      return -1
   end

   function apply( ctx )
      if self.action: self.action( ctx, self.grabbedChar )
      return 1
   end
end

/*# Empty rule meant to immediately do an action and change state without consuming input. */
class DummyRule( nextState, action ) from Rule( nextState, action )
   function match( text, pos )
      return pos
   end
end

/*# Rule matching the end of line */
class EOLRule( nextState, action ) from Rule( nextState, action )
   function match( text, pos )
      return text.len()
   end
end

/*# Rule matching the end of line, with look ahead.
   This prevents exiting from the loop checking this line when EOLRuleLA is matched
*/
class EOLRuleLA( nextState, action ) from EOLRule( nextState, action )
   lookAhead = true
end

/*#
   Rule combining one or more sub-rules.
   @param rules An array of rules that may be matched.
   @param nextState The state where to go if a sub-rule is matched.
   @param actionPre An action to run as action(context, winningRule) @b before winning rule action is performed.
   @param actionPost An action to run as action(context, winningRule) @b after winning rule action is performed.

   If @b nextState is nil, then the winning rule state transition is applied, otherwise
   @b nextstate overrides winning rule state setting.

   If @b nextState contains a "*" character, it is replaced with the state from the rule. So, you can have
   "#pop;*" to first pop the current state and then apply the state transition from the winner rule.
*/
class ProxyRule( rules, nextState, actionPre, actionPost) from Rule( nextState, actionPre )
   rules = rules
   actionPost = actionPost
   winningRule = nil
   hasState = nextState ? true : false
   incState = "*" in nextState
   origState = nextState

   
   function match( text, pos )
      self.winningRule = nil
      n = 0
      l = self.rules.len()
      res = -1
      matchPos = text.len()
      while n < l
         res = self.rules[n].match( text, pos )
         if res == 0
            // we have the winner
            self.winningRule = self.rules[n]
            return res
         elif res > -1 and res < matchPos
            matchPos = res
            self.winningRule = self.rules
         end
         ++n
      end

      return res
   end


   function apply( ctx )
      if self.winningRule
         if self.action: self.action( ctx, self.winningRule )
         retval = self.winningRule.apply(ctx)
         if self.actionPost: self.actionPost( ctx, self.winningRule )

         if self.hasState
            if self.incState
               self.nextState = self.origState.replace( "*", self.winningRule.nextState )
            end
            // else, let the state it has.
         else
            self.nextState = self.winningRule.nextState
         end
         
         self.matchLen = retval
         return retval
      end

      self.matchLen = 0
      return 0
   end
end