The command ch_expr is used to change the current expression evaluator.
- interpcom -> ch_expr n
(where n is an integer) will define the n-th expression evaluator as the current one.
The 0-th one is the ordinary one.
The 1-th uses complex numbers. In this case the variable I contains . For instance
- interpcom -> A=2-3*I
defines the variable A containing the complex number .
The next expression evaluators are the supplementary ones.
The command varlist, used to give the list of all the variables of the usual expression evaluator, can also be used to see the variables of all the other ones:
- interpcom -> varlist n
gives the list of all the variables of the n-th expression evaluator, and
- interpcom -> varlist all
gives the list of all the variables of all the expression evaluators.
It is possible to use the variables of new expression evaluators in loops, when the sign of the corresponding numbers has a meaning. For example, in the following program
ch_expr 1 x=4+3*I do i 1 10 x=x+1+I enddo ch_expr 0
the variable in the loop is a complex number. It is possible to let the loop use ordinary variables by using ch_expr inside the loop :
ch_expr 1 x=4+3*I ch_expr 0 do i 1 10 ch_expr 1 x=x+1+I ch_expr 0 enddo
In this case it is still possible to use the variable of the loop inside expressions parsed by other expression evaluators. For example
ch_expr 1 x=1 ch_expr 0 do i 1 10 ch_expr 1 x=x*!(i) ch_expr 0 enddo
(cf. 4.5).
We show now how to call directly a new expression evaluator. This can be useful for instance if one wants to parse the arguments of a new command that needs a different kind of numbers. For this the function
int Evaluate_Gen(int n, char *e, void **res, int *a, flow_data *flow_interp);
is used. Here n is the number of the supplementary expression evaluator (0 for the first), e contains the string that must be evaluated, result[0] will be the address of the result, and flow_interp is the address of the flow_data structure corresponding to the thread from which the function is called. For example
void *result; int dum; result = NULL; Evaluate_Gen(n, "x=2", &result, &dum, flow_interp); /* Makes "x=2" in the additional expression evaluator n */ if (result != NULL) { ... Expreval_ops[n].clear(result); /* frees the memory occupied by the result */ }
Note that in this example, the expression evaluator used in the thread is
flow_interp->expr_ev, corresponding to n =
flow_interp->expr_ev - 2). But it is possible to use a different n.