int ScopeMapBodyArgs(EvalContext *ctx, const char *scopeid, Rlist *give, const Rlist *take)
{
Rlist *rpg = NULL;
const Rlist *rpt = NULL;
FnCall *fp;
DataType dtg = DATA_TYPE_NONE, dtt = DATA_TYPE_NONE;
char *lval;
void *rval;
int len1, len2;
CfDebug("MapBodyArgs(begin)\n");
len1 = RlistLen(give);
len2 = RlistLen(take);
if (len1 != len2)
{
CfOut(OUTPUT_LEVEL_ERROR, "", " !! Argument mismatch in body template give[+args] = %d, take[-args] = %d", len1, len2);
return false;
}
for (rpg = give, rpt = take; rpg != NULL && rpt != NULL; rpg = rpg->next, rpt = rpt->next)
{
dtg = StringDataType(ctx, scopeid, (char *) rpg->item);
dtt = StringDataType(ctx, scopeid, (char *) rpt->item);
if (dtg != dtt)
{
CfOut(OUTPUT_LEVEL_ERROR, "", "Type mismatch between logical/formal parameters %s/%s\n", (char *) rpg->item,
(char *) rpt->item);
CfOut(OUTPUT_LEVEL_ERROR, "", "%s is %s whereas %s is %s\n", (char *) rpg->item, CF_DATATYPES[dtg],
(char *) rpt->item, CF_DATATYPES[dtt]);
}
switch (rpg->type)
{
case RVAL_TYPE_SCALAR:
lval = (char *) rpt->item;
rval = rpg->item;
CfDebug("MapBodyArgs(SCALAR,%s,%s)\n", lval, (char *) rval);
EvalContextVariablePut(ctx, (VarRef) { NULL, scopeid, lval }, (Rval) { rval, RVAL_TYPE_SCALAR }, dtg);
break;
case RVAL_TYPE_LIST:
lval = (char *) rpt->item;
rval = rpg->item;
EvalContextVariablePut(ctx, (VarRef) { NULL, scopeid, lval }, (Rval) { rval, RVAL_TYPE_LIST }, dtg);
break;
case RVAL_TYPE_FNCALL:
fp = (FnCall *) rpg->item;
dtg = DATA_TYPE_NONE;
{
const FnCallType *fncall_type = FnCallTypeGet(fp->name);
if (fncall_type)
{
dtg = fncall_type->dtype;
}
}
FnCallResult res = FnCallEvaluate(ctx, fp, NULL);
if (res.status == FNCALL_FAILURE && THIS_AGENT_TYPE != AGENT_TYPE_COMMON)
{
// Unresolved variables
if (VERBOSE)
{
printf
(" !! Embedded function argument does not resolve to a name - probably too many evaluation levels for ");
FnCallShow(stdout, fp);
printf(" (try simplifying)\n");
}
}
else
{
FnCallDestroy(fp);
rpg->item = res.rval.item;
rpg->type = res.rval.type;
lval = (char *) rpt->item;
rval = rpg->item;
EvalContextVariablePut(ctx, (VarRef) { NULL, scopeid, lval }, (Rval) {rval, RVAL_TYPE_SCALAR }, dtg);
}
break;
default:
/* Nothing else should happen */
ProgrammingError("Software error: something not a scalar/function in argument literal");
}
}
CfDebug("MapBodyArgs(end)\n");
return true;
}
int ScopeMapBodyArgs(EvalContext *ctx, const char *ns, const char *scope, Rlist *give, const Rlist *take)
{
Rlist *rpg = NULL;
const Rlist *rpt = NULL;
FnCall *fp;
DataType dtg = DATA_TYPE_NONE, dtt = DATA_TYPE_NONE;
char *lval;
void *rval;
int len1, len2;
len1 = RlistLen(give);
len2 = RlistLen(take);
if (len1 != len2)
{
Log(LOG_LEVEL_ERR, "Argument mismatch in body template give[+args] = %d, take[-args] = %d", len1, len2);
return false;
}
for (rpg = give, rpt = take; rpg != NULL && rpt != NULL; rpg = rpg->next, rpt = rpt->next)
{
dtg = StringDataType(ctx, (char *) rpg->item);
dtt = StringDataType(ctx, (char *) rpt->item);
if (dtg != dtt)
{
Log(LOG_LEVEL_ERR, "Type mismatch between logical/formal parameters %s/%s", (char *) rpg->item,
(char *) rpt->item);
Log(LOG_LEVEL_ERR, "%s is %s whereas %s is %s", (char *) rpg->item, DataTypeToString(dtg),
(char *) rpt->item, DataTypeToString(dtt));
}
switch (rpg->type)
{
case RVAL_TYPE_SCALAR:
{
lval = (char *) rpt->item;
rval = rpg->item;
VarRef *ref = VarRefParseFromNamespaceAndScope(lval, ns, scope, CF_NS, '.');
EvalContextVariablePut(ctx, ref, (Rval) { rval, RVAL_TYPE_SCALAR }, dtg);
}
break;
case RVAL_TYPE_LIST:
{
lval = (char *) rpt->item;
rval = rpg->item;
VarRef *ref = VarRefParseFromNamespaceAndScope(lval, ns, scope, CF_NS, '.');
EvalContextVariablePut(ctx, ref, (Rval) { rval, RVAL_TYPE_LIST }, dtg);
VarRefDestroy(ref);
}
break;
case RVAL_TYPE_FNCALL:
fp = (FnCall *) rpg->item;
dtg = DATA_TYPE_NONE;
{
const FnCallType *fncall_type = FnCallTypeGet(fp->name);
if (fncall_type)
{
dtg = fncall_type->dtype;
}
}
FnCallResult res = FnCallEvaluate(ctx, fp, NULL);
if (res.status == FNCALL_FAILURE && THIS_AGENT_TYPE != AGENT_TYPE_COMMON)
{
Log(LOG_LEVEL_VERBOSE, "Embedded function argument does not resolve to a name - probably too many evaluation levels for '%s'",
fp->name);
}
else
{
FnCallDestroy(fp);
rpg->item = res.rval.item;
rpg->type = res.rval.type;
lval = (char *) rpt->item;
rval = rpg->item;
VarRef *ref = VarRefParseFromNamespaceAndScope(lval, ns, scope, CF_NS, '.');
EvalContextVariablePut(ctx, ref, (Rval) {rval, RVAL_TYPE_SCALAR }, dtg);
VarRefDestroy(ref);
}
break;
default:
/* Nothing else should happen */
ProgrammingError("Software error: something not a scalar/function in argument literal");
}
}
return true;
}
int MapBodyArgs(const char *scopeid, Rlist *give, const Rlist *take)
{
Rlist *rpg = NULL;
const Rlist *rpt = NULL;
FnCall *fp;
enum cfdatatype dtg = cf_notype, dtt = cf_notype;
char *lval;
void *rval;
int len1, len2;
CfDebug("MapBodyArgs(begin)\n");
len1 = RlistLen(give);
len2 = RlistLen(take);
if (len1 != len2)
{
CfOut(cf_error, "", " !! Argument mismatch in body template give[+args] = %d, take[-args] = %d", len1, len2);
return false;
}
for (rpg = give, rpt = take; rpg != NULL && rpt != NULL; rpg = rpg->next, rpt = rpt->next)
{
dtg = StringDataType(scopeid, (char *) rpg->item);
dtt = StringDataType(scopeid, (char *) rpt->item);
if (dtg != dtt)
{
CfOut(cf_error, "", "Type mismatch between logical/formal parameters %s/%s\n", (char *) rpg->item,
(char *) rpt->item);
CfOut(cf_error, "", "%s is %s whereas %s is %s\n", (char *) rpg->item, CF_DATATYPES[dtg],
(char *) rpt->item, CF_DATATYPES[dtt]);
}
switch (rpg->type)
{
case CF_SCALAR:
lval = (char *) rpt->item;
rval = rpg->item;
CfDebug("MapBodyArgs(SCALAR,%s,%s)\n", lval, (char *) rval);
AddVariableHash(scopeid, lval, (Rval) {rval, CF_SCALAR}, dtg, NULL, 0);
break;
case CF_LIST:
lval = (char *) rpt->item;
rval = rpg->item;
AddVariableHash(scopeid, lval, (Rval) {rval, CF_LIST}, dtg, NULL, 0);
break;
case CF_FNCALL:
fp = (FnCall *) rpg->item;
dtg = FunctionReturnType(fp->name);
FnCallResult res = EvaluateFunctionCall(fp, NULL);
if (res.status == FNCALL_FAILURE && THIS_AGENT_TYPE != cf_common)
{
// Unresolved variables
if (VERBOSE)
{
printf
(" !! Embedded function argument does not resolve to a name - probably too many evaluation levels for ");
ShowFnCall(stdout, fp);
printf(" (try simplifying)\n");
}
}
else
{
DeleteFnCall(fp);
rpg->item = res.rval.item;
rpg->type = res.rval.rtype;
lval = (char *) rpt->item;
rval = rpg->item;
AddVariableHash(scopeid, lval, (Rval) {rval, CF_SCALAR}, dtg, NULL, 0);
}
break;
default:
/* Nothing else should happen */
FatalError("Software error: something not a scalar/function in argument literal");
}
}
CfDebug("MapBodyArgs(end)\n");
return true;
}
void ScopeMapBodyArgs(EvalContext *ctx, const Body *body, const Rlist *args)
{
const Rlist *arg = NULL;
const Rlist *param = NULL;
for (arg = args, param = body->args; arg != NULL && param != NULL; arg = arg->next, param = param->next)
{
DataType arg_type = CF_DATA_TYPE_NONE;
switch (arg->val.type)
{
case RVAL_TYPE_SCALAR:
arg_type = StringDataType(ctx, RlistScalarValue(arg));
break;
case RVAL_TYPE_FNCALL:
{
const FnCallType *fn = FnCallTypeGet(RlistFnCallValue(arg)->name);
if (!fn)
{
FatalError(ctx, "Argument '%s' given to body '%s' is not a valid function",
RlistFnCallValue(arg)->name, body->name);
}
arg_type = fn->dtype;
}
break;
default:
FatalError(ctx, "Cannot derive data type from Rval type %c", arg->val.type);
}
switch (arg->val.type)
{
case RVAL_TYPE_SCALAR:
{
const char *lval = RlistScalarValue(param);
VarRef *ref = VarRefParseFromNamespaceAndScope(lval, NULL, "body", CF_NS, '.');
EvalContextVariablePut(ctx, ref, RvalScalarValue(arg->val), arg_type, "source=body");
VarRefDestroy(ref);
}
break;
case RVAL_TYPE_LIST:
{
const char *lval = RlistScalarValue(param);
VarRef *ref = VarRefParseFromNamespaceAndScope(lval, NULL, "body", CF_NS, '.');
EvalContextVariablePut(ctx, ref, RvalRlistValue(arg->val), arg_type, "source=body");
VarRefDestroy(ref);
}
break;
case RVAL_TYPE_FNCALL:
{
FnCall *fp = RlistFnCallValue(arg);
arg_type = CF_DATA_TYPE_NONE;
{
const FnCallType *fncall_type = FnCallTypeGet(fp->name);
if (fncall_type)
{
arg_type = fncall_type->dtype;
}
}
FnCallResult res = FnCallEvaluate(ctx, body->parent_policy, fp, NULL);
if (res.status == FNCALL_FAILURE && THIS_AGENT_TYPE != AGENT_TYPE_COMMON)
{
Log(LOG_LEVEL_VERBOSE, "Embedded function argument does not resolve to a name - probably too many evaluation levels for '%s'",
fp->name);
}
else
{
const char *lval = RlistScalarValue(param);
void *rval = res.rval.item;
VarRef *ref = VarRefParseFromNamespaceAndScope(lval, NULL, "body", CF_NS, '.');
EvalContextVariablePut(ctx, ref, rval, arg_type, "source=body");
VarRefDestroy(ref);
}
RvalDestroy(res.rval);
}
break;
default:
/* Nothing else should happen */
ProgrammingError("Software error: something not a scalar/function in argument literal");
}
}
}
void ScopeMapBodyArgs(EvalContext *ctx, const Body *body, const Rlist *args)
{
const Rlist *arg = NULL;
const Rlist *param = NULL;
for (arg = args, param = body->args; arg != NULL && param != NULL; arg = arg->next, param = param->next)
{
DataType arg_type = StringDataType(ctx, RlistScalarValue(arg));
DataType param_type = StringDataType(ctx, RlistScalarValue(param));
if (arg_type != param_type)
{
Log(LOG_LEVEL_ERR, "Type mismatch between logical/formal parameters %s/%s", (char *) arg->item,
(char *) param->item);
Log(LOG_LEVEL_ERR, "%s is %s whereas %s is %s", (char *) arg->item, DataTypeToString(arg_type),
(char *) param->item, DataTypeToString(param_type));
}
switch (arg->type)
{
case RVAL_TYPE_SCALAR:
{
const char *lval = RlistScalarValue(param);
void *rval = arg->item;
VarRef *ref = VarRefParseFromNamespaceAndScope(lval, NULL, "body", CF_NS, '.');
EvalContextVariablePut(ctx, ref, (Rval) { rval, RVAL_TYPE_SCALAR }, arg_type);
}
break;
case RVAL_TYPE_LIST:
{
const char *lval = RlistScalarValue(param->item);
void *rval = arg->item;
VarRef *ref = VarRefParseFromNamespaceAndScope(lval, NULL, "body", CF_NS, '.');
EvalContextVariablePut(ctx, ref, (Rval) { rval, RVAL_TYPE_LIST }, arg_type);
VarRefDestroy(ref);
}
break;
case RVAL_TYPE_FNCALL:
{
FnCall *fp = arg->item;
arg_type = DATA_TYPE_NONE;
{
const FnCallType *fncall_type = FnCallTypeGet(fp->name);
if (fncall_type)
{
arg_type = fncall_type->dtype;
}
}
FnCallResult res = FnCallEvaluate(ctx, fp, NULL);
if (res.status == FNCALL_FAILURE && THIS_AGENT_TYPE != AGENT_TYPE_COMMON)
{
Log(LOG_LEVEL_VERBOSE, "Embedded function argument does not resolve to a name - probably too many evaluation levels for '%s'",
fp->name);
}
else
{
FnCallDestroy(fp);
const char *lval = RlistScalarValue(param);
void *rval = res.rval.item;
VarRef *ref = VarRefParseFromNamespaceAndScope(lval, NULL, "body", CF_NS, '.');
EvalContextVariablePut(ctx, ref, (Rval) {rval, RVAL_TYPE_SCALAR }, res.rval.type);
VarRefDestroy(ref);
}
}
break;
default:
/* Nothing else should happen */
ProgrammingError("Software error: something not a scalar/function in argument literal");
}
}
}
