/// <summary> /// /// check the parameters, according to the definition. /// </summary> /// <param name="exprExecResult"></param> /// <param name="functionToCallMapper"></param> /// <param name="listExprExecParam"></param> /// <returns></returns> public bool CheckParams(ExecResult exprExecResult, FunctionToCallMapper functionToCallMapper, List <ExpressionExecBase> listExprExecParam) { bool res; // check param1 res = CheckParam(exprExecResult, functionToCallMapper, listExprExecParam, 1, functionToCallMapper.Param1Type); if (functionToCallMapper.Param1Type == DataType.NotDefined) { return(res); } // check param2 res &= CheckParam(exprExecResult, functionToCallMapper, listExprExecParam, 2, functionToCallMapper.Param2Type); if (functionToCallMapper.Param2Type == DataType.NotDefined) { return(res); } // check param3 res &= CheckParam(exprExecResult, functionToCallMapper, listExprExecParam, 3, functionToCallMapper.Param3Type); //if (functionToCallMapper.Param2Type == DataType.NotDefined) return res; // check others params // todo: return(res); }
/// <summary> /// Execute a functionCall. /// First execute parameters and then execute the function code attached/linked. /// </summary> /// <param name="exprExecResult"></param> /// <param name="exprFunctionCall"></param> /// <param name="exprExecBase"></param> /// <returns></returns> private bool ExecExpressionFunctionCall(ExecResult exprExecResult, ExprFunctionCall exprFunctionCall, out ExpressionExecBase exprExecBase) { ExpressionExecBase exprExecParamBase; List <ExpressionExecBase> listExprExecParam = new List <ExpressionExecBase>(); bool res = true; exprExecBase = null; // get the function code FunctionToCallMapper functionToCallMapper = _exprEvalConfig.ListFunctionToCallMapper.Find(f => f.FunctionCallName.Equals(exprFunctionCall.FunctionName, StringComparison.InvariantCultureIgnoreCase)); if (functionToCallMapper == null) { // error exprExecResult.AddErrorExec(ErrorCode.FunctionCallNotLinked, "FunctionCallName", exprFunctionCall.FunctionName); return(false); } // execute params of the function foreach (ExpressionBase exprParam in exprFunctionCall.ListExprParameters) { res &= ExecExpression(exprExecResult, exprParam, out exprExecParamBase); listExprExecParam.Add(exprExecParamBase); } // a param execution failed if (!res) { return(false); } // execute the function code attached to the functionCall, provide executed params return(_exprExecutorFunctionCall.ExecExpressionFunctionCall(exprExecResult, exprFunctionCall, functionToCallMapper, listExprExecParam, out exprExecBase)); }
/// <summary> /// Check that all found functionCall in the expression are linked with a function body. /// </summary> /// <returns></returns> private bool CheckFunctionCalls() { // set to no error bool functionCallMappedRes = true; // scan each defined var by the parser foreach (ExprFunctionCallUsed functionCallUsed in _expressionData.ExprParseResult.ListExprFunctionCallUsed) { // is a functionToCall mapped to the functionCall found in the expression? FunctionToCallMapper functionToCall = _exprEvalConfig.ListFunctionToCallMapper.Find(f => f.FunctionCallName.Equals(functionCallUsed.Name, StringComparison.InvariantCultureIgnoreCase)); if (functionToCall == null) { // any function code matching the functionCall name is found! _expressionData.ExprExecResult.AddErrorExec(ErrorCode.FunctionCallNotLinked, "FunctionCallName", functionCallUsed.Name); functionCallMappedRes = false; // check the next functionCall used/present in the expression continue; } // ok the functionCall is attached to a functionCode, check the params count (the type will be checked later at execution) if (!CheckParamsCountMatching(functionCallUsed, functionToCall)) { // the error is set inside the function functionCallMappedRes = false; } } return(functionCallMappedRes); }
/// <summary> /// Check the match of parameters between the functionCall and the attached function code. /// the matching of the type of each parameter will be checked later at the execution stage. /// </summary> /// <param name="functionCallUsed"></param> /// <param name="functionToCall"></param> /// <returns></returns> private bool CheckParamsCountMatching(ExprFunctionCallUsed functionCallUsed, FunctionToCallMapper functionToCall) { // the function code has any parameter if (functionToCall.Param1Type == DataType.NotDefined) { if (functionCallUsed.ParameterCount != 0) { // error, the parameter count mismatch between the function call and the function code _expressionData.ExprExecResult.AddErrorExec(ErrorCode.FunctionCallParamCountWrong, "FunctionCallName", functionCallUsed.Name); return(false); } // ok, the parameter count match return(true); } // one parameter at least is present if (functionToCall.Param2Type == DataType.NotDefined) { if (functionCallUsed.ParameterCount != 1) { // error, the parameter count mismatch between the function call and the function code _expressionData.ExprExecResult.AddErrorExec(ErrorCode.FunctionCallParamCountWrong, "FunctionCallName", functionCallUsed.Name); return(false); } // ok, the parameter count match return(true); } // one parameter at least is present if (functionToCall.Param3Type == DataType.NotDefined) { if (functionCallUsed.ParameterCount != 2) { // error, the parameter count mismatch between the function call and the function code _expressionData.ExprExecResult.AddErrorExec(ErrorCode.FunctionCallParamCountWrong, "FunctionCallName", functionCallUsed.Name); return(false); } // ok, the parameter count match return(true); } // the function call has three parameters if (functionCallUsed.ParameterCount != 3) { // error, the parameter count mismatch between the function call and the function code _expressionData.ExprExecResult.AddErrorExec(ErrorCode.FunctionCallParamCountWrong, "FunctionCallName", functionCallUsed.Name); return(false); } // ok, the parameter count match return(true); // todo: enlever code de check count param dans la methode ExprExecutorFunctionCallRetBase.CheckParam() }
/// <summary> /// Check one parameter of a function call. /// </summary> /// <param name="exprExecResult"></param> /// <param name="functionToCallMapper"></param> /// <param name="listExprExecParam"></param> /// <param name="paramNum"></param> /// <param name="dataType"></param> /// <returns></returns> private bool CheckParam(ExecResult exprExecResult, FunctionToCallMapper functionToCallMapper, List <ExpressionExecBase> listExprExecParam, int paramNum, DataType dataType) { // check param //if (dataType == DataType.NotDefined) //{ // ici(); // // any parameter // if (listExprExecParam.Count > paramNum) // { // // error! too many parameters provided // exprExecResult.AddError(ExecErrorCode.ExprFunctionCallParamCountWrong, "ParamExpectedCount", (paramNum).ToString(), "ParamFoundCount", listExprExecParam.Count.ToString()); // return false; // } // // the param type is set to NotDefined // return true; //} //// at least one parameter is expected //if (listExprExecParam.Count < paramNum) //{ // // errror! not enought provided parameters // exprExecResult.AddError(ExecErrorCode.ExprFunctionCallParamCountWrong, "ParamExpectedCount", (paramNum).ToString(), "ParamFoundCount", listExprExecParam.Count.ToString()); // return false; //} if (dataType == DataType.NotDefined) { return(true); } // check param, should be a bool if (dataType == DataType.Bool) { // check the type of the param ExprExecValueBool exprParamBool; if (!GetCheckParamBool(exprExecResult, functionToCallMapper.FunctionCallName, listExprExecParam[paramNum - 1], out exprParamBool)) { return(false); } // the param1 is ok return(true); } // check param, should be an int if (dataType == DataType.Int) { // check the type of the param ExprExecValueInt exprParamInt; if (!GetCheckParamInt(exprExecResult, functionToCallMapper.FunctionCallName, listExprExecParam[paramNum - 1], out exprParamInt)) { return(false); } // the param1 is ok return(true); } // string if (dataType == DataType.String) { // check the type of the param ExprExecValueString exprParamString; if (!GetCheckParamString(exprExecResult, functionToCallMapper.FunctionCallName, listExprExecParam[paramNum - 1], out exprParamString)) { return(false); } // the param is ok return(true); } // check param, should be a double // check the type of the param ExprExecValueDouble exprParamDouble; if (!GetCheckParamDouble(exprExecResult, functionToCallMapper.FunctionCallName, listExprExecParam[paramNum - 1], out exprParamDouble)) { return(false); } // the param is ok return(true); }