private void Test(string input, string expectOutput, int expectMessages = 0, Severity expectSev = 0)
{
// Install token-to-string stategy to aid debugging
using (G.PushTLV(Token.ToStringStrategyTLV, t => (t.Value ?? ((CalcTokenType)t.TypeInt).ToString()).ToString())) {
MessageHolder errorList;
var input2 = StripInitialNewline(input);
var lexer = new CalculatorLexer(input2)
{
ErrorSink = errorList = new MessageHolder()
};
var wrapr = new IndentTokenGenerator(lexer, allIndTrig, new Token((int)CalcTokenType.Semicolon, 0, 0, null))
{
EolIndentTriggers = eolIndTrig,
IndentToken = new Token((int)CalcTokenType.LBrace, 0, 0, null),
DedentToken = new Token((int)CalcTokenType.RBrace, 0, 0, null),
};
var output = new DList <Token>();
for (var t = wrapr.NextToken(); t.HasValue; t = wrapr.NextToken())
{
output.Add(t.Value);
}
var expectTokens = new CalculatorLexer(expectOutput).Buffered().ToList();
AreEqual(expectMessages, errorList.List.Count);
if (expectMessages > 0)
{
AreEqual(expectSev, errorList.List.Max(m => m.Severity));
}
ExpectList(output, expectTokens, false);
}
}
public static double Calculate(string input)
{
var lexer = new CalculatorLexer(input);
Token EOF = new Token((int) TT.EOF, input.Length, 0);
var parser = new Calculator {
Src = new ParserSource<Token>(lexer, EOF, lexer.SourceFile)
};
return parser.Expr();
}
public void TestCalculator()
{
var testString = @"a=1+2*3; print a;";
CalculatorLexer lexer = new CalculatorLexer(new AntlrInputStream(testString));
CommonTokenStream tokens = new CommonTokenStream(lexer);
CalculatorParser p = new CalculatorParser(tokens);
p.BuildParseTree = true;
p.AddParseListener(new CalculatorListener());
ParserRuleContext t = p.program();
}
static int Evaluate(string input)
{
var stream = new AntlrInputStream(input);
var lexer = new CalculatorLexer(stream);
var tokens = new CommonTokenStream(lexer);
var parser = new CalculatorParser(tokens);
var program = parser.program();
var visitor = new CalcGrammarVisitor();
var result = visitor.Visit(program);
return(result);
}
public object Evaluate(string expression)
{
AntlrInputStream stream = new AntlrInputStream(expression);
CalculatorLexer lexer = new CalculatorLexer(stream);
CommonTokenStream tokenStream = new CommonTokenStream(lexer);
CalculatorParser parser = new CalculatorParser(tokenStream);
var root = parser.expression();
object result = root.Accept(m_processor);
return(result);
}
static void Main(string[] args)
{
Stream inputStream = Console.OpenStandardInput();
AntlrInputStream input = new AntlrInputStream(inputStream);
CalculatorLexer lexer = new CalculatorLexer(input);
lexer.AddErrorHandlers();
CommonTokenStream tokens = new CommonTokenStream(lexer);
CalculatorParser parser = new CalculatorParser(tokens);
parser.addSubExpr();
Console.ReadLine();
}
private int EvaluateInput(string input)
{
CalculatorLexer lexer = new CalculatorLexer(new AntlrInputStream(input));
lexer.RemoveErrorListeners();
lexer.AddErrorListener(new ThrowingErrorListener <int>());
CalculatorParser parser = new CalculatorParser(new CommonTokenStream(lexer));
parser.RemoveErrorListeners();
parser.AddErrorListener(new ThrowingErrorListener <IToken>());
return(new CalculatorVisitor().Visit(parser.expression()));
}
private void button1_Click(object sender, EventArgs e)
{
var reader = new StringReader(Formula.Text);
var input = new AntlrInputStream(reader.ReadToEnd());
var lexer = new CalculatorLexer(input);
var tokens = new CommonTokenStream(lexer);
var parser = new CalculatorParser(tokens);
IParseTree tree = parser.prog();
Tree.Text = tree.ToStringTree(parser);
var visitor = new CalculatorVisitor();
Result.Text = visitor.Visit(tree).ToString();
}
public static void Main(String[] args)
{
var data = File.ReadAllText("input.txt");
var input = new AntlrInputStream(data);
CalculatorLexer lexer = new CalculatorLexer(input);
CommonTokenStream tokens = new CommonTokenStream(lexer);
CalculatorParser parser = new CalculatorParser(tokens);
var tree = parser.input();
CalculatorBaseVisitorImpl calcVisitor = new CalculatorBaseVisitorImpl();
double result = calcVisitor.Visit(tree);
Console.WriteLine("Result: " + result);
}
static void Main(string[] args)
{
while (true)
{
Stream inputStream = Console.OpenStandardInput();
AntlrInputStream input = new AntlrInputStream(inputStream);
CalculatorLexer lexer = new CalculatorLexer(input);
CommonTokenStream tokens = new CommonTokenStream(lexer);
CalculatorParser parser = new CalculatorParser(tokens);
parser.prog();
Console.WriteLine("done");
Console.ReadLine();
}
}
static void Main(string[] args)
{
Stream inputStream = Console.OpenStandardInput();
AntlrInputStream input = new AntlrInputStream(inputStream);
CalculatorLexer lexer = new CalculatorLexer(input);
lexer.AddErrorHandlers();
CommonTokenStream tokens = new CommonTokenStream(lexer);
CalculatorParser parser = new CalculatorParser(tokens);
parser.addSubExpr();
Console.ReadLine();
}
static void Main(string[] args)
{
Stream inputStream = Console.OpenStandardInput();
AntlrInputStream input = new AntlrInputStream(inputStream);
CalculatorLexer lexer = new CalculatorLexer(input);
CommonTokenStream tokens = new CommonTokenStream(lexer);
CalculatorParser parser = new CalculatorParser(tokens);
IParseTree tree = parser.prog();
Console.WriteLine(tree.ToStringTree());
Console.WriteLine("done"); //to know when it's done
Console.ReadLine(); //to see the result
}
static void Main(string[] args)
{
var inputStream = new StreamReader(Console.OpenStandardInput());
var input = new AntlrInputStream(inputStream.ReadToEnd());
var lexer = new CalculatorLexer(input);
var tokens = new CommonTokenStream(lexer);
var parser = new CalculatorParser(tokens);
IParseTree tree = parser.prog();
Console.WriteLine(tree.ToStringTree(parser));
var visitor = new CalculatorVisitor();
Console.WriteLine(visitor.Visit(tree));
}
public static double Evaluate(string expression)
{
var lexer = new CalculatorLexer(new AntlrInputStream(expression));
lexer.RemoveErrorListeners();
lexer.AddErrorListener(new ThrowExceptionErrorListener());
var tokens = new CommonTokenStream(lexer);
var parser = new CalculatorParser(tokens);
var tree = parser.compileUnit();
var visitor = new ExcelVisitor();
return(visitor.Visit(tree));
}
static void Main(string[] args)
{
try
{
StreamReader inputStream = new StreamReader(Console.OpenStandardInput());
AntlrInputStream input = new AntlrInputStream(inputStream.ReadToEnd());
CalculatorLexer lexer = new CalculatorLexer(input);
CommonTokenStream tokens = new CommonTokenStream(lexer);
CalculatorParser parser = new CalculatorParser(tokens);
IParseTree tree = parser.prog();
Console.WriteLine(tree.ToStringTree(parser));
CalculatorVisitor visitor = new CalculatorVisitor();
Console.WriteLine(visitor.Visit(tree));
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
Console.ReadLine();
}
static void Main(string[] args)
{
try
{
StreamReader inputStream = new StreamReader(Console.OpenStandardInput());
AntlrInputStream input = new AntlrInputStream(inputStream.ReadToEnd());
CalculatorLexer lexer = new CalculatorLexer(input);
CommonTokenStream tokens = new CommonTokenStream(lexer);
CalculatorParser parser = new CalculatorParser(tokens);
IParseTree tree = parser.input();
Console.WriteLine(tree.ToStringTree(parser));
CalculatorVisitor visitor = new CalculatorVisitor();
Console.WriteLine(visitor.Visit(tree));
}
catch (DivideByZeroException ex)
{
Console.WriteLine("Cannot Divide By Zero");
}
Console.ReadLine();
}
public void Test_Visitor_With_SingleExpression_And_MultipleVariables_Returns_Variables()
{
var expressions = @"x = (((nrm / (1 + pct)) * (1 + (iss/100) + (pis/100))) / (1 + (iss/100) + (pis/100))) * (1 + (iss/100) + (pis/100) + frd)";
AntlrInputStream input = new AntlrInputStream(expressions);
CalculatorLexer lexer = new CalculatorLexer(input);
CommonTokenStream tokens = new CommonTokenStream(lexer);
CalculatorParser parser = new CalculatorParser(tokens);
IParseTree tree = parser.input();
CalculatorBaseVisitorImpl visitor = new CalculatorBaseVisitorImpl();
visitor.Variables.Add("nrm", 1223.5251m);
visitor.Variables.Add("pct", 0.05m);
visitor.Variables.Add("iss", 5m);
visitor.Variables.Add("pis", 3m);
visitor.Variables.Add("frd", 0.012m);
visitor.Visit(tree);
var result = visitor.Variables["x"];
}
public object Execute(string script)
{
AntlrInputStream stream = new AntlrInputStream(script);
CalculatorLexer lexer = new CalculatorLexer(stream);
CommonTokenStream tokenStream = new CommonTokenStream(lexer);
CalculatorParser parser = new CalculatorParser(tokenStream);
var root = parser.program();
if (root.IsEmpty && root.exception != null)
{
if (root.exception is RecognitionException)
{
throw new Exception("null");
}
else
{
throw new InvalidOperationException();
}
}
object result = root.Accept(m_processor);
return(result);
}
static void Main(string[] args)
{
var expressions = @"x = (((nrm / (1 + pct)) * (1 + (iss/100) + (pis/100))) / (1 + (iss/100) + (pis/100))) * (1 + (iss/100) + (pis/100) + frd)";
AntlrInputStream input = new AntlrInputStream(expressions);
CalculatorLexer lexer = new CalculatorLexer(input);
CommonTokenStream tokens = new CommonTokenStream(lexer);
CalculatorParser parser = new CalculatorParser(tokens);
IParseTree tree = parser.input();
CalculatorBaseVisitorImpl visitor = new CalculatorBaseVisitorImpl();
visitor.Variables.Add("nrm", 1223.5251m);
visitor.Variables.Add("pct", 0.05m);
visitor.Variables.Add("iss", 5m);
visitor.Variables.Add("pis", 3m);
visitor.Variables.Add("frd", 0.012m);
visitor.Visit(tree);
var result = visitor.Variables["x"];
Console.ReadLine();
}
/// <summary>
/// This will attempt to recalculate if an error was encountered. Will try to skip whitespaces
/// and comments so to prevent number literals and function qualifiers not being identified.
/// </summary>
/// <param name="formula"></param>
/// <param name="secondRun"></param>
/// <returns></returns>
private static CalculationResult CalculateResult(string formula, bool secondRun)
{
if (string.IsNullOrWhiteSpace(formula))
{
return(new CalculationResult
{
IsValid = true,
Result = 0
});
}
var inputStream = new AntlrInputStream(formula);
var lexer = new CalculatorLexer(inputStream);
var tokenStream = new CommonTokenStream(lexer);
var parser = new CalculatorParser(tokenStream);
// Removing default error listeners due to noise in debug
lexer.RemoveErrorListeners();
parser.RemoveErrorListeners();
// But adding the custom one
var customErrorListener = new CalculatorErrorListener();
parser.AddErrorListener(customErrorListener);
var visitor = new CalculatorVisitor();
var calculatorExpression = parser.calculator().expression();
var result = visitor.Visit(calculatorExpression);
var isValid = customErrorListener.IsValid;
var errorLocation = customErrorListener.ErrorLocation;
var errorMessage = customErrorListener.ErrorMessage;
if (double.IsInfinity(result))
{
isValid = false;
}
if (!isValid && !secondRun)
{
var cleanedFormula = string.Empty;
var tokenList = tokenStream.GetTokens().ToList();
for (var i = 0; i < tokenList.Count - 1; i++)
{
cleanedFormula += tokenList[i].Text;
}
var originalErrorLocation = errorLocation;
var retriedResult = CalculateResult(cleanedFormula, true);
if (!retriedResult.IsValid)
{
retriedResult.ErrorPosition = originalErrorLocation;
retriedResult.ErrorMessage = errorMessage;
}
return(retriedResult);
}
return(new CalculationResult
{
IsValid = isValid,
Result = isValid || double.IsInfinity(result)
? result
: double.NaN,
ErrorPosition = errorLocation,
ErrorMessage = isValid ? null : errorMessage
});
}
private void Test(string input, string expectOutput, int expectMessages = 0, Severity expectSev = 0)
{
// Install token-to-string stategy to aid debugging
using (G.PushTLV(Token.ToStringStrategyTLV, t => (t.Value ?? ((CalcTokenType)t.TypeInt).ToString()).ToString())) {
MessageHolder errorList;
var input2 = StripInitialNewline(input);
var lexer = new CalculatorLexer(input2) { ErrorSink = errorList = new MessageHolder() };
var wrapr = new IndentTokenGenerator(lexer, allIndTrig, new Token((int)CalcTokenType.Semicolon, 0, 0, null)) {
EolIndentTriggers = eolIndTrig,
IndentToken = new Token((int)CalcTokenType.LBrace, 0, 0, null),
DedentToken = new Token((int)CalcTokenType.RBrace, 0, 0, null),
};
var output = new DList<Token>();
for (var t = wrapr.NextToken(); t.HasValue; t = wrapr.NextToken())
output.Add(t.Value);
var expectTokens = new CalculatorLexer(expectOutput).Buffered().ToList();
AreEqual(expectMessages, errorList.List.Count);
if (expectMessages > 0)
AreEqual(expectSev, errorList.List.Max(m => m.Severity));
ExpectList(output, expectTokens, false);
}
}
