public void TestCompleteBuffer()
{
Grammar g = new Grammar(
"lexer grammar t;\n" +
"ID : 'a'..'z'+;\n" +
"INT : '0'..'9'+;\n" +
"SEMI : ';';\n" +
"ASSIGN : '=';\n" +
"PLUS : '+';\n" +
"MULT : '*';\n" +
"WS : ' '+;\n");
// Tokens: 012345678901234567
// Input: x = 3 * 0 + 2 * 0;
ICharStream input = new ANTLRStringStream("x = 3 * 0 + 2 * 0;");
Interpreter lexEngine = new Interpreter(g, input);
BufferedTokenStream tokens = new BufferedTokenStream(lexEngine);
int i = 1;
IToken t = tokens.LT(i);
while (t.Type != CharStreamConstants.EndOfFile)
{
i++;
t = tokens.LT(i);
}
tokens.LT(i++); // push it past end
tokens.LT(i++);
string result = tokens.ToString();
string expecting = "x = 3 * 0 + 2 * 0;";
Assert.AreEqual(expecting, result);
}
public static LuaResult Compile(
StaticMetaTables staticTables,
string source,
dynamic globals = null,
string name = null)
{
var result = new LuaResult();
var stopwatch = new Stopwatch();
stopwatch.Start();
try
{
var stream = new ANTLRStringStream(source);
var lexer = new ChunkLexer(stream);
var tokenStream = new CommonTokenStream(lexer);
var parser = new ChunkParser(tokenStream);
var r = parser.chunk();
result.Errors.AddRange(parser.Errors);
Expression e;
var scope = Scope.NewTopLevelScop();
var chunk = new Chunk();
result.Errors.AddRange(chunk.Generate(staticTables, scope, r.Tree, out e));
var fnExp = Expression.Lambda<Func<Table, object>>(e, scope.Env.GlobalParameter);
result.Chunk = new CompiledChunk(fnExp.Compile(), globals ?? new Table(), name);
}
finally
{
stopwatch.Stop();
result.ElapsedTime = stopwatch.Elapsed;
result.Success = !result.Errors.ContainsError();
}
return result;
}
public void TestMismatchedSetError()
{
Grammar pg = new Grammar(
"parser grammar p;\n" +
"prog : WHILE ID LCURLY (assign)* RCURLY;\n" +
"assign : ID ASSIGN expr SEMI ;\n" +
"expr : INT | FLOAT | ID ;\n");
Grammar g = new Grammar();
g.ImportTokenVocabulary(pg);
g.FileName = "<string>";
g.SetGrammarContent(
"lexer grammar t;\n" +
"WHILE : 'while';\n" +
"LCURLY : '{';\n" +
"RCURLY : '}';\n" +
"ASSIGN : '=';\n" +
"SEMI : ';';\n" +
"ID : ('a'..'z')+ ;\n" +
"INT : (DIGIT)+ ;\n" +
"FLOAT : (DIGIT)+ '.' (DIGIT)* ;\n" +
"fragment DIGIT : '0'..'9';\n" +
"WS : (' ')+ ;\n");
ICharStream input = new ANTLRStringStream("while x { i=; y=3.42; z=y; }");
Interpreter lexEngine = new Interpreter(g, input);
FilteringTokenStream tokens = new FilteringTokenStream(lexEngine);
tokens.SetTokenTypeChannel(g.GetTokenType("WS"), 99);
//System.out.println("tokens="+tokens.toString());
Interpreter parseEngine = new Interpreter(pg, tokens);
ParseTree t = parseEngine.Parse("prog");
string result = t.ToStringTree();
string expecting =
"(<grammar p> (prog while x { (assign i = (expr MismatchedSetException(10!={5,6,7})))))";
Assert.AreEqual(expecting, result);
}
/// <summary>
/// Parses an expression in text form for later evaluation.
/// </summary>
/// <param name="pszCode">The expression to be parsed.</param>
/// <param name="dwFlags">A combination of flags from the PARSEFLAGS enumeration that controls parsing.</param>
/// <param name="nRadix">The radix to be used in parsing any numerical information in pszCode.</param>
/// <param name="ppExpr">Returns the IDebugExpression2 object that represents the parsed expression, which is ready for binding and evaluation.</param>
/// <param name="pbstrError">Returns the error message if the expression contains an error.</param>
/// <param name="pichError">Returns the character index of the error in pszCode if the expression contains an error.</param>
/// <returns>If successful, returns S_OK; otherwise, returns an error code.</returns>
/// <remarks>
/// When this method is called, a debug engine (DE) should parse the expression and validate it for correctness.
/// The pbstrError and pichError parameters may be filled in if the expression is invalid.
///
/// Note that the expression is not evaluated, only parsed. A later call to the IDebugExpression2.EvaluateSync
/// or IDebugExpression2.EvaluateAsync methods evaluates the parsed expression.
/// </remarks>
public int ParseText(string pszCode, enum_PARSEFLAGS dwFlags, uint nRadix, out IDebugExpression2 ppExpr, out string pbstrError, out uint pichError)
{
if (pszCode == null)
throw new ArgumentNullException("pszCode");
if (pszCode.Length == 0)
throw new ArgumentException();
// dwFlags=0 in the Immediate window
if (dwFlags != enum_PARSEFLAGS.PARSE_EXPRESSION && dwFlags != 0)
throw new NotImplementedException();
try
{
var expressionInput = new ANTLRStringStream(pszCode);
var expressionUnicodeInput = new JavaUnicodeStream(expressionInput);
var expressionLexer = new Java2Lexer(expressionUnicodeInput);
var expressionTokens = new CommonTokenStream(expressionLexer);
var expressionParser = new Java2Parser(expressionTokens);
IAstRuleReturnScope<CommonTree> result = expressionParser.standaloneExpression();
ppExpr = new JavaDebugExpression(this, result.Tree, pszCode);
pbstrError = null;
pichError = 0;
return VSConstants.S_OK;
}
catch (RecognitionException e)
{
ppExpr = null;
pbstrError = e.Message;
pichError = (uint)Math.Max(0, e.Index);
return VSConstants.E_FAIL;
}
}
public void VisitLine(String line)
{
Core interp_visitor = new Core();
PrintVisitor print_visitor = new PrintVisitor(interp_visitor);
ANTLRStringStream string_stream = new ANTLRStringStream(line);
spinachLexer lexer = new spinachLexer(string_stream);
CommonTokenStream tokens = new CommonTokenStream(lexer);
spinachParser parser = new Test_Core(tokens, "");
try
{
spinachParser.program_return program = parser.program(); //h= (l+j)*h*l+l-h;
if (strBuilder.ToString() == "")
{
List<Element> elements = program.ret;
///-- call core function. to pass list of element.
for (int i = 0; i < elements.Count; i++)
{
Element curr = elements[i];
curr.Accept(print_visitor);
curr.Accept(interp_visitor);//PlotReceiver
}
}
else
{
Onerror(101, strBuilder.ToString());
}
}
catch (RecognitionException e)
{
Onerror(102, e.Message);
}
}
public Expression Compile(String relinqScript)
{
var input = new ANTLRStringStream(relinqScript);
var lex = new EcmaScriptV3Lexer(input);
var tokens = new CommonTokenStream(lex);
var parser = new EcmaScriptV3Parser(tokens);
var es3Ast = parser.expression();
var rsAst = new RelinqScriptParser().Visit((CommonTree)es3Ast.Tree);
var compilerAst = new TypeInferenceAstBuilder().Visit(rsAst);
using (var engine = new TypeInferenceEngine(compilerAst))
{
#if DEBUG
try
{
var wtf = 0;
while(!engine.Run()) if (wtf++ == 10) break;
return new StronglyTypedAstBuilder().Visit(compilerAst);
}
catch (Exception)
{
engine.Dump();
throw;
}
#else
engine.Run();
return new StronglyTypedAstBuilder().Visit(tiAst);
#endif
}
}
public Boolean RunTest()
{
try
{
GlobalMemory.Clear();
var sStream = new ANTLRStringStream(input);
var lexer = new SGLLexer(sStream);
var tStream = new CommonTokenStream(lexer);
// Parsing
var parser = new SGLParser(tStream);
var t = (CommonTree) parser.main().Tree;
// Printing tree
Console.WriteLine("; " + t.ToStringTree());
// TreeWalking
var treeStream = new CommonTreeNodeStream(t);
var tw = new SGLTreeWalker(treeStream, true);
AbstractNode returned = tw.main();
returned.Evaluate();
if (debug)
{
realOutput = GlobalMemory.Instance.DebugString;
}
else
{
realOutput = GlobalMemory.Instance.StoryboardCode.ToString();
}
// comparison
realOutput = realOutput.Trim();
output.Trim();
if (output.Equals(realOutput))
{
return true;
}
else
{
return false;
}
}
catch (CompilerException ce)
{
Console.WriteLine(ce.GetExceptionAsString());
return false;
}
catch (Exception ex)
{
Console.WriteLine("Es ist ein Fehler aufgetreten.");
Console.WriteLine(ex.Message);
Console.WriteLine(ex.StackTrace);
return false;
}
}
public void Execute()
{
string input =
@"
Sart(0,0)
End(12,15)
";
ANTLRStringStream inStream = new ANTLRStringStream(input);
ConfLexer lexer = new ConfLexer(inStream);
CommonTokenStream tokens = new CommonTokenStream(lexer);
ConfParser parser = new ConfParser(tokens);
ConfParser.prog_return returnParser = parser.prog();
var tree = returnParser.Tree as CommonTree;
foreach (CommonTree item in tree.Children)
{
if (item.Type == ConfLexer.ID)
Console.WriteLine("function=" + item.Text);
else if(item.Type == ConfLexer.INT)
Console.WriteLine("params:" + item.Text);
}
Console.ReadKey();
}
public static List<Error> Translate(Source source)
{
var err = new List<Error>();
var prg = new Program();
try
{
var input = new ANTLRStringStream(source.GetSourceData());
var lexer = new PascalLexer(input);
var tokens = new CommonTokenStream(lexer);
var parser = new PascalParser(tokens);
prg = parser.program();
prg.SetSourceIdentifier(source.GetSourceIdentifier());
}
catch (RecognitionException e)
{
err.Add(new Error(FormatRecognitionException(e, source.GetSourceIdentifier())));
}
if (err.Count != 0)
return err;
var val = new Validator();
err = val.Validate(prg);
Root = prg;
return err;
}
public static string Compile(string input)
{
input = input.Replace("\r", "");
ANTLRStringStream Input = new ANTLRStringStream(input);
SugarCppLexer lexer = new SugarCppLexer(Input);
CommonTokenStream tokens = new CommonTokenStream(lexer);
SugarCppParser parser = new SugarCppParser(tokens);
AstParserRuleReturnScope<CommonTree, IToken> t = parser.root();
CommonTree ct = (CommonTree)t.Tree;
if (parser.errors.Count() > 0)
{
StringBuilder sb = new StringBuilder();
foreach (var error in parser.errors)
{
sb.Append(error);
sb.Append("\n");
}
throw new Exception(sb.ToString());
}
CommonTreeNodeStream nodes = new CommonTreeNodeStream(ct);
SugarWalker walker = new SugarWalker(nodes);
Root ast = walker.root();
TargetCpp target_cpp = new TargetCpp();
return ast.Accept(target_cpp).Render();
}
public ASMParser GetParser(string script)
{
var input = new ANTLRStringStream(script);
var lexer = new ASMLexer(input);
var tokens = new CommonTokenStream(lexer);
return new ASMParser(tokens);
}
public Context From(string source)
{
var stream = new ANTLRStringStream(source);
var lexer = new MessageContractsLexer(stream);
var tokens = new CommonTokenStream(lexer);
var parser = new MessageContractsParser(tokens)
{
TreeAdaptor = new CommonTreeAdaptor()
};
var program = parser.GetProgram();
var commonTree = (CommonTree)program.Tree;
var node = commonTree as CommonErrorNode;
if (node != null)
{
throw new InvalidOperationException(node.ToString());
}
var ctx = new Context();
foreach (var child in commonTree.Children)
{
WalkDeclarations(child, ctx);
}
return ctx;
}
public Boolean RunTest()
{
try
{
ANTLRStringStream sStream = new ANTLRStringStream(input);
SGLLexer lexer = new SGLLexer(sStream);
CommonTokenStream tStream = new CommonTokenStream(lexer);
// Parsing
SGLParser parser = new SGLParser(tStream);
CommonTree t = (CommonTree)parser.compilationUnit().Tree;
// Printing tree
Console.WriteLine("; " + t.ToStringTree());
// TreeWalking
CommonTreeNodeStream treeStream = new CommonTreeNodeStream(t);
SGLTreeWalker tw = new SGLTreeWalker(treeStream);
SGLNode returned = tw.compilationUnit();
returned.Evaluate();
realOutput = tw.GetStoryboardCode().ToString();
// comparison
realOutput = realOutput.Trim();
output.Trim();
if (output.Equals(realOutput))
{
return true;
}
else
{
return false;
}
}
catch (SGLCompilerException ce)
{
if (ce.ErrorType.Equals("Antlr.Parser"))
{
Console.WriteLine("Error (wrong syntax) on " + ce.Message);
}
else
{
Console.WriteLine("Error (" + ce.ErrorType + ") on line " + ce.Line + ": " + ce.Message);
}
return false;
}
catch (Exception ex)
{
Console.WriteLine("Es ist ein Fehler aufgetreten.");
Console.WriteLine(ex.Message);
Console.WriteLine(ex.StackTrace);
return false;
}
}
private static AntlrCalcEngineParser CreateParser( string parseText )
{
var input = new ANTLRStringStream( parseText );
var lex = new AntlrCalcEngineLexer( input );
var tokens = new CommonTokenStream( lex );
return new AntlrCalcEngineParser( tokens );
}
public static JsonParser jsonParserFromString(string input)
{
var inputStream = new ANTLRStringStream(input);
var lexer = new JsonLexer(inputStream);
var tokens = new CommonTokenStream(lexer);
var parser = new JsonParser(tokens);
return parser;
}
private CommonTree ParseViaAntlrOnly(String relinqScriptCode)
{
var input = new ANTLRStringStream(relinqScriptCode);
var lex = new EcmaScriptV3Lexer(input);
var tokens = new CommonTokenStream(lex);
var parser = new EcmaScriptV3Parser(tokens);
return (CommonTree)parser.expression().Tree;
}
private static LexResult AssertThat(string input)
{
var antlrStringStream = new ANTLRStringStream(input);
var lexter = new CFlatLexer(antlrStringStream);
var tokens = new CommonTokenStream(lexter);
return new LexResult(tokens);
}
public StyleDocument LoadFromString(string input)
{
var stream = new ANTLRStringStream(input);
var lexer = new lesscssLexer(stream);
var parser = new lesscssParser(new CommonTokenStream(lexer));
var root = parser.lessCss();
return ParseDocument((BaseTree)root.Tree);
}
static void Main(string[] args)
{
var input = new ANTLRStringStream("a=(3+4)*5\r\na+1\r\n");
var lexer = new ExprLexer(input);
var tokens = new CommonTokenStream(lexer);
var parser = new ExprParser(tokens);
parser.prog();
}
// throws SyntaxErrorException
private CommonTree AcquireAntlrAst()
{
var input = new ANTLRStringStream(ElfCode);
var lex = new ElfLexer(input);
var tokens = new CommonTokenStream(lex);
var parser = new ElfParser(tokens);
var esV3Ast = (CommonTree)parser.script().Tree;
return esV3Ast.RecursivelyReplaceNullListsWithEmptyOnes();
}
public string Process(string template, Dictionary<string, object> variables)
{
//This is a hack, but it removes the need for a step to separate html from tt
//by treating it all as literals between tags
Console.WriteLine("--------------------------------------------");
Console.WriteLine(template);
template = string.Concat("[%'", template.Replace("[%", "'^^][%").Replace("%]", "%][%'").Replace("'^^]", "'%]"), "'%]");
template = template.Replace("[%''%]", "");
Console.WriteLine("--------------------------------------------");
Console.WriteLine(template);
Console.WriteLine("--------------------------------------------");
//CSharpTarget.stg contains string templates used for targeting C#
//TextReader stgReader = new StreamReader(File.Open("CSharpGenerator.stg", FileMode.Open));
TextReader stgReader = new StreamReader("CSharpGenerator.stg");
StringTemplateGroup stg = new StringTemplateGroup(stgReader);
//lex
ICharStream input = new ANTLRStringStream(template);
TemplateLexer lex = new TemplateLexer(input);
//parse
TemplateParser parse = new TemplateParser(new CommonTokenStream(lex));
TemplateParser.document_return parseRet = parse.document();
Console.WriteLine(( (CommonTree) parseRet.Tree).ToStringTree());
//generate C#
ITreeNodeStream nodeStream = new CommonTreeNodeStream(parseRet.Tree);
CSharpGenerator gen = new CSharpGenerator(nodeStream);
gen.TemplateLib = stg;
CSharpGenerator.document_return ret = gen.document();
//compile to executable and optionally run
Console.WriteLine("--------------------------------------------");
Console.WriteLine(ret.Template.ToString());
Console.WriteLine("--------------------------------------------");
// compile and run it
var inMemory = true;
Assembly assembly = Generate(ret.Template.ToString(), "", inMemory);
if (inMemory)
{
//assembly.EntryPoint.Invoke(null, new object[] { new string[] { } });
var o = assembly.CreateInstance("x");
Object[] args = {this.Settings, variables};
var result = o.GetType().InvokeMember("Render", BindingFlags.Instance | BindingFlags.Public | BindingFlags.InvokeMethod, null, o, args);
return result.ToString();
}
return "";
}
internal static CommonTree BuildAst(string document)
{
var input = new ANTLRStringStream(document);
var lexer = new JavaLexer(input);
var tokens = new CommonTokenStream(lexer);
var parser = new JavaParser(tokens);
return parser.javaSource().Tree;
}
private static void Main(string[] args)
{
var input = new ANTLRStringStream("if row[0] = 0 then 0");
var lexer = new TigerLexer(input);
var tokens = new CommonTokenStream(lexer);
var parser = new TigerParser(tokens);
ExpressionNode x = parser.prog();
// Debug();
}
public CommonTree BuildAST(string script)
{
var input = new ANTLRStringStream(script);
var lexer = new NPortugolLexer(input);
var tokens = new CommonTokenStream(lexer);
var parser = new NPortugolParser(tokens);
var ast = parser.script();
return (CommonTree) ast.Tree;
}
public static AstNode Check(string src, Context context)
{
ICharStream input = new ANTLRStringStream(src);
CCompilerLexer lexer = new CCompilerLexer(input);
CommonTokenStream tokens = new CommonTokenStream(lexer);
CCompilerParser parser = new CCompilerParser(tokens);
parser.TreeAdaptor = new AstNodeTreeAdapter();
AstNode program = (AstNode)parser.execute().Tree;
SemanticChecker.Check((AstNode)program, context);
return program;
}
public string Parse(string input)
{
Antlr.Runtime.ANTLRStringStream stream = new Antlr.Runtime.ANTLRStringStream(input);
formulaLexer lexer = new formulaLexer(stream);
CommonTokenStream tokens = new CommonTokenStream(lexer);
formulaParser parser = new formulaParser(tokens);
AstParserRuleReturnScope <CommonTree, CommonToken> result = parser.formula();
String textual = result.Tree.ToStringTree();
return(textual);
}
public RelinqScriptExpression Parse()
{
var input = new ANTLRStringStream(RelinqScriptCode);
var lex = new EcmaScriptV3Lexer(input);
var tokens = new CommonTokenStream(lex);
var parser = new EcmaScriptV3Parser(tokens);
var esV3Ast = (CommonTree)parser.program().Tree;
esV3Ast.RecursivelyReplaceNullListsWithEmptyOnes();
return Parse(esV3Ast);
}
/// <summary>
/// Parses the specified content.
/// </summary>
/// <param name="content">The content.</param>
/// <returns></returns>
public Stylesheet Parse(string content)
{
var stream = new ANTLRStringStream(content);
var lexer = new ExCSSLexer(stream);
var tokens = new CommonTokenStream(lexer);
var parser = new ExCSSParser(tokens);
var tree = parser.parse().Tree;
return BuildStylesheet(tree);
}
/// <summary>
/// Creates and parses mapcss from a string.
/// </summary>
/// <param name="css"></param>
/// <returns></returns>
public static MapCSSFile FromString(string css)
{
var input = new ANTLRStringStream(css);
var lexer = new MapCSSLexer(input);
var tokens = new CommonTokenStream(lexer);
var parser = new MapCSSParser(tokens);
var tree = parser.stylesheet().Tree as Antlr.Runtime.Tree.CommonTree;
// parse into domain.
return MapCSSDomainParser.Parse(tree);
}
private FilterTree stringPatternAST(string source)
{
try
{
ANTLRStringStream input = new ANTLRStringStream(source);
StringPatternLexer lexer = new StringPatternLexer(input);
CommonTokenStream tokens = new CommonTokenStream(lexer);
StringPatternParser parser = new StringPatternParser(tokens);
return parser.parse().Tree;
}
catch { }
return null;
}
public static Sequence ParseString(string text)
{
ANTLRStringStream strStream = new ANTLRStringStream(text);
BonsaiLexer lexer = new BonsaiLexer(strStream);
CommonTokenStream tokStream = new CommonTokenStream(lexer);
Generated.BonsaiParser parser = new Generated.BonsaiParser(tokStream);
var returnValue = parser.program();
CommonTree tree = (CommonTree)returnValue.Tree;
CommonTreeNodeStream treeNodeStream = new CommonTreeNodeStream((CommonTree)returnValue.Tree);
Generated.BonsaiTree treeWalker = new Generated.BonsaiTree(treeNodeStream);
return new Sequence(treeWalker.program().result.Statements);
}
