antlr4 0.9.2

data/lib/antlr4/Recognizer.rb

@@ -0,0 +1,162 @@
+
+class Recognizer
+
+    attr_accessor :listeners, :interp #, :stateNumber
+    attr_accessor :tokenTypeMapCache, :ruleIndexMapCache 
+    attr_accessor :state
+    def initialize
+        @listeners = [ ConsoleErrorListener.INSTANCE ]
+        @interp = nil
+        @state       = -1
+        @tokenTypeMapCache = Hash.new
+        @ruleIndexMapCache = Hash.new
+    end
+
+    def getState
+      @state
+    end
+    def extractVersion(version)
+        pos = version.index(".")
+        major = version[0..pos-1]
+        version = version[pos+1..version.length]
+        pos = version.index(".")
+        if pos.nil?
+            pos = version.index("-")
+        end
+        if pos.nil?
+            pos = version.length
+        end
+        minor = version[0..pos-1]
+        return major, minor
+    end
+
+    def checkVersion(toolVersion)
+        runtimeVersion = "4.4.1"
+        rvmajor, rvminor = self.extractVersion(runtimeVersion)
+        tvmajor, tvminor = self.extractVersion(toolVersion)
+        if rvmajor!=tvmajor or rvminor!=tvminor
+            puts "ANTLR runtime and generated code versions disagree: #{runtimeVersion}!=#{toolVersion}"
+        end
+    end
+
+    def addErrorListener(listener)
+        self.listeners.push(listener)
+    end
+    def getTokenTypeMap
+        tokenNames = self.getTokenNames()
+        if tokenNames.nil? then
+            raise UnsupportedOperationException.new("The current recognizer does not provide a list of token names.")
+        end
+        result = self.tokenTypeMapCache.get(tokenNames)
+        if result.nil? 
+            result = tokenNames.zip(0..tokenNames.length) 
+            result["EOF"] = Token::EOF
+            self.tokenTypeMapCache[tokenNames] = result
+        end
+        return result
+    end
+    # Get a map from rule names to rule indexes.
+    #
+    # <p>Used for XPath and tree pattern compilation.</p>
+    #
+    def getRuleIndexMap
+        ruleNames = self.ruleNames
+        if ruleNames.nil? then
+            raise UnsupportedOperationException.new("The current recognizer does not provide a list of rule names.")
+        end
+        result = self.ruleIndexMapCache.get(ruleNames)
+        if result.nil? 
+            result = ruleNames.zip( 0..ruleNames.length)
+            self.ruleIndexMapCache[ruleNames] = result
+        end
+        return result
+    end
+
+    def getTokenType(tokenName)
+        ttype = self.getTokenTypeMap().get(tokenName)
+        if not ttype.nil? then
+            return ttype
+        else
+            return Token::INVALID_TYPE
+        end
+    end
+
+    # What is the error header, normally line/character position information?#
+    def getErrorHeader(e) # :RecognitionException):
+        line = e.getOffendingToken().line
+        column = e.getOffendingToken().column
+        return "line #{line}:#{column}"
+    end
+
+
+    # How should a token be displayed in an error message? The default
+    #  is to display just the text, but during development you might
+    #  want to have a lot of information spit out.  Override in that case
+    #  to use t.toString() (which, for CommonToken, dumps everything about
+    #  the token). This is better than forcing you to override a method in
+    #  your token objects because you don't have to go modify your lexer
+    #  so that it creates a new Java type.
+    #
+    # @deprecated This method is not called by the ANTLR 4 Runtime. Specific
+    # implementations of {@link ANTLRErrorStrategy} may provide a similar
+    # feature when necessary. For example, see
+    # {@link DefaultErrorStrategy#getTokenErrorDisplay}.
+    #
+    def getTokenErrorDisplay(t)
+        return "<no token>" if t.nil? 
+        s = t.text
+        if s.nil? 
+            if t.type==Token::EOF
+                s = "<EOF>"
+            else
+                s = "<" + str(t.type) + ">"
+            end
+        end
+        s = s.gsub("\n","\\n")
+        s = s.gsub("\r","\\r")
+        s = s.gsub("\t","\\t")
+        return "'" + s + "'"
+    end
+
+    def getErrorListenerDispatch
+        return ProxyErrorListener.new(self.listeners)
+    end
+
+    # subclass needs to override these if there are sempreds or actions
+    # that the ATN interp needs to execute
+    def sempred(localctx, ruleIndex, actionIndex)
+        return true
+    end
+
+    def precpred(localctx, precedence)
+        return true
+    end
+
+#    def state
+#        @stateNumber
+#    end
+
+    # Indicate that the recognizer has changed internal state that is
+    #  consistent with the ATN state passed in.  This way we always know
+    #  where we are in the ATN as the parser goes along. The rule
+    #  context objects form a stack that lets us see the stack of
+    #  invoking rules. Combine this and we have complete ATN
+    #  configuration information.
+
+#    def state=(atnState)
+#        @stateNumber = atnState
+#    end
+end
+
+#import unittest
+#class Test(unittest.TestCase):
+#    def testVersion(self):
+#        major, minor = Recognizer().extractVersion("1.2")
+#        self.assertEqual("1", major)
+#        self.assertEqual("2", minor)
+#        major, minor = Recognizer().extractVersion("1.2.3")
+#        self.assertEqual("1", major)
+#        self.assertEqual("2", minor)
+#        major, minor = Recognizer().extractVersion("1.2-snapshot")
+#        self.assertEqual("1", major)
+#        self.assertEqual("2", minor)

