aa", "DistinguishBetweenInsertAfterAndInsertBeforeToPreserverOrder",
+ func(r *TokenStreamRewriter){
+ r.InsertBeforeDefault(0, "")
+ r.InsertAfterDefault(0, "")
+ r.InsertBeforeDefault(1, "")
+ r.InsertAfterDefault(1,"")
+ }),
+ NewLexerTest("aa", "a
a", "DistinguishBetweenInsertAfterAndInsertBeforeToPreserverOrder2",
+ func(r *TokenStreamRewriter){
+ r.InsertBeforeDefault(0, "")
+ r.InsertBeforeDefault(0, "")
+ r.InsertAfterDefault(0, "
")
+ r.InsertAfterDefault(0, "")
+ r.InsertBeforeDefault(1, "")
+ r.InsertAfterDefault(1,"")
+ }),
+ NewLexerTest("ab", "!b", "DistinguishBetweenInsertAfterAndInsertBeforeToPreserverOrder2",
+ func(r *TokenStreamRewriter){
+ r.InsertBeforeDefault(0, "")
+ r.InsertBeforeDefault(0, "")
+ r.InsertBeforeDefault(0, "
")
+ r.InsertAfterDefault(0, "")
+ r.InsertAfterDefault(0, "")
+ r.InsertAfterDefault(0, "
")
+ r.InsertBeforeDefault(1, "!")
+ }),
+ }
+
+
+ for _,c := range tests{
+ t.Run(c.description,func(t *testing.T) {
+ rewriter := prepare_rewriter(c.input)
+ c.ops(rewriter)
+ if len(c.expected_exception)>0{
+ panic_tester(t, c.expected_exception, rewriter)
+ }else{
+ result := rewriter.GetTextDefault()
+ if result!=c.expected{
+ t.Errorf("Expected:%s | Result: %s", c.expected, result)
+ }
+ }
+ } )
+ }
+}
+
+
+// Suppress unused import error
+var _ = fmt.Printf
+var _ = unicode.IsLetter
+
+var serializedLexerAtn = []uint16{
+ 3, 24715, 42794, 33075, 47597, 16764, 15335, 30598, 22884, 2, 5, 15, 8,
+ 1, 4, 2, 9, 2, 4, 3, 9, 3, 4, 4, 9, 4, 3, 2, 3, 2, 3, 3, 3, 3, 3, 4, 3,
+ 4, 2, 2, 5, 3, 3, 5, 4, 7, 5, 3, 2, 2, 2, 14, 2, 3, 3, 2, 2, 2, 2, 5, 3,
+ 2, 2, 2, 2, 7, 3, 2, 2, 2, 3, 9, 3, 2, 2, 2, 5, 11, 3, 2, 2, 2, 7, 13,
+ 3, 2, 2, 2, 9, 10, 7, 99, 2, 2, 10, 4, 3, 2, 2, 2, 11, 12, 7, 100, 2, 2,
+ 12, 6, 3, 2, 2, 2, 13, 14, 7, 101, 2, 2, 14, 8, 3, 2, 2, 2, 3, 2, 2,
+}
+
+var lexerDeserializer = NewATNDeserializer(nil)
+var lexerAtn = lexerDeserializer.DeserializeFromUInt16(serializedLexerAtn)
+
+var lexerChannelNames = []string{
+ "DEFAULT_TOKEN_CHANNEL", "HIDDEN",
+}
+
+var lexerModeNames = []string{
+ "DEFAULT_MODE",
+}
+
+var lexerLiteralNames = []string{
+ "", "'a'", "'b'", "'c'",
+}
+
+var lexerSymbolicNames = []string{
+ "", "A", "B", "C",
+}
+
+var lexerRuleNames = []string{
+ "A", "B", "C",
+}
+
+type LexerA struct {
+ *BaseLexer
+ channelNames []string
+ modeNames []string
+ // TODO: EOF string
+}
+
+var lexerDecisionToDFA = make([]*DFA, len(lexerAtn.DecisionToState))
+
+func init() {
+ for index, ds := range lexerAtn.DecisionToState {
+ lexerDecisionToDFA[index] = NewDFA(ds, index)
+ }
+}
+
+func NewLexerA(input CharStream) *LexerA {
+
+ l := new(LexerA)
+
+ l.BaseLexer = NewBaseLexer(input)
+ l.Interpreter = NewLexerATNSimulator(l, lexerAtn, lexerDecisionToDFA, NewPredictionContextCache())
+
+ l.channelNames = lexerChannelNames
+ l.modeNames = lexerModeNames
+ l.RuleNames = lexerRuleNames
+ l.LiteralNames = lexerLiteralNames
+ l.SymbolicNames = lexerSymbolicNames
+ l.GrammarFileName = "LexerA.g4"
+ // TODO: l.EOF = antlr.TokenEOF
+
+ return l
+}
+
+// LexerA tokens.
+const (
+ LexerAA = 1
+ LexerAB = 2
+ LexerAC = 3
+)
+
diff --git a/runtime/Java/pom.xml b/runtime/Java/pom.xml
index c42015629..3eb60b2df 100644
--- a/runtime/Java/pom.xml
+++ b/runtime/Java/pom.xml
@@ -27,6 +27,7 @@
org.apache.maven.plugins
maven-source-plugin
+ 3.0.1
diff --git a/runtime/Java/src/org/antlr/v4/runtime/CodePointCharStream.java b/runtime/Java/src/org/antlr/v4/runtime/CodePointCharStream.java
index 491ef6918..107faa7b1 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/CodePointCharStream.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/CodePointCharStream.java
@@ -151,8 +151,8 @@ public abstract class CodePointCharStream implements CharStream {
/** Return the UTF-16 encoded string for the given interval */
@Override
public String getText(Interval interval) {
- int startIdx = Math.min(interval.a, size - 1);
- int len = Math.min(interval.b - interval.a + 1, size);
+ int startIdx = Math.min(interval.a, size);
+ int len = Math.min(interval.b - interval.a + 1, size - startIdx);
// We know the maximum code point in byteArray is U+00FF,
// so we can treat this as if it were ISO-8859-1, aka Latin-1,
diff --git a/runtime/Java/src/org/antlr/v4/runtime/DefaultErrorStrategy.java b/runtime/Java/src/org/antlr/v4/runtime/DefaultErrorStrategy.java
index 819538539..02b5ee510 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/DefaultErrorStrategy.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/DefaultErrorStrategy.java
@@ -36,6 +36,21 @@ public class DefaultErrorStrategy implements ANTLRErrorStrategy {
protected IntervalSet lastErrorStates;
+ /**
+ * This field is used to propagate information about the lookahead following
+ * the previous match. Since prediction prefers completing the current rule
+ * to error recovery efforts, error reporting may occur later than the
+ * original point where it was discoverable. The original context is used to
+ * compute the true expected sets as though the reporting occurred as early
+ * as possible.
+ */
+ protected ParserRuleContext nextTokensContext;
+
+ /**
+ * @see #nextTokensContext
+ */
+ protected int nextTokensState;
+
/**
* {@inheritDoc}
*
@@ -225,7 +240,20 @@ public class DefaultErrorStrategy implements ANTLRErrorStrategy {
// try cheaper subset first; might get lucky. seems to shave a wee bit off
IntervalSet nextTokens = recognizer.getATN().nextTokens(s);
- if (nextTokens.contains(Token.EPSILON) || nextTokens.contains(la)) {
+ if (nextTokens.contains(la)) {
+ // We are sure the token matches
+ nextTokensContext = null;
+ nextTokensState = ATNState.INVALID_STATE_NUMBER;
+ return;
+ }
+
+ if (nextTokens.contains(Token.EPSILON)) {
+ if (nextTokensContext == null) {
+ // It's possible the next token won't match; information tracked
+ // by sync is restricted for performance.
+ nextTokensContext = recognizer.getContext();
+ nextTokensState = recognizer.getState();
+ }
return;
}
@@ -450,7 +478,14 @@ public class DefaultErrorStrategy implements ANTLRErrorStrategy {
}
// even that didn't work; must throw the exception
- throw new InputMismatchException(recognizer);
+ InputMismatchException e;
+ if (nextTokensContext == null) {
+ e = new InputMismatchException(recognizer);
+ } else {
+ e = new InputMismatchException(recognizer, nextTokensState, nextTokensContext);
+ }
+
+ throw e;
}
/**
diff --git a/runtime/Java/src/org/antlr/v4/runtime/InputMismatchException.java b/runtime/Java/src/org/antlr/v4/runtime/InputMismatchException.java
index fc4261558..08ef67c58 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/InputMismatchException.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/InputMismatchException.java
@@ -13,4 +13,10 @@ public class InputMismatchException extends RecognitionException {
super(recognizer, recognizer.getInputStream(), recognizer._ctx);
this.setOffendingToken(recognizer.getCurrentToken());
}
+
+ public InputMismatchException(Parser recognizer, int state, ParserRuleContext ctx) {
+ super(recognizer, recognizer.getInputStream(), ctx);
+ this.setOffendingState(state);
+ this.setOffendingToken(recognizer.getCurrentToken());
+ }
}
diff --git a/runtime/Java/src/org/antlr/v4/runtime/atn/ParserATNSimulator.java b/runtime/Java/src/org/antlr/v4/runtime/atn/ParserATNSimulator.java
index 46840ab7c..76524ebd8 100755
--- a/runtime/Java/src/org/antlr/v4/runtime/atn/ParserATNSimulator.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/atn/ParserATNSimulator.java
@@ -270,7 +270,7 @@ public class ParserATNSimulator extends ATNSimulator {
public static final boolean retry_debug = false;
/** Just in case this optimization is bad, add an ENV variable to turn it off */
- public static final boolean TURN_OFF_LR_LOOP_ENTRY_BRANCH_OPT = Boolean.parseBoolean(System.getenv("TURN_OFF_LR_LOOP_ENTRY_BRANCH_OPT"));
+ public static final boolean TURN_OFF_LR_LOOP_ENTRY_BRANCH_OPT = Boolean.parseBoolean(getSafeEnv("TURN_OFF_LR_LOOP_ENTRY_BRANCH_OPT"));
protected final Parser parser;
@@ -1541,11 +1541,6 @@ public class ParserATNSimulator extends ATNSimulator {
ATNConfig c = getEpsilonTarget(config, t, continueCollecting,
depth == 0, fullCtx, treatEofAsEpsilon);
if ( c!=null ) {
- if (!t.isEpsilon() && !closureBusy.add(c)) {
- // avoid infinite recursion for EOF* and EOF+
- continue;
- }
-
int newDepth = depth;
if ( config.state instanceof RuleStopState) {
assert !fullCtx;
@@ -1555,11 +1550,6 @@ public class ParserATNSimulator extends ATNSimulator {
// come in handy and we avoid evaluating context dependent
// preds if this is > 0.
- if (!closureBusy.add(c)) {
- // avoid infinite recursion for right-recursive rules
- continue;
- }
-
if (_dfa != null && _dfa.isPrecedenceDfa()) {
int outermostPrecedenceReturn = ((EpsilonTransition)t).outermostPrecedenceReturn();
if (outermostPrecedenceReturn == _dfa.atnStartState.ruleIndex) {
@@ -1568,15 +1558,28 @@ public class ParserATNSimulator extends ATNSimulator {
}
c.reachesIntoOuterContext++;
+
+ if (!closureBusy.add(c)) {
+ // avoid infinite recursion for right-recursive rules
+ continue;
+ }
+
configs.dipsIntoOuterContext = true; // TODO: can remove? only care when we add to set per middle of this method
assert newDepth > Integer.MIN_VALUE;
newDepth--;
if ( debug ) System.out.println("dips into outer ctx: "+c);
}
- else if (t instanceof RuleTransition) {
- // latch when newDepth goes negative - once we step out of the entry context we can't return
- if (newDepth >= 0) {
- newDepth++;
+ else {
+ if (!t.isEpsilon() && !closureBusy.add(c)) {
+ // avoid infinite recursion for EOF* and EOF+
+ continue;
+ }
+
+ if (t instanceof RuleTransition) {
+ // latch when newDepth goes negative - once we step out of the entry context we can't return
+ if (newDepth >= 0) {
+ newDepth++;
+ }
}
}
@@ -2178,4 +2181,14 @@ public class ParserATNSimulator extends ATNSimulator {
public Parser getParser() {
return parser;
}
+
+ public static String getSafeEnv(String envName) {
+ try {
+ return System.getenv(envName);
+ }
+ catch(SecurityException e) {
+ // use the default value
+ }
+ return null;
+ }
}
diff --git a/runtime/JavaScript/src/antlr4/Utils.js b/runtime/JavaScript/src/antlr4/Utils.js
index d7627be60..2cb939a66 100644
--- a/runtime/JavaScript/src/antlr4/Utils.js
+++ b/runtime/JavaScript/src/antlr4/Utils.js
@@ -401,11 +401,11 @@ DoubleDict.prototype.set = function (a, b, o) {
function escapeWhitespace(s, escapeSpaces) {
- s = s.replace("\t", "\\t");
- s = s.replace("\n", "\\n");
- s = s.replace("\r", "\\r");
+ s = s.replace(/\t/g, "\\t")
+ .replace(/\n/g, "\\n")
+ .replace(/\r/g, "\\r");
if (escapeSpaces) {
- s = s.replace(" ", "\u00B7");
+ s = s.replace(/ /g, "\u00B7");
}
return s;
}
@@ -443,4 +443,4 @@ exports.hashStuff = hashStuff;
exports.escapeWhitespace = escapeWhitespace;
exports.arrayToString = arrayToString;
exports.titleCase = titleCase;
-exports.equalArrays = equalArrays;
\ No newline at end of file
+exports.equalArrays = equalArrays;
diff --git a/runtime/Python2/src/antlr4/Parser.py b/runtime/Python2/src/antlr4/Parser.py
index d88f77918..69abe739b 100644
--- a/runtime/Python2/src/antlr4/Parser.py
+++ b/runtime/Python2/src/antlr4/Parser.py
@@ -218,6 +218,13 @@ class Parser (Recognizer):
self._ctx.exitRule(listener)
listener.exitEveryRule(self._ctx)
+ # Gets the number of syntax errors reported during parsing. This value is
+ # incremented each time {@link #notifyErrorListeners} is called.
+ #
+ # @see #notifyErrorListeners
+ #
+ def getNumberOfSyntaxErrors(self):
+ return self._syntaxErrors
def getTokenFactory(self):
return self._input.tokenSource._factory
diff --git a/runtime/Python2/src/antlr4/tree/RuleTagToken.py b/runtime/Python2/src/antlr4/tree/RuleTagToken.py
index 2043c1625..d63a3a53b 100644
--- a/runtime/Python2/src/antlr4/tree/RuleTagToken.py
+++ b/runtime/Python2/src/antlr4/tree/RuleTagToken.py
@@ -36,14 +36,13 @@ class RuleTagToken(Token):
self.tokenIndex = -1 # from 0..n-1 of the token object in the input stream
self.line = 0 # line=1..n of the 1st character
self.column = -1 # beginning of the line at which it occurs, 0..n-1
- self.label = label
+ self.label = unicode(label)
self._text = self.getText() # text of the token.
-
- self.ruleName = ruleName
+ self.ruleName = unicode(ruleName)
def getText(self):
if self.label is None:
- return "<" + self.ruleName + ">"
+ return u"<" + self.ruleName + u">"
else:
- return "<" + self.label + ":" + self.ruleName + ">"
+ return u"<" + self.label + ":" + self.ruleName + u">"
diff --git a/runtime/Python2/src/antlr4/tree/TokenTagToken.py b/runtime/Python2/src/antlr4/tree/TokenTagToken.py
index 2ffc79f6f..dba41f785 100644
--- a/runtime/Python2/src/antlr4/tree/TokenTagToken.py
+++ b/runtime/Python2/src/antlr4/tree/TokenTagToken.py
@@ -24,8 +24,8 @@ class TokenTagToken(CommonToken):
#
def __init__(self, tokenName, type, label=None):
super(TokenTagToken, self).__init__(type=type)
- self.tokenName = tokenName
- self.label = label
+ self.tokenName = unicode(tokenName)
+ self.label = unicode(label)
self._text = self.getText()
#
@@ -36,9 +36,9 @@ class TokenTagToken(CommonToken):
#
def getText(self):
if self.label is None:
- return "<" + self.tokenName + ">"
+ return u"<" + self.tokenName + u">"
else:
- return "<" + self.label + ":" + self.tokenName + ">"
+ return u"<" + self.label + u":" + self.tokenName + u">"
# The implementation for {@link TokenTagToken} returns a string of the form
# {@code tokenName:type}.
diff --git a/runtime/Python2/src/antlr4/tree/Tree.py b/runtime/Python2/src/antlr4/tree/Tree.py
index 26e959612..14b5f29ec 100644
--- a/runtime/Python2/src/antlr4/tree/Tree.py
+++ b/runtime/Python2/src/antlr4/tree/Tree.py
@@ -108,13 +108,13 @@ class TerminalNodeImpl(TerminalNode):
return visitor.visitTerminal(self)
def getText(self):
- return self.symbol.text
+ return unicode(self.symbol.text)
def __unicode__(self):
if self.symbol.type == Token.EOF:
- return ""
+ return u""
else:
- return self.symbol.text
+ return unicode(self.symbol.text)
# Represents a token that was consumed during resynchronization
# rather than during a valid match operation. For example,
diff --git a/runtime/Python3/src/antlr4/Parser.py b/runtime/Python3/src/antlr4/Parser.py
index 03f10a438..c461bbdc0 100644
--- a/runtime/Python3/src/antlr4/Parser.py
+++ b/runtime/Python3/src/antlr4/Parser.py
@@ -227,6 +227,14 @@ class Parser (Recognizer):
listener.exitEveryRule(self._ctx)
+ # Gets the number of syntax errors reported during parsing. This value is
+ # incremented each time {@link #notifyErrorListeners} is called.
+ #
+ # @see #notifyErrorListeners
+ #
+ def getNumberOfSyntaxErrors(self):
+ return self._syntaxErrors
+
def getTokenFactory(self):
return self._input.tokenSource._factory
diff --git a/runtime/Python3/src/antlr4/__init__.py b/runtime/Python3/src/antlr4/__init__.py
index 4eac6c579..37c834202 100644
--- a/runtime/Python3/src/antlr4/__init__.py
+++ b/runtime/Python3/src/antlr4/__init__.py
@@ -12,7 +12,7 @@ from antlr4.atn.LexerATNSimulator import LexerATNSimulator
from antlr4.atn.ParserATNSimulator import ParserATNSimulator
from antlr4.atn.PredictionMode import PredictionMode
from antlr4.PredictionContext import PredictionContextCache
-from antlr4.ParserRuleContext import ParserRuleContext
+from antlr4.ParserRuleContext import RuleContext, ParserRuleContext
from antlr4.tree.Tree import ParseTreeListener, ParseTreeVisitor, ParseTreeWalker, TerminalNode, ErrorNode, RuleNode
from antlr4.error.Errors import RecognitionException, IllegalStateException, NoViableAltException
from antlr4.error.ErrorStrategy import BailErrorStrategy
diff --git a/runtime/Swift/.gitignore b/runtime/Swift/.gitignore
index c54511205..e4a84b226 100644
--- a/runtime/Swift/.gitignore
+++ b/runtime/Swift/.gitignore
@@ -1 +1,4 @@
+.build/
+Antlr4.xcodeproj/
+Tests/Antlr4Tests/gen/
xcuserdata/
diff --git a/runtime/Swift/Package.swift b/runtime/Swift/Package.swift
index 5c2e28b12..0d72a47dd 100644
--- a/runtime/Swift/Package.swift
+++ b/runtime/Swift/Package.swift
@@ -1,3 +1,4 @@
+// swift-tools-version:4.0
// Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
// Use of this file is governed by the BSD 3-clause license that
// can be found in the LICENSE.txt file in the project root.
@@ -5,15 +6,19 @@
import PackageDescription
let package = Package(
- name: "Antlr4"
-)
-
-products.append(
- Product(
- name: "Antlr4",
- type: .Library(.Dynamic),
- modules: [
- "Antlr4"
- ]
- )
+ name: "Antlr4",
+ products: [
+ .library(
+ name: "Antlr4",
+ type: .dynamic,
+ targets: ["Antlr4"]),
+ ],
+ targets: [
+ .target(
+ name: "Antlr4",
+ dependencies: []),
+ .testTarget(
+ name: "Antlr4Tests",
+ dependencies: ["Antlr4"]),
+ ]
)
diff --git a/runtime/Swift/Sources/Antlr4/ANTLRErrorListener.swift b/runtime/Swift/Sources/Antlr4/ANTLRErrorListener.swift
index 942986b5e..486ae0f2c 100644
--- a/runtime/Swift/Sources/Antlr4/ANTLRErrorListener.swift
+++ b/runtime/Swift/Sources/Antlr4/ANTLRErrorListener.swift
@@ -1,20 +1,23 @@
+///
/// Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
/// Use of this file is governed by the BSD 3-clause license that
/// can be found in the LICENSE.txt file in the project root.
/// How to emit recognition errors.
+///
public protocol ANTLRErrorListener: class {
+ ///
/// Upon syntax error, notify any interested parties. This is not how to
- /// recover from errors or compute error messages. {@link org.antlr.v4.runtime.ANTLRErrorStrategy}
+ /// recover from errors or compute error messages. _org.antlr.v4.runtime.ANTLRErrorStrategy_
/// specifies how to recover from syntax errors and how to compute error
/// messages. This listener's job is simply to emit a computed message,
/// though it has enough information to create its own message in many cases.
- ///
- /// The {@link org.antlr.v4.runtime.RecognitionException} is non-null for all syntax errors except
+ ///
+ /// The _RecognitionException_ is non-null for all syntax errors except
/// when we discover mismatched token errors that we can recover from
/// in-line, without returning from the surrounding rule (via the single
- /// token insertion and deletion mechanism).
- ///
+ /// token insertion and deletion mechanism).
+ ///
/// - parameter recognizer:
/// What parser got the error. From this
/// object, you can access the context as well
@@ -22,7 +25,7 @@ public protocol ANTLRErrorListener: class {
/// - parameter offendingSymbol:
/// The offending token in the input token
/// stream, unless recognizer is a lexer (then it's null). If
- /// no viable alternative error, {@code e} has token at which we
+ /// no viable alternative error, `e` has token at which we
/// started production for the decision.
/// - parameter line:
/// The line number in the input where the error occurred.
@@ -35,116 +38,122 @@ public protocol ANTLRErrorListener: class {
/// the reporting of an error. It is null in the case where
/// the parser was able to recover in line without exiting the
/// surrounding rule.
- func syntaxError(_ recognizer: Recognizer,
- _ offendingSymbol: AnyObject?,
- _ line: Int,
- _ charPositionInLine: Int,
- _ msg: String,
- _ e: AnyObject?// RecognitionException?
+ ///
+ func syntaxError(_ recognizer: Recognizer,
+ _ offendingSymbol: AnyObject?,
+ _ line: Int,
+ _ charPositionInLine: Int,
+ _ msg: String,
+ _ e: AnyObject?
)
+ ///
/// This method is called by the parser when a full-context prediction
/// results in an ambiguity.
- ///
- /// Each full-context prediction which does not result in a syntax error
- /// will call either {@link #reportContextSensitivity} or
- /// {@link #reportAmbiguity}.
- ///
- /// When {@code ambigAlts} is not null, it contains the set of potentially
+ ///
+ /// Each full-context prediction which does not result in a syntax error
+ /// will call either _#reportContextSensitivity_ or
+ /// _#reportAmbiguity_.
+ ///
+ /// When `ambigAlts` is not null, it contains the set of potentially
/// viable alternatives identified by the prediction algorithm. When
- /// {@code ambigAlts} is null, use {@link org.antlr.v4.runtime.atn.ATNConfigSet#getAlts} to obtain the
- /// represented alternatives from the {@code configs} argument.
- ///
- /// When {@code exact} is {@code true}, all of the potentially
+ /// `ambigAlts` is null, use _org.antlr.v4.runtime.atn.ATNConfigSet#getAlts_ to obtain the
+ /// represented alternatives from the `configs` argument.
+ ///
+ /// When `exact` is `true`, __all__ of the potentially
/// viable alternatives are truly viable, i.e. this is reporting an exact
- /// ambiguity. When {@code exact} is {@code false}, at least two of
+ /// ambiguity. When `exact` is `false`, __at least two__ of
/// the potentially viable alternatives are viable for the current input, but
/// the prediction algorithm terminated as soon as it determined that at
- /// least the minimum potentially viable alternative is truly
- /// viable.
- ///
- /// When the {@link org.antlr.v4.runtime.atn.PredictionMode#LL_EXACT_AMBIG_DETECTION} prediction
+ /// least the __minimum__ potentially viable alternative is truly
+ /// viable.
+ ///
+ /// When the _org.antlr.v4.runtime.atn.PredictionMode#LL_EXACT_AMBIG_DETECTION_ prediction
/// mode is used, the parser is required to identify exact ambiguities so
- /// {@code exact} will always be {@code true}.
- ///
- /// This method is not used by lexers.
- ///
+ /// `exact` will always be `true`.
+ ///
+ /// This method is not used by lexers.
+ ///
/// - parameter recognizer: the parser instance
/// - parameter dfa: the DFA for the current decision
/// - parameter startIndex: the input index where the decision started
/// - parameter stopIndex: the input input where the ambiguity was identified
- /// - parameter exact: {@code true} if the ambiguity is exactly known, otherwise
- /// {@code false}. This is always {@code true} when
- /// {@link org.antlr.v4.runtime.atn.PredictionMode#LL_EXACT_AMBIG_DETECTION} is used.
- /// - parameter ambigAlts: the potentially ambiguous alternatives, or {@code null}
+ /// - parameter exact: `true` if the ambiguity is exactly known, otherwise
+ /// `false`. This is always `true` when
+ /// _org.antlr.v4.runtime.atn.PredictionMode#LL_EXACT_AMBIG_DETECTION_ is used.
+ /// - parameter ambigAlts: the potentially ambiguous alternatives, or `null`
/// to indicate that the potentially ambiguous alternatives are the complete
- /// set of represented alternatives in {@code configs}
+ /// set of represented alternatives in `configs`
/// - parameter configs: the ATN configuration set where the ambiguity was
/// identified
+ ///
func reportAmbiguity(_ recognizer: Parser,
_ dfa: DFA,
_ startIndex: Int,
_ stopIndex: Int,
_ exact: Bool,
_ ambigAlts: BitSet,
- _ configs: ATNConfigSet) throws
+ _ configs: ATNConfigSet)
+ ///
/// This method is called when an SLL conflict occurs and the parser is about
/// to use the full context information to make an LL decision.
- ///
- /// If one or more configurations in {@code configs} contains a semantic
+ ///
+ /// If one or more configurations in `configs` contains a semantic
/// predicate, the predicates are evaluated before this method is called. The
/// subset of alternatives which are still viable after predicates are
- /// evaluated is reported in {@code conflictingAlts}.
- ///
- /// This method is not used by lexers.
- ///
+ /// evaluated is reported in `conflictingAlts`.
+ ///
+ /// This method is not used by lexers.
+ ///
/// - parameter recognizer: the parser instance
/// - parameter dfa: the DFA for the current decision
/// - parameter startIndex: the input index where the decision started
/// - parameter stopIndex: the input index where the SLL conflict occurred
/// - parameter conflictingAlts: The specific conflicting alternatives. If this is
- /// {@code null}, the conflicting alternatives are all alternatives
- /// represented in {@code configs}. At the moment, conflictingAlts is non-null
+ /// `null`, the conflicting alternatives are all alternatives
+ /// represented in `configs`. At the moment, conflictingAlts is non-null
/// (for the reference implementation, but Sam's optimized version can see this
/// as null).
/// - parameter configs: the ATN configuration set where the SLL conflict was
/// detected
+ ///
func reportAttemptingFullContext(_ recognizer: Parser,
_ dfa: DFA,
_ startIndex: Int,
_ stopIndex: Int,
_ conflictingAlts: BitSet?,
- _ configs: ATNConfigSet) throws
+ _ configs: ATNConfigSet)
+ ///
/// This method is called by the parser when a full-context prediction has a
/// unique result.
- ///
- /// Each full-context prediction which does not result in a syntax error
- /// will call either {@link #reportContextSensitivity} or
- /// {@link #reportAmbiguity}.
- ///
- /// For prediction implementations that only evaluate full-context
+ ///
+ /// Each full-context prediction which does not result in a syntax error
+ /// will call either _#reportContextSensitivity_ or
+ /// _#reportAmbiguity_.
+ ///
+ /// For prediction implementations that only evaluate full-context
/// predictions when an SLL conflict is found (including the default
- /// {@link org.antlr.v4.runtime.atn.ParserATNSimulator} implementation), this method reports cases
+ /// _org.antlr.v4.runtime.atn.ParserATNSimulator_ implementation), this method reports cases
/// where SLL conflicts were resolved to unique full-context predictions,
/// i.e. the decision was context-sensitive. This report does not necessarily
/// indicate a problem, and it may appear even in completely unambiguous
- /// grammars.
- ///
- /// {@code configs} may have more than one represented alternative if the
+ /// grammars.
+ ///
+ /// `configs` may have more than one represented alternative if the
/// full-context prediction algorithm does not evaluate predicates before
/// beginning the full-context prediction. In all cases, the final prediction
- /// is passed as the {@code prediction} argument.
- ///
- /// Note that the definition of "context sensitivity" in this method
- /// differs from the concept in {@link org.antlr.v4.runtime.atn.DecisionInfo#contextSensitivities}.
+ /// is passed as the `prediction` argument.
+ ///
+ /// Note that the definition of "context sensitivity" in this method
+ /// differs from the concept in _org.antlr.v4.runtime.atn.DecisionInfo#contextSensitivities_.
/// This method reports all instances where an SLL conflict occurred but LL
/// parsing produced a unique result, whether or not that unique result
- /// matches the minimum alternative in the SLL conflicting set.
- ///
- /// This method is not used by lexers.
- ///
+ /// matches the minimum alternative in the SLL conflicting set.
+ ///
+ /// This method is not used by lexers.
+ ///
/// - parameter recognizer: the parser instance
/// - parameter dfa: the DFA for the current decision
/// - parameter startIndex: the input index where the decision started
@@ -153,10 +162,11 @@ public protocol ANTLRErrorListener: class {
/// - parameter prediction: the unambiguous result of the full-context prediction
/// - parameter configs: the ATN configuration set where the unambiguous prediction
/// was determined
+ ///
func reportContextSensitivity(_ recognizer: Parser,
_ dfa: DFA,
_ startIndex: Int,
_ stopIndex: Int,
_ prediction: Int,
- _ configs: ATNConfigSet) throws
+ _ configs: ATNConfigSet)
}
diff --git a/runtime/Swift/Sources/Antlr4/ANTLRErrorStrategy.swift b/runtime/Swift/Sources/Antlr4/ANTLRErrorStrategy.swift
index 541a2a3b4..7ca228ff8 100644
--- a/runtime/Swift/Sources/Antlr4/ANTLRErrorStrategy.swift
+++ b/runtime/Swift/Sources/Antlr4/ANTLRErrorStrategy.swift
@@ -1,99 +1,119 @@
+///
+///
/// Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
/// Use of this file is governed by the BSD 3-clause license that
/// can be found in the LICENSE.txt file in the project root.
-/// The interface for defining strategies to deal with syntax errors encountered
-/// during a parse by ANTLR-generated parsers. We distinguish between three
-/// different kinds of errors:
-///
-///
-/// - The parser could not figure out which path to take in the ATN (none of
-/// the available alternatives could possibly match)
-/// - The current input does not match what we were looking for
-/// - A predicate evaluated to false
-///
-///
-/// Implementations of this interface report syntax errors by calling
-/// {@link org.antlr.v4.runtime.Parser#notifyErrorListeners}.
-///
-/// TODO: what to do about lexers
+///
+///
+
+///
+///
+/// The interface for defining strategies to deal with syntax errors
+/// encountered during a parse by ANTLR-generated parsers. We distinguish between three
+/// different kinds of errors:
+///
+/// * The parser could not figure out which path to take in the ATN (none of
+/// the available alternatives could possibly match)
+/// * The current input does not match what we were looking for
+/// * A predicate evaluated to false
+///
+/// Implementations of this interface report syntax errors by calling
+/// _org.antlr.v4.runtime.Parser#notifyErrorListeners_.
+///
+/// TODO: what to do about lexers
+///
public protocol ANTLRErrorStrategy {
- /// Reset the error handler state for the specified {@code recognizer}.
+ ///
+ /// Reset the error handler state for the specified `recognizer`.
/// - parameter recognizer: the parser instance
+ ///
func reset(_ recognizer: Parser)
+ ///
/// This method is called when an unexpected symbol is encountered during an
- /// inline match operation, such as {@link org.antlr.v4.runtime.Parser#match}. If the error
+ /// inline match operation, such as _org.antlr.v4.runtime.Parser#match_. If the error
/// strategy successfully recovers from the match failure, this method
- /// returns the {@link org.antlr.v4.runtime.Token} instance which should be treated as the
+ /// returns the _org.antlr.v4.runtime.Token_ instance which should be treated as the
/// successful result of the match.
- ///
- /// This method handles the consumption of any tokens - the caller should
- /// not call {@link org.antlr.v4.runtime.Parser#consume} after a successful recovery.
- ///
- /// Note that the calling code will not report an error if this method
+ ///
+ /// This method handles the consumption of any tokens - the caller should
+ /// __not__ call _org.antlr.v4.runtime.Parser#consume_ after a successful recovery.
+ ///
+ /// Note that the calling code will not report an error if this method
/// returns successfully. The error strategy implementation is responsible
- /// for calling {@link org.antlr.v4.runtime.Parser#notifyErrorListeners} as appropriate.
- ///
+ /// for calling _org.antlr.v4.runtime.Parser#notifyErrorListeners_ as appropriate.
+ ///
/// - parameter recognizer: the parser instance
- /// - org.antlr.v4.runtime.RecognitionException if the error strategy was not able to
+ /// - throws: _RecognitionException_ if the error strategy was not able to
/// recover from the unexpected input symbol
+ ///
@discardableResult
- func recoverInline(_ recognizer: Parser) throws -> Token // RecognitionException;
+ func recoverInline(_ recognizer: Parser) throws -> Token
- /// This method is called to recover from exception {@code e}. This method is
- /// called after {@link #reportError} by the default exception handler
+ ///
+ /// This method is called to recover from exception `e`. This method is
+ /// called after _#reportError_ by the default exception handler
/// generated for a rule method.
- ///
+ ///
/// - seealso: #reportError
- ///
+ ///
/// - parameter recognizer: the parser instance
/// - parameter e: the recognition exception to recover from
- /// - org.antlr.v4.runtime.RecognitionException if the error strategy could not recover from
+ /// - throws: _RecognitionException_ if the error strategy could not recover from
/// the recognition exception
- func recover(_ recognizer: Parser, _ e: AnyObject) throws // RecognitionException;
+ ///
+ func recover(_ recognizer: Parser, _ e: RecognitionException) throws
+ ///
/// This method provides the error handler with an opportunity to handle
/// syntactic or semantic errors in the input stream before they result in a
- /// {@link org.antlr.v4.runtime.RecognitionException}.
- ///
- /// The generated code currently contains calls to {@link #sync} after
- /// entering the decision state of a closure block ({@code (...)*} or
- /// {@code (...)+}).
- ///
- /// For an implementation based on Jim Idle's "magic sync" mechanism, see
- /// {@link org.antlr.v4.runtime.DefaultErrorStrategy#sync}.
- ///
+ /// _org.antlr.v4.runtime.RecognitionException_.
+ ///
+ /// The generated code currently contains calls to _#sync_ after
+ /// entering the decision state of a closure block (`(...)*` or
+ /// `(...)+`).
+ ///
+ /// For an implementation based on Jim Idle's "magic sync" mechanism, see
+ /// _org.antlr.v4.runtime.DefaultErrorStrategy#sync_.
+ ///
/// - seealso: org.antlr.v4.runtime.DefaultErrorStrategy#sync
- ///
+ ///
/// - parameter recognizer: the parser instance
- /// - org.antlr.v4.runtime.RecognitionException if an error is detected by the error
+ /// - throws: _RecognitionException_ if an error is detected by the error
/// strategy but cannot be automatically recovered at the current state in
/// the parsing process
- func sync(_ recognizer: Parser) throws // RecognitionException;
+ ///
+ func sync(_ recognizer: Parser) throws
+ ///
/// Tests whether or not recognizer} is in the process of recovering
- /// from an error. In error recovery mode, {@link org.antlr.v4.runtime.Parser#consume} adds
+ /// from an error. In error recovery mode, _org.antlr.v4.runtime.Parser#consume_ adds
/// symbols to the parse tree by calling
- /// {@link Parser#createErrorNode(ParserRuleContext, Token)} then
- /// {@link ParserRuleContext#addErrorNode(ErrorNode)} instead of
- /// {@link Parser#createTerminalNode(ParserRuleContext, Token)}.
- ///
+ /// _Parser#createErrorNode(ParserRuleContext, Token)_ then
+ /// _ParserRuleContext#addErrorNode(ErrorNode)_ instead of
+ /// _Parser#createTerminalNode(ParserRuleContext, Token)_.
+ ///
/// - parameter recognizer: the parser instance
- /// - returns: {@code true} if the parser is currently recovering from a parse
- /// error, otherwise {@code false}
+ /// - returns: `true` if the parser is currently recovering from a parse
+ /// error, otherwise `false`
+ ///
func inErrorRecoveryMode(_ recognizer: Parser) -> Bool
+ ///
/// This method is called by when the parser successfully matches an input
/// symbol.
- ///
+ ///
/// - parameter recognizer: the parser instance
+ ///
func reportMatch(_ recognizer: Parser)
- /// Report any kind of {@link org.antlr.v4.runtime.RecognitionException}. This method is called by
+ ///
+ /// Report any kind of _org.antlr.v4.runtime.RecognitionException_. This method is called by
/// the default exception handler generated for a rule method.
- ///
+ ///
/// - parameter recognizer: the parser instance
/// - parameter e: the recognition exception to report
- func reportError(_ recognizer: Parser, _ e: AnyObject)
+ ///
+ func reportError(_ recognizer: Parser, _ e: RecognitionException)
}
diff --git a/runtime/Swift/Sources/Antlr4/ANTLRFileStream.swift b/runtime/Swift/Sources/Antlr4/ANTLRFileStream.swift
index 053b6348d..9ed7ac9ef 100644
--- a/runtime/Swift/Sources/Antlr4/ANTLRFileStream.swift
+++ b/runtime/Swift/Sources/Antlr4/ANTLRFileStream.swift
@@ -1,8 +1,10 @@
+///
/// Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
/// Use of this file is governed by the BSD 3-clause license that
/// can be found in the LICENSE.txt file in the project root.
-/// This is an {@link org.antlr.v4.runtime.ANTLRInputStream} that is loaded from a file all at once
+/// This is an _org.antlr.v4.runtime.ANTLRInputStream_ that is loaded from a file all at once
/// when you construct the object.
+///
import Foundation
@@ -10,7 +12,6 @@ public class ANTLRFileStream: ANTLRInputStream {
internal var fileName: String
public convenience override init(_ fileName: String) {
- // throws; IOException
self.init(fileName, nil)
}
diff --git a/runtime/Swift/Sources/Antlr4/ANTLRInputStream.swift b/runtime/Swift/Sources/Antlr4/ANTLRInputStream.swift
index 3b73981fd..17bbd8096 100644
--- a/runtime/Swift/Sources/Antlr4/ANTLRInputStream.swift
+++ b/runtime/Swift/Sources/Antlr4/ANTLRInputStream.swift
@@ -1,26 +1,36 @@
+///
/// Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
/// Use of this file is governed by the BSD 3-clause license that
/// can be found in the LICENSE.txt file in the project root.
-/// Vacuum all input from a {@link java.io.Reader}/{@link java.io.InputStream} and then treat it
-/// like a {@code char[]} buffer. Can also pass in a {@link String} or
-/// {@code char[]} to use.
-///
-/// If you need encoding, pass in stream/reader with correct encoding.
+/// Vacuum all input from a _java.io.Reader_/_java.io.InputStream_ and then treat it
+/// like a `char[]` buffer. Can also pass in a _String_ or
+/// `char[]` to use.
+///
+/// If you need encoding, pass in stream/reader with correct encoding.
+///
public class ANTLRInputStream: CharStream {
public static let READ_BUFFER_SIZE: Int = 1024
public static let INITIAL_BUFFER_SIZE: Int = 1024
+ ///
/// The data being scanned
+ ///
internal var data: [Character]
+ ///
/// How many characters are actually in the buffer
+ ///
internal var n: Int
+ ///
/// 0..n-1 index into string of next char
+ ///
internal var p: Int = 0
+ ///
/// What is name or source of this char stream?
+ ///
public var name: String?
public init() {
@@ -28,87 +38,26 @@ public class ANTLRInputStream: CharStream {
data = [Character]()
}
+ ///
/// Copy data in string to a local char array
+ ///
public init(_ input: String) {
self.data = Array(input.characters) // input.toCharArray();
self.n = input.length
}
+ ///
/// This is the preferred constructor for strings as no data is copied
+ ///
public init(_ data: [Character], _ numberOfActualCharsInArray: Int) {
self.data = data
self.n = numberOfActualCharsInArray
}
- /// public convenience init(_ r : Reader) throws; IOException {
- /// self.init(r, INITIAL_BUFFER_SIZE, READ_BUFFER_SIZE);
- /// }
- ///
- /// public convenience init(_ r : Reader, _ initialSize : Int) throws; IOException {
- /// self.init(r, initialSize, READ_BUFFER_SIZE);
- /// }
- ///
- /// public init(_ r : Reader, _ initialSize : Int, _ readChunkSize : Int) throws; IOException {
- /// load(r, initialSize, readChunkSize);
- /// }
- ///
- /// public convenience init(_ input : InputStream) throws; IOException {
- /// self.init(InputStreamReader(input), INITIAL_BUFFER_SIZE);
- /// }
- ///
- /// public convenience init(_ input : InputStream, _ initialSize : Int) throws; IOException {
- /// self.init(InputStreamReader(input), initialSize);
- /// }
- ///
- /// public convenience init(_ input : InputStream, _ initialSize : Int, _ readChunkSize : Int) throws; IOException {
- /// self.init(InputStreamReader(input), initialSize, readChunkSize);
- /// }
- ///
- /// public func load(r : Reader, _ size : Int, _ readChunkSize : Int)
- /// throws; IOException
- /// {
- /// if ( r==nil ) {
- /// return;
- /// }
- /// if ( size<=0 ) {
- /// size = INITIAL_BUFFER_SIZE;
- /// }
- /// if ( readChunkSize<=0 ) {
- /// readChunkSize = READ_BUFFER_SIZE;
- /// }
- /// // print("load "+size+" in chunks of "+readChunkSize);
- /// try {
- /// // alloc initial buffer size.
- /// data = new char[size];
- /// // read all the data in chunks of readChunkSize
- /// var numRead : Int=0;
- /// var p : Int = 0;
- /// do {
- /// if ( p+readChunkSize > data.length ) { // overflow?
- /// // print("### overflow p="+p+", data.length="+data.length);
- /// data = Arrays.copyOf(data, data.length * 2);
- /// }
- /// numRead = r.read(data, p, readChunkSize);
- /// // print("read "+numRead+" chars; p was "+p+" is now "+(p+numRead));
- /// p += numRead;
- /// } while (numRead!=-1); // while not EOF
- /// // set the actual size of the data available;
- /// // EOF subtracted one above in p+=numRead; add one back
- /// n = p+1;
- /// //print("n="+n);
- /// }
- /// finally {
- /// r.close();
- /// }
- /// }
- /// Reset the stream so that it's in the same state it was
- /// when the object was created *except* the data array is not
- /// touched.
public func reset() {
p = 0
}
-
public func consume() throws {
if p >= n {
assert(LA(1) == ANTLRInputStream.EOF, "Expected: LA(1)==IntStream.EOF")
@@ -124,7 +73,6 @@ public class ANTLRInputStream: CharStream {
}
}
-
public func LA(_ i: Int) -> Int {
var i = i
if i == 0 {
@@ -150,9 +98,11 @@ public class ANTLRInputStream: CharStream {
return LA(i)
}
+ ///
/// Return the current input symbol index 0..n where n indicates the
/// last symbol has been read. The index is the index of char to
/// be returned from LA(1).
+ ///
public func index() -> Int {
return p
}
@@ -161,7 +111,9 @@ public class ANTLRInputStream: CharStream {
return n
}
+ ///
/// mark/release do nothing; we have entire buffer
+ ///
public func mark() -> Int {
return -1
@@ -170,8 +122,10 @@ public class ANTLRInputStream: CharStream {
public func release(_ marker: Int) {
}
+ ///
/// consume() ahead until p==index; can't just set p=index as we must
/// update line and charPositionInLine. If we seek backwards, just set p
+ ///
public func seek(_ index: Int) throws {
var index = index
@@ -186,7 +140,6 @@ public class ANTLRInputStream: CharStream {
}
}
-
public func getText(_ interval: Interval) -> String {
let start: Int = interval.a
var stop: Int = interval.b
@@ -201,7 +154,6 @@ public class ANTLRInputStream: CharStream {
return String(data[start ..< (start + count)])
}
-
public func getSourceName() -> String {
guard let name = name , !name.isEmpty else {
return ANTLRInputStream.UNKNOWN_SOURCE_NAME
@@ -209,7 +161,6 @@ public class ANTLRInputStream: CharStream {
return name
}
-
public func toString() -> String {
return String(data)
}
diff --git a/runtime/Swift/Sources/Antlr4/BailErrorStrategy.swift b/runtime/Swift/Sources/Antlr4/BailErrorStrategy.swift
index eca1de705..d1e81140c 100644
--- a/runtime/Swift/Sources/Antlr4/BailErrorStrategy.swift
+++ b/runtime/Swift/Sources/Antlr4/BailErrorStrategy.swift
@@ -1,69 +1,74 @@
+///
/// Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
/// Use of this file is governed by the BSD 3-clause license that
/// can be found in the LICENSE.txt file in the project root.
+///
-
-/// This implementation of {@link org.antlr.v4.runtime.ANTLRErrorStrategy} responds to syntax errors
+///
+///
+/// This implementation of _org.antlr.v4.runtime.ANTLRErrorStrategy_ responds to syntax errors
/// by immediately canceling the parse operation with a
-/// {@link org.antlr.v4.runtime.misc.ParseCancellationException}. The implementation ensures that the
-/// {@link org.antlr.v4.runtime.ParserRuleContext#exception} field is set for all parse tree nodes
+/// _org.antlr.v4.runtime.misc.ParseCancellationException_. The implementation ensures that the
+/// _org.antlr.v4.runtime.ParserRuleContext#exception_ field is set for all parse tree nodes
/// that were not completed prior to encountering the error.
-///
-///
-/// This error strategy is useful in the following scenarios.
-///
-///
-/// - Two-stage parsing: This error strategy allows the first
+///
+/// This error strategy is useful in the following scenarios.
+///
+/// * __Two-stage parsing:__ This error strategy allows the first
/// stage of two-stage parsing to immediately terminate if an error is
/// encountered, and immediately fall back to the second stage. In addition to
/// avoiding wasted work by attempting to recover from errors here, the empty
-/// implementation of {@link org.antlr.v4.runtime.BailErrorStrategy#sync} improves the performance of
-/// the first stage.
-/// - Silent validation: When syntax errors are not being
+/// implementation of _org.antlr.v4.runtime.BailErrorStrategy#sync_ improves the performance of
+/// the first stage.
+///
+/// * __Silent validation:__ When syntax errors are not being
/// reported or logged, and the parse result is simply ignored if errors occur,
-/// the {@link org.antlr.v4.runtime.BailErrorStrategy} avoids wasting work on recovering from errors
-/// when the result will be ignored either way.
-///
-///
-///
-/// {@code myparser.setErrorHandler(new BailErrorStrategy());}
-///
+/// the _org.antlr.v4.runtime.BailErrorStrategy_ avoids wasting work on recovering from errors
+/// when the result will be ignored either way.
+///
+/// `myparser.setErrorHandler(new BailErrorStrategy());`
+///
/// - seealso: org.antlr.v4.runtime.Parser#setErrorHandler(org.antlr.v4.runtime.ANTLRErrorStrategy)
-
+///
+///
public class BailErrorStrategy: DefaultErrorStrategy {
public override init(){}
- /// Instead of recovering from exception {@code e}, re-throw it wrapped
- /// in a {@link org.antlr.v4.runtime.misc.ParseCancellationException} so it is not caught by the
- /// rule function catches. Use {@link Exception#getCause()} to get the
- /// original {@link org.antlr.v4.runtime.RecognitionException}.
- override
- public func recover(_ recognizer: Parser, _ e: AnyObject) throws {
- var context: ParserRuleContext? = recognizer.getContext()
- while let contextWrap = context{
+ ///
+ /// Instead of recovering from exception `e`, re-throw it wrapped
+ /// in a _org.antlr.v4.runtime.misc.ParseCancellationException_ so it is not caught by the
+ /// rule function catches. Use _Exception#getCause()_ to get the
+ /// original _org.antlr.v4.runtime.RecognitionException_.
+ ///
+ override public func recover(_ recognizer: Parser, _ e: RecognitionException) throws {
+ var context = recognizer.getContext()
+ while let contextWrap = context {
contextWrap.exception = e
context = (contextWrap.getParent() as? ParserRuleContext)
}
- throw ANTLRException.recognition(e: e)
+ throw ANTLRException.recognition(e: e)
}
+ ///
/// Make sure we don't attempt to recover inline; if the parser
/// successfully recovers, it won't throw an exception.
+ ///
override
public func recoverInline(_ recognizer: Parser) throws -> Token {
- let e: InputMismatchException = try InputMismatchException(recognizer)
- var context: ParserRuleContext? = recognizer.getContext()
+ let e = InputMismatchException(recognizer)
+ var context = recognizer.getContext()
while let contextWrap = context {
contextWrap.exception = e
context = (contextWrap.getParent() as? ParserRuleContext)
}
- throw ANTLRException.recognition(e: e)
-
+ throw ANTLRException.recognition(e: e)
}
+ ///
/// Make sure we don't attempt to recover from problems in subrules.
+ ///
override
public func sync(_ recognizer: Parser) {
}
diff --git a/runtime/Swift/Sources/Antlr4/BaseErrorListener.swift b/runtime/Swift/Sources/Antlr4/BaseErrorListener.swift
index 5a4292c4e..8db84a00b 100644
--- a/runtime/Swift/Sources/Antlr4/BaseErrorListener.swift
+++ b/runtime/Swift/Sources/Antlr4/BaseErrorListener.swift
@@ -1,24 +1,28 @@
+///
/// Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
/// Use of this file is governed by the BSD 3-clause license that
/// can be found in the LICENSE.txt file in the project root.
+///
-/// Provides an empty default implementation of {@link org.antlr.v4.runtime.ANTLRErrorListener}. The
+///
+/// Provides an empty default implementation of _org.antlr.v4.runtime.ANTLRErrorListener_. The
/// default implementation of each method does nothing, but can be overridden as
/// necessary.
-///
+///
/// - Sam Harwell
+///
open class BaseErrorListener: ANTLRErrorListener {
public init() {
}
- open func syntaxError(_ recognizer: Recognizer,
- _ offendingSymbol: AnyObject?,
- _ line: Int,
- _ charPositionInLine: Int,
- _ msg: String,
- _ e: AnyObject?//RecognitionException
+ open func syntaxError(_ recognizer: Recognizer,
+ _ offendingSymbol: AnyObject?,
+ _ line: Int,
+ _ charPositionInLine: Int,
+ _ msg: String,
+ _ e: AnyObject?
) {
}
@@ -29,7 +33,7 @@ open class BaseErrorListener: ANTLRErrorListener {
_ stopIndex: Int,
_ exact: Bool,
_ ambigAlts: BitSet,
- _ configs: ATNConfigSet) throws {
+ _ configs: ATNConfigSet) {
}
@@ -38,7 +42,7 @@ open class BaseErrorListener: ANTLRErrorListener {
_ startIndex: Int,
_ stopIndex: Int,
_ conflictingAlts: BitSet?,
- _ configs: ATNConfigSet) throws {
+ _ configs: ATNConfigSet) {
}
@@ -47,6 +51,6 @@ open class BaseErrorListener: ANTLRErrorListener {
_ startIndex: Int,
_ stopIndex: Int,
_ prediction: Int,
- _ configs: ATNConfigSet) throws {
+ _ configs: ATNConfigSet) {
}
}
diff --git a/runtime/Swift/Sources/Antlr4/BufferedTokenStream.swift b/runtime/Swift/Sources/Antlr4/BufferedTokenStream.swift
index 8ea114821..2805f8855 100644
--- a/runtime/Swift/Sources/Antlr4/BufferedTokenStream.swift
+++ b/runtime/Swift/Sources/Antlr4/BufferedTokenStream.swift
@@ -1,52 +1,63 @@
+///
/// Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
/// Use of this file is governed by the BSD 3-clause license that
/// can be found in the LICENSE.txt file in the project root.
+///
-/// This implementation of {@link org.antlr.v4.runtime.TokenStream} loads tokens from a
-/// {@link org.antlr.v4.runtime.TokenSource} on-demand, and places the tokens in a buffer to provide
+///
+/// This implementation of _org.antlr.v4.runtime.TokenStream_ loads tokens from a
+/// _org.antlr.v4.runtime.TokenSource_ on-demand, and places the tokens in a buffer to provide
/// access to any previous token by index.
-///
-///
-/// This token stream ignores the value of {@link org.antlr.v4.runtime.Token#getChannel}. If your
+///
+///
+/// This token stream ignores the value of _org.antlr.v4.runtime.Token#getChannel_. If your
/// parser requires the token stream filter tokens to only those on a particular
-/// channel, such as {@link org.antlr.v4.runtime.Token#DEFAULT_CHANNEL} or
-/// {@link org.antlr.v4.runtime.Token#HIDDEN_CHANNEL}, use a filtering token stream such a
-/// {@link org.antlr.v4.runtime.CommonTokenStream}.
+/// channel, such as _org.antlr.v4.runtime.Token#DEFAULT_CHANNEL_ or
+/// _org.antlr.v4.runtime.Token#HIDDEN_CHANNEL_, use a filtering token stream such a
+/// _org.antlr.v4.runtime.CommonTokenStream_.
+///
public class BufferedTokenStream: TokenStream {
- /// The {@link org.antlr.v4.runtime.TokenSource} from which tokens for this stream are fetched.
+ ///
+ /// The _org.antlr.v4.runtime.TokenSource_ from which tokens for this stream are fetched.
+ ///
internal var tokenSource: TokenSource
+ ///
/// A collection of all tokens fetched from the token source. The list is
- /// considered a complete view of the input once {@link #fetchedEOF} is set
- /// to {@code true}.
+ /// considered a complete view of the input once _#fetchedEOF_ is set
+ /// to `true`.
+ ///
internal var tokens: Array = Array()
// Array(100
- /// The index into {@link #tokens} of the current token (next token to
- /// {@link #consume}). {@link #tokens}{@code [}{@link #p}{@code ]} should be
- /// {@link #LT LT(1)}.
- ///
- /// This field is set to -1 when the stream is first constructed or when
- /// {@link #setTokenSource} is called, indicating that the first token has
+ ///
+ /// The index into _#tokens_ of the current token (next token to
+ /// _#consume_). _#tokens_`[`_#p_`]` should be
+ /// _#LT LT(1)_.
+ ///
+ /// This field is set to -1 when the stream is first constructed or when
+ /// _#setTokenSource_ is called, indicating that the first token has
/// not yet been fetched from the token source. For additional information,
- /// see the documentation of {@link org.antlr.v4.runtime.IntStream} for a description of
- /// Initializing Methods.
+ /// see the documentation of _org.antlr.v4.runtime.IntStream_ for a description of
+ /// Initializing Methods.
+ ///
internal var p: Int = -1
- /// Indicates whether the {@link org.antlr.v4.runtime.Token#EOF} token has been fetched from
- /// {@link #tokenSource} and added to {@link #tokens}. This field improves
+ ///
+ /// Indicates whether the _org.antlr.v4.runtime.Token#EOF_ token has been fetched from
+ /// _#tokenSource_ and added to _#tokens_. This field improves
/// performance for the following cases:
- ///
- ///
- /// - {@link #consume}: The lookahead check in {@link #consume} to prevent
+ ///
+ /// * _#consume_: The lookahead check in _#consume_ to prevent
/// consuming the EOF symbol is optimized by checking the values of
- /// {@link #fetchedEOF} and {@link #p} instead of calling {@link #LA}.
- /// - {@link #fetch}: The check to prevent adding multiple EOF symbols into
- /// {@link #tokens} is trivial with this field.
- ///
- ///
- ///
- /// line line:charPositionInLine msg
- ///
- override
- public func syntaxError(_ recognizer: Recognizer,
- _ offendingSymbol: AnyObject?,
- _ line: Int,
- _ charPositionInLine: Int,
- _ msg: String,
- _ e: AnyObject?
+ ///
+ ///
+ /// This implementation prints messages to _System#err_ containing the
+ /// values of `line`, `charPositionInLine`, and `msg` using
+ /// the following format.
+ ///
+ /// line __line__:__charPositionInLine__ __msg__
+ ///
+ ///
+ override public func syntaxError(_ recognizer: Recognizer,
+ _ offendingSymbol: AnyObject?,
+ _ line: Int,
+ _ charPositionInLine: Int,
+ _ msg: String,
+ _ e: AnyObject?
) {
if Parser.ConsoleError {
errPrint("line \(line):\(charPositionInLine) \(msg)")
diff --git a/runtime/Swift/Sources/Antlr4/DefaultErrorStrategy.swift b/runtime/Swift/Sources/Antlr4/DefaultErrorStrategy.swift
index a7221b8dc..d6ac65767 100644
--- a/runtime/Swift/Sources/Antlr4/DefaultErrorStrategy.swift
+++ b/runtime/Swift/Sources/Antlr4/DefaultErrorStrategy.swift
@@ -1,92 +1,96 @@
+///
/// Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
/// Use of this file is governed by the BSD 3-clause license that
/// can be found in the LICENSE.txt file in the project root.
+///
-
-
-/// This is the default implementation of {@link org.antlr.v4.runtime.ANTLRErrorStrategy} used for
+///
+/// This is the default implementation of _org.antlr.v4.runtime.ANTLRErrorStrategy_ used for
/// error reporting and recovery in ANTLR parsers.
+///
import Foundation
public class DefaultErrorStrategy: ANTLRErrorStrategy {
+ ///
/// Indicates whether the error strategy is currently "recovering from an
/// error". This is used to suppress reporting multiple error messages while
/// attempting to recover from a detected syntax error.
- ///
+ ///
/// - seealso: #inErrorRecoveryMode
+ ///
internal var errorRecoveryMode: Bool = false
+ ///
/// The index into the input stream where the last error occurred.
/// This is used to prevent infinite loops where an error is found
/// but no token is consumed during recovery...another error is found,
/// ad nauseum. This is a failsafe mechanism to guarantee that at least
/// one token/tree node is consumed for two errors.
+ ///
internal var lastErrorIndex: Int = -1
internal var lastErrorStates: IntervalSet?
- /// {@inheritDoc}
- ///
- /// The default implementation simply calls {@link #endErrorCondition} to
- /// ensure that the handler is not in error recovery mode.
-
+ ///
+ /// The default implementation simply calls _#endErrorCondition_ to
+ /// ensure that the handler is not in error recovery mode.
+ ///
public func reset(_ recognizer: Parser) {
endErrorCondition(recognizer)
}
+ ///
/// This method is called to enter error recovery mode when a recognition
/// exception is reported.
- ///
+ ///
/// - parameter recognizer: the parser instance
+ ///
internal func beginErrorCondition(_ recognizer: Parser) {
errorRecoveryMode = true
}
- /// {@inheritDoc}
-
public func inErrorRecoveryMode(_ recognizer: Parser) -> Bool {
return errorRecoveryMode
}
+ ///
/// This method is called to leave error recovery mode after recovering from
/// a recognition exception.
- ///
+ ///
/// - parameter recognizer:
+ ///
internal func endErrorCondition(_ recognizer: Parser) {
errorRecoveryMode = false
lastErrorStates = nil
lastErrorIndex = -1
}
- /// {@inheritDoc}
- ///
- /// The default implementation simply calls {@link #endErrorCondition}.
-
+ ///
+ /// The default implementation simply calls _#endErrorCondition_.
+ ///
public func reportMatch(_ recognizer: Parser) {
endErrorCondition(recognizer)
}
- /// {@inheritDoc}
- ///
- /// The default implementation returns immediately if the handler is already
- /// in error recovery mode. Otherwise, it calls {@link #beginErrorCondition}
- /// and dispatches the reporting task based on the runtime type of {@code e}
- /// according to the following table.
- ///
- ///
- /// - {@link org.antlr.v4.runtime.NoViableAltException}: Dispatches the call to
- /// {@link #reportNoViableAlternative}
- /// - {@link org.antlr.v4.runtime.InputMismatchException}: Dispatches the call to
- /// {@link #reportInputMismatch}
- /// - {@link org.antlr.v4.runtime.FailedPredicateException}: Dispatches the call to
- /// {@link #reportFailedPredicate}
- /// - All other types: calls {@link org.antlr.v4.runtime.Parser#notifyErrorListeners} to report
- /// the exception
- ///
-
+ ///
+ ///
+ /// The default implementation returns immediately if the handler is already
+ /// in error recovery mode. Otherwise, it calls _#beginErrorCondition_
+ /// and dispatches the reporting task based on the runtime type of `e`
+ /// according to the following table.
+ ///
+ /// * _org.antlr.v4.runtime.NoViableAltException_: Dispatches the call to
+ /// _#reportNoViableAlternative_
+ /// * _org.antlr.v4.runtime.InputMismatchException_: Dispatches the call to
+ /// _#reportInputMismatch_
+ /// * _org.antlr.v4.runtime.FailedPredicateException_: Dispatches the call to
+ /// _#reportFailedPredicate_
+ /// * All other types: calls _org.antlr.v4.runtime.Parser#notifyErrorListeners_ to report
+ /// the exception
+ ///
public func reportError(_ recognizer: Parser,
- _ e: AnyObject) {
+ _ e: RecognitionException) {
// if we've already reported an error and have not matched a token
// yet successfully, don't report any errors.
if inErrorRecoveryMode(recognizer) {
@@ -94,31 +98,27 @@ public class DefaultErrorStrategy: ANTLRErrorStrategy {
return // don't report spurious errors
}
beginErrorCondition(recognizer)
- //TODO: exception handler
- if (e is NoViableAltException) {
- try! reportNoViableAlternative(recognizer, e as! NoViableAltException);
- } else {
- if (e is InputMismatchException) {
- reportInputMismatch(recognizer, e as! InputMismatchException);
- } else {
- if (e is FailedPredicateException) {
- reportFailedPredicate(recognizer, e as! FailedPredicateException);
- } else {
- errPrint("unknown recognition error type: " + String(describing: type(of: e)));
- let re = (e as! RecognitionException)
- recognizer.notifyErrorListeners(re.getOffendingToken(), re.message ?? "", e);
- }
- }
+ if let nvae = e as? NoViableAltException {
+ reportNoViableAlternative(recognizer, nvae)
+ }
+ else if let ime = e as? InputMismatchException {
+ reportInputMismatch(recognizer, ime)
+ }
+ else if let fpe = e as? FailedPredicateException {
+ reportFailedPredicate(recognizer, fpe)
+ }
+ else {
+ errPrint("unknown recognition error type: " + String(describing: type(of: e)))
+ recognizer.notifyErrorListeners(e.getOffendingToken(), e.message ?? "", e)
}
}
- /// {@inheritDoc}
- ///
- /// The default implementation resynchronizes the parser by consuming tokens
+ ///
+ /// The default implementation resynchronizes the parser by consuming tokens
/// until we find one in the resynchronization set--loosely the set of tokens
- /// that can follow the current rule.
-
- public func recover(_ recognizer: Parser, _ e: AnyObject) throws {
+ /// that can follow the current rule.
+ ///
+ public func recover(_ recognizer: Parser, _ e: RecognitionException) throws {
// print("recover in "+recognizer.getRuleInvocationStack()+
// " index="+getTokenStream(recognizer).index()+
// ", lastErrorIndex="+
@@ -138,77 +138,74 @@ public class DefaultErrorStrategy: ANTLRErrorStrategy {
}
lastErrorIndex = getTokenStream(recognizer).index()
if lastErrorStates == nil {
- lastErrorStates = try IntervalSet()
+ lastErrorStates = IntervalSet()
}
try lastErrorStates!.add(recognizer.getState())
- let followSet: IntervalSet = try getErrorRecoverySet(recognizer)
+ let followSet = getErrorRecoverySet(recognizer)
try consumeUntil(recognizer, followSet)
}
- /// The default implementation of {@link org.antlr.v4.runtime.ANTLRErrorStrategy#sync} makes sure
+ ///
+ /// The default implementation of _org.antlr.v4.runtime.ANTLRErrorStrategy#sync_ makes sure
/// that the current lookahead symbol is consistent with what were expecting
/// at this point in the ATN. You can call this anytime but ANTLR only
/// generates code to check before subrules/loops and each iteration.
- ///
- /// Implements Jim Idle's magic sync mechanism in closures and optional
- /// subrules. E.g.,
- ///
- ///
+ ///
+ /// Implements Jim Idle's magic sync mechanism in closures and optional
+ /// subrules. E.g.,
+ ///
+ ///
/// a : sync ( stuff sync )* ;
/// sync : {consume to what can follow sync} ;
- ///
- ///
- /// At the start of a sub rule upon error, {@link #sync} performs single
+ ///
+ ///
+ /// At the start of a sub rule upon error, _#sync_ performs single
/// token deletion, if possible. If it can't do that, it bails on the current
/// rule and uses the default error recovery, which consumes until the
/// resynchronization set of the current rule.
- ///
- /// If the sub rule is optional ({@code (...)?}, {@code (...)*}, or block
+ ///
+ /// If the sub rule is optional (`(...)?`, `(...)*`, or block
/// with an empty alternative), then the expected set includes what follows
- /// the subrule.
- ///
- /// During loop iteration, it consumes until it sees a token that can start a
+ /// the subrule.
+ ///
+ /// During loop iteration, it consumes until it sees a token that can start a
/// sub rule or what follows loop. Yes, that is pretty aggressive. We opt to
- /// stay in the loop as long as possible.
- ///
- /// ORIGINS
- ///
- /// Previous versions of ANTLR did a poor job of their recovery within loops.
+ /// stay in the loop as long as possible.
+ ///
+ /// __ORIGINS__
+ ///
+ /// Previous versions of ANTLR did a poor job of their recovery within loops.
/// A single mismatch token or missing token would force the parser to bail
- /// out of the entire rules surrounding the loop. So, for rule
- ///
- ///
+ /// out of the entire rules surrounding the loop. So, for rule
+ ///
+ ///
/// classDef : 'class' ID '{' member* '}'
- ///
- ///
+ ///
+ ///
/// input with an extra token between members would force the parser to
/// consume until it found the next class definition rather than the next
/// member definition of the current class.
- ///
- /// This functionality cost a little bit of effort because the parser has to
+ ///
+ /// This functionality cost a little bit of effort because the parser has to
/// compare token set at the start of the loop and at each iteration. If for
/// some reason speed is suffering for you, you can turn off this
- /// functionality by simply overriding this method as a blank { }.
+ /// functionality by simply overriding this method as a blank { }.
+ ///
public func sync(_ recognizer: Parser) throws {
- let s: ATNState = recognizer.getInterpreter().atn.states[recognizer.getState()]!
+ let s = recognizer.getInterpreter().atn.states[recognizer.getState()]!
// errPrint("sync @ "+s.stateNumber+"="+s.getClass().getSimpleName());
// If already recovering, don't try to sync
if inErrorRecoveryMode(recognizer) {
return
}
- let tokens: TokenStream = getTokenStream(recognizer)
- let la: Int = try tokens.LA(1)
+ let tokens = getTokenStream(recognizer)
+ let la = try tokens.LA(1)
// try cheaper subset first; might get lucky. seems to shave a wee bit off
- //let set : IntervalSet = recognizer.getATN().nextTokens(s)
-
- if try recognizer.getATN().nextTokens(s).contains(CommonToken.EPSILON) {
- return
- }
-
- if try recognizer.getATN().nextTokens(s).contains(la) {
+ let nextToks = recognizer.getATN().nextTokens(s)
+ if nextToks.contains(CommonToken.EPSILON) || nextToks.contains(la) {
return
}
@@ -221,15 +218,14 @@ public class DefaultErrorStrategy: ANTLRErrorStrategy {
if try singleTokenDeletion(recognizer) != nil {
return
}
- throw try ANTLRException.recognition(e: InputMismatchException(recognizer))
+ throw ANTLRException.recognition(e: InputMismatchException(recognizer))
case ATNState.PLUS_LOOP_BACK: fallthrough
case ATNState.STAR_LOOP_BACK:
// errPrint("at loop back: "+s.getClass().getSimpleName());
- try reportUnwantedToken(recognizer)
- let expecting: IntervalSet = try recognizer.getExpectedTokens()
- let whatFollowsLoopIterationOrRule: IntervalSet =
- try expecting.or(try getErrorRecoverySet(recognizer)) as! IntervalSet
+ reportUnwantedToken(recognizer)
+ let expecting = try recognizer.getExpectedTokens()
+ let whatFollowsLoopIterationOrRule = expecting.or(getErrorRecoverySet(recognizer)) as! IntervalSet
try consumeUntil(recognizer, whatFollowsLoopIterationOrRule)
break
@@ -239,258 +235,274 @@ public class DefaultErrorStrategy: ANTLRErrorStrategy {
}
}
- /// This is called by {@link #reportError} when the exception is a
- /// {@link org.antlr.v4.runtime.NoViableAltException}.
- ///
+ ///
+ /// This is called by _#reportError_ when the exception is a
+ /// _org.antlr.v4.runtime.NoViableAltException_.
+ ///
/// - seealso: #reportError
- ///
+ ///
/// - parameter recognizer: the parser instance
/// - parameter e: the recognition exception
+ ///
internal func reportNoViableAlternative(_ recognizer: Parser,
- _ e: NoViableAltException) throws {
- let tokens: TokenStream? = getTokenStream(recognizer)
+ _ e: NoViableAltException) {
+ let tokens = getTokenStream(recognizer)
var input: String
- if let tokens = tokens {
- if e.getStartToken().getType() == CommonToken.EOF {
- input = ""
- } else {
+ if e.getStartToken().getType() == CommonToken.EOF {
+ input = ""
+ }
+ else {
+ do {
input = try tokens.getText(e.getStartToken(), e.getOffendingToken())
}
- } else {
- input = ""
+ catch {
+ input = ""
+ }
}
- let msg: String = "no viable alternative at input " + escapeWSAndQuote(input)
+ let msg = "no viable alternative at input " + escapeWSAndQuote(input)
recognizer.notifyErrorListeners(e.getOffendingToken(), msg, e)
}
- /// This is called by {@link #reportError} when the exception is an
- /// {@link org.antlr.v4.runtime.InputMismatchException}.
- ///
+ ///
+ /// This is called by _#reportError_ when the exception is an
+ /// _org.antlr.v4.runtime.InputMismatchException_.
+ ///
/// - seealso: #reportError
- ///
+ ///
/// - parameter recognizer: the parser instance
/// - parameter e: the recognition exception
+ ///
internal func reportInputMismatch(_ recognizer: Parser,
_ e: InputMismatchException) {
- let msg: String = "mismatched input " + getTokenErrorDisplay(e.getOffendingToken()) +
+ let msg = "mismatched input " + getTokenErrorDisplay(e.getOffendingToken()) +
" expecting " + e.getExpectedTokens()!.toString(recognizer.getVocabulary())
recognizer.notifyErrorListeners(e.getOffendingToken(), msg, e)
}
- /// This is called by {@link #reportError} when the exception is a
- /// {@link org.antlr.v4.runtime.FailedPredicateException}.
- ///
+ ///
+ /// This is called by _#reportError_ when the exception is a
+ /// _org.antlr.v4.runtime.FailedPredicateException_.
+ ///
/// - seealso: #reportError
- ///
+ ///
/// - parameter recognizer: the parser instance
/// - parameter e: the recognition exception
+ ///
internal func reportFailedPredicate(_ recognizer: Parser,
_ e: FailedPredicateException) {
- let ruleName: String = recognizer.getRuleNames()[recognizer._ctx!.getRuleIndex()]
- let msg: String = "rule " + ruleName + " " + e.message! // e.getMessage()
+ let ruleName = recognizer.getRuleNames()[recognizer._ctx!.getRuleIndex()]
+ let msg = "rule \(ruleName) \(e.message!)"
recognizer.notifyErrorListeners(e.getOffendingToken(), msg, e)
}
+ ///
/// This method is called to report a syntax error which requires the removal
/// of a token from the input stream. At the time this method is called, the
- /// erroneous symbol is current {@code LT(1)} symbol and has not yet been
+ /// erroneous symbol is current `LT(1)` symbol and has not yet been
/// removed from the input stream. When this method returns,
- /// {@code recognizer} is in error recovery mode.
- ///
- /// This method is called when {@link #singleTokenDeletion} identifies
+ /// `recognizer` is in error recovery mode.
+ ///
+ /// This method is called when _#singleTokenDeletion_ identifies
/// single-token deletion as a viable recovery strategy for a mismatched
- /// input error.
- ///
- /// The default implementation simply returns if the handler is already in
- /// error recovery mode. Otherwise, it calls {@link #beginErrorCondition} to
+ /// input error.
+ ///
+ /// The default implementation simply returns if the handler is already in
+ /// error recovery mode. Otherwise, it calls _#beginErrorCondition_ to
/// enter error recovery mode, followed by calling
- /// {@link org.antlr.v4.runtime.Parser#notifyErrorListeners}.
- ///
+ /// _org.antlr.v4.runtime.Parser#notifyErrorListeners_.
+ ///
/// - parameter recognizer: the parser instance
- internal func reportUnwantedToken(_ recognizer: Parser) throws {
+ ///
+ internal func reportUnwantedToken(_ recognizer: Parser) {
if inErrorRecoveryMode(recognizer) {
return
}
beginErrorCondition(recognizer)
- let t: Token = try recognizer.getCurrentToken()
- let tokenName: String = getTokenErrorDisplay(t)
- let expecting: IntervalSet = try getExpectedTokens(recognizer)
- let msg: String = "extraneous input " + tokenName + " expecting " +
- expecting.toString(recognizer.getVocabulary())
+ let t = try? recognizer.getCurrentToken()
+ let tokenName = getTokenErrorDisplay(t)
+ let expecting = (try? getExpectedTokens(recognizer)) ?? IntervalSet.EMPTY_SET
+ let msg = "extraneous input \(tokenName) expecting \(expecting.toString(recognizer.getVocabulary()))"
recognizer.notifyErrorListeners(t, msg, nil)
}
+ ///
/// This method is called to report a syntax error which requires the
/// insertion of a missing token into the input stream. At the time this
/// method is called, the missing token has not yet been inserted. When this
- /// method returns, {@code recognizer} is in error recovery mode.
- ///
- /// This method is called when {@link #singleTokenInsertion} identifies
+ /// method returns, `recognizer` is in error recovery mode.
+ ///
+ /// This method is called when _#singleTokenInsertion_ identifies
/// single-token insertion as a viable recovery strategy for a mismatched
- /// input error.
- ///
- /// The default implementation simply returns if the handler is already in
- /// error recovery mode. Otherwise, it calls {@link #beginErrorCondition} to
+ /// input error.
+ ///
+ /// The default implementation simply returns if the handler is already in
+ /// error recovery mode. Otherwise, it calls _#beginErrorCondition_ to
/// enter error recovery mode, followed by calling
- /// {@link org.antlr.v4.runtime.Parser#notifyErrorListeners}.
- ///
+ /// _org.antlr.v4.runtime.Parser#notifyErrorListeners_.
+ ///
/// - parameter recognizer: the parser instance
- internal func reportMissingToken(_ recognizer: Parser) throws {
+ ///
+ internal func reportMissingToken(_ recognizer: Parser) {
if inErrorRecoveryMode(recognizer) {
return
}
beginErrorCondition(recognizer)
- let t: Token = try recognizer.getCurrentToken()
- let expecting: IntervalSet = try getExpectedTokens(recognizer)
- let msg: String = "missing " + expecting.toString(recognizer.getVocabulary()) +
- " at " + getTokenErrorDisplay(t)
+ let t = try? recognizer.getCurrentToken()
+ let expecting = (try? getExpectedTokens(recognizer)) ?? IntervalSet.EMPTY_SET
+ let msg = "missing \(expecting.toString(recognizer.getVocabulary())) at \(getTokenErrorDisplay(t))"
recognizer.notifyErrorListeners(t, msg, nil)
}
- /// {@inheritDoc}
- ///
- /// The default implementation attempts to recover from the mismatched input
+ ///
+ ///
+ ///
+ /// The default implementation attempts to recover from the mismatched input
/// by using single token insertion and deletion as described below. If the
/// recovery attempt fails, this method throws an
- /// {@link org.antlr.v4.runtime.InputMismatchException}.
- ///
- /// EXTRA TOKEN (single token deletion)
- ///
- /// {@code LA(1)} is not what we are looking for. If {@code LA(2)} has the
- /// right token, however, then assume {@code LA(1)} is some extra spurious
+ /// _org.antlr.v4.runtime.InputMismatchException_.
+ ///
+ /// __EXTRA TOKEN__ (single token deletion)
+ ///
+ /// `LA(1)` is not what we are looking for. If `LA(2)` has the
+ /// right token, however, then assume `LA(1)` is some extra spurious
/// token and delete it. Then consume and return the next token (which was
- /// the {@code LA(2)} token) as the successful result of the match operation.
- ///
- /// This recovery strategy is implemented by {@link #singleTokenDeletion}.
- ///
- /// MISSING TOKEN (single token insertion)
- ///
- /// If current token (at {@code LA(1)}) is consistent with what could come
- /// after the expected {@code LA(1)} token, then assume the token is missing
- /// and use the parser's {@link org.antlr.v4.runtime.TokenFactory} to create it on the fly. The
+ /// the `LA(2)` token) as the successful result of the match operation.
+ ///
+ /// This recovery strategy is implemented by _#singleTokenDeletion_.
+ ///
+ /// __MISSING TOKEN__ (single token insertion)
+ ///
+ /// If current token (at `LA(1)`) is consistent with what could come
+ /// after the expected `LA(1)` token, then assume the token is missing
+ /// and use the parser's _org.antlr.v4.runtime.TokenFactory_ to create it on the fly. The
/// "insertion" is performed by returning the created token as the successful
- /// result of the match operation.
- ///
- /// This recovery strategy is implemented by {@link #singleTokenInsertion}.
- ///
- /// EXAMPLE
- ///
- /// For example, Input {@code i=(3;} is clearly missing the {@code ')'}. When
- /// the parser returns from the nested call to {@code expr}, it will have
- /// call chain:
- ///
- ///
+ /// result of the match operation.
+ ///
+ /// This recovery strategy is implemented by _#singleTokenInsertion_.
+ ///
+ /// __EXAMPLE__
+ ///
+ /// For example, Input `i=(3;` is clearly missing the `')'`. When
+ /// the parser returns from the nested call to `expr`, it will have
+ /// call chain:
+ ///
+ ///
/// stat → expr → atom
- ///
- ///
- /// and it will be trying to match the {@code ')'} at this point in the
+ ///
+ ///
+ /// and it will be trying to match the `')'` at this point in the
/// derivation:
- ///
- ///
+ ///
+ ///
/// => ID '=' '(' INT ')' ('+' atom)* ';'
/// ^
- ///
- ///
- /// The attempt to match {@code ')'} will fail when it sees {@code ';'} and
- /// call {@link #recoverInline}. To recover, it sees that {@code LA(1)==';'}
- /// is in the set of tokens that can follow the {@code ')'} token reference
- /// in rule {@code atom}. It can assume that you forgot the {@code ')'}.
+ ///
+ ///
+ /// The attempt to match `')'` will fail when it sees `';'` and
+ /// call _#recoverInline_. To recover, it sees that `LA(1)==';'`
+ /// is in the set of tokens that can follow the `')'` token reference
+ /// in rule `atom`. It can assume that you forgot the `')'`.
+ ///
public func recoverInline(_ recognizer: Parser) throws -> Token {
// SINGLE TOKEN DELETION
- let matchedSymbol: Token? = try singleTokenDeletion(recognizer)
- if matchedSymbol != nil {
+ let matchedSymbol = try singleTokenDeletion(recognizer)
+ if let matchedSymbol = matchedSymbol {
// we have deleted the extra token.
// now, move past ttype token as if all were ok
try recognizer.consume()
- return matchedSymbol!
+ return matchedSymbol
}
// SINGLE TOKEN INSERTION
if try singleTokenInsertion(recognizer) {
return try getMissingSymbol(recognizer)
}
- throw try ANTLRException.recognition(e: InputMismatchException(recognizer))
- // throw try ANTLRException.InputMismatch(e: InputMismatchException(recognizer) )
- //RuntimeException("InputMismatchException")
// even that didn't work; must throw the exception
- //throwException() /* throw InputMismatchException(recognizer); */
+ throw ANTLRException.recognition(e: InputMismatchException(recognizer))
}
+ ///
/// This method implements the single-token insertion inline error recovery
- /// strategy. It is called by {@link #recoverInline} if the single-token
+ /// strategy. It is called by _#recoverInline_ if the single-token
/// deletion strategy fails to recover from the mismatched input. If this
- /// method returns {@code true}, {@code recognizer} will be in error recovery
+ /// method returns `true`, `recognizer` will be in error recovery
/// mode.
- ///
- /// This method determines whether or not single-token insertion is viable by
- /// checking if the {@code LA(1)} input symbol could be successfully matched
- /// if it were instead the {@code LA(2)} symbol. If this method returns
- /// {@code true}, the caller is responsible for creating and inserting a
- /// token with the correct type to produce this behavior.
- ///
+ ///
+ /// This method determines whether or not single-token insertion is viable by
+ /// checking if the `LA(1)` input symbol could be successfully matched
+ /// if it were instead the `LA(2)` symbol. If this method returns
+ /// `true`, the caller is responsible for creating and inserting a
+ /// token with the correct type to produce this behavior.
+ ///
/// - parameter recognizer: the parser instance
- /// - returns: {@code true} if single-token insertion is a viable recovery
- /// strategy for the current mismatched input, otherwise {@code false}
+ /// - returns: `true` if single-token insertion is a viable recovery
+ /// strategy for the current mismatched input, otherwise `false`
+ ///
internal func singleTokenInsertion(_ recognizer: Parser) throws -> Bool {
- let currentSymbolType: Int = try getTokenStream(recognizer).LA(1)
+ let currentSymbolType = try getTokenStream(recognizer).LA(1)
// if current token is consistent with what could come after current
// ATN state, then we know we're missing a token; error recovery
// is free to conjure up and insert the missing token
- let currentState: ATNState = recognizer.getInterpreter().atn.states[recognizer.getState()]!
- let next: ATNState = currentState.transition(0).target
- let atn: ATN = recognizer.getInterpreter().atn
- let expectingAtLL2: IntervalSet = try atn.nextTokens(next, recognizer._ctx)
+ let currentState = recognizer.getInterpreter().atn.states[recognizer.getState()]!
+ let next = currentState.transition(0).target
+ let atn = recognizer.getInterpreter().atn
+ let expectingAtLL2 = atn.nextTokens(next, recognizer._ctx)
// print("LT(2) set="+expectingAtLL2.toString(recognizer.getTokenNames()));
if expectingAtLL2.contains(currentSymbolType) {
- try reportMissingToken(recognizer)
+ reportMissingToken(recognizer)
return true
}
return false
}
+ ///
/// This method implements the single-token deletion inline error recovery
- /// strategy. It is called by {@link #recoverInline} to attempt to recover
+ /// strategy. It is called by _#recoverInline_ to attempt to recover
/// from mismatched input. If this method returns null, the parser and error
/// handler state will not have changed. If this method returns non-null,
- /// {@code recognizer} will not be in error recovery mode since the
+ /// `recognizer` will __not__ be in error recovery mode since the
/// returned token was a successful match.
- ///
- /// If the single-token deletion is successful, this method calls
- /// {@link #reportUnwantedToken} to report the error, followed by
- /// {@link org.antlr.v4.runtime.Parser#consume} to actually "delete" the extraneous token. Then,
- /// before returning {@link #reportMatch} is called to signal a successful
- /// match.
- ///
+ ///
+ /// If the single-token deletion is successful, this method calls
+ /// _#reportUnwantedToken_ to report the error, followed by
+ /// _org.antlr.v4.runtime.Parser#consume_ to actually "delete" the extraneous token. Then,
+ /// before returning _#reportMatch_ is called to signal a successful
+ /// match.
+ ///
/// - parameter recognizer: the parser instance
- /// - returns: the successfully matched {@link org.antlr.v4.runtime.Token} instance if single-token
+ /// - returns: the successfully matched _org.antlr.v4.runtime.Token_ instance if single-token
/// deletion successfully recovers from the mismatched input, otherwise
- /// {@code null}
+ /// `null`
+ ///
internal func singleTokenDeletion(_ recognizer: Parser) throws -> Token? {
- let nextTokenType: Int = try getTokenStream(recognizer).LA(2)
- let expecting: IntervalSet = try getExpectedTokens(recognizer)
+ let nextTokenType = try getTokenStream(recognizer).LA(2)
+ let expecting = try getExpectedTokens(recognizer)
if expecting.contains(nextTokenType) {
- try reportUnwantedToken(recognizer)
+ reportUnwantedToken(recognizer)
+ ///
/// errPrint("recoverFromMismatchedToken deleting "+
/// ((TokenStream)getTokenStream(recognizer)).LT(1)+
/// " since "+((TokenStream)getTokenStream(recognizer)).LT(2)+
/// " is what we want");
+ ///
try recognizer.consume() // simply delete extra token
// we want to return the token we're actually matching
- let matchedSymbol: Token = try recognizer.getCurrentToken()
+ let matchedSymbol = try recognizer.getCurrentToken()
reportMatch(recognizer) // we know current token is correct
return matchedSymbol
}
return nil
}
+ ///
/// Conjure up a missing token during error recovery.
- ///
+ ///
/// The recognizer attempts to recover from single missing
/// symbols. But, actions might refer to that missing symbol.
/// For example, x=ID {f($x);}. The action clearly assumes
@@ -507,31 +519,33 @@ public class DefaultErrorStrategy: ANTLRErrorStrategy {
/// a CommonToken of the appropriate type. The text will be the token.
/// If you change what tokens must be created by the lexer,
/// override this method to create the appropriate tokens.
-
+ ///
internal func getTokenStream(_ recognizer: Parser) -> TokenStream {
return recognizer.getInputStream() as! TokenStream
}
internal func getMissingSymbol(_ recognizer: Parser) throws -> Token {
- let currentSymbol: Token = try recognizer.getCurrentToken()
- let expecting: IntervalSet = try getExpectedTokens(recognizer)
- let expectedTokenType: Int = expecting.getMinElement() // get any element
+ let currentSymbol = try recognizer.getCurrentToken()
+ let expecting = try getExpectedTokens(recognizer)
+ let expectedTokenType = expecting.getMinElement() // get any element
var tokenText: String
if expectedTokenType == CommonToken.EOF {
tokenText = ""
} else {
tokenText = ""
}
- var current: Token = currentSymbol
- let lookback: Token? = try getTokenStream(recognizer).LT(-1)
+ var current = currentSymbol
+ let lookback = try getTokenStream(recognizer).LT(-1)
if current.getType() == CommonToken.EOF && lookback != nil {
current = lookback!
}
- let token = recognizer.getTokenFactory().create((current.getTokenSource(), current.getTokenSource()!.getInputStream()), expectedTokenType, tokenText,
- CommonToken.DEFAULT_CHANNEL,
- -1, -1,
- current.getLine(), current.getCharPositionInLine())
+ let token = recognizer.getTokenFactory().create(
+ current.getTokenSourceAndStream(),
+ expectedTokenType, tokenText,
+ CommonToken.DEFAULT_CHANNEL,
+ -1, -1,
+ current.getLine(), current.getCharPositionInLine())
return token
}
@@ -541,6 +555,7 @@ public class DefaultErrorStrategy: ANTLRErrorStrategy {
return try recognizer.getExpectedTokens()
}
+ ///
/// 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
@@ -548,23 +563,24 @@ public class DefaultErrorStrategy: ANTLRErrorStrategy {
/// 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.
+ ///
internal func getTokenErrorDisplay(_ t: Token?) -> String {
- if t == nil {
+ guard let t = t else {
return ""
}
- var s: String? = getSymbolText(t!)
+ var s = getSymbolText(t)
if s == nil {
- if getSymbolType(t!) == CommonToken.EOF {
+ if getSymbolType(t) == CommonToken.EOF {
s = ""
} else {
- s = "<\(getSymbolType(t!))>"
+ s = "<\(getSymbolType(t))>"
}
}
return escapeWSAndQuote(s!)
}
- internal func getSymbolText(_ symbol: Token) -> String {
- return symbol.getText()!
+ internal func getSymbolText(_ symbol: Token) -> String? {
+ return symbol.getText()
}
internal func getSymbolType(_ symbol: Token) -> Int {
@@ -580,6 +596,7 @@ public class DefaultErrorStrategy: ANTLRErrorStrategy {
return "'" + s + "'"
}
+ ///
/// Compute the error recovery set for the current rule. During
/// rule invocation, the parser pushes the set of tokens that can
/// follow that rule reference on the stack; this amounts to
@@ -588,9 +605,9 @@ public class DefaultErrorStrategy: ANTLRErrorStrategy {
/// This local follow set only includes tokens
/// from within the rule; i.e., the FIRST computation done by
/// ANTLR stops at the end of a rule.
- ///
+ ///
/// EXAMPLE
- ///
+ ///
/// When you find a "no viable alt exception", the input is not
/// consistent with any of the alternatives for rule r. The best
/// thing to do is to consume tokens until you see something that
@@ -598,9 +615,9 @@ public class DefaultErrorStrategy: ANTLRErrorStrategy {
/// You don't want the exact set of viable next tokens because the
/// input might just be missing a token--you might consume the
/// rest of the input looking for one of the missing tokens.
- ///
+ ///
/// Consider grammar:
- ///
+ ///
/// a : '[' b ']'
/// | '(' b ')'
/// ;
@@ -608,30 +625,30 @@ public class DefaultErrorStrategy: ANTLRErrorStrategy {
/// c : ID
/// | INT
/// ;
- ///
+ ///
/// At each rule invocation, the set of tokens that could follow
/// that rule is pushed on a stack. Here are the various
/// context-sensitive follow sets:
- ///
+ ///
/// FOLLOW(b1_in_a) = FIRST(']') = ']'
/// FOLLOW(b2_in_a) = FIRST(')') = ')'
/// FOLLOW(c_in_b) = FIRST('^') = '^'
- ///
+ ///
/// Upon erroneous input "[]", the call chain is
- ///
+ ///
/// a -> b -> c
- ///
+ ///
/// and, hence, the follow context stack is:
- ///
+ ///
/// depth follow set start of rule execution
/// 0 a (from main())
/// 1 ']' b
/// 2 '^' c
- ///
+ ///
/// Notice that ')' is not included, because b would have to have
/// been called from a different context in rule a for ')' to be
/// included.
- ///
+ ///
/// For error recovery, we cannot consider FOLLOW(c)
/// (context-sensitive or otherwise). We need the combined set of
/// all context-sensitive FOLLOW sets--the set of all tokens that
@@ -648,53 +665,55 @@ public class DefaultErrorStrategy: ANTLRErrorStrategy {
/// the same recovery set and doesn't consume anything. Rule b
/// exits normally returning to rule a. Now it finds the ']' (and
/// with the successful match exits errorRecovery mode).
- ///
+ ///
/// So, you can see that the parser walks up the call chain looking
/// for the token that was a member of the recovery set.
- ///
+ ///
/// Errors are not generated in errorRecovery mode.
- ///
+ ///
/// ANTLR's error recovery mechanism is based upon original ideas:
- ///
+ ///
/// "Algorithms + Data Structures = Programs" by Niklaus Wirth
- ///
+ ///
/// and
- ///
+ ///
/// "A note on error recovery in recursive descent parsers":
/// http://portal.acm.org/citation.cfm?id=947902.947905
- ///
+ ///
/// Later, Josef Grosch had some good ideas:
- ///
+ ///
/// "Efficient and Comfortable Error Recovery in Recursive Descent
/// Parsers":
/// ftp://www.cocolab.com/products/cocktail/doca4.ps/ell.ps.zip
- ///
+ ///
/// Like Grosch I implement context-sensitive FOLLOW sets that are combined
/// at run-time upon error to avoid overhead during parsing.
- internal func getErrorRecoverySet(_ recognizer: Parser) throws -> IntervalSet {
- let atn: ATN = recognizer.getInterpreter().atn
+ ///
+ internal func getErrorRecoverySet(_ recognizer: Parser) -> IntervalSet {
+ let atn = recognizer.getInterpreter().atn
var ctx: RuleContext? = recognizer._ctx
- let recoverSet: IntervalSet = try IntervalSet()
- while let ctxWrap = ctx , ctxWrap.invokingState >= 0 {
+ let recoverSet = IntervalSet()
+ while let ctxWrap = ctx, ctxWrap.invokingState >= 0 {
// compute what follows who invoked us
- let invokingState: ATNState = atn.states[ctxWrap.invokingState]!
- let rt: RuleTransition = invokingState.transition(0) as! RuleTransition
- let follow: IntervalSet = try atn.nextTokens(rt.followState)
- try recoverSet.addAll(follow)
+ let invokingState = atn.states[ctxWrap.invokingState]!
+ let rt = invokingState.transition(0) as! RuleTransition
+ let follow = atn.nextTokens(rt.followState)
+ try! recoverSet.addAll(follow)
ctx = ctxWrap.parent
}
- try recoverSet.remove(CommonToken.EPSILON)
+ try! recoverSet.remove(CommonToken.EPSILON)
// print("recover set "+recoverSet.toString(recognizer.getTokenNames()));
return recoverSet
}
+ ///
/// Consume tokens until one matches the given token set.
+ ///
internal func consumeUntil(_ recognizer: Parser, _ set: IntervalSet) throws {
// errPrint("consumeUntil("+set.toString(recognizer.getTokenNames())+")");
- var ttype: Int = try getTokenStream(recognizer).LA(1)
+ var ttype = try getTokenStream(recognizer).LA(1)
while ttype != CommonToken.EOF && !set.contains(ttype) {
//print("consume during recover LA(1)="+getTokenNames()[input.LA(1)]);
-// getTokenStream(recognizer).consume();
try recognizer.consume()
ttype = try getTokenStream(recognizer).LA(1)
}
diff --git a/runtime/Swift/Sources/Antlr4/DiagnosticErrorListener.swift b/runtime/Swift/Sources/Antlr4/DiagnosticErrorListener.swift
index 75681f617..4109f672b 100644
--- a/runtime/Swift/Sources/Antlr4/DiagnosticErrorListener.swift
+++ b/runtime/Swift/Sources/Antlr4/DiagnosticErrorListener.swift
@@ -1,45 +1,53 @@
+///
/// Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
/// Use of this file is governed by the BSD 3-clause license that
/// can be found in the LICENSE.txt file in the project root.
+///
-/// This implementation of {@link org.antlr.v4.runtime.ANTLRErrorListener} can be used to identify
+///
+/// This implementation of _org.antlr.v4.runtime.ANTLRErrorListener_ can be used to identify
/// certain potential correctness and performance problems in grammars. "Reports"
-/// are made by calling {@link org.antlr.v4.runtime.Parser#notifyErrorListeners} with the appropriate
+/// are made by calling _org.antlr.v4.runtime.Parser#notifyErrorListeners_ with the appropriate
/// message.
-///
-///
-/// - Ambiguities: These are cases where more than one path through the
-/// grammar can match the input.
-/// - Weak context sensitivity: These are cases where full-context
+///
+/// * __Ambiguities__: These are cases where more than one path through the
+/// grammar can match the input.
+/// * __Weak context sensitivity__: These are cases where full-context
/// prediction resolved an SLL conflict to a unique alternative which equaled the
-/// minimum alternative of the SLL conflict.
-/// - Strong (forced) context sensitivity: These are cases where the
+/// minimum alternative of the SLL conflict.
+/// * __Strong (forced) context sensitivity__: These are cases where the
/// full-context prediction resolved an SLL conflict to a unique alternative,
-/// and the minimum alternative of the SLL conflict was found to not be
+/// __and__ the minimum alternative of the SLL conflict was found to not be
/// a truly viable alternative. Two-stage parsing cannot be used for inputs where
-/// this situation occurs.
-///
-///
+/// this situation occurs.
+///
/// - Sam Harwell
+///
import Foundation
public class DiagnosticErrorListener: BaseErrorListener {
- /// When {@code true}, only exactly known ambiguities are reported.
+ ///
+ /// When `true`, only exactly known ambiguities are reported.
+ ///
internal final var exactOnly: Bool
- /// Initializes a new instance of {@link org.antlr.v4.runtime.DiagnosticErrorListener} which only
+ ///
+ /// Initializes a new instance of _org.antlr.v4.runtime.DiagnosticErrorListener_ which only
/// reports exact ambiguities.
+ ///
public convenience override init() {
self.init(true)
}
- /// Initializes a new instance of {@link org.antlr.v4.runtime.DiagnosticErrorListener}, specifying
+ ///
+ /// Initializes a new instance of _org.antlr.v4.runtime.DiagnosticErrorListener_, specifying
/// whether all ambiguities or only exact ambiguities are reported.
- ///
- /// - parameter exactOnly: {@code true} to report only exact ambiguities, otherwise
- /// {@code false} to report all ambiguities.
+ ///
+ /// - parameter exactOnly: `true` to report only exact ambiguities, otherwise
+ /// `false` to report all ambiguities.
+ ///
public init(_ exactOnly: Bool) {
self.exactOnly = exactOnly
}
@@ -51,16 +59,16 @@ public class DiagnosticErrorListener: BaseErrorListener {
_ stopIndex: Int,
_ exact: Bool,
_ ambigAlts: BitSet,
- _ configs: ATNConfigSet) throws {
+ _ configs: ATNConfigSet) {
if exactOnly && !exact {
return
}
let decision = getDecisionDescription(recognizer, dfa)
- let conflictingAlts = try getConflictingAlts(ambigAlts, configs)
- let text = try recognizer.getTokenStream()!.getText(Interval.of(startIndex, stopIndex))
+ let conflictingAlts = getConflictingAlts(ambigAlts, configs)
+ let text = getTextInInterval(recognizer, startIndex, stopIndex)
let message = "reportAmbiguity d=\(decision): ambigAlts=\(conflictingAlts), input='\(text)'"
- try recognizer.notifyErrorListeners(message)
+ recognizer.notifyErrorListeners(message)
}
override
@@ -69,11 +77,11 @@ public class DiagnosticErrorListener: BaseErrorListener {
_ startIndex: Int,
_ stopIndex: Int,
_ conflictingAlts: BitSet?,
- _ configs: ATNConfigSet) throws {
+ _ configs: ATNConfigSet) {
let decision = getDecisionDescription(recognizer, dfa)
- let text = try recognizer.getTokenStream()!.getText(Interval.of(startIndex, stopIndex))
+ let text = getTextInInterval(recognizer, startIndex, stopIndex)
let message = "reportAttemptingFullContext d=\(decision), input='\(text)'"
- try recognizer.notifyErrorListeners(message)
+ recognizer.notifyErrorListeners(message)
}
override
@@ -82,11 +90,11 @@ public class DiagnosticErrorListener: BaseErrorListener {
_ startIndex: Int,
_ stopIndex: Int,
_ prediction: Int,
- _ configs: ATNConfigSet) throws {
+ _ configs: ATNConfigSet) {
let decision = getDecisionDescription(recognizer, dfa)
- let text = try recognizer.getTokenStream()!.getText(Interval.of(startIndex, stopIndex))
+ let text = getTextInInterval(recognizer, startIndex, stopIndex)
let message = "reportContextSensitivity d=\(decision), input='\(text)'"
- try recognizer.notifyErrorListeners(message)
+ recognizer.notifyErrorListeners(message)
}
internal func getDecisionDescription(_ recognizer: Parser, _ dfa: DFA) -> String {
@@ -106,21 +114,28 @@ public class DiagnosticErrorListener: BaseErrorListener {
return "\(decision) (\(ruleName))"
}
+ ///
/// Computes the set of conflicting or ambiguous alternatives from a
/// configuration set, if that information was not already provided by the
/// parser.
- ///
+ ///
/// - parameter reportedAlts: The set of conflicting or ambiguous alternatives, as
/// reported by the parser.
/// - parameter configs: The conflicting or ambiguous configuration set.
- /// - returns: Returns {@code reportedAlts} if it is not {@code null}, otherwise
- /// returns the set of alternatives represented in {@code configs}.
- internal func getConflictingAlts(_ reportedAlts: BitSet?, _ configs: ATNConfigSet) throws -> BitSet {
- if reportedAlts != nil {
- return reportedAlts!
- }
- let result = try configs.getAltBitSet()
- return result
+ /// - returns: Returns `reportedAlts` if it is not `null`, otherwise
+ /// returns the set of alternatives represented in `configs`.
+ ///
+ internal func getConflictingAlts(_ reportedAlts: BitSet?, _ configs: ATNConfigSet) -> BitSet {
+ return reportedAlts ?? configs.getAltBitSet()
+ }
+}
+
+
+fileprivate func getTextInInterval(_ recognizer: Parser, _ startIndex: Int, _ stopIndex: Int) -> String {
+ do {
+ return try recognizer.getTokenStream()?.getText(Interval.of(startIndex, stopIndex)) ?? ""
+ }
+ catch {
+ return ""
}
-
}
diff --git a/runtime/Swift/Sources/Antlr4/FailedPredicateException.swift b/runtime/Swift/Sources/Antlr4/FailedPredicateException.swift
index 529ce372f..c4e2bd310 100644
--- a/runtime/Swift/Sources/Antlr4/FailedPredicateException.swift
+++ b/runtime/Swift/Sources/Antlr4/FailedPredicateException.swift
@@ -1,36 +1,28 @@
+///
/// Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
/// Use of this file is governed by the BSD 3-clause license that
/// can be found in the LICENSE.txt file in the project root.
+///
+///
/// A semantic predicate failed during validation. Validation of predicates
/// occurs when normally parsing the alternative just like matching a token.
/// Disambiguating predicate evaluation occurs when we test a predicate during
/// prediction.
-public class FailedPredicateException: RecognitionException {
+///
+public class FailedPredicateException: RecognitionException {
private final var ruleIndex: Int
private final var predicateIndex: Int
private final var predicate: String?
- public convenience init(_ recognizer: Parser) throws {
- try self.init(recognizer, nil)
- }
+ public init(_ recognizer: Parser, _ predicate: String? = nil, _ message: String? = nil) {
+ let s = recognizer.getInterpreter().atn.states[recognizer.getState()]!
- public convenience init(_ recognizer: Parser, _ predicate: String?)throws {
- try self.init(recognizer, predicate, nil)
- }
-
- public init(_ recognizer: Parser,
- _ predicate: String?,
- _ message: String?) throws
- {
-
- let s: ATNState = recognizer.getInterpreter().atn.states[recognizer.getState()]!
-
- let trans: AbstractPredicateTransition = s.transition(0) as! AbstractPredicateTransition
- if trans is PredicateTransition {
- self.ruleIndex = (trans as! PredicateTransition).ruleIndex
- self.predicateIndex = (trans as! PredicateTransition).predIndex
+ let trans = s.transition(0) as! AbstractPredicateTransition
+ if let predex = trans as? PredicateTransition {
+ self.ruleIndex = predex.ruleIndex
+ self.predicateIndex = predex.predIndex
}
else {
self.ruleIndex = 0
@@ -39,9 +31,10 @@ public class FailedPredicateException: RecognitionException
self.predicate = predicate
- super.init(FailedPredicateException.formatMessage(predicate!, message), recognizer , recognizer.getInputStream()!, recognizer._ctx)
-
- try self.setOffendingToken(recognizer.getCurrentToken())
+ super.init(recognizer, recognizer.getInputStream()!, recognizer._ctx, FailedPredicateException.formatMessage(predicate, message))
+ if let token = try? recognizer.getCurrentToken() {
+ setOffendingToken(token)
+ }
}
public func getRuleIndex() -> Int {
@@ -52,17 +45,17 @@ public class FailedPredicateException: RecognitionException
return predicateIndex
}
-
public func getPredicate() -> String? {
return predicate
}
- private static func formatMessage(_ predicate: String, _ message: String?) -> String {
+ private static func formatMessage(_ predicate: String?, _ message: String?) -> String {
if message != nil {
return message!
}
- return "failed predicate: {predicate}?" //String.format(Locale.getDefault(), "failed predicate: {%s}?", predicate);
+ let predstr = predicate ?? ""
+ return "failed predicate: {\(predstr)}?"
}
}
diff --git a/runtime/Swift/Sources/Antlr4/InputMismatchException.swift b/runtime/Swift/Sources/Antlr4/InputMismatchException.swift
index 32f9ac89e..8af781702 100644
--- a/runtime/Swift/Sources/Antlr4/InputMismatchException.swift
+++ b/runtime/Swift/Sources/Antlr4/InputMismatchException.swift
@@ -1,14 +1,20 @@
+///
/// Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
/// Use of this file is governed by the BSD 3-clause license that
/// can be found in the LICENSE.txt file in the project root.
+///
+///
/// This signifies any kind of mismatched input exceptions such as
/// when the current input does not match the expected token.
+///
-public class InputMismatchException: RecognitionException {
- public init(_ recognizer: Parser) throws {
+public class InputMismatchException: RecognitionException {
+ public init(_ recognizer: Parser) {
super.init(recognizer, recognizer.getInputStream()!, recognizer._ctx)
- self.setOffendingToken(try recognizer.getCurrentToken())
+ if let token = try? recognizer.getCurrentToken() {
+ setOffendingToken(token)
+ }
}
}
diff --git a/runtime/Swift/Sources/Antlr4/IntStream.swift b/runtime/Swift/Sources/Antlr4/IntStream.swift
index 69af63969..d56a3f62c 100644
--- a/runtime/Swift/Sources/Antlr4/IntStream.swift
+++ b/runtime/Swift/Sources/Antlr4/IntStream.swift
@@ -1,117 +1,112 @@
+///
/// Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
/// Use of this file is governed by the BSD 3-clause license that
/// can be found in the LICENSE.txt file in the project root.
+///
+///
/// A simple stream of symbols whose values are represented as integers. This
-/// interface provides marked ranges with support for a minimum level
+/// interface provides __marked ranges__ with support for a minimum level
/// of buffering necessary to implement arbitrary lookahead during prediction.
-/// For more information on marked ranges, see {@link #mark}.
-///
-/// Initializing Methods: Some methods in this interface have
+/// For more information on marked ranges, see _#mark_.
+///
+/// __Initializing Methods:__ Some methods in this interface have
/// unspecified behavior if no call to an initializing method has occurred after
-/// the stream was constructed. The following is a list of initializing methods:
-///
-///
-/// - {@link #LA}
-/// - {@link #consume}
-/// - {@link #size}
-///
-
+/// the stream was constructed. The following is a list of initializing methods:
+///
+/// * _#LA_
+/// * _#consume_
+/// * _#size_
+///
public protocol IntStream: class {
- /// The value returned by {@link #LA LA()} when the end of the stream is
- /// reached.
- //let EOF : Int = -1;
-
- /// The value returned by {@link #getSourceName} when the actual name of the
- /// underlying source is not known.
- //let UNKNOWN_SOURCE_NAME : String = "";
+ ///
/// Consumes the current symbol in the stream. This method has the following
/// effects:
- ///
- ///
- /// - Forward movement: The value of {@link #index index()}
- /// before calling this method is less than the value of {@code index()}
- /// after calling this method.
- /// - Ordered lookahead: The value of {@code LA(1)} before
- /// calling this method becomes the value of {@code LA(-1)} after calling
- /// this method.
- ///
- ///
- /// Note that calling this method does not guarantee that {@code index()} is
+ ///
+ /// * __Forward movement:__ The value of _#index index()_
+ /// before calling this method is less than the value of `index()`
+ /// after calling this method.
+ /// * __Ordered lookahead:__ The value of `LA(1)` before
+ /// calling this method becomes the value of `LA(-1)` after calling
+ /// this method.
+ ///
+ /// Note that calling this method does not guarantee that `index()` is
/// incremented by exactly 1, as that would preclude the ability to implement
- /// filtering streams (e.g. {@link org.antlr.v4.runtime.CommonTokenStream} which distinguishes
+ /// filtering streams (e.g. _org.antlr.v4.runtime.CommonTokenStream_ which distinguishes
/// between "on-channel" and "off-channel" tokens).
- ///
- /// - IllegalStateException if an attempt is made to consume the the
- /// end of the stream (i.e. if {@code LA(1)==}{@link #EOF EOF} before calling
- /// {@code consume}).
+ ///
+ /// - throws: _ANTLRError.illegalState_ if an attempt is made to consume the the
+ /// end of the stream (i.e. if `LA(1)==`_#EOF EOF_ before calling
+ /// `consume`).
+ ///
func consume() throws
- /// Gets the value of the symbol at offset {@code i} from the current
- /// position. When {@code i==1}, this method returns the value of the current
+ ///
+ /// Gets the value of the symbol at offset `i` from the current
+ /// position. When `i==1`, this method returns the value of the current
/// symbol in the stream (which is the next symbol to be consumed). When
- /// {@code i==-1}, this method returns the value of the previously read
+ /// `i==-1`, this method returns the value of the previously read
/// symbol in the stream. It is not valid to call this method with
- /// {@code i==0}, but the specific behavior is unspecified because this
+ /// `i==0`, but the specific behavior is unspecified because this
/// method is frequently called from performance-critical code.
- ///
- /// This method is guaranteed to succeed if any of the following are true:
- ///
- ///
- /// - {@code i>0}
- /// - {@code i==-1} and {@link #index index()} returns a value greater
- /// than the value of {@code index()} after the stream was constructed
- /// and {@code LA(1)} was called in that order. Specifying the current
- /// {@code index()} relative to the index after the stream was created
+ ///
+ /// This method is guaranteed to succeed if any of the following are true:
+ ///
+ /// * `i>0`
+ /// * `i==-1` and _#index index()_ returns a value greater
+ /// than the value of `index()` after the stream was constructed
+ /// and `LA(1)` was called in that order. Specifying the current
+ /// `index()` relative to the index after the stream was created
/// allows for filtering implementations that do not return every symbol
- /// from the underlying source. Specifying the call to {@code LA(1)}
- /// allows for lazily initialized streams.
- /// - {@code LA(i)} refers to a symbol consumed within a marked region
- /// that has not yet been released.
- ///
- ///
- /// If {@code i} represents a position at or beyond the end of the stream,
- /// this method returns {@link #EOF}.
- ///
- /// The return value is unspecified if {@code i<0} and fewer than {@code -i}
- /// calls to {@link #consume consume()} have occurred from the beginning of
- /// the stream before calling this method.
- ///
- /// - UnsupportedOperationException if the stream does not support
+ /// from the underlying source. Specifying the call to `LA(1)`
+ /// allows for lazily initialized streams.
+ /// * `LA(i)` refers to a symbol consumed within a marked region
+ /// that has not yet been released.
+ ///
+ /// If `i` represents a position at or beyond the end of the stream,
+ /// this method returns _#EOF_.
+ ///
+ /// The return value is unspecified if `i<0` and fewer than `-i`
+ /// calls to _#consume consume()_ have occurred from the beginning of
+ /// the stream before calling this method.
+ ///
+ /// - throws: _ANTLRError.unsupportedOperation_ if the stream does not support
/// retrieving the value of the specified symbol
+ ///
func LA(_ i: Int) throws -> Int
- /// A mark provides a guarantee that {@link #seek seek()} operations will be
- /// valid over a "marked range" extending from the index where {@code mark()}
- /// was called to the current {@link #index index()}. This allows the use of
+ ///
+ /// A mark provides a guarantee that _#seek seek()_ operations will be
+ /// valid over a "marked range" extending from the index where `mark()`
+ /// was called to the current _#index index()_. This allows the use of
/// streaming input sources by specifying the minimum buffering requirements
/// to support arbitrary lookahead during prediction.
- ///
- /// The returned mark is an opaque handle (type {@code int}) which is passed
- /// to {@link #release release()} when the guarantees provided by the marked
+ ///
+ /// The returned mark is an opaque handle (type `int`) which is passed
+ /// to _#release release()_ when the guarantees provided by the marked
/// range are no longer necessary. When calls to
- /// {@code mark()}/{@code release()} are nested, the marks must be released
+ /// `mark()`/`release()` are nested, the marks must be released
/// in reverse order of which they were obtained. Since marked regions are
/// used during performance-critical sections of prediction, the specific
/// behavior of invalid usage is unspecified (i.e. a mark is not released, or
/// a mark is released twice, or marks are not released in reverse order from
- /// which they were created).
- ///
- /// The behavior of this method is unspecified if no call to an
- /// {@link org.antlr.v4.runtime.IntStream initializing method} has occurred after this stream was
- /// constructed.
- ///
- /// This method does not change the current position in the input stream.
- ///
- /// The following example shows the use of {@link #mark mark()},
- /// {@link #release release(mark)}, {@link #index index()}, and
- /// {@link #seek seek(index)} as part of an operation to safely work within a
+ /// which they were created).
+ ///
+ /// The behavior of this method is unspecified if no call to an
+ /// _org.antlr.v4.runtime.IntStream initializing method_ has occurred after this stream was
+ /// constructed.
+ ///
+ /// This method does not change the current position in the input stream.
+ ///
+ /// The following example shows the use of _#mark mark()_,
+ /// _#release release(mark)_, _#index index()_, and
+ /// _#seek seek(index)_ as part of an operation to safely work within a
/// marked region, then restore the stream position to its original value and
- /// release the mark.
- ///
+ /// release the mark.
+ ///
/// IntStream stream = ...;
/// int index = -1;
/// int mark = stream.mark();
@@ -124,70 +119,78 @@ public protocol IntStream: class {
/// }
/// stream.release(mark);
/// }
- ///
- ///
+ ///
+ ///
/// - returns: An opaque marker which should be passed to
- /// {@link #release release()} when the marked range is no longer required.
+ /// _#release release()_ when the marked range is no longer required.
+ ///
func mark() -> Int
+ ///
/// This method releases a marked range created by a call to
- /// {@link #mark mark()}. Calls to {@code release()} must appear in the
- /// reverse order of the corresponding calls to {@code mark()}. If a mark is
+ /// _#mark mark()_. Calls to `release()` must appear in the
+ /// reverse order of the corresponding calls to `mark()`. If a mark is
/// released twice, or if marks are not released in reverse order of the
- /// corresponding calls to {@code mark()}, the behavior is unspecified.
- ///
- /// For more information and an example, see {@link #mark}.
- ///
- /// - parameter marker: A marker returned by a call to {@code mark()}.
+ /// corresponding calls to `mark()`, the behavior is unspecified.
+ ///
+ /// For more information and an example, see _#mark_.
+ ///
+ /// - parameter marker: A marker returned by a call to `mark()`.
/// - seealso: #mark
+ ///
func release(_ marker: Int) throws
+ ///
/// Return the index into the stream of the input symbol referred to by
- /// {@code LA(1)}.
- ///
- /// The behavior of this method is unspecified if no call to an
- /// {@link org.antlr.v4.runtime.IntStream initializing method} has occurred after this stream was
- /// constructed.
+ /// `LA(1)`.
+ ///
+ /// The behavior of this method is unspecified if no call to an
+ /// _org.antlr.v4.runtime.IntStream initializing method_ has occurred after this stream was
+ /// constructed.
+ ///
func index() -> Int
- /// Set the input cursor to the position indicated by {@code index}. If the
+ ///
+ /// Set the input cursor to the position indicated by `index`. If the
/// specified index lies past the end of the stream, the operation behaves as
- /// though {@code index} was the index of the EOF symbol. After this method
+ /// though `index` was the index of the EOF symbol. After this method
/// returns without throwing an exception, then at least one of the following
/// will be true.
- ///
- ///
- /// - {@link #index index()} will return the index of the first symbol
- /// appearing at or after the specified {@code index}. Specifically,
+ ///
+ /// * _#index index()_ will return the index of the first symbol
+ /// appearing at or after the specified `index`. Specifically,
/// implementations which filter their sources should automatically
- /// adjust {@code index} forward the minimum amount required for the
- /// operation to target a non-ignored symbol.
- /// - {@code LA(1)} returns {@link #EOF}
- ///
- ///
- /// This operation is guaranteed to not throw an exception if {@code index}
+ /// adjust `index` forward the minimum amount required for the
+ /// operation to target a non-ignored symbol.
+ /// * `LA(1)` returns _#EOF_
+ ///
+ /// This operation is guaranteed to not throw an exception if `index`
/// lies within a marked region. For more information on marked regions, see
- /// {@link #mark}. The behavior of this method is unspecified if no call to
- /// an {@link org.antlr.v4.runtime.IntStream initializing method} has occurred after this stream
+ /// _#mark_. The behavior of this method is unspecified if no call to
+ /// an _org.antlr.v4.runtime.IntStream initializing method_ has occurred after this stream
/// was constructed.
- ///
+ ///
/// - parameter index: The absolute index to seek to.
- ///
- /// - IllegalArgumentException if {@code index} is less than 0
- /// - UnsupportedOperationException if the stream does not support
+ ///
+ /// - throws: _ANTLRError.illegalArgument_ if `index` is less than 0
+ /// - throws: _ANTLRError.unsupportedOperation_ if the stream does not support
/// seeking to the specified index
+ ///
func seek(_ index: Int) throws
+ ///
/// Returns the total number of symbols in the stream, including a single EOF
/// symbol.
- ///
- /// - UnsupportedOperationException if the size of the stream is
+ ///
+ /// - throws: _ANTLRError.unsupportedOperation_ if the size of the stream is
/// unknown.
+ ///
func size() -> Int
+ ///
/// Gets the name of the underlying symbol source. This method returns a
/// non-null, non-empty string. If such a name is not known, this method
- /// returns {@link #UNKNOWN_SOURCE_NAME}.
-
+ /// returns _#UNKNOWN_SOURCE_NAME_.
+ ///
func getSourceName() -> String
}
diff --git a/runtime/Swift/Sources/Antlr4/InterpreterRuleContext.swift b/runtime/Swift/Sources/Antlr4/InterpreterRuleContext.swift
index ea4789386..b881a94ea 100644
--- a/runtime/Swift/Sources/Antlr4/InterpreterRuleContext.swift
+++ b/runtime/Swift/Sources/Antlr4/InterpreterRuleContext.swift
@@ -1,33 +1,41 @@
+///
/// Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
/// Use of this file is governed by the BSD 3-clause license that
/// can be found in the LICENSE.txt file in the project root.
+///
-/// This class extends {@link org.antlr.v4.runtime.ParserRuleContext} by allowing the value of
-/// {@link #getRuleIndex} to be explicitly set for the context.
-///
-///
-/// {@link org.antlr.v4.runtime.ParserRuleContext} does not include field storage for the rule index
+///
+/// This class extends _org.antlr.v4.runtime.ParserRuleContext_ by allowing the value of
+/// _#getRuleIndex_ to be explicitly set for the context.
+///
+///
+/// _org.antlr.v4.runtime.ParserRuleContext_ does not include field storage for the rule index
/// since the context classes created by the code generator override the
-/// {@link #getRuleIndex} method to return the correct value for that context.
+/// _#getRuleIndex_ method to return the correct value for that context.
/// Since the parser interpreter does not use the context classes generated for a
/// parser, this class (with slightly more memory overhead per node) is used to
-/// provide equivalent functionality.
+/// provide equivalent functionality.
+///
public class InterpreterRuleContext: ParserRuleContext {
- /// This is the backing field for {@link #getRuleIndex}.
+ ///
+ /// This is the backing field for _#getRuleIndex_.
+ ///
private var ruleIndex: Int = -1
public override init() {
super.init()
}
- /// Constructs a new {@link org.antlr.v4.runtime.InterpreterRuleContext} with the specified
+ ///
+ /// Constructs a new _org.antlr.v4.runtime.InterpreterRuleContext_ with the specified
/// parent, invoking state, and rule index.
- ///
+ ///
/// - parameter parent: The parent context.
/// - parameter invokingStateNumber: The invoking state number.
/// - parameter ruleIndex: The rule index for the current context.
+ ///
public init(_ parent: ParserRuleContext?,
_ invokingStateNumber: Int,
_ ruleIndex: Int) {
@@ -41,9 +49,11 @@ public class InterpreterRuleContext: ParserRuleContext {
return ruleIndex
}
- /// Copy a {@link org.antlr.v4.runtime.ParserRuleContext} or {@link org.antlr.v4.runtime.InterpreterRuleContext}
- /// stack to a {@link org.antlr.v4.runtime.InterpreterRuleContext} tree.
- /// Return {@link null} if {@code ctx} is null.
+ ///
+ /// Copy a _org.antlr.v4.runtime.ParserRuleContext_ or _org.antlr.v4.runtime.InterpreterRuleContext_
+ /// stack to a _org.antlr.v4.runtime.InterpreterRuleContext_ tree.
+ /// Return _null_ if `ctx` is null.
+ ///
public static func fromParserRuleContext(_ ctx: ParserRuleContext?) -> InterpreterRuleContext? {
guard let ctx = ctx else {
return nil
diff --git a/runtime/Swift/Sources/Antlr4/Lexer.swift b/runtime/Swift/Sources/Antlr4/Lexer.swift
index 9c251ba66..e47aa1a93 100644
--- a/runtime/Swift/Sources/Antlr4/Lexer.swift
+++ b/runtime/Swift/Sources/Antlr4/Lexer.swift
@@ -1,35 +1,39 @@
+///
/// Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
/// Use of this file is governed by the BSD 3-clause license that
/// can be found in the LICENSE.txt file in the project root.
+///
+///
/// A lexer is recognizer that draws input symbols from a character stream.
/// lexer grammars result in a subclass of this object. A Lexer object
/// uses simplified match() and error recovery mechanisms in the interest
/// of speed.
+///
import Foundation
-//public class Lexer : Recognizer
+open class Lexer: Recognizer, TokenSource {
+ public static let EOF = -1
+ public static let DEFAULT_MODE = 0
+ public static let MORE = -2
+ public static let SKIP = -3
-open class Lexer: Recognizer
- , TokenSource {
- public static let EOF: Int = -1
- public static let DEFAULT_MODE: Int = 0
- public static let MORE: Int = -2
- public static let SKIP: Int = -3
-
- public static let DEFAULT_TOKEN_CHANNEL: Int = CommonToken.DEFAULT_CHANNEL
- public static let HIDDEN: Int = CommonToken.HIDDEN_CHANNEL
- public static let MIN_CHAR_VALUE: Int = Character.MIN_VALUE;
- public static let MAX_CHAR_VALUE: Int = Character.MAX_VALUE;
+ public static let DEFAULT_TOKEN_CHANNEL = CommonToken.DEFAULT_CHANNEL
+ public static let HIDDEN = CommonToken.HIDDEN_CHANNEL
+ public static let MIN_CHAR_VALUE = Character.MIN_VALUE;
+ public static let MAX_CHAR_VALUE = Character.MAX_VALUE;
public var _input: CharStream?
- internal var _tokenFactorySourcePair: (TokenSource?, CharStream?)
+ internal var _tokenFactorySourcePair: TokenSourceAndStream
+ ///
/// How to create token objects
- internal var _factory: TokenFactory = CommonTokenFactory.DEFAULT
+ ///
+ internal var _factory = CommonTokenFactory.DEFAULT
+ ///
/// The goal of all lexer rules/methods is to create a token object.
/// This is an instance variable as multiple rules may collaborate to
/// create a single token. nextToken will return this object after
@@ -37,44 +41,63 @@ open class Lexer: Recognizer
/// emissions, then set this to the last token to be matched or
/// something nonnull so that the auto token emit mechanism will not
/// emit another token.
+ ///
public var _token: Token?
+ ///
/// What character index in the stream did the current token start at?
/// Needed, for example, to get the text for current token. Set at
/// the start of nextToken.
- public var _tokenStartCharIndex: Int = -1
+ ///
+ public var _tokenStartCharIndex = -1
+ ///
/// The line on which the first character of the token resides
- public var _tokenStartLine: Int = 0
+ ///
+ public var _tokenStartLine = 0
+ ///
/// The character position of first character within the line
- public var _tokenStartCharPositionInLine: Int = 0
+ ///
+ public var _tokenStartCharPositionInLine = 0
+ ///
/// Once we see EOF on char stream, next token will be EOF.
/// If you have DONE : EOF ; then you see DONE EOF.
- public var _hitEOF: Bool = false
+ ///
+ public var _hitEOF = false
+ ///
/// The channel number for the current token
- public var _channel: Int = 0
+ ///
+ public var _channel = 0
+ ///
/// The token type for the current token
- public var _type: Int = 0
+ ///
+ public var _type = 0
- public final var _modeStack: Stack = Stack()
- public var _mode: Int = Lexer.DEFAULT_MODE
+ public final var _modeStack = Stack()
+ public var _mode = Lexer.DEFAULT_MODE
+ ///
/// You can set the text for the current token to override what is in
/// the input char buffer. Use setText() or can set this instance var.
+ ///
public var _text: String?
public override init() {
+ self._tokenFactorySourcePair = TokenSourceAndStream()
+ super.init()
+ self._tokenFactorySourcePair.tokenSource = self
}
public init(_ input: CharStream) {
-
- super.init()
self._input = input
- self._tokenFactorySourcePair = (self, input)
+ self._tokenFactorySourcePair = TokenSourceAndStream()
+ super.init()
+ self._tokenFactorySourcePair.tokenSource = self
+ self._tokenFactorySourcePair.stream = input
}
open func reset() throws {
@@ -97,8 +120,10 @@ open class Lexer: Recognizer
getInterpreter().reset()
}
+ ///
/// Return a token from this source; i.e., match a token on the char
/// stream.
+ ///
open func nextToken() throws -> Token {
guard let _input = _input else {
@@ -107,7 +132,7 @@ open class Lexer: Recognizer
// Mark start location in char stream so unbuffered streams are
// guaranteed at least have text of current token
- var tokenStartMarker: Int = _input.mark()
+ var tokenStartMarker = _input.mark()
defer {
// make sure we release marker after match or
// unbuffered char stream will keep buffering
@@ -158,11 +183,13 @@ open class Lexer: Recognizer
}
+ ///
/// Instruct the lexer to skip creating a token for current lexer rule
/// and look for another token. nextToken() knows to keep looking when
/// a lexer rule finishes with token set to SKIP_TOKEN. Recall that
/// if token==null at end of any token rule, it creates one for you
/// and emits it.
+ ///
open func skip() {
_type = Lexer.SKIP
}
@@ -205,14 +232,16 @@ open class Lexer: Recognizer
return _factory
}
+ ///
/// Set the char stream and reset the lexer
+ ///
open override func setInputStream(_ input: IntStream) throws {
self._input = nil
- self._tokenFactorySourcePair = (self, _input!)
+ self._tokenFactorySourcePair = makeTokenSourceAndStream()
try reset()
self._input = input as? CharStream
- self._tokenFactorySourcePair = (self, _input!)
+ self._tokenFactorySourcePair = makeTokenSourceAndStream()
}
@@ -225,40 +254,45 @@ open class Lexer: Recognizer
return _input
}
+ ///
/// By default does not support multiple emits per nextToken invocation
/// for efficiency reasons. Subclass and override this method, nextToken,
/// and getToken (to push tokens into a list and pull from that list
/// rather than a single variable as this implementation does).
+ ///
open func emit(_ token: Token) {
//System.err.println("emit "+token);
self._token = token
}
+ ///
/// The standard method called to automatically emit a token at the
/// outermost lexical rule. The token object should point into the
/// char buffer start..stop. If there is a text override in 'text',
/// use that to set the token's text. Override this method to emit
/// custom Token objects or provide a new factory.
+ ///
@discardableResult
open func emit() -> Token {
- let t: Token = _factory.create(_tokenFactorySourcePair, _type, _text, _channel, _tokenStartCharIndex, getCharIndex() - 1,
- _tokenStartLine, _tokenStartCharPositionInLine)
+ let t = _factory.create(_tokenFactorySourcePair, _type, _text, _channel, _tokenStartCharIndex, getCharIndex() - 1, _tokenStartLine, _tokenStartCharPositionInLine)
emit(t)
return t
}
+
@discardableResult
open func emitEOF() -> Token {
- let cpos: Int = getCharPositionInLine()
- let line: Int = getLine()
- let eof: Token = _factory.create(
- _tokenFactorySourcePair,
- CommonToken.EOF,
- nil,
- CommonToken.DEFAULT_CHANNEL,
- _input!.index(),
- _input!.index() - 1,
- line,
- cpos)
+ let cpos = getCharPositionInLine()
+ let line = getLine()
+ let idx = _input!.index()
+ let eof = _factory.create(
+ _tokenFactorySourcePair,
+ CommonToken.EOF,
+ nil,
+ CommonToken.DEFAULT_CHANNEL,
+ idx,
+ idx - 1,
+ line,
+ cpos)
emit(eof)
return eof
}
@@ -281,13 +315,17 @@ open class Lexer: Recognizer
getInterpreter().setCharPositionInLine(charPositionInLine)
}
+ ///
/// What is the index of the current character of lookahead?
+ ///
open func getCharIndex() -> Int {
return _input!.index()
}
+ ///
/// Return the text matched so far for the current token or any
/// text override.
+ ///
open func getText() -> String {
if _text != nil {
return _text!
@@ -295,13 +333,17 @@ open class Lexer: Recognizer
return getInterpreter().getText(_input!)
}
+ ///
/// Set the complete text of this token; it wipes any previous
/// changes to the text.
+ ///
open func setText(_ text: String) {
self._text = text
}
+ ///
/// Override if emitting multiple tokens.
+ ///
open func getToken() -> Token {
return _token!
}
@@ -334,19 +376,13 @@ open class Lexer: Recognizer
return nil
}
- /// Used to print out token names like ID during debugging and
- /// error reporting. The generated parsers implement a method
- /// that overrides this to point to their String[] tokenNames.
- override
- open func getTokenNames() -> [String?]? {
- return nil
- }
-
+ ///
/// Return a list of all Token objects in input char stream.
/// Forces load of all tokens. Does not include EOF token.
- open func getAllTokens() throws -> Array {
- var tokens: Array = Array()
- var t: Token = try nextToken()
+ ///
+ open func getAllTokens() throws -> [Token] {
+ var tokens = [Token]()
+ var t = try nextToken()
while t.getType() != CommonToken.EOF {
tokens.append(t)
t = try nextToken()
@@ -361,32 +397,35 @@ open class Lexer: Recognizer
}
}
- open func notifyListeners(_ e: LexerNoViableAltException, recognizer: Recognizer) {
+ open func notifyListeners(_ e: LexerNoViableAltException, recognizer: Recognizer) {
- let text: String = _input!.getText(Interval.of(_tokenStartCharIndex, _input!.index()))
- let msg: String = "token recognition error at: '\(getErrorDisplay(text))'"
+ let text: String
+ do {
+ text = try _input!.getText(Interval.of(_tokenStartCharIndex, _input!.index()))
+ }
+ catch {
+ text = ""
+ }
+ let msg = "token recognition error at: '\(getErrorDisplay(text))'"
- let listener: ANTLRErrorListener = getErrorListenerDispatch()
+ let listener = getErrorListenerDispatch()
listener.syntaxError(recognizer, nil, _tokenStartLine, _tokenStartCharPositionInLine, msg, e)
}
open func getErrorDisplay(_ s: String) -> String {
- let buf: StringBuilder = StringBuilder()
- for c: Character in s.characters {
+ let buf = StringBuilder()
+ for c in s.characters {
buf.append(getErrorDisplay(c))
}
return buf.toString()
}
open func getErrorDisplay(_ c: Character) -> String {
- var s: String = String(c) // String.valueOf(c as Character);
+ var s = String(c)
if c.integerValue == CommonToken.EOF {
s = ""
}
switch s {
-// case CommonToken.EOF :
-// s = "";
-// break;
case "\n":
s = "\\n"
case "\t":
@@ -404,16 +443,18 @@ open class Lexer: Recognizer
return "'\(s)'"
}
+ ///
/// Lexers can normally match any char in it's vocabulary after matching
/// a token, so do the easy thing and just kill a character and hope
/// it all works out. You can instead use the rule invocation stack
/// to do sophisticated error recovery if you are in a fragment rule.
- //public func recover(re : RecognitionException) {
-
+ ///
open func recover(_ re: AnyObject) throws {
- //System.out.println("consuming char "+(char)input.LA(1)+" during recovery");
- //re.printStackTrace();
// TODO: Do we lose character or line position information?
try _input!.consume()
}
+
+ internal func makeTokenSourceAndStream() -> TokenSourceAndStream {
+ return TokenSourceAndStream(self, _input)
+ }
}
diff --git a/runtime/Swift/Sources/Antlr4/LexerInterpreter.swift b/runtime/Swift/Sources/Antlr4/LexerInterpreter.swift
index 55c2f26e8..99d9f72d8 100644
--- a/runtime/Swift/Sources/Antlr4/LexerInterpreter.swift
+++ b/runtime/Swift/Sources/Antlr4/LexerInterpreter.swift
@@ -1,24 +1,23 @@
+///
/// Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
/// Use of this file is governed by the BSD 3-clause license that
/// can be found in the LICENSE.txt file in the project root.
+///
public class LexerInterpreter: Lexer {
internal final var grammarFileName: String
internal final var atn: ATN
- ////@Deprecated
- internal final var tokenNames: [String?]?
internal final var ruleNames: [String]
internal final var channelNames: [String]
internal final var modeNames: [String]
-
private final var vocabulary: Vocabulary?
internal final var _decisionToDFA: [DFA]
- internal final var _sharedContextCache: PredictionContextCache =
- PredictionContextCache()
+ internal final var _sharedContextCache = PredictionContextCache()
+
// public override init() {
// super.init()}
@@ -36,13 +35,6 @@ public class LexerInterpreter: Lexer {
self.grammarFileName = grammarFileName
self.atn = atn
- self.tokenNames = [String?]()
- //new String[atn.maxTokenType];
- let length = tokenNames!.count
- for i in 0.. [String?]? {
- return tokenNames
- }
-
override
public func getRuleNames() -> [String] {
return ruleNames
diff --git a/runtime/Swift/Sources/Antlr4/LexerNoViableAltException.swift b/runtime/Swift/Sources/Antlr4/LexerNoViableAltException.swift
index 392400e37..9f560c6c6 100644
--- a/runtime/Swift/Sources/Antlr4/LexerNoViableAltException.swift
+++ b/runtime/Swift/Sources/Antlr4/LexerNoViableAltException.swift
@@ -1,13 +1,19 @@
+///
/// Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
/// Use of this file is governed by the BSD 3-clause license that
/// can be found in the LICENSE.txt file in the project root.
+///
-public class LexerNoViableAltException: RecognitionException, CustomStringConvertible {
+public class LexerNoViableAltException: RecognitionException, CustomStringConvertible {
+ ///
/// Matching attempted at what input index?
+ ///
private final var startIndex: Int
+ ///
/// Which configurations did we try at input.index() that couldn't match input.LA(1)?
+ ///
private final var deadEndConfigs: ATNConfigSet
public init(_ lexer: Lexer?,
@@ -25,23 +31,15 @@ public class LexerNoViableAltException: RecognitionException,
return startIndex
}
-
public func getDeadEndConfigs() -> ATNConfigSet {
return deadEndConfigs
}
- //override
-// public func getInputStream() -> CharStream {
-// return super.getInputStream() as! CharStream;
-// }
-
-
public var description: String {
- var symbol: String = ""
- if startIndex >= 0 && startIndex < getInputStream().size() {
- let charStream: CharStream = getInputStream() as! CharStream
- let interval: Interval = Interval.of(startIndex, startIndex)
- symbol = charStream.getText(interval)
+ var symbol = ""
+ if let charStream = getInputStream() as? CharStream, startIndex >= 0 && startIndex < charStream.size() {
+ let interval = Interval.of(startIndex, startIndex)
+ symbol = try! charStream.getText(interval)
symbol = Utils.escapeWhitespace(symbol, false)
}
diff --git a/runtime/Swift/Sources/Antlr4/ListTokenSource.swift b/runtime/Swift/Sources/Antlr4/ListTokenSource.swift
index a553642cd..0863e16ee 100644
--- a/runtime/Swift/Sources/Antlr4/ListTokenSource.swift
+++ b/runtime/Swift/Sources/Antlr4/ListTokenSource.swift
@@ -1,90 +1,98 @@
+///
/// Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
/// Use of this file is governed by the BSD 3-clause license that
/// can be found in the LICENSE.txt file in the project root.
+///
-/// Provides an implementation of {@link org.antlr.v4.runtime.TokenSource} as a wrapper around a list
-/// of {@link org.antlr.v4.runtime.Token} objects.
-///
-/// If the final token in the list is an {@link org.antlr.v4.runtime.Token#EOF} token, it will be used
-/// as the EOF token for every call to {@link #nextToken} after the end of the
-/// list is reached. Otherwise, an EOF token will be created.
+///
+/// Provides an implementation of _org.antlr.v4.runtime.TokenSource_ as a wrapper around a list
+/// of _org.antlr.v4.runtime.Token_ objects.
+///
+/// If the final token in the list is an _org.antlr.v4.runtime.Token#EOF_ token, it will be used
+/// as the EOF token for every call to _#nextToken_ after the end of the
+/// list is reached. Otherwise, an EOF token will be created.
+///
public class ListTokenSource: TokenSource {
- /// The wrapped collection of {@link org.antlr.v4.runtime.Token} objects to return.
- internal final var tokens: Array
+ ///
+ /// The wrapped collection of _org.antlr.v4.runtime.Token_ objects to return.
+ ///
+ internal final var tokens: [Token]
- /// The name of the input source. If this value is {@code null}, a call to
- /// {@link #getSourceName} should return the source name used to create the
- /// the next token in {@link #tokens} (or the previous token if the end of
+ ///
+ /// The name of the input source. If this value is `null`, a call to
+ /// _#getSourceName_ should return the source name used to create the
+ /// the next token in _#tokens_ (or the previous token if the end of
/// the input has been reached).
+ ///
private final var sourceName: String?
- /// The index into {@link #tokens} of token to return by the next call to
- /// {@link #nextToken}. The end of the input is indicated by this value
- /// being greater than or equal to the number of items in {@link #tokens}.
- internal var i: Int = 0
+ ///
+ /// The index into _#tokens_ of token to return by the next call to
+ /// _#nextToken_. The end of the input is indicated by this value
+ /// being greater than or equal to the number of items in _#tokens_.
+ ///
+ internal var i = 0
+ ///
/// This field caches the EOF token for the token source.
+ ///
internal var eofToken: Token?
- /// This is the backing field for {@link #getTokenFactory} and
- /// {@link setTokenFactory}.
- private var _factory: TokenFactory = CommonTokenFactory.DEFAULT
+ ///
+ /// This is the backing field for _#getTokenFactory_ and
+ /// _setTokenFactory_.
+ ///
+ private var _factory = CommonTokenFactory.DEFAULT
- /// Constructs a new {@link org.antlr.v4.runtime.ListTokenSource} instance from the specified
- /// collection of {@link org.antlr.v4.runtime.Token} objects.
- ///
- /// - parameter tokens: The collection of {@link org.antlr.v4.runtime.Token} objects to provide as a
- /// {@link org.antlr.v4.runtime.TokenSource}.
- /// - NullPointerException if {@code tokens} is {@code null}
- public convenience init(_ tokens: Array) {
+ ///
+ /// Constructs a new _org.antlr.v4.runtime.ListTokenSource_ instance from the specified
+ /// collection of _org.antlr.v4.runtime.Token_ objects.
+ ///
+ /// - parameter tokens: The collection of _org.antlr.v4.runtime.Token_ objects to provide as a
+ /// _org.antlr.v4.runtime.TokenSource_.
+ ///
+ public convenience init(_ tokens: [Token]) {
self.init(tokens, nil)
}
- /// Constructs a new {@link org.antlr.v4.runtime.ListTokenSource} instance from the specified
- /// collection of {@link org.antlr.v4.runtime.Token} objects and source name.
- ///
- /// - parameter tokens: The collection of {@link org.antlr.v4.runtime.Token} objects to provide as a
- /// {@link org.antlr.v4.runtime.TokenSource}.
- /// - parameter sourceName: The name of the {@link org.antlr.v4.runtime.TokenSource}. If this value is
- /// {@code null}, {@link #getSourceName} will attempt to infer the name from
- /// the next {@link org.antlr.v4.runtime.Token} (or the previous token if the end of the input has
+ ///
+ /// Constructs a new _org.antlr.v4.runtime.ListTokenSource_ instance from the specified
+ /// collection of _org.antlr.v4.runtime.Token_ objects and source name.
+ ///
+ /// - parameter tokens: The collection of _org.antlr.v4.runtime.Token_ objects to provide as a
+ /// _org.antlr.v4.runtime.TokenSource_.
+ /// - parameter sourceName: The name of the _org.antlr.v4.runtime.TokenSource_. If this value is
+ /// `null`, _#getSourceName_ will attempt to infer the name from
+ /// the next _org.antlr.v4.runtime.Token_ (or the previous token if the end of the input has
/// been reached).
- ///
- /// - NullPointerException if {@code tokens} is {@code null}
- public init(_ tokens: Array, _ sourceName: String?) {
-
+ ///
+ public init(_ tokens: [Token], _ sourceName: String?) {
self.tokens = tokens
self.sourceName = sourceName
}
- /// {@inheritDoc}
-
public func getCharPositionInLine() -> Int {
if i < tokens.count {
return tokens[i].getCharPositionInLine()
- } else {
- if let eofToken = eofToken {
- return eofToken.getCharPositionInLine()
- } else {
- if tokens.count > 0 {
- // have to calculate the result from the line/column of the previous
- // token, along with the text of the token.
- let lastToken: Token = tokens[tokens.count - 1]
+ }
+ else if let eofToken = eofToken {
+ return eofToken.getCharPositionInLine()
+ }
+ else if tokens.count > 0 {
+ // have to calculate the result from the line/column of the previous
+ // token, along with the text of the token.
+ let lastToken = tokens[tokens.count - 1]
- if let tokenText = lastToken.getText() {
- let lastNewLine: Int = tokenText.lastIndexOf("\n")
- if lastNewLine >= 0 {
- return tokenText.length - lastNewLine - 1
- }
- }
- var position = lastToken.getCharPositionInLine()
- position += lastToken.getStopIndex()
- position -= lastToken.getStartIndex()
- position += 1
- return position
+ if let tokenText = lastToken.getText() {
+ let lastNewLine = tokenText.lastIndexOf("\n")
+ if lastNewLine >= 0 {
+ return tokenText.length - lastNewLine - 1
}
}
+ return (lastToken.getCharPositionInLine() +
+ lastToken.getStopIndex() -
+ lastToken.getStartIndex() + 1)
}
// only reach this if tokens is empty, meaning EOF occurs at the first
@@ -92,27 +100,26 @@ public class ListTokenSource: TokenSource {
return 0
}
- /// {@inheritDoc}
-
public func nextToken() -> Token {
if i >= tokens.count {
if eofToken == nil {
- var start: Int = -1
+ var start = -1
if tokens.count > 0 {
- let previousStop: Int = tokens[tokens.count - 1].getStopIndex()
+ let previousStop = tokens[tokens.count - 1].getStopIndex()
if previousStop != -1 {
start = previousStop + 1
}
}
- let stop: Int = max(-1, start - 1)
- eofToken = _factory.create((self, getInputStream()!), CommonToken.EOF, "EOF", CommonToken.DEFAULT_CHANNEL, start, stop, getLine(), getCharPositionInLine())
+ let stop = max(-1, start - 1)
+ let source = TokenSourceAndStream(self, getInputStream())
+ eofToken = _factory.create(source, CommonToken.EOF, "EOF", CommonToken.DEFAULT_CHANNEL, start, stop, getLine(), getCharPositionInLine())
}
return eofToken!
}
- let t: Token = tokens[i]
+ let t = tokens[i]
if i == tokens.count - 1 && t.getType() == CommonToken.EOF {
eofToken = t
}
@@ -121,8 +128,6 @@ public class ListTokenSource: TokenSource {
return t
}
- /// {@inheritDoc}
-
public func getLine() -> Int {
if i < tokens.count {
return tokens[i].getLine()
@@ -133,8 +138,8 @@ public class ListTokenSource: TokenSource {
if tokens.count > 0 {
// have to calculate the result from the line/column of the previous
// token, along with the text of the token.
- let lastToken: Token = tokens[tokens.count - 1]
- var line: Int = lastToken.getLine()
+ let lastToken = tokens[tokens.count - 1]
+ var line = lastToken.getLine()
if let tokenText = lastToken.getText() {
let length = tokenText.length
@@ -156,30 +161,24 @@ public class ListTokenSource: TokenSource {
return 1
}
- /// {@inheritDoc}
-
public func getInputStream() -> CharStream? {
if i < tokens.count {
return tokens[i].getInputStream()
- } else {
- if let eofToken = eofToken{
- return eofToken.getInputStream()
- } else {
- if tokens.count > 0 {
- return tokens[tokens.count - 1].getInputStream()
- }
- }
+ }
+ else if let eofToken = eofToken {
+ return eofToken.getInputStream()
+ }
+ else if tokens.count > 0 {
+ return tokens[tokens.count - 1].getInputStream()
}
// no input stream information is available
return nil
}
- /// {@inheritDoc}
-
public func getSourceName() -> String {
- if sourceName != nil {
- return sourceName!
+ if let sourceName = sourceName {
+ return sourceName
}
if let inputStream = getInputStream() {
@@ -189,14 +188,10 @@ public class ListTokenSource: TokenSource {
return "List"
}
- /// {@inheritDoc}
-
public func setTokenFactory(_ factory: TokenFactory) {
self._factory = factory
}
- /// {@inheritDoc}
-
public func getTokenFactory() -> TokenFactory {
return _factory
}
diff --git a/runtime/Swift/Sources/Antlr4/NoViableAltException.swift b/runtime/Swift/Sources/Antlr4/NoViableAltException.swift
index 8a41f8cca..bf3ab415f 100644
--- a/runtime/Swift/Sources/Antlr4/NoViableAltException.swift
+++ b/runtime/Swift/Sources/Antlr4/NoViableAltException.swift
@@ -4,48 +4,49 @@
*/
-/** Indicates that the parser could not decide which of two or more paths
- * to take based upon the remaining input. It tracks the starting token
- * of the offending input and also knows where the parser was
- * in the various paths when the error. Reported by reportNoViableAlternative()
- */
+/// Indicates that the parser could not decide which of two or more paths
+/// to take based upon the remaining input. It tracks the starting token
+/// of the offending input and also knows where the parser was
+/// in the various paths when the error. Reported by reportNoViableAlternative()
+///
-public class NoViableAltException: RecognitionException {
- /** Which configurations did we try at input.index() that couldn't match input.LT(1)? */
+public class NoViableAltException: RecognitionException {
+ /// Which configurations did we try at input.index() that couldn't match input.LT(1)?
private final var deadEndConfigs: ATNConfigSet?
- /** The token object at the start index; the input stream might
- * not be buffering tokens so get a reference to it. (At the
- * time the error occurred, of course the stream needs to keep a
- * buffer all of the tokens but later we might not have access to those.)
- */
-
+ /// The token object at the start index; the input stream might
+ /// not be buffering tokens so get a reference to it. (At the
+ /// time the error occurred, of course the stream needs to keep a
+ /// buffer all of the tokens but later we might not have access to those.)
+ ///
private final var startToken: Token
- public convenience init(_ recognizer: Parser?) throws {
+ public convenience init(_ recognizer: Parser) {
// LL(1) error
+ let token = try! recognizer.getCurrentToken()
self.init(recognizer,
- recognizer!.getInputStream()!,
- try recognizer!.getCurrentToken(),
- try recognizer!.getCurrentToken(),
+ recognizer.getInputStream()!,
+ token,
+ token,
nil,
- recognizer!._ctx)
+ recognizer._ctx)
}
public init(_ recognizer: Parser?,
_ input: IntStream,
_ startToken: Token,
- _ offendingToken: Token,
+ _ offendingToken: Token?,
_ deadEndConfigs: ATNConfigSet?,
_ ctx: ParserRuleContext?) {
self.deadEndConfigs = deadEndConfigs
self.startToken = startToken
- // as? Recognizer
super.init(recognizer, input, ctx)
- self.setOffendingToken(offendingToken)
+ if let offendingToken = offendingToken {
+ setOffendingToken(offendingToken)
+ }
}
diff --git a/runtime/Swift/Sources/Antlr4/Parser.swift b/runtime/Swift/Sources/Antlr4/Parser.swift
index 81ce2ac4f..a031aaf88 100644
--- a/runtime/Swift/Sources/Antlr4/Parser.swift
+++ b/runtime/Swift/Sources/Antlr4/Parser.swift
@@ -1,14 +1,18 @@
-///
+///
+///
/// Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
/// Use of this file is governed by the BSD 3-clause license that
/// can be found in the LICENSE.txt file in the project root.
-///
+///
+///
import Foundation
+///
/// This is all the parsing support code essentially; most of it is error recovery stuff.
+///
open class Parser: Recognizer {
- public static let EOF: Int = -1
+ public static let EOF = -1
public static var ConsoleError = true
public class TraceListener: ParseTreeListener {
@@ -23,16 +27,13 @@ open class Parser: Recognizer {
print("enter \(ruleName), LT(1)=\(lt1)")
}
-
public func visitTerminal(_ node: TerminalNode) {
print("consume \(String(describing: node.getSymbol())) rule \(host.getRuleNames()[host._ctx!.getRuleIndex()])")
}
-
public func visitErrorNode(_ node: ErrorNode) {
}
-
public func exitEveryRule(_ ctx: ParserRuleContext) throws {
let ruleName = host.getRuleNames()[ctx.getRuleIndex()]
let lt1 = try host._input.LT(1)!.getText()!
@@ -41,58 +42,56 @@ open class Parser: Recognizer {
}
public class TrimToSizeListener: ParseTreeListener {
-
-
- public static let INSTANCE: TrimToSizeListener = TrimToSizeListener()
-
+ public static let INSTANCE = TrimToSizeListener()
public func enterEveryRule(_ ctx: ParserRuleContext) {
}
-
public func visitTerminal(_ node: TerminalNode) {
}
-
public func visitErrorNode(_ node: ErrorNode) {
}
-
public func exitEveryRule(_ ctx: ParserRuleContext) {
// TODO: Print exit info.
}
}
+ ///
/// mutex for bypassAltsAtnCache updates
+ ///
private var bypassAltsAtnCacheMutex = Mutex()
+ ///
/// mutex for decisionToDFA updates
+ ///
private var decisionToDFAMutex = Mutex()
- /**
- * This field maps from the serialized ATN string to the deserialized {@link org.antlr.v4.runtime.atn.ATN} with
- * bypass alternatives.
- *
- * @see org.antlr.v4.runtime.atn.ATNDeserializationOptions#isGenerateRuleBypassTransitions()
- */
+ ///
+ /// This field maps from the serialized ATN string to the deserialized _org.antlr.v4.runtime.atn.ATN_ with
+ /// bypass alternatives.
+ ///
+ /// - SeeAlso: org.antlr.v4.runtime.atn.ATNDeserializationOptions#isGenerateRuleBypassTransitions()
+ ///
private let bypassAltsAtnCache: HashMap = HashMap()
- /**
- * The error handling strategy for the parser. The default value is a new
- * instance of {@link org.antlr.v4.runtime.DefaultErrorStrategy}.
- *
- * @see #getErrorHandler
- * @see #setErrorHandler
- */
+ ///
+ /// The error handling strategy for the parser. The default value is a new
+ /// instance of _org.antlr.v4.runtime.DefaultErrorStrategy_.
+ ///
+ /// - SeeAlso: #getErrorHandler
+ /// - SeeAlso: #setErrorHandler
+ ///
public var _errHandler: ANTLRErrorStrategy = DefaultErrorStrategy()
- /**
- * The input stream.
- *
- * @see #getInputStream
- * @see #setInputStream
- */
+ ///
+ /// The input stream.
+ ///
+ /// - SeeAlso: #getInputStream
+ /// - SeeAlso: #setInputStream
+ ///
public var _input: TokenStream!
internal var _precedenceStack: Stack = {
@@ -102,42 +101,42 @@ open class Parser: Recognizer {
}()
- /**
- * The {@link org.antlr.v4.runtime.ParserRuleContext} object for the currently executing rule.
- * This is always non-null during the parsing process.
- */
+ ///
+ /// The _org.antlr.v4.runtime.ParserRuleContext_ object for the currently executing rule.
+ /// This is always non-null during the parsing process.
+ ///
public var _ctx: ParserRuleContext? = nil
- /**
- * Specifies whether or not the parser should construct a parse tree during
- * the parsing process. The default value is {@code true}.
- *
- * @see #getBuildParseTree
- * @see #setBuildParseTree
- */
+ ///
+ /// Specifies whether or not the parser should construct a parse tree during
+ /// the parsing process. The default value is `true`.
+ ///
+ /// - SeeAlso: #getBuildParseTree
+ /// - SeeAlso: #setBuildParseTree
+ ///
internal var _buildParseTrees: Bool = true
- /**
- * When {@link #setTrace}{@code (true)} is called, a reference to the
- * {@link org.antlr.v4.runtime.Parser.TraceListener} is stored here so it can be easily removed in a
- * later call to {@link #setTrace}{@code (false)}. The listener itself is
- * implemented as a parser listener so this field is not directly used by
- * other parser methods.
- */
+ ///
+ /// When _#setTrace_`(true)` is called, a reference to the
+ /// _org.antlr.v4.runtime.Parser.TraceListener_ is stored here so it can be easily removed in a
+ /// later call to _#setTrace_`(false)`. The listener itself is
+ /// implemented as a parser listener so this field is not directly used by
+ /// other parser methods.
+ ///
private var _tracer: TraceListener?
- /**
- * The list of {@link org.antlr.v4.runtime.tree.ParseTreeListener} listeners registered to receive
- * events during the parse.
- *
- * @see #addParseListener
- */
+ ///
+ /// The list of _org.antlr.v4.runtime.tree.ParseTreeListener_ listeners registered to receive
+ /// events during the parse.
+ ///
+ /// - SeeAlso: #addParseListener
+ ///
public var _parseListeners: Array?
- /**
- * The number of syntax errors reported during parsing. This value is
- * incremented each time {@link #notifyErrorListeners} is called.
- */
+ ///
+ /// The number of syntax errors reported during parsing. This value is
+ /// incremented each time _#notifyErrorListeners_ is called.
+ ///
internal var _syntaxErrors: Int = 0
public init(_ input: TokenStream) throws {
@@ -146,7 +145,7 @@ open class Parser: Recognizer {
try setInputStream(input)
}
- /** reset the parser's state */
+ /// reset the parser's state
public func reset() throws {
if (getInputStream() != nil) {
try getInputStream()!.seek(0)
@@ -164,28 +163,28 @@ open class Parser: Recognizer {
}
}
- /**
- * Match current input symbol against {@code ttype}. If the symbol type
- * matches, {@link org.antlr.v4.runtime.ANTLRErrorStrategy#reportMatch} and {@link #consume} are
- * called to complete the match process.
- *
- * If the symbol type does not match,
- * {@link org.antlr.v4.runtime.ANTLRErrorStrategy#recoverInline} is called on the current error
- * strategy to attempt recovery. If {@link #getBuildParseTree} is
- * {@code true} and the token index of the symbol returned by
- * {@link org.antlr.v4.runtime.ANTLRErrorStrategy#recoverInline} is -1, the symbol is added to
- * the parse tree by calling {@link #createErrorNode(ParserRuleContext, Token)} then
- * {@link ParserRuleContext#addErrorNode(ErrorNode)}.
- *
- * @param ttype the token type to match
- * @return the matched symbol
- * @throws org.antlr.v4.runtime.RecognitionException if the current input symbol did not match
- * {@code ttype} and the error strategy could not recover from the
- * mismatched symbol
- */
+ ///
+ /// Match current input symbol against `ttype`. If the symbol type
+ /// matches, _org.antlr.v4.runtime.ANTLRErrorStrategy#reportMatch_ and _#consume_ are
+ /// called to complete the match process.
+ ///
+ /// If the symbol type does not match,
+ /// _org.antlr.v4.runtime.ANTLRErrorStrategy#recoverInline_ is called on the current error
+ /// strategy to attempt recovery. If _#getBuildParseTree_ is
+ /// `true` and the token index of the symbol returned by
+ /// _org.antlr.v4.runtime.ANTLRErrorStrategy#recoverInline_ is -1, the symbol is added to
+ /// the parse tree by calling _#createErrorNode(ParserRuleContext, Token)_ then
+ /// _ParserRuleContext#addErrorNode(ErrorNode)_.
+ ///
+ /// - Parameter ttype: the token type to match
+ /// - Throws: org.antlr.v4.runtime.RecognitionException if the current input symbol did not match
+ /// `ttype` and the error strategy could not recover from the
+ /// mismatched symbol
+ /// - Returns: the matched symbol
+ ///
@discardableResult
public func match(_ ttype: Int) throws -> Token {
- var t: Token = try getCurrentToken()
+ var t = try getCurrentToken()
if t.getType() == ttype {
_errHandler.reportMatch(self)
try consume()
@@ -200,27 +199,27 @@ open class Parser: Recognizer {
return t
}
- /**
- * Match current input symbol as a wildcard. If the symbol type matches
- * (i.e. has a value greater than 0), {@link org.antlr.v4.runtime.ANTLRErrorStrategy#reportMatch}
- * and {@link #consume} are called to complete the match process.
- *
- * If the symbol type does not match,
- * {@link org.antlr.v4.runtime.ANTLRErrorStrategy#recoverInline} is called on the current error
- * strategy to attempt recovery. If {@link #getBuildParseTree} is
- * {@code true} and the token index of the symbol returned by
- * {@link org.antlr.v4.runtime.ANTLRErrorStrategy#recoverInline} is -1, the symbol is added to
- * the parse tree by calling {@link #createErrorNode(ParserRuleContext, Token)} then
- * {@link ParserRuleContext#addErrorNode(ErrorNode)}.
- *
- * @return the matched symbol
- * @throws org.antlr.v4.runtime.RecognitionException if the current input symbol did not match
- * a wildcard and the error strategy could not recover from the mismatched
- * symbol
- *///; RecognitionException
+ ///
+ /// Match current input symbol as a wildcard. If the symbol type matches
+ /// (i.e. has a value greater than 0), _org.antlr.v4.runtime.ANTLRErrorStrategy#reportMatch_
+ /// and _#consume_ are called to complete the match process.
+ ///
+ /// If the symbol type does not match,
+ /// _org.antlr.v4.runtime.ANTLRErrorStrategy#recoverInline_ is called on the current error
+ /// strategy to attempt recovery. If _#getBuildParseTree_ is
+ /// `true` and the token index of the symbol returned by
+ /// _org.antlr.v4.runtime.ANTLRErrorStrategy#recoverInline_ is -1, the symbol is added to
+ /// the parse tree by calling _#createErrorNode(ParserRuleContext, Token)_ then
+ /// _ParserRuleContext#addErrorNode(ErrorNode)_.
+ ///
+ /// - Throws: org.antlr.v4.runtime.RecognitionException if the current input symbol did not match
+ /// a wildcard and the error strategy could not recover from the mismatched
+ /// symbol
+ /// - Returns: the matched symbol
+ ///
@discardableResult
public func matchWildcard() throws -> Token {
- var t: Token = try getCurrentToken()
+ var t = try getCurrentToken()
if t.getType() > 0 {
_errHandler.reportMatch(self)
try consume()
@@ -236,43 +235,43 @@ open class Parser: Recognizer {
return t
}
- /**
- * Track the {@link org.antlr.v4.runtime.ParserRuleContext} objects during the parse and hook
- * them up using the {@link org.antlr.v4.runtime.ParserRuleContext#children} list so that it
- * forms a parse tree. The {@link org.antlr.v4.runtime.ParserRuleContext} returned from the start
- * rule represents the root of the parse tree.
- *
- * Note that if we are not building parse trees, rule contexts only point
- * upwards. When a rule exits, it returns the context but that gets garbage
- * collected if nobody holds a reference. It points upwards but nobody
- * points at it.
- *
- * When we build parse trees, we are adding all of these contexts to
- * {@link org.antlr.v4.runtime.ParserRuleContext#children} list. Contexts are then not candidates
- * for garbage collection.
- */
+ ///
+ /// Track the _org.antlr.v4.runtime.ParserRuleContext_ objects during the parse and hook
+ /// them up using the _org.antlr.v4.runtime.ParserRuleContext#children_ list so that it
+ /// forms a parse tree. The _org.antlr.v4.runtime.ParserRuleContext_ returned from the start
+ /// rule represents the root of the parse tree.
+ ///
+ /// Note that if we are not building parse trees, rule contexts only point
+ /// upwards. When a rule exits, it returns the context but that gets garbage
+ /// collected if nobody holds a reference. It points upwards but nobody
+ /// points at it.
+ ///
+ /// When we build parse trees, we are adding all of these contexts to
+ /// _org.antlr.v4.runtime.ParserRuleContext#children_ list. Contexts are then not candidates
+ /// for garbage collection.
+ ///
public func setBuildParseTree(_ buildParseTrees: Bool) {
self._buildParseTrees = buildParseTrees
}
- /**
- * Gets whether or not a complete parse tree will be constructed while
- * parsing. This property is {@code true} for a newly constructed parser.
- *
- * @return {@code true} if a complete parse tree will be constructed while
- * parsing, otherwise {@code false}
- */
+ ///
+ /// Gets whether or not a complete parse tree will be constructed while
+ /// parsing. This property is `true` for a newly constructed parser.
+ ///
+ /// - Returns: `true` if a complete parse tree will be constructed while
+ /// parsing, otherwise `false`
+ ///
public func getBuildParseTree() -> Bool {
return _buildParseTrees
}
- /**
- * Trim the internal lists of the parse tree during parsing to conserve memory.
- * This property is set to {@code false} by default for a newly constructed parser.
- *
- * @param trimParseTrees {@code true} to trim the capacity of the {@link org.antlr.v4.runtime.ParserRuleContext#children}
- * list to its size after a rule is parsed.
- */
+ ///
+ /// Trim the internal lists of the parse tree during parsing to conserve memory.
+ /// This property is set to `false` by default for a newly constructed parser.
+ ///
+ /// - Parameter trimParseTrees: `true` to trim the capacity of the _org.antlr.v4.runtime.ParserRuleContext#children_
+ /// list to its size after a rule is parsed.
+ ///
public func setTrimParseTree(_ trimParseTrees: Bool) {
if trimParseTrees {
if getTrimParseTree() {
@@ -284,72 +283,61 @@ open class Parser: Recognizer {
}
}
- /**
- * @return {@code true} if the {@link org.antlr.v4.runtime.ParserRuleContext#children} list is trimmed
- * using the default {@link org.antlr.v4.runtime.Parser.TrimToSizeListener} during the parse process.
- */
+ ///
+ /// - Returns: `true` if the _org.antlr.v4.runtime.ParserRuleContext#children_ list is trimmed
+ /// using the default _org.antlr.v4.runtime.Parser.TrimToSizeListener_ during the parse process.
+ ///
public func getTrimParseTree() -> Bool {
-
return !getParseListeners().filter({ $0 === TrimToSizeListener.INSTANCE }).isEmpty
}
-
- public func getParseListeners() -> Array {
- let listeners: Array? = _parseListeners
- if listeners == nil {
- return Array()
- }
-
- return listeners!
+ public func getParseListeners() -> [ParseTreeListener] {
+ return _parseListeners ?? [ParseTreeListener]()
}
- /**
- * Registers {@code listener} to receive events during the parsing process.
- *
- * To support output-preserving grammar transformations (including but not
- * limited to left-recursion removal, automated left-factoring, and
- * optimized code generation), calls to listener methods during the parse
- * may differ substantially from calls made by
- * {@link org.antlr.v4.runtime.tree.ParseTreeWalker#DEFAULT} used after the parse is complete. In
- * particular, rule entry and exit events may occur in a different order
- * during the parse than after the parser. In addition, calls to certain
- * rule entry methods may be omitted.
- *
- * With the following specific exceptions, calls to listener events are
- * deterministic, i.e. for identical input the calls to listener
- * methods will be the same.
- *
- *
- * - Alterations to the grammar used to generate code may change the
- * behavior of the listener calls.
- * - Alterations to the command line options passed to ANTLR 4 when
- * generating the parser may change the behavior of the listener calls.
- * - Changing the version of the ANTLR Tool used to generate the parser
- * may change the behavior of the listener calls.
- *
- *
- * @param listener the listener to add
- *
- * @throws NullPointerException if {@code} listener is {@code null}
- */
+ ///
+ /// Registers `listener` to receive events during the parsing process.
+ ///
+ /// To support output-preserving grammar transformations (including but not
+ /// limited to left-recursion removal, automated left-factoring, and
+ /// optimized code generation), calls to listener methods during the parse
+ /// may differ substantially from calls made by
+ /// _org.antlr.v4.runtime.tree.ParseTreeWalker#DEFAULT_ used after the parse is complete. In
+ /// particular, rule entry and exit events may occur in a different order
+ /// during the parse than after the parser. In addition, calls to certain
+ /// rule entry methods may be omitted.
+ ///
+ /// With the following specific exceptions, calls to listener events are
+ /// __deterministic__, i.e. for identical input the calls to listener
+ /// methods will be the same.
+ ///
+ /// * Alterations to the grammar used to generate code may change the
+ /// behavior of the listener calls.
+ /// * Alterations to the command line options passed to ANTLR 4 when
+ /// generating the parser may change the behavior of the listener calls.
+ /// * Changing the version of the ANTLR Tool used to generate the parser
+ /// may change the behavior of the listener calls.
+ ///
+ /// - Parameter listener: the listener to add
+ ///
public func addParseListener(_ listener: ParseTreeListener) {
if _parseListeners == nil {
- _parseListeners = Array()
+ _parseListeners = [ParseTreeListener]()
}
- self._parseListeners!.append(listener)
+ _parseListeners!.append(listener)
}
- /**
- * Remove {@code listener} from the list of parse listeners.
- *
- * If {@code listener} is {@code null} or has not been added as a parse
- * listener, this method does nothing.
- *
- * @see #addParseListener
- *
- * @param listener the listener to remove
- */
+ ///
+ /// Remove `listener` from the list of parse listeners.
+ ///
+ /// If `listener` is `null` or has not been added as a parse
+ /// listener, this method does nothing.
+ ///
+ /// - SeeAlso: #addParseListener
+ ///
+ /// - Parameter listener: the listener to remove
+ ///
public func removeParseListener(_ listener: ParseTreeListener?) {
if _parseListeners != nil {
@@ -364,20 +352,20 @@ open class Parser: Recognizer {
}
}
- /**
- * Remove all parse listeners.
- *
- * @see #addParseListener
- */
+ ///
+ /// Remove all parse listeners.
+ ///
+ /// - SeeAlso: #addParseListener
+ ///
public func removeParseListeners() {
_parseListeners = nil
}
- /**
- * Notify any parse listeners of an enter rule event.
- *
- * @see #addParseListener
- */
+ ///
+ /// Notify any parse listeners of an enter rule event.
+ ///
+ /// - SeeAlso: #addParseListener
+ ///
public func triggerEnterRuleEvent() throws {
if let _parseListeners = _parseListeners, let _ctx = _ctx {
for listener: ParseTreeListener in _parseListeners {
@@ -387,63 +375,59 @@ open class Parser: Recognizer {
}
}
- /**
- * Notify any parse listeners of an exit rule event.
- *
- * @see #addParseListener
- */
+ ///
+ /// Notify any parse listeners of an exit rule event.
+ ///
+ /// - SeeAlso: #addParseListener
+ ///
public func triggerExitRuleEvent() throws {
// reverse order walk of listeners
if let _parseListeners = _parseListeners, let _ctx = _ctx {
- var i: Int = _parseListeners.count - 1
+ var i = _parseListeners.count - 1
while i >= 0 {
- let listener: ParseTreeListener = _parseListeners[i]
+ let listener = _parseListeners[i]
_ctx.exitRule(listener)
- try listener.exitEveryRule(_ctx)
+ try listener.exitEveryRule(_ctx)
i -= 1
}
}
}
- /**
- * Gets the number of syntax errors reported during parsing. This value is
- * incremented each time {@link #notifyErrorListeners} is called.
- *
- * @see #notifyErrorListeners
- */
+ ///
+ /// Gets the number of syntax errors reported during parsing. This value is
+ /// incremented each time _#notifyErrorListeners_ is called.
+ ///
+ /// - SeeAlso: #notifyErrorListeners
+ ///
public func getNumberOfSyntaxErrors() -> Int {
return _syntaxErrors
}
override
open func getTokenFactory() -> TokenFactory {
- //
return _input.getTokenSource().getTokenFactory()
}
- /** Tell our token source and error strategy about a new way to create tokens. */
+ /// Tell our token source and error strategy about a new way to create tokens.
override
open func setTokenFactory(_ factory: TokenFactory) {
- //
_input.getTokenSource().setTokenFactory(factory)
}
- /**
- * The ATN with bypass alternatives is expensive to create so we create it
- * lazily.
- *
- * @throws UnsupportedOperationException if the current parser does not
- * implement the {@link #getSerializedATN()} method.
- */
-
+ ///
+ /// The ATN with bypass alternatives is expensive to create so we create it
+ /// lazily.
+ ///
+ /// - Throws: _ANTLRError.unsupportedOperation_ if the current parser does not
+ /// implement the _#getSerializedATN()_ method.
+ ///
public func getATNWithBypassAlts() -> ATN {
- let serializedAtn: String = getSerializedATN()
+ let serializedAtn = getSerializedATN()
- var result: ATN? = bypassAltsAtnCache[serializedAtn]
- bypassAltsAtnCacheMutex.synchronized {
- [unowned self] in
+ var result = bypassAltsAtnCache[serializedAtn]
+ bypassAltsAtnCacheMutex.synchronized { [unowned self] in
if result == nil {
- let deserializationOptions: ATNDeserializationOptions = ATNDeserializationOptions()
+ let deserializationOptions = ATNDeserializationOptions()
try! deserializationOptions.setGenerateRuleBypassTransitions(true)
result = try! ATNDeserializer(deserializationOptions).deserialize(Array(serializedAtn.characters))
self.bypassAltsAtnCache[serializedAtn] = result!
@@ -452,36 +436,34 @@ open class Parser: Recognizer {
return result!
}
- /**
- * The preferred method of getting a tree pattern. For example, here's a
- * sample use:
- *
- *
- * ParseTree t = parser.expr();
- * ParseTreePattern p = parser.compileParseTreePattern("<ID>+0", MyParser.RULE_expr);
- * ParseTreeMatch m = p.match(t);
- * String id = m.get("ID");
- *
- */
+ ///
+ /// The preferred method of getting a tree pattern. For example, here's a
+ /// sample use:
+ ///
+ ///
+ /// ParseTree t = parser.expr();
+ /// ParseTreePattern p = parser.compileParseTreePattern("<ID>+0", MyParser.RULE_expr);
+ /// ParseTreeMatch m = p.match(t);
+ /// String id = m.get("ID");
+ ///
+ ///
public func compileParseTreePattern(_ pattern: String, _ patternRuleIndex: Int) throws -> ParseTreePattern {
if let tokenStream = getTokenStream() {
- let tokenSource: TokenSource = tokenStream.getTokenSource()
- if tokenSource is Lexer {
- let lexer: Lexer = tokenSource as! Lexer
+ let tokenSource = tokenStream.getTokenSource()
+ if let lexer = tokenSource as? Lexer {
return try compileParseTreePattern(pattern, patternRuleIndex, lexer)
}
}
throw ANTLRError.unsupportedOperation(msg: "Parser can't discover a lexer to use")
-
}
- /**
- * The same as {@link #compileParseTreePattern(String, int)} but specify a
- * {@link org.antlr.v4.runtime.Lexer} rather than trying to deduce it from this parser.
- */
+ ///
+ /// The same as _#compileParseTreePattern(String, int)_ but specify a
+ /// _org.antlr.v4.runtime.Lexer_ rather than trying to deduce it from this parser.
+ ///
public func compileParseTreePattern(_ pattern: String, _ patternRuleIndex: Int,
_ lexer: Lexer) throws -> ParseTreePattern {
- let m: ParseTreePatternMatcher = ParseTreePatternMatcher(lexer, self)
+ let m = ParseTreePatternMatcher(lexer, self)
return try m.compile(pattern, patternRuleIndex)
}
@@ -508,7 +490,7 @@ open class Parser: Recognizer {
return _input
}
- /** Set the token stream and reset the parser. */
+ /// Set the token stream and reset the parser.
public func setTokenStream(_ input: TokenStream) throws {
//TODO self._input = nil;
self._input = nil;
@@ -516,74 +498,76 @@ open class Parser: Recognizer {
self._input = input
}
- /** Match needs to return the current input symbol, which gets put
- * into the label for the associated token ref; e.g., x=ID.
- */
+ /// Match needs to return the current input symbol, which gets put
+ /// into the label for the associated token ref; e.g., x=ID.
+ ///
public func getCurrentToken() throws -> Token {
return try _input.LT(1)!
}
- public final func notifyErrorListeners(_ msg: String) throws {
- try notifyErrorListeners(getCurrentToken(), msg, nil)
+ public final func notifyErrorListeners(_ msg: String) {
+ let token = try? getCurrentToken()
+ notifyErrorListeners(token, msg, nil)
}
- public func notifyErrorListeners(_ offendingToken: Token, _ msg: String,
- _ e: AnyObject?) {
+ public func notifyErrorListeners(_ offendingToken: Token?, _ msg: String, _ e: AnyObject?) {
_syntaxErrors += 1
- var line: Int = -1
- var charPositionInLine: Int = -1
- line = offendingToken.getLine()
- charPositionInLine = offendingToken.getCharPositionInLine()
+ var line = -1
+ var charPositionInLine = -1
+ if let offendingToken = offendingToken {
+ line = offendingToken.getLine()
+ charPositionInLine = offendingToken.getCharPositionInLine()
+ }
- let listener: ANTLRErrorListener = getErrorListenerDispatch()
+ let listener = getErrorListenerDispatch()
listener.syntaxError(self, offendingToken, line, charPositionInLine, msg, e)
}
- /**
- * Consume and return the {@linkplain #getCurrentToken current symbol}.
- *
- * E.g., given the following input with {@code A} being the current
- * lookahead symbol, this function moves the cursor to {@code B} and returns
- * {@code A}.
- *
- *
- * A B
- * ^
- *
- *
- * If the parser is not in error recovery mode, the consumed symbol is added
- * to the parse tree using {@link ParserRuleContext#addChild(TerminalNode)}, and
- * {@link org.antlr.v4.runtime.tree.ParseTreeListener#visitTerminal} is called on any parse listeners.
- * If the parser is in error recovery mode, the consumed symbol is
- * added to the parse tree using {@link #createErrorNode(ParserRuleContext, Token)} then
- * {@link ParserRuleContext#addErrorNode(ErrorNode)} and
- * {@link org.antlr.v4.runtime.tree.ParseTreeListener#visitErrorNode} is called on any parse
- * listeners.
- */
+ ///
+ /// Consume and return the |: #getCurrentToken current symbol:|.
+ ///
+ /// E.g., given the following input with `A` being the current
+ /// lookahead symbol, this function moves the cursor to `B` and returns
+ /// `A`.
+ ///
+ ///
+ /// A B
+ /// ^
+ ///
+ ///
+ /// If the parser is not in error recovery mode, the consumed symbol is added
+ /// to the parse tree using _ParserRuleContext#addChild(TerminalNode)_, and
+ /// _org.antlr.v4.runtime.tree.ParseTreeListener#visitTerminal_ is called on any parse listeners.
+ /// If the parser __is__ in error recovery mode, the consumed symbol is
+ /// added to the parse tree using _#createErrorNode(ParserRuleContext, Token)_ then
+ /// _ParserRuleContext#addErrorNode(ErrorNode)_ and
+ /// _org.antlr.v4.runtime.tree.ParseTreeListener#visitErrorNode_ is called on any parse
+ /// listeners.
+ ///
@discardableResult
public func consume() throws -> Token {
- let o: Token = try getCurrentToken()
+ let o = try getCurrentToken()
if o.getType() != Parser.EOF {
try getInputStream()!.consume()
}
guard let _ctx = _ctx else {
return o
}
- let hasListener: Bool = _parseListeners != nil && !_parseListeners!.isEmpty
+ let hasListener = _parseListeners != nil && !_parseListeners!.isEmpty
if _buildParseTrees || hasListener {
if _errHandler.inErrorRecoveryMode(self) {
- let node: ErrorNode = _ctx.addErrorNode(createErrorNode(parent: _ctx, t: o))
+ let node = _ctx.addErrorNode(createErrorNode(parent: _ctx, t: o))
if let _parseListeners = _parseListeners {
- for listener: ParseTreeListener in _parseListeners {
+ for listener in _parseListeners {
listener.visitErrorNode(node)
}
}
} else {
- let node: TerminalNode = _ctx.addChild(createTerminalNode(parent: _ctx, t: o))
+ let node = _ctx.addChild(createTerminalNode(parent: _ctx, t: o))
if let _parseListeners = _parseListeners {
- for listener: ParseTreeListener in _parseListeners {
+ for listener in _parseListeners {
listener.visitTerminal(node)
}
}
@@ -592,20 +576,20 @@ open class Parser: Recognizer {
return o
}
- /** How to create a token leaf node associated with a parent.
- * Typically, the terminal node to create is not a function of the parent.
- *
- * @since 4.7
- */
+ /// How to create a token leaf node associated with a parent.
+ /// Typically, the terminal node to create is not a function of the parent.
+ ///
+ /// - Since: 4.7
+ ///
public func createTerminalNode(parent: ParserRuleContext, t: Token) -> TerminalNode {
return TerminalNodeImpl(t);
}
- /** How to create an error node, given a token, associated with a parent.
- * Typically, the error node to create is not a function of the parent.
- *
- * @since 4.7
- */
+ /// How to create an error node, given a token, associated with a parent.
+ /// Typically, the error node to create is not a function of the parent.
+ ///
+ /// - Since: 4.7
+ ///
public func createErrorNode(parent: ParserRuleContext, t: Token) -> ErrorNode {
return ErrorNode(t);
}
@@ -618,10 +602,10 @@ open class Parser: Recognizer {
}
}
- /**
- * Always called by generated parsers upon entry to a rule. Access field
- * {@link #_ctx} get the current context.
- */
+ ///
+ /// Always called by generated parsers upon entry to a rule. Access field
+ /// _#_ctx_ get the current context.
+ ///
public func enterRule(_ localctx: ParserRuleContext, _ state: Int, _ ruleIndex: Int) throws {
setState(state)
_ctx = localctx
@@ -660,12 +644,12 @@ open class Parser: Recognizer {
}
}
- /**
- * Get the precedence level for the top-most precedence rule.
- *
- * @return The precedence level for the top-most precedence rule, or -1 if
- * the parser context is not nested within a precedence rule.
- */
+ ///
+ /// Get the precedence level for the top-most precedence rule.
+ ///
+ /// - Returns: The precedence level for the top-most precedence rule, or -1 if
+ /// the parser context is not nested within a precedence rule.
+ ///
public final func getPrecedence() -> Int {
if _precedenceStack.isEmpty {
return -1
@@ -674,11 +658,13 @@ open class Parser: Recognizer {
return _precedenceStack.peek() ?? -1
}
- /**
- * @deprecated Use
- * {@link #enterRecursionRule(org.antlr.v4.runtime.ParserRuleContext, int, int, int)} instead.
- */
- ////@Deprecated
+ ///
+ /// Use
+ /// _#enterRecursionRule(org.antlr.v4.runtime.ParserRuleContext, int, int, int)_ instead.
+ ///
+ ///
+ /// /@Deprecated
+ ///
public func enterRecursionRule(_ localctx: ParserRuleContext, _ ruleIndex: Int) throws {
try enterRecursionRule(localctx, getATN().ruleToStartState[ruleIndex].stateNumber, ruleIndex, 0)
}
@@ -693,11 +679,11 @@ open class Parser: Recognizer {
}
}
- /** Like {@link #enterRule} but for recursive rules.
- * Make the current context the child of the incoming localctx.
- */
+ /// Like _#enterRule_ but for recursive rules.
+ /// Make the current context the child of the incoming localctx.
+ ///
public func pushNewRecursionContext(_ localctx: ParserRuleContext, _ state: Int, _ ruleIndex: Int) throws {
- let previous: ParserRuleContext = _ctx!
+ let previous = _ctx!
previous.parent = localctx
previous.invokingState = state
previous.stop = try _input.LT(-1)
@@ -716,12 +702,12 @@ open class Parser: Recognizer {
public func unrollRecursionContexts(_ _parentctx: ParserRuleContext?) throws {
_precedenceStack.pop()
_ctx!.stop = try _input.LT(-1)
- let retctx: ParserRuleContext = _ctx! // save current ctx (return value)
+ let retctx = _ctx! // save current ctx (return value)
// unroll so _ctx is as it was before call to recursive method
if _parseListeners != nil {
- while let ctxWrap = _ctx , ctxWrap !== _parentctx {
- try triggerExitRuleEvent()
+ while let ctxWrap = _ctx, ctxWrap !== _parentctx {
+ try triggerExitRuleEvent()
_ctx = ctxWrap.parent as? ParserRuleContext
}
} else {
@@ -738,7 +724,7 @@ open class Parser: Recognizer {
}
public func getInvokingContext(_ ruleIndex: Int) -> ParserRuleContext? {
- var p: ParserRuleContext? = _ctx
+ var p = _ctx
while let pWrap = p {
if pWrap.getRuleIndex() == ruleIndex {
return pWrap
@@ -766,63 +752,63 @@ open class Parser: Recognizer {
return false
}
- /** Given an AmbiguityInfo object that contains information about an
- * ambiguous decision event, return the list of ambiguous parse trees.
- * An ambiguity occurs when a specific token sequence can be recognized
- * in more than one way by the grammar. These ambiguities are detected only
- * at decision points.
- *
- * The list of trees includes the actual interpretation (that for
- * the minimum alternative number) and all ambiguous alternatives.
- * The actual interpretation is always first.
- *
- * This method reuses the same physical input token stream used to
- * detect the ambiguity by the original parser in the first place.
- * This method resets/seeks within but does not alter originalParser.
- * The input position is restored upon exit from this method.
- * Parsers using a {@link org.antlr.v4.runtime.UnbufferedTokenStream} may not be able to
- * perform the necessary save index() / seek(saved_index) operation.
- *
- * The trees are rooted at the node whose start..stop token indices
- * include the start and stop indices of this ambiguity event. That is,
- * the trees returns will always include the complete ambiguous subphrase
- * identified by the ambiguity event.
- *
- * Be aware that this method does NOT notify error or parse listeners as
- * it would trigger duplicate or otherwise unwanted events.
- *
- * This uses a temporary ParserATNSimulator and a ParserInterpreter
- * so we don't mess up any statistics, event lists, etc...
- * The parse tree constructed while identifying/making ambiguityInfo is
- * not affected by this method as it creates a new parser interp to
- * get the ambiguous interpretations.
- *
- * Nodes in the returned ambig trees are independent of the original parse
- * tree (constructed while identifying/creating ambiguityInfo).
- *
- * @since 4.5.1
- *
- * @param originalParser The parser used to create ambiguityInfo; it
- * is not modified by this routine and can be either
- * a generated or interpreted parser. It's token
- * stream *is* reset/seek()'d.
- * @param ambiguityInfo The information about an ambiguous decision event
- * for which you want ambiguous parse trees.
- * @param startRuleIndex The start rule for the entire grammar, not
- * the ambiguous decision. We re-parse the entire input
- * and so we need the original start rule.
- *
- * @return The list of all possible interpretations of
- * the input for the decision in ambiguityInfo.
- * The actual interpretation chosen by the parser
- * is always given first because this method
- * retests the input in alternative order and
- * ANTLR always resolves ambiguities by choosing
- * the first alternative that matches the input.
- *
- * @throws org.antlr.v4.runtime.RecognitionException Throws upon syntax error while matching
- * ambig input.
- */
+ /// Given an AmbiguityInfo object that contains information about an
+ /// ambiguous decision event, return the list of ambiguous parse trees.
+ /// An ambiguity occurs when a specific token sequence can be recognized
+ /// in more than one way by the grammar. These ambiguities are detected only
+ /// at decision points.
+ ///
+ /// The list of trees includes the actual interpretation (that for
+ /// the minimum alternative number) and all ambiguous alternatives.
+ /// The actual interpretation is always first.
+ ///
+ /// This method reuses the same physical input token stream used to
+ /// detect the ambiguity by the original parser in the first place.
+ /// This method resets/seeks within but does not alter originalParser.
+ /// The input position is restored upon exit from this method.
+ /// Parsers using a _org.antlr.v4.runtime.UnbufferedTokenStream_ may not be able to
+ /// perform the necessary save index() / seek(saved_index) operation.
+ ///
+ /// The trees are rooted at the node whose start..stop token indices
+ /// include the start and stop indices of this ambiguity event. That is,
+ /// the trees returns will always include the complete ambiguous subphrase
+ /// identified by the ambiguity event.
+ ///
+ /// Be aware that this method does NOT notify error or parse listeners as
+ /// it would trigger duplicate or otherwise unwanted events.
+ ///
+ /// This uses a temporary ParserATNSimulator and a ParserInterpreter
+ /// so we don't mess up any statistics, event lists, etc...
+ /// The parse tree constructed while identifying/making ambiguityInfo is
+ /// not affected by this method as it creates a new parser interp to
+ /// get the ambiguous interpretations.
+ ///
+ /// Nodes in the returned ambig trees are independent of the original parse
+ /// tree (constructed while identifying/creating ambiguityInfo).
+ ///
+ /// - Since: 4.5.1
+ ///
+ /// - Parameter originalParser: The parser used to create ambiguityInfo; it
+ /// is not modified by this routine and can be either
+ /// a generated or interpreted parser. It's token
+ /// stream *is* reset/seek()'d.
+ /// - Parameter ambiguityInfo: The information about an ambiguous decision event
+ /// for which you want ambiguous parse trees.
+ /// - Parameter startRuleIndex: The start rule for the entire grammar, not
+ /// the ambiguous decision. We re-parse the entire input
+ /// and so we need the original start rule.
+ ///
+ /// - Throws: org.antlr.v4.runtime.RecognitionException Throws upon syntax error while matching
+ /// ambig input.
+ /// - Returns: The list of all possible interpretations of
+ /// the input for the decision in ambiguityInfo.
+ /// The actual interpretation chosen by the parser
+ /// is always given first because this method
+ /// retests the input in alternative order and
+ /// ANTLR always resolves ambiguities by choosing
+ /// the first alternative that matches the input.
+ ///
+ ///
// public class func getAmbiguousParseTrees(originalParser : Parser,
// _ ambiguityInfo : AmbiguityInfo,
// _ startRuleIndex : Int) throws -> Array //; RecognitionException
@@ -851,7 +837,7 @@ open class Parser: Recognizer {
// parser.getInterpreter()!.setPredictionMode(PredictionMode.LL_EXACT_AMBIG_DETECTION);
//
// // get ambig trees
-// var alt : Int = ambiguityInfo.ambigAlts.nextSetBit(0);
+// var alt : Int = ambiguityInfo.ambigAlts.firstSetBit();
// while alt>=0 {
// // re-parse entire input for all ambiguous alternatives
// // (don't have to do first as it's been parsed, but do again for simplicity
@@ -875,26 +861,25 @@ open class Parser: Recognizer {
// return trees;
// }
- /**
- * Checks whether or not {@code symbol} can follow the current state in the
- * ATN. The behavior of this method is equivalent to the following, but is
- * implemented such that the complete context-sensitive follow set does not
- * need to be explicitly constructed.
- *
- *
- * return getExpectedTokens().contains(symbol);
- *
- *
- * @param symbol the symbol type to check
- * @return {@code true} if {@code symbol} can follow the current state in
- * the ATN, otherwise {@code false}.
- */
- public func isExpectedToken(_ symbol: Int) throws -> Bool {
-// return getInterpreter().atn.nextTokens(_ctx);
- let atn: ATN = getInterpreter().atn
+ ///
+ /// Checks whether or not `symbol` can follow the current state in the
+ /// ATN. The behavior of this method is equivalent to the following, but is
+ /// implemented such that the complete context-sensitive follow set does not
+ /// need to be explicitly constructed.
+ ///
+ ///
+ /// return getExpectedTokens().contains(symbol);
+ ///
+ ///
+ /// - Parameter symbol: the symbol type to check
+ /// - Returns: `true` if `symbol` can follow the current state in
+ /// the ATN, otherwise `false`.
+ ///
+ public func isExpectedToken(_ symbol: Int) -> Bool {
+ let atn = getInterpreter().atn
var ctx: ParserRuleContext? = _ctx
- let s: ATNState = atn.states[getState()]!
- var following: IntervalSet = try atn.nextTokens(s)
+ let s = atn.states[getState()]!
+ var following = atn.nextTokens(s)
if following.contains(symbol) {
return true
}
@@ -903,10 +888,10 @@ open class Parser: Recognizer {
return false
}
- while let ctxWrap = ctx , ctxWrap.invokingState >= 0 && following.contains(CommonToken.EPSILON) {
- let invokingState: ATNState = atn.states[ctxWrap.invokingState]!
- let rt: RuleTransition = invokingState.transition(0) as! RuleTransition
- following = try atn.nextTokens(rt.followState)
+ while let ctxWrap = ctx, ctxWrap.invokingState >= 0 && following.contains(CommonToken.EPSILON) {
+ let invokingState = atn.states[ctxWrap.invokingState]!
+ let rt = invokingState.transition(0) as! RuleTransition
+ following = atn.nextTokens(rt.followState)
if following.contains(symbol) {
return true
}
@@ -921,55 +906,51 @@ open class Parser: Recognizer {
return false
}
- /**
- * Computes the set of input symbols which could follow the current parser
- * state and context, as given by {@link #getState} and {@link #getContext},
- * respectively.
- *
- * @see org.antlr.v4.runtime.atn.ATN#getExpectedTokens(int, org.antlr.v4.runtime.RuleContext)
- */
+ ///
+ /// Computes the set of input symbols which could follow the current parser
+ /// state and context, as given by _#getState_ and _#getContext_,
+ /// respectively.
+ ///
+ /// - SeeAlso: org.antlr.v4.runtime.atn.ATN#getExpectedTokens(int, org.antlr.v4.runtime.RuleContext)
+ ///
public func getExpectedTokens() throws -> IntervalSet {
return try getATN().getExpectedTokens(getState(), getContext()!)
}
- public func getExpectedTokensWithinCurrentRule() throws -> IntervalSet {
- let atn: ATN = getInterpreter().atn
- let s: ATNState = atn.states[getState()]!
- return try atn.nextTokens(s)
+ public func getExpectedTokensWithinCurrentRule() -> IntervalSet {
+ let atn = getInterpreter().atn
+ let s = atn.states[getState()]!
+ return atn.nextTokens(s)
}
- /** Get a rule's index (i.e., {@code RULE_ruleName} field) or -1 if not found. */
+ /// Get a rule's index (i.e., `RULE_ruleName` field) or -1 if not found.
public func getRuleIndex(_ ruleName: String) -> Int {
- let ruleIndex: Int? = getRuleIndexMap()[ruleName]
- if ruleIndex != nil {
- return ruleIndex!
- }
- return -1
+ return getRuleIndexMap()[ruleName] ?? -1
}
public func getRuleContext() -> ParserRuleContext? {
return _ctx
}
- /** Return List<String> of the rule names in your parser instance
- * leading up to a call to the current rule. You could override if
- * you want more details such as the file/line info of where
- * in the ATN a rule is invoked.
- *
- * This is very useful for error messages.
- */
- public func getRuleInvocationStack() -> Array {
+ /// Return List<String> of the rule names in your parser instance
+ /// leading up to a call to the current rule. You could override if
+ /// you want more details such as the file/line info of where
+ /// in the ATN a rule is invoked.
+ ///
+ /// This is very useful for error messages.
+ ///
+ public func getRuleInvocationStack() -> [String] {
return getRuleInvocationStack(_ctx)
}
- public func getRuleInvocationStack(_ p: RuleContext?) -> Array {
+ public func getRuleInvocationStack(_ p: RuleContext?) -> [String] {
var p = p
- var ruleNames: [String] = getRuleNames()
- var stack: Array = Array()
+ var ruleNames = getRuleNames()
+ var stack = [String]()
while let pWrap = p {
// compute what follows who invoked us
- let ruleIndex: Int = pWrap.getRuleIndex()
+ let ruleIndex = pWrap.getRuleIndex()
if ruleIndex < 0 {
stack.append("n/a")
} else {
@@ -980,17 +961,15 @@ open class Parser: Recognizer {
return stack
}
- /** For debugging and other purposes. */
- public func getDFAStrings() -> Array {
- var s: Array = Array()
+ /// For debugging and other purposes.
+ public func getDFAStrings() -> [String] {
+ var s = [String]()
guard let _interp = _interp else {
return s
}
- decisionToDFAMutex.synchronized {
- [unowned self] in
-
+ decisionToDFAMutex.synchronized { [unowned self] in
for d in 0..<_interp.decisionToDFA.count {
- let dfa: DFA = _interp.decisionToDFA[d]
+ let dfa = _interp.decisionToDFA[d]
s.append(dfa.toString(self.getVocabulary()))
}
@@ -998,17 +977,15 @@ open class Parser: Recognizer {
return s
}
- /** For debugging and other purposes. */
+ /// For debugging and other purposes.
public func dumpDFA() {
- guard let _interp = _interp else {
+ guard let _interp = _interp else {
return
}
- decisionToDFAMutex.synchronized {
- [unowned self] in
- var seenOne: Bool = false
+ decisionToDFAMutex.synchronized { [unowned self] in
+ var seenOne = false
- for d in 0..<_interp.decisionToDFA.count {
- let dfa: DFA = _interp.decisionToDFA[d]
+ for dfa in _interp.decisionToDFA {
if !dfa.states.isEmpty {
if seenOne {
print("")
@@ -1028,36 +1005,35 @@ open class Parser: Recognizer {
override
open func getParseInfo() -> ParseInfo? {
- let interp: ParserATNSimulator? = getInterpreter()
- if interp is ProfilingATNSimulator {
- return ParseInfo(interp as! ProfilingATNSimulator)
+ let interp = getInterpreter()
+ if let interp = interp as? ProfilingATNSimulator {
+ return ParseInfo(interp)
}
return nil
}
- /**
- * @since 4.3
- */
+ ///
+ /// - Since: 4.3
+ ///
public func setProfile(_ profile: Bool) {
- let interp: ParserATNSimulator = getInterpreter()
- let saveMode: PredictionMode = interp.getPredictionMode()
+ let interp = getInterpreter()
+ let saveMode = interp.getPredictionMode()
if profile {
if !(interp is ProfilingATNSimulator) {
setInterpreter(ProfilingATNSimulator(self))
}
} else {
if interp is ProfilingATNSimulator {
- let sim: ParserATNSimulator =
- ParserATNSimulator(self, getATN(), interp.decisionToDFA, interp.getSharedContextCache()!)
+ let sim = ParserATNSimulator(self, getATN(), interp.decisionToDFA, interp.getSharedContextCache()!)
setInterpreter(sim)
}
}
getInterpreter().setPredictionMode(saveMode)
}
- /** During a parse is sometimes useful to listen in on the rule entry and exit
- * events as well as token matches. This is for quick and dirty debugging.
- */
+ /// During a parse is sometimes useful to listen in on the rule entry and exit
+ /// events as well as token matches. This is for quick and dirty debugging.
+ ///
public func setTrace(_ trace: Bool) {
if !trace {
removeParseListener(_tracer)
@@ -1072,12 +1048,12 @@ open class Parser: Recognizer {
}
}
- /**
- * Gets whether a {@link org.antlr.v4.runtime.Parser.TraceListener} is registered as a parse listener
- * for the parser.
- *
- * @see #setTrace(boolean)
- */
+ ///
+ /// Gets whether a _org.antlr.v4.runtime.Parser.TraceListener_ is registered as a parse listener
+ /// for the parser.
+ ///
+ /// - SeeAlso: #setTrace(boolean)
+ ///
public func isTrace() -> Bool {
return _tracer != nil
}
diff --git a/runtime/Swift/Sources/Antlr4/ParserInterpreter.swift b/runtime/Swift/Sources/Antlr4/ParserInterpreter.swift
index 6f136cc68..1e760fc84 100644
--- a/runtime/Swift/Sources/Antlr4/ParserInterpreter.swift
+++ b/runtime/Swift/Sources/Antlr4/ParserInterpreter.swift
@@ -5,26 +5,26 @@
-/** A parser simulator that mimics what ANTLR's generated
- * parser code does. A ParserATNSimulator is used to make
- * predictions via adaptivePredict but this class moves a pointer through the
- * ATN to simulate parsing. ParserATNSimulator just
- * makes us efficient rather than having to backtrack, for example.
- *
- * This properly creates parse trees even for left recursive rules.
- *
- * We rely on the left recursive rule invocation and special predicate
- * transitions to make left recursive rules work.
- *
- * See TestParserInterpreter for examples.
- */
+/// A parser simulator that mimics what ANTLR's generated
+/// parser code does. A ParserATNSimulator is used to make
+/// predictions via adaptivePredict but this class moves a pointer through the
+/// ATN to simulate parsing. ParserATNSimulator just
+/// makes us efficient rather than having to backtrack, for example.
+///
+/// This properly creates parse trees even for left recursive rules.
+///
+/// We rely on the left recursive rule invocation and special predicate
+/// transitions to make left recursive rules work.
+///
+/// See TestParserInterpreter for examples.
+///
public class ParserInterpreter: Parser {
internal final var grammarFileName: String
internal final var atn: ATN
- /** This identifies StarLoopEntryState's that begin the (...)*
- * precedence loops of left recursive rules.
- */
+ /// This identifies StarLoopEntryState's that begin the (...)*
+ /// precedence loops of left recursive rules.
+ ///
internal final var statesNeedingLeftRecursionContext: BitSet
internal final var decisionToDFA: [DFA]
@@ -32,37 +32,34 @@ public class ParserInterpreter: Parser {
internal final var sharedContextCache: PredictionContextCache =
PredictionContextCache()
- ////@Deprecated
- internal final var tokenNames: [String]
internal final var ruleNames: [String]
private final var vocabulary: Vocabulary
- /** Tracks LR rules for adjusting the contexts */
+ /// Tracks LR rules for adjusting the contexts
internal final var _parentContextStack: Array<(ParserRuleContext?, Int)> =
Array<(ParserRuleContext?, Int)>()
- /** We need a map from (decision,inputIndex)->forced alt for computing ambiguous
- * parse trees. For now, we allow exactly one override.
- */
+ /// We need a map from (decision,inputIndex)->forced alt for computing ambiguous
+ /// parse trees. For now, we allow exactly one override.
+ ///
internal var overrideDecision: Int = -1
internal var overrideDecisionInputIndex: Int = -1
internal var overrideDecisionAlt: Int = -1
- /** A copy constructor that creates a new parser interpreter by reusing
- * the fields of a previous interpreter.
- *
- * @since 4.5.1
- *
- * @param old The interpreter to copy
- */
+ /// A copy constructor that creates a new parser interpreter by reusing
+ /// the fields of a previous interpreter.
+ ///
+ /// - Since: 4.5.1
+ ///
+ /// - Parameter old: The interpreter to copy
+ ///
public init(_ old: ParserInterpreter) throws {
self.atn = old.atn
self.grammarFileName = old.grammarFileName
self.statesNeedingLeftRecursionContext = old.statesNeedingLeftRecursionContext
self.decisionToDFA = old.decisionToDFA
- self.tokenNames = old.tokenNames
self.ruleNames = old.ruleNames
self.vocabulary = old.vocabulary
try super.init(old.getTokenStream()!)
@@ -71,26 +68,11 @@ public class ParserInterpreter: Parser {
sharedContextCache))
}
- /**
- * @deprecated Use {@link #ParserInterpreter(String, org.antlr.v4.runtime.Vocabulary, java.util.Collection, org.antlr.v4.runtime.atn.ATN, org.antlr.v4.runtime.TokenStream)} instead.
- */
- //@Deprecated
- public convenience init(_ grammarFileName: String, _ tokenNames: Array?,
- _ ruleNames: Array, _ atn: ATN, _ input: TokenStream) throws {
- try self.init(grammarFileName, Vocabulary.fromTokenNames(tokenNames), ruleNames, atn, input)
- }
-
public init(_ grammarFileName: String, _ vocabulary: Vocabulary,
_ ruleNames: Array, _ atn: ATN, _ input: TokenStream) throws {
self.grammarFileName = grammarFileName
self.atn = atn
- self.tokenNames = [String]()// new String[atn.maxTokenType];
- let length = tokenNames.count
- for i in 0.. [String] {
- return tokenNames
- }
-
override
public func getVocabulary() -> Vocabulary {
return vocabulary
@@ -142,19 +118,19 @@ public class ParserInterpreter: Parser {
return grammarFileName
}
- /** Begin parsing at startRuleIndex */
+ /// Begin parsing at startRuleIndex
public func parse(_ startRuleIndex: Int) throws -> ParserRuleContext {
- let startRuleStartState: RuleStartState = atn.ruleToStartState[startRuleIndex]
+ let startRuleStartState = atn.ruleToStartState[startRuleIndex]
- let rootContext: InterpreterRuleContext = InterpreterRuleContext(nil, ATNState.INVALID_STATE_NUMBER, startRuleIndex)
+ let rootContext = InterpreterRuleContext(nil, ATNState.INVALID_STATE_NUMBER, startRuleIndex)
if startRuleStartState.isPrecedenceRule {
- try enterRecursionRule(rootContext, startRuleStartState.stateNumber, startRuleIndex, 0)
+ try enterRecursionRule(rootContext, startRuleStartState.stateNumber, startRuleIndex, 0)
} else {
try enterRule(rootContext, startRuleStartState.stateNumber, startRuleIndex)
}
while true {
- let p: ATNState = getATNState()!
+ let p = getATNState()!
switch p.getStateType() {
case ATNState.RULE_STOP:
// pop; return from rule
@@ -204,7 +180,7 @@ public class ParserInterpreter: Parser {
var altNum: Int
if p.getNumberOfTransitions() > 1 {
try getErrorHandler().sync(self)
- let decision: Int = (p as! DecisionState).decision
+ let decision = (p as! DecisionState).decision
if decision == overrideDecision && _input.index() == overrideDecisionInputIndex {
altNum = overrideDecisionAlt
} else {
@@ -214,7 +190,7 @@ public class ParserInterpreter: Parser {
altNum = 1
}
- let transition: Transition = p.transition(altNum - 1)
+ let transition = p.transition(altNum - 1)
switch transition.getSerializationType() {
case Transition.EPSILON:
if try statesNeedingLeftRecursionContext.get(p.stateNumber) &&
@@ -248,9 +224,9 @@ public class ParserInterpreter: Parser {
break
case Transition.RULE:
- let ruleStartState: RuleStartState = transition.target as! RuleStartState
- let ruleIndex: Int = ruleStartState.ruleIndex!
- let ctx: InterpreterRuleContext = InterpreterRuleContext(_ctx, p.stateNumber, ruleIndex)
+ let ruleStartState = transition.target as! RuleStartState
+ let ruleIndex = ruleStartState.ruleIndex!
+ let ctx = InterpreterRuleContext(_ctx, p.stateNumber, ruleIndex)
if ruleStartState.isPrecedenceRule {
try enterRecursionRule(ctx, ruleStartState.stateNumber, ruleIndex, (transition as! RuleTransition).precedence)
} else {
@@ -259,25 +235,20 @@ public class ParserInterpreter: Parser {
break
case Transition.PREDICATE:
- let predicateTransition: PredicateTransition = transition as! PredicateTransition
+ let predicateTransition = transition as! PredicateTransition
if try !sempred(_ctx!, predicateTransition.ruleIndex, predicateTransition.predIndex) {
-
- throw try ANTLRException.recognition(e: FailedPredicateException(self))
-
+ throw ANTLRException.recognition(e: FailedPredicateException(self))
}
-
break
case Transition.ACTION:
- let actionTransition: ActionTransition = transition as! ActionTransition
+ let actionTransition = transition as! ActionTransition
try action(_ctx, actionTransition.ruleIndex, actionTransition.actionIndex)
break
case Transition.PRECEDENCE:
if !precpred(_ctx!, (transition as! PrecedencePredicateTransition).precedence) {
-
- throw try ANTLRException.recognition(e: FailedPredicateException(self, "precpred(_ctx,\((transition as! PrecedencePredicateTransition).precedence))"))
-
+ throw ANTLRException.recognition(e: FailedPredicateException(self, "precpred(_ctx,\((transition as! PrecedencePredicateTransition).precedence))"))
}
break
@@ -290,59 +261,59 @@ public class ParserInterpreter: Parser {
}
internal func visitRuleStopState(_ p: ATNState) throws {
- let ruleStartState: RuleStartState = atn.ruleToStartState[p.ruleIndex!]
+ let ruleStartState = atn.ruleToStartState[p.ruleIndex!]
if ruleStartState.isPrecedenceRule {
- let parentContext: (ParserRuleContext?, Int) = _parentContextStack.pop()
- try unrollRecursionContexts(parentContext.0!)
- setState(parentContext.1)
+ let (parentContext, parentState) = _parentContextStack.pop()
+ try unrollRecursionContexts(parentContext!)
+ setState(parentState)
} else {
try exitRule()
}
- let ruleTransition: RuleTransition = atn.states[getState()]!.transition(0) as! RuleTransition
+ let ruleTransition = atn.states[getState()]!.transition(0) as! RuleTransition
setState(ruleTransition.followState.stateNumber)
}
- /** Override this parser interpreters normal decision-making process
- * at a particular decision and input token index. Instead of
- * allowing the adaptive prediction mechanism to choose the
- * first alternative within a block that leads to a successful parse,
- * force it to take the alternative, 1..n for n alternatives.
- *
- * As an implementation limitation right now, you can only specify one
- * override. This is sufficient to allow construction of different
- * parse trees for ambiguous input. It means re-parsing the entire input
- * in general because you're never sure where an ambiguous sequence would
- * live in the various parse trees. For example, in one interpretation,
- * an ambiguous input sequence would be matched completely in expression
- * but in another it could match all the way back to the root.
- *
- * s : e '!'? ;
- * e : ID
- * | ID '!'
- * ;
- *
- * Here, x! can be matched as (s (e ID) !) or (s (e ID !)). In the first
- * case, the ambiguous sequence is fully contained only by the root.
- * In the second case, the ambiguous sequences fully contained within just
- * e, as in: (e ID !).
- *
- * Rather than trying to optimize this and make
- * some intelligent decisions for optimization purposes, I settled on
- * just re-parsing the whole input and then using
- * {link Trees#getRootOfSubtreeEnclosingRegion} to find the minimal
- * subtree that contains the ambiguous sequence. I originally tried to
- * record the call stack at the point the parser detected and ambiguity but
- * left recursive rules create a parse tree stack that does not reflect
- * the actual call stack. That impedance mismatch was enough to make
- * it it challenging to restart the parser at a deeply nested rule
- * invocation.
- *
- * Only parser interpreters can override decisions so as to avoid inserting
- * override checking code in the critical ALL(*) prediction execution path.
- *
- * @since 4.5.1
- */
+ /// Override this parser interpreters normal decision-making process
+ /// at a particular decision and input token index. Instead of
+ /// allowing the adaptive prediction mechanism to choose the
+ /// first alternative within a block that leads to a successful parse,
+ /// force it to take the alternative, 1..n for n alternatives.
+ ///
+ /// As an implementation limitation right now, you can only specify one
+ /// override. This is sufficient to allow construction of different
+ /// parse trees for ambiguous input. It means re-parsing the entire input
+ /// in general because you're never sure where an ambiguous sequence would
+ /// live in the various parse trees. For example, in one interpretation,
+ /// an ambiguous input sequence would be matched completely in expression
+ /// but in another it could match all the way back to the root.
+ ///
+ /// s : e '!'? ;
+ /// e : ID
+ /// | ID '!'
+ /// ;
+ ///
+ /// Here, x! can be matched as (s (e ID) !) or (s (e ID !)). In the first
+ /// case, the ambiguous sequence is fully contained only by the root.
+ /// In the second case, the ambiguous sequences fully contained within just
+ /// e, as in: (e ID !).
+ ///
+ /// Rather than trying to optimize this and make
+ /// some intelligent decisions for optimization purposes, I settled on
+ /// just re-parsing the whole input and then using
+ /// {link Trees#getRootOfSubtreeEnclosingRegion} to find the minimal
+ /// subtree that contains the ambiguous sequence. I originally tried to
+ /// record the call stack at the point the parser detected and ambiguity but
+ /// left recursive rules create a parse tree stack that does not reflect
+ /// the actual call stack. That impedance mismatch was enough to make
+ /// it it challenging to restart the parser at a deeply nested rule
+ /// invocation.
+ ///
+ /// Only parser interpreters can override decisions so as to avoid inserting
+ /// override checking code in the critical ALL(*) prediction execution path.
+ ///
+ /// - Since: 4.5.1
+ ///
public func addDecisionOverride(_ decision: Int, _ tokenIndex: Int, _ forcedAlt: Int) {
overrideDecision = decision
overrideDecisionInputIndex = tokenIndex
diff --git a/runtime/Swift/Sources/Antlr4/ParserRuleContext.swift b/runtime/Swift/Sources/Antlr4/ParserRuleContext.swift
index 532018058..deabbc0bd 100644
--- a/runtime/Swift/Sources/Antlr4/ParserRuleContext.swift
+++ b/runtime/Swift/Sources/Antlr4/ParserRuleContext.swift
@@ -4,83 +4,79 @@
*/
-/** A rule invocation record for parsing.
- *
- * Contains all of the information about the current rule not stored in the
- * RuleContext. It handles parse tree children list, Any ATN state
- * tracing, and the default values available for rule invocations:
- * start, stop, rule index, current alt number.
- *
- * Subclasses made for each rule and grammar track the parameters,
- * return values, locals, and labels specific to that rule. These
- * are the objects that are returned from rules.
- *
- * Note text is not an actual field of a rule return value; it is computed
- * from start and stop using the input stream's toString() method. I
- * could add a ctor to this so that we can pass in and store the input
- * stream, but I'm not sure we want to do that. It would seem to be undefined
- * to get the .text property anyway if the rule matches tokens from multiple
- * input streams.
- *
- * I do not use getters for fields of objects that are used simply to
- * group values such as this aggregate. The getters/setters are there to
- * satisfy the superclass interface.
- */
-
+/// A rule invocation record for parsing.
+///
+/// Contains all of the information about the current rule not stored in the
+/// RuleContext. It handles parse tree children list, Any ATN state
+/// tracing, and the default values available for rule invocations:
+/// start, stop, rule index, current alt number.
+///
+/// Subclasses made for each rule and grammar track the parameters,
+/// return values, locals, and labels specific to that rule. These
+/// are the objects that are returned from rules.
+///
+/// Note text is not an actual field of a rule return value; it is computed
+/// from start and stop using the input stream's toString() method. I
+/// could add a ctor to this so that we can pass in and store the input
+/// stream, but I'm not sure we want to do that. It would seem to be undefined
+/// to get the .text property anyway if the rule matches tokens from multiple
+/// input streams.
+///
+/// I do not use getters for fields of objects that are used simply to
+/// group values such as this aggregate. The getters/setters are there to
+/// satisfy the superclass interface.
+///
open class ParserRuleContext: RuleContext {
public var visited = false
- /** If we are debugging or building a parse tree for a visitor,
- * we need to track all of the tokens and rule invocations associated
- * with this rule's context. This is empty for parsing w/o tree constr.
- * operation because we don't the need to track the details about
- * how we parse this rule.
- */
+ /// If we are debugging or building a parse tree for a visitor,
+ /// we need to track all of the tokens and rule invocations associated
+ /// with this rule's context. This is empty for parsing w/o tree constr.
+ /// operation because we don't the need to track the details about
+ /// how we parse this rule.
+ ///
public var children: Array
+
+#### Edit the build settings if necessary
+
+Swift Package Manager currently does not support iOS, watchOS, or tvOS. If
+you wish to build for those platforms, you will need to alter the project
+build settings manually.
+
+#### Add generated parser and lexer to project
+
+Make sure the parsers/lexers
generated in __step 2__ are added to the project. To do this, you can
drag the generated files from Finder to the Xcode IDE. Remember to
check __Copy items if needed__ to make sure the files are actually
moved into the project folder instead of symbolic links (see the
screenshot below). After moving you will be able to see your files in
-the project navigator. But when you open one of the files, you will
-see Xcode complaining the module "Antlr4" could not be found at the
-import statement. This is expected, since we still need the ANTLR
-Swift runtime for those missing symbols.
+the project navigator. Make sure that the Target Membership settings
+are correct for your project.
-* __Download ANTLR runtime__. Due to unstable ABI of Swift language,
-there will not be a single "library" for the Swift ANTLR runtime for
-now. To get Swift ANTLR runtime, clone the ANTLR repository. Open it
-in finder. From the root directory of the repo, go to runtime/Swift
-folder. You will see the Xcode project manifest file:
-__Antlr4.xcodeproj__.
+#### Add the ANTLR Swift runtime as a dependency
-* __Import ANTLR Swift runtime into project__. Drag Antlr4.xcodeproj
-into your project, after this is done, your Xcode project navigator
-will be something like the screenshot below. In this case, your own
-project is "Smalltalk", and you will be able to see the
-Antlr4.xcodeproj shown as a contained project. The error message will
-still be there, that's because we still need to tell Xcode how to find
-the runtime.
-
-
-
-* __Add dependencies__. Simply adding ANTLR Swift runtime and build
-the artifact is not enough. You still need to specify
-dependencies. Click your own project (Smalltalk), and you will see
-project setting page. Go to "Build Phase", and inside it make sure
-your ANTLR Swift runtime framework is added to both "__Target
-Dependencies__" and "__Link Binary With Libraries__" sections, as
-shown below. After correctly added dependencies, the error message for
-importing library will be gone.
+Select your own project in Xcode and go to the Build Phases settings panel.
+Add the ANTLR runtime under __Target Dependencies__ and __Link Binary With
+Libraries__.
-## Example playground
+#### Build your project
-The Swift runtime includes an Xcode playground to get started with.
+The runtime and generated grammar should now build correctly.
-First go to the ANTLR4 repository, and open
-`runtime/Swift/Antlr4.xcworkspace` in Xcode. Select "Antlr4 OSX > My
-Mac" as the build target, and build the project as normal. The
-playground should then be active.
+### Swift Package Manager Projects
-The playground includes a simple grammar called "Hello", and an
-example for walking the parse tree. You should see in the playground
-output that it is printing messages for each node in the parse tree as
-it walks.
+Since we cannot have a separate repository for Swift target (see issue [#1774](https://github.com/antlr/antlr4/issues/1774)),
+and Swift is currently not ABI stable. We currently support support SPM-based
+projects by creating temporary local repository.
-The grammar is defined in the playground's `Resources/Hello.g4`. The
-parser was generated from the grammar using ANTLR like this:
+For people using [Swift Package Manager](https://swift.org/package-manager/),
+the __boot.py__ script supports generating local repository that can be used
+as a dependency to your project. Simply run:
-```
-antlr4 -Dlanguage=Swift -visitor -o ../Sources/Autogen Hello.g4
+```
+python boot.py --gen-spm-module
```
-The example tree walker is in Sources/HelloWalker.swift.
-
+The prompt will show something like below:
+
+
+
+Put the SPM directive that contains the url to temporary repository to your
+project's Package.swift. And run `swift build` in your project.
+
+The project is generated in your system's `/tmp/` directory, if you find it
+inconvenient, consider copy that generated ANTLR repository to some place
+that won't be cleaned automatically and update `url` parameter in your
+`Package.swift` file.
diff --git a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Swift.test.stg b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Swift.test.stg
index 2a203e969..64d560df5 100755
--- a/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Swift.test.stg
+++ b/runtime-testsuite/resources/org/antlr/v4/test/runtime/templates/Swift.test.stg
@@ -72,7 +72,7 @@ TokenStartColumnEquals(i) ::= <%self._tokenStartCharPositionInLine == %>
ImportListener(X) ::= ""
-GetExpectedTokenNames() ::= "try self.getExpectedTokens().toString(self.tokenNames)"
+GetExpectedTokenNames() ::= "try self.getExpectedTokens().toString(self.getVocabulary())"
RuleInvocationStack() ::= "getRuleInvocationStack().description.replacingOccurrences(of: \"\\\"\", with: \"\")"
diff --git a/runtime-testsuite/test/org/antlr/v4/runtime/TestCodePointCharStream.java b/runtime-testsuite/test/org/antlr/v4/runtime/TestCodePointCharStream.java
index 25c4c0919..c40c4048c 100644
--- a/runtime-testsuite/test/org/antlr/v4/runtime/TestCodePointCharStream.java
+++ b/runtime-testsuite/test/org/antlr/v4/runtime/TestCodePointCharStream.java
@@ -23,6 +23,7 @@ public class TestCodePointCharStream {
CodePointCharStream s = CharStreams.fromString("");
assertEquals(0, s.size());
assertEquals(0, s.index());
+ assertEquals("", s.toString());
}
@Test
diff --git a/runtime-testsuite/test/org/antlr/v4/test/runtime/descriptors/ParserErrorsDescriptors.java b/runtime-testsuite/test/org/antlr/v4/test/runtime/descriptors/ParserErrorsDescriptors.java
index 0b53e994e..26352d317 100644
--- a/runtime-testsuite/test/org/antlr/v4/test/runtime/descriptors/ParserErrorsDescriptors.java
+++ b/runtime-testsuite/test/org/antlr/v4/test/runtime/descriptors/ParserErrorsDescriptors.java
@@ -618,4 +618,28 @@ public class ParserErrorsDescriptors {
public String grammar;
}
+
+ public static class ExtraneousInput extends BaseParserTestDescriptor {
+ public String input = "baa";
+ public String output = null;
+ public String errors = "line 1:0 mismatched input 'b' expecting {