public static bool TestAst(string src)
{
var grammar = new PyUsacGrammar();
var langData = new LanguageData(grammar);
var parser = new Irony.Parsing.Parser(langData);//Para evitar conflicto con el namespace Parser
var parseTree = parser.Parse(src);
var root = parseTree.Root;
if (parseTree.HasErrors())
{
ErrorHelper.ErrorFactory.CreateParsingErrors(parseTree, "_null");
return(false);
}
else
{
var dotCode = GetDot(root);
var astBuilder = new AstBuilder(new AstContext(langData));
astBuilder.BuildAst(parseTree);
var astRoot = (AstNode)root.AstNode;
Debug.WriteLine("");
Debug.WriteLine("--------------------------------------------------");
Debug.WriteLine("");
GetDot(astRoot);
return(true);
}
}
public override void BuildAst(LanguageData language, ParseTree parseTree)
{
var opHandler = new OperatorHandler(language.Grammar.CaseSensitive);
Util.Ensure(!parseTree.HasErrors, "ParseTree has errors, cannot build AST.");
var astContext = new InterpreterAstContext(language, opHandler);
var astBuilder = new AstBuilder(astContext);
astBuilder.BuildAst(parseTree);
}
public override void BuildAst(LanguageData language, ParseTree parseTree)
{
var opHandler = CreateOpeartorHandler(language);
Util.Check(!parseTree.HasErrors(), "ParseTree has errors, cannot build AST.");
var astContext = new InterpreterAstContext(language, opHandler);
var astBuilder = new AstBuilder(astContext);
astBuilder.BuildAst(parseTree);
}
public virtual void BuildAst(LanguageData language, ParseTree parseTree)
{
if (!LanguageFlags.IsSet(LanguageFlags.CreateAst))
{
return;
}
var astContext = new AstContext(language);
var astBuilder = new AstBuilder(astContext);
astBuilder.BuildAst(parseTree);
}
public override void BuildAst(LanguageData language, ParseTree parseTree)
{
if (parseTree.HasErrors())
{
throw new Exception("parse tree has errors. cannot build ast");
}
var context = new AstContext(parseTree.FileName, language);
var builder = new AstBuilder(context);
builder.BuildAst(parseTree);
}
/// <summary>Builds the AST for the specified language data and parse tree.</summary>
/// <param name="language">The language data.</param>
/// <param name="parseTree">The parse tree to build the AST against.</param>
public override void BuildAst(LanguageData language, ParseTree parseTree)
{
if (!LanguageFlags.IsSet(LanguageFlags.CreateAst))
{
return;
}
var astContext = new InterpreterAstContext(language, _OperatorHandler);
astContext.DefaultNodeType = typeof(NotSupportedNode);
var astBuilder = new AstBuilder(astContext);
astBuilder.BuildAst(parseTree);
}
public override void BuildAst(LanguageData language, ParseTree parseTree)
{
if (LanguageFlags.IsSet(LanguageFlags.CreateAst))
{
var astContext = new AstContext(language);
astContext.DefaultNodeType = typeof(DefaultAstNode);
astContext.DefaultLiteralNodeType = typeof(DefaultAstNode);
astContext.DefaultIdentifierNodeType = typeof(DefaultAstNode);
var astBuilder = new AstBuilder(astContext);
astBuilder.BuildAst(parseTree);
}
}
private ISqlNode ParseNode(string sqlSource, ICollection <SqlParseError> errors, out long parseTime)
{
var tree = parser.Parse(sqlSource);
parseTime = tree.ParseTimeMilliseconds;
if (tree.Status == ParseTreeStatus.Error)
{
BuildErrors(tree, errors, tree.ParserMessages);
return(null);
}
var astContext = new AstContext(languageData)
{
DefaultNodeType = typeof(SqlNode),
DefaultIdentifierNodeType = typeof(IdentifierNode)
};
var astCompiler = new AstBuilder(astContext);
astCompiler.BuildAst(tree);
if (tree.HasErrors())
{
BuildErrors(tree, errors, tree.ParserMessages);
}
var node = (ISqlNode)tree.Root.AstNode;
if (node.NodeName == "root")
{
node = node.ChildNodes.FirstOrDefault();
}
return(node);
}
