public string Parse(
string inputString,
ISimpleQueryLanguageVisitor <string> visitor)
{
logger.Debug(string.Format(
"Parse inputString: {0}", inputString));
Debug.WriteLine(string.Format(
"Parse inputString: {0}", inputString));
using (MemoryStream inputStream =
new MemoryStream(Encoding.ASCII.GetBytes(inputString))) {
inputStream.Position = 0;
AntlrInputStream input = new AntlrInputStream(inputStream);
SimpleQueryLanguageLexer lexer =
new SimpleQueryLanguageLexer(input);
CommonTokenStream tokens = new CommonTokenStream(lexer);
SimpleQueryLanguageParser parser =
new SimpleQueryLanguageParser(tokens);
parser.ErrorHandler = new BailErrorStrategy();
IParseTree tree = parser.prog();
Debug.WriteLine(string.Format("ParseTree: {0}",
tree.ToStringTree(parser)));
logger.Debug(string.Format("ParseTree: {0}",
tree.ToStringTree(parser)));
string result = visitor.Visit(tree);
logger.Debug(string.Format("Parse result: {0}", result));
Debug.WriteLine(string.Format("Parse result: {0}", result));
return(result);
}
}
public ASTResult GetAST(string path)
{
string program = File.ReadAllText(path);
AntlrInputStream input = new AntlrInputStream(program);
QLMainLexer lexer = new QLMainLexer(input);
CommonTokenStream tokens = new CommonTokenStream(lexer);
QLMainParser parser = new QLMainParser(tokens);
//remove standard Error Listener
parser.RemoveErrorListeners();
//Detect more errors (like ambiguousness errors)
//parser.AddErrorListener(new DiagnosticErrorListener());
//add standard error listener
parser.AddErrorListener(new ParserErrorListener());
IParseTree tree = parser.form();
Console.WriteLine(tree.ToStringTree(parser));
FormVisitor visitor = new FormVisitor();
Form ast = visitor.Visit(tree);
//TypeCheck.TypeChecker.GetTypeCheckDiagnosis(ast);
//Evaluate();
return(new ASTResult(ast));
}
static void Main(string[] args)
{
StreamReader astream = new StreamReader("test.txt");
AntlrInputStream antlrStream = new AntlrInputStream(astream);
firstLexer lexer = new firstLexer(antlrStream);
CommonTokenStream tokens = new CommonTokenStream(lexer);
firstParser parser = new firstParser(tokens);
IParseTree tree = parser.compileUnit();
GraphvizPrinterVisitor ptPrinter = new GraphvizPrinterVisitor();
ptPrinter.Visit(tree);
ASTGenerator astGenerator = new ASTGenerator();
astGenerator.Visit(tree);
ASTPrinter astPrinter = new ASTPrinter("test.dot");
astPrinter.Visit(astGenerator.M_Root);
Console.WriteLine(tree.ToStringTree());
}
private void botonEjecuta(object sender, EventArgs e)
{
string cadAnalisar = richTextBoxConsulta.Text.ToUpper();
AntlrInputStream input = new AntlrInputStream(cadAnalisar);
GramaticaSQLLexer lexer = new GramaticaSQLLexer(input);
CommonTokenStream token = new CommonTokenStream(lexer);
GramaticaSQLParser parser = new GramaticaSQLParser(token);
IParseTree tree = parser.consulta();
MessageBox.Show(tree.ToStringTree(parser));
visitorSQL visitor = new visitorSQL(BD, dataGridViewResConsulta);
visitor.Visit(tree);
//agregaInfoAGrid(visitor);
/*foreach(Entidad a in visitor.lisTabCons)
* {
* MessageBox.Show("Tabla: " + a.nombre+" Atributo: ");
* foreach(Atributo b in a.listAtrib)
* {
* MessageBox.Show(b.nombre);
* }
*
* }*/
}
private void Compilar()
{
AreaDeEscritura.SaveFile(ruta, RichTextBoxStreamType.PlainText);
StreamReader inputStream = new StreamReader(ruta);
try
{
AntlrInputStream input = new AntlrInputStream(inputStream.ReadToEnd());
NoobLexer lexer = new NoobLexer(input);
CommonTokenStream tokens = new CommonTokenStream(lexer);
NoobParser parser = new NoobParser(tokens);
IParseTree tree = parser.prog();
NoobVisitor visitor = new NoobVisitor();
visitor.Visit(tree);
inputStream.Close();
string arbol = tree.ToStringTree(parser);
Interprete inter = new Interprete(visitor.gsRepInt.gsTablaCuadruplo, visitor.gsRepInt.gsTablaDeSimbolos);
inter.EjecutarPrograma();
/*
*
*/
visitor.gsRepInt.imprimeTablaCuadruplos(this.TablaDeCuadruplos);
visitor.gsRepInt.imprimeTablaDeSimbolos(this.dtgTablaSimbolos);
}
catch (Exception e)
{
MessageBox.Show(" Error Sintactico " + e);
inputStream.Close();
}
}
public static void Main(string[] args)
{
if (args.Length == 0)
{
Console.WriteLine("Please name the C# file that you would like to compile as a program argument.");
return;
}
StreamReader sr = new StreamReader(args[0]);
ICharStream stream = CharStreams.fromString(sr.ReadToEnd());
CSharpLexer lexer = new CSharpLexer(stream);
ITokenStream tokenStream = new CommonTokenStream(lexer);
CSharpParser parser = new CSharpParser(tokenStream);
parser.BuildParseTree = true;
IParseTree tree = parser.compilation_unit();
Console.WriteLine(tree.ToStringTree(parser));
AST ast = new AST();
SymbolTable symbolTable = new SymbolTable();
ASTBuilder astBuilder = new ASTBuilder(ast, symbolTable);
ParseTreeWalker.Default.Walk(astBuilder, tree);
ast.Print();
}
private void button_Parse_Click(object sender, RoutedEventArgs e)
{
if (string.IsNullOrEmpty(textBox_Expr.Text))
{
return;
}
AntlrInputStream input = new AntlrInputStream(textBox_Expr.Text);
ParamExprGrammarLexer lexer = new ParamExprGrammarLexer(input);
CommonTokenStream tokens = new CommonTokenStream(lexer);
ParamExprGrammarParser parser = new ParamExprGrammarParser(tokens);
parser.RemoveErrorListeners();
Logger.resetStream();
parser.AddErrorListener(new ParamExprErrorListener());
//IParseTree tree = parser.start_rule();
IParseTree tree = parser.param_expr();
ParseTreeWalker walker = new ParseTreeWalker();
EvalListener eval = new EvalListener(parser);
walker.Walk(eval, tree);
// BIMRL_output.Text = tree.ToStringTree(parser);
string toOutput = new string(Logger.getmStreamContent());
textBox_Output.Text = tree.ToStringTree(parser) + '\n' + toOutput;
}
public void PrintResult(IParseTree parseTree, GrammarParser grammarParser, Visitor visitor)
{
Console.WriteLine("");
Console.WriteLine("Drzewo parsowania:");
Console.ForegroundColor = ConsoleColor.Cyan;
Console.WriteLine(parseTree.ToStringTree(grammarParser));
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine($"Wynik = {visitor.Visit(parseTree).ToString("R", FORMAT)}" + "\n");
Console.ResetColor();
}
static void Main(string[] args)
{
string stream;
Automato automato;
bool sair = false;
using (StreamReader arq = new StreamReader("gramatica.txt"))
stream = arq.ReadLine();
//esta automato está no arquivo gramatica.txt
//M=({a, b}, {q0, q1, q2, q3}, T, q0, {q3}) T={q0,a={q0,q1}; q0,b={q0,q2}; q1,a=q3; q2,b=q3; q3,a=q3; q3,b=q3}
//possui aa ou bb como subpalavra
//M=({a, b}, {q0, q1, q2, q3}, T, q0, {q3}) T={q0,a={q0,q1}; q0,b=q0; q1,a=q2; q2,a=q3}
//reconhece a palavra que possui aaa como sufixo
AntlrInputStream input = new AntlrInputStream(stream);
ITokenSource lexer = new AFNDLexer(input);
ITokenStream token = new CommonTokenStream(lexer);
AFNDParser parser = new AFNDParser(token);
parser.BuildParseTree = true;
IParseTree tree = parser.expr();
AFNDVisitor visitor = new AFNDVisitor();
Console.WriteLine(tree.ToStringTree(parser));
visitor.Visit(tree);
automato = visitor.GetAutomato();
if (automato.valido)
{
Console.WriteLine("Automato valido.");
while (!sair)
{
Console.WriteLine("Informe a frase teste: (S para sair)");
string s = Console.ReadLine();
if (!s.Equals("S"))
{
automato.Executar(s);
}
else
{
sair = true;
}
}
}
else
{
Console.WriteLine("Automato inválido.");
}
Console.ReadKey();
}
static void Main(string[] args)
{
StreamReader r = new StreamReader(args[0]);
AntlrInputStream ar = new AntlrInputStream(r);
CSVLexer lexer = new CSVLexer(ar);
CommonTokenStream tokens = new CommonTokenStream(lexer);
CSVParser parser = new CSVParser(tokens);
IParseTree tree = parser.compileUnit();
Console.WriteLine(tree.ToStringTree());
}
static void Main(string[] args)
{
try {
string input = "";
StringBuilder text = new StringBuilder();
Console.WriteLine("-----StringGrammar----- \n" +
"Ciag znakow: (ujety w cudyslow \"\") Przyklad: \"tekst\"\n" +
"Przesuniecie w lewo: '<' Przyklad: <2\"tekst\" \n" +
"Przesuniecie w prawo: '>' Przyklad: >2\"tekst\" \n" +
"Konkatencja: '+' Przyklad: \"tekst1\" + \"tekst2\" \n" +
"Roznica: '-' Przyklad: \"abce\" - \"ab\" \n" +
"Litery duze: '^' Przyklad: ^\"abc\" \n" +
"Litery male: '_' Przyklad: _\"ABC\" \n" +
"Podciag: '$' Przyklad: $2\"abcde\" lub $3,2\"abcde\" \n" +
"\n" +
"Podaj ciag (Ciag nalezy zakonczyc kombinacja 'CTRL+Z'):");
while ((input = Console.ReadLine()) != null)
{
text.AppendLine(input);
}
AntlrInputStream inputStream = new AntlrInputStream(text.ToString());
StringGrammarLexer lexer = new StringGrammarLexer(inputStream);
CommonTokenStream commonTokenStream = new CommonTokenStream(lexer);
StringGrammarParser parser = new StringGrammarParser(commonTokenStream)
{
BuildParseTree = true
};
IParseTree tree = parser.prog();
int errors = parser.NumberOfSyntaxErrors;
Console.WriteLine("Liczba bledow syntaktycznych: " + errors);
if (0 == errors)
{
StringGrammarVisitor visitor = new StringGrammarVisitor();
if (TreeIsNotEmpty(tree))
{
var result = visitor.Visit(tree);
Console.WriteLine(tree.ToStringTree(parser));
Console.WriteLine("Wynik = " + result);
}
else
{
Console.WriteLine("Nie podano żadnego ciągu znakowego");
}
}
;
} catch (Exception ex) {
Console.WriteLine("Blad: " + ex);
}
Console.Read();
}
static void Main(string[] args)
{
var a = new StreamReader("./root.txt");
var antlrInput = new AntlrInputStream(a);
var lexer = new CalcLexer(antlrInput);
var tokens = new BufferedTokenStream(lexer);
var parser = new CalcParser(tokens);
lexer.PushLexerState();
IParseTree tree = parser.compileUnit();
Console.WriteLine(tree.ToStringTree());
}
public void Parse()
{
foreach (string s in m_inputFiles)
{
StreamReader str = new StreamReader(s);
AntlrInputStream ANTLRstr = new AntlrInputStream(str);
BNFLexer lexer = new BNFLexer(ANTLRstr);
CommonTokenStream tokens = new CommonTokenStream(lexer);
BNFParser parser = new BNFParser(tokens);
lexer.Mode(BNFLexer.DECLARATIONS);
IParseTree tree = parser.compileUnit();
Console.WriteLine(tree.ToStringTree());
}
}
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));
}
private void ButCalc_Click(object sender, EventArgs e)
{
var reader = new StringReader(Formula.Text);
var input = new AntlrInputStream(reader.ReadToEnd());
var lexer = new CalcLexer(input);
var tokens = new CommonTokenStream(lexer);
var parser = new CalcParser(tokens);
IParseTree tree = parser.prog();
Tree.Text = tree.ToStringTree(parser);
var visitor = new CalcVisitor();
Result.Text = visitor.Visit(tree).ToString();
}
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 ExampleOne()
{
AntlrInputStream input = new AntlrInputStream(File.Open("t.expr", FileMode.Open));
ExprLexer lexer = new ExprLexer(input);
CommonTokenStream tokenStream = new CommonTokenStream(lexer);
ExprParser parser = new ExprParser(tokenStream);
IParseTree tree = parser.prog();
string output = tree.ToStringTree(parser).Replace("\\n", "\n"); //Environment.NewLine);
Console.Write(output);
Console.Read();
}
static void Main(string[] args)
{
var filePath = @"episodeview.xqy";
var inputStream = new FileStream(filePath, FileMode.Open);
var input = new AntlrInputStream(inputStream);
var lexer = new XqyLexer(input);
var tokens = new CommonTokenStream(lexer);
var parser = new XqyParser(tokens);
IParseTree tree = parser.prog();
Console.WriteLine(tree.ToStringTree(parser));
var visitor = new XqyVisitor();
Console.WriteLine(visitor.Visit(tree));
}
static void Main(string[] args)
{
AntlrInputStream input = new AntlrInputStream(args[0]);
ArrayInitLexer lexer = new ArrayInitLexer(input);
CommonTokenStream tokens = new CommonTokenStream(lexer);
ArrayInitParser parser = new ArrayInitParser(tokens);
IParseTree tree = parser.list();
Console.WriteLine(tree.ToStringTree(parser));
Console.WriteLine("");
ParseTreeWalker walker = new ParseTreeWalker();
walker.Walk(new ValueConvertor(), tree);
Console.WriteLine("");
}
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)
{
StreamReader astream = new StreamReader(args[0]);
AntlrInputStream antlrStream = new AntlrInputStream(astream);
MINICLexer lexer = new MINICLexer(antlrStream);
CommonTokenStream tokens = new CommonTokenStream(lexer);
MINICParser parser = new MINICParser(tokens);
IParseTree tree = parser.compileUnit();
Console.WriteLine(tree.ToStringTree());
STPrinter ptPrinter = new STPrinter();
ptPrinter.Visit(tree);
ASTGenerator astGenerator = new ASTGenerator();
astGenerator.Visit(tree);
ASTPrinter astPrinter = new ASTPrinter("test.ast.dot");
astPrinter.Visit(astGenerator.M_Root);
MINIC2CTranslation tr = new MINIC2CTranslation();
tr.VisitCOMPILEUNIT(astGenerator.M_Root as CASTCompileUnit, new TranslationParameters());
tr.M_TranslatedFile.EmmitStdout();
StreamWriter trFile = new StreamWriter(Path.GetFileName(args[0] + ".c"));
tr.M_TranslatedFile.EmmitToFile(trFile);
trFile.Close();
StreamWriter m_streamWriter = new StreamWriter("CodeStructure.dot");
tr.M_TranslatedFile.PrintStructure(m_streamWriter);
}
public static void VerilogSample()
{
Console.WriteLine("Hello World!");
// TODO: Implement Functionality Here
Stream stream = new FileStream("mux_using_assign.v", FileMode.Open);
StreamReader inputStream = new StreamReader(stream);
AntlrInputStream input = new AntlrInputStream(inputStream.ReadToEnd());
Verilog2001Lexer lexer = new Verilog2001Lexer(input);
CommonTokenStream tokens = new CommonTokenStream(lexer);
Verilog2001Parser parser = new Verilog2001Parser(tokens);
IParseTree tree = parser.source_text();
Console.WriteLine(tree.ToStringTree(parser));
//VhdlAntlrVisitor visitor = new VhdlAntlrVisitor();
//Console.WriteLine(visitor.Visit(tree));
Console.Write("Press any key to continue . . . ");
Console.ReadKey(true);
}
static void Main(string[] args)
{
StreamReader AStream = new StreamReader(args[0]);
AntlrInputStream antlrInputStream = new AntlrInputStream(AStream);
MINICLexer lexer = new MINICLexer(antlrInputStream);
CommonTokenStream tokens = new CommonTokenStream(lexer);
MINICParser parser = new MINICParser(tokens);
IParseTree tree = parser.compileUnit();
Console.WriteLine(tree.ToStringTree());
STPrinterVisitor stPrinter = new STPrinterVisitor();
stPrinter.Visit(tree);
ASTGenerator astgen = new ASTGenerator();
astgen.Visit(tree);
ASTPrinterVisitor astPrinterVisitor = new ASTPrinterVisitor("test.ast.dot");
astPrinterVisitor.Visit(astgen.M_Root);
MINICTranslation cGenerator = new MINICTranslation();
cGenerator.Visit(astgen.M_Root);
CodeContainer file = cGenerator.FileBuilder.AssemblyCodeContainer();
Console.WriteLine(file.ToString());
StreamWriter m_streamWriter = new StreamWriter("CodeStructure.dot");
cGenerator.FileBuilder.PrintStructure(m_streamWriter);
MINICPrinter m_minicPrinter = new MINICPrinter("CodeStructure.c", file);
m_minicPrinter.printer();
}
static void Main(string[] args)
{
StreamReader aStream = new StreamReader(args[0]);
AntlrInputStream antlrInputStream = new AntlrInputStream(aStream);
SimpleCalcLexer lexer = new SimpleCalcLexer(antlrInputStream);
CommonTokenStream tokens = new CommonTokenStream(lexer);
SimpleCalcParser parser = new SimpleCalcParser(tokens);
IParseTree tree = parser.compileUnit();
Console.WriteLine(tree.ToStringTree());
STPrinter stPrinter = new STPrinter();
stPrinter.Visit(tree);
ASTGenerator astgen = new ASTGenerator();
astgen.Visit(tree);
ASTPrinterVisitor astPrinter = new ASTPrinterVisitor();
astPrinter.Visit(astgen.M_Root);
}
public bool ParseValid(string text)
{
//var inputStream = new StreamReader(Console.OpenStandardInput());
var input = new AntlrInputStream(text);
var lexer = new DOTLexer(input);
var tokens = new CommonTokenStream(lexer);
var parser = new DOTParser(tokens);
parser.RemoveErrorListeners();
var errorListener = new ErrorListener(_errorHandler);
parser.AddErrorListener(errorListener);
IParseTree tree = parser.graph();
var tmp = tree.ToStringTree(parser);
// Console.WriteLine(tree.ToStringTree(parser));
// CalculatorVisitor visitor = new CalculatorVisitor();
// Console.WriteLine(visitor.Visit(tree));
return(!errorListener.HasParserErrors);
}
private void button1_Click(object sender, EventArgs e)
{
string inputString = textBox1.Text;
ICharStream inputStream = new AntlrInputStream(inputString.ToString());
ITokenSource speakLexer = new SpeakLexer(inputStream);
CommonTokenStream commonTokenStream = new CommonTokenStream(speakLexer);
SpeakParser speakParser = new SpeakParser(commonTokenStream);
speakParser.BuildParseTree = true;
IParseTree tree = speakParser.chat();
textBox1.Text = tree.ToStringTree();
var treeNodeDrawable = new ASTTreeNode(tree);
if (pictureBox1.Image != null)
{
pictureBox1.Image.Dispose();
pictureBox1.Image = null;
}
Image image = new VisualAST(treeNodeDrawable).Draw();
pictureBox1.Image = image;
}
public void Test1()
{
// Assert
var input = new AntlrInputStream(new StringReader(@"
module X
entity A {
a : A
b : B
}
entity B {}"));
var lexer = new EntityLanguageLexer(input);
var tokens = new CommonTokenStream(lexer);
var parser = new EntityLanguageParser(tokens);
// Act
IParseTree tree = parser.start();
// Assert
string s = tree.ToStringTree(parser);
Assert.Equal("(start module X (definition entity A { (property a : (type A)) (property b : (type B)) }) (definition entity B { }))", s);
}
static void Main(string[] args)
{
try
{
Console.WriteLine("Key in the input string:");
var input = Console.ReadLine();
ICharStream charStream = new AntlrInputStream(input);
DateCalculatorLexer lexer = new DateCalculatorLexer(charStream);
ITokenStream tokenStream = new CommonTokenStream(lexer);
DateCalculatorParser parser = new DateCalculatorParser(tokenStream)
{
BuildParseTree = true
};
IParseTree tree = parser.expression();
var errors = parser.NumberOfSyntaxErrors;
Console.WriteLine($"Number of syntax errors: {errors}");
Console.WriteLine(tree.ToStringTree(parser));
if (0 < errors)
{
return;
}
var visitor = new TreeVisitor();
Console.WriteLine($"Result = {visitor.Visit(tree).ToString()}");
Console.WriteLine("Koniec!");
}
catch (Exception ex)
{
Console.WriteLine("Error: " + ex);
}
}
static void Main(string[] args)
{
Program.Initiation();
while (true)
{
Console.Write(">> ");
StreamReader streamReader = new StreamReader(Console.OpenStandardInput());
try
{
AntlrInputStream inputStream = new AntlrInputStream(streamReader.ReadLine());
if (inputStream.ToString().Contains("\u001a") || inputStream.ToString().Contains("\u0004"))
{
Console.WriteLine("EOF");
break;
}
FA_LanguageLexer fA_LanguageLexer = new FA_LanguageLexer(inputStream);
CommonTokenStream commonTokenStream = new CommonTokenStream(fA_LanguageLexer);
FA_LanguageParser fA_LanguageParser = new FA_LanguageParser(commonTokenStream);
IParseTree parseTree = fA_LanguageParser.conversation();
FA_Visitor fA_Visitor = new FA_Visitor(Program.functions);
// Print tree and output result
Console.WriteLine(parseTree.ToStringTree(fA_LanguageParser));
Console.WriteLine(fA_Visitor.Visit(parseTree).ToString());
}
catch (System.NullReferenceException e)
{
Console.WriteLine("error: " + e.Message);
continue;
}
}
}
public override Expression Visit(IParseTree tree)
{
writer($"{System.Reflection.MethodBase.GetCurrentMethod().Name} | {tree.ToStringTree()}");
return(base.Visit(tree));
}
