public static bool StartsBeforeStartOf(IParseTree a, IParseTree b)
{
Interval sourceIntervalA = a.SourceInterval;
Interval sourceIntervalB = b.SourceInterval;
return(sourceIntervalA.a < sourceIntervalB.a);
}
public override bool Equals(object o)
{
if (!(o is Antlr4.Runtime.Misc.Interval))
{
return(false);
}
Antlr4.Runtime.Misc.Interval other = (Antlr4.Runtime.Misc.Interval)o;
return(this.a == other.a && this.b == other.b);
}
/** Return a list of parse trees, one for each alternative in a decision
* given the same input.
*
* Very similar to {@link #getAllPossibleParseTrees} except
* that it re-parses the input for every alternative in a decision,
* not just the ambiguous ones (there is no alts parameter here).
* This method also tries to reduce the size of the parse trees
* by stripping away children of the tree that are completely out of range
* of startIndex..stopIndex. Also, because errors are expected, we
* use a specialized error handler that more or less bails out
* but that also consumes the first erroneous token at least. This
* ensures that an error node will be in the parse tree for display.
*
* NOTES:
* // we must parse the entire input now with decision overrides
* // we cannot parse a subset because it could be that a decision
* // above our decision of interest needs to read way past
* // lookaheadInfo.stopIndex. It seems like there is no escaping
* // the use of a full and complete token stream if we are
* // resetting to token index 0 and re-parsing from the start symbol.
* // It's not easy to restart parsing somewhere in the middle like a
* // continuation because our call stack does not match the
* // tree stack because of left recursive rule rewriting. grrrr!
*
* @since 4.5.1
*/
public static IList <ParserRuleContext> GetLookaheadParseTrees(Grammar g,
ParserInterpreter originalParser,
ITokenStream tokens,
int startRuleIndex,
int decision,
int startIndex,
int stopIndex)
{
IList <ParserRuleContext> trees = new List <ParserRuleContext>();
// Create a new parser interpreter to parse the ambiguous subphrase
ParserInterpreter parser = DeriveTempParserInterpreter(g, originalParser, tokens);
DecisionState decisionState = originalParser.Atn.decisionToState[decision];
for (int alt = 1; alt <= decisionState.Transitions.Length; alt++)
{
// re-parse entire input for all ambiguous alternatives
// (don't have to do first as it's been parsed, but do again for simplicity
// using this temp parser.)
BailButConsumeErrorStrategy errorHandler = new BailButConsumeErrorStrategy();
parser.ErrorHandler = errorHandler;
parser.Reset();
parser.AddDecisionOverride(decision, startIndex, alt);
ParserRuleContext tt = parser.Parse(startRuleIndex);
int stopTreeAt = stopIndex;
if (errorHandler.firstErrorTokenIndex >= 0)
{
stopTreeAt = errorHandler.firstErrorTokenIndex; // cut off rest at first error
}
Interval overallRange = tt.SourceInterval;
if (stopTreeAt > overallRange.b)
{
// If we try to look beyond range of tree, stopTreeAt must be EOF
// for which there is no EOF ref in grammar. That means tree
// will not have node for stopTreeAt; limit to overallRange.b
stopTreeAt = overallRange.b;
}
ParserRuleContext subtree =
Trees.GetRootOfSubtreeEnclosingRegion(tt,
startIndex,
stopTreeAt);
// Use higher of overridden decision tree or tree enclosing all tokens
if (Trees.IsAncestorOf(parser.OverrideDecisionRoot, subtree))
{
subtree = parser.OverrideDecisionRoot;
}
Trees.StripChildrenOutOfRange(subtree, parser.OverrideDecisionRoot, startIndex, stopTreeAt);
trees.Add(subtree);
}
return(trees);
}
/// <summary>
/// Return the interval with elements from
/// <c>this</c>
/// not in
/// <paramref name="other"/>
/// ;
/// <paramref name="other"/>
/// must not be totally enclosed (properly contained)
/// within
/// <c>this</c>
/// , which would result in two disjoint intervals
/// instead of the single one returned by this method.
/// </summary>
public Antlr4.Runtime.Misc.Interval?DifferenceNotProperlyContained(Antlr4.Runtime.Misc.Interval other)
{
Antlr4.Runtime.Misc.Interval?diff = null;
// other.a to left of this.a (or same)
if (other.StartsBeforeNonDisjoint(this))
{
diff = Antlr4.Runtime.Misc.Interval.Of(Math.Max(this.a, other.b + 1), this.b);
}
else
{
// other.a to right of this.a
if (other.StartsAfterNonDisjoint(this))
{
diff = Antlr4.Runtime.Misc.Interval.Of(this.a, other.a - 1);
}
}
return(diff);
}
public static System.Collections.Generic.List <string> GetVariableNames()
{
System.Collections.Generic.List <string> ls = new System.Collections.Generic.List <string>();
string text = @"
SELECT BE_Name FROM T_Benutzer WHERE Name =@username
OR Name LIKE '%' + @foo + '%'
";
System.IO.StringReader reader = new System.IO.StringReader(text);
// Antlr4.Runtime.AntlrInputStream input = new Antlr4.Runtime.AntlrInputStream(reader);
Antlr4.Runtime.ICharStream input1 = new Antlr4.Runtime.AntlrInputStream(reader);
Antlr4.Runtime.CaseChangingCharStream input = new Antlr4.Runtime.CaseChangingCharStream(input1, true);
TSqlLexer lexer = new TSqlLexer(input);
Antlr4.Runtime.CommonTokenStream tokenStream = new Antlr4.Runtime.CommonTokenStream(lexer);
tokenStream.Fill();
int lastIndex = 0;
foreach (Antlr4.Runtime.IToken token in tokenStream.GetTokens())
{
// System.Console.WriteLine(token.Text);
string tokenTypeName = lexer.Vocabulary.GetSymbolicName(token.Type);
Antlr4.Runtime.Misc.Interval ival = new Antlr4.Runtime.Misc.Interval(lastIndex, token.StopIndex);
string extracted = token.InputStream.GetText(ival);
// table_name, cte_name: ID, SQUARE_BRACKET_ID
// Local variables: LOCAL_ID
if (token.Type == TSqlLexer.LOCAL_ID)
{
extracted = extracted.Trim(new char[] { ' ', '\t', '\v', '\r', '\n' });
ls.Add(extracted);
} // End if (token.Type == TSqlLexer.LOCAL_ID)
lastIndex = token.StopIndex + 1;
} // Next token
return(ls);
}
private static string CreateErrorMessageForContext(Antlr4.Runtime.ParserRuleContext context, string message, string fileName = "(unknown)")
{
if (context == null)
{
return(message);
}
int lineNumber = context.Start.Line;
// getting the text that has the issue inside
var interval = new Antlr4.Runtime.Misc.Interval(0, context.Start.InputStream.Size);
string[] lines = context.Start.InputStream.GetText(interval).Split('\n');
string line = lines[context.Start.Line - 1];
string theMessage = string.Format(CultureInfo.CurrentCulture, "Error in {3} line {0}\n{1}\n{2}", lineNumber, line, message, fileName);
return(theMessage);
}
public bool ProperlyContains(Antlr4.Runtime.Misc.Interval other)
{
return(other.a >= this.a && other.b <= this.b);
}
/// <summary>Return the interval in common between this and o</summary>
public Antlr4.Runtime.Misc.Interval Intersection(Antlr4.Runtime.Misc.Interval other)
{
return(Antlr4.Runtime.Misc.Interval.Of(Math.Max(a, other.a), Math.Min(b, other.b)));
}
// this.b>=other.b implied
/// <summary>Are both ranges disjoint? I.e., no overlap?</summary>
public bool Disjoint(Antlr4.Runtime.Misc.Interval other)
{
return(StartsBeforeDisjoint(other) || StartsAfterDisjoint(other));
}
/// <summary>Are two intervals adjacent such as 0..41 and 42..42?</summary>
public bool Adjacent(Antlr4.Runtime.Misc.Interval other)
{
return(this.a == other.b + 1 || this.b == other.a - 1);
}
public string GetText(Antlr4.Runtime.Misc.Interval interval)
{
throw new NotImplementedException();
}
/// <summary>Does this start after other? NonDisjoint</summary>
public bool StartsAfterNonDisjoint(Antlr4.Runtime.Misc.Interval other)
{
return(this.a > other.a && this.a <= other.b);
}
static void SplitMultiTableInsertScript()
{
string fileName = @"D:\SQL\TESS\Anlage_Refdaten.txt";
fileName = @"D:\SQL\TESS\Adressdaten.txt";
fileName = @"D:\SQL\TESS\Anlagedaten.txt";
fileName = @"D:\SQL\TESS\Anlagerechte.txt";
fileName = @"D:\SQL\TESS\Kontaktdaten.txt";
fileName = @"D:\SQL\TESS\Navigation.txt";
fileName = @"D:\username\Desktop\Raumdaten\Raumdaten.sql";
fileName = @"D:\username\Desktop\Raumdaten\Vertragsdaten.sql";
System.Text.StringBuilder sb = new System.Text.StringBuilder();
// https://github.com/antlr/grammars-v4/tree/master/tsql
// https://github.com/antlr/grammars-v4/tree/master/plsql/CSharp
System.Text.Encoding enc = GetSystemEncoding();
string text = System.IO.File.ReadAllText(fileName, enc);
System.IO.StringReader reader = new System.IO.StringReader(text);
// Antlr4.Runtime.AntlrInputStream input = new Antlr4.Runtime.AntlrInputStream(reader);
Antlr4.Runtime.ICharStream input1 = new Antlr4.Runtime.AntlrInputStream(reader);
Antlr4.Runtime.CaseChangingCharStream input = new Antlr4.Runtime.CaseChangingCharStream(input1, true);
TSqlLexer lexer = new TSqlLexer(input);
Antlr4.Runtime.CommonTokenStream tokenStream = new Antlr4.Runtime.CommonTokenStream(lexer);
tokenStream.Fill();
int lastIndex = 0;
System.Collections.Generic.Dictionary <string, System.Collections.Generic.List <string> > dict =
new System.Collections.Generic.Dictionary <string, System.Collections.Generic.List <string> >(System.StringComparer.InvariantCultureIgnoreCase);
System.Collections.Generic.List <string> lsTableName = new System.Collections.Generic.List <string>();
bool ignoreThis = true;
bool partOfTableName = false;
int lastTokenType = -1;
int secondLastTokenType = -1;
foreach (Antlr4.Runtime.IToken token in tokenStream.GetTokens())
{
// System.Console.WriteLine(token.Text);
string tokenTypeName = lexer.Vocabulary.GetSymbolicName(token.Type);
Antlr4.Runtime.Misc.Interval ival = new Antlr4.Runtime.Misc.Interval(lastIndex, token.StopIndex);
string extracted = token.InputStream.GetText(ival);
extracted = extracted.Trim(new char[] { '\t', '\v', '\r', '\n' });
if (token.Type == TSqlLexer.INSERT)
{
if (sb.Length > 0)
{
string tn = string.Join(".", lsTableName.ToArray()).Replace("[", "").Replace("]", "").Trim();
lsTableName.Clear();
System.Console.WriteLine(tn);
if (!dict.ContainsKey(tn))
{
dict[tn] = new System.Collections.Generic.List <string>();
}
sb.Append(";");
dict[tn].Add(sb.ToString());
}
sb.Clear();
ignoreThis = false;
partOfTableName = true;
}
else if (token.Type == TSqlLexer.GO)
{
ignoreThis = true;
partOfTableName = false;
}
else if (token.Type == TSqlLexer.USE)
{
ignoreThis = true;
partOfTableName = false;
}
else if (token.Type == TSqlLexer.SEMI)
{
ignoreThis = true;
partOfTableName = false;
}
else if (token.Type == TSqlLexer.Eof)
{
}
else if (token.Type == TSqlLexer.LR_BRACKET)
{
partOfTableName = false;
}
else if (token.Type == TSqlLexer.RR_BRACKET)
{
}
else if (token.Type == TSqlLexer.COMMA)
{
}
else if (token.Type == TSqlLexer.INTO)
{
}
else if (token.Type == TSqlLexer.VALUES || token.Type == TSqlLexer.SELECT)
{
}
else if (token.Type == TSqlLexer.ID || token.Type == TSqlLexer.SQUARE_BRACKET_ID)
{
if (partOfTableName)
{
lsTableName.Add(extracted);
}
}
else if (token.Type == TSqlLexer.DOT)
{
}
else if (token.Type == TSqlLexer.STRING)
{
}
else if (token.Type == TSqlLexer.DECIMAL)
{
}
else if (token.Type == TSqlLexer.FLOAT)
{
}
else if (token.Type == TSqlLexer.NULL)
{
}
else if (token.Type == TSqlLexer.CAST)
{
}
else if (token.Type == TSqlLexer.AS)
{
// CAST(xxx AS datetime)
}
else if (token.Type == TSqlLexer.MINUS)
{
// Negative Number
}
else
{
System.Console.WriteLine(tokenTypeName);
}
// System.Console.WriteLine((extracted));
if (!ignoreThis && token.Type != TSqlLexer.SEMI)
{
sb.Append(extracted);
}
// System.Console.WriteLine(token.Text);
// System.Console.WriteLine(token.Type);
// System.Console.WriteLine(tokenTypeName);
lastIndex = token.StopIndex + 1;
secondLastTokenType = lastTokenType;
lastTokenType = token.Type;
} // Next token
if (sb.Length > 0)
{
string tn = string.Join(".", lsTableName.ToArray()).Replace("[", "").Replace("]", "").Trim();
lsTableName.Clear();
System.Console.WriteLine(tn);
if (!dict.ContainsKey(tn))
{
dict[tn] = new System.Collections.Generic.List <string>();
}
sb.Append(";");
dict[tn].Add(sb.ToString());
} // End if (sb.Length > 0)
sb.Clear();
sb = null;
string baseDir = System.IO.Path.GetFileNameWithoutExtension(fileName);
string outputDirectory = System.IO.Path.GetDirectoryName(fileName);
baseDir = System.IO.Path.Combine(outputDirectory, baseDir);
if (!System.IO.Directory.Exists(baseDir))
{
System.IO.Directory.CreateDirectory(baseDir);
}
foreach (System.Collections.Generic.KeyValuePair <string, System.Collections.Generic.List <string> > kvp in dict)
{
string dir = kvp.Key;
string content = string.Join("\r\n\r\n", kvp.Value.ToArray());
System.Console.WriteLine(content);
string fn = System.IO.Path.Combine(baseDir, kvp.Key + ".sql");
System.IO.File.WriteAllText(fn, content, System.Text.Encoding.UTF8);
} // Next kvp
System.Console.WriteLine(dict);
} // End Sub SplitMultiTableInsertScript
public string GetText(Interval interval)
{
return(_source.GetText(interval));
}
/// <summary>Does this start at or before other? Nondisjoint</summary>
public bool StartsBeforeNonDisjoint(Antlr4.Runtime.Misc.Interval other)
{
return(this.a <= other.a && this.b >= other.a);
}
} // End Sub SplitMultiTableInsertScript
static string SubstituteVariablesTest()
{
// https://github.com/antlr/grammars-v4/tree/master/tsql
// https://github.com/antlr/grammars-v4/tree/master/plsql/CSharp
string text = @"
DECLARE @legalEntity int
-- SET @legalEntity = 1
;WITH CTE AS
(
SELECT 1 AS id, 123 AS abc
UNION SELECT 2 AS id, 456 AS abc
UNION SELECT 3 AS id, 789 AS abc
UNION SELECT 4 AS id, 012 AS abc
UNION SELECT 5 AS id, 345 AS abc
UNION SELECT 6 AS id, 678 AS abc
)
SELECT
*
,'@legalEntity' AS abcdef -- strings do not get substituted
,987 AS [@legalEntity] -- identifiers do not get substituted
FROM CTE
WHERE (1=1)
AND
(
'0' IN (@legalEntity,
@legalEntity )
OR
CTE.id IN (@legalEntity)
-- CTE.id IN (@legalEntity /* @legalEntity */)
)
/*
==>
AND
(
'0' IN (1,2,6)
OR
CTE.id IN (1,2,6)
-- OR CTE.id IN (1,2,3,4,5,6 /* 1,2,3,4,5,6 */)
)
*/
";
System.IO.StringReader reader = new System.IO.StringReader(text);
// Antlr4.Runtime.AntlrInputStream input = new Antlr4.Runtime.AntlrInputStream(reader);
Antlr4.Runtime.ICharStream input1 = new Antlr4.Runtime.AntlrInputStream(reader);
Antlr4.Runtime.CaseChangingCharStream input = new Antlr4.Runtime.CaseChangingCharStream(input1, true);
TSqlLexer lexer = new TSqlLexer(input);
Antlr4.Runtime.CommonTokenStream tokenStream = new Antlr4.Runtime.CommonTokenStream(lexer);
tokenStream.Fill();
System.Text.StringBuilder sb = new System.Text.StringBuilder();
int lastIndex = 0;
foreach (Antlr4.Runtime.IToken token in tokenStream.GetTokens())
{
// System.Console.WriteLine(token.Text);
string tokenTypeName = lexer.Vocabulary.GetSymbolicName(token.Type);
#if NO_COMMENTS
if (token.Type == TSqlLexer.LINE_COMMENT || token.Type == TSqlLexer.COMMENT ||
token.Type == TSqlLexer.Eof)
{
Antlr4.Runtime.Misc.Interval blankInterval = new Antlr4.Runtime.Misc.Interval(lastIndex, token.StartIndex - 1);
string extractedBlank = token.InputStream.GetText(blankInterval);
if (string.IsNullOrEmpty(extractedBlank))
{
sb.Append(" ");
}
else
{
sb.Append(extractedBlank);
}
lastIndex = token.StopIndex + 1;
continue;
} // End if comment
#endif
// sql += token.Text + " ";
Antlr4.Runtime.Misc.Interval ival = new Antlr4.Runtime.Misc.Interval(lastIndex, token.StopIndex);
string extracted = token.InputStream.GetText(ival);
// table_name, cte_name: ID, SQUARE_BRACKET_ID
// Local variables: LOCAL_ID
if (token.Type == TSqlLexer.LOCAL_ID)
{
extracted = extracted.Trim(new char[] { ' ', '\t', '\v', '\r', '\n' });
System.Console.WriteLine(extracted);
} // End if (token.Type == TSqlLexer.LOCAL_ID)
// System.Console.WriteLine((extracted));
sb.Append(extracted);
// System.Console.WriteLine(token.Text);
// System.Console.WriteLine(token.Type);
// System.Console.WriteLine(tokenTypeName);
lastIndex = token.StopIndex + 1;
} // Next token
string sql = sb.ToString();
sb.Clear();
sb = null;
System.Console.WriteLine(sql);
return(sql);
} // End Sub SubstituteVariablesTest
public Interval(Antlr4.Runtime.Misc.Interval interval)
{
_interval = interval;
}
} // End Sub CommentRemoverLexerTest
// https://github.com/dotjpg3141/Strings
static void LexerTest(string text)
{
try
{
System.IO.StringReader reader = new System.IO.StringReader(text);
// Antlr4.Runtime.AntlrInputStream input = new Antlr4.Runtime.AntlrInputStream(reader);
Antlr4.Runtime.ICharStream input1 = new Antlr4.Runtime.AntlrInputStream(reader);
Antlr4.Runtime.CaseChangingCharStream input = new Antlr4.Runtime.CaseChangingCharStream(input1, true);
TSqlLexer lexer = new TSqlLexer(input);
Antlr4.Runtime.CommonTokenStream tokenStream = new Antlr4.Runtime.CommonTokenStream(lexer);
tokenStream.Fill();
System.Text.StringBuilder sb = new System.Text.StringBuilder();
int lastIndex = 0;
foreach (Antlr4.Runtime.IToken token in tokenStream.GetTokens())
{
// System.Console.WriteLine(token.Text);
string tokenTypeName = lexer.Vocabulary.GetSymbolicName(token.Type);
if (token.Type == TSqlLexer.LINE_COMMENT || token.Type == TSqlLexer.COMMENT ||
token.Type == TSqlLexer.Eof)
{
Antlr4.Runtime.Misc.Interval blankInterval = new Antlr4.Runtime.Misc.Interval(lastIndex, token.StartIndex - 1);
string extractedBlank = token.InputStream.GetText(blankInterval);
if (string.IsNullOrEmpty(extractedBlank))
{
sb.Append(" ");
}
else
{
sb.Append(extractedBlank);
}
lastIndex = token.StopIndex + 1;
continue;
} // End if comment
// sql += token.Text + " ";
Antlr4.Runtime.Misc.Interval ival = new Antlr4.Runtime.Misc.Interval(lastIndex, token.StopIndex);
string extracted = token.InputStream.GetText(ival);
// System.Console.WriteLine((extracted));
sb.Append(extracted);
// System.Console.WriteLine(token.Text);
// System.Console.WriteLine(token.Type);
// System.Console.WriteLine(tokenTypeName);
lastIndex = token.StopIndex + 1;
} // Next token
string sql = sb.ToString();
sb.Clear();
sb = null;
System.Console.WriteLine(sql);
}
catch (System.Exception e)
{
System.Console.WriteLine(e.Message);
}
} // End Sub LexerTest
public override Handle Set(GrammarAST associatedAST, IList <GrammarAST> alts, bool invert)
{
ATNState left = NewState(associatedAST);
ATNState right = NewState(associatedAST);
IntervalSet set = new IntervalSet();
foreach (GrammarAST t in alts)
{
if (t.Type == ANTLRParser.RANGE)
{
int a = CharSupport.GetCharValueFromGrammarCharLiteral(t.GetChild(0).Text);
int b = CharSupport.GetCharValueFromGrammarCharLiteral(t.GetChild(1).Text);
if (CheckRange((GrammarAST)t.GetChild(0), (GrammarAST)t.GetChild(1), a, b))
{
CheckSetCollision(associatedAST, set, a, b);
set.Add(a, b);
}
}
else if (t.Type == ANTLRParser.LEXER_CHAR_SET)
{
set.AddAll(GetSetFromCharSetLiteral(t));
}
else if (t.Type == ANTLRParser.STRING_LITERAL)
{
int c = CharSupport.GetCharValueFromGrammarCharLiteral(t.Text);
if (c != -1)
{
CheckSetCollision(associatedAST, set, c);
set.Add(c);
}
else
{
g.tool.errMgr.GrammarError(ErrorType.INVALID_LITERAL_IN_LEXER_SET,
g.fileName, t.Token, t.Text);
}
}
else if (t.Type == ANTLRParser.TOKEN_REF)
{
g.tool.errMgr.GrammarError(ErrorType.UNSUPPORTED_REFERENCE_IN_LEXER_SET,
g.fileName, t.Token, t.Text);
}
}
if (invert)
{
left.AddTransition(new NotSetTransition(right, set));
}
else
{
Transition transition;
if (set.GetIntervals().Count == 1)
{
Interval interval = set.GetIntervals()[0];
transition = new RangeTransition(right, interval.a, interval.b);
}
else
{
transition = new SetTransition(right, set);
}
left.AddTransition(transition);
}
associatedAST.atnState = left;
return(new Handle(left, right));
}
private static void OptimizeSets(Grammar g, ATN atn)
{
if (g.IsParser())
{
// parser codegen doesn't currently support SetTransition
return;
}
int removedStates = 0;
IList <DecisionState> decisions = atn.decisionToState;
foreach (DecisionState decision in decisions)
{
if (decision.ruleIndex >= 0)
{
Rule rule = g.GetRule(decision.ruleIndex);
if (char.IsLower(rule.name[0]))
{
// parser codegen doesn't currently support SetTransition
continue;
}
}
IntervalSet setTransitions = new IntervalSet();
for (int i = 0; i < decision.NumberOfTransitions; i++)
{
Transition epsTransition = decision.Transition(i);
if (!(epsTransition is EpsilonTransition))
{
continue;
}
if (epsTransition.target.NumberOfTransitions != 1)
{
continue;
}
Transition transition = epsTransition.target.Transition(0);
if (!(transition.target is BlockEndState))
{
continue;
}
if (transition is NotSetTransition)
{
// TODO: not yet implemented
continue;
}
if (transition is AtomTransition ||
transition is RangeTransition ||
transition is SetTransition)
{
setTransitions.Add(i);
}
}
// due to min alt resolution policies, can only collapse sequential alts
for (int i = setTransitions.GetIntervals().Count - 1; i >= 0; i--)
{
Interval interval = setTransitions.GetIntervals()[i];
if (interval.Length <= 1)
{
continue;
}
ATNState blockEndState = decision.Transition(interval.a).target.Transition(0).target;
IntervalSet matchSet = new IntervalSet();
for (int j = interval.a; j <= interval.b; j++)
{
Transition matchTransition = decision.Transition(j).target.Transition(0);
if (matchTransition is NotSetTransition)
{
throw new NotImplementedException();
}
IntervalSet set = matchTransition.Label;
int minElem = set.MinElement;
int maxElem = set.MaxElement;
for (int k = minElem; k <= maxElem; k++)
{
if (matchSet.Contains(k))
{
char setMin = (char)set.MinElement;
char setMax = (char)set.MaxElement;
// TODO: Token is missing (i.e. position in source will not be displayed).
g.tool.errMgr.GrammarError(ErrorType.CHARACTERS_COLLISION_IN_SET, g.fileName,
null, (char)minElem + "-" + (char)maxElem, "[" + setMin + "-" + setMax + "]");
break;
}
}
matchSet.AddAll(set);
}
Transition newTransition;
if (matchSet.GetIntervals().Count == 1)
{
if (matchSet.Count == 1)
{
newTransition = new AtomTransition(blockEndState, matchSet.MinElement);
}
else
{
Interval matchInterval = matchSet.GetIntervals()[0];
newTransition = new RangeTransition(blockEndState, matchInterval.a, matchInterval.b);
}
}
else
{
newTransition = new SetTransition(blockEndState, matchSet);
}
decision.Transition(interval.a).target.SetTransition(0, newTransition);
for (int j = interval.a + 1; j <= interval.b; j++)
{
Transition removed = decision.Transition(interval.a + 1);
decision.RemoveTransition(interval.a + 1);
atn.RemoveState(removed.target);
removedStates++;
}
}
}
//System.Console.WriteLine("ATN optimizer removed " + removedStates + " states by collapsing sets.");
}
public string GetText(Interval interval)
{
return _source.GetText(interval);
}
/// <summary>Does this.a start after other.b? May or may not be disjoint</summary>
public bool StartsAfter(Antlr4.Runtime.Misc.Interval other)
{
return(this.a > other.a);
}
public static System.Collections.Generic.List <string> LexWithAntlr(string text)
{
System.Collections.Generic.List <string> ls = new System.Collections.Generic.List <string>();
System.IO.StringReader reader = new System.IO.StringReader(text);
// Antlr4.Runtime.AntlrInputStream input = new Antlr4.Runtime.AntlrInputStream(reader);
Antlr4.Runtime.ICharStream input1 = new Antlr4.Runtime.AntlrInputStream(reader);
Antlr4.Runtime.CaseChangingCharStream input = new Antlr4.Runtime.CaseChangingCharStream(input1, true);
Rfc5424Lexer lexer = new Rfc5424Lexer(input);
Antlr4.Runtime.CommonTokenStream tokenStream = new Antlr4.Runtime.CommonTokenStream(lexer);
tokenStream.Fill();
Rfc5424Parser parser = new Rfc5424Parser(tokenStream);
Rfc5424Parser.Syslog_msgContext msgContext = parser.syslog_msg();
RfcVisitor vis = new RfcVisitor();
string s = vis.Visit(msgContext);
Antlr4.Runtime.Tree.ParseTreeWalker walker = new Antlr4.Runtime.Tree.ParseTreeWalker();
// AntlrTsqListener listener = new AntlrTsqListener();
EverythingListener listener = new EverythingListener();
// walker.Walk(listener, msgContext);
// new EverythingListener().EnterBom(parser.bom());
// new EverythingListener().EnterTimestamp(parser.timestamp());
// new EverythingListener().EnterEveryRule(parser.version());
// new EverythingListener().EnterEveryRule(parser.timestamp());
// var x = parser.msg();
var x = parser.timestamp();
Antlr4.Runtime.Misc.Interval msgInt = x.SourceInterval; // new Antlr4.Runtime.Misc.Interval(lastIndex, token.StopIndex);
string extractedMsg = tokenStream.GetText(msgInt);
System.Console.WriteLine(extractedMsg);
int lastIndex = 0;
foreach (Antlr4.Runtime.IToken token in tokenStream.GetTokens())
{
// System.Console.WriteLine(token.Text);
string tokenTypeName = lexer.Vocabulary.GetSymbolicName(token.Type);
Antlr4.Runtime.Misc.Interval ival = new Antlr4.Runtime.Misc.Interval(lastIndex, token.StopIndex);
string extracted = token.InputStream.GetText(ival);
// table_name, cte_name: ID, SQUARE_BRACKET_ID
// Local variables: LOCAL_ID
lastIndex = token.StopIndex + 1;
} // Next token
return(ls);
}