data/lib/antlr4/RuleContext.rb

@@ -0,0 +1,226 @@
+#  A rule context is a record of a single rule invocation. It knows
+#  which context invoked it, if any. If there is no parent context, then
+#  naturally the invoking state is not valid.  The parent link
+#  provides a chain upwards from the current rule invocation to the root
+#  of the invocation tree, forming a stack. We actually carry no
+#  information about the rule associated with this context (except
+#  when parsing). We keep only the state number of the invoking state from
+#  the ATN submachine that invoked this. Contrast this with the s
+#  pointer inside ParserRuleContext that tracks the current state
+#  being "executed" for the current rule.
+#
+#  The parent contexts are useful for computing lookahead sets and
+#  getting error information.
+#
+#  These objects are used during parsing and prediction.
+#  For the special case of parsers, we use the subclass
+#  ParserRuleContext.
+#
+#  @see ParserRuleContext
+
+class RuleContext < RuleNode
+
+    @@EMPTY = nil
+    def self.EMPTY
+      if @@EMPTY.nil? then
+        @@EMPTY = ParserRuleContext.new()
+      end
+      @@EMPTY
+    end
+
+    attr_accessor :parentCtx, :invokingState 
+    def initialize(parent=nil, invoking_state=-1)
+        super()
+        # What context invoked this rule?
+        @parentCtx = parent
+        # What state invoked the rule associated with this context?
+        #  The "return address" is the followState of invokingState
+        #  If parent is null, this should be -1.
+        @invokingState = invoking_state
+    end
+
+    def depth
+        n = 0
+        p = self
+        while not p.nil? do 
+            p = p.parentCtx
+            n = n + 1
+        end
+        return n
+    end
+
+    # A context is empty if there is no invoking state; meaning nobody call
+    #  current context.
+    def isEmpty
+        return self.invokingState == -1
+    end
+
+    # satisfy the ParseTree / SyntaxTree interface
+
+    def getSourceInterval
+        return Antlr4::INVALID_INTERVAL
+    end
+
+    def getRuleContext
+        return self
+    end
+
+    def getPayload
+        return self
+    end
+
+   # Return the combined text of all child nodes. This method only considers
+    #  tokens which have been added to the parse tree.
+    #  <p>
+    #  Since tokens on hidden channels (e.g. whitespace or comments) are not
+    #  added to the parse trees, they will not appear in the output of this
+    #  method.
+    #/
+    def getText
+        if self.getChildCount() == 0
+            return ""
+        end
+        StringIO.open  do |builder|
+            self.getChildren().each {|child| builder.write(child.getText()) }
+            return builder.string()
+        end
+    end
+
+    def getRuleIndex
+        return -1
+    end
+
+    def getChild(i)
+        return nil
+    end
+
+    def getChildCount
+        return 0
+    end
+
+    def getChildren
+       Array.new #  [].map {|c| c } 
+    end
+    def accept(visitor)
+        return visitor.visitChildren(self)
+    end
+
+   # # Call this method to view a parse tree in a dialog box visually.#/
+   #  public Future<JDialog> inspect(@Nullable Parser parser) {
+   #      List<String> ruleNames = parser != null ? Arrays.asList(parser.getRuleNames()) : null;
+   #      return inspect(ruleNames);
+   #  }
+   #
+   #  public Future<JDialog> inspect(@Nullable List<String> ruleNames) {
+   #      TreeViewer viewer = new TreeViewer(ruleNames, this);
+   #      return viewer.open();
+   #  }
+   #
+   # # Save this tree in a postscript file#/
+   #  public void save(@Nullable Parser parser, String fileName)
+   #      throws IOException, PrintException
+   #  {
+   #      List<String> ruleNames = parser != null ? Arrays.asList(parser.getRuleNames()) : null;
+   #      save(ruleNames, fileName);
+   #  }
+   #
+   # # Save this tree in a postscript file using a particular font name and size#/
+   #  public void save(@Nullable Parser parser, String fileName,
+   #                   String fontName, int fontSize)
+   #      throws IOException
+   #  {
+   #      List<String> ruleNames = parser != null ? Arrays.asList(parser.getRuleNames()) : null;
+   #      save(ruleNames, fileName, fontName, fontSize);
+   #  }
+   #
+   # # Save this tree in a postscript file#/
+   #  public void save(@Nullable List<String> ruleNames, String fileName)
+   #      throws IOException, PrintException
+   #  {
+   #      Trees.writePS(this, ruleNames, fileName);
+   #  }
+   #
+   # # Save this tree in a postscript file using a particular font name and size#/
+   #  public void save(@Nullable List<String> ruleNames, String fileName,
+   #                   String fontName, int fontSize)
+   #      throws IOException
+   #  {
+   #      Trees.writePS(this, ruleNames, fileName, fontName, fontSize);
+   #  }
+   #
+   # # Print out a whole tree, not just a node, in LISP format
+   #  #  (root child1 .. childN). Print just a node if this is a leaf.
+   #  #  We have to know the recognizer so we can get rule names.
+   #  #/
+   #  @Override
+   #  public String toStringTree(@Nullable Parser recog) {
+   #      return Trees.toStringTree(this, recog);
+   #  }
+   #
+   # Print out a whole tree, not just a node, in LISP format
+   #  (root child1 .. childN). Print just a node if this is a leaf.
+   #
+    def toStringTree(ruleNames=nil ,recog=nil)
+        return Trees.toStringTree(self, ruleNames, recog)
+    end
+   #  }
+   #
+   #  @Override
+   #  public String toStringTree() {
+   #      return toStringTree((List<String>)null);
+   #  }
+   #
+    def to_s 
+        return self.toString(nil, nil)
+    end
+
+   #  @Override
+   #  public String toString() {
+   #      return toString((List<String>)null, (RuleContext)null);
+   #  }
+   #
+   #  public final String toString(@Nullable Recognizer<?,?> recog) {
+   #      return toString(recog, ParserRuleContext.EMPTY);
+   #  }
+   #
+   #  public final String toString(@Nullable List<String> ruleNames) {
+   #      return toString(ruleNames, null);
+   #  }
+   #
+   #  // recog null unless ParserRuleContext, in which case we use subclass toString(...)
+   #  public String toString(@Nullable Recognizer<?,?> recog, @Nullable RuleContext stop) {
+   #      String[] ruleNames = recog != null ? recog.getRuleNames() : null;
+   #      List<String> ruleNamesList = ruleNames != null ? Arrays.asList(ruleNames) : null;
+   #      return toString(ruleNamesList, stop);
+   #  }
+
+    def toString(ruleNames, stop) #->str#ruleNames:list, stop:RuleContext)->str:
+        StringIO.open  do |buf|
+            p = self
+            buf.write("[")
+            while (not p.nil?) and p != stop do
+                if ruleNames.nil? then
+                    if not p.isEmpty()
+                        buf.write(p.invokingState.to_s)
+                    end
+                else
+                    ri = p.getRuleIndex()
+                    if ri >= 0 and ri < ruleNames.length
+                        ruleName = ruleNames[ri] 
+                    else 
+                        ruleName = ri.to_s
+                    end
+                    # ruleName = ruleNames[ri] if ri >= 0 and ri < len(ruleNames) else str(ri)
+                    buf.write(ruleName)
+                end
+                if p.parentCtx and (ruleNames or not p.parentCtx.isEmpty()) then
+                    buf.write(" ")
+                end
+                p = p.parentCtx
+            end
+            buf.write("]")
+            return buf.string()
+        end
+    end
+end
+

