private static string GenerateRoxygenBlock(string functionName, IFunctionDefinition fd, string lineBreak) {
var sb = new StringBuilder();
IFunctionInfo fi = fd.MakeFunctionInfo(functionName);
if (fi != null && fi.Signatures.Count > 0) {
sb.Append(Invariant($"#' Title{lineBreak}"));
sb.Append(Invariant($"#'{lineBreak}"));
int length = sb.Length;
foreach (var p in fi.Signatures[0].Arguments) {
if (!string.IsNullOrEmpty(p.Name)) {
sb.Append(Invariant($"#' @param {p.Name}{lineBreak}"));
}
}
if (sb.Length > length) {
sb.Append(Invariant($"#'{lineBreak}"));
}
sb.Append(Invariant($"#' @return{lineBreak}"));
sb.Append(Invariant($"#' @export{lineBreak}"));
sb.Append(Invariant($"#'{lineBreak}"));
sb.Append("#' @examples");
}
return sb.ToString();
}
public FunctionDocumentation(string libName, ResourceKeyStack messagePath, IFunctionDefinition func)
{
_libName = libName;
_name = func.Name;
_arguments = func.Arguments;
_returnType = func.ReturnType;
_messagePath = messagePath.BranchFor(func);
_description=_messagePath.Description;
_category = CategoryHelper.GetCategory(func.GetType());
}
private static IFunctionInstance CreateFunctionInstance(IFunctionDefinition func, IDictionary <string, object> parameters)
{
var context = new FunctionInstanceFactoryContext
{
Id = Guid.NewGuid(),
ParentId = null,
ExecutionReason = ExecutionReason.HostCall,
Parameters = parameters
};
return(func.InstanceFactory.Create(context));
}
public static IFunctionInfo MakeFunctionInfo(this IFunctionDefinition fd, string functionName, bool isInternal)
{
if (fd != null)
{
var fi = new FunctionInfo(functionName, isInternal)
{
Signatures = new [] { fd.MakeSignature(functionName) }
};
return(fi);
}
return(null);
}
public static FunctionEvaluationException WrongParameter(IFunctionDefinition function, int paramterIndex,
object parameter)
{
string msg = String.Format("Can't evaluate function {0} expected {1} but found {2} on argument {3}({4})",
function.Name,
function.Arguments[paramterIndex].Type.Name,
parameter.GetType().Name,
function.Arguments[paramterIndex].Name,
paramterIndex
);
return new FunctionEvaluationException(msg);
}
private static IFunctionDefinition ResolveFunctionDefinition(MethodInfo method, IFunctionIndexLookup functionLookup)
{
IFunctionDefinition function = functionLookup.Lookup(method);
if (function == null)
{
string msg = String.Format(CultureInfo.CurrentCulture, "'{0}' can't be invoked from Azure WebJobs SDK. Is it missing Azure WebJobs SDK attributes?", method);
throw new InvalidOperationException(msg);
}
return(function);
}
protected override string InputParameterType(int i, Invocation invocation, GrGenType ownerType)
{
if (invocation is RuleInvocation)
{
RuleInvocation ruleInvocation = (RuleInvocation)invocation;
IAction action = SequenceBase.GetAction(ruleInvocation);
return(TypesHelper.DotNetTypeToXgrsType(action.RulePattern.Inputs[i]));
}
else if (invocation is SequenceInvocation)
{
SequenceSequenceCallInterpreted seqInvocation = (SequenceSequenceCallInterpreted)invocation;
if (seqInvocation.SequenceDef is SequenceDefinitionInterpreted)
{
SequenceDefinitionInterpreted seqDef = (SequenceDefinitionInterpreted)seqInvocation.SequenceDef;
return(seqDef.InputVariables[i].Type);
}
else
{
SequenceDefinitionCompiled seqDef = (SequenceDefinitionCompiled)seqInvocation.SequenceDef;
return(TypesHelper.DotNetTypeToXgrsType(seqDef.SeqInfo.ParameterTypes[i]));
}
}
else if (invocation is ProcedureInvocation)
{
ProcedureInvocation procInvocation = (ProcedureInvocation)invocation;
if (ownerType != null)
{
IProcedureDefinition procDef = ownerType.GetProcedureMethod(procInvocation.Name);
return(TypesHelper.DotNetTypeToXgrsType(procDef.Inputs[i]));
}
else
{
SequenceComputationProcedureCallInterpreted procInvocationInterpreted = (SequenceComputationProcedureCallInterpreted)procInvocation;
return(TypesHelper.DotNetTypeToXgrsType(procInvocationInterpreted.ProcedureDef.Inputs[i]));
}
}
else if (invocation is FunctionInvocation)
{
FunctionInvocation funcInvocation = (FunctionInvocation)invocation;
if (ownerType != null)
{
IFunctionDefinition funcDef = ownerType.GetFunctionMethod(funcInvocation.Name);
return(TypesHelper.DotNetTypeToXgrsType(funcDef.Inputs[i]));
}
else
{
SequenceExpressionFunctionCallInterpreted funcInvocationInterpreted = (SequenceExpressionFunctionCallInterpreted)funcInvocation;
return(TypesHelper.DotNetTypeToXgrsType(funcInvocationInterpreted.FunctionDef.Inputs[i]));
}
}
throw new Exception("Internal error");
}
protected override int NumInputParameters(Invocation invocation, InheritanceType ownerType)
{
if (invocation is RuleInvocation)
{
RuleInvocation ruleInvocation = (RuleInvocation)invocation;
IAction action = SequenceBase.GetAction(ruleInvocation);
return(action.RulePattern.Inputs.Length);
}
else if (invocation is SequenceInvocation)
{
SequenceSequenceCallInterpreted seqInvocation = (SequenceSequenceCallInterpreted)invocation;
if (seqInvocation.SequenceDef is SequenceDefinitionInterpreted)
{
SequenceDefinitionInterpreted seqDef = (SequenceDefinitionInterpreted)seqInvocation.SequenceDef;
return(seqDef.InputVariables.Length);
}
else
{
SequenceDefinitionCompiled seqDef = (SequenceDefinitionCompiled)seqInvocation.SequenceDef;
return(seqDef.SeqInfo.ParameterTypes.Length);
}
}
else if (invocation is ProcedureInvocation)
{
ProcedureInvocation procInvocation = (ProcedureInvocation)invocation;
if (ownerType != null)
{
IProcedureDefinition procDef = ownerType.GetProcedureMethod(procInvocation.Name);
return(procDef.Inputs.Length);
}
else
{
SequenceComputationProcedureCallInterpreted procInvocationInterpreted = (SequenceComputationProcedureCallInterpreted)procInvocation;
return(procInvocationInterpreted.ProcedureDef.Inputs.Length);
}
}
else if (invocation is FunctionInvocation)
{
FunctionInvocation funcInvocation = (FunctionInvocation)invocation;
if (ownerType != null)
{
IFunctionDefinition funcDef = ownerType.GetFunctionMethod(funcInvocation.Name);
return(funcDef.Inputs.Length);
}
else
{
SequenceExpressionFunctionCallInterpreted funcInvocationInterpreted = (SequenceExpressionFunctionCallInterpreted)funcInvocation;
return(funcInvocationInterpreted.FunctionDef.Inputs.Length);
}
}
throw new Exception("Internal error");
}
public override SequenceExpressionFunctionCall CreateSequenceExpressionFunctionCallUserFunction(String functionName, String packagePrefix,
List <SequenceExpression> argExprs)
{
String packagePrefixedFunctionName = !PackageIsNullOrGlobal(packagePrefix) ? packagePrefix + "::" + functionName : functionName;
IFunctionDefinition functionDef = actions.GetFunctionDefinition(packagePrefixedFunctionName);
if (functionDef == null)
{
throw new SequenceParserException(packagePrefixedFunctionName, DefinitionType.Function, SequenceParserError.UnknownFunction);
}
return(new SequenceExpressionFunctionCallInterpreted(functionDef, argExprs));
}
public static FunctionEvaluationException WrongParameter(IFunctionDefinition function, int paramterIndex,
object parameter)
{
string msg = String.Format("Can't evaluate function {0} expected {1} but found {2} on argument {3}({4})",
function.Name,
function.Arguments[paramterIndex].Type.Name,
parameter.GetType().Name,
function.Arguments[paramterIndex].Name,
paramterIndex
);
return(new FunctionEvaluationException(msg));
}
/// <summary>
/// Instantiates a new FunctionInvocationParameterBindings object
/// </summary>
/// <param name="functionDef">The defined function to be used</param>
/// <param name="argExprs">An array of expressions used to compute the arguments</param>
/// <param name="arguments">An array of arguments.</param>
public FunctionInvocationParameterBindings(IFunctionDefinition functionDef,
SequenceExpression[] argExprs, object[] arguments)
: base(argExprs, arguments)
{
FunctionDef = functionDef;
if (functionDef != null)
{
Name = functionDef.Name;
PrePackage = functionDef.Package;
Package = PrePackage;
PackagePrefixedName = Package != null ? Package + "::" + Name : Name;
}
}
public static IFunctionSignature GetFunctionSignature(this IFunctionDefinition fd)
{
TypeRegistry.DefaultRegistry.TryGetTypeByName(fd.Typename, out var returnType);
List <TypeId> paramTypes = new List <TypeId>();
foreach (var paramTypeName in fd.ParameterDeclarations.ParameterDeclarations.Select(item => item.TypeName))
{
if (TypeRegistry.DefaultRegistry.TryGetTypeByName(paramTypeName, out var paramTid))
{
paramTypes.Add(paramTid.TypeId);
}
}
return(new FunctionSignature(fd.Name, returnType?.TypeId, paramTypes.ToArray()));
}
public void Add(IFunctionDefinition function, FunctionDescriptor descriptor, MethodInfo method)
{
string id = descriptor.Id;
if (_functionsById.ContainsKey(id))
{
throw new InvalidOperationException("Method overloads are not supported. " +
"There are multiple methods with the name '" + id + "'.");
}
_functionsById.Add(id, function);
_functionsByMethod.Add(method, function);
_functionDescriptors.Add(descriptor);
}
public void Add(IFunctionDefinition function, FunctionDescriptor descriptor, MethodInfo method)
{
string id = descriptor.Id;
if (_functionsById.ContainsKey(id))
{
throw new InvalidOperationException("Method overloads are not supported. " +
"There are multiple methods with the name '" + id + "'.");
}
_functionsById.Add(id, function);
_functionsByMethod.Add(method, function);
_functionDescriptors.Add(descriptor);
}
private async Task CallAsyncCore(MethodInfo method, IDictionary <string, object> arguments,
CancellationToken cancellationToken)
{
await EnsureHostStartedAsync(cancellationToken);
IFunctionDefinition function = ResolveFunctionDefinition(method, _context.FunctionLookup);
IFunctionInstance instance = CreateFunctionInstance(function, arguments);
IDelayedException exception = await _context.Executor.TryExecuteAsync(instance, cancellationToken);
if (exception != null)
{
exception.Throw();
}
}
/// <summary>Calls a job method.</summary>
/// <param name="name">The name of the function to call.</param>
/// <param name="arguments">The argument names and values to bind to parameters in the job method. In addition to parameter values, these may also include binding data values. </param>
/// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
/// <returns>A <see cref="Task"/> that will call the job method.</returns>
public async Task CallAsync(string name, IDictionary <string, object> arguments = null, CancellationToken cancellationToken = default(CancellationToken))
{
if (name == null)
{
throw new ArgumentNullException(nameof(name));
}
ThrowIfDisposed();
await EnsureHostInitializedAsync(cancellationToken);
IFunctionDefinition function = _context.FunctionLookup.LookupByName(name);
await CallAsyncCore(function, name, arguments, cancellationToken);
}
private async Task CallAsyncCore(IFunctionDefinition function, object functionKey, IDictionary <string, object> arguments, CancellationToken cancellationToken)
{
Validate(function, functionKey);
IFunctionInstance instance = CreateFunctionInstance(function, arguments);
IDelayedException exception = null;
exception = await _context.Executor.TryExecuteAsync(instance, cancellationToken);
if (exception != null)
{
exception.Throw();
}
}
private void GuardParams(IFunctionDefinition function)
{
var functionArguments = function.Arguments;
if (functionArguments.Length == 0)
{
return;
}
for (var i = 0; i < functionArguments.Length - 1; i++)
{
if (functionArguments[i].Params)
{
throw new ArgumentException($"Only last argument of a function can be a params argument. Argument {functionArguments[i].Name} of {function.Name} is in violation.");
}
}
}
private static bool DetermineFunction(AstRoot ast, int position, out IFunctionDefinition fd, out IVariable v, out FunctionCall fc)
{
fd = ast.FindFunctionDefinition(position, out v);
fc = null;
if (fd == null)
{
fc = ast.GetNodeOfTypeFromPosition <FunctionCall>(position);
var name = fc.GetFunctionName();
if (string.IsNullOrEmpty(name) || !_s4FunctionNames.Contains(name))
{
fc = null;
}
}
return(fd != null || fc != null);
}
public void TestNoAutoTrigger1()
{
var entry = IndexMethod("NoAutoTrigger1");
Assert.NotNull(entry);
IFunctionDefinition definiton = entry.Item2;
Assert.NotNull(definiton);
Assert.Null(definiton.ListenerFactory);
FunctionDescriptor descriptor = entry.Item1;
Assert.NotNull(descriptor);
var parameters = descriptor.Parameters;
Assert.Single(parameters);
Assert.IsType <BlobParameterDescriptor>(parameters.First());
}
public void TestNoAutoTrigger2()
{
var entry = IndexMethod("NoAutoTrigger2");
Assert.NotNull(entry);
IFunctionDefinition definiton = entry.Item2;
Assert.NotNull(definiton);
Assert.Null(definiton.ListenerFactory);
FunctionDescriptor descriptor = entry.Item1;
Assert.NotNull(descriptor);
var parameters = descriptor.Parameters;
Assert.Equal(2, parameters.Count());
Assert.IsType <CallerSuppliedParameterDescriptor>(parameters.ElementAt(0));
Assert.IsType <CallerSuppliedParameterDescriptor>(parameters.ElementAt(1));
}
private IFunctionInstance CreateFunctionInstance(CallAndOverrideMessage message)
{
IFunctionDefinition function = _functionLookup.Lookup(message.FunctionId);
if (function == null)
{
return(null);
}
IDictionary <string, object> objectParameters = new Dictionary <string, object>();
if (message.Arguments != null)
{
foreach (KeyValuePair <string, string> item in message.Arguments)
{
objectParameters.Add(item.Key, item.Value);
}
}
return(function.InstanceFactory.Create(message.Id, message.ParentId, message.Reason, objectParameters));
}
protected override int NumInputParameters(Invocation invocation, GrGenType ownerType)
{
if (invocation is RuleInvocation)
{
RuleInvocation ruleInvocation = (RuleInvocation)invocation;
return(actionsTypeInformation.rulesToInputTypes[ruleInvocation.PackagePrefixedName].Count);
}
else if (invocation is SequenceInvocation)
{
SequenceInvocation seqInvocation = (SequenceInvocation)invocation;
return(actionsTypeInformation.sequencesToInputTypes[seqInvocation.PackagePrefixedName].Count);
}
else if (invocation is ProcedureInvocation)
{
ProcedureInvocation procInvocation = (ProcedureInvocation)invocation;
if (ownerType != null)
{
IProcedureDefinition procDef = ownerType.GetProcedureMethod(procInvocation.Name);
return(procDef.Inputs.Length);
}
else
{
return(actionsTypeInformation.proceduresToInputTypes[procInvocation.PackagePrefixedName].Count);
}
}
else if (invocation is FunctionInvocation)
{
FunctionInvocation funcInvocation = (FunctionInvocation)invocation;
if (ownerType != null)
{
IFunctionDefinition funcDef = ownerType.GetFunctionMethod(funcInvocation.Name);
return(funcDef.Inputs.Length);
}
else
{
return(actionsTypeInformation.functionsToInputTypes[funcInvocation.PackagePrefixedName].Count);
}
}
throw new Exception("Internal error");
}
protected override string InputParameterType(int i, Invocation invocation, GrGenType ownerType)
{
if (invocation is RuleInvocation)
{
RuleInvocation ruleInvocation = (RuleInvocation)invocation;
return(actionsTypeInformation.rulesToInputTypes[ruleInvocation.PackagePrefixedName][i]);
}
else if (invocation is SequenceInvocation)
{
SequenceInvocation seqInvocation = (SequenceInvocation)invocation;
return(actionsTypeInformation.sequencesToInputTypes[seqInvocation.PackagePrefixedName][i]);
}
else if (invocation is ProcedureInvocation)
{
ProcedureInvocation procInvocation = (ProcedureInvocation)invocation;
if (ownerType != null)
{
IProcedureDefinition procDef = ownerType.GetProcedureMethod(procInvocation.Name);
return(TypesHelper.DotNetTypeToXgrsType(procDef.Inputs[i]));
}
else
{
return(actionsTypeInformation.proceduresToInputTypes[procInvocation.PackagePrefixedName][i]);
}
}
else if (invocation is FunctionInvocation)
{
FunctionInvocation funcInvocation = (FunctionInvocation)invocation;
if (ownerType != null)
{
IFunctionDefinition funcDef = ownerType.GetFunctionMethod(funcInvocation.Name);
return(TypesHelper.DotNetTypeToXgrsType(funcDef.Inputs[i]));
}
else
{
return(actionsTypeInformation.functionsToInputTypes[funcInvocation.PackagePrefixedName][i]);
}
}
throw new Exception("Internal error");
}
/// <summary>Calls a job method.</summary>
/// <param name="name">The name of the function to call.</param>
/// <param name="arguments">The argument names and values to bind to parameters in the job method. In addition to parameter values, these may also include binding data values. </param>
/// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
/// <returns>A <see cref="Task"/> that will call the job method.</returns>
public async Task CallAsync(string name, IDictionary <string, object> arguments = null, CancellationToken cancellationToken = default(CancellationToken))
{
if (name == null)
{
throw new ArgumentNullException(nameof(name));
}
ThrowIfDisposed();
await EnsureHostInitializedAsync(cancellationToken);
IFunctionDefinition function = _context.FunctionLookup.LookupByName(name);
Validate(function, name);
IFunctionInstance instance = CreateFunctionInstance(function, arguments);
IDelayedException exception = await _context.Executor.TryExecuteAsync(instance, cancellationToken);
if (exception != null)
{
exception.Throw();
}
}
public VFunction(IFunctionDefinition funDef) : this(funDef.name)
{
foreach (var arg in funDef.arguments)
{
AddArgument(arg.varName);
}
foreach (var v in funDef.variables)
{
AddVariable(v.varName);
}
foreach (var statement in funDef.statements)
{
var velement = VElementBuilder.Create(statement);
AddExpression(velement);
}
var sourceVariables = vvariables.Concat(varguments).ToList();
foreach (var @ref in refs)
{
var variable = sourceVariables.FirstOrDefault(x => x.varName == @ref.markInitVarName);
variable.AttachVarRef(@ref);
}
}
public void RemoveFunction(IFunctionDefinition fd) => Functions.Remove(fd);
internal Function(IFunctionDefinition function)
{
_function = function;
}
private String BuildParameters(InvocationParameterBindings paramBindings, IFunctionDefinition functionMethod)
{
String parameters = "";
for(int i = 0; i < paramBindings.ArgumentExpressions.Length; i++)
{
if(paramBindings.ArgumentExpressions[i] != null)
{
String typeName = TypesHelper.DotNetTypeToXgrsType(functionMethod.Inputs[i]);
String cast = "(" + TypesHelper.XgrsTypeToCSharpType(typeName, model) + ")";
parameters += ", " + cast + GetSequenceExpression(paramBindings.ArgumentExpressions[i], null);
}
else
{
// the sequence parser always emits all argument expressions, for interpreted and compiled
throw new Exception("Internal error: missing argument expressions");
}
}
return parameters;
}
public void AddFunction(IFunctionDefinition fd) => Functions.Add(fd);
public MathFunctionParser(IFunctionDefinition func)
{
_func = func;
}
/// <summary>
/// Instantiates a new FunctionInvocationParameterBindings object
/// </summary>
/// <param name="functionDef">The defined function to be used</param>
/// <param name="argExprs">An array of expressions used to compute the arguments</param>
/// <param name="arguments">An array of arguments.</param>
public FunctionInvocationParameterBindings(IFunctionDefinition functionDef,
SequenceExpression[] argExprs, object[] arguments)
: base(argExprs, arguments)
{
FunctionDef = functionDef;
if(functionDef != null)
{
Name = functionDef.Name;
PrePackage = functionDef.Package;
Package = PrePackage;
PackagePrefixedName = Package != null ? Package + "::" + Name : Name;
}
}
public static IFunctionDefinition CreateFunction(object instance, MethodInfo method)
{
var parameters = method.GetParameters();
var parameterTypes = method.GetParameters().Convert(p => p.ParameterType);
int outParameterCount = parameters.Count(p => p.IsOut);
Type functionType;
if (method.ReturnType == typeof(void))
{
switch (parameterTypes.Length)
{
default:
case 0:
functionType = typeof(FunctionDefinition);
break;
case 1:
functionType = typeof(FunctionInDefinition <>).MakeGenericType(parameterTypes);
break;
case 2:
if (outParameterCount == 2)
{
functionType = typeof(FunctionOutDefinition <,>).MakeGenericType(parameterTypes);
}
else
{
functionType = typeof(FunctionInDefinition <,>).MakeGenericType(parameterTypes);
}
break;
case 3:
if (outParameterCount == 3)
{
functionType = typeof(FunctionOutDefinition <, ,>).MakeGenericType(parameterTypes);
}
else
{
functionType = typeof(FunctionInDefinition <, ,>).MakeGenericType(parameterTypes);
}
break;
case 4:
functionType = typeof(FunctionInDefinition <, , ,>).MakeGenericType(parameterTypes);
break;
case 5:
functionType = typeof(FunctionInDefinition <, , ,>).MakeGenericType(parameterTypes);
break;
}
}
else
{
switch (parameterTypes.Length)
{
default:
case 0:
functionType = typeof(FunctionOutDefinition <>).MakeGenericType(method.ReturnType);
break;
case 1:
functionType = typeof(FunctionInOutDefinition <,>).MakeGenericType(parameterTypes.Joined(method.ReturnType));
break;
case 2:
functionType = typeof(FunctionInOutDefinition <, ,>).MakeGenericType(parameterTypes.Joined(method.ReturnType));
break;
case 3:
functionType = typeof(FunctionInOutDefinition <, , ,>).MakeGenericType(parameterTypes.Joined(method.ReturnType));
break;
case 4:
functionType = typeof(FunctionInOutDefinition <, , , ,>).MakeGenericType(parameterTypes.Joined(method.ReturnType));
break;
case 5:
functionType = typeof(FunctionInOutDefinition <, , , , ,>).MakeGenericType(parameterTypes.Joined(method.ReturnType));
break;
}
}
IFunctionDefinition function = null;
try
{
if (method.IsStatic)
{
function = (IFunctionDefinition)Activator.CreateInstance(functionType, null, method);
}
else
{
function = (IFunctionDefinition)Activator.CreateInstance(functionType, instance, method);
}
}
catch { }
return(function);
}
private void SubstituteFunctionDefinitions(IFunctionCollection classDefinition, List <IFunctionDefinition> fdg, IFunctionDefinition combinedFunction)
{
foreach (var fd in fdg)
{
classDefinition.RemoveFunction(fd);
}
classDefinition.AddFunction(combinedFunction);
}
public ResourceKeyStack BranchFor(IFunctionDefinition function)
{
var branch = (ResourceKeyStack)MemberwiseClone();
branch._function = function;
return branch;
}
internal Function(IFunctionDefinition function)
{
_function = function;
}
private static IFunctionInstance CreateFunctionInstance(IFunctionDefinition func,
IDictionary <string, object> parameters)
{
return(func.InstanceFactory.Create(Guid.NewGuid(), null, ExecutionReason.HostCall, parameters));
}
private static IFunctionInstance CreateFunctionInstance(IFunctionDefinition func, IDictionary<string, object> parameters)
{
return func.InstanceFactory.Create(Guid.NewGuid(), null, ExecutionReason.HostCall, parameters);
}
public void Add(IFunctionDefinition function, FunctionDescriptor descriptor, MethodInfo method)
{
Functions.Add(descriptor);
}
public String BuildParameters(Invocation invocation, SequenceExpression[] ArgumentExpressions, IFunctionDefinition functionMethod, SourceBuilder source)
{
String parameters = "";
for (int i = 0; i < ArgumentExpressions.Length; i++)
{
if (ArgumentExpressions[i] != null)
{
String typeName = TypesHelper.DotNetTypeToXgrsType(functionMethod.Inputs[i]);
String cast = "(" + TypesHelper.XgrsTypeToCSharpType(typeName, model) + ")";
parameters += ", " + cast + exprGen.GetSequenceExpression(ArgumentExpressions[i], source);
}
else
{
// the sequence parser always emits all argument expressions, for interpreted and compiled
throw new Exception("Internal error: missing argument expressions");
}
}
return(parameters);
}
protected void RegisterFunction(IFunctionDefinition function)
{
functions.Add(function.Name, function);
}
