private static TypeInferenceResults SolveBodyTypes(
SyntaxTree syntaxTree,
IConstantList constants,
IFunctionDictionary functionDictionary,
AprioriTypesMap aprioriTypes)
{
var bodyTypeSolving = RuntimeBuilderHelper.SolveBodyOrThrow(
syntaxTree, functionDictionary, constants, aprioriTypes);
var enterVisitor = new ApplyTiResultEnterVisitor(bodyTypeSolving, TicTypesConverter.Concrete);
var exitVisitor = new ApplyTiResultsExitVisitor();
foreach (var syntaxNode in syntaxTree.Nodes)
{
//function nodes were solved above
if (syntaxNode is UserFunctionDefinitionSyntaxNode)
{
continue;
}
//set types to nodes
syntaxNode.ComeOver(enterVisitor, exitVisitor);
}
return(bodyTypeSolving);
}
public static TypeInferenceResults SolveBodyOrThrow(
SyntaxTree syntaxTree,
IFunctionDictionary functions,
IConstantList constants,
AprioriTypesMap aprioriTypes)
{
try
{
var resultBuilder = new TypeInferenceResultsBuilder();
var typeGraph = new GraphBuilder(syntaxTree.MaxNodeId);
if (!TicSetupVisitor.SetupTicForBody(
tree: syntaxTree,
ticGraph: typeGraph,
functions: functions,
constants: constants,
aprioriTypes: aprioriTypes,
results: resultBuilder))
{
throw ErrorFactory.TypesNotSolved(syntaxTree);
}
var bodyTypeSolving = typeGraph.Solve();
if (bodyTypeSolving == null)
{
throw ErrorFactory.TypesNotSolved(syntaxTree);
}
resultBuilder.SetResults(bodyTypeSolving);
return(resultBuilder.Build());
}
catch (TicException e) { throw ErrorFactory.TranslateTicError(e, syntaxTree); }
}
private static FunRuntime Build(
SyntaxTree syntaxTree,
IFunctionDictionary functionsDictionary,
IConstantList constants,
AprioriTypesMap aprioriTypesMap)
{
#region build user functions
//get topology sort of the functions call
//result is the order of functions that need to be compiled
//functions that not references other functions have to be compiled firstly
//Then those functions will be compiled
//that refer to already compiled functions
var functionSolveOrder = syntaxTree.FindFunctionSolvingOrderOrThrow();
List <IFunctionSignature> userFunctions;
IFunctionDictionary functionDictionary;
if (functionSolveOrder.Length == 0)
{
functionDictionary = functionsDictionary;
userFunctions = EmptyUserFunctionsList;
}
else
{
userFunctions = new List <IFunctionSignature>();
var scopeFunctionDictionary = new ScopeFunctionDictionary(functionsDictionary);
functionDictionary = scopeFunctionDictionary;
//build user functions
foreach (var functionSyntaxNode in functionSolveOrder)
{
//todo list capacity
var userFun = BuildFunctionAndPutItToDictionary(
functionSyntaxNode: functionSyntaxNode,
constants: constants,
functionsDictionary: scopeFunctionDictionary);
userFunctions.Add(userFun);
}
}
#endregion
var bodyTypeSolving = SolveBodyTypes(syntaxTree, constants, functionDictionary, aprioriTypesMap);
#region build body
var variables = new VariableDictionary();
var equations = new List <Equation>();
foreach (var treeNode in syntaxTree.Nodes)
{
if (treeNode is EquationSyntaxNode node)
{
var equation = BuildEquationAndPutItToVariables(node, functionDictionary, variables, bodyTypeSolving);
equations.Add(equation);
if (Helper.DoesItLooksLikeSuperAnonymousVariable(equation.Id))
{
throw FunParseException.ErrorStubToDo("variable cannot starts with 'it'");
}
if (TraceLog.IsEnabled)
{
TraceLog.WriteLine($"\r\nEQUATION: {equation.Id}:{equation.Expression.Type} = ... \r\n");
}
}
else if (treeNode is VarDefinitionSyntaxNode varDef)
{
if (Helper.DoesItLooksLikeSuperAnonymousVariable(varDef.Id))
{
throw FunParseException.ErrorStubToDo("variable cannot starts with 'it'");
}
var variableSource = VariableSource.CreateWithStrictTypeLabel(
varDef.Id,
varDef.FunnyType,
varDef.Interval,
isOutput: false,
varDef.Attributes);
if (!variables.TryAdd(variableSource))
{
var allUsages = variables.GetUsages(variableSource.Name);
throw ErrorFactory.VariableIsDeclaredAfterUsing(allUsages);
}
if (TraceLog.IsEnabled)
{
TraceLog.WriteLine($"\r\nVARIABLE: {variableSource.Name}:{variableSource.Type} = ... \r\n");
}
}
else if (treeNode is UserFunctionDefinitionSyntaxNode)
{
continue;//user function was built above
}
else
{
throw new InvalidOperationException($"Type {treeNode} is not supported as tree root");
}
}
#endregion
foreach (var userFunction in userFunctions)
{
if (userFunction is GenericUserFunction generic && generic.BuiltCount == 0)
{
// Generic function is declared but concrete was not built.
// We have to build it at least once to search all possible errors
GenericUserFunction.CreateSomeConcrete(generic);
}
}
return(new FunRuntime(equations, variables, userFunctions));
}
public static FunRuntime Build(string script, IFunctionDictionary functionDictionary, IConstantList constants = null, AprioriTypesMap aprioriTypesMap = null)
{
aprioriTypesMap ??= AprioriTypesMap.Empty;
var flow = Tokenizer.ToFlow(script);
var syntaxTree = Parser.Parse(flow);
//Set node numbers
var setNodeNumberVisitor = new SetNodeNumberVisitor();
syntaxTree.ComeOver(setNodeNumberVisitor);
syntaxTree.MaxNodeId = setNodeNumberVisitor.LastUsedNumber;
return(Build(syntaxTree, functionDictionary, constants ?? EmptyConstantList.Instance, aprioriTypesMap));
}