functionCallClass createNewInstance(functionCallClass context)
{
switch (context.extraInfo)
{
case null:
if (indexed.Classes.Exists(context.functionName))
{
context.extraInfo = indexed;
return(createNewInstanceAHK(context));
}
else if (assemblyMap.Type.Exists(context.functionName))
{
// context.extraInfo = invokeAssemblyMethod(null, context);
// return context;
}
return(null);
case IndexedNode o:
return(createNewInstanceAHK(context));
default:
// context.extraInfo = invokeAssemblyMethod(context.extraInfo, context);
return(context);
}
}
public override functionCallClass functionCall(functionCallClass context)
{
switch (context.extraInfo)
{
case null:
if (indexed.Functions.Exists(context.functionName))
{
context.extraInfo = indexed;
return(functionCallAHK(context));
}
else if (assemblyMap.Method.Exists(context.functionName))
{
context.extraInfo = invokeAssemblyMethod(null, context);
return(context);
}
return(null);
case IndexedNode o:
return(functionCallAHK(context));
default:
context.extraInfo = invokeAssemblyMethod(context.extraInfo, context);
return(context);
}
}
void setParameters(functionCallClass functionCall, functionDeclarationClass function)
{
if (function.functionHead.functionParameters.Count == 0)
{
return;
}
if (function.functionHead.functionParameters.Count < functionCall.functionParameterList.Count &&
!function.functionHead.functionParameters.Last().isVariadic)
{
return;
} //error: signature mismatch
// no default parameters or overriden default parameters
for (int i = 0; i < functionCall.functionParameterList.Count; i++)
{
var _variable = variable(function.functionHead.functionParameters[i].variableName);
var exp = functionCall.functionParameterList[i].extraInfo;
exp = exp is VariableValue? ((VariableValue)exp).Value : exp;
((VariableValue)_variable.extraInfo).Value = exp;
}
// default parameters
for (int i = functionCall.functionParameterList.Count; i < function.functionHead.functionParameters.Count; i++)
{
var _variable = variable(function.functionHead.functionParameters[i].variableName);
var exp = traverser.objectDispatcher(function.functionHead.functionParameters[i].expression).extraInfo;
exp = exp is VariableValue? ((VariableValue)exp).Value : exp;
((VariableValue)_variable.extraInfo).Value = exp;
}
}
functionCallClass createNewInstanceAHK(functionCallClass context)
{
var baseClass = ((IndexedNode)context.extraInfo).Classes[context.functionName];
var newScope = new IndexedNode();
newScope.Functions = baseClass.Functions;
newScope.Classes = baseClass.Classes;
newScope.AutoExecute = baseClass.AutoExecute;
autoExec(newScope);
autoExecuted[newScope] = true;
context.extraInfo = newScope;
return(context);
}
object invokeAssemblyMethod(object scope, functionCallClass func)
{
MethodInfo[] MethodArray = null;
if (scope == null)
{
if (!assemblyMap.Method.Exists(func.functionName))
{
return(null);
}
MethodArray = assemblyMap.Method[func.functionName].ToArray();
}
else if (scope is Type t)
{
MethodArray = t.GetMethods();
}
else
{
MethodArray = scope.GetType().GetMethods();
}
var method = MethodArray.Where(i => i.Name.ToLower() == func.functionName.ToLower() &&
i.GetParameters().Count() == func.functionParameterList.Count)
.First();
var assemblyParameters = prepareAssemblyParameters(method, func.functionParameterList);
var retVal = method.Invoke(scope is Type? null : scope, assemblyParameters);
var methodParams = method.GetParameters();
for (int i = 0; i < methodParams.Count(); i++)
{
if (!methodParams[i].ParameterType.IsByRef)
{
continue;
}
if (func.functionParameterList[i] is complexVariableClass o)
{
((VariableValue)o.extraInfo).Value = assemblyParameters[i];
}
}
return(retVal);
}
public functionCallClass functionCallAHK(functionCallClass context)
{
IndexedNode scope = (IndexedNode)context.extraInfo;
var function = getCorrectFunctionOverload(scope.Functions[context.functionName], context);
if (function == null)
{
} //incorrect overload error
foreach (var exp in context.functionParameterList)
{
traverser.objectDispatcher(exp);
}
// var parameterVariableAssignList = addParams(context, function);
// function.functionBody = parameterVariableAssignList.Concat(function.functionBody).ToList();
var oIndexed = indexed;
indexed = new IndexedNode();
indexed.Functions = oIndexed.Functions;
indexed.Classes = oIndexed.Classes;
indexed.Parent = scope;
setParameters(context, function);
foreach (var functionNode in function.functionBody)
{
var retVal = traverser.objectDispatcher(functionNode);
if (retVal.extraInfo is returnBlockClass r)
{
context.extraInfo = r.expression?.extraInfo;
break;
}
}
indexed = oIndexed;
return(context);
}
public virtual string functionCall(functionCallClass context)
{
return(context.defaultValue);
}
functionDeclarationClass getCorrectFunctionOverload(List <functionDeclarationClass> functionList, functionCallClass functionCall)
{
var retList = new List <functionDeclarationClass>();
var callParamCount = functionCall.functionParameterList.Count;
foreach (var function in functionList)
{
var requiredParams = function.functionHead.functionParameters.Where(i => !i.isVariadic && i.expression == null).Count();
var totalParams = function.functionHead.functionParameters.Count;
if (callParamCount == requiredParams)
{
retList.Add(function);
}
else if (callParamCount > requiredParams && callParamCount <= totalParams)
{
retList.Add(function);
}
}
return(retList.OrderBy(i => i.functionHead.functionParameters.Count).FirstOrDefault());
}
