public override object CreateInstance(List<Elements.Value> parameters)
{
List<AbstractVisualClass> LayerGenerators = new List<AbstractVisualClass>();
foreach (Elements.Value parameter in parameters) {
LayerGenerators.Add((AbstractVisualClass)parameter.ObjectValue);
}
return new LayerClass(LayerGenerators);
}
public override object CreateNewInstance(List<Elements.Value> parameters)
{
ListFactory<Visual> layerObjects = new List<Visual>();
foreach (Elements.Value parameter in parameters) {
layerObjects.Add((Visual)parameter.ObjectValue);
}
return new LayerFactory(layerObjects);
}
public LayerGenerator(List<AbstractVisualClass> layerClasses)
{
List<AbstractVisualGenerator> LayerGeneratorsTemp = new List<AbstractVisualGenerator>();
foreach (AbstractVisualClass obj in layerClasses)
{
LayerGeneratorsTemp.Add(obj.Object);
}
this.LayerGenerators = LayerGeneratorsTemp;
}
public Layer(List<Visual> layerClasses)
{
ListFactory<Sprite> layerObjectsTemp = new List<Sprite>();
foreach (Visual obj in layerClasses)
{
layerObjectsTemp.Add(obj.Object);
}
this.layerObjects = layerObjectsTemp;
}
protected override Value Invoke()
{
if (objectVar != null && scope != null)
{
var values = new List<Value>();
foreach (AbstractNode node in parameters)
{
values.Add(node.Evaluate());
}
Value resolvedValue = scope.Resolve(objectVar);
if (resolvedValue == null)
{
throw new CompilerException(line, 211, objectVar);
}
if (resolvedValue.Type == ValType.Object)
{
try
{
AbstractClass objectInstance = resolvedValue.ObjectValue;
return objectInstance.InvokeMethod(funcName, values);
}
catch (CompilerException ce)
{
if (ce.ErrorCode == 314)
{
if (GlobalMemory.Instance.IsFunctionKnown(funcName))
{
Function function = GlobalMemory.Instance.GetFunction(funcName, values);
if (function is UserFunction)
{
GlobalMemory.Instance.AddCallToStack(new CallItem(funcName, Line));
Value returnValue = ((UserFunction) function).Invoke(resolvedValue, values);
GlobalMemory.Instance.PopLastCall();
return returnValue;
}
else
{
throw;
}
}
else
{
throw;
}
}
else
{
throw;
}
}
}
throw new CompilerException(line, 316, resolvedValue.TypeString);
}
else
{
var values = new List<Value>();
foreach (AbstractNode node in parameters)
{
values.Add(node.Evaluate());
}
Function function;
if (LibraryManager.Instance.IsFunctionKnown(funcName))
{
function = LibraryManager.Instance.GetFunction(funcName, values);
return function.Invoke(values);
}
else
{
GlobalMemory.Instance.AddCallToStack(new CallItem(funcName, Line));
function = GlobalMemory.Instance.GetFunction(funcName, values);
Value returnValue = function.Invoke(values);
GlobalMemory.Instance.PopLastCall();
return returnValue;
}
}
}
