public RecursiveIndexReference(IndexReference reference)
{
this.WorkshopVariable = reference.WorkshopVariable;
this.Index = reference.Index;
this.ArrayBuilder = reference.ArrayBuilder;
}
public SubroutineInfo(Subroutine routine, FunctionBuildController functionBuilder, IndexReference[] parameterStores, IndexReference objectStore)
{
Subroutine = routine;
FunctionBuilder = functionBuilder;
ParameterStores = parameterStores;
ObjectStore = objectStore;
}
public WorkshopArrayBuilder(WorkshopVariable constructor, IndexReference store)
{
Constructor = constructor;
Store = store;
}
public SubroutineInfo(Subroutine routine, ReturnHandler returnHandler, TranslateRule rule, IndexReference[] parameterStores, IndexReference objectStore)
{
Subroutine = routine;
ReturnHandler = returnHandler;
Rule = rule;
ParameterStores = parameterStores;
ObjectStore = objectStore;
}
public void Init(DeltinScript deltinScript)
{
ClassIndexes = deltinScript.VarCollection.Assign(ClassIndexesTag, true, false);
deltinScript.InitialGlobal.ActionSet.AddAction(ClassIndexes.SetVariable(0, null, Constants.MAX_ARRAY_LENGTH));
}
public ExpressionTreeParseResult ParseTree(ActionSet actionSet, bool expectingValue, bool asElement)
{
IGettable resultingVariable = null;
IWorkshopTree target = null;
IWorkshopTree result = null;
VarIndexAssigner currentAssigner = actionSet.IndexAssigner;
IndexReference currentObject = null;
Element[] resultIndex = new Element[0];
for (int i = 0; i < Tree.Length; i++)
{
bool isLast = i == Tree.Length - 1;
IWorkshopTree current = null;
if (Tree[i] is CallVariableAction)
{
var callVariableAction = (CallVariableAction)Tree[i];
var reference = currentAssigner[callVariableAction.Calling];
current = reference.GetVariable((Element)target);
resultIndex = new Element[callVariableAction.Index.Length];
for (int ai = 0; ai < callVariableAction.Index.Length; ai++)
{
var workshopIndex = callVariableAction.Index[ai].Parse(actionSet);
resultIndex[ai] = (Element)workshopIndex;
current = Element.Part <V_ValueInArray>(current, workshopIndex);
}
// If this is the last node in the tree, set the resulting variable.
if (isLast)
{
resultingVariable = reference;
}
}
else
{
var newCurrent = Tree[i].Parse(actionSet.New(currentAssigner).New(currentObject), asElement);
if (newCurrent != null)
{
current = newCurrent;
resultIndex = new Element[0];
}
}
if (Tree[i].Type() == null)
{
// If this isn't the last in the tree, set it as the target.
if (!isLast)
{
target = current;
}
currentObject = null;
}
else
{
currentObject = Tree[i].Type().GetObjectSource(actionSet.Translate.DeltinScript, current);
if (Tree[i].Type() is DefinedType)
{
currentAssigner = actionSet.IndexAssigner.CreateContained();
var definedType = ((DefinedType)Tree[i].Type());
// Assign the object variables indexes.
definedType.AddObjectVariablesToAssigner(currentObject, currentAssigner);
}
}
result = current;
}
if (result == null && expectingValue)
{
throw new Exception("Expression tree result is null");
}
return(new ExpressionTreeParseResult(result, resultIndex, target, resultingVariable));
}
// Sets up single-instance methods for methods with the 'rule' attribute.
public void SetupSubroutine()
{
if (subroutineInfo != null || !IsSubroutine)
{
return;
}
// Setup the subroutine element.
Subroutine subroutine = parseInfo.TranslateInfo.SubroutineCollection.NewSubroutine(Name);
// Create the rule.
TranslateRule subroutineRule = new TranslateRule(parseInfo.TranslateInfo, subroutine, SubroutineName, subroutineDefaultGlobal);
// Setup the return handler.
ReturnHandler returnHandler = new ReturnHandler(subroutineRule.ActionSet, Name, multiplePaths || Attributes.Virtual);
ActionSet actionSet = subroutineRule.ActionSet.New(returnHandler).New(subroutineRule.ActionSet.IndexAssigner.CreateContained());
// Get the variables that will be used to store the parameters.
IndexReference[] parameterStores = new IndexReference[ParameterVars.Length];
for (int i = 0; i < ParameterVars.Length; i++)
{
// Create the workshop variable the parameter will be stored as.
IndexReference indexResult = actionSet.IndexAssigner.AddIndexReference(actionSet.VarCollection, ParameterVars[i], subroutineDefaultGlobal, Attributes.Recursive);
parameterStores[i] = indexResult;
// Assign virtual variables to the index reference.
foreach (Var virtualParameterOption in VirtualVarGroup(i))
{
actionSet.IndexAssigner.Add(virtualParameterOption, indexResult);
}
}
// If the subroutine is an object function inside a class, create a variable to store the class object.
IndexReference objectStore = null;
if (Attributes.ContainingType != null && !Static)
{
objectStore = actionSet.VarCollection.Assign("_" + Name + "_subroutineStore", true, !Attributes.Recursive);
// Set the objectStore as an empty array if the subroutine is recursive.
if (Attributes.Recursive)
{
actionSet.InitialSet().AddAction(objectStore.SetVariable(new V_EmptyArray()));
Attributes.ContainingType.AddObjectVariablesToAssigner(Element.Part <V_LastOf>(objectStore.GetVariable()), actionSet.IndexAssigner);
actionSet = actionSet.New(Element.Part <V_LastOf>(objectStore.GetVariable())).PackThis();
}
else
{
Attributes.ContainingType.AddObjectVariablesToAssigner(objectStore.GetVariable(), actionSet.IndexAssigner);
actionSet = actionSet.New(objectStore.GetVariable()).PackThis();
}
}
// Set the subroutine info.
subroutineInfo = new SubroutineInfo(subroutine, returnHandler, parameterStores, objectStore);
MethodBuilder builder = new MethodBuilder(this, actionSet, returnHandler);
builder.BuilderSet = builder.BuilderSet.New(Attributes.Recursive);
builder.ParseInner();
// Apply returns.
returnHandler.ApplyReturnSkips();
// Pop object array and parameters if recursive.
if (Attributes.Recursive)
{
if (objectStore != null)
{
actionSet.AddAction(objectStore.ModifyVariable(Operation.RemoveFromArrayByIndex, Element.Part <V_CountOf>(objectStore.GetVariable()) - 1));
}
RecursiveStack.PopParameterStacks(actionSet, ParameterVars);
}
// Add the subroutine.
Rule translatedRule = subroutineRule.GetRule();
parseInfo.TranslateInfo.WorkshopRules.Add(translatedRule);
var codeLens = new ElementCountCodeLens(DefinedAt.range, parseInfo.TranslateInfo.OptimizeOutput);
parseInfo.Script.AddCodeLensRange(codeLens);
codeLens.RuleParsed(translatedRule);
}