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()); }