static void Main(string[] args)
{
var calc = string.Join(" ", args);
var parse = ArithmeticParser.Parse(calc);
if (!parse.IsValid)
{
Console.Error.WriteLine("Invalid input:");
Console.Error.WriteLine(parse.ErrorMessage);
Environment.ExitCode = -1000;
return;
}
var answer = Computer.Compute(parse);
Console.WriteLine($"{calc} = {answer}");
}
public static IParseTree Parse(string input)
{
var str = new AntlrInputStream(input);
var lexer = new ArithmeticLexer(str);
Lexer = lexer;
var tokens = new CommonTokenStream(lexer);
TokenStream = tokens;
var parser = new ArithmeticParser(tokens);
Parser = parser;
var tree = parser.file_();
Tree = tree;
return(tree);
}
private int _convert(List <int> operands, string expression, double default_value)
{
int amount_operands = expression.Count((c) => c == 'x');
if (amount_operands != operands.Count)
{
Console.WriteLine(String.Format("WARN: amount of operands didnt match in operation {0} in BasicOperationConverter", expression));
return((int)default_value);
}
foreach (int operand in operands)
{
expression = expression.ReplaceFirst("x", operand.ToString());
}
int result = ArithmeticParser.EvaluateExpression(expression);
return(result);
}
static void Main(string[] args)
{
var parser = new ArithmeticParser();
var operations = new List<IPerformAnOperation>();
var value = "";
while (!value.ToLowerInvariant().Equals("compute"))
{
value = Console.ReadLine();
operations.Add(parser.GetOperation(value));
}
var result = 0;
foreach (var operation in operations)
{
result = operation.Operate(result);
}
Console.WriteLine(string.Format("The result is {0}", result));
Console.ReadLine();
}
public void ResultIsComputed()
{
//Arrange
var testStrings = new [] {
"5 + 3 * 6",
"5 * 3 + 6",
"5 * 2 + 3 / 4",
"5 * (2 + 3) / 4",
};
//Act
var results = testStrings
.Select(s => new { String = s, Result = ArithmeticParser.Parse(s) })
.ToList();
//Assert
var output = new Output();
output.FormatTable(results.Select(r => new { r.String, Description = r.Result.Describe(), Result = Computer.Compute(r.Result) }));
output.Report.Verify();
}
public void InputIsConverted()
{
//Arrange
var testStrings = new [] {
"1",
"32-5",
"(100 * 3)",
"100 + (3 * 5)",
"(3 * 5) + 100",
"1 + 2 + 3",
"1 + (3 * (5 + 6))",
"1 +",
"(1 + 3",
"(",
")",
"((1 + 2) * 3",
"(1 + 2) * 3)",
"5 + (10)"
};
//Act
var results = testStrings
.Select(s => new { String = s, Result = ArithmeticParser.Parse(s) })
.ToList();
//Assert
var output = new Output();
var report = results.AsReport(rep => rep
.AddColumn(r => r.String, cc => cc.Heading("Input"))
.AddColumn(r => r.Result.IsValid, cc => { })
.AddColumn(r => r.Result.Describe(), cc => cc.Heading("Result"))
.AddColumn(r => r.Result.ErrorMessage, cc => {})
);
output.FormatTable(report);
output.Report.Verify();
}
static void Try(string input)
{
var str = new AntlrInputStream(input);
System.Console.WriteLine(input);
var lexer = new ArithmeticLexer(str);
var tokens = new CommonTokenStream(lexer);
var parser = new ArithmeticParser(tokens);
var listener_lexer = new ErrorListener <int>();
var listener_parser = new ErrorListener <IToken>();
lexer.AddErrorListener(listener_lexer);
parser.AddErrorListener(listener_parser);
var tree = parser.file();
if (listener_lexer.had_error || listener_parser.had_error)
{
System.Console.WriteLine("error in parse.");
}
else
{
System.Console.WriteLine("parse completed.");
}
}
private void ArithmeticEvaluator(string _inputexpr, string _inputresult, Dictionary <string, dynamic> _external_data = null, bool Interpret = false, bool failTest = false)
{
var _expected = _inputresult;
if (Interpret == false && failTest == false)
{
var tokens = Helper_ConvertStringToList(_inputexpr);
int _index = 0;
ArithmeticParser p = new ArithmeticParser(tokens, ref _index);
var _actual = p.arith_expression?.expression;
Assert.AreEqual(_expected, _actual);
}
if (Interpret == true && failTest == false)
{
X.IO.Arithmetic.Evaluator ii = new X.IO.Arithmetic.Evaluator();
var _result = ii.Eval(_inputexpr, _external_data);
Assert.AreEqual(_expected, _result.value.ToString());
}
}
static Antlr4.Runtime.Tree.IParseTree DoParse(string input)
{
bool show_tree = false;
bool show_tokens = false;
bool old = false;
bool two_byte = false;
string file_name = null;
System.Text.Encoding encoding = null;
ICharStream str = null;
if (input == null && file_name == null)
{
str = CharStreams.fromStream(System.Console.OpenStandardInput());
}
else if (input != null)
{
str = CharStreams.fromString(input);
}
else if (file_name != null)
{
if (two_byte)
{
str = new TwoByteCharStream(file_name);
}
else if (old)
{
FileStream fs = new FileStream(file_name, FileMode.Open);
str = new Antlr4.Runtime.AntlrInputStream(fs);
}
else if (encoding == null)
{
str = CharStreams.fromPath(file_name);
}
else
{
str = CharStreams.fromPath(file_name, encoding);
}
}
var lexer = new ArithmeticLexer(str);
if (show_tokens)
{
StringBuilder new_s = new StringBuilder();
for (int i = 0; ; ++i)
{
var ro_token = lexer.NextToken();
var token = (CommonToken)ro_token;
token.TokenIndex = i;
new_s.AppendLine(token.ToString());
if (token.Type == Antlr4.Runtime.TokenConstants.EOF)
{
break;
}
}
System.Console.Error.WriteLine(new_s.ToString());
lexer.Reset();
}
var tokens = new CommonTokenStream(lexer);
var parser = new ArithmeticParser(tokens);
var listener_lexer = new ErrorListener <int>();
var listener_parser = new ErrorListener <IToken>();
lexer.AddErrorListener(listener_lexer);
parser.AddErrorListener(listener_parser);
DateTime before = DateTime.Now;
ArithmeticParser.File_Context tree = parser.file_();
DateTime after = DateTime.Now;
System.Console.Error.WriteLine("Time: " + (after - before));
if (listener_lexer.had_error || listener_parser.had_error)
{
System.Console.Error.WriteLine("Parse failed.");
}
else
{
System.Console.Error.WriteLine("Parse succeeded.");
}
if (show_tree)
{
System.Console.Error.WriteLine(tree.ToStringTree(parser));
}
System.Environment.Exit(listener_lexer.had_error || listener_parser.had_error ? 1 : 0);
return(tree);
}
static void Main(string[] args)
{
bool show_tree = false;
bool show_tokens = false;
string file_name = null;
string input = null;
for (int i = 0; i < args.Length; ++i)
{
if (args[i].Equals("-tokens"))
{
show_tokens = true;
continue;
}
else if (args[i].Equals("-tree"))
{
show_tree = true;
continue;
}
else if (args[i].Equals("-input"))
{
input = args[++i];
}
else if (args[i].Equals("-file"))
{
file_name = args[++i];
}
}
ICharStream str = null;
if (input == null && file_name == null)
{
StringBuilder sb = new StringBuilder();
int ch;
while ((ch = System.Console.Read()) != -1)
{
sb.Append((char)ch);
}
input = sb.ToString();
str = CharStreams.fromString(input);
}
else if (input != null)
{
str = CharStreams.fromString(input);
}
else if (file_name != null)
{
str = CharStreams.fromPath(file_name);
}
var lexer = new ArithmeticLexer(str);
if (show_tokens)
{
StringBuilder new_s = new StringBuilder();
for (int i = 0; ; ++i)
{
var ro_token = lexer.NextToken();
var token = (CommonToken)ro_token;
token.TokenIndex = i;
new_s.AppendLine(token.ToString());
if (token.Type == Antlr4.Runtime.TokenConstants.EOF)
{
break;
}
}
System.Console.Error.WriteLine(new_s.ToString());
lexer.Reset();
}
var tokens = new CommonTokenStream(lexer);
var parser = new ArithmeticParser(tokens);
var listener_lexer = new ErrorListener <int>();
var listener_parser = new ErrorListener <IToken>();
lexer.AddErrorListener(listener_lexer);
parser.AddErrorListener(listener_parser);
var tree = parser.file();
if (listener_lexer.had_error || listener_parser.had_error)
{
System.Console.Error.WriteLine("parse failed.");
}
else
{
System.Console.Error.WriteLine("parse succeeded.");
}
if (show_tree)
{
System.Console.Error.WriteLine(tree.ToStringTree(parser));
}
System.Environment.Exit(listener_lexer.had_error || listener_parser.had_error ? 1 : 0);
}
