private bool ParseCreatorSig(string sig, out List <InstructionArgumentSignature> ret)
{
ret = new List <InstructionArgumentSignature>();
if (sig == null)
{
return(false);
}
string[] overloads = sig.Split('|');
foreach (string overload in overloads)
{
List <InstructionArgumentCategory> signature = new List <InstructionArgumentCategory>();
for (int i = 0; i < overload.Length; i++)
{
signature.Add(SerializableFLInstructionArgument.Parse(overload[i]));
}
ret.Add(new InstructionArgumentSignature {
Signature = signature
});
}
return(true);
}
protected override void Validate(
SerializableFLProgram prog, SerializableFLFunction func,
SerializableFLInstruction inst, SerializableFLInstructionArgument arg)
{
FLExecutableElementModifiers calledFunc =
prog.Functions.FirstOrDefault(x => x.Name == arg.Identifier)?.Modifiers ??
prog.ExternalFunctions.First(x => x.Name == arg.Identifier).Modifiers;
if (calledFunc.NoCall)
{
throw new FLInvalidFLElementModifierUseException(
func.Name,
FLKeywords.NoCallKeyword,
$"Can not use instruction {inst.InstructionKey} with a Defined Function that is marked with the nocall modifier."
);
}
}
protected override void Validate(
SerializableFLProgram prog, SerializableFLFunction func,
SerializableFLInstruction inst, SerializableFLInstructionArgument arg)
{
SerializableFLBuffer buf = prog.DefinedBuffers.First(x => x.Name == arg.Identifier);
if (buf.Modifiers.IsReadOnly)
{
throw new FLInvalidFLElementModifierUseException(
func.Name,
FLKeywords.ReadOnlyBufferModifier,
$"Can not use instruction {inst.InstructionKey} with a static buffer."
);
}
if (buf.Modifiers.IsArray)
{
throw new FLInvalidFLElementModifierUseException(
func.Name,
FLKeywords.ArrayKey,
$"Can not use instruction {inst.InstructionKey} with an array buffer."
);
}
}
protected abstract void Validate(
SerializableFLProgram prog, SerializableFLFunction func,
SerializableFLInstruction inst, SerializableFLInstructionArgument arg);
public override object Process(object o)
{
SerializableFLProgram input = (SerializableFLProgram)o;
Dictionary <string, SerializableExternalFLFunction> convertedFuncs =
new Dictionary <string, SerializableExternalFLFunction>();
for (int i = input.ExternalFunctions.Count - 1; i >= 0; i--)
{
SerializableExternalFLFunction serializableExternalFlFunction = input.ExternalFunctions[i];
if (serializableExternalFlFunction.Modifiers.ComputeOnce)
{
string newName = "_cached_" + serializableExternalFlFunction.Name;
convertedFuncs.Add(newName, serializableExternalFlFunction);
input.ExternalFunctions.RemoveAt(i);
LazyLoadingFLBuffer buf = new LazyLoadingFLBuffer(
root =>
{
FLProgram prog =
serializableExternalFlFunction
.ExternalProgram
.Initialize(
root.Instance,
InstructionSet
);
FLBuffer b = new FLBuffer(
root.Instance,
root.Dimensions.x,
root.Dimensions.y,
root.Dimensions.z,
"CachedBuffer" +
serializableExternalFlFunction
.Name
);
prog.Run(b, true);
b = prog.GetActiveBuffer(true);
prog.FreeResources();
return(b);
},
serializableExternalFlFunction
.Modifiers.InitializeOnStart
);
input.DefinedBuffers.Add(
new SerializableScriptBuffer(
newName,
new FLBufferModifiers(
newName,
new[]
{
FLKeywords
.ReadOnlyBufferModifier
}
),
buf
)
);
}
}
foreach (KeyValuePair <string, SerializableExternalFLFunction> staticFunction in convertedFuncs)
{
foreach (SerializableFLFunction serializableFlFunction in input.Functions)
{
foreach (SerializableFLInstruction serializableFlInstruction in serializableFlFunction.Instructions)
{
for (int i = 0; i < serializableFlInstruction.Arguments.Count; i++)
{
SerializableFLInstructionArgument arg = serializableFlInstruction.Arguments[i];
if (arg.Identifier == staticFunction.Value.Name)
{
serializableFlInstruction.Arguments[i] =
new SerializeBufferArgument(staticFunction.Key);
}
}
}
}
}
return(input);
}
public override object Process(object o)
{
SerializableFLProgram input = (SerializableFLProgram)o;
Dictionary <string, SerializableFLFunction> staticFunctions =
new Dictionary <string, SerializableFLFunction>();
for (int i = input.Functions.Count - 1; i >= 0; i--)
{
SerializableFLFunction staticFunction = input.Functions[i];
if (!staticFunction.Modifiers.IsStatic || staticFunction.Name == FLKeywords.EntryFunctionKey)
{
continue;
}
string funcName = "_ext_" + staticFunction.Name;
staticFunctions.Add(funcName, staticFunction);
input.Functions.RemoveAt(i);
List <string> source = staticFunction.Instructions.Select(x => x.ToString()).ToList();
source.Insert(0, FLKeywords.EntryFunctionKey + ":");
FLParserInput pi = new FLParserInput(
"Exported Function: " +
staticFunction
.Name,
source.ToArray(),
false
);
pi.KernelData = new List <EmbeddedKernelData>(input.KernelData);
SerializableFLProgram ext = (SerializableFLProgram)Target.Process(pi);
List <string> mods = new List <string> {
FLKeywords.NoJumpKeyword
};
if (staticFunction.Modifiers.ComputeOnce)
{
mods.Add(FLKeywords.ComputeOnceKeyword);
}
FLExecutableElementModifiers e = new FLExecutableElementModifiers(funcName, mods.ToArray());
input.ExternalFunctions.Add(new SerializableExternalFLFunction(funcName, ext, e));
}
foreach (KeyValuePair <string, SerializableFLFunction> staticFunction in staticFunctions)
{
foreach (SerializableFLFunction serializableFlFunction in input.Functions)
{
foreach (SerializableFLInstruction serializableFlInstruction in serializableFlFunction.Instructions)
{
for (int i = 0; i < serializableFlInstruction.Arguments.Count; i++)
{
SerializableFLInstructionArgument arg = serializableFlInstruction.Arguments[i];
if (arg.Identifier == staticFunction.Value.Name)
{
serializableFlInstruction.Arguments[i] =
new SerializeExternalFunctionArgument(staticFunction.Key);
}
}
}
}
}
return(input);
}
