void MapIteratorsFromRval(EvalContext *ctx, const Bundle *bundle, Rval rval,
Rlist **scalars, Rlist **lists, Rlist **containers)
{
assert(rval.item);
if (rval.item == NULL)
{
return;
}
switch (rval.type)
{
case RVAL_TYPE_SCALAR:
{
char *val = RvalScalarValue(rval);
size_t val_len = strlen(val);
ExpandAndMapIteratorsFromScalar(ctx, bundle, val, val_len, 0, scalars, lists, containers, NULL);
}
break;
case RVAL_TYPE_LIST:
for (const Rlist *rp = RvalRlistValue(rval); rp; rp = rp->next)
{
MapIteratorsFromRval(ctx, bundle, rp->val, scalars, lists, containers);
}
break;
case RVAL_TYPE_FNCALL:
ExpandAndMapIteratorsFromScalar(ctx, bundle, RvalFnCallValue(rval)->name,
strlen(RvalFnCallValue(rval)->name), 0, scalars, lists, containers, NULL);
for (const Rlist *rp = RvalFnCallValue(rval)->args; rp; rp = rp->next)
{
Log(LOG_LEVEL_DEBUG, "Looking at arg for function-like object '%s'", RvalFnCallValue(rval)->name);
MapIteratorsFromRval(ctx, bundle, rp->val, scalars, lists, containers);
}
break;
case RVAL_TYPE_CONTAINER:
case RVAL_TYPE_NOPROMISEE:
Log(LOG_LEVEL_DEBUG, "Unknown Rval type for scope '%s'", bundle->name);
break;
}
}
static void ExpandAndMapIteratorsFromScalar(EvalContext *ctx, const Bundle *bundle, char *string, size_t length,
int level, Rlist **scalars, Rlist **lists,
Rlist **containers, Rlist **full_expansion)
{
assert(string);
if (!string)
{
return;
}
Buffer *value = BufferNew();
for (size_t i = 0; i < length; i++)
{
const char *sp = string + i;
Rlist *tmp_list = NULL;
BufferZero(value);
if (ExtractScalarPrefix(value, sp, length - i))
{
if (full_expansion)
{
RlistConcatInto(&tmp_list, *full_expansion, BufferData(value));
RlistDestroy(*full_expansion);
*full_expansion = tmp_list;
tmp_list = NULL;
}
sp += BufferSize(value);
i += BufferSize(value);
BufferZero(value);
if (i >= length)
{
break;
}
}
if (*sp == '$')
{
BufferZero(value);
ExtractScalarReference(value, sp, length - i, true);
if (BufferSize(value) > 0)
{
Rlist *inner_expansion = NULL;
Rlist *exp = NULL;
int success = 0;
VarRef *ref = VarRefParse(BufferData(value));
int increment = BufferSize(value) - 1 + 3;
// Handle any embedded variables
char *substring = string + i + 2;
ExpandAndMapIteratorsFromScalar(ctx, bundle, substring, BufferSize(value), level+1, scalars, lists, containers, &inner_expansion);
for (exp = inner_expansion; exp != NULL; exp = exp->next)
{
// If a list is non-local, i.e. $(bundle.var), map it to local $(bundle#var)
// NB without modifying variables as we map them, it's not
// possible to handle remote lists referenced by a variable
// scope. For example:
// scope => "test."; var => "somelist"; $($(scope)$(var)) fails
// varname => "test.somelist"; $($(varname)) also fails
// TODO Unless the consumer handles it?
const char *inner_ref_str = RlistScalarValue(exp);
VarRef *inner_ref = VarRefParseFromBundle(inner_ref_str, bundle);
// var is the expanded name of the variable in its native context
// finalname will be the mapped name in the local context "this."
DataType value_type = DATA_TYPE_NONE;
const void *value = EvalContextVariableGet(ctx, inner_ref, &value_type);
if (value)
{
char *mangled_inner_ref = xstrdup(inner_ref_str);
MangleVarRefString(mangled_inner_ref, strlen(mangled_inner_ref));
success++;
switch (DataTypeToRvalType(value_type))
{
case RVAL_TYPE_LIST:
if (level > 0)
{
RlistPrependScalarIdemp(lists, mangled_inner_ref);
}
else
{
RlistAppendScalarIdemp(lists, mangled_inner_ref);
}
if (full_expansion)
{
for (const Rlist *rp = value; rp != NULL; rp = rp->next)
{
// append each slist item to each of full_expansion
RlistConcatInto(&tmp_list, *full_expansion, RlistScalarValue(rp));
}
}
break;
case RVAL_TYPE_SCALAR:
RlistAppendScalarIdemp(scalars, mangled_inner_ref);
if (full_expansion)
{
// append the scalar value to each of full_expansion
RlistConcatInto(&tmp_list, *full_expansion, value);
}
break;
case RVAL_TYPE_CONTAINER:
if (level > 0)
{
RlistPrependScalarIdemp(containers, mangled_inner_ref);
}
else
{
RlistAppendScalarIdemp(containers, mangled_inner_ref);
}
break;
case RVAL_TYPE_FNCALL:
case RVAL_TYPE_NOPROMISEE:
break;
}
free(mangled_inner_ref);
}
VarRefDestroy(inner_ref);
}
RlistDestroy(inner_expansion);
if (full_expansion)
{
RlistDestroy(*full_expansion);
*full_expansion = tmp_list;
tmp_list = NULL;
}
// No need to map this.* even though it's technically qualified
if (success && IsQualifiedVariable(BufferData(value)) && strcmp(ref->scope, "this") != 0)
{
char *dotpos = strchr(substring, '.');
if (dotpos)
{
*dotpos = CF_MAPPEDLIST; // replace '.' with '#'
}
if (strchr(BufferData(value), ':'))
{
char *colonpos = strchr(substring, ':');
if (colonpos)
{
*colonpos = '*';
}
}
}
VarRefDestroy(ref);
sp += increment;
i += increment;
}
}
}
BufferDestroy(value);
}
