public void Accept(IVisitor visitor)
{
visitor.VisitEnter(this);
Left.Accept(visitor);
Right.Accept(visitor);
visitor.VisitLeave(this);
}
public void Accept(IVisitor visitor)
{
visitor.VisitEnter(this);
Expression.Accept(visitor);
Index.Accept(visitor);
visitor.VisitLeave(this);
}
public OptionalValue <BitcodeModule> Generate(IAstNode ast)
{
ast.ValidateNotNull(nameof(ast));
ast.Accept(this);
if (AnonymousFunctions.Count > 0)
{
var mainFunction = Module.CreateFunction("main", Context.GetFunctionType(Context.VoidType));
var block = mainFunction.AppendBasicBlock("entry");
var irBuilder = new InstructionBuilder(block);
var printdFunc = Module.CreateFunction("printd", Context.GetFunctionType(Context.DoubleType, Context.DoubleType));
foreach (var anonFunc in AnonymousFunctions)
{
var value = irBuilder.Call(anonFunc);
irBuilder.Call(printdFunc, value);
}
irBuilder.Return( );
// Use always inline and Dead Code Elimination module passes to inline all of the
// anonymous functions. This effectively strips all the calls just generated for main()
// and inlines each of the anonymous functions directly into main, dropping the now
// unused original anonymous functions all while retaining all of the original source
// debug information locations.
using var mpm = new ModulePassManager( );
mpm.AddAlwaysInlinerPass( )
.AddGlobalDCEPass( )
.Run(Module);
Module.DIBuilder.Finish( );
}
return(OptionalValue.Create(Module));
}
protected internal virtual string Output2MySql(IAstNode node, string sql)
{
var sb = new StringBuilder(sql.Length);
node.Accept(new MySqlOutputAstVisitor(sb));
return(sb.ToString());
}
public static string ToString(IAstNode ast, bool showOffsets = false)
{
var dumper = new DumpAstVisitor(showOffsets);
var code = ast.Accept(dumper);
return(code);
}
public IExpression Resolve(IAstNode node)
{
return(node
.Accept(new ConstantParsingVisitor())
.Accept(new BindingVisitor(this))
.Accept(new ConversionVisitor(this)));
}
public List <IOperation> Compile(IAstNode node)
{
var irVisitor = new IRVisitor();
node.Accept(irVisitor);
return(irVisitor.Operations);
}
private IExpression Index(IAstNode operand, AstNodeCollection arguments)
{
var resolvedArguments = ResolveArguments(arguments);
var resolvedOperand = operand.Accept(this);
if (resolvedOperand.Type.IsArray)
{
if (resolvedArguments.Length != resolvedOperand.Type.GetArrayRank())
{
throw new ExpressionsException(
"Invalid array index rank",
ExpressionsExceptionType.TypeMismatch
);
}
foreach (var argument in resolvedArguments)
{
if (!TypeUtil.IsCastAllowed(argument.Type, typeof(int)))
{
throw new ExpressionsException(
"Argument of array index must be convertable to integer",
ExpressionsExceptionType.TypeMismatch
);
}
}
if (resolvedArguments.Length == 1)
{
return(new Expressions.Index(resolvedOperand, resolvedArguments[0], resolvedOperand.Type.GetElementType()));
}
else
{
return(_resolver.ResolveMethod(resolvedOperand, "Get", resolvedArguments));
}
}
var defaultMemberAttributes = resolvedOperand.Type.GetCustomAttributes(typeof(DefaultMemberAttribute), true);
if (defaultMemberAttributes.Length != 1)
{
throw new ExpressionsException(
"Operand does not support indexing",
ExpressionsExceptionType.TypeMismatch
);
}
var result = _resolver.ResolveMethod(resolvedOperand, "get_" + ((DefaultMemberAttribute)defaultMemberAttributes[0]).MemberName, resolvedArguments);
if (result == null)
{
throw new ExpressionsException(
"Unresolved index method",
ExpressionsExceptionType.UnresolvedMethod
);
}
return(result);
}
public IReadOnlyList <Block> Render(IAstNode node)
{
var context = new ParsingContext(1);
node.Accept(this, context);
context.Blocks.Trim();
return(context.Blocks);
}
/// <summary>Gets the complete collection of errors for this node and children</summary>
/// <param name="node">Node to traverse for errors</param>
/// <remarks>Traverses the node hierarchy to find all error node at any depth</remarks>
/// <returns>Collection of errors found</returns>
public static IReadOnlyCollection <ErrorNode> CollectErrors([ValidatedNotNull] this IAstNode node)
{
node.ValidateNotNull(nameof(node));
var collector = new ErrorNodeCollector();
node.Accept <string>(collector);
return(collector.Errors);
}
private IEnumerable <IInstruction> Eval(IAstNode node, IInstruction atTheEnd)
{
var evalVisitor = new CodeGenVisitor(this.readOnlyEnvData);
node.Accept(evalVisitor);
evalVisitor.instructions.Add(atTheEnd);
return(evalVisitor.instructions);
}
internal void Ast_VisitsCorrectMethod(IAstNode node, string expectedCalledMethod)
{
var visitorCallCounting = new AstVisitorCallCounting();
node.Accept(visitorCallCounting);
Assert.Single(visitorCallCounting.CallCount);
Assert.Equal(1, visitorCallCounting.CallCount[expectedCalledMethod]);
}
/// <summary>
/// Calculated two values and returns the result
/// </summary>
/// <param name="target">Visitor to use when calculating the values</param>
/// <param name="value1">Value to the left</param>
/// <param name="value2">Value to the right</param>
/// <param name="calcInt">Method to calculate values if int</param>
/// <param name="calcDec">Method to calculate values if decimal</param>
/// <param name="error">Method to handle errors (usually type errors)</param>
/// <returns>The result of the calculation</returns>
public static object Calculate(this IVisitor target, IAstNode value1, IAstNode value2,
Func <int, int, object> calcInt, Func <decimal, decimal, object> calcDec,
Func <object, object, Exception, object> error)
{
if (target == null)
{
throw new ArgumentNullException(nameof(target));
}
if (value1 == null)
{
throw new ArgumentNullException(nameof(value1));
}
if (value2 == null)
{
throw new ArgumentNullException(nameof(value2));
}
if (calcInt == null)
{
throw new ArgumentNullException(nameof(calcInt));
}
if (calcDec == null)
{
throw new ArgumentNullException(nameof(calcDec));
}
if (error == null)
{
throw new ArgumentNullException(nameof(error));
}
var v1 = value1.Accept(target);
var v2 = value2.Accept(target);
try
{
if (v1 is int i1 && v2 is int i2)
{
return(calcInt(i1, i2));
}
if (!ValueHelper.IsNumeric(v1) || !ValueHelper.IsNumeric(v2))
{
return(error(v1, v2, new InvalidOperationException("Value is not numeric!")));
}
var d1 = Convert.ToDecimal(v1);
var d2 = Convert.ToDecimal(v2);
return(calcDec(d1, d2));
}
catch (Exception innerException)
{
return(error(v1, v2, innerException));
}
}
public static DirectedGraph CreateGraph([ValidatedNotNull] this IAstNode node)
{
node.ValidateNotNull(nameof(node));
var generator = new AstGraphGenerator();
node.Accept(generator);
return(generator.Graph);
}
public static void AstEquals(IAstNode astExpected, IAstNode astActual, bool showOffsets = false)
{
var dumper = new DumpAstVisitor(showOffsets);
var expectedCode = astExpected.Accept(dumper);
var actualCode = astActual.Accept(dumper);
Check.That(actualCode).IsEqualTo(expectedCode);
Console.WriteLine(expectedCode);
}
public static void AstEquals(IAstNode astExpected, IAstNode astActual, bool showOffsets = false)
{
var dumper = new DumpAstVisitor(showOffsets);
var expectedCode = astExpected.Accept(dumper);
var actualCode = astActual.Accept(dumper);
Check.That(actualCode).IsEqualTo(expectedCode);
Console.WriteLine(expectedCode);
}
public Value Generate(IAstNode ast, Action <CodeGeneratorException> codeGenerationErroHandler)
{
try
{
// Prototypes, including extern are ignored as AST generation
// adds them to the RuntimeState so that already has the declarations
return((ast is FunctionDefinition) ? ast.Accept(this) : null);
}
catch (CodeGeneratorException ex) when(codeGenerationErroHandler != null)
{
codeGenerationErroHandler(ex);
return(null);
}
}
private void Accept(SqlAstVisitor visitor, IList<ITransformer> tranformers, IAstNode parent)
{
Debug.WriteLine(parent.Level+"\t"+parent.ParentNode + "\t" + parent +"\t" + parent.OriginalValue);
foreach (ITransformer transformer in tranformers)
{
parent.Transform(transformer);
}
parent.Accept(visitor);
IList<IAstNode> childs = parent.ChildNodes;
if (childs == null)
{
return;
}
foreach(IAstNode child in childs)
{
Accept(visitor, tranformers, child);
}
}
public Value Generate(IAstNode ast, Action <CodeGeneratorException> codeGenerationErroHandler)
{
try
{
ast.Accept(this);
if (AnonymousFunctions.Count > 0)
{
var mainFunction = Module.AddFunction("main", Context.GetFunctionType(Context.VoidType));
var block = mainFunction.AppendBasicBlock("entry");
var irBuilder = new InstructionBuilder(block);
var printdFunc = Module.AddFunction("printd", Context.GetFunctionType(Context.DoubleType, Context.DoubleType));
foreach (var anonFunc in AnonymousFunctions)
{
var value = irBuilder.Call(anonFunc);
irBuilder.Call(printdFunc, value);
}
irBuilder.Return( );
// Use always inline and Dead Code Elimination module passes to inline all of the
// anonymous functions. This effectively strips all the calls just generated for main()
// and inlines each of the anonymous functions directly into main, dropping the now
// unused original anonymous functions all while retaining all of the original source
// debug information locations.
var mpm = new ModulePassManager( )
.AddAlwaysInlinerPass( )
.AddGlobalDCEPass( );
mpm.Run(Module);
Module.DIBuilder.Finish( );
}
}
catch (CodeGeneratorException ex) when(codeGenerationErroHandler != null)
{
codeGenerationErroHandler(ex);
}
return(null);
}
private void Accept(SqlAstVisitor visitor, IList <ITransformer> tranformers, IAstNode parent)
{
Debug.WriteLine(parent.Level + "\t" + parent.ParentNode + "\t" + parent + "\t" + parent.OriginalValue);
foreach (ITransformer transformer in tranformers)
{
parent.Transform(transformer);
}
parent.Accept(visitor);
IList <IAstNode> childs = parent.ChildNodes;
if (childs == null)
{
return;
}
foreach (IAstNode child in childs)
{
Accept(visitor, tranformers, child);
}
}
private bool IsEqual(IAstNode value1, IAstNode value2)
{
var v1 = value1.Accept(this);
var v2 = value2.Accept(this);
if (v1 == null && v2 == null)
{
return(true);
}
if (v1 == null || v2 == null)
{
return(false);
}
if (ValueHelper.IsNumeric(v1) && ValueHelper.IsNumeric(v2))
{
var d1 = Convert.ToDecimal(v1);
var d2 = Convert.ToDecimal(v2);
return(d1 == d2);
}
return(v1.Equals(v2));
}
public static void DumpAst(IAstNode ast)
{
ast.Accept(new DumpAstVisitor());
}
public static string ToString(IAstNode ast, bool showOffsets = false)
{
var dumper = new DumpAstVisitor(showOffsets);
var code = ast.Accept(dumper);
return code;
}
public IExpression Resolve(IAstNode node)
{
return node
.Accept(new ConstantParsingVisitor())
.Accept(new BindingVisitor(this))
.Accept(new ConversionVisitor(this));
}
public IAstNode Eval(IAstNode ast)
{
ast.Accept(this);
return(ast);
}
private void Visit(IAstNode node) => node.Accept(this);
public void Accept(IVisitor visitor)
{
visitor.VisitEnter(this);
Arg.Accept(visitor);
visitor.VisitLeave(this);
}
internal static void Generate(IAstNode p, TextWriter streamWriter, string nspace)
{
p.Accept(new ProtoGenerator(streamWriter,nspace));
}
public void Resolve(IAstNode root, ResolveContext context)
{
root.Accept(this, context);
}
internal static void Generate(IAstNode p, TextWriter streamWriter, string nspace)
{
p.Accept(new ProtoGenerator(streamWriter, nspace));
}
public void Generate(IAstNode rootNode, TextWriter textWriter)
{
MdlGeneratorAstVisitor generatorAstVisitor = new MdlGeneratorAstVisitor(textWriter);
rootNode.Accept(generatorAstVisitor);
}
protected internal virtual string Output2MySql(IAstNode node, string sql)
{
var sb = new StringBuilder(sql.Length);
node.Accept(new MySqlOutputAstVisitor(sb));
return sb.ToString();
}