int parseAndComputeRuleNewEnv( char *rule, ruleExecInfo_t *rei, int reiSaveFlag, msParamArray_t *msParamArray, rError_t *errmsg, Region *r ) { Env *env = defaultEnv( r ); addCmdExecOutToEnv( globalEnv( env ), r ); int rescode = 0; msParamArray_t *orig = NULL; if ( msParamArray != NULL ) { rescode = convertMsParamArrayToEnv( msParamArray, env->previous, r ); RE_ERROR( rescode < 0 ); } orig = rei->msParamArray; rei->msParamArray = NULL; rescode = parseAndComputeRule( rule, env, rei, reiSaveFlag, errmsg, r ); RE_ERROR( rescode < 0 ); if ( orig == NULL ) { rei->msParamArray = newMsParamArray(); } else { rei->msParamArray = orig; } rescode = convertEnvToMsParamArray( rei->msParamArray, env, errmsg, r ); RE_ERROR( rescode < 0 ); /* deleteEnv(env, 3); */ return rescode; error: /* deleteEnv(env, 3); */ return rescode; }
int parseAndComputeRuleAdapter( char *rule, msParamArray_t *msParamArray, ruleExecInfo_t *rei, int reiSaveFlag, Region *r ) { /* set clearDelayed to 0 so that nested calls to this function do not call clearDelay() */ int recclearDelayed = ruleEngineConfig.clearDelayed; ruleEngineConfig.clearDelayed = 0; rError_t errmsgBuf; errmsgBuf.errMsg = NULL; errmsgBuf.len = 0; Env *env = defaultEnv( r ); rei->status = 0; int rescode = 0; if ( msParamArray != NULL ) { if ( strncmp( rule, "@external\n", 10 ) == 0 ) { rescode = parseAndComputeMsParamArrayToEnv( msParamArray, globalEnv( env ), rei, reiSaveFlag, &errmsgBuf, r ); RE_ERROR( rescode < 0 ); rule = rule + 10; } else { rescode = convertMsParamArrayToEnv( msParamArray, globalEnv( env ), r ); RE_ERROR( rescode < 0 ); } } deleteFromHashTable(globalEnv(env)->current, "ruleExecOut"); rei->msParamArray = msParamArray; rescode = parseAndComputeRule( rule, env, rei, reiSaveFlag, &errmsgBuf, r ); RE_ERROR( rescode < 0 ); if ( NULL == rei->msParamArray ) { rei->msParamArray = newMsParamArray(); } rescode = convertEnvToMsParamArray( rei->msParamArray, env, &errmsgBuf, r ); RE_ERROR( rescode < 0 ); freeRErrorContent( &errmsgBuf ); /* deleteEnv(env, 3); */ return rescode; error: logErrMsg( &errmsgBuf, &rei->rsComm->rError ); rei->status = rescode; freeRErrorContent( &errmsgBuf ); /* deleteEnv(env, 3); */ if ( recclearDelayed ) { clearDelayed(); } ruleEngineConfig.clearDelayed = recclearDelayed; return rescode; }
ExprType *typeRule( RuleDesc *rule, Env *funcDesc, Hashtable *varTypes, List *typingConstraints, rError_t *errmsg, Node **errnode, Region *r ) { /* printf("%s\n", node->subtrees[0]->text); */ addRErrorMsg( errmsg, -1, ERR_MSG_SEP ); char buf[ERR_MSG_LEN]; Node *node = rule->node; int dynamictyping = rule->dynamictyping; ExprType *resType = typeExpression3( node->subtrees[1], dynamictyping, funcDesc, varTypes, typingConstraints, errmsg, errnode, r ); /*printf("Type %d\n",resType->t); */ RE_ERROR( getNodeType( resType ) == T_ERROR ); if ( getNodeType( resType ) != T_BOOL && getNodeType( resType ) != T_VAR && getNodeType( resType ) != T_DYNAMIC ) { char buf2[1024], buf3[ERR_MSG_LEN]; typeToString( resType, varTypes, buf2, 1024 ); snprintf( buf3, ERR_MSG_LEN, "error: the type %s of the rule condition is not supported", buf2 ); generateErrMsg( buf3, NODE_EXPR_POS( node->subtrees[1] ), node->subtrees[1]->base, buf ); addRErrorMsg( errmsg, RE_TYPE_ERROR, buf ); RE_ERROR( 1 ); } resType = typeExpression3( node->subtrees[2], dynamictyping, funcDesc, varTypes, typingConstraints, errmsg, errnode, r ); RE_ERROR( getNodeType( resType ) == T_ERROR ); resType = typeExpression3( node->subtrees[3], dynamictyping, funcDesc, varTypes, typingConstraints, errmsg, errnode, r ); RE_ERROR( getNodeType( resType ) == T_ERROR ); /* printVarTypeEnvToStdOut(varTypes); */ RE_ERROR( solveConstraints( typingConstraints, varTypes, errmsg, errnode, r ) == ABSURDITY ); int i; for ( i = 1; i <= 3; i++ ) { // 1 = cond, 2 = actions, 3 = recovery postProcessCoercion( node->subtrees[i], varTypes, errmsg, errnode, r ); postProcessActions( node->subtrees[i], funcDesc, errmsg, errnode, r ); } /*printTree(node, 0); */ return newSimpType( T_INT, r ); error: snprintf( buf, ERR_MSG_LEN, "type error: in rule %s", node->subtrees[0]->text ); addRErrorMsg( errmsg, RE_TYPE_ERROR, buf ); return resType; }
int parseAndComputeRuleNewEnv( char *rule, ruleExecInfo_t *rei, int reiSaveFlag, msParamArray_t *msParamArray, rError_t *errmsg, Region *r ) { Env *env = defaultEnv( r ); int rescode = 0; if ( msParamArray != NULL ) { rescode = convertMsParamArrayToEnv( msParamArray, env->previous, r ); RE_ERROR( rescode < 0 ); deleteFromHashTable(env->previous->current, "ruleExecOut"); } rescode = parseAndComputeRule( rule, env, rei, reiSaveFlag, errmsg, r ); RE_ERROR( rescode < 0 ); rescode = convertEnvToMsParamArray( rei->msParamArray, env, errmsg, r ); RE_ERROR( rescode < 0 ); /* deleteEnv(env, 3); */ return rescode; error: /* deleteEnv(env, 3); */ return rescode; }
int parseAndComputeRuleAdapter( char *rule, msParamArray_t *msParamArray, ruleExecInfo_t *rei, int reiSaveFlag, Region *r ) { /* set clearDelayed to 0 so that nested calls to this function do not call clearDelay() */ int recclearDelayed = ruleEngineConfig.clearDelayed; ruleEngineConfig.clearDelayed = 0; rError_t errmsgBuf; errmsgBuf.errMsg = NULL; errmsgBuf.len = 0; Env *env = defaultEnv( r ); rei->status = 0; msParamArray_t *orig = NULL; Res *execOutRes; int rescode = 0; if ( msParamArray != NULL ) { if ( strncmp( rule, "@external\n", 10 ) == 0 ) { rescode = parseAndComputeMsParamArrayToEnv( msParamArray, globalEnv( env ), rei, reiSaveFlag, &errmsgBuf, r ); RE_ERROR( rescode < 0 ); rule = rule + 10; } else { rescode = convertMsParamArrayToEnv( msParamArray, globalEnv( env ), r ); RE_ERROR( rescode < 0 ); } } if ( ( execOutRes = ( Res * )lookupFromEnv( env, "ruleExecOut" ) ) == NULL || TYPE( execOutRes ) == T_UNSPECED ) { /* add cmdExecOut only if ruleExecOut is an output parameter */ deleteFromHashTable( globalEnv( env )->current, "ruleExecOut" ); addCmdExecOutToEnv( globalEnv( env ), r ); } orig = rei->msParamArray; rei->msParamArray = NULL; rescode = parseAndComputeRule( rule, env, rei, reiSaveFlag, &errmsgBuf, r ); if ( orig == NULL ) { rei->msParamArray = newMsParamArray(); } else { rei->msParamArray = orig; } convertEnvToMsParamArray( rei->msParamArray, env, &errmsgBuf, r ); RE_ERROR( rescode < 0 ); freeRErrorContent( &errmsgBuf ); /* deleteEnv(env, 3); */ return rescode; error: logErrMsg( &errmsgBuf, &rei->rsComm->rError ); rei->status = rescode; freeRErrorContent( &errmsgBuf ); /* deleteEnv(env, 3); */ if ( recclearDelayed ) { clearDelayed(); } ruleEngineConfig.clearDelayed = recclearDelayed; return rescode; }