private void CheckIfAdded(IIndexReferencer var)
{
if (references.ContainsKey(var))
{
throw new Exception(var.Name + " was already added into the variable index assigner.");
}
}
public IndexReference Assign(IIndexReferencer var, bool isGlobal)
{
// variableIsGlobal will equal isGlobal if var.VariableType is dynamic. Otherwise, it will equal is var.VariableType global.
bool variableIsGlobal = var.VariableType == VariableType.Dynamic ? isGlobal : var.VariableType == VariableType.Global;
if (!var.InExtendedCollection)
{
if (var.ID == -1)
{
return(new IndexReference(ArrayBuilder, AssignWorkshopVariable(var.Name, variableIsGlobal)));
}
else
{
WorkshopVariable workshopVariable = new WorkshopVariable(variableIsGlobal, var.ID, MetaElement.WorkshopNameFromCodeName(var.Name, NamesTaken(variableIsGlobal)));
variableList(variableIsGlobal).Add(workshopVariable);
return(new IndexReference(ArrayBuilder, workshopVariable));
}
}
else
{
int index = NextFreeExtended(variableIsGlobal);
IndexReference reference = new IndexReference(ArrayBuilder, variableIsGlobal ? global : player, new V_Number(index));
ExtendedVariableList(variableIsGlobal).Add(new ExtendedVariable(var.Name, reference, index));
return(reference);
}
}
public void LocalVariableAccessed(IIndexReferencer variable)
{
if (!CapturedVariables.Contains(variable) && _lambdaScope.Parent.ScopeContains(variable))
{
CapturedVariables.Add(variable);
}
}
public void Add(IIndexReferencer var, IWorkshopTree reference)
{
if (reference == null)
{
throw new ArgumentNullException(nameof(reference));
}
CheckIfAdded(var);
references.Add(var, new WorkshopElementReference(reference));
}
public void Add(IIndexReferencer var, IndexReference reference)
{
if (reference == null)
{
throw new ArgumentNullException(nameof(reference));
}
CheckIfAdded(var);
references.Add(var, reference);
}
public void LocalVariableAccessed(IIndexReferencer referencer)
{
if (LocalVariableTracker != null)
{
foreach (var tracker in LocalVariableTracker)
{
tracker.LocalVariableAccessed(referencer);
}
}
}
public IGettable this[IIndexReferencer var]
{
get {
if (TryGet(var, out IGettable gettable))
{
return(gettable);
}
throw new Exception(string.Format("The variable {0} is not assigned to an index.", var.Name));
}
private set {}
}
public IGettable Add(IIndexReferencer var, IWorkshopTree reference)
{
if (reference == null)
{
throw new ArgumentNullException(nameof(reference));
}
CheckIfAdded(var);
var weRef = new WorkshopElementReference(reference);
references.Add(var, weRef);
return(weRef);
}
protected ObjectVariable AddObjectVariable(IIndexReferencer variable)
{
// Create an ObjectVariable
ObjectVariable createdObjectVariable = new ObjectVariable(variable);
// Add the ObjectVariable to the ObjectVariables list. This will assign the variable a stack when WorkshopInit executes.
ObjectVariables.Add(createdObjectVariable);
// Copy the variable to the serve object scope. This allows the variable to be accessed when doing className.variableName.
serveObjectScope.CopyVariable(variable);
// Return the created ObjectVariable.
return(createdObjectVariable);
}
public void Add(IIndexReferencer var, IWorkshopTree reference)
{
if (reference == null)
{
throw new ArgumentNullException(nameof(reference));
}
if (references.ContainsKey(var))
{
throw new Exception(var.Name + " was already added into the variable index assigner.");
}
references.Add(var, new WorkshopElementReference(reference));
}
public bool TryGet(IIndexReferencer var, out IGettable gettable)
{
VarIndexAssigner current = this;
while (current != null)
{
if (current.references.ContainsKey(var))
{
gettable = current.references[var];
return(true);
}
current = current.parent;
}
gettable = null;
return(false);
}
public IGettable this[IIndexReferencer var]
{
get {
VarIndexAssigner current = this;
while (current != null)
{
if (current.references.ContainsKey(var))
{
return(current.references[var]);
}
current = current.parent;
}
throw new Exception(string.Format("The variable {0} is not assigned to an index.", var.Name));
}
private set {}
}
public IParameterHandler[] Parameters()
{
var parameters = new IParameterHandler[_root.ParameterCount()];
for (int i = 0; i < parameters.Length; i++)
{
// Get all vars in each function.
var vars = new IIndexReferencer[VirtualOptions.Length];
for (int v = 0; v < vars.Length; v++)
{
vars[v] = VirtualOptions[v].GetParameterVar(i);
}
parameters[i] = new DefinedParameterHandler(vars, IsRecursive());
}
return(parameters);
}
public IGettable Add(VarCollection varCollection, IIndexReferencer var, bool isGlobal, IWorkshopTree referenceValue, bool recursive = false)
{
if (varCollection == null)
{
throw new ArgumentNullException(nameof(varCollection));
}
if (var == null)
{
throw new ArgumentNullException(nameof(var));
}
CheckIfAdded(var);
IGettable assigned;
// A gettable/settable variable
if (var.Settable())
{
assigned = varCollection.Assign(var, isGlobal);
if (recursive || var.Recursive)
{
assigned = new RecursiveIndexReference((IndexReference)assigned);
}
references.Add(var, assigned);
}
// Element reference
else if (var.VariableType == VariableType.ElementReference)
{
if (referenceValue == null)
{
throw new ArgumentNullException(nameof(referenceValue));
}
assigned = new WorkshopElementReference(referenceValue);
references.Add(var, assigned);
}
else
{
throw new NotImplementedException();
}
return(assigned);
}
public void Add(IIndexReferencer referencer, IndexReference value)
{
int[] index = new int[value.Index.Length];
for (int i = 0; i < index.Length; i++)
{
if (value.Index[i] is V_Number number)
{
index[i] = (int)number.Value;
}
else
{
return;
}
}
var newVariable = new LinkableDebugVariable(this, referencer, value.WorkshopVariable, index);
Variables.Add(newVariable);
LinkableVariables.Add(newVariable);
_variablesScope.Variables.Add(newVariable);
}
public static bool EventPlayerDefaultCall(IIndexReferencer referencer, IExpression parent, ParseInfo parseInfo) => referencer.VariableType == VariableType.Player && (parent == null || parent.ReturningScope() != parseInfo.TranslateInfo.PlayerVariableScope);
public ObjectVariable(IIndexReferencer variable)
{
Variable = variable;
}
public CallVariableAction(IIndexReferencer calling, IExpression[] index)
{
Calling = calling;
Index = index;
}
