void *lookupFromEnv(Env *env, char *key) {
void* val = lookupFromHashTable(env->current, key);
if(val==NULL && env->previous!=NULL) {
val = lookupFromEnv(env->previous, key);
}
return val;
}
Res *setVariableValue(char *varName, Res *val, ruleExecInfo_t *rei, Env *env, rError_t *errmsg, Region *r) {
int i;
char *varMap;
char errbuf[ERR_MSG_LEN];
if (varName[0] == '$') {
if(TYPE(val)!=T_STRING) {
snprintf(errbuf, ERR_MSG_LEN, "error: assign a nonstring value to session variable %s.", varName);
addRErrorMsg(errmsg, RE_UNSUPPORTED_OP_OR_TYPE, errbuf);
return newErrorRes(r, RE_UNSUPPORTED_OP_OR_TYPE);
}
i = getVarMap("", varName, &varMap, 0);
if (i < 0) {
snprintf(errbuf, ERR_MSG_LEN, "error: unsupported session variable \"%s\".",varName);
addRErrorMsg(errmsg, RE_UNSUPPORTED_SESSION_VAR, errbuf);
return newErrorRes(r, RE_UNSUPPORTED_SESSION_VAR);
}
setVarValue(varMap, rei, strdup(val->text));
return newIntRes(r, 0);
}
else if(varName[0] == '*') {
if(lookupFromEnv(env, varName)==NULL) {
/* new variable */
if(insertIntoHashTable(env->current, varName, val) == 0) {
snprintf(errbuf, ERR_MSG_LEN, "error: unable to write to local variable \"%s\".",varName);
addRErrorMsg(errmsg, RE_UNABLE_TO_WRITE_LOCAL_VAR, errbuf);
return newErrorRes(r, RE_UNABLE_TO_WRITE_LOCAL_VAR);
}
} else {
updateInEnv(env, varName, val);
}
return newIntRes(r, 0);
}
return newIntRes(r, 0);
}
ExprType *typeRuleSet( RuleSet *ruleset, rError_t *errmsg, Node **errnode, Region *r ) {
Env *funcDesc = ruleEngineConfig.extFuncDescIndex;
Hashtable *ruleType = newHashTable2( MAX_NUM_RULES * 2, r );
ExprType *res;
int i;
for ( i = 0; i < ruleset->len; i++ ) {
RuleDesc *rule = ruleset->rules[i];
if ( rule->ruleType == RK_REL || rule->ruleType == RK_FUNC ) {
List *typingConstraints = newList( r );
Hashtable *varTypes = newHashTable2( 100, r );
ExprType *restype = typeRule( rule, funcDesc, varTypes, typingConstraints, errmsg, errnode, r );
/*char buf[1024]; */
/*typingConstraintsToString(typingConstraints, buf, 1024); */
/*printf("rule %s, typing constraints: %s\n", ruleset->rules[i]->subtrees[0]->text, buf); */
if ( getNodeType( restype ) == T_ERROR ) {
res = restype;
char *errbuf = ( char * ) malloc( ERR_MSG_LEN * 1024 * sizeof( char ) );
errMsgToString( errmsg, errbuf, ERR_MSG_LEN * 1024 );
#ifdef DEBUG
writeToTmp( "ruleerr.log", errbuf );
writeToTmp( "ruleerr.log", "\n" );
#endif
rodsLog( LOG_ERROR, "%s", errbuf );
free( errbuf );
freeRErrorContent( errmsg );
RETURN;
}
/* check that function names are unique and do not conflict with system msis */
char errbuf[ERR_MSG_LEN];
char *ruleName = rule->node->subtrees[0]->text;
FunctionDesc *fd;
if ( ( fd = ( FunctionDesc * )lookupFromEnv( funcDesc, ruleName ) ) != NULL ) {
if ( getNodeType( fd ) != N_FD_EXTERNAL && getNodeType( fd ) != N_FD_RULE_INDEX_LIST ) {
char *err;
switch ( getNodeType( fd ) ) {
case N_FD_CONSTRUCTOR:
err = "redefinition of constructor";
break;
case N_FD_DECONSTRUCTOR:
err = "redefinition of deconstructor";
break;
case N_FD_FUNCTION:
err = "redefinition of system microservice";
break;
default:
err = "redefinition of system symbol";
break;
}
generateErrMsg( err, NODE_EXPR_POS( rule->node ), rule->node->base, errbuf );
addRErrorMsg( errmsg, RE_FUNCTION_REDEFINITION, errbuf );
res = newErrorType( RE_FUNCTION_REDEFINITION, r );
*errnode = rule->node;
RETURN;
}
}
RuleDesc *rd = ( RuleDesc * )lookupFromHashTable( ruleType, ruleName );
if ( rd != NULL ) {
if ( rule->ruleType == RK_FUNC || rd ->ruleType == RK_FUNC ) {
generateErrMsg( "redefinition of function", NODE_EXPR_POS( rule->node ), rule->node->base, errbuf );
addRErrorMsg( errmsg, RE_FUNCTION_REDEFINITION, errbuf );
generateErrMsg( "previous definition", NODE_EXPR_POS( rd->node ), rd->node->base, errbuf );
addRErrorMsg( errmsg, RE_FUNCTION_REDEFINITION, errbuf );
res = newErrorType( RE_FUNCTION_REDEFINITION, r );
*errnode = rule->node;
RETURN;
}
}
else {
insertIntoHashTable( ruleType, ruleName, rule );
}
}
}
res = newSimpType( T_INT, r ); /* Although a rule set does not have type T_INT, return T_INT to indicate success. */
ret:
return res;
}
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;
}
