public SyntaxParser(SlidingTextWindow TextWindow)
{
TokenList = new SyntaxList();
oLexer = new SyntaxLexer(TextWindow);
// Must initialise after object variables initialised
this.Initialise();
}
public static SyntaxParser GetSyntaxParser(string text)
{
var inputStream = new AntlrInputStream(text);
var syntaxLexer = new SyntaxLexer(inputStream);
var commonTokenStream = new CommonTokenStream(syntaxLexer);
var syntaxParser = new SyntaxParser(commonTokenStream);
return(syntaxParser);
}
public DatabaseExpressionEvaluator(string expression, UniversalGuid playerGuid)
{
lexer = new SyntaxLexer(new AntlrInputStream(expression));
tokens = new CommonTokenStream(lexer);
parser = new SyntaxParser(tokens);
parser.BuildParseTree = true;
parser.RemoveErrorListeners();
visitor = new ExpressionVisitor(new IsPacketSpecificPlayerProcessor(playerGuid));
}
/// <summary>
/// This is very unsafe as everything is converted to Upper
/// before the conversion (ie. it matches against any case)
/// </summary>
/// <param name="xoTrivia"></param>
/// <returns></returns>
private static Boolean ScanTriviaForKeywords(
ParsingContext xoContext,
SyntaxTrivia xoTrivia,
out List <ISyntax> xaoReturnList)
{
// Initialise the out var
xaoReturnList = new List <ISyntax>();
// Exit early if invalid argument passed
if (xoTrivia == null)
{
return(false);
}
// Break apart the trivia text
String[] asTriviaTextTokens = xoTrivia.RawSQLText.Split();
// Start looping through the trivia text
for (int iIndex = 0; iIndex < asTriviaTextTokens.Length; iIndex++)
{
// For each string in the Comment/Trivia
String sLoopingVar = asTriviaTextTokens[iIndex];
SyntaxKind ePossibleKind = SyntaxKindUtilities.GetKindFromString(sLoopingVar); // Try and get a kind
// If we have a positive match
if (ePossibleKind != SyntaxKind.UnknownNode)
{
// Mayfly
SyntaxToken oToken = new SyntaxToken(ePossibleKind, sLoopingVar);
// If we can consume this node (it is something we expect)
if (xoContext.CurrentNode.CanConsumeNode(
new ParsingContext(xoContext.CurrentNode,
new SyntaxList(oToken)),
false) == CanConsumeResult.Consume)
{
// Create tokens from everything beyond this Keyword we can use (because they will most likely be
// a part of the new keyword)
String sRemainingText = String.Join(" ", asTriviaTextTokens.Skip(iIndex));
xoTrivia.RawSQLText = String.Join(" ", asTriviaTextTokens.Take(iIndex));
// Start lexing the rest of the terms
SyntaxLexer oLexer = new SyntaxLexer(new SlidingTextWindow(sRemainingText));
// Add the new tokens to our list
while (oLexer.HasTokensLeftToProcess())
{
xaoReturnList.Add(oLexer.LexNextToken());
}
}
}
}
return(xaoReturnList.Count > 0);
}
public static void Test_LexIdentifiers(string input, string expected)
{
List <SyntaxToken> tokens = new SyntaxLexer(input).Lex();
List <SyntaxTokenKind> tokenKinds = new List <SyntaxTokenKind>();
foreach (SyntaxToken token in tokens)
{
tokenKinds.Add(token.Kind);
}
List <SyntaxTokenKind> expectedTokenKinds = ConvertToSyntaxTokenKinds(expected);
Assert.Equal(expectedTokenKinds, tokenKinds);
}
/// <summary>
/// Check text changed
/// </summary>
/// <param name="e"></param>
protected override void OnTextChanged(TextChangedEventArgs e)
{
base.OnTextChanged(e);
int length = Text.Length;
string text_buf = Text;
int pos = text_buf.IndexOf('\t');
while (pos != -1)
{
int linestart = text_buf.LastIndexOf(Environment.NewLine, pos);
if (linestart == -1)
{
linestart = 0;
}
else
{
linestart += 2;
}
int numSpace = TabSize - (pos - linestart) % TabSize;
text_buf = text_buf.Remove(pos, 1);
text_buf = text_buf.Insert(pos, new string(' ', numSpace));
pos = text_buf.IndexOf('\t', pos);
}
Text = text_buf;
//this.Text = this.Text.Replace("\t",this.Tab);
// If the Text is changed because of the Tab-Replacing this function is called again
// thats why we don't Parse
if (Text.Length > length)
{
return;
}
if (SyntaxLexer != null)
{
SyntaxLexer.Parse(this.Text, CaretIndex, e.Changes);
}
this.InvalidateVisual();
}
public static void Main()
{
while (true)
{
Console.Write("> ");
string input = Console.ReadLine();
if (input == "")
{
continue;
}
if (input == "exit")
{
return;
}
SyntaxLexer lexer = new SyntaxLexer();
SyntaxParser parser = new SyntaxParser();
Interpreter interpreter = new Interpreter();
List <SyntaxToken> tokens = lexer.Lex(input);
SyntaxParseResult result = parser.Parse(tokens);
foreach (Diagnostic diagnostic in result.Diagnostics)
{
Console.WriteLine($"{diagnostic.Severity}: {diagnostic.Message} at {diagnostic.Range.Start}");
}
DustObject value = interpreter.Interpret(result.Node);
Console.WriteLine($"{value.ToString().Value} ({value.TypeName})");
}
}
