/* Helper to replace a connection's expression only if the given string
* parses successfully. Returns 0 on success, non-zero on error. */
static int replace_expression_string(mapper_connection c,
const char *expr_str,
int *input_history_size,
int *output_history_size)
{
mapper_expr expr = mapper_expr_new_from_string(
expr_str, c->props.src_type, c->props.dest_type,
c->props.src_length, c->props.dest_length);
if (!expr)
return 1;
*input_history_size = mapper_expr_input_history_size(expr);
*output_history_size = mapper_expr_output_history_size(expr);
if (c->expr)
mapper_expr_free(c->expr);
c->expr = expr;
if (c->props.expression == expr_str)
return 0;
int len = strlen(expr_str);
if (!c->props.expression || len > strlen(c->props.expression))
c->props.expression = realloc(c->props.expression, len+1);
/* Using strncpy() here causes memory profiling errors due to possible
* overlapping memory (e.g. expr_str == c->props.expression). */
memcpy(c->props.expression, expr_str, len);
c->props.expression[len] = '\0';
return 0;
}
void reallocate_connection_histories(mapper_connection c,
int input_history_size,
int output_history_size)
{
mapper_signal sig = c->parent->signal;
int i, j;
// At least for now, exit if this is an input signal
if (!sig->props.is_output) {
return;
}
// If there is no expression, then no memory needs to be
// reallocated.
if (!c->expr)
return;
if (input_history_size < 1)
input_history_size = 1;
// Reallocate input histories
if (input_history_size > c->parent->history_size) {
size_t sample_size = msig_vector_bytes(sig);
for (i=0; i<sig->props.num_instances; i++) {
mhist_realloc(&c->parent->history[i], input_history_size,
sample_size, 1);
}
c->parent->history_size = input_history_size;
}
else if (input_history_size < c->parent->history_size) {
// Do nothing for now...
// Find maximum input length needed for connections
/*mapper_connection temp = c->parent->connections;
while (c) {
if (c->props.mode == MO_EXPRESSION) {
if (c->expr->input_history_size > input_history_size) {
input_history_size = c->expr->input_history_size;
}
}
c = c->next;
}*/
}
// reallocate output histories
if (output_history_size > c->props.dest_history_size) {
int sample_size = mapper_type_size(c->props.dest_type) * c->props.dest_length;
for (i=0; i<sig->props.num_instances; i++) {
mhist_realloc(&c->history[i], output_history_size, sample_size, 0);
}
c->props.dest_history_size = output_history_size;
}
else if (output_history_size < mapper_expr_output_history_size(c->expr)) {
// Do nothing for now...
}
// reallocate user variable histories
int new_num_vars = mapper_expr_num_variables(c->expr);
if (new_num_vars > c->num_expr_vars) {
for (i=0; i<sig->props.num_instances; i++) {
c->expr_vars[i] = realloc(c->expr_vars[i], new_num_vars *
sizeof(struct _mapper_signal_history));
// initialize new variables...
for (j=c->num_expr_vars; j<new_num_vars; j++) {
c->expr_vars[i][j].type = 'd';
c->expr_vars[i][j].length = 0;
c->expr_vars[i][j].size = 0;
c->expr_vars[i][j].value = 0;
c->expr_vars[i][j].timetag = 0;
c->expr_vars[i][j].position = -1;
}
}
c->num_expr_vars = new_num_vars;
}
else if (new_num_vars < c->num_expr_vars) {
// Do nothing for now...
}
for (i=0; i<sig->props.num_instances; i++) {
for (j=0; j<new_num_vars; j++) {
int history_size = mapper_expr_variable_history_size(c->expr, j);
int vector_length = mapper_expr_variable_vector_length(c->expr, j);
mhist_realloc(c->expr_vars[i]+j, history_size,
vector_length * sizeof(double), 0);
(c->expr_vars[i]+j)->length = vector_length;
(c->expr_vars[i]+j)->size = history_size;
(c->expr_vars[i]+j)->position = -1;
}
}
}
int parse_and_eval(int expectation)
{
// clear output arrays
int i;
for (i = 0; i < DEST_ARRAY_LEN; i++) {
dest_int[i] = 0;
dest_float[i] = 0.0f;
dest_double[i] = 0.0;
}
eprintf("***************** Expression %d *****************\n",
expression_count++);
eprintf("Parsing string '%s'\n", str);
e = mapper_expr_new_from_string(str, num_sources, src_types, src_lengths,
outh.type, outh.length);
if (!e) {
eprintf("Parser FAILED.\n");
goto fail;
}
for (i = 0; i < num_sources; i++) {
inh[i].size = mapper_expr_input_history_size(e, i);
}
outh.size = mapper_expr_output_history_size(e);
if (mapper_expr_num_variables(e) > MAX_VARS) {
eprintf("Maximum variables exceeded.\n");
goto fail;
}
// reallocate variable value histories
for (i = 0; i < e->num_variables; i++) {
eprintf("user_var[%d]: %p\n", i, &user_vars[i]);
mhist_realloc(&user_vars[i], e->variables[i].history_size,
sizeof(double), 0);
}
user_vars_p = user_vars;
#ifdef DEBUG
if (verbose) {
char str[128];
snprintf(str, 128, "Parser returned %d tokens:", e->length);
printexpr(str, e);
}
#endif
token_count += e->length;
eprintf("Try evaluation once... ");
if (!mapper_expr_evaluate(e, inh_p, &user_vars_p, &outh, &tt_in, typestring)) {
eprintf("FAILED.\n");
goto fail;
}
eprintf("OK\n");
then = current_time();
eprintf("Calculate expression %i times... ", iterations);
i = iterations-1;
while (i--) {
mapper_expr_evaluate(e, inh_p, &user_vars_p, &outh, &tt_in, typestring);
}
now = current_time();
eprintf("%g seconds.\n", now-then);
total_elapsed_time += now-then;
if (verbose) {
printf("Got: ");
print_value(typestring, outh.length, outh.value, outh.position);
printf(" \n");
}
else
printf(".");
mapper_expr_free(e);
return expectation != EXPECT_SUCCESS;
fail:
return expectation != EXPECT_FAILURE;
}
