override public IWorkshopTree New(ActionSet actionSet, Constructor constructor, IWorkshopTree[] constructorValues, object[] additionalParameterData)
{
if (TypeKind == TypeKind.Class)
{
return(NewClass(actionSet.New(actionSet.IndexAssigner.CreateContained()), constructor, constructorValues));
}
else if (TypeKind == TypeKind.Struct)
{
return(NewStruct(actionSet.New(actionSet.IndexAssigner.CreateContained()), constructor, constructorValues));
}
else
{
throw new NotImplementedException();
}
}
// Parses the method.
public override IWorkshopTree Parse(ActionSet actionSet, MethodCall methodCall)
{
actionSet = actionSet.New(actionSet.IndexAssigner.CreateContained());
var controller = new FunctionBuildController(actionSet, methodCall, new DefaultGroupDeterminer(GetOverrideFunctionHandlers()));
return(controller.Call());
}
override public IWorkshopTree Parse(ActionSet actionSet, MethodCall methodCall)
{
// Assign the parameters.
actionSet = actionSet.New(actionSet.IndexAssigner.CreateContained());
return(AbstractMacroBuilder.Call(actionSet, this, methodCall));
}
override public IWorkshopTree Parse(ActionSet actionSet, IWorkshopTree[] parameterValues, object[] additionalParameterData)
{
actionSet = actionSet
.New(actionSet.IndexAssigner.CreateContained());
if (IsRecursive)
{
return(ParseRecursive(actionSet, parameterValues));
}
ReturnHandler returnHandler = new ReturnHandler(actionSet, Name, multiplePaths);
actionSet = actionSet.New(returnHandler);
AssignParameters(actionSet, ParameterVars, parameterValues);
block.Translate(actionSet);
returnHandler.ApplyReturnSkips();
return(returnHandler.GetReturnedValue());
}
override public IWorkshopTree Parse(ActionSet actionSet, IWorkshopTree[] parameterValues, object[] additionalParameterData)
{
// Assign the parameters.
actionSet = actionSet.New(actionSet.IndexAssigner.CreateContained());
for (int i = 0; i < ParameterVars.Length; i++)
{
actionSet.IndexAssigner.Add(ParameterVars[i], parameterValues[i]);
}
// Parse the expression.
return(Expression.Parse(actionSet));
}
override public IWorkshopTree Parse(ActionSet actionSet, MethodCall methodCall)
{
// Assign the parameters.
actionSet = actionSet.New(actionSet.IndexAssigner.CreateContained());
for (int i = 0; i < ParameterVars.Length; i++)
{
actionSet.IndexAssigner.Add(ParameterVars[i], methodCall.ParameterValues[i]);
}
// Parse the expression.
return(Expression.Parse(actionSet));
}
public override IWorkshopTree New(ActionSet actionSet, Constructor constructor, IWorkshopTree[] constructorValues, object[] additionalParameterData)
{
actionSet = actionSet.New(actionSet.IndexAssigner.CreateContained());
ClassData classData = actionSet.Translate.DeltinScript.GetComponent <ClassData>();
// Classes are stored in the class array (`classData.ClassArray`),
// this stores the index where the new class is created at.
var classReference = Create(actionSet, classData);
New(actionSet, new NewClassInfo(classReference, constructor, constructorValues, additionalParameterData));
// Return the reference.
return(classReference.GetVariable());
}
private IWorkshopTree ParseNormal(ActionSet actionSet, MethodCall methodCall)
{
// Create the return handler.
ReturnHandler returnHandler = methodCall.ReturnHandler ?? new ReturnHandler(actionSet, Name, multiplePaths);
actionSet = actionSet.New(returnHandler);
// Assign the parameters and translate the block.
AssignParameters(actionSet, ParameterVars, methodCall.ParameterValues);
block.Translate(actionSet);
if (methodCall.ResolveReturnHandler)
{
returnHandler.ApplyReturnSkips();
}
return(returnHandler.GetReturnedValue());
}
public TranslateRule(DeltinScript deltinScript, RuleAction ruleAction)
{
DeltinScript = deltinScript;
IsGlobal = ruleAction.EventType == RuleEvent.OngoingGlobal;
Name = ruleAction.Name;
EventType = ruleAction.EventType;
Team = ruleAction.Team;
Player = ruleAction.Player;
Disabled = ruleAction.Disabled;
Priority = ruleAction.Priority;
ActionSet = new ActionSet(this, null, Actions);
GetConditions(ruleAction);
RuleReturnHandler returnHandler = new RuleReturnHandler(ActionSet);
ruleAction.Block.Translate(ActionSet.New(returnHandler));
}
public override IWorkshopTree New(ActionSet actionSet, Constructor constructor, IWorkshopTree[] constructorValues, object[] additionalParameterData)
{
actionSet = actionSet.New(actionSet.IndexAssigner.CreateContained());
ClassData classData = actionSet.Translate.DeltinScript.GetComponent <ClassData>();
// Classes are stored in the class array (`classData.ClassArray`),
// this stores the index where the new class is created at.
var classReference = actionSet.VarCollection.Assign("_new_" + Name + "_class_index", actionSet.IsGlobal, true);
classData.GetClassIndex(Identifier, classReference, actionSet);
// Get object variables.
BaseSetup(actionSet, (Element)classReference.GetVariable());
New(actionSet, new NewClassInfo(classReference, constructor, constructorValues, additionalParameterData));
// Return the reference.
return(classReference.GetVariable());
}
public TranslateRule(DeltinScript deltinScript, RuleAction ruleAction)
{
DeltinScript = deltinScript;
IsGlobal = ruleAction.EventType == RuleEvent.OngoingGlobal;
Name = ruleAction.Name;
EventType = ruleAction.EventType;
Team = ruleAction.Team;
Player = ruleAction.Player;
Disabled = ruleAction.Disabled;
ContinueSkip = new ContinueSkip(this);
ActionSet = new ActionSet(this, null, Actions);
GetConditions(ruleAction);
ReturnHandler returnHandler = new ReturnHandler(ActionSet, Name, false);
ruleAction.Block.Translate(ActionSet.New(returnHandler));
returnHandler.ApplyReturnSkips();
}
private IWorkshopTree ParseVirtual(ActionSet actionSet, MethodCall methodCall)
{
// Create the switch that chooses the overload.
SwitchBuilder typeSwitch = new SwitchBuilder(actionSet);
// Loop through all potential methods.
IMethod[] options = Attributes.AllOverrideOptions();
// Get the call settings.
MethodCall callSettings = new MethodCall(methodCall.ParameterValues, methodCall.AdditionalParameterData)
{
ResolveOverrides = false,
ResolveReturnHandler = false,
ReturnHandler = new ReturnHandler(actionSet, Name, true)
};
// Parse the current overload.
typeSwitch.NextCase(new V_Number(((ClassType)Attributes.ContainingType).Identifier));
Parse(actionSet, callSettings);
foreach (IMethod option in options)
{
// The action set for the overload.
ActionSet optionSet = actionSet.New(actionSet.IndexAssigner.CreateContained());
// Add the object variables of the selected method.
option.Attributes.ContainingType.AddObjectVariablesToAssigner(optionSet.CurrentObject, optionSet.IndexAssigner);
// Go to next case then parse the block.
typeSwitch.NextCase(new V_Number(((ClassType)option.Attributes.ContainingType).Identifier));
option.Parse(optionSet, callSettings);
}
ClassData classData = actionSet.Translate.DeltinScript.SetupClasses();
// Finish the switch.
typeSwitch.Finish(Element.Part <V_ValueInArray>(classData.ClassIndexes.GetVariable(), actionSet.CurrentObject));
callSettings.ReturnHandler.ApplyReturnSkips();
return(callSettings.ReturnHandler.GetReturnedValue());
}
// Parses the method.
override public IWorkshopTree Parse(ActionSet actionSet, MethodCall methodCall)
{
actionSet = actionSet.New(actionSet.IndexAssigner.CreateContained());
if (Attributes.WasOverriden && methodCall.ResolveOverrides)
{
return(ParseVirtual(actionSet, methodCall));
}
if (Attributes.Recursive && !IsSubroutine)
{
return(RecursiveStack.Call(this, methodCall, actionSet));
}
if (IsSubroutine)
{
return(ParseSubroutine(actionSet, methodCall));
}
return(ParseNormal(actionSet, methodCall));
}
/// <summary>Calls the method.</summary>
private IWorkshopTree ParseCall(ActionSet actionSet, MethodCall methodCall)
{
// Create the array used for continuing after a recursive call.
continueArray = actionSet.VarCollection.Assign("_" + method.Name + "_recursiveContinue", actionSet.IsGlobal, false);
nextContinue = actionSet.VarCollection.Assign("_" + method.Name + "_nextContinue", actionSet.IsGlobal, true);
actionSet.InitialSet().AddAction(continueArray.SetVariable(new V_EmptyArray()));
ReturnHandler returnHandler = methodCall.ReturnHandler ?? new ReturnHandler(actionSet, method.Name, method.multiplePaths);
this.returnHandler = returnHandler;
DefinedMethod.AssignParameters(actionSet, method.ParameterVars, methodCall.ParameterValues, true);
actionSet.AddAction(Element.Part <A_While>(new V_True()));
continueAt = new SkipStartMarker(actionSet);
continueAt.SetSkipCount((Element)nextContinue.GetVariable());
actionSet.AddAction(continueAt);
method.block.Translate(actionSet.New(returnHandler));
PopParameterStacks(actionSet);
// Pop the continueArray.
actionSet.AddAction(Element.Part <A_SkipIf>(new V_Compare(
Element.Part <V_CountOf>(continueArray.GetVariable()),
Operators.Equal,
new V_Number(0)
), new V_Number(3)));
actionSet.AddAction(nextContinue.SetVariable(Element.Part <V_LastOf>(continueArray.GetVariable())));
actionSet.AddAction(continueArray.ModifyVariable(Operation.RemoveFromArrayByIndex, Element.Part <V_CountOf>(continueArray.GetVariable()) - 1));
actionSet.AddAction(endOfMethod);
actionSet.AddAction(new A_End());
actionSet.AddAction(nextContinue.SetVariable(0));
return(returnHandler.GetReturnedValue());
}
public IWorkshopTree ParseVirtual()
{
IMacroOption[] options = AllOptions();
//If there are no overrides, don't bother creating the lookup table
if (options.Length == 1)
{
return(options[0].Parse(ActionSet));
}
List <IWorkshopTree> expElements = new List <IWorkshopTree>();
List <int> resolves = new List <int>();
List <int> identifiers = new List <int>();
bool needsResolve = false;
foreach (var option in options)
{
var optionSet = ActionSet.New(ActionSet.IndexAssigner.CreateContained());
option.Type().AddObjectVariablesToAssigner(optionSet.CurrentObject, optionSet.IndexAssigner);
int currentIndex = expElements.Count;
expElements.Add(option.Parse(optionSet));
resolves.Add(currentIndex);
identifiers.Add(((ClassType)option.Type()).Identifier);
// Iterate through every type.
foreach (CodeType type in ActionSet.Translate.DeltinScript.Types.AllTypes)
{
// If 'type' does not equal the current virtual option's containing class...
if (option.Type() != type
// ...and 'type' implements the containing class...
&& type.Implements(option.Type())
// ...and 'type' does not have their own function implementation...
&& Deltin.Deltinteger.Parse.FunctionBuilder.VirtualLookupTable.AutoImplemented(option.Type(), options.Select(option => option.Type()).ToArray(), type))
// ...then add an additional case for 'type's class identifier.
{
needsResolve = true;
resolves.Add(currentIndex);
identifiers.Add(((ClassType)type).Identifier);
}
}
}
Element expArray = Element.CreateArray(expElements.ToArray());
Element resolveArray = Element.CreateArray(resolves.Select(i => new V_Number(i)).ToArray());
Element identArray = Element.CreateArray(identifiers.Select(i => new V_Number(i)).ToArray());
ClassData classData = ActionSet.Translate.DeltinScript.GetComponent <ClassData>();
Element classIdentifier = Element.Part <V_ValueInArray>(classData.ClassIndexes.GetVariable(), ActionSet.CurrentObject);
/*
* class A // Class identifier: 5
* {
* virtual define Macro: 2;
* }
* class B : A // Class identifier: 6
* {
* override define Macro: 3;
* }
* In this case, the macro can be resolved like so:
* [2, 3][Index Of([5, 6], class id)]
* This output will not work in this case:
* class A // Class identifier: 5
* {
* virtual define Macro: 2;
* }
* class B : A // Class identifier: 6
* {
* override define Macro: 3;
* }
* class C : B // Class identifier: 7
* {
* }
* C does not implement 'Macro'. This will cause the output to be the same as above.
* This is not correct. Since C implements B, it should return 3. Since Index Of returns -1, the macro will return 0 if 'new C().Macro' is called.
* If this case happens, 'needsResolve' will be true. When it is true, do this instead:
* [2, 3][0, 1, 1][IndexOf([5, 6, 7], class id)]
* '[0, 1, 1]' will map the index to the correct macro value.
*/
if (needsResolve)
{
return(expArray[resolveArray[Element.Part <V_IndexOfArrayValue>(identArray, classIdentifier)]]);
}
else
{
return(expArray[Element.Part <V_IndexOfArrayValue>(identArray, classIdentifier)]);
}
}
// IExpression
public IWorkshopTree Parse(ActionSet actionSet, bool asElement = true)
{
return(CallingMethod.Parse(actionSet.New(NameRange), GetParameterValuesAsWorkshop(actionSet), OverloadChooser.AdditionalParameterData));
}
private IWorkshopTree ParseRecursive(ActionSet actionSet, IWorkshopTree[] parameterValues)
{
// Check the method stack to see if this method was already called.
RecursiveMethodStack lastCall = actionSet.Translate.MethodStack.FirstOrDefault(ms => ms.Function == this) as RecursiveMethodStack;
// If not, set up the stack and call the method.
if (lastCall == null)
{
// Assign the parameters.
AssignParameters(actionSet, ParameterVars, parameterValues, true);
// Get the return handler if a value is returned.
ReturnHandler returnHandler = new ReturnHandler(actionSet, Name, true);
// Set up the condinue skip array.
IndexReference continueSkipArray = actionSet.VarCollection.Assign("recursiveContinueArray", actionSet.IsGlobal, false);
SkipEndMarker methodStart = new SkipEndMarker();
actionSet.AddAction(methodStart);
// Add the method to the stack.
var stack = new RecursiveMethodStack(this, returnHandler, continueSkipArray, methodStart);
actionSet.Translate.MethodStack.Add(stack);
// Parse the method block.
block.Translate(actionSet.New(returnHandler));
// Apply the returns.
if (returnHandler != null)
{
returnHandler.ApplyReturnSkips();
}
// Pop the recursive parameters
// TODO: Make this work with all sub scoped variables somehow
for (int i = 0; i < ParameterVars.Length; i++)
{
var pop = (actionSet.IndexAssigner[ParameterVars[i]] as RecursiveIndexReference)?.Pop();
if (pop != null)
{
actionSet.AddAction(pop);
}
}
// Setup the continue skip
actionSet.ContinueSkip.Setup(actionSet);
actionSet.ContinueSkip.SetSkipCount(actionSet, Element.Part <V_LastOf>(continueSkipArray.GetVariable()));
// Remove the last recursive continue skip.
actionSet.AddAction(continueSkipArray.SetVariable(
// Pop
Element.Part <V_ArraySlice>(
continueSkipArray.GetVariable(),
new V_Number(0),
Element.Part <V_CountOf>(continueSkipArray.GetVariable()) - 1
)
));
// Loop if there are any values in the continue skip array.
actionSet.AddAction(Element.Part <A_LoopIf>(
Element.Part <V_CountOf>(continueSkipArray.GetVariable()) > 0
));
// Reset the continue skip.
actionSet.ContinueSkip.ResetSkipCount(actionSet);
actionSet.AddAction(continueSkipArray.SetVariable(0));
// Remove the method from the stack.
actionSet.Translate.MethodStack.Remove(stack);
return(returnHandler.GetReturnedValue());
}
// If it is, push the parameters to the stack.
else
{
for (int i = 0; i < ParameterVars.Length; i++)
{
var varReference = actionSet.IndexAssigner[ParameterVars[i]];
if (varReference is RecursiveIndexReference)
{
actionSet.AddAction(((RecursiveIndexReference)varReference).Push(
(Element)parameterValues[i]
));
}
}
// Add to the continue skip array.
V_Number skipLength = new V_Number();
actionSet.AddAction(lastCall.ContinueSkipArray.SetVariable(
Element.Part <V_Append>(lastCall.ContinueSkipArray.GetVariable(), skipLength)
));
actionSet.ContinueSkip.Setup(actionSet);
actionSet.ContinueSkip.SetSkipCount(actionSet, lastCall.MethodStart);
actionSet.AddAction(new A_Loop());
SkipEndMarker continueAt = new SkipEndMarker();
actionSet.AddAction(continueAt);
skipLength.Value = actionSet.ContinueSkip.GetSkipCount(continueAt).Value;
return(lastCall.ReturnHandler.GetReturnedValue());
}
}
// IStatement
public void Translate(ActionSet actionSet)
{
CallingMethod.Parse(actionSet.New(NameRange), GetParameterValuesAsWorkshop(actionSet), OverloadChooser.AdditionalParameterData);
}
public IWorkshopTree Parse(ActionSet actionSet)
{
actionSet = actionSet.New(actionSet.IndexAssigner.CreateContained());
return(AbstractMacroBuilder.Call(actionSet, this));
}
// IExpression
public IWorkshopTree Parse(ActionSet actionSet)
{
return(CallingMethod.Parse(actionSet.New(NameRange), GetMethodCall(actionSet)));
}
public ExpressionTreeParseResult ParseTree(ActionSet actionSet, bool expectingValue)
{
IGettable resultingVariable = null; // The resulting variable.
IWorkshopTree target = null; // The resulting player.
IWorkshopTree result = null; // The resulting value.
VarIndexAssigner currentAssigner = actionSet.IndexAssigner;
IWorkshopTree 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));
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
{
var type = Tree[i].Type();
currentObject = current;
currentAssigner = actionSet.IndexAssigner.CreateContained();
type.AddObjectVariablesToAssigner(currentObject, currentAssigner);
}
result = current;
}
if (result == null && expectingValue)
{
throw new Exception("Expression tree result is null");
}
return(new ExpressionTreeParseResult(result, resultIndex, target, resultingVariable));
}
public IWorkshopTree Parse(ActionSet actionSet, bool asElement = true)
{
return(Element.Part <V_ValueInArray>(Expression.Parse(actionSet.New(expressionRange)), Index.Parse(actionSet.New(indexRange))));
}
public override void Parse(ActionSet actionSet, IWorkshopTree[] parameterValues, object[] additionalParameterData)
{
actionSet = actionSet.New(actionSet.IndexAssigner.CreateContained()).PackThis();
DefinedMethod.AssignParameters(actionSet, ParameterVars, parameterValues);
Block.Translate(actionSet);
}
public override void Parse(ActionSet actionSet, IWorkshopTree[] parameterValues)
{
actionSet = actionSet.New(actionSet.IndexAssigner.CreateContained());
DefinedMethod.AssignParameters(actionSet, ParameterVars, parameterValues);
Block.Translate(actionSet);
}
// IStatement
public void Translate(ActionSet actionSet)
{
CallingMethod.Parse(actionSet.New(NameRange), GetMethodCall(actionSet));
}
// Parses the method.
override public IWorkshopTree Parse(ActionSet actionSet, MethodCall methodCall)
{
actionSet = actionSet.New(actionSet.IndexAssigner.CreateContained());
return(MethodBuilder.Call(this, methodCall, actionSet));
}
// 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, subroutineRule, 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);
}
protected override void New(ActionSet actionSet, NewClassInfo newClassInfo)
{
// Run the constructor.
AddObjectVariablesToAssigner((Element)newClassInfo.ObjectReference.GetVariable(), actionSet.IndexAssigner);
newClassInfo.Constructor.Parse(actionSet.New((Element)newClassInfo.ObjectReference.GetVariable()), newClassInfo.ConstructorValues, null);
}