data/lib/antlr4/Token.rb

@@ -0,0 +1,124 @@
+# A token has properties: text, type, line, character position in the line
+# (so we can ignore tabs), token channel, index, and source from which
+# we obtained this token.
+
+class Token
+
+    INVALID_TYPE = 0
+    # During lookahead operations, this "token" signifies we hit rule end ATN state
+    # and did not follow it despite needing to.
+    EPSILON = -2
+    MIN_USER_TOKEN_TYPE = 1
+    EOF = -1
+    # All tokens go to the parser (unless skip() is called in that rule)
+    # on a particular "channel".  The parser tunes to a particular channel
+    # so that whitespace etc... can go to the parser on a "hidden" channel.
+    DEFAULT_CHANNEL = 0
+    # Anything on different channel than DEFAULT_CHANNEL is not parsed
+    # by parser.
+    HIDDEN_CHANNEL = 1
+
+    attr_accessor :source, :type, :channel, :start, :stop, :tokenIndex
+    attr_accessor :line, :column , :text
+# A token has properties: text, type, line, character position in the line
+# (so we can ignore tabs), token channel, index, and source from which
+# we obtained this token.
+    def initialize()
+        self.source = nil
+        self.type = nil       # token type of the token
+        self.channel = nil    # The parser ignores everything not on DEFAULT_CHANNEL
+        self.start = -1       # optional; return -1 if not implemented.
+        self.stop = -1        # optional; return -1 if not implemented.
+        self.tokenIndex = nil # from 0..n-1 of the token object in the input stream
+        self.line = nil       # line=1..n of the 1st character
+        self.column = nil     # beginning of the line at which it occurs, 0..n-1
+    end
+    # Explicitly set the text for this token. If {code text} is not
+    # {@code null}, then {@link #getText} will return this value rather than
+    # extracting the text from the input.
+    #
+    # @param text The explicit text of the token, or {@code null} if the text
+    # should be obtained from the input along with the start and stop indexes
+    # of the token.
+
+    def getTokenSource()
+        return self.source[0]
+    end
+
+    def getInputStream()
+        return self.source[1]
+    end
+end
+
+class CommonToken < Token
+    # An empty {@link Pair} which is used as the default value of
+    # {@link #source} for tokens that do not have a source.
+    EMPTY_SOURCE = [nil, nil]
+
+    def initialize(source = EMPTY_SOURCE, type = nil, channel=Token::DEFAULT_CHANNEL, start=-1, stop=-1)
+        super()
+        self.source = source
+        self.type = type
+        self.channel = channel
+        self.start = start
+        self.stop = stop
+        self.tokenIndex = -1
+        if source[0] then
+            self.line = source[0].line
+            self.column = source[0].column
+        else
+            self.column = -1
+            self.line = nil
+        end
+    end
+    # Constructs a new {@link CommonToken} as a copy of another {@link Token}.
+    #
+    # <p>
+    # If {@code oldToken} is also a {@link CommonToken} instance, the newly
+    # constructed token will share a reference to the {@link #text} field and
+    # the {@link Pair} stored in {@link #source}. Otherwise, {@link #text} will
+    # be assigned the result of calling {@link #getText}, and {@link #source}
+    # will be constructed from the result of {@link Token#getTokenSource} and
+    # {@link Token#getInputStream}.</p>
+    #
+    # @param oldToken The token to copy.
+     #
+    def clone()
+#        t = CommonToken(self.source, self.type, self.channel, self.start, self.stop)
+#        t.tokenIndex = self.tokenIndex
+#        t.line = self.line
+#        t.column = self.column
+#        t.text = self.text
+#        return t
+      raise NotImplementedError.new("Token.clone not implemented")
+    end
+    def text()
+        return @text if @text
+        input = self.getInputStream()
+        return nil if input.nil? 
+        n = input.size
+        if self.start < n and self.stop < n then
+            return input.getText(self.start, self.stop)
+        else
+            return '<EOF>'
+        end
+    end
+
+    def to_s
+      txt = self.text()
+      if txt.nil? then
+        txt = "<no text>"
+      else 
+        txt = txt.gsub("\n","\\n").gsub("\r","\\r").gsub("\t","\\t")
+      end
+      if self.channel > 0 then
+        c = ",channel=#{channel}"
+      else
+        c = ""
+      end
+      "[@#{tokenIndex},#{start}:#{stop}='#{txt}',<#{type}>#{c},#{line}:#{column}]"
+    end
+    def inspect
+      to_s
+    end
+end