From 981f641ef44fe4d72dcb0e1248a2f96ba53cee69 Mon Sep 17 00:00:00 2001 From: Miller Puckette Date: Sat, 6 Nov 2004 16:07:34 +0000 Subject: 0.38 test 9 (mostly bug fixes) svn path=/trunk/; revision=2226 --- pd/extra/expr~/fts_to_pd.h | 16 +- pd/extra/expr~/makefile | 2 +- pd/extra/expr~/vexp.c | 3432 ++++++++++++++++++++++---------------------- pd/extra/expr~/vexp.h | 258 ++-- pd/extra/expr~/vexp_fun.c | 1590 ++++++++++---------- pd/extra/expr~/vexp_if.c | 1696 +++++++++++----------- 6 files changed, 3497 insertions(+), 3497 deletions(-) (limited to 'pd/extra/expr~') diff --git a/pd/extra/expr~/fts_to_pd.h b/pd/extra/expr~/fts_to_pd.h index 57b0382c..9ca2fc42 100644 --- a/pd/extra/expr~/fts_to_pd.h +++ b/pd/extra/expr~/fts_to_pd.h @@ -14,14 +14,14 @@ permission is granted to use this file for any purpose. typedef t_symbol *fts_symbol_t; #ifdef MSP -#define t_atom Atom -#define t_symbol Symbol -#define pd_new(x) newobject(x); -#define pd_free(x) freeobject(x); -#define t_outlet void -#define t_binbuf void -typedef t_class *t_pd; -typedef float t_floatarg; +#define t_atom Atom +#define t_symbol Symbol +#define pd_new(x) newobject(x); +#define pd_free(x) freeobject(x); +#define t_outlet void +#define t_binbuf void +typedef t_class *t_pd; +typedef float t_floatarg; #include #include diff --git a/pd/extra/expr~/makefile b/pd/extra/expr~/makefile index 042380dd..ff1dae4b 100644 --- a/pd/extra/expr~/makefile +++ b/pd/extra/expr~/makefile @@ -81,7 +81,7 @@ LINUXOBJ = vexp.pd_linux_o vexp_fun.pd_linux_o vexp_if.pd_linux_o LINUXCFLAGS = -DPD -O2 -funroll-loops -fomit-frame-pointer -fPIC \ -Wall -W -Wshadow -Wstrict-prototypes \ - -Wno-unused -Wno-parentheses -Wno-switch $(CFLAGS) + -Wno-unused -Wno-parentheses -Wno-switch LINUXINCLUDE = -I../../src diff --git a/pd/extra/expr~/vexp.c b/pd/extra/expr~/vexp.c index c0001e1f..7d4d7b52 100644 --- a/pd/extra/expr~/vexp.c +++ b/pd/extra/expr~/vexp.c @@ -28,16 +28,16 @@ /* "expr~" and "fexpr~" conversion by Shahrokh Yadegari c. 1999,2000 */ /* - * Feb 2002 - added access to variables - * multiple expression support - * new short hand forms for fexpr~ - * now $y or $y1 = $y1[-1] and $y2 = $y2[-1] - * --sdy + * Feb 2002 - added access to variables + * multiple expression support + * new short hand forms for fexpr~ + * now $y or $y1 = $y1[-1] and $y2 = $y2[-1] + * --sdy * * July 2002 - * fixed bugs introduced in last changes in store and ET_EQ - * --sdy - * + * fixed bugs introduced in last changes in store and ET_EQ + * --sdy + * */ /* @@ -73,7 +73,7 @@ #include "vexp.h" #ifdef MSP #undef isdigit -#define isdigit(x) (x >= '0' && x <= '9') +#define isdigit(x) (x >= '0' && x <= '9') #endif char *atoif(char *s, long int *value, long int *type); @@ -81,30 +81,30 @@ char *atoif(char *s, long int *value, long int *type); static struct ex_ex *ex_lex(struct expr *expr, long int *n); struct ex_ex *ex_match(struct ex_ex *eptr, long int op); struct ex_ex *ex_parse(struct expr *expr, struct ex_ex *iptr, - struct ex_ex *optr, long int *argc); + struct ex_ex *optr, long int *argc); struct ex_ex *ex_eval(struct expr *expr, struct ex_ex *eptr, - struct ex_ex *optr, int i); + struct ex_ex *optr, int i); int expr_donew(struct expr *exprr, int ac, t_atom *av); struct ex_ex *eval_func(struct expr *expr,struct ex_ex *eptr, - struct ex_ex *optr, int i); + struct ex_ex *optr, int i); struct ex_ex *eval_tab(struct expr *expr, struct ex_ex *eptr, - struct ex_ex *optr, int i); + struct ex_ex *optr, int i); struct ex_ex *eval_var(struct expr *expr, struct ex_ex *eptr, - struct ex_ex *optr, int i); + struct ex_ex *optr, int i); struct ex_ex *eval_store(struct expr *expr, struct ex_ex *eptr, - struct ex_ex *optr, int i); + struct ex_ex *optr, int i); struct ex_ex *eval_sigidx(struct expr *expr, struct ex_ex *eptr, - struct ex_ex *optr, int i); -static int cal_sigidx(struct ex_ex *optr, /* The output value */ - int i, float rem_i, /* integer and fractinal part of index */ - int idx, /* index of current fexpr~ processing */ - int vsize, /* vector size */ - float *curvec, float *prevec); /* current and previous table */ + struct ex_ex *optr, int i); +static int cal_sigidx(struct ex_ex *optr, /* The output value */ + int i, float rem_i, /* integer and fractinal part of index */ + int idx, /* index of current fexpr~ processing */ + int vsize, /* vector size */ + float *curvec, float *prevec); /* current and previous table */ t_ex_func *find_func(char *s); void ex_dzdetect(struct expr *expr); -#define MAX_ARGS 10 +#define MAX_ARGS 10 extern t_ex_func ex_funcs[]; struct ex_ex nullex; @@ -181,7 +181,7 @@ void atom_string(t_atom *a, char *buf, unsigned int bufsize) break; case A_DOLLSYM: sprintf(buf, "$%s", a->a_w.w_symbol->s_name); - break; + break; #else /* MAX */ case A_DOLLAR: sprintf(buf, "$%s", a->a_w.w_symbol->s_name); @@ -194,24 +194,24 @@ void atom_string(t_atom *a, char *buf, unsigned int bufsize) #endif /* MSP */ /* * expr_donew -- create a new "expr" object. - * returns 1 on failure, 0 on success. + * returns 1 on failure, 0 on success. */ int expr_donew(struct expr *expr, int ac, t_atom *av) { - struct ex_ex *list; - struct ex_ex *ret; - long max_node = 0; /* maximum number of nodes needed */ - char *exp_string; - int exp_strlen; - t_binbuf *b; - int i; - - memset(expr->exp_var, 0, MAX_VARS * sizeof (*expr->exp_var)); + struct ex_ex *list; + struct ex_ex *ret; + long max_node = 0; /* maximum number of nodes needed */ + char *exp_string; + int exp_strlen; + t_binbuf *b; + int i; + + memset(expr->exp_var, 0, MAX_VARS * sizeof (*expr->exp_var)); #ifdef PD - b = binbuf_new(); - binbuf_add(b, ac, av); - binbuf_gettext(b, &exp_string, &exp_strlen); + b = binbuf_new(); + binbuf_add(b, ac, av); + binbuf_gettext(b, &exp_string, &exp_strlen); #else /* MSP */ { @@ -246,657 +246,657 @@ expr_donew(struct expr *expr, int ac, t_atom *av) exp_strlen = length; } #endif - exp_string = (char *)t_resizebytes(exp_string, exp_strlen,exp_strlen+1); - exp_string[exp_strlen] = 0; - expr->exp_string = exp_string; - expr->exp_str = exp_string; - expr->exp_nexpr = 0; - ret = (struct ex_ex *) 0; - /* - * if ret == 0 it means that we have no expression - * so we let the pass go through to build a single null stack - */ - while (*expr->exp_str || !ret) { - list = ex_lex(expr, &max_node); - if (!list) { /* syntax error */ - goto error; - } - expr->exp_stack[expr->exp_nexpr] = - (struct ex_ex *)fts_malloc(max_node * sizeof (struct ex_ex)); - expr->exp_nexpr++; - ret = ex_match(list, (long)0); - if (!ret) /* syntax error */ - goto error; - ret = ex_parse(expr, - list, expr->exp_stack[expr->exp_nexpr - 1], (long *)0); - if (!ret) - goto error; - } - *ret = nullex; - t_freebytes(exp_string, exp_strlen+1); - return (0); + exp_string = (char *)t_resizebytes(exp_string, exp_strlen,exp_strlen+1); + exp_string[exp_strlen] = 0; + expr->exp_string = exp_string; + expr->exp_str = exp_string; + expr->exp_nexpr = 0; + ret = (struct ex_ex *) 0; + /* + * if ret == 0 it means that we have no expression + * so we let the pass go through to build a single null stack + */ + while (*expr->exp_str || !ret) { + list = ex_lex(expr, &max_node); + if (!list) { /* syntax error */ + goto error; + } + expr->exp_stack[expr->exp_nexpr] = + (struct ex_ex *)fts_malloc(max_node * sizeof (struct ex_ex)); + expr->exp_nexpr++; + ret = ex_match(list, (long)0); + if (!ret) /* syntax error */ + goto error; + ret = ex_parse(expr, + list, expr->exp_stack[expr->exp_nexpr - 1], (long *)0); + if (!ret) + goto error; + } + *ret = nullex; + t_freebytes(exp_string, exp_strlen+1); + return (0); error: - for (i = 0; i < expr->exp_nexpr; i++) { - fts_free(expr->exp_stack[i]); - expr->exp_stack[i] = 0; - } - expr->exp_nexpr = 0; - if (list) - fts_free(list); - t_freebytes(exp_string, exp_strlen+1); - return (1); + for (i = 0; i < expr->exp_nexpr; i++) { + fts_free(expr->exp_stack[i]); + expr->exp_stack[i] = 0; + } + expr->exp_nexpr = 0; + if (list) + fts_free(list); + t_freebytes(exp_string, exp_strlen+1); + return (1); } /* * ex_lex -- This routine is a bit more than a lexical parser since it will - * also do some syntax checking. It reads the string s and will - * return a linked list of struct ex_ex. - * It will also put the number of the nodes in *n. + * also do some syntax checking. It reads the string s and will + * return a linked list of struct ex_ex. + * It will also put the number of the nodes in *n. */ struct ex_ex * ex_lex(struct expr *expr, long int *n) { - struct ex_ex *list_arr; - struct ex_ex *exptr; - long non = 0; /* number of nodes */ - long maxnode = 0; - - list_arr = (struct ex_ex *)fts_malloc(sizeof (struct ex_ex) * MINODES); - if (! list_arr) { - post("ex_lex: no mem\n"); - return ((struct ex_ex *)0); - } - exptr = list_arr; - maxnode = MINODES; - - while (8) - { - if (non >= maxnode) { - maxnode += MINODES; - - list_arr = fts_realloc((void *)list_arr, - sizeof (struct ex_ex) * maxnode); - if (!list_arr) { - post("ex_lex: no mem\n"); - return ((struct ex_ex *)0); - } - exptr = &(list_arr)[non]; - } - - if (getoken(expr, exptr)) { - fts_free(list_arr); - return ((struct ex_ex *)0); - } - non++; - - if (!exptr->ex_type) - break; - - exptr++; - } - *n = non; - - return list_arr; + struct ex_ex *list_arr; + struct ex_ex *exptr; + long non = 0; /* number of nodes */ + long maxnode = 0; + + list_arr = (struct ex_ex *)fts_malloc(sizeof (struct ex_ex) * MINODES); + if (! list_arr) { + post("ex_lex: no mem\n"); + return ((struct ex_ex *)0); + } + exptr = list_arr; + maxnode = MINODES; + + while (8) + { + if (non >= maxnode) { + maxnode += MINODES; + + list_arr = fts_realloc((void *)list_arr, + sizeof (struct ex_ex) * maxnode); + if (!list_arr) { + post("ex_lex: no mem\n"); + return ((struct ex_ex *)0); + } + exptr = &(list_arr)[non]; + } + + if (getoken(expr, exptr)) { + fts_free(list_arr); + return ((struct ex_ex *)0); + } + non++; + + if (!exptr->ex_type) + break; + + exptr++; + } + *n = non; + + return list_arr; } /* * ex_match -- this routine walks through the eptr and matches the * perentheses and brackets, it also converts the function - * names to a pointer to the describing structure of the - * specified function + * names to a pointer to the describing structure of the + * specified function */ /* operator to match */ struct ex_ex * ex_match(struct ex_ex *eptr, long int op) { - int firstone = 1; - struct ex_ex *ret; - t_ex_func *fun; - - for (; 8; eptr++, firstone = 0) { - switch (eptr->ex_type) { - case 0: - if (!op) - return (eptr); - post("expr syntax error: an open %s not matched\n", - op == OP_RP ? "parenthesis" : "bracket"); - return (exNULL); - case ET_INT: - case ET_FLT: - case ET_II: - case ET_FI: - case ET_SI: - case ET_VI: - case ET_SYM: - case ET_VSYM: - continue; - case ET_YO: - if (eptr[1].ex_type != ET_OP || eptr[1].ex_op != OP_LB) - eptr->ex_type = ET_YOM1; - continue; - case ET_XI: - if (eptr[1].ex_type != ET_OP || eptr[1].ex_op != OP_LB) - eptr->ex_type = ET_XI0; - continue; - case ET_TBL: - case ET_FUNC: - case ET_LP: - /* CHANGE - case ET_RP: - */ - case ET_LB: - /* CHANGE - case ET_RB: - */ - post("ex_match: unexpected type, %ld\n", eptr->ex_type); - return (exNULL); - case ET_OP: - if (op == eptr->ex_op) - return (eptr); - /* - * if we are looking for a right peranthesis - * or a right bracket and find the other kind, - * it has to be a syntax error - */ - if ((eptr->ex_op == OP_RP && op == OP_RB) || - (eptr->ex_op == OP_RB && op == OP_RP)) { - post("expr syntax error: prenthesis or brackets not matched\n"); - return (exNULL); - } - /* - * Up to now we have marked the unary minuses as - * subrtacts. Any minus that is the first one in - * chain or is preceeded by anything except ')' and - * ']' is a unary minus. - */ - if (eptr->ex_op == OP_SUB) { - ret = eptr - 1; - if (firstone || (ret->ex_type == ET_OP && - ret->ex_op != OP_RB && ret->ex_op != OP_RP)) - eptr->ex_op = OP_UMINUS; - } else if (eptr->ex_op == OP_LP) { - ret = ex_match(eptr + 1, OP_RP); - if (!ret) - return (ret); - eptr->ex_type = ET_LP; - eptr->ex_ptr = (char *) ret; - eptr = ret; - } else if (eptr->ex_op == OP_LB) { - ret = ex_match(eptr + 1, OP_RB); - if (!ret) - return (ret); - eptr->ex_type = ET_LB; - eptr->ex_ptr = (char *) ret; - eptr = ret; - } - continue; - case ET_STR: - if (eptr[1].ex_op == OP_LB) { - char *tmp; - - eptr->ex_type = ET_TBL; - tmp = eptr->ex_ptr; - if (ex_getsym(tmp, (t_symbol **)&(eptr->ex_ptr))) { - post("expr: syntax error: problms with ex_getsym\n"); - return (exNULL); - } - fts_free((void *)tmp); - } else if (eptr[1].ex_op == OP_LP) { - fun = find_func(eptr->ex_ptr); - if (!fun) { - post( - "expr: error: function %s not found\n", - eptr->ex_ptr); - return (exNULL); - } - eptr->ex_type = ET_FUNC; - eptr->ex_ptr = (char *) fun; - } else { - char *tmp; - - if (eptr[1].ex_type && eptr[1].ex_type!=ET_OP){ - post("expr: syntax error: bad string '%s'\n", eptr->ex_ptr); - return (exNULL); - } - /* it is a variable */ - eptr->ex_type = ET_VAR; - tmp = eptr->ex_ptr; - if (ex_getsym(tmp, - (t_symbol **)&(eptr->ex_ptr))) { - post("expr: variable '%s' not found",tmp); - return (exNULL); - } - } - continue; - default: - post("ex_match: bad type\n"); - return (exNULL); - } - } - /* NOTREACHED */ + int firstone = 1; + struct ex_ex *ret; + t_ex_func *fun; + + for (; 8; eptr++, firstone = 0) { + switch (eptr->ex_type) { + case 0: + if (!op) + return (eptr); + post("expr syntax error: an open %s not matched\n", + op == OP_RP ? "parenthesis" : "bracket"); + return (exNULL); + case ET_INT: + case ET_FLT: + case ET_II: + case ET_FI: + case ET_SI: + case ET_VI: + case ET_SYM: + case ET_VSYM: + continue; + case ET_YO: + if (eptr[1].ex_type != ET_OP || eptr[1].ex_op != OP_LB) + eptr->ex_type = ET_YOM1; + continue; + case ET_XI: + if (eptr[1].ex_type != ET_OP || eptr[1].ex_op != OP_LB) + eptr->ex_type = ET_XI0; + continue; + case ET_TBL: + case ET_FUNC: + case ET_LP: + /* CHANGE + case ET_RP: + */ + case ET_LB: + /* CHANGE + case ET_RB: + */ + post("ex_match: unexpected type, %ld\n", eptr->ex_type); + return (exNULL); + case ET_OP: + if (op == eptr->ex_op) + return (eptr); + /* + * if we are looking for a right peranthesis + * or a right bracket and find the other kind, + * it has to be a syntax error + */ + if ((eptr->ex_op == OP_RP && op == OP_RB) || + (eptr->ex_op == OP_RB && op == OP_RP)) { + post("expr syntax error: prenthesis or brackets not matched\n"); + return (exNULL); + } + /* + * Up to now we have marked the unary minuses as + * subrtacts. Any minus that is the first one in + * chain or is preceeded by anything except ')' and + * ']' is a unary minus. + */ + if (eptr->ex_op == OP_SUB) { + ret = eptr - 1; + if (firstone || (ret->ex_type == ET_OP && + ret->ex_op != OP_RB && ret->ex_op != OP_RP)) + eptr->ex_op = OP_UMINUS; + } else if (eptr->ex_op == OP_LP) { + ret = ex_match(eptr + 1, OP_RP); + if (!ret) + return (ret); + eptr->ex_type = ET_LP; + eptr->ex_ptr = (char *) ret; + eptr = ret; + } else if (eptr->ex_op == OP_LB) { + ret = ex_match(eptr + 1, OP_RB); + if (!ret) + return (ret); + eptr->ex_type = ET_LB; + eptr->ex_ptr = (char *) ret; + eptr = ret; + } + continue; + case ET_STR: + if (eptr[1].ex_op == OP_LB) { + char *tmp; + + eptr->ex_type = ET_TBL; + tmp = eptr->ex_ptr; + if (ex_getsym(tmp, (t_symbol **)&(eptr->ex_ptr))) { + post("expr: syntax error: problms with ex_getsym\n"); + return (exNULL); + } + fts_free((void *)tmp); + } else if (eptr[1].ex_op == OP_LP) { + fun = find_func(eptr->ex_ptr); + if (!fun) { + post( + "expr: error: function %s not found\n", + eptr->ex_ptr); + return (exNULL); + } + eptr->ex_type = ET_FUNC; + eptr->ex_ptr = (char *) fun; + } else { + char *tmp; + + if (eptr[1].ex_type && eptr[1].ex_type!=ET_OP){ + post("expr: syntax error: bad string '%s'\n", eptr->ex_ptr); + return (exNULL); + } + /* it is a variable */ + eptr->ex_type = ET_VAR; + tmp = eptr->ex_ptr; + if (ex_getsym(tmp, + (t_symbol **)&(eptr->ex_ptr))) { + post("expr: variable '%s' not found",tmp); + return (exNULL); + } + } + continue; + default: + post("ex_match: bad type\n"); + return (exNULL); + } + } + /* NOTREACHED */ } /* * ex_parse -- This function if called when we have already done some - * parsing on the expression, and we have already matched - * our brackets and parenthesis. The main job of this - * function is to convert the infix expression to the - * prefix form. - * First we find the operator with the lowest precedence and - * put it on the stack ('optr', it is really just an array), then - * we call ourself (ex_parse()), on its arguments (unary operators - * only have one operator.) - * When "argc" is set it means that we are parsing the arguments - * of a function and we will increment *argc anytime we find - * a a segment that can qualify as an argument (counting commas). + * parsing on the expression, and we have already matched + * our brackets and parenthesis. The main job of this + * function is to convert the infix expression to the + * prefix form. + * First we find the operator with the lowest precedence and + * put it on the stack ('optr', it is really just an array), then + * we call ourself (ex_parse()), on its arguments (unary operators + * only have one operator.) + * When "argc" is set it means that we are parsing the arguments + * of a function and we will increment *argc anytime we find + * a a segment that can qualify as an argument (counting commas). * - * returns 0 on syntax error + * returns 0 on syntax error */ /* number of argument separated by comma */ struct ex_ex * ex_parse(struct expr *x, struct ex_ex *iptr, struct ex_ex *optr, long int *argc) { - struct ex_ex *eptr; - struct ex_ex *lowpre = 0; /* pointer to the lowest precedence */ - struct ex_ex savex; - long pre = HI_PRE; - long count; - - if (!iptr) { - post("ex_parse: input is null, iptr = 0x%lx\n", iptr); - return (exNULL); - } - if (!iptr->ex_type) - return (exNULL); - - /* - * the following loop finds the lowest precedence operator in the - * the input token list, comma is explicitly checked here since - * that is a special operator and is only legal in functions - */ - for (eptr = iptr, count = 0; eptr->ex_type; eptr++, count++) - switch (eptr->ex_type) { - case ET_SYM: - case ET_VSYM: - if (!argc) { - post("expr: syntax error: symbols allowed for functions only\n"); - ex_print(eptr); - return (exNULL); - } - case ET_INT: - case ET_FLT: - case ET_II: - case ET_FI: - case ET_XI0: - case ET_YOM1: - case ET_VI: - case ET_VAR: - if (!count && !eptr[1].ex_type) { - *optr++ = *eptr; - return (optr); - } - break; - case ET_XI: - case ET_YO: - case ET_SI: - case ET_TBL: - if (eptr[1].ex_type != ET_LB) { - post("expr: syntax error: brackets missing\n"); - ex_print(eptr); - return (exNULL); - } - /* if this table is the only token, parse the table */ - if (!count && - !((struct ex_ex *) eptr[1].ex_ptr)[1].ex_type) { - savex = *((struct ex_ex *) eptr[1].ex_ptr); - *((struct ex_ex *) eptr[1].ex_ptr) = nullex; - *optr++ = *eptr; - lowpre = ex_parse(x, &eptr[2], optr, (long *)0); - *((struct ex_ex *) eptr[1].ex_ptr) = savex; - return(lowpre); - } - eptr = (struct ex_ex *) eptr[1].ex_ptr; - break; - case ET_OP: - if (eptr->ex_op == OP_COMMA) { - if (!argc || !count || !eptr[1].ex_type) { - post("expr: syntax error: illegal comma\n"); - ex_print(eptr[1].ex_type ? eptr : iptr); - return (exNULL); - } - } - if (!eptr[1].ex_type) { - post("expr: syntax error: missing operand\n"); - ex_print(iptr); - return (exNULL); - } - if ((eptr->ex_op & PRE_MASK) <= pre) { - pre = eptr->ex_op & PRE_MASK; - lowpre = eptr; - } - break; - case ET_FUNC: - if (eptr[1].ex_type != ET_LP) { - post("expr: ex_parse: no parenthesis\n"); - return (exNULL); - } - /* if this function is the only token, parse it */ - if (!count && - !((struct ex_ex *) eptr[1].ex_ptr)[1].ex_type) { - long ac; - - if (eptr[1].ex_ptr == (char *) &eptr[2]) { - post("expr: syntax error: missing argument\n"); - ex_print(eptr); - return (exNULL); - } - ac = 0; - savex = *((struct ex_ex *) eptr[1].ex_ptr); - *((struct ex_ex *) eptr[1].ex_ptr) = nullex; - *optr++ = *eptr; - lowpre = ex_parse(x, &eptr[2], optr, &ac); - if (!lowpre) - return (exNULL); - ac++; - if (ac != - ((t_ex_func *)eptr->ex_ptr)->f_argc){ - post("expr: syntax error: function '%s' needs %ld arguments\n", - ((t_ex_func *)eptr->ex_ptr)->f_name, - ((t_ex_func *)eptr->ex_ptr)->f_argc); - return (exNULL); - } - *((struct ex_ex *) eptr[1].ex_ptr) = savex; - return (lowpre); - } - eptr = (struct ex_ex *) eptr[1].ex_ptr; - break; - case ET_LP: - case ET_LB: - if (!count && - !((struct ex_ex *) eptr->ex_ptr)[1].ex_type) { - if (eptr->ex_ptr == (char *)(&eptr[1])) { - post("expr: syntax error: empty '%s'\n", - eptr->ex_type==ET_LP?"()":"[]"); - ex_print(eptr); - return (exNULL); - } - savex = *((struct ex_ex *) eptr->ex_ptr); - *((struct ex_ex *) eptr->ex_ptr) = nullex; - lowpre = ex_parse(x, &eptr[1], optr, (long *)0); - *((struct ex_ex *) eptr->ex_ptr) = savex; - return (lowpre); - } - eptr = (struct ex_ex *)eptr->ex_ptr; - break; - case ET_STR: - default: - ex_print(eptr); - post("expr: ex_parse: type = 0x%lx\n", eptr->ex_type); - return (exNULL); - } - - if (pre == HI_PRE) { - post("expr: syntax error: missing operation\n"); - ex_print(iptr); - return (exNULL); - } - if (count < 2) { - post("expr: syntax error: mission operand\n"); - ex_print(iptr); - return (exNULL); - } - if (count == 2) { - if (lowpre != iptr) { - post("expr: ex_parse: unary operator should be first\n"); - return (exNULL); - } - if (!unary_op(lowpre->ex_op)) { - post("expr: syntax error: not a uniary operator\n"); - ex_print(iptr); - return (exNULL); - } - *optr++ = *lowpre; - eptr = ex_parse(x, &lowpre[1], optr, argc); - return (eptr); - } - if (lowpre == iptr) { - post("expr: syntax error: mission operand\n"); - ex_print(iptr); - return (exNULL); - } - savex = *lowpre; - *lowpre = nullex; - if (savex.ex_op != OP_COMMA) - *optr++ = savex; - else - (*argc)++; - eptr = ex_parse(x, iptr, optr, argc); - if (eptr) { - eptr = ex_parse(x, &lowpre[1], eptr, argc); - *lowpre = savex; - } - return (eptr); + struct ex_ex *eptr; + struct ex_ex *lowpre = 0; /* pointer to the lowest precedence */ + struct ex_ex savex; + long pre = HI_PRE; + long count; + + if (!iptr) { + post("ex_parse: input is null, iptr = 0x%lx\n", iptr); + return (exNULL); + } + if (!iptr->ex_type) + return (exNULL); + + /* + * the following loop finds the lowest precedence operator in the + * the input token list, comma is explicitly checked here since + * that is a special operator and is only legal in functions + */ + for (eptr = iptr, count = 0; eptr->ex_type; eptr++, count++) + switch (eptr->ex_type) { + case ET_SYM: + case ET_VSYM: + if (!argc) { + post("expr: syntax error: symbols allowed for functions only\n"); + ex_print(eptr); + return (exNULL); + } + case ET_INT: + case ET_FLT: + case ET_II: + case ET_FI: + case ET_XI0: + case ET_YOM1: + case ET_VI: + case ET_VAR: + if (!count && !eptr[1].ex_type) { + *optr++ = *eptr; + return (optr); + } + break; + case ET_XI: + case ET_YO: + case ET_SI: + case ET_TBL: + if (eptr[1].ex_type != ET_LB) { + post("expr: syntax error: brackets missing\n"); + ex_print(eptr); + return (exNULL); + } + /* if this table is the only token, parse the table */ + if (!count && + !((struct ex_ex *) eptr[1].ex_ptr)[1].ex_type) { + savex = *((struct ex_ex *) eptr[1].ex_ptr); + *((struct ex_ex *) eptr[1].ex_ptr) = nullex; + *optr++ = *eptr; + lowpre = ex_parse(x, &eptr[2], optr, (long *)0); + *((struct ex_ex *) eptr[1].ex_ptr) = savex; + return(lowpre); + } + eptr = (struct ex_ex *) eptr[1].ex_ptr; + break; + case ET_OP: + if (eptr->ex_op == OP_COMMA) { + if (!argc || !count || !eptr[1].ex_type) { + post("expr: syntax error: illegal comma\n"); + ex_print(eptr[1].ex_type ? eptr : iptr); + return (exNULL); + } + } + if (!eptr[1].ex_type) { + post("expr: syntax error: missing operand\n"); + ex_print(iptr); + return (exNULL); + } + if ((eptr->ex_op & PRE_MASK) <= pre) { + pre = eptr->ex_op & PRE_MASK; + lowpre = eptr; + } + break; + case ET_FUNC: + if (eptr[1].ex_type != ET_LP) { + post("expr: ex_parse: no parenthesis\n"); + return (exNULL); + } + /* if this function is the only token, parse it */ + if (!count && + !((struct ex_ex *) eptr[1].ex_ptr)[1].ex_type) { + long ac; + + if (eptr[1].ex_ptr == (char *) &eptr[2]) { + post("expr: syntax error: missing argument\n"); + ex_print(eptr); + return (exNULL); + } + ac = 0; + savex = *((struct ex_ex *) eptr[1].ex_ptr); + *((struct ex_ex *) eptr[1].ex_ptr) = nullex; + *optr++ = *eptr; + lowpre = ex_parse(x, &eptr[2], optr, &ac); + if (!lowpre) + return (exNULL); + ac++; + if (ac != + ((t_ex_func *)eptr->ex_ptr)->f_argc){ + post("expr: syntax error: function '%s' needs %ld arguments\n", + ((t_ex_func *)eptr->ex_ptr)->f_name, + ((t_ex_func *)eptr->ex_ptr)->f_argc); + return (exNULL); + } + *((struct ex_ex *) eptr[1].ex_ptr) = savex; + return (lowpre); + } + eptr = (struct ex_ex *) eptr[1].ex_ptr; + break; + case ET_LP: + case ET_LB: + if (!count && + !((struct ex_ex *) eptr->ex_ptr)[1].ex_type) { + if (eptr->ex_ptr == (char *)(&eptr[1])) { + post("expr: syntax error: empty '%s'\n", + eptr->ex_type==ET_LP?"()":"[]"); + ex_print(eptr); + return (exNULL); + } + savex = *((struct ex_ex *) eptr->ex_ptr); + *((struct ex_ex *) eptr->ex_ptr) = nullex; + lowpre = ex_parse(x, &eptr[1], optr, (long *)0); + *((struct ex_ex *) eptr->ex_ptr) = savex; + return (lowpre); + } + eptr = (struct ex_ex *)eptr->ex_ptr; + break; + case ET_STR: + default: + ex_print(eptr); + post("expr: ex_parse: type = 0x%lx\n", eptr->ex_type); + return (exNULL); + } + + if (pre == HI_PRE) { + post("expr: syntax error: missing operation\n"); + ex_print(iptr); + return (exNULL); + } + if (count < 2) { + post("expr: syntax error: mission operand\n"); + ex_print(iptr); + return (exNULL); + } + if (count == 2) { + if (lowpre != iptr) { + post("expr: ex_parse: unary operator should be first\n"); + return (exNULL); + } + if (!unary_op(lowpre->ex_op)) { + post("expr: syntax error: not a uniary operator\n"); + ex_print(iptr); + return (exNULL); + } + *optr++ = *lowpre; + eptr = ex_parse(x, &lowpre[1], optr, argc); + return (eptr); + } + if (lowpre == iptr) { + post("expr: syntax error: mission operand\n"); + ex_print(iptr); + return (exNULL); + } + savex = *lowpre; + *lowpre = nullex; + if (savex.ex_op != OP_COMMA) + *optr++ = savex; + else + (*argc)++; + eptr = ex_parse(x, iptr, optr, argc); + if (eptr) { + eptr = ex_parse(x, &lowpre[1], eptr, argc); + *lowpre = savex; + } + return (eptr); } /* * this is the devide zero check for a a non devide operator */ -#define DZC(ARG1,OPR,ARG2) (ARG1 OPR ARG2) - -#define EVAL(OPR); \ -eptr = ex_eval(expr, ex_eval(expr, eptr, &left, idx), &right, idx); \ -switch (left.ex_type) { \ -case ET_INT: \ - switch(right.ex_type) { \ - case ET_INT: \ - if (optr->ex_type == ET_VEC) { \ - op = optr->ex_vec; \ - scalar = (float)DZC(left.ex_int, OPR, right.ex_int); \ - for (j = 0; j < expr->exp_vsize; j++) \ - *op++ = scalar; \ - } else { \ - optr->ex_type = ET_INT; \ - optr->ex_int = DZC(left.ex_int, OPR, right.ex_int); \ - } \ - break; \ - case ET_FLT: \ - if (optr->ex_type == ET_VEC) { \ - op = optr->ex_vec; \ - scalar = DZC(((float)left.ex_int), OPR, right.ex_flt);\ - for (j = 0; j < expr->exp_vsize; j++) \ - *op++ = scalar; \ - } else { \ - optr->ex_type = ET_FLT; \ - optr->ex_flt = DZC(((float)left.ex_int), OPR, \ - right.ex_flt); \ - } \ - break; \ - case ET_VEC: \ - case ET_VI: \ - if (optr->ex_type != ET_VEC) { \ - if (optr->ex_type == ET_VI) { \ - post("expr~: Int. error %d", __LINE__); \ - abort(); \ - } \ - optr->ex_type = ET_VEC; \ - optr->ex_vec = (t_float *) \ - fts_malloc(sizeof (t_float)*expr->exp_vsize); \ - } \ - scalar = left.ex_int; \ - rp = right.ex_vec; \ - op = optr->ex_vec; \ - for (i = 0; i < expr->exp_vsize; i++) { \ - *op++ = DZC (scalar, OPR, *rp); \ - rp++; \ - } \ - break; \ - case ET_SYM: \ - default: \ - post_error((fts_object_t *) expr, \ - "expr: ex_eval(%d): bad right type %ld\n", \ - __LINE__, right.ex_type); \ - nullret = 1; \ - } \ - break; \ -case ET_FLT: \ - switch(right.ex_type) { \ - case ET_INT: \ - if (optr->ex_type == ET_VEC) { \ - op = optr->ex_vec; \ - scalar = DZC((float) left.ex_flt, OPR, right.ex_int); \ - for (j = 0; j < expr->exp_vsize; j++) \ - *op++ = scalar; \ - } else { \ - optr->ex_type = ET_FLT; \ - optr->ex_flt = DZC(left.ex_flt, OPR, right.ex_int); \ - } \ - break; \ - case ET_FLT: \ - if (optr->ex_type == ET_VEC) { \ - op = optr->ex_vec; \ - scalar = DZC(left.ex_flt, OPR, right.ex_flt); \ - for (j = 0; j < expr->exp_vsize; j++) \ - *op++ = scalar; \ - } else { \ - optr->ex_type = ET_FLT; \ - optr->ex_flt= DZC(left.ex_flt, OPR, right.ex_flt); \ - } \ - break; \ - case ET_VEC: \ - case ET_VI: \ - if (optr->ex_type != ET_VEC) { \ - if (optr->ex_type == ET_VI) { \ - post("expr~: Int. error %d", __LINE__); \ - abort(); \ - } \ - optr->ex_type = ET_VEC; \ - optr->ex_vec = (t_float *) \ - fts_malloc(sizeof (t_float)*expr->exp_vsize); \ - } \ - scalar = left.ex_flt; \ - rp = right.ex_vec; \ - op = optr->ex_vec; \ - for (i = 0; i < expr->exp_vsize; i++) { \ - *op++ = DZC(scalar, OPR, *rp); \ - rp++; \ - } \ - break; \ - case ET_SYM: \ - default: \ - post_error((fts_object_t *) expr, \ - "expr: ex_eval(%d): bad right type %ld\n", \ - __LINE__, right.ex_type); \ - nullret = 1; \ - } \ - break; \ -case ET_VEC: \ -case ET_VI: \ - if (optr->ex_type != ET_VEC) { \ - if (optr->ex_type == ET_VI) { \ - post("expr~: Int. error %d", __LINE__); \ - abort(); \ - } \ - optr->ex_type = ET_VEC; \ - optr->ex_vec = (t_float *) \ - fts_malloc(sizeof (t_float)*expr->exp_vsize); \ - } \ - op = optr->ex_vec; \ - lp = left.ex_vec; \ - switch(right.ex_type) { \ - case ET_INT: \ - scalar = right.ex_int; \ - for (i = 0; i < expr->exp_vsize; i++) { \ - *op++ = DZC(*lp, OPR, scalar); \ - lp++; \ - } \ - break; \ - case ET_FLT: \ - scalar = right.ex_flt; \ - for (i = 0; i < expr->exp_vsize; i++) { \ - *op++ = DZC(*lp, OPR, scalar); \ - lp++; \ - } \ - break; \ - case ET_VEC: \ - case ET_VI: \ - rp = right.ex_vec; \ - for (i = 0; i < expr->exp_vsize; i++) { \ - /* \ - * on a RISC processor one could copy \ - * 8 times in each round to get a considerable \ - * improvement \ - */ \ - *op++ = DZC(*lp, OPR, *rp); \ - rp++; lp++; \ - } \ - break; \ - case ET_SYM: \ - default: \ - post_error((fts_object_t *) expr, \ - "expr: ex_eval(%d): bad right type %ld\n", \ - __LINE__, right.ex_type); \ - nullret = 1; \ - } \ - break; \ -case ET_SYM: \ -default: \ - post_error((fts_object_t *) expr, \ - "expr: ex_eval(%d): bad left type %ld\n", \ - __LINE__, left.ex_type); \ -} \ +#define DZC(ARG1,OPR,ARG2) (ARG1 OPR ARG2) + +#define EVAL(OPR); \ +eptr = ex_eval(expr, ex_eval(expr, eptr, &left, idx), &right, idx); \ +switch (left.ex_type) { \ +case ET_INT: \ + switch(right.ex_type) { \ + case ET_INT: \ + if (optr->ex_type == ET_VEC) { \ + op = optr->ex_vec; \ + scalar = (float)DZC(left.ex_int, OPR, right.ex_int); \ + for (j = 0; j < expr->exp_vsize; j++) \ + *op++ = scalar; \ + } else { \ + optr->ex_type = ET_INT; \ + optr->ex_int = DZC(left.ex_int, OPR, right.ex_int); \ + } \ + break; \ + case ET_FLT: \ + if (optr->ex_type == ET_VEC) { \ + op = optr->ex_vec; \ + scalar = DZC(((float)left.ex_int), OPR, right.ex_flt);\ + for (j = 0; j < expr->exp_vsize; j++) \ + *op++ = scalar; \ + } else { \ + optr->ex_type = ET_FLT; \ + optr->ex_flt = DZC(((float)left.ex_int), OPR, \ + right.ex_flt); \ + } \ + break; \ + case ET_VEC: \ + case ET_VI: \ + if (optr->ex_type != ET_VEC) { \ + if (optr->ex_type == ET_VI) { \ + post("expr~: Int. error %d", __LINE__); \ + abort(); \ + } \ + optr->ex_type = ET_VEC; \ + optr->ex_vec = (t_float *) \ + fts_malloc(sizeof (t_float)*expr->exp_vsize); \ + } \ + scalar = left.ex_int; \ + rp = right.ex_vec; \ + op = optr->ex_vec; \ + for (i = 0; i < expr->exp_vsize; i++) { \ + *op++ = DZC (scalar, OPR, *rp); \ + rp++; \ + } \ + break; \ + case ET_SYM: \ + default: \ + post_error((fts_object_t *) expr, \ + "expr: ex_eval(%d): bad right type %ld\n", \ + __LINE__, right.ex_type); \ + nullret = 1; \ + } \ + break; \ +case ET_FLT: \ + switch(right.ex_type) { \ + case ET_INT: \ + if (optr->ex_type == ET_VEC) { \ + op = optr->ex_vec; \ + scalar = DZC((float) left.ex_flt, OPR, right.ex_int); \ + for (j = 0; j < expr->exp_vsize; j++) \ + *op++ = scalar; \ + } else { \ + optr->ex_type = ET_FLT; \ + optr->ex_flt = DZC(left.ex_flt, OPR, right.ex_int); \ + } \ + break; \ + case ET_FLT: \ + if (optr->ex_type == ET_VEC) { \ + op = optr->ex_vec; \ + scalar = DZC(left.ex_flt, OPR, right.ex_flt); \ + for (j = 0; j < expr->exp_vsize; j++) \ + *op++ = scalar; \ + } else { \ + optr->ex_type = ET_FLT; \ + optr->ex_flt= DZC(left.ex_flt, OPR, right.ex_flt); \ + } \ + break; \ + case ET_VEC: \ + case ET_VI: \ + if (optr->ex_type != ET_VEC) { \ + if (optr->ex_type == ET_VI) { \ + post("expr~: Int. error %d", __LINE__); \ + abort(); \ + } \ + optr->ex_type = ET_VEC; \ + optr->ex_vec = (t_float *) \ + fts_malloc(sizeof (t_float)*expr->exp_vsize); \ + } \ + scalar = left.ex_flt; \ + rp = right.ex_vec; \ + op = optr->ex_vec; \ + for (i = 0; i < expr->exp_vsize; i++) { \ + *op++ = DZC(scalar, OPR, *rp); \ + rp++; \ + } \ + break; \ + case ET_SYM: \ + default: \ + post_error((fts_object_t *) expr, \ + "expr: ex_eval(%d): bad right type %ld\n", \ + __LINE__, right.ex_type); \ + nullret = 1; \ + } \ + break; \ +case ET_VEC: \ +case ET_VI: \ + if (optr->ex_type != ET_VEC) { \ + if (optr->ex_type == ET_VI) { \ + post("expr~: Int. error %d", __LINE__); \ + abort(); \ + } \ + optr->ex_type = ET_VEC; \ + optr->ex_vec = (t_float *) \ + fts_malloc(sizeof (t_float)*expr->exp_vsize); \ + } \ + op = optr->ex_vec; \ + lp = left.ex_vec; \ + switch(right.ex_type) { \ + case ET_INT: \ + scalar = right.ex_int; \ + for (i = 0; i < expr->exp_vsize; i++) { \ + *op++ = DZC(*lp, OPR, scalar); \ + lp++; \ + } \ + break; \ + case ET_FLT: \ + scalar = right.ex_flt; \ + for (i = 0; i < expr->exp_vsize; i++) { \ + *op++ = DZC(*lp, OPR, scalar); \ + lp++; \ + } \ + break; \ + case ET_VEC: \ + case ET_VI: \ + rp = right.ex_vec; \ + for (i = 0; i < expr->exp_vsize; i++) { \ + /* \ + * on a RISC processor one could copy \ + * 8 times in each round to get a considerable \ + * improvement \ + */ \ + *op++ = DZC(*lp, OPR, *rp); \ + rp++; lp++; \ + } \ + break; \ + case ET_SYM: \ + default: \ + post_error((fts_object_t *) expr, \ + "expr: ex_eval(%d): bad right type %ld\n", \ + __LINE__, right.ex_type); \ + nullret = 1; \ + } \ + break; \ +case ET_SYM: \ +default: \ + post_error((fts_object_t *) expr, \ + "expr: ex_eval(%d): bad left type %ld\n", \ + __LINE__, left.ex_type); \ +} \ break; /* * evaluate a unary operator, TYPE is applied to float operands */ -#define EVAL_UNARY(OPR, TYPE) \ - eptr = ex_eval(expr, eptr, &left, idx); \ - switch(left.ex_type) { \ - case ET_INT: \ - if (optr->ex_type == ET_VEC) { \ - ex_mkvector(optr->ex_vec,(float)(OPR left.ex_int),\ - expr->exp_vsize);\ - break; \ - } \ - optr->ex_type = ET_INT; \ - optr->ex_int = OPR left.ex_int; \ - break; \ - case ET_FLT: \ - if (optr->ex_type == ET_VEC) { \ - ex_mkvector(optr->ex_vec, OPR (TYPE left.ex_flt),\ - expr->exp_vsize);\ - break; \ - } \ - optr->ex_type = ET_FLT; \ - optr->ex_flt = OPR (TYPE left.ex_flt); \ - break; \ - case ET_VI: \ - case ET_VEC: \ - j = expr->exp_vsize; \ - if (optr->ex_type != ET_VEC) { \ - optr->ex_type = ET_VEC; \ - optr->ex_vec = (t_float *) \ - fts_malloc(sizeof (t_float)*expr->exp_vsize); \ - } \ - op = optr->ex_vec; \ - lp = left.ex_vec; \ - j = expr->exp_vsize; \ - for (i = 0; i < j; i++) \ - *op++ = OPR (TYPE *lp++); \ - break; \ - default: \ - post_error((fts_object_t *) expr, \ - "expr: ex_eval(%d): bad left type %ld\n", \ - __LINE__, left.ex_type); \ - nullret++; \ - } \ - break; +#define EVAL_UNARY(OPR, TYPE) \ + eptr = ex_eval(expr, eptr, &left, idx); \ + switch(left.ex_type) { \ + case ET_INT: \ + if (optr->ex_type == ET_VEC) { \ + ex_mkvector(optr->ex_vec,(float)(OPR left.ex_int),\ + expr->exp_vsize);\ + break; \ + } \ + optr->ex_type = ET_INT; \ + optr->ex_int = OPR left.ex_int; \ + break; \ + case ET_FLT: \ + if (optr->ex_type == ET_VEC) { \ + ex_mkvector(optr->ex_vec, OPR (TYPE left.ex_flt),\ + expr->exp_vsize);\ + break; \ + } \ + optr->ex_type = ET_FLT; \ + optr->ex_flt = OPR (TYPE left.ex_flt); \ + break; \ + case ET_VI: \ + case ET_VEC: \ + j = expr->exp_vsize; \ + if (optr->ex_type != ET_VEC) { \ + optr->ex_type = ET_VEC; \ + optr->ex_vec = (t_float *) \ + fts_malloc(sizeof (t_float)*expr->exp_vsize); \ + } \ + op = optr->ex_vec; \ + lp = left.ex_vec; \ + j = expr->exp_vsize; \ + for (i = 0; i < j; i++) \ + *op++ = OPR (TYPE *lp++); \ + break; \ + default: \ + post_error((fts_object_t *) expr, \ + "expr: ex_eval(%d): bad left type %ld\n", \ + __LINE__, left.ex_type); \ + nullret++; \ + } \ + break; void ex_mkvector(t_float *fp, t_float x, int size) { - while (size--) - *fp++ = x; + while (size--) + *fp++ = x; } /* @@ -905,29 +905,29 @@ ex_mkvector(t_float *fp, t_float x, int size) void ex_dzdetect(struct expr *expr) { - char *etype; - - if (!expr->exp_error & EE_DZ) { - if (IS_EXPR(expr)) - etype = "expr"; - else if (IS_EXPR_TILDE(expr)) - etype = "expr~"; - else if (IS_FEXPR_TILDE(expr)) - etype = "fexpr~"; - else { - post ("expr -- ex_dzdetect internal error"); - etype = ""; - } - post ("%s divide by zero detected", etype); - expr->exp_error |= EE_DZ; - } + char *etype; + + if (!expr->exp_error & EE_DZ) { + if (IS_EXPR(expr)) + etype = "expr"; + else if (IS_EXPR_TILDE(expr)) + etype = "expr~"; + else if (IS_FEXPR_TILDE(expr)) + etype = "fexpr~"; + else { + post ("expr -- ex_dzdetect internal error"); + etype = ""; + } + post ("%s divide by zero detected", etype); + expr->exp_error |= EE_DZ; + } } - + /* * ex_eval -- evaluate the array of prefix expression - * ex_eval returns the pointer to the first unevaluated node - * in the array. This is a recursive routine. + * ex_eval returns the pointer to the first unevaluated node + * in the array. This is a recursive routine. */ /* SDY @@ -944,270 +944,270 @@ ex_eval(struct expr *expr, struct ex_ex *eptr, struct ex_ex *optr, int idx) /* the result pointer */ /* the sample numnber processed for fexpr~ */ { - int i, j; - t_float *lp, *rp, *op; /* left, right, and out pointer to vectors */ - t_float scalar; - int nullret = 0; /* did we have an error */ - struct ex_ex left, right; /* left and right operands */ - - left.ex_type = 0; - left.ex_int = 0; - right.ex_type = 0; - right.ex_int = 0; - - if (!eptr) - return (exNULL); - switch (eptr->ex_type) { - case ET_INT: - if (optr->ex_type == ET_VEC) - ex_mkvector(optr->ex_vec, (float) eptr->ex_int, - expr->exp_vsize); - else - *optr = *eptr; - return (++eptr); - - case ET_FLT: - - if (optr->ex_type == ET_VEC) - ex_mkvector(optr->ex_vec, eptr->ex_flt, expr->exp_vsize); - else - *optr = *eptr; - return (++eptr); - - case ET_SYM: - if (optr->ex_type == ET_VEC) { - post_error((fts_object_t *) expr, - "expr: ex_eval: cannot turn string to vector\n"); - return (exNULL); - } - *optr = *eptr; - return (++eptr); - case ET_II: - if (eptr->ex_int == -1) { - post_error((fts_object_t *) expr, - "expr: ex_eval: inlet number not set\n"); - return (exNULL); - } - if (optr->ex_type == ET_VEC) { - ex_mkvector(optr->ex_vec, - (t_float)expr->exp_var[eptr->ex_int].ex_int, - expr->exp_vsize); - } else { - optr->ex_type = ET_INT; - optr->ex_int = expr->exp_var[eptr->ex_int].ex_int; - } - return (++eptr); - case ET_FI: - if (eptr->ex_int == -1) { - post_error((fts_object_t *) expr, - "expr: ex_eval: inlet number not set\n"); - return (exNULL); - } - if (optr->ex_type == ET_VEC) { - ex_mkvector(optr->ex_vec, - expr->exp_var[eptr->ex_int].ex_flt, expr->exp_vsize); - } else { - optr->ex_type = ET_FLT; - optr->ex_flt = expr->exp_var[eptr->ex_int].ex_flt; - } - return (++eptr); - - case ET_VSYM: - if (optr->ex_type == ET_VEC) { - post_error((fts_object_t *) expr, - "expr: IntErr. vsym in for vec out\n"); - return (exNULL); - } - if (eptr->ex_int == -1) { - post_error((fts_object_t *) expr, - "expr: ex_eval: inlet number not set\n"); - return (exNULL); - } - optr->ex_type = ET_SYM; - optr->ex_ptr = expr->exp_var[eptr->ex_int].ex_ptr; - return(++eptr); - - case ET_VI: - if (optr->ex_type != ET_VEC) - *optr = expr->exp_var[eptr->ex_int]; - else if (optr->ex_vec != expr->exp_var[eptr->ex_int].ex_vec) - memcpy(optr->ex_vec, expr->exp_var[eptr->ex_int].ex_vec, - expr->exp_vsize * sizeof (t_float)); - return(++eptr); - case ET_VEC: - if (optr->ex_type != ET_VEC) { - optr->ex_type = ET_VEC; - optr->ex_vec = eptr->ex_vec; - eptr->ex_type = ET_INT; - eptr->ex_int = 0; - } else if (optr->ex_vec != eptr->ex_vec) { - memcpy(optr->ex_vec, eptr->ex_vec, - expr->exp_vsize * sizeof (t_float)); + int i, j; + t_float *lp, *rp, *op; /* left, right, and out pointer to vectors */ + t_float scalar; + int nullret = 0; /* did we have an error */ + struct ex_ex left, right; /* left and right operands */ + + left.ex_type = 0; + left.ex_int = 0; + right.ex_type = 0; + right.ex_int = 0; + + if (!eptr) + return (exNULL); + switch (eptr->ex_type) { + case ET_INT: + if (optr->ex_type == ET_VEC) + ex_mkvector(optr->ex_vec, (float) eptr->ex_int, + expr->exp_vsize); + else + *optr = *eptr; + return (++eptr); + + case ET_FLT: + + if (optr->ex_type == ET_VEC) + ex_mkvector(optr->ex_vec, eptr->ex_flt, expr->exp_vsize); + else + *optr = *eptr; + return (++eptr); + + case ET_SYM: + if (optr->ex_type == ET_VEC) { + post_error((fts_object_t *) expr, + "expr: ex_eval: cannot turn string to vector\n"); + return (exNULL); + } + *optr = *eptr; + return (++eptr); + case ET_II: + if (eptr->ex_int == -1) { + post_error((fts_object_t *) expr, + "expr: ex_eval: inlet number not set\n"); + return (exNULL); + } + if (optr->ex_type == ET_VEC) { + ex_mkvector(optr->ex_vec, + (t_float)expr->exp_var[eptr->ex_int].ex_int, + expr->exp_vsize); + } else { + optr->ex_type = ET_INT; + optr->ex_int = expr->exp_var[eptr->ex_int].ex_int; + } + return (++eptr); + case ET_FI: + if (eptr->ex_int == -1) { + post_error((fts_object_t *) expr, + "expr: ex_eval: inlet number not set\n"); + return (exNULL); + } + if (optr->ex_type == ET_VEC) { + ex_mkvector(optr->ex_vec, + expr->exp_var[eptr->ex_int].ex_flt, expr->exp_vsize); + } else { + optr->ex_type = ET_FLT; + optr->ex_flt = expr->exp_var[eptr->ex_int].ex_flt; + } + return (++eptr); + + case ET_VSYM: + if (optr->ex_type == ET_VEC) { + post_error((fts_object_t *) expr, + "expr: IntErr. vsym in for vec out\n"); + return (exNULL); + } + if (eptr->ex_int == -1) { + post_error((fts_object_t *) expr, + "expr: ex_eval: inlet number not set\n"); + return (exNULL); + } + optr->ex_type = ET_SYM; + optr->ex_ptr = expr->exp_var[eptr->ex_int].ex_ptr; + return(++eptr); + + case ET_VI: + if (optr->ex_type != ET_VEC) + *optr = expr->exp_var[eptr->ex_int]; + else if (optr->ex_vec != expr->exp_var[eptr->ex_int].ex_vec) + memcpy(optr->ex_vec, expr->exp_var[eptr->ex_int].ex_vec, + expr->exp_vsize * sizeof (t_float)); + return(++eptr); + case ET_VEC: + if (optr->ex_type != ET_VEC) { + optr->ex_type = ET_VEC; + optr->ex_vec = eptr->ex_vec; + eptr->ex_type = ET_INT; + eptr->ex_int = 0; + } else if (optr->ex_vec != eptr->ex_vec) { + memcpy(optr->ex_vec, eptr->ex_vec, + expr->exp_vsize * sizeof (t_float)); /* do we need to free here? or can we free higher up */ /* SDY the next lines do not make sense */ post("calling fts_free\n"); abort(); - fts_free(optr->ex_vec); - optr->ex_type = ET_INT; - eptr->ex_int = 0; - } else { /* this should not happen */ - post("expr int. error, optr->ex_vec = %d",optr->ex_vec); - abort(); - } - return(++eptr); - case ET_XI0: - /* short hand for $x?[0] */ - - /* SDY delete the following check */ - if (!IS_FEXPR_TILDE(expr) || optr->ex_type==ET_VEC) { - post("%d:exp->exp_flags = %d", __LINE__,expr->exp_flags); - abort(); - } - optr->ex_type = ET_FLT; - optr->ex_flt = expr->exp_var[eptr->ex_int].ex_vec[idx]; - return(++eptr); - case ET_YOM1: - /* - * short hand for $y?[-1] - * if we are calculating the first sample of the vector - * we need to look at the previous results buffer - */ - optr->ex_type = ET_FLT; - if (idx == 0) - optr->ex_flt = - expr->exp_p_res[eptr->ex_int][expr->exp_vsize - 1]; - else - optr->ex_flt=expr->exp_tmpres[eptr->ex_int][idx-1]; - return(++eptr); - - case ET_YO: - case ET_XI: - /* SDY delete the following */ - if (!IS_FEXPR_TILDE(expr) || optr->ex_type==ET_VEC) { - post("%d:expr->exp_flags = %d", __LINE__,expr->exp_flags); - abort(); - } - return (eval_sigidx(expr, eptr, optr, idx)); - - case ET_TBL: - case ET_SI: - return (eval_tab(expr, eptr, optr, idx)); - case ET_FUNC: - return (eval_func(expr, eptr, optr, idx)); - case ET_VAR: - return (eval_var(expr, eptr, optr, idx)); - case ET_OP: - break; - case ET_STR: - case ET_LP: - case ET_LB: - default: - post_error((fts_object_t *) expr, - "expr: ex_eval: unexpected type %d\n", eptr->ex_type); - return (exNULL); - } - if (!eptr[1].ex_type) { - post_error((fts_object_t *) expr, - "expr: ex_eval: not enough nodes 1\n"); - return (exNULL); - } - if (!unary_op(eptr->ex_op) && !eptr[2].ex_type) { - post_error((fts_object_t *) expr, - "expr: ex_eval: not enough nodes 2\n"); - return (exNULL); - } - - switch((eptr++)->ex_op) { - case OP_STORE: - return (eval_store(expr, eptr, optr, idx)); - case OP_NOT: - EVAL_UNARY(!, +); - case OP_NEG: - EVAL_UNARY(~, (long)); - case OP_UMINUS: - EVAL_UNARY(-, +); - case OP_MUL: - EVAL(*); - case OP_ADD: - EVAL(+); - case OP_SUB: - EVAL(-); - case OP_LT: - EVAL(<); - case OP_LE: - EVAL(<=); - case OP_GT: - EVAL(>); - case OP_GE: - EVAL(>=); - case OP_EQ: - EVAL(==); - case OP_NE: - EVAL(!=); + fts_free(optr->ex_vec); + optr->ex_type = ET_INT; + eptr->ex_int = 0; + } else { /* this should not happen */ + post("expr int. error, optr->ex_vec = %d",optr->ex_vec); + abort(); + } + return(++eptr); + case ET_XI0: + /* short hand for $x?[0] */ + + /* SDY delete the following check */ + if (!IS_FEXPR_TILDE(expr) || optr->ex_type==ET_VEC) { + post("%d:exp->exp_flags = %d", __LINE__,expr->exp_flags); + abort(); + } + optr->ex_type = ET_FLT; + optr->ex_flt = expr->exp_var[eptr->ex_int].ex_vec[idx]; + return(++eptr); + case ET_YOM1: + /* + * short hand for $y?[-1] + * if we are calculating the first sample of the vector + * we need to look at the previous results buffer + */ + optr->ex_type = ET_FLT; + if (idx == 0) + optr->ex_flt = + expr->exp_p_res[eptr->ex_int][expr->exp_vsize - 1]; + else + optr->ex_flt=expr->exp_tmpres[eptr->ex_int][idx-1]; + return(++eptr); + + case ET_YO: + case ET_XI: + /* SDY delete the following */ + if (!IS_FEXPR_TILDE(expr) || optr->ex_type==ET_VEC) { + post("%d:expr->exp_flags = %d", __LINE__,expr->exp_flags); + abort(); + } + return (eval_sigidx(expr, eptr, optr, idx)); + + case ET_TBL: + case ET_SI: + return (eval_tab(expr, eptr, optr, idx)); + case ET_FUNC: + return (eval_func(expr, eptr, optr, idx)); + case ET_VAR: + return (eval_var(expr, eptr, optr, idx)); + case ET_OP: + break; + case ET_STR: + case ET_LP: + case ET_LB: + default: + post_error((fts_object_t *) expr, + "expr: ex_eval: unexpected type %d\n", eptr->ex_type); + return (exNULL); + } + if (!eptr[1].ex_type) { + post_error((fts_object_t *) expr, + "expr: ex_eval: not enough nodes 1\n"); + return (exNULL); + } + if (!unary_op(eptr->ex_op) && !eptr[2].ex_type) { + post_error((fts_object_t *) expr, + "expr: ex_eval: not enough nodes 2\n"); + return (exNULL); + } + + switch((eptr++)->ex_op) { + case OP_STORE: + return (eval_store(expr, eptr, optr, idx)); + case OP_NOT: + EVAL_UNARY(!, +); + case OP_NEG: + EVAL_UNARY(~, (long)); + case OP_UMINUS: + EVAL_UNARY(-, +); + case OP_MUL: + EVAL(*); + case OP_ADD: + EVAL(+); + case OP_SUB: + EVAL(-); + case OP_LT: + EVAL(<); + case OP_LE: + EVAL(<=); + case OP_GT: + EVAL(>); + case OP_GE: + EVAL(>=); + case OP_EQ: + EVAL(==); + case OP_NE: + EVAL(!=); /* * following operators convert their argument to integer */ #undef DZC -#define DZC(ARG1,OPR,ARG2) (((int)ARG1) OPR ((int)ARG2)) - case OP_SL: - EVAL(<<); - case OP_SR: - EVAL(>>); - case OP_AND: - EVAL(&); - case OP_XOR: - EVAL(^); - case OP_OR: - EVAL(|); - case OP_LAND: - EVAL(&&); - case OP_LOR: - EVAL(||); +#define DZC(ARG1,OPR,ARG2) (((int)ARG1) OPR ((int)ARG2)) + case OP_SL: + EVAL(<<); + case OP_SR: + EVAL(>>); + case OP_AND: + EVAL(&); + case OP_XOR: + EVAL(^); + case OP_OR: + EVAL(|); + case OP_LAND: + EVAL(&&); + case OP_LOR: + EVAL(||); /* * for modulo we need to convert to integer and check for divide by zero */ #undef DZC -#define DZC(ARG1,OPR,ARG2) (((ARG2)?(((int)ARG1) OPR ((int)ARG2)) \ - : (ex_dzdetect(expr),0))) - case OP_MOD: - EVAL(%); +#define DZC(ARG1,OPR,ARG2) (((ARG2)?(((int)ARG1) OPR ((int)ARG2)) \ + : (ex_dzdetect(expr),0))) + case OP_MOD: + EVAL(%); /* * define the divide by zero check for divide */ #undef DZC -#define DZC(ARG1,OPR,ARG2) (((ARG2)?(ARG1 OPR ARG2):(ex_dzdetect(expr),0))) - case OP_DIV: - EVAL(/); - case OP_LP: - case OP_RP: - case OP_LB: - case OP_RB: - case OP_COMMA: - case OP_SEMI: - default: - post_error((fts_object_t *) expr, "expr: ex_print: bad op 0x%x\n", eptr->ex_op); - return (exNULL); - } - - - /* - * the left and right nodes could have been transformed to vectors - * down the chain - */ - if (left.ex_type == ET_VEC) - fts_free(left.ex_vec); - if (right.ex_type == ET_VEC) - fts_free(right.ex_vec); - if (nullret) - return (exNULL); - else - return (eptr); +#define DZC(ARG1,OPR,ARG2) (((ARG2)?(ARG1 OPR ARG2):(ex_dzdetect(expr),0))) + case OP_DIV: + EVAL(/); + case OP_LP: + case OP_RP: + case OP_LB: + case OP_RB: + case OP_COMMA: + case OP_SEMI: + default: + post_error((fts_object_t *) expr, "expr: ex_print: bad op 0x%x\n", eptr->ex_op); + return (exNULL); + } + + + /* + * the left and right nodes could have been transformed to vectors + * down the chain + */ + if (left.ex_type == ET_VEC) + fts_free(left.ex_vec); + if (right.ex_type == ET_VEC) + fts_free(right.ex_vec); + if (nullret) + return (exNULL); + else + return (eptr); } /* * eval_func -- evaluate a function, call ex_eval() on all the arguments - * so that all of them are terminal nodes. The call the - * appropriate function + * so that all of them are terminal nodes. The call the + * appropriate function */ struct ex_ex * eval_func(struct expr *expr, struct ex_ex *eptr, struct ex_ex *optr, int idx) @@ -1215,37 +1215,37 @@ eval_func(struct expr *expr, struct ex_ex *eptr, struct ex_ex *optr, int idx) /* the operation stack */ /* the result pointer */ { - int i; - struct ex_ex args[MAX_ARGS]; - t_ex_func *f; - - f = (t_ex_func *)(eptr++)->ex_ptr; - if (!f || !f->f_name) { - return (exNULL); - } - if (f->f_argc > MAX_ARGS) { - post_error((fts_object_t *) expr, "expr: eval_func: asking too many arguments\n"); - return (exNULL); - } - - for (i = 0; i < f->f_argc; i++) { - args[i].ex_type = 0; - args[i].ex_int = 0; - eptr = ex_eval(expr, eptr, &args[i], idx); - } - (*f->f_func)(expr, f->f_argc, args, optr); - for (i = 0; i < f->f_argc; i++) { - if (args[i].ex_type == ET_VEC) - fts_free(args[i].ex_vec); - } - return (eptr); + int i; + struct ex_ex args[MAX_ARGS]; + t_ex_func *f; + + f = (t_ex_func *)(eptr++)->ex_ptr; + if (!f || !f->f_name) { + return (exNULL); + } + if (f->f_argc > MAX_ARGS) { + post_error((fts_object_t *) expr, "expr: eval_func: asking too many arguments\n"); + return (exNULL); + } + + for (i = 0; i < f->f_argc; i++) { + args[i].ex_type = 0; + args[i].ex_int = 0; + eptr = ex_eval(expr, eptr, &args[i], idx); + } + (*f->f_func)(expr, f->f_argc, args, optr); + for (i = 0; i < f->f_argc; i++) { + if (args[i].ex_type == ET_VEC) + fts_free(args[i].ex_vec); + } + return (eptr); } /* * eval_store -- evaluate the '=' operator, - * make sure the first operator is a legal left operator - * and call ex_eval on the right operator + * make sure the first operator is a legal left operator + * and call ex_eval on the right operator */ struct ex_ex * eval_store(struct expr *expr, struct ex_ex *eptr, struct ex_ex *optr, int idx) @@ -1253,11 +1253,11 @@ eval_store(struct expr *expr, struct ex_ex *eptr, struct ex_ex *optr, int idx) /* the operation stack */ /* the result pointer */ { - struct ex_ex arg; - int isvalue; - char *tbl = (char *) 0; - char *var = (char *) 0; - int badleft = 0; + struct ex_ex arg; + int isvalue; + char *tbl = (char *) 0; + char *var = (char *) 0; + int badleft = 0; post("store called\n"); ex_print(eptr); @@ -1265,41 +1265,41 @@ eptr = ex_eval(expr, ++eptr, optr, idx); return (eptr); #ifdef notdef /* SDY */ - arg.ex_type = ET_INT; - arg.ex_int = 0; - if (eptr->ex_type == ET_VAR) { - var = (char *) eptr->ex_ptr; - - eptr = ex_eval(expr, ++eptr, &arg, idx); - (void)max_ex_var_store(expr, (t_symbol *)var, &arg, optr); - if (arg.ex_type == ET_VEC) - fts_free(arg.ex_vec); - } - - - if (eptr->ex_type == ET_SI) { - eptr++; - if (eptr->ex_type = - } - - /* the left operator should either be a value or a array member */ - switch (eptr->ex_type) { - case ET_SI: - if ((eptr + 1)->ex_type == OP_LB) { - } - if (!expr->exp_var[eptr->ex_int].ex_ptr) { - if (!(expr->exp_error & EE_NOTABLE)) { - post("expr: syntax error: no string for inlet %d", eptr->ex_int + 1); - post("expr: No more table errors will be reported"); - post("expr: till the next reset"); - expr->exp_error |= EE_NOTABLE; - } - badleft++; - } else - tbl = (char *) expr->exp_var[eptr->ex_int].ex_ptr; - break; - case ET_TBL: - } + arg.ex_type = ET_INT; + arg.ex_int = 0; + if (eptr->ex_type == ET_VAR) { + var = (char *) eptr->ex_ptr; + + eptr = ex_eval(expr, ++eptr, &arg, idx); + (void)max_ex_var_store(expr, (t_symbol *)var, &arg, optr); + if (arg.ex_type == ET_VEC) + fts_free(arg.ex_vec); + } + + + if (eptr->ex_type == ET_SI) { + eptr++; + if (eptr->ex_type = + } + + /* the left operator should either be a value or a array member */ + switch (eptr->ex_type) { + case ET_SI: + if ((eptr + 1)->ex_type == OP_LB) { + } + if (!expr->exp_var[eptr->ex_int].ex_ptr) { + if (!(expr->exp_error & EE_NOTABLE)) { + post("expr: syntax error: no string for inlet %d", eptr->ex_int + 1); + post("expr: No more table errors will be reported"); + post("expr: till the next reset"); + expr->exp_error |= EE_NOTABLE; + } + badleft++; + } else + tbl = (char *) expr->exp_var[eptr->ex_int].ex_ptr; + break; + case ET_TBL: + } #endif /* SDY */ } @@ -1312,43 +1312,43 @@ eval_tab(struct expr *expr, struct ex_ex *eptr, struct ex_ex *optr, int idx) /* the operation stack */ /* the result pointer */ { - struct ex_ex arg; - char *tbl = (char *) 0; - int notable = 0; - - if (eptr->ex_type == ET_SI) { - if (!expr->exp_var[eptr->ex_int].ex_ptr) { + struct ex_ex arg; + char *tbl = (char *) 0; + int notable = 0; + + if (eptr->ex_type == ET_SI) { + if (!expr->exp_var[eptr->ex_int].ex_ptr) { /* SDY post_error() does not work in MAX/MSP yet - post_error((fts_object_t *) expr, - "expr: syntax error: no string for inlet %d\n", eptr->ex_int + 1); + post_error((fts_object_t *) expr, + "expr: syntax error: no string for inlet %d\n", eptr->ex_int + 1); */ - if (!(expr->exp_error & EE_NOTABLE)) { - post("expr: syntax error: no string for inlet %d", eptr->ex_int + 1); - post("expr: No more table errors will be reported"); - post("expr: till the next reset"); - expr->exp_error |= EE_NOTABLE; - } - notable++; - } else - tbl = (char *) expr->exp_var[eptr->ex_int].ex_ptr; - } else if (eptr->ex_type == ET_TBL) - tbl = (char *) eptr->ex_ptr; - else { - post_error((fts_object_t *) expr, "expr: eval_tbl: bad type %ld\n", eptr->ex_type); - notable++; - - } - arg.ex_type = 0; - arg.ex_int = 0; - eptr = ex_eval(expr, ++eptr, &arg, idx); - - optr->ex_type = ET_INT; - optr->ex_int = 0; - if (!notable) - (void)max_ex_tab(expr, (t_symbol *)tbl, &arg, optr); - if (arg.ex_type == ET_VEC) - fts_free(arg.ex_vec); - return (eptr); + if (!(expr->exp_error & EE_NOTABLE)) { + post("expr: syntax error: no string for inlet %d", eptr->ex_int + 1); + post("expr: No more table errors will be reported"); + post("expr: till the next reset"); + expr->exp_error |= EE_NOTABLE; + } + notable++; + } else + tbl = (char *) expr->exp_var[eptr->ex_int].ex_ptr; + } else if (eptr->ex_type == ET_TBL) + tbl = (char *) eptr->ex_ptr; + else { + post_error((fts_object_t *) expr, "expr: eval_tbl: bad type %ld\n", eptr->ex_type); + notable++; + + } + arg.ex_type = 0; + arg.ex_int = 0; + eptr = ex_eval(expr, ++eptr, &arg, idx); + + optr->ex_type = ET_INT; + optr->ex_int = 0; + if (!notable) + (void)max_ex_tab(expr, (t_symbol *)tbl, &arg, optr); + if (arg.ex_type == ET_VEC) + fts_free(arg.ex_vec); + return (eptr); } /* @@ -1360,38 +1360,38 @@ eval_var(struct expr *expr, struct ex_ex *eptr, struct ex_ex *optr, int idx) /* the operation stack */ /* the result pointer */ { - struct ex_ex arg; - char *var = (char *) 0; - int novar = 0; - - if (eptr->ex_type == ET_SI) { - if (!expr->exp_var[eptr->ex_int].ex_ptr) { + struct ex_ex arg; + char *var = (char *) 0; + int novar = 0; + + if (eptr->ex_type == ET_SI) { + if (!expr->exp_var[eptr->ex_int].ex_ptr) { /* SDY post_error() does not work in MAX/MSP yet post_error((fts_object_t *) expr, "expr: syntax error: no string for inlet %d\n", eptr->ex_int + 1); */ - if (!(expr->exp_error & EE_NOVAR)) { - post("expr: syntax error: no string for inlet %d", eptr->ex_int + 1); - post("expr: No more table errors will be reported"); - post("expr: till the next reset"); - expr->exp_error |= EE_NOVAR; - } - novar++; - } else - var = (char *) expr->exp_var[eptr->ex_int].ex_ptr; - } else if (eptr->ex_type == ET_VAR) - var = (char *) eptr->ex_ptr; - else { - post_error((fts_object_t *) expr, "expr: eval_tbl: bad type %ld\n", eptr->ex_type); - novar++; - - } - - optr->ex_type = ET_INT; - optr->ex_int = 0; - if (!novar) - (void)max_ex_var(expr, (t_symbol *)var, optr); - return (++eptr); + if (!(expr->exp_error & EE_NOVAR)) { + post("expr: syntax error: no string for inlet %d", eptr->ex_int + 1); + post("expr: No more table errors will be reported"); + post("expr: till the next reset"); + expr->exp_error |= EE_NOVAR; + } + novar++; + } else + var = (char *) expr->exp_var[eptr->ex_int].ex_ptr; + } else if (eptr->ex_type == ET_VAR) + var = (char *) eptr->ex_ptr; + else { + post_error((fts_object_t *) expr, "expr: eval_tbl: bad type %ld\n", eptr->ex_type); + novar++; + + } + + optr->ex_type = ET_INT; + optr->ex_int = 0; + if (!novar) + (void)max_ex_var(expr, (t_symbol *)var, optr); + return (++eptr); } /* @@ -1404,148 +1404,148 @@ eval_sigidx(struct expr *expr, struct ex_ex *eptr, struct ex_ex *optr, int idx) /* the result pointer */ /* the index */ { - struct ex_ex arg; - struct ex_ex *reteptr; - int i = 0, j = 0; - float fi = 0, /* index in float */ - rem_i = 0; /* remains of the float */ - char *tbl; - - arg.ex_type = 0; - arg.ex_int = 0; - reteptr = ex_eval(expr, eptr + 1, &arg, idx); - if (arg.ex_type == ET_FLT) { - fi = arg.ex_flt; /* float index */ - i = (int) arg.ex_flt; /* integer index */ - rem_i = arg.ex_flt - i; /* remains of integer */ - } else if (arg.ex_type == ET_INT) { - fi = arg.ex_int; /* float index */ - i = arg.ex_int; - rem_i = 0; - } else { - post("eval_sigidx: bad res type (%d)", arg.ex_type); - } - optr->ex_type = ET_FLT; - /* - * indexing an input vector - */ - if (eptr->ex_type == ET_XI) { - if (fi > 0) { - if (!(expr->exp_error & EE_BI_INPUT)) { - expr->exp_error |= EE_BI_INPUT; - post("expr: input vector index > 0, (vector x%d[%f])", - eptr->ex_int + 1, i + rem_i); - post("fexpr~: index assumed to be = 0"); - post("fexpr~: no error report till next reset"); - ex_print(eptr); - } - /* just replace it with zero */ - i = 0; - rem_i = 0; - } - if (cal_sigidx(optr, i, rem_i, idx, expr->exp_vsize, - expr->exp_var[eptr->ex_int].ex_vec, - expr->exp_p_var[eptr->ex_int])) { - if (!(expr->exp_error & EE_BI_INPUT)) { - expr->exp_error |= EE_BI_INPUT; - post("expr: input vector index < -VectorSize, (vector x%d[%f])", eptr->ex_int + 1, fi); - ex_print(eptr); - post("fexpr~: index assumed to be = -%d", - expr->exp_vsize); - post("fexpr~: no error report till next reset"); - } - } - - /* - * indexing an output vector - */ - } else if (eptr->ex_type == ET_YO) { - /* for output vectors index of zero is not legal */ - if (fi >= 0) { - if (!(expr->exp_error & EE_BI_OUTPUT)) { - expr->exp_error |= EE_BI_OUTPUT; - post("fexpr~: bad output index, (%f)", fi); - ex_print(eptr); - post("fexpr~: no error report till next reset"); - post("fexpr~: index assumed to be = -1"); - } - i = -1; - } - if (eptr->ex_int >= expr->exp_nexpr) { - post("fexpr~: $y%d illegal: not that many exprs", - eptr->ex_int); - optr->ex_flt = 0; - return (reteptr); - } - if (cal_sigidx(optr, i, rem_i, idx, expr->exp_vsize, - expr->exp_tmpres[eptr->ex_int], - expr->exp_p_res[eptr->ex_int])) { - if (!(expr->exp_error & EE_BI_OUTPUT)) { - expr->exp_error |= EE_BI_OUTPUT; - post("fexpr~: bad output index, (%f)", fi); - ex_print(eptr); - post("fexpr~: index assumed to be = -%d", - expr->exp_vsize); - } - } - } else { - optr->ex_flt = 0; - post("fexpr~:eval_sigidx: internal error - unknown vector (%d)", - eptr->ex_type); - } - return (reteptr); + struct ex_ex arg; + struct ex_ex *reteptr; + int i = 0, j = 0; + float fi = 0, /* index in float */ + rem_i = 0; /* remains of the float */ + char *tbl; + + arg.ex_type = 0; + arg.ex_int = 0; + reteptr = ex_eval(expr, eptr + 1, &arg, idx); + if (arg.ex_type == ET_FLT) { + fi = arg.ex_flt; /* float index */ + i = (int) arg.ex_flt; /* integer index */ + rem_i = arg.ex_flt - i; /* remains of integer */ + } else if (arg.ex_type == ET_INT) { + fi = arg.ex_int; /* float index */ + i = arg.ex_int; + rem_i = 0; + } else { + post("eval_sigidx: bad res type (%d)", arg.ex_type); + } + optr->ex_type = ET_FLT; + /* + * indexing an input vector + */ + if (eptr->ex_type == ET_XI) { + if (fi > 0) { + if (!(expr->exp_error & EE_BI_INPUT)) { + expr->exp_error |= EE_BI_INPUT; + post("expr: input vector index > 0, (vector x%d[%f])", + eptr->ex_int + 1, i + rem_i); + post("fexpr~: index assumed to be = 0"); + post("fexpr~: no error report till next reset"); + ex_print(eptr); + } + /* just replace it with zero */ + i = 0; + rem_i = 0; + } + if (cal_sigidx(optr, i, rem_i, idx, expr->exp_vsize, + expr->exp_var[eptr->ex_int].ex_vec, + expr->exp_p_var[eptr->ex_int])) { + if (!(expr->exp_error & EE_BI_INPUT)) { + expr->exp_error |= EE_BI_INPUT; + post("expr: input vector index < -VectorSize, (vector x%d[%f])", eptr->ex_int + 1, fi); + ex_print(eptr); + post("fexpr~: index assumed to be = -%d", + expr->exp_vsize); + post("fexpr~: no error report till next reset"); + } + } + + /* + * indexing an output vector + */ + } else if (eptr->ex_type == ET_YO) { + /* for output vectors index of zero is not legal */ + if (fi >= 0) { + if (!(expr->exp_error & EE_BI_OUTPUT)) { + expr->exp_error |= EE_BI_OUTPUT; + post("fexpr~: bad output index, (%f)", fi); + ex_print(eptr); + post("fexpr~: no error report till next reset"); + post("fexpr~: index assumed to be = -1"); + } + i = -1; + } + if (eptr->ex_int >= expr->exp_nexpr) { + post("fexpr~: $y%d illegal: not that many exprs", + eptr->ex_int); + optr->ex_flt = 0; + return (reteptr); + } + if (cal_sigidx(optr, i, rem_i, idx, expr->exp_vsize, + expr->exp_tmpres[eptr->ex_int], + expr->exp_p_res[eptr->ex_int])) { + if (!(expr->exp_error & EE_BI_OUTPUT)) { + expr->exp_error |= EE_BI_OUTPUT; + post("fexpr~: bad output index, (%f)", fi); + ex_print(eptr); + post("fexpr~: index assumed to be = -%d", + expr->exp_vsize); + } + } + } else { + optr->ex_flt = 0; + post("fexpr~:eval_sigidx: internal error - unknown vector (%d)", + eptr->ex_type); + } + return (reteptr); } /* * cal_sigidx -- given two tables (one current one previous) calculate an * evaluation of a float index into the vectors by linear - * interpolation - * return 0 on success, 1 on failure (index out of bound) + * interpolation + * return 0 on success, 1 on failure (index out of bound) */ static int -cal_sigidx(struct ex_ex *optr, /* The output value */ - int i, float rem_i, /* integer and fractinal part of index */ - int idx, /* index of current fexpr~ processing */ - int vsize, /* vector size */ - float *curvec, float *prevec) /* current and previous table */ +cal_sigidx(struct ex_ex *optr, /* The output value */ + int i, float rem_i, /* integer and fractinal part of index */ + int idx, /* index of current fexpr~ processing */ + int vsize, /* vector size */ + float *curvec, float *prevec) /* current and previous table */ { - int n; - - n = i + idx; - if (n > 0) { - /* from the curvec */ - if (rem_i) - optr->ex_flt = curvec[n] + - rem_i * (curvec[n] - curvec[n - 1]); - else - optr->ex_flt = curvec[n]; - return (0); - } - if (n == 0) { - /* - * this is the case that the remaining float - * is between two tables - */ - if (rem_i) - optr->ex_flt = *curvec + - rem_i * (*curvec - prevec[vsize - 1]); - else - optr->ex_flt = *curvec; - return (0); - } - /* find the index in the saved buffer */ - n = vsize + n; - if (n > 0) { - if (rem_i) - optr->ex_flt = prevec[n] + - rem_i * (prevec[n] - prevec[n - 1]); - else - optr->ex_flt = prevec[n]; - return (0); - } - /* out of bound */ - optr->ex_flt = *prevec; - return (1); + int n; + + n = i + idx; + if (n > 0) { + /* from the curvec */ + if (rem_i) + optr->ex_flt = curvec[n] + + rem_i * (curvec[n] - curvec[n - 1]); + else + optr->ex_flt = curvec[n]; + return (0); + } + if (n == 0) { + /* + * this is the case that the remaining float + * is between two tables + */ + if (rem_i) + optr->ex_flt = *curvec + + rem_i * (*curvec - prevec[vsize - 1]); + else + optr->ex_flt = *curvec; + return (0); + } + /* find the index in the saved buffer */ + n = vsize + n; + if (n > 0) { + if (rem_i) + optr->ex_flt = prevec[n] + + rem_i * (prevec[n] - prevec[n - 1]); + else + optr->ex_flt = prevec[n]; + return (0); + } + /* out of bound */ + optr->ex_flt = *prevec; + return (1); } /* @@ -1554,314 +1554,314 @@ cal_sigidx(struct ex_ex *optr, /* The output value */ int getoken(struct expr *expr, struct ex_ex *eptr) { - char *p; - long i; + char *p; + long i; - if (!expr->exp_str) { - post("expr: getoken: expression string not set\n"); - return (0); - } + if (!expr->exp_str) { + post("expr: getoken: expression string not set\n"); + return (0); + } retry: - if (!*expr->exp_str) { - eptr->ex_type = 0; - eptr->ex_int = 0; - return (0); - } - if (*expr->exp_str == ';') { - expr->exp_str++; - eptr->ex_type = 0; - eptr->ex_int = 0; - return (0); - } - eptr->ex_type = ET_OP; - switch (*expr->exp_str++) { - case '\\': - case ' ': - case '\t': - goto retry; - case ';': - post("expr: syntax error: ';' not implemented\n"); - return (1); - case ',': - eptr->ex_op = OP_COMMA; - break; - case '(': - eptr->ex_op = OP_LP; - break; - case ')': - eptr->ex_op = OP_RP; - break; - case ']': - eptr->ex_op = OP_RB; - break; - case '~': - eptr->ex_op = OP_NEG; - break; - /* we will take care of unary minus later */ - case '*': - eptr->ex_op = OP_MUL; - break; - case '/': - eptr->ex_op = OP_DIV; - break; - case '%': - eptr->ex_op = OP_MOD; - break; - case '+': - eptr->ex_op = OP_ADD; - break; - case '-': - eptr->ex_op = OP_SUB; - break; - case '^': - eptr->ex_op = OP_XOR; - break; - case '[': - eptr->ex_op = OP_LB; - break; - case '!': - if (*expr->exp_str == '=') { - eptr->ex_op = OP_NE; - expr->exp_str++; - } else - eptr->ex_op = OP_NOT; - break; - case '<': - switch (*expr->exp_str) { - case '<': - eptr->ex_op = OP_SL; - expr->exp_str++; - break; - case '=': - eptr->ex_op = OP_LE; - expr->exp_str++; - break; - default: - eptr->ex_op = OP_LT; - break; - } - break; - case '>': - switch (*expr->exp_str) { - case '>': - eptr->ex_op = OP_SR; - expr->exp_str++; - break; - case '=': - eptr->ex_op = OP_GE; - expr->exp_str++; - break; - default: - eptr->ex_op = OP_GT; - break; - } - break; - case '=': - if (*expr->exp_str++ != '=') { - post("expr: syntax error: =\n"); - return (1); - } - eptr->ex_op = OP_EQ; - break; + if (!*expr->exp_str) { + eptr->ex_type = 0; + eptr->ex_int = 0; + return (0); + } + if (*expr->exp_str == ';') { + expr->exp_str++; + eptr->ex_type = 0; + eptr->ex_int = 0; + return (0); + } + eptr->ex_type = ET_OP; + switch (*expr->exp_str++) { + case '\\': + case ' ': + case '\t': + goto retry; + case ';': + post("expr: syntax error: ';' not implemented\n"); + return (1); + case ',': + eptr->ex_op = OP_COMMA; + break; + case '(': + eptr->ex_op = OP_LP; + break; + case ')': + eptr->ex_op = OP_RP; + break; + case ']': + eptr->ex_op = OP_RB; + break; + case '~': + eptr->ex_op = OP_NEG; + break; + /* we will take care of unary minus later */ + case '*': + eptr->ex_op = OP_MUL; + break; + case '/': + eptr->ex_op = OP_DIV; + break; + case '%': + eptr->ex_op = OP_MOD; + break; + case '+': + eptr->ex_op = OP_ADD; + break; + case '-': + eptr->ex_op = OP_SUB; + break; + case '^': + eptr->ex_op = OP_XOR; + break; + case '[': + eptr->ex_op = OP_LB; + break; + case '!': + if (*expr->exp_str == '=') { + eptr->ex_op = OP_NE; + expr->exp_str++; + } else + eptr->ex_op = OP_NOT; + break; + case '<': + switch (*expr->exp_str) { + case '<': + eptr->ex_op = OP_SL; + expr->exp_str++; + break; + case '=': + eptr->ex_op = OP_LE; + expr->exp_str++; + break; + default: + eptr->ex_op = OP_LT; + break; + } + break; + case '>': + switch (*expr->exp_str) { + case '>': + eptr->ex_op = OP_SR; + expr->exp_str++; + break; + case '=': + eptr->ex_op = OP_GE; + expr->exp_str++; + break; + default: + eptr->ex_op = OP_GT; + break; + } + break; + case '=': + if (*expr->exp_str++ != '=') { + post("expr: syntax error: =\n"); + return (1); + } + eptr->ex_op = OP_EQ; + break; /* do not allow the store till the function is fixed - if (*expr->exp_str != '=') - eptr->ex_op = OP_STORE; - else { - expr->exp_str++; - eptr->ex_op = OP_EQ; - } - break; + if (*expr->exp_str != '=') + eptr->ex_op = OP_STORE; + else { + expr->exp_str++; + eptr->ex_op = OP_EQ; + } + break; */ - case '&': - if (*expr->exp_str == '&') { - expr->exp_str++; - eptr->ex_op = OP_LAND; - } else - eptr->ex_op = OP_AND; - break; - - case '|': - if ((*expr->exp_str == '|')) { - expr->exp_str++; - eptr->ex_op = OP_LOR; - } else - eptr->ex_op = OP_OR; - break; - case '$': - switch (*expr->exp_str++) { - case 'I': - case 'i': - eptr->ex_type = ET_II; - break; - case 'F': - case 'f': - eptr->ex_type = ET_FI; - break; - case 'S': - case 's': - eptr->ex_type = ET_SI; - break; - case 'V': - case 'v': - if (IS_EXPR_TILDE(expr)) { - eptr->ex_type = ET_VI; - break; - } - post("$v? works only for expr~"); - post("expr: syntax error: %s\n", &expr->exp_str[-2]); - return (1); - case 'X': - case 'x': - if (IS_FEXPR_TILDE(expr)) { - eptr->ex_type = ET_XI; - if (isdigit(*expr->exp_str)) - break; - /* for $x[] is a shorhand for $x1[] */ - eptr->ex_int = 0; - goto noinletnum; - } - post("$x? works only for fexpr~"); - post("expr: syntax error: %s\n", &expr->exp_str[-2]); - return (1); - case 'y': - case 'Y': - if (IS_FEXPR_TILDE(expr)) { - eptr->ex_type = ET_YO; - /*$y takes no number */ - if (isdigit(*expr->exp_str)) - break; - /* for $y[] is a shorhand for $y1[] */ - eptr->ex_int = 0; - goto noinletnum; - } - post("$y works only for fexpr~"); - default: - post("expr: syntax error: %s\n", &expr->exp_str[-2]); - return (1); - } - p = atoif(expr->exp_str, &eptr->ex_op, &i); - if (!p) { - post("expr: syntax error: %s\n", &expr->exp_str[-2]); - return (1); - } - if (i != ET_INT) { - post("expr: syntax error: %s\n", expr->exp_str); - return (1); - } - /* - * make the user inlets one based rather than zero based - * therefore we decrement the number that user has supplied - */ - if (!eptr->ex_op || (eptr->ex_op)-- > MAX_VARS) { - post("expr: syntax error: inlet or outlet out of range: %s\n", - expr->exp_str); - return (1); - } - - /* - * until we can change the input type of inlets on - * the fly (at pd_new() - * time) the first input to expr~ is always a vectore - * and $f1 or $i1 is - * illegal for fexr~ - */ - if (eptr->ex_op == 0 && - (IS_FEXPR_TILDE(expr) || IS_EXPR_TILDE(expr)) && - (eptr->ex_type==ET_II || eptr->ex_type==ET_FI || - eptr->ex_type==ET_SI)) { - post("first inlet of expr~/fexpr~ can only be a vector"); - return (1); - } - /* record the inlet or outlet type and check for consistency */ - if (eptr->ex_type == ET_YO ) { - /* it is an outlet for fexpr~*/ - /* no need to do anything */ - ; - } else if (!expr->exp_var[eptr->ex_op].ex_type) - expr->exp_var[eptr->ex_op].ex_type = eptr->ex_type; - else if (expr->exp_var[eptr->ex_op].ex_type != eptr->ex_type) { - post("expr: syntax error: inlets can only have one type: %s\n", expr->exp_str); - return (1); - } - expr->exp_str = p; + case '&': + if (*expr->exp_str == '&') { + expr->exp_str++; + eptr->ex_op = OP_LAND; + } else + eptr->ex_op = OP_AND; + break; + + case '|': + if ((*expr->exp_str == '|')) { + expr->exp_str++; + eptr->ex_op = OP_LOR; + } else + eptr->ex_op = OP_OR; + break; + case '$': + switch (*expr->exp_str++) { + case 'I': + case 'i': + eptr->ex_type = ET_II; + break; + case 'F': + case 'f': + eptr->ex_type = ET_FI; + break; + case 'S': + case 's': + eptr->ex_type = ET_SI; + break; + case 'V': + case 'v': + if (IS_EXPR_TILDE(expr)) { + eptr->ex_type = ET_VI; + break; + } + post("$v? works only for expr~"); + post("expr: syntax error: %s\n", &expr->exp_str[-2]); + return (1); + case 'X': + case 'x': + if (IS_FEXPR_TILDE(expr)) { + eptr->ex_type = ET_XI; + if (isdigit(*expr->exp_str)) + break; + /* for $x[] is a shorhand for $x1[] */ + eptr->ex_int = 0; + goto noinletnum; + } + post("$x? works only for fexpr~"); + post("expr: syntax error: %s\n", &expr->exp_str[-2]); + return (1); + case 'y': + case 'Y': + if (IS_FEXPR_TILDE(expr)) { + eptr->ex_type = ET_YO; + /*$y takes no number */ + if (isdigit(*expr->exp_str)) + break; + /* for $y[] is a shorhand for $y1[] */ + eptr->ex_int = 0; + goto noinletnum; + } + post("$y works only for fexpr~"); + default: + post("expr: syntax error: %s\n", &expr->exp_str[-2]); + return (1); + } + p = atoif(expr->exp_str, &eptr->ex_op, &i); + if (!p) { + post("expr: syntax error: %s\n", &expr->exp_str[-2]); + return (1); + } + if (i != ET_INT) { + post("expr: syntax error: %s\n", expr->exp_str); + return (1); + } + /* + * make the user inlets one based rather than zero based + * therefore we decrement the number that user has supplied + */ + if (!eptr->ex_op || (eptr->ex_op)-- > MAX_VARS) { + post("expr: syntax error: inlet or outlet out of range: %s\n", + expr->exp_str); + return (1); + } + + /* + * until we can change the input type of inlets on + * the fly (at pd_new() + * time) the first input to expr~ is always a vectore + * and $f1 or $i1 is + * illegal for fexr~ + */ + if (eptr->ex_op == 0 && + (IS_FEXPR_TILDE(expr) || IS_EXPR_TILDE(expr)) && + (eptr->ex_type==ET_II || eptr->ex_type==ET_FI || + eptr->ex_type==ET_SI)) { + post("first inlet of expr~/fexpr~ can only be a vector"); + return (1); + } + /* record the inlet or outlet type and check for consistency */ + if (eptr->ex_type == ET_YO ) { + /* it is an outlet for fexpr~*/ + /* no need to do anything */ + ; + } else if (!expr->exp_var[eptr->ex_op].ex_type) + expr->exp_var[eptr->ex_op].ex_type = eptr->ex_type; + else if (expr->exp_var[eptr->ex_op].ex_type != eptr->ex_type) { + post("expr: syntax error: inlets can only have one type: %s\n", expr->exp_str); + return (1); + } + expr->exp_str = p; noinletnum: - break; - case '"': - { - struct ex_ex ex; - - p = expr->exp_str; - if (!*expr->exp_str || *expr->exp_str == '"') { - post("expr: syntax error: empty symbol: %s\n", --expr->exp_str); - return (1); - } - if (getoken(expr, &ex)) - return (1); - switch (ex.ex_type) { - case ET_STR: - if (ex_getsym(ex.ex_ptr, (t_symbol **)&(eptr->ex_ptr))) { - post("expr: syntax error: getoken: problms with ex_getsym\n"); - return (1); - } - eptr->ex_type = ET_SYM; - break; - case ET_SI: - *eptr = ex; - eptr->ex_type = ET_VSYM; - break; - default: - post("expr: syntax error: bad symbol name: %s\n", p); - return (1); - } - if (*expr->exp_str++ != '"') { - post("expr: syntax error: missing '\"'\n"); - return (1); - } - break; - } - case '.': - case '0': - case '1': - case '2': - case '3': - case '4': - case '5': - case '6': - case '7': - case '8': - case '9': - p = atoif(--expr->exp_str, &eptr->ex_int, &eptr->ex_type); - if (!p) - return (1); - expr->exp_str = p; - break; - - default: - /* - * has to be a string, it should either be a - * function or a table - */ - p = --expr->exp_str; - for (i = 0; name_ok(*p); i++) - p++; - if (!i) { - post("expr: syntax error: %s\n", expr->exp_str); - return (1); - } - eptr->ex_ptr = (char *)fts_malloc(i + 1); - strncpy(eptr->ex_ptr, expr->exp_str, (int) i); - (eptr->ex_ptr)[i] = 0; - expr->exp_str = p; - /* - * we mark this as a string and later we will change this - * to either a function or a table - */ - eptr->ex_type = ET_STR; - break; - } - return (0); + break; + case '"': + { + struct ex_ex ex; + + p = expr->exp_str; + if (!*expr->exp_str || *expr->exp_str == '"') { + post("expr: syntax error: empty symbol: %s\n", --expr->exp_str); + return (1); + } + if (getoken(expr, &ex)) + return (1); + switch (ex.ex_type) { + case ET_STR: + if (ex_getsym(ex.ex_ptr, (t_symbol **)&(eptr->ex_ptr))) { + post("expr: syntax error: getoken: problms with ex_getsym\n"); + return (1); + } + eptr->ex_type = ET_SYM; + break; + case ET_SI: + *eptr = ex; + eptr->ex_type = ET_VSYM; + break; + default: + post("expr: syntax error: bad symbol name: %s\n", p); + return (1); + } + if (*expr->exp_str++ != '"') { + post("expr: syntax error: missing '\"'\n"); + return (1); + } + break; + } + case '.': + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + p = atoif(--expr->exp_str, &eptr->ex_int, &eptr->ex_type); + if (!p) + return (1); + expr->exp_str = p; + break; + + default: + /* + * has to be a string, it should either be a + * function or a table + */ + p = --expr->exp_str; + for (i = 0; name_ok(*p); i++) + p++; + if (!i) { + post("expr: syntax error: %s\n", expr->exp_str); + return (1); + } + eptr->ex_ptr = (char *)fts_malloc(i + 1); + strncpy(eptr->ex_ptr, expr->exp_str, (int) i); + (eptr->ex_ptr)[i] = 0; + expr->exp_str = p; + /* + * we mark this as a string and later we will change this + * to either a function or a table + */ + eptr->ex_type = ET_STR; + break; + } + return (0); } /* @@ -1870,100 +1870,100 @@ noinletnum: char * atoif(char *s, long int *value, long int *type) { - char *p; - long int_val = 0; - int flt = 0; - float pos = 0; - float flt_val = 0; - int base = 10; - - p = s; - if (*p == '0' && (p[1] == 'x' || p[1] == 'X')) { - base = 16; - p += 2; - } - while (8) { - switch (*p) { - case '.': - if (flt || base != 10) { - post("expr: syntax error: %s\n", s); - return ((char *) 0); - } - flt++; - pos = 10; - flt_val = int_val; - break; - case '0': - case '1': - case '2': - case '3': - case '4': - case '5': - case '6': - case '7': - case '8': - case '9': - if (flt) { - flt_val += (*p - '0') / pos; - pos *= 10; - } else { - int_val *= base; - int_val += (*p - '0'); - } - break; - case 'a': - case 'b': - case 'c': - case 'd': - case 'e': - case 'f': - if (base != 16 || flt) { - post("expr: syntax error: %s\n", s); - return ((char *) 0); - } - int_val *= base; - int_val += (*p - 'a' + 10); - break; - case 'A': - case 'B': - case 'C': - case 'D': - case 'E': - case 'F': - if (base != 16 || flt) { - post("expr: syntax error: %s\n", s); - return ((char *) 0); - } - int_val *= base; - int_val += (*p - 'A' + 10); - break; - default: - if (flt) { - *type = ET_FLT; - *((float *) value) = flt_val; - } else { - *type = ET_INT; - *value = int_val; - } - return (p); - } - p++; - } + char *p; + long int_val = 0; + int flt = 0; + float pos = 0; + float flt_val = 0; + int base = 10; + + p = s; + if (*p == '0' && (p[1] == 'x' || p[1] == 'X')) { + base = 16; + p += 2; + } + while (8) { + switch (*p) { + case '.': + if (flt || base != 10) { + post("expr: syntax error: %s\n", s); + return ((char *) 0); + } + flt++; + pos = 10; + flt_val = int_val; + break; + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + if (flt) { + flt_val += (*p - '0') / pos; + pos *= 10; + } else { + int_val *= base; + int_val += (*p - '0'); + } + break; + case 'a': + case 'b': + case 'c': + case 'd': + case 'e': + case 'f': + if (base != 16 || flt) { + post("expr: syntax error: %s\n", s); + return ((char *) 0); + } + int_val *= base; + int_val += (*p - 'a' + 10); + break; + case 'A': + case 'B': + case 'C': + case 'D': + case 'E': + case 'F': + if (base != 16 || flt) { + post("expr: syntax error: %s\n", s); + return ((char *) 0); + } + int_val *= base; + int_val += (*p - 'A' + 10); + break; + default: + if (flt) { + *type = ET_FLT; + *((float *) value) = flt_val; + } else { + *type = ET_INT; + *value = int_val; + } + return (p); + } + p++; + } } /* * find_func -- returns a pointer to the found function structure - * otherwise it returns 0 + * otherwise it returns 0 */ t_ex_func * find_func(char *s) { - t_ex_func *f; + t_ex_func *f; - for (f = ex_funcs; f->f_name; f++) - if (!strcmp(f->f_name, s)) - return (f); - return ((t_ex_func *) 0); + for (f = ex_funcs; f->f_name; f++) + if (!strcmp(f->f_name, s)) + return (f); + return ((t_ex_func *) 0); } @@ -1975,166 +1975,166 @@ void ex_print(struct ex_ex *eptr) { - while (eptr->ex_type) { - switch (eptr->ex_type) { - case ET_INT: - post("%ld ", eptr->ex_int); - break; - case ET_FLT: - post("%f ", eptr->ex_flt); - break; - case ET_STR: - post("%s ", eptr->ex_ptr); - break; - case ET_TBL: - case ET_VAR: - post("%s ", ex_symname((fts_symbol_t )eptr->ex_ptr)); - break; - case ET_SYM: - post("\"%s\" ", ex_symname((fts_symbol_t )eptr->ex_ptr)); - break; - case ET_VSYM: - post("\"$s%ld\" ", eptr->ex_int + 1); - break; - case ET_FUNC: - post("%s ", - ((t_ex_func *)eptr->ex_ptr)->f_name); - break; - case ET_LP: - post("%c", '('); - break; - /* CHANGE - case ET_RP: - post("%c ", ')'); - break; - */ - case ET_LB: - post("%c", '['); - break; - /* CHANGE - case ET_RB: - post("%c ", ']'); - break; - */ - case ET_II: - post("$i%ld ", eptr->ex_int + 1); - break; - case ET_FI: - post("$f%ld ", eptr->ex_int + 1); - break; - case ET_SI: - post("$s%lx ", eptr->ex_ptr); - break; - case ET_VI: - post("$v%lx ", eptr->ex_vec); - break; - case ET_VEC: - post("vec = %ld ", eptr->ex_vec); - break; - case ET_YOM1: - case ET_YO: - post("$y%d", eptr->ex_int + 1); - break; - case ET_XI: - case ET_XI0: - post("$x%d", eptr->ex_int + 1); - break; - case ET_OP: - switch (eptr->ex_op) { - case OP_LP: - post("%c", '('); - break; - case OP_RP: - post("%c ", ')'); - break; - case OP_LB: - post("%c", '['); - break; - case OP_RB: - post("%c ", ']'); - break; - case OP_NOT: - post("%c", '!'); - break; - case OP_NEG: - post("%c", '~'); - break; - case OP_UMINUS: - post("%c", '-'); - break; - case OP_MUL: - post("%c", '*'); - break; - case OP_DIV: - post("%c", '/'); - break; - case OP_MOD: - post("%c", '%'); - break; - case OP_ADD: - post("%c", '+'); - break; - case OP_SUB: - post("%c", '-'); - break; - case OP_SL: - post("%s", "<<"); - break; - case OP_SR: - post("%s", ">>"); - break; - case OP_LT: - post("%c", '<'); - break; - case OP_LE: - post("%s", "<="); - break; - case OP_GT: - post("%c", '>'); - break; - case OP_GE: - post("%s", ">="); - break; - case OP_EQ: - post("%s", "=="); - break; - case OP_STORE: - post("%s", "="); - break; - case OP_NE: - post("%s", "!="); - break; - case OP_AND: - post("%c", '&'); - break; - case OP_XOR: - post("%c", '^'); - break; - case OP_OR: - post("%c", '|'); - break; - case OP_LAND: - post("%s", "&&"); - break; - case OP_LOR: - post("%s", "||"); - break; - case OP_COMMA: - post("%c", ','); - break; - case OP_SEMI: - post("%c", ';'); - break; - default: - post("expr: ex_print: bad op 0x%lx\n", eptr->ex_op); - } - break; - default: - post("expr: ex_print: bad type 0x%lx\n", eptr->ex_type); - } - eptr++; - } - post("\n"); + while (eptr->ex_type) { + switch (eptr->ex_type) { + case ET_INT: + post("%ld ", eptr->ex_int); + break; + case ET_FLT: + post("%f ", eptr->ex_flt); + break; + case ET_STR: + post("%s ", eptr->ex_ptr); + break; + case ET_TBL: + case ET_VAR: + post("%s ", ex_symname((fts_symbol_t )eptr->ex_ptr)); + break; + case ET_SYM: + post("\"%s\" ", ex_symname((fts_symbol_t )eptr->ex_ptr)); + break; + case ET_VSYM: + post("\"$s%ld\" ", eptr->ex_int + 1); + break; + case ET_FUNC: + post("%s ", + ((t_ex_func *)eptr->ex_ptr)->f_name); + break; + case ET_LP: + post("%c", '('); + break; + /* CHANGE + case ET_RP: + post("%c ", ')'); + break; + */ + case ET_LB: + post("%c", '['); + break; + /* CHANGE + case ET_RB: + post("%c ", ']'); + break; + */ + case ET_II: + post("$i%ld ", eptr->ex_int + 1); + break; + case ET_FI: + post("$f%ld ", eptr->ex_int + 1); + break; + case ET_SI: + post("$s%lx ", eptr->ex_ptr); + break; + case ET_VI: + post("$v%lx ", eptr->ex_vec); + break; + case ET_VEC: + post("vec = %ld ", eptr->ex_vec); + break; + case ET_YOM1: + case ET_YO: + post("$y%d", eptr->ex_int + 1); + break; + case ET_XI: + case ET_XI0: + post("$x%d", eptr->ex_int + 1); + break; + case ET_OP: + switch (eptr->ex_op) { + case OP_LP: + post("%c", '('); + break; + case OP_RP: + post("%c ", ')'); + break; + case OP_LB: + post("%c", '['); + break; + case OP_RB: + post("%c ", ']'); + break; + case OP_NOT: + post("%c", '!'); + break; + case OP_NEG: + post("%c", '~'); + break; + case OP_UMINUS: + post("%c", '-'); + break; + case OP_MUL: + post("%c", '*'); + break; + case OP_DIV: + post("%c", '/'); + break; + case OP_MOD: + post("%c", '%'); + break; + case OP_ADD: + post("%c", '+'); + break; + case OP_SUB: + post("%c", '-'); + break; + case OP_SL: + post("%s", "<<"); + break; + case OP_SR: + post("%s", ">>"); + break; + case OP_LT: + post("%c", '<'); + break; + case OP_LE: + post("%s", "<="); + break; + case OP_GT: + post("%c", '>'); + break; + case OP_GE: + post("%s", ">="); + break; + case OP_EQ: + post("%s", "=="); + break; + case OP_STORE: + post("%s", "="); + break; + case OP_NE: + post("%s", "!="); + break; + case OP_AND: + post("%c", '&'); + break; + case OP_XOR: + post("%c", '^'); + break; + case OP_OR: + post("%c", '|'); + break; + case OP_LAND: + post("%s", "&&"); + break; + case OP_LOR: + post("%s", "||"); + break; + case OP_COMMA: + post("%c", ','); + break; + case OP_SEMI: + post("%c", ';'); + break; + default: + post("expr: ex_print: bad op 0x%lx\n", eptr->ex_op); + } + break; + default: + post("expr: ex_print: bad type 0x%lx\n", eptr->ex_type); + } + eptr++; + } + post("\n"); } #ifdef NT diff --git a/pd/extra/expr~/vexp.h b/pd/extra/expr~/vexp.h index e90c8409..92dfb06e 100644 --- a/pd/extra/expr~/vexp.h +++ b/pd/extra/expr~/vexp.h @@ -43,9 +43,9 @@ /* This is put in fts_to_pd.h #ifdef MSP -#define t_atom Atom -#define t_symbol Symbol -#define pd_new(x) newobject(x); +#define t_atom Atom +#define t_symbol Symbol +#define pd_new(x) newobject(x); #define t_outlet void #endif */ @@ -55,8 +55,8 @@ * is 10. */ -#define MAX_VARS 9 -#define MINODES 10 /* was 200 */ +#define MAX_VARS 9 +#define MINODES 10 /* was 200 */ /* terminal defines */ @@ -67,156 +67,156 @@ * separators are defines as operators just for convenience */ -#define OP_SEMI ((long)(1<<16|1)) /* ; */ -#define OP_COMMA ((long)(2<<16|2)) /* , */ -#define OP_LOR ((long)(3<<16|3)) /* || */ -#define OP_LAND ((long)(4<<16|4)) /* && */ -#define OP_OR ((long)(5<<16|5)) /* | */ -#define OP_XOR ((long)(6<<16|6)) /* ^ */ -#define OP_AND ((long)(7<<16|7)) /* & */ -#define OP_NE ((long)(8<<16|8)) /* != */ -#define OP_EQ ((long)(8<<16|9)) /* == */ -#define OP_GE ((long)(9<<16|10)) /* >= */ -#define OP_GT ((long)(9<<16|11)) /* > */ -#define OP_LE ((long)(9<<16|12)) /* <= */ -#define OP_LT ((long)(9<<16|13)) /* < */ -#define OP_SR ((long)(10<<16|14)) /* >> */ -#define OP_SL ((long)(10<<16|15)) /* << */ -#define OP_SUB ((long)(11<<16|16)) /* - */ -#define OP_ADD ((long)(11<<16|17)) /* + */ -#define OP_MOD ((long)(12<<16|18)) /* % */ -#define OP_DIV ((long)(12<<16|19)) /* / */ -#define OP_MUL ((long)(12<<16|20)) /* * */ -#define OP_UMINUS ((long)(13<<16|21)) /* - unary minus */ -#define OP_NEG ((long)(13<<16|22)) /* ~ one complement */ -#define OP_NOT ((long)(13<<16|23)) /* ! */ -#define OP_RB ((long)(14<<16|24)) /* ] */ -#define OP_LB ((long)(14<<16|25)) /* [ */ -#define OP_RP ((long)(14<<16|26)) /* ) */ -#define OP_LP ((long)(14<<16|27)) /* ( */ -#define OP_STORE ((long)(15<<16|28)) /* = */ -#define HI_PRE ((long)(100<<16)) /* infinite precedence */ -#define PRE_MASK ((long)0xffff0000) /* precedence level mask */ +#define OP_SEMI ((long)(1<<16|1)) /* ; */ +#define OP_COMMA ((long)(2<<16|2)) /* , */ +#define OP_LOR ((long)(3<<16|3)) /* || */ +#define OP_LAND ((long)(4<<16|4)) /* && */ +#define OP_OR ((long)(5<<16|5)) /* | */ +#define OP_XOR ((long)(6<<16|6)) /* ^ */ +#define OP_AND ((long)(7<<16|7)) /* & */ +#define OP_NE ((long)(8<<16|8)) /* != */ +#define OP_EQ ((long)(8<<16|9)) /* == */ +#define OP_GE ((long)(9<<16|10)) /* >= */ +#define OP_GT ((long)(9<<16|11)) /* > */ +#define OP_LE ((long)(9<<16|12)) /* <= */ +#define OP_LT ((long)(9<<16|13)) /* < */ +#define OP_SR ((long)(10<<16|14)) /* >> */ +#define OP_SL ((long)(10<<16|15)) /* << */ +#define OP_SUB ((long)(11<<16|16)) /* - */ +#define OP_ADD ((long)(11<<16|17)) /* + */ +#define OP_MOD ((long)(12<<16|18)) /* % */ +#define OP_DIV ((long)(12<<16|19)) /* / */ +#define OP_MUL ((long)(12<<16|20)) /* * */ +#define OP_UMINUS ((long)(13<<16|21)) /* - unary minus */ +#define OP_NEG ((long)(13<<16|22)) /* ~ one complement */ +#define OP_NOT ((long)(13<<16|23)) /* ! */ +#define OP_RB ((long)(14<<16|24)) /* ] */ +#define OP_LB ((long)(14<<16|25)) /* [ */ +#define OP_RP ((long)(14<<16|26)) /* ) */ +#define OP_LP ((long)(14<<16|27)) /* ( */ +#define OP_STORE ((long)(15<<16|28)) /* = */ +#define HI_PRE ((long)(100<<16)) /* infinite precedence */ +#define PRE_MASK ((long)0xffff0000) /* precedence level mask */ struct ex_ex; -#define name_ok(c) (((c)=='_') || ((c)>='a' && (c)<='z') || \ - ((c)>='A' && (c)<='Z') || ((c) >= '0' && (c) <= '9')) -#define unary_op(x) ((x) == OP_NOT || (x) == OP_NEG || (x) == OP_UMINUS) +#define name_ok(c) (((c)=='_') || ((c)>='a' && (c)<='z') || \ + ((c)>='A' && (c)<='Z') || ((c) >= '0' && (c) <= '9')) +#define unary_op(x) ((x) == OP_NOT || (x) == OP_NEG || (x) == OP_UMINUS) struct ex_ex { - union { - long v_int; - float v_flt; - t_float *v_vec; /* this is an for allocated vector */ - long op; - char *ptr; - } ex_cont; /* content */ -#define ex_int ex_cont.v_int -#define ex_flt ex_cont.v_flt -#define ex_vec ex_cont.v_vec -#define ex_op ex_cont.op -#define ex_ptr ex_cont.ptr - long ex_type; /* type of the node */ + union { + long v_int; + float v_flt; + t_float *v_vec; /* this is an for allocated vector */ + long op; + char *ptr; + } ex_cont; /* content */ +#define ex_int ex_cont.v_int +#define ex_flt ex_cont.v_flt +#define ex_vec ex_cont.v_vec +#define ex_op ex_cont.op +#define ex_ptr ex_cont.ptr + long ex_type; /* type of the node */ }; -#define exNULL ((struct ex_ex *)0) +#define exNULL ((struct ex_ex *)0) /* defines for ex_type */ -#define ET_INT 1 /* an int */ -#define ET_FLT 2 /* a float */ -#define ET_OP 3 /* operator */ -#define ET_STR 4 /* string */ -#define ET_TBL 5 /* a table, the content is a pointer */ -#define ET_FUNC 6 /* a function */ -#define ET_SYM 7 /* symbol ("string") */ -#define ET_VSYM 8 /* variable symbol ("$s?") */ - /* we treat parenthesis and brackets */ - /* special to keep a pointer to their */ - /* match in the content */ -#define ET_LP 9 /* left parenthesis */ -#define ET_LB 10 /* left bracket */ -#define ET_II 11 /* and integer inlet */ -#define ET_FI 12 /* float inlet */ -#define ET_SI 13 /* string inlet */ -#define ET_VI 14 /* signal inlet */ -#define ET_VEC 15 /* allocated signal vector */ - /* special types for fexpr~ */ -#define ET_YO 16 /* vector output for fexpr~ */ -#define ET_YOM1 17 /* shorthand for $y?[-1] */ -#define ET_XI 18 /* vector input for fexpr~ */ -#define ET_XI0 20 /* shorthand for $x?[0] */ -#define ET_VAR 21 /* variable */ +#define ET_INT 1 /* an int */ +#define ET_FLT 2 /* a float */ +#define ET_OP 3 /* operator */ +#define ET_STR 4 /* string */ +#define ET_TBL 5 /* a table, the content is a pointer */ +#define ET_FUNC 6 /* a function */ +#define ET_SYM 7 /* symbol ("string") */ +#define ET_VSYM 8 /* variable symbol ("$s?") */ + /* we treat parenthesis and brackets */ + /* special to keep a pointer to their */ + /* match in the content */ +#define ET_LP 9 /* left parenthesis */ +#define ET_LB 10 /* left bracket */ +#define ET_II 11 /* and integer inlet */ +#define ET_FI 12 /* float inlet */ +#define ET_SI 13 /* string inlet */ +#define ET_VI 14 /* signal inlet */ +#define ET_VEC 15 /* allocated signal vector */ + /* special types for fexpr~ */ +#define ET_YO 16 /* vector output for fexpr~ */ +#define ET_YOM1 17 /* shorthand for $y?[-1] */ +#define ET_XI 18 /* vector input for fexpr~ */ +#define ET_XI0 20 /* shorthand for $x?[0] */ +#define ET_VAR 21 /* variable */ /* defines for ex_flags */ -#define EF_TYPE_MASK 0x07 /* first three bits define the type of expr */ -#define EF_EXPR 0x01 /* expr - control in and out */ -#define EF_EXPR_TILDE 0x02 /* expr~ signal and control in, signal out */ -#define EF_FEXPR_TILDE 0x04 /* fexpr~ filter expression */ +#define EF_TYPE_MASK 0x07 /* first three bits define the type of expr */ +#define EF_EXPR 0x01 /* expr - control in and out */ +#define EF_EXPR_TILDE 0x02 /* expr~ signal and control in, signal out */ +#define EF_FEXPR_TILDE 0x04 /* fexpr~ filter expression */ -#define EF_STOP 0x08 /* is it stopped used for expr~ and fexpr~ */ -#define EF_VERBOSE 0x10 /* verbose mode */ +#define EF_STOP 0x08 /* is it stopped used for expr~ and fexpr~ */ +#define EF_VERBOSE 0x10 /* verbose mode */ -#define IS_EXPR(x) ((((x)->exp_flags&EF_TYPE_MASK)|EF_EXPR) == EF_EXPR) -#define IS_EXPR_TILDE(x) \ +#define IS_EXPR(x) ((((x)->exp_flags&EF_TYPE_MASK)|EF_EXPR) == EF_EXPR) +#define IS_EXPR_TILDE(x) \ ((((x)->exp_flags&EF_TYPE_MASK)|EF_EXPR_TILDE)==EF_EXPR_TILDE) -#define IS_FEXPR_TILDE(x) \ +#define IS_FEXPR_TILDE(x) \ ((((x)->exp_flags&EF_TYPE_MASK)|EF_FEXPR_TILDE)==EF_FEXPR_TILDE) -#define SET_EXPR(x) (x)->exp_flags |= EF_EXPR; \ - (x)->exp_flags &= ~EF_EXPR_TILDE; \ - (x)->exp_flags &= ~EF_FEXPR_TILDE; +#define SET_EXPR(x) (x)->exp_flags |= EF_EXPR; \ + (x)->exp_flags &= ~EF_EXPR_TILDE; \ + (x)->exp_flags &= ~EF_FEXPR_TILDE; -#define SET_EXPR_TILDE(x) (x)->exp_flags &= ~EF_EXPR; \ - (x)->exp_flags |= EF_EXPR_TILDE; \ - (x)->exp_flags &= ~EF_FEXPR_TILDE; +#define SET_EXPR_TILDE(x) (x)->exp_flags &= ~EF_EXPR; \ + (x)->exp_flags |= EF_EXPR_TILDE; \ + (x)->exp_flags &= ~EF_FEXPR_TILDE; -#define SET_FEXPR_TILDE(x) (x)->exp_flags &= ~EF_EXPR; \ - (x)->exp_flags &= ~EF_EXPR_TILDE; \ - (x)->exp_flags |= EF_FEXPR_TILDE; +#define SET_FEXPR_TILDE(x) (x)->exp_flags &= ~EF_EXPR; \ + (x)->exp_flags &= ~EF_EXPR_TILDE; \ + (x)->exp_flags |= EF_FEXPR_TILDE; /* * defines for expr_error */ -#define EE_DZ 0x01 /* divide by zero error */ -#define EE_BI_OUTPUT 0x02 /* Bad output index */ -#define EE_BI_INPUT 0x04 /* Bad input index */ -#define EE_NOTABLE 0x08 /* NO TABLE */ -#define EE_NOVAR 0x10 /* NO VARIABLE */ +#define EE_DZ 0x01 /* divide by zero error */ +#define EE_BI_OUTPUT 0x02 /* Bad output index */ +#define EE_BI_INPUT 0x04 /* Bad input index */ +#define EE_NOTABLE 0x08 /* NO TABLE */ +#define EE_NOVAR 0x10 /* NO VARIABLE */ typedef struct expr { #ifdef PD - t_object exp_ob; + t_object exp_ob; #else /* MSP */ - t_pxobject exp_ob; + t_pxobject exp_ob; #endif - int exp_flags; /* are we expr~, fexpr~, or expr */ - int exp_error; /* reported errors */ - int exp_nexpr; /* number of expressions */ - char *exp_string; /* the full expression string */ - char *exp_str; /* current parsing position */ - t_outlet *exp_outlet[MAX_VARS]; + int exp_flags; /* are we expr~, fexpr~, or expr */ + int exp_error; /* reported errors */ + int exp_nexpr; /* number of expressions */ + char *exp_string; /* the full expression string */ + char *exp_str; /* current parsing position */ + t_outlet *exp_outlet[MAX_VARS]; #ifdef PD - struct _exprproxy *exp_proxy; + struct _exprproxy *exp_proxy; #else /* MAX */ - void *exp_proxy[MAX_VARS]; - long exp_proxy_id; + void *exp_proxy[MAX_VARS]; + long exp_proxy_id; #endif - struct ex_ex *exp_stack[MAX_VARS]; - struct ex_ex exp_var[MAX_VARS]; - struct ex_ex exp_res[MAX_VARS]; /* the evluation result */ - t_float *exp_p_var[MAX_VARS]; - t_float *exp_p_res[MAX_VARS]; /* the previous evaluation result */ - t_float *exp_tmpres[MAX_VARS]; /* temporty result for fexpr~ */ - int exp_vsize; /* the size of the signal vector */ - int exp_nivec; /* # of vector inlets */ - float exp_f; /* control value to be transformed to signal */ + struct ex_ex *exp_stack[MAX_VARS]; + struct ex_ex exp_var[MAX_VARS]; + struct ex_ex exp_res[MAX_VARS]; /* the evluation result */ + t_float *exp_p_var[MAX_VARS]; + t_float *exp_p_res[MAX_VARS]; /* the previous evaluation result */ + t_float *exp_tmpres[MAX_VARS]; /* temporty result for fexpr~ */ + int exp_vsize; /* the size of the signal vector */ + int exp_nivec; /* # of vector inlets */ + float exp_f; /* control value to be transformed to signal */ } t_expr; typedef struct ex_funcs { - char *f_name; /* function name */ - void (*f_func)(t_expr *, long, struct ex_ex *, struct ex_ex *); - /* the real function performing the function (void, no return!!!) */ - long f_argc; /* number of arguments */ + char *f_name; /* function name */ + void (*f_func)(t_expr *, long, struct ex_ex *, struct ex_ex *); + /* the real function performing the function (void, no return!!!) */ + long f_argc; /* number of arguments */ } t_ex_func; /* function prototypes for pd-related functions called withing vexp.h */ @@ -227,12 +227,12 @@ extern int ex_getsym(char *p, t_symbol **s); extern const char *ex_symname(t_symbol *s); void ex_mkvector(t_float *fp, t_float x, int size); extern void ex_size(t_expr *expr, long int argc, struct ex_ex *argv, - struct ex_ex *optr); -extern void ex_sum(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr); -extern void ex_Sum(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr); -extern void ex_avg(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr); -extern void ex_Avg(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr); -extern void ex_store(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr); + struct ex_ex *optr); +extern void ex_sum(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr); +extern void ex_Sum(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr); +extern void ex_avg(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr); +extern void ex_Avg(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr); +extern void ex_store(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr); int value_getonly(t_symbol *s, t_float *f); diff --git a/pd/extra/expr~/vexp_fun.c b/pd/extra/expr~/vexp_fun.c index 53e9092f..fba49b18 100644 --- a/pd/extra/expr~/vexp_fun.c +++ b/pd/extra/expr~/vexp_fun.c @@ -27,55 +27,55 @@ /* "expr" was written by Shahrokh Yadegari c. 1989. -msp * * Nov. 2001 --sdy - * conversion for expr~ + * conversion for expr~ * * Jan, 2002 --sdy - * added fmod() + * added fmod() * * May 2002 - * added floor and ceil for expr -- Orm Finnendahl + * added floor and ceil for expr -- Orm Finnendahl * * July 2002 --sdy - * added the following math funtions: - * cbrt - cube root - * erf - error function - * erfc - complementary error function - * expm1 - exponential minus 1, - * log1p - logarithm of 1 plus - * isinf - is the value infinite, - * finite - is the value finite - * isnan -- is the resut a nan (Not a number) - * copysign - copy sign of a number - * ldexp - multiply floating-point number by integral power of 2 - * imodf - get signed integral value from floating-point number - * modf - get signed fractional value from floating-point number - * drem - floating-point remainder function + * added the following math funtions: + * cbrt - cube root + * erf - error function + * erfc - complementary error function + * expm1 - exponential minus 1, + * log1p - logarithm of 1 plus + * isinf - is the value infinite, + * finite - is the value finite + * isnan -- is the resut a nan (Not a number) + * copysign - copy sign of a number + * ldexp - multiply floating-point number by integral power of 2 + * imodf - get signed integral value from floating-point number + * modf - get signed fractional value from floating-point number + * drem - floating-point remainder function * - * The following are done but not popular enough in math libss - * to be included yet - * hypoth - Euclidean distance function - * trunc - * round - * nearbyint - + * The following are done but not popular enough in math libss + * to be included yet + * hypoth - Euclidean distance function + * trunc + * round + * nearbyint - */ /* * vexp_func.c -- this file include all the functions for vexp. - * the first two arguments to the function are the number - * of argument and an array of arguments (argc, argv) - * the last argument is a pointer to a struct ex_ex for - * the result. Up do this point, the content of the - * struct ex_ex that these functions receive are either - * ET_INT (long), ET_FLT (float), or ET_SYM (char **, it is - * char ** and not char * since NewHandle of Mac returns - * a char ** for relocatability.) The common practice in - * these functions is that they figure out the type of their - * result according to the type of the arguments. In general - * the ET_SYM is used an ET_INT when we expect a value. - * It is the users responsibility not to pass strings to the - * function. + * the first two arguments to the function are the number + * of argument and an array of arguments (argc, argv) + * the last argument is a pointer to a struct ex_ex for + * the result. Up do this point, the content of the + * struct ex_ex that these functions receive are either + * ET_INT (long), ET_FLT (float), or ET_SYM (char **, it is + * char ** and not char * since NewHandle of Mac returns + * a char ** for relocatability.) The common practice in + * these functions is that they figure out the type of their + * result according to the type of the arguments. In general + * the ET_SYM is used an ET_INT when we expect a value. + * It is the users responsibility not to pass strings to the + * function. */ #include @@ -145,68 +145,68 @@ static void ex_hypoth(t_expr *expr, long argc, struct ex_ex *argv, struct ex_ex t_ex_func ex_funcs[] = { - {"min", ex_min, 2}, - {"max", ex_max, 2}, - {"int", ex_toint, 1}, - {"rint", ex_rint, 1}, - {"float", ex_tofloat, 1}, - {"fmod", ex_fmod, 2}, - {"floor", ex_floor, 2}, - {"ceil", ex_ceil, 2}, - {"pow", ex_pow, 2}, - {"sqrt", ex_sqrt, 1}, - {"exp", ex_exp, 1}, - {"log10", ex_log, 1}, - {"ln", ex_ln, 1}, - {"log", ex_ln, 1}, - {"sin", ex_sin, 1}, - {"cos", ex_cos, 1}, - {"tan", ex_tan, 1}, - {"asin", ex_asin, 1}, - {"acos", ex_acos, 1}, - {"atan", ex_atan, 1}, - {"atan2", ex_atan2, 2}, - {"sinh", ex_sinh, 1}, - {"cosh", ex_cosh, 1}, - {"tanh", ex_tanh, 1}, - {"fact", ex_fact, 1}, - {"random", ex_random, 2}, /* random number */ - {"abs", ex_abs, 1}, - {"if", ex_if, 3}, - {"ldexp ", ex_ldexp, 1}, - {"imodf ", ex_imodf, 1}, - {"modf", ex_modf, 1}, + {"min", ex_min, 2}, + {"max", ex_max, 2}, + {"int", ex_toint, 1}, + {"rint", ex_rint, 1}, + {"float", ex_tofloat, 1}, + {"fmod", ex_fmod, 2}, + {"floor", ex_floor, 2}, + {"ceil", ex_ceil, 2}, + {"pow", ex_pow, 2}, + {"sqrt", ex_sqrt, 1}, + {"exp", ex_exp, 1}, + {"log10", ex_log, 1}, + {"ln", ex_ln, 1}, + {"log", ex_ln, 1}, + {"sin", ex_sin, 1}, + {"cos", ex_cos, 1}, + {"tan", ex_tan, 1}, + {"asin", ex_asin, 1}, + {"acos", ex_acos, 1}, + {"atan", ex_atan, 1}, + {"atan2", ex_atan2, 2}, + {"sinh", ex_sinh, 1}, + {"cosh", ex_cosh, 1}, + {"tanh", ex_tanh, 1}, + {"fact", ex_fact, 1}, + {"random", ex_random, 2}, /* random number */ + {"abs", ex_abs, 1}, + {"if", ex_if, 3}, + {"ldexp ", ex_ldexp, 1}, + {"imodf ", ex_imodf, 1}, + {"modf", ex_modf, 1}, #ifndef NT - {"cbrt", ex_cbrt, 1}, - {"erf", ex_erf, 1}, - {"erfc", ex_erfc, 1}, - {"expm1", ex_expm1, 1}, - {"log1p", ex_log1p, 1}, - {"isinf", ex_isinf, 1}, - {"finite", ex_finite, 1}, - {"isnan", ex_isnan, 1}, - {"copysig", ex_copysign, 1}, - {"drem", ex_drem, 1}, - {"asinh", ex_asinh, 1}, - {"acosh", ex_acosh, 1}, - {"atanh", ex_atanh, 1}, /* hyperbolic atan */ + {"cbrt", ex_cbrt, 1}, + {"erf", ex_erf, 1}, + {"erfc", ex_erfc, 1}, + {"expm1", ex_expm1, 1}, + {"log1p", ex_log1p, 1}, + {"isinf", ex_isinf, 1}, + {"finite", ex_finite, 1}, + {"isnan", ex_isnan, 1}, + {"copysig", ex_copysign, 1}, + {"drem", ex_drem, 1}, + {"asinh", ex_asinh, 1}, + {"acosh", ex_acosh, 1}, + {"atanh", ex_atanh, 1}, /* hyperbolic atan */ #endif #ifdef PD - {"size", ex_size, 1}, - {"sum", ex_sum, 1}, - {"Sum", ex_Sum, 3}, - {"avg", ex_avg, 1}, - {"Avg", ex_Avg, 3}, - {"store", ex_store, 3}, + {"size", ex_size, 1}, + {"sum", ex_sum, 1}, + {"Sum", ex_Sum, 3}, + {"avg", ex_avg, 1}, + {"Avg", ex_Avg, 3}, + {"store", ex_store, 3}, #endif #ifdef notdef /* the following will be added once they are more popular in math libraries */ - {"round", ex_round, 1}, - {"trunc", ex_trunc, 1}, - {"nearbyint", ex_nearbyint, 1}, - {"hypoth", ex_hypoth, 1}, + {"round", ex_round, 1}, + {"trunc", ex_trunc, 1}, + {"nearbyint", ex_nearbyint, 1}, + {"hypoth", ex_hypoth, 1}, #endif - {0, 0, 0} + {0, 0, 0} }; /* @@ -214,189 +214,189 @@ t_ex_func ex_funcs[] = { * if fltret is set return float * otherwise return value based on regular typechecking, */ -#define FUNC_EVAL(left, right, func, leftfuncast, rightfuncast, optr, fltret) \ -switch (left->ex_type) { \ -case ET_INT: \ - switch(right->ex_type) { \ - case ET_INT: \ - if (optr->ex_type == ET_VEC) { \ - op = optr->ex_vec; \ - scalar = (float)func(leftfuncast left->ex_int, \ - rightfuncast right->ex_int); \ - j = e->exp_vsize; \ - while (j--) \ - *op++ = scalar; \ - } else { \ - if (fltret) { \ - optr->ex_type = ET_FLT; \ - optr->ex_flt = (float)func(leftfuncast \ - left->ex_int, rightfuncast right->ex_int); \ - } else { \ - optr->ex_type = ET_INT; \ - optr->ex_int = (int)func(leftfuncast \ - left->ex_int, rightfuncast right->ex_int); \ - } \ - } \ - break; \ - case ET_FLT: \ - if (optr->ex_type == ET_VEC) { \ - op = optr->ex_vec; \ - scalar = (float)func(leftfuncast left->ex_int, \ - rightfuncast right->ex_flt); \ - j = e->exp_vsize; \ - while (j--) \ - *op++ = scalar; \ - } else { \ - optr->ex_type = ET_FLT; \ - optr->ex_flt = (float)func(leftfuncast left->ex_int, \ - rightfuncast right->ex_flt); \ - } \ - break; \ - case ET_VEC: \ - case ET_VI: \ - if (optr->ex_type != ET_VEC) { \ - if (optr->ex_type == ET_VI) { \ - post("expr~: Int. error %d", __LINE__); \ - abort(); \ - } \ - optr->ex_type = ET_VEC; \ - optr->ex_vec = (t_float *) \ - fts_malloc(sizeof (t_float)*e->exp_vsize); \ - } \ - scalar = left->ex_int; \ - rp = right->ex_vec; \ - op = optr->ex_vec; \ - j = e->exp_vsize; \ - while (j--) { \ - *op++ = (float)func(leftfuncast scalar, \ - rightfuncast *rp); \ - rp++; \ - } \ - break; \ - case ET_SYM: \ - default: \ - post_error((fts_object_t *) e, \ - "expr: FUNC_EVAL(%d): bad right type %ld\n", \ - __LINE__, right->ex_type);\ - } \ - break; \ -case ET_FLT: \ - switch(right->ex_type) { \ - case ET_INT: \ - if (optr->ex_type == ET_VEC) { \ - op = optr->ex_vec; \ - scalar = (float)func(leftfuncast left->ex_flt, \ - rightfuncast right->ex_int); \ - j = e->exp_vsize; \ - while (j--) \ - *op++ = scalar; \ - } else { \ - optr->ex_type = ET_FLT; \ - optr->ex_flt = (float)func(leftfuncast left->ex_flt, \ - rightfuncast right->ex_int); \ - } \ - break; \ - case ET_FLT: \ - if (optr->ex_type == ET_VEC) { \ - op = optr->ex_vec; \ - scalar = (float)func(leftfuncast left->ex_flt, \ - rightfuncast right->ex_flt); \ - j = e->exp_vsize; \ - while (j--) \ - *op++ = scalar; \ - } else { \ - optr->ex_type = ET_FLT; \ - optr->ex_flt = (float)func(leftfuncast left->ex_flt, \ - rightfuncast right->ex_flt); \ - } \ - break; \ - case ET_VEC: \ - case ET_VI: \ - if (optr->ex_type != ET_VEC) { \ - if (optr->ex_type == ET_VI) { \ - post("expr~: Int. error %d", __LINE__); \ - abort(); \ - } \ - optr->ex_type = ET_VEC; \ - optr->ex_vec = (t_float *) \ - fts_malloc(sizeof (t_float) * e->exp_vsize);\ - } \ - scalar = left->ex_flt; \ - rp = right->ex_vec; \ - op = optr->ex_vec; \ - j = e->exp_vsize; \ - while (j--) { \ - *op++ = (float)func(leftfuncast scalar, \ - rightfuncast *rp); \ - rp++; \ - } \ - break; \ - case ET_SYM: \ - default: \ - post_error((fts_object_t *) e, \ - "expr: FUNC_EVAL(%d): bad right type %ld\n", \ - __LINE__, right->ex_type);\ - } \ - break; \ -case ET_VEC: \ -case ET_VI: \ - if (optr->ex_type != ET_VEC) { \ - if (optr->ex_type == ET_VI) { \ - post("expr~: Int. error %d", __LINE__); \ - abort(); \ - } \ - optr->ex_type = ET_VEC; \ - optr->ex_vec = (t_float *) \ - fts_malloc(sizeof (t_float) * e->exp_vsize); \ - } \ - op = optr->ex_vec; \ - lp = left->ex_vec; \ - switch(right->ex_type) { \ - case ET_INT: \ - scalar = right->ex_int; \ - j = e->exp_vsize; \ - while (j--) { \ - *op++ = (float)func(leftfuncast *lp, \ - rightfuncast scalar); \ - lp++; \ - } \ - break; \ - case ET_FLT: \ - scalar = right->ex_flt; \ - j = e->exp_vsize; \ - while (j--) { \ - *op++ = (float)func(leftfuncast *lp, \ - rightfuncast scalar); \ - lp++; \ - } \ - break; \ - case ET_VEC: \ - case ET_VI: \ - rp = right->ex_vec; \ - j = e->exp_vsize; \ - while (j--) { \ - /* \ - * on a RISC processor one could copy \ - * 8 times in each round to get a considerable \ - * improvement \ - */ \ - *op++ = (float)func(leftfuncast *lp, \ - rightfuncast *rp); \ - rp++; lp++; \ - } \ - break; \ - case ET_SYM: \ - default: \ - post_error((fts_object_t *) e, \ - "expr: FUNC_EVAL(%d): bad right type %ld\n", \ - __LINE__, right->ex_type);\ - } \ - break; \ -case ET_SYM: \ -default: \ - post_error((fts_object_t *) e, \ - "expr: FUNC_EVAL(%d): bad left type %ld\n", \ - __LINE__, left->ex_type); \ +#define FUNC_EVAL(left, right, func, leftfuncast, rightfuncast, optr, fltret) \ +switch (left->ex_type) { \ +case ET_INT: \ + switch(right->ex_type) { \ + case ET_INT: \ + if (optr->ex_type == ET_VEC) { \ + op = optr->ex_vec; \ + scalar = (float)func(leftfuncast left->ex_int, \ + rightfuncast right->ex_int); \ + j = e->exp_vsize; \ + while (j--) \ + *op++ = scalar; \ + } else { \ + if (fltret) { \ + optr->ex_type = ET_FLT; \ + optr->ex_flt = (float)func(leftfuncast \ + left->ex_int, rightfuncast right->ex_int); \ + } else { \ + optr->ex_type = ET_INT; \ + optr->ex_int = (int)func(leftfuncast \ + left->ex_int, rightfuncast right->ex_int); \ + } \ + } \ + break; \ + case ET_FLT: \ + if (optr->ex_type == ET_VEC) { \ + op = optr->ex_vec; \ + scalar = (float)func(leftfuncast left->ex_int, \ + rightfuncast right->ex_flt); \ + j = e->exp_vsize; \ + while (j--) \ + *op++ = scalar; \ + } else { \ + optr->ex_type = ET_FLT; \ + optr->ex_flt = (float)func(leftfuncast left->ex_int, \ + rightfuncast right->ex_flt); \ + } \ + break; \ + case ET_VEC: \ + case ET_VI: \ + if (optr->ex_type != ET_VEC) { \ + if (optr->ex_type == ET_VI) { \ + post("expr~: Int. error %d", __LINE__); \ + abort(); \ + } \ + optr->ex_type = ET_VEC; \ + optr->ex_vec = (t_float *) \ + fts_malloc(sizeof (t_float)*e->exp_vsize); \ + } \ + scalar = left->ex_int; \ + rp = right->ex_vec; \ + op = optr->ex_vec; \ + j = e->exp_vsize; \ + while (j--) { \ + *op++ = (float)func(leftfuncast scalar, \ + rightfuncast *rp); \ + rp++; \ + } \ + break; \ + case ET_SYM: \ + default: \ + post_error((fts_object_t *) e, \ + "expr: FUNC_EVAL(%d): bad right type %ld\n", \ + __LINE__, right->ex_type);\ + } \ + break; \ +case ET_FLT: \ + switch(right->ex_type) { \ + case ET_INT: \ + if (optr->ex_type == ET_VEC) { \ + op = optr->ex_vec; \ + scalar = (float)func(leftfuncast left->ex_flt, \ + rightfuncast right->ex_int); \ + j = e->exp_vsize; \ + while (j--) \ + *op++ = scalar; \ + } else { \ + optr->ex_type = ET_FLT; \ + optr->ex_flt = (float)func(leftfuncast left->ex_flt, \ + rightfuncast right->ex_int); \ + } \ + break; \ + case ET_FLT: \ + if (optr->ex_type == ET_VEC) { \ + op = optr->ex_vec; \ + scalar = (float)func(leftfuncast left->ex_flt, \ + rightfuncast right->ex_flt); \ + j = e->exp_vsize; \ + while (j--) \ + *op++ = scalar; \ + } else { \ + optr->ex_type = ET_FLT; \ + optr->ex_flt = (float)func(leftfuncast left->ex_flt, \ + rightfuncast right->ex_flt); \ + } \ + break; \ + case ET_VEC: \ + case ET_VI: \ + if (optr->ex_type != ET_VEC) { \ + if (optr->ex_type == ET_VI) { \ + post("expr~: Int. error %d", __LINE__); \ + abort(); \ + } \ + optr->ex_type = ET_VEC; \ + optr->ex_vec = (t_float *) \ + fts_malloc(sizeof (t_float) * e->exp_vsize);\ + } \ + scalar = left->ex_flt; \ + rp = right->ex_vec; \ + op = optr->ex_vec; \ + j = e->exp_vsize; \ + while (j--) { \ + *op++ = (float)func(leftfuncast scalar, \ + rightfuncast *rp); \ + rp++; \ + } \ + break; \ + case ET_SYM: \ + default: \ + post_error((fts_object_t *) e, \ + "expr: FUNC_EVAL(%d): bad right type %ld\n", \ + __LINE__, right->ex_type);\ + } \ + break; \ +case ET_VEC: \ +case ET_VI: \ + if (optr->ex_type != ET_VEC) { \ + if (optr->ex_type == ET_VI) { \ + post("expr~: Int. error %d", __LINE__); \ + abort(); \ + } \ + optr->ex_type = ET_VEC; \ + optr->ex_vec = (t_float *) \ + fts_malloc(sizeof (t_float) * e->exp_vsize); \ + } \ + op = optr->ex_vec; \ + lp = left->ex_vec; \ + switch(right->ex_type) { \ + case ET_INT: \ + scalar = right->ex_int; \ + j = e->exp_vsize; \ + while (j--) { \ + *op++ = (float)func(leftfuncast *lp, \ + rightfuncast scalar); \ + lp++; \ + } \ + break; \ + case ET_FLT: \ + scalar = right->ex_flt; \ + j = e->exp_vsize; \ + while (j--) { \ + *op++ = (float)func(leftfuncast *lp, \ + rightfuncast scalar); \ + lp++; \ + } \ + break; \ + case ET_VEC: \ + case ET_VI: \ + rp = right->ex_vec; \ + j = e->exp_vsize; \ + while (j--) { \ + /* \ + * on a RISC processor one could copy \ + * 8 times in each round to get a considerable \ + * improvement \ + */ \ + *op++ = (float)func(leftfuncast *lp, \ + rightfuncast *rp); \ + rp++; lp++; \ + } \ + break; \ + case ET_SYM: \ + default: \ + post_error((fts_object_t *) e, \ + "expr: FUNC_EVAL(%d): bad right type %ld\n", \ + __LINE__, right->ex_type);\ + } \ + break; \ +case ET_SYM: \ +default: \ + post_error((fts_object_t *) e, \ + "expr: FUNC_EVAL(%d): bad left type %ld\n", \ + __LINE__, left->ex_type); \ } /* @@ -404,124 +404,124 @@ default: \ * if fltret is set return float * otherwise return value based on regular typechecking, */ -#define FUNC_EVAL_UNARY(left, func, leftcast, optr, fltret) \ -switch(left->ex_type) { \ -case ET_INT: \ - if (optr->ex_type == ET_VEC) { \ - ex_mkvector(optr->ex_vec, \ - (float)(func (leftcast left->ex_int)), e->exp_vsize);\ - break; \ - } \ - if (fltret) { \ - optr->ex_type = ET_FLT; \ - optr->ex_flt = (float) func(leftcast left->ex_int); \ - break; \ - } \ - optr->ex_type = ET_INT; \ - optr->ex_int = (int) func(leftcast left->ex_int); \ - break; \ -case ET_FLT: \ - if (optr->ex_type == ET_VEC) { \ - ex_mkvector(optr->ex_vec, \ - (float)(func (leftcast left->ex_flt)), e->exp_vsize);\ - break; \ - } \ - optr->ex_type = ET_FLT; \ - optr->ex_flt = (float) func(leftcast left->ex_flt); \ - break; \ -case ET_VI: \ -case ET_VEC: \ - if (optr->ex_type != ET_VEC) { \ - optr->ex_type = ET_VEC; \ - optr->ex_vec = (t_float *) \ - fts_malloc(sizeof (t_float)*e->exp_vsize); \ - } \ - op = optr->ex_vec; \ - lp = left->ex_vec; \ - j = e->exp_vsize; \ - while (j--) \ - *op++ = (float)(func (leftcast *lp++)); \ - break; \ -default: \ - post_error((fts_object_t *) e, \ - "expr: FUNV_EVAL_UNARY(%d): bad left type %ld\n",\ - __LINE__, left->ex_type); \ +#define FUNC_EVAL_UNARY(left, func, leftcast, optr, fltret) \ +switch(left->ex_type) { \ +case ET_INT: \ + if (optr->ex_type == ET_VEC) { \ + ex_mkvector(optr->ex_vec, \ + (float)(func (leftcast left->ex_int)), e->exp_vsize);\ + break; \ + } \ + if (fltret) { \ + optr->ex_type = ET_FLT; \ + optr->ex_flt = (float) func(leftcast left->ex_int); \ + break; \ + } \ + optr->ex_type = ET_INT; \ + optr->ex_int = (int) func(leftcast left->ex_int); \ + break; \ +case ET_FLT: \ + if (optr->ex_type == ET_VEC) { \ + ex_mkvector(optr->ex_vec, \ + (float)(func (leftcast left->ex_flt)), e->exp_vsize);\ + break; \ + } \ + optr->ex_type = ET_FLT; \ + optr->ex_flt = (float) func(leftcast left->ex_flt); \ + break; \ +case ET_VI: \ +case ET_VEC: \ + if (optr->ex_type != ET_VEC) { \ + optr->ex_type = ET_VEC; \ + optr->ex_vec = (t_float *) \ + fts_malloc(sizeof (t_float)*e->exp_vsize); \ + } \ + op = optr->ex_vec; \ + lp = left->ex_vec; \ + j = e->exp_vsize; \ + while (j--) \ + *op++ = (float)(func (leftcast *lp++)); \ + break; \ +default: \ + post_error((fts_object_t *) e, \ + "expr: FUNV_EVAL_UNARY(%d): bad left type %ld\n",\ + __LINE__, left->ex_type); \ } #undef min #undef max -#define min(x,y) (x > y ? y : x) -#define max(x,y) (x > y ? x : y) +#define min(x,y) (x > y ? y : x) +#define max(x,y) (x > y ? x : y) -#define FUNC_DEF(ex_func, func, castleft, castright, fltret); \ -static void \ +#define FUNC_DEF(ex_func, func, castleft, castright, fltret); \ +static void \ ex_func(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr)\ -{ \ - struct ex_ex *left, *right; \ - float *op; /* output pointer */ \ - float *lp, *rp; /* left and right vector pointers */ \ - float scalar; \ - int j; \ - \ - left = argv++; \ - right = argv; \ - FUNC_EVAL(left, right, func, castleft, castright, optr, fltret); \ +{ \ + struct ex_ex *left, *right; \ + float *op; /* output pointer */ \ + float *lp, *rp; /* left and right vector pointers */ \ + float scalar; \ + int j; \ + \ + left = argv++; \ + right = argv; \ + FUNC_EVAL(left, right, func, castleft, castright, optr, fltret); \ } -#define FUNC_DEF_UNARY(ex_func, func, cast, fltret); \ -static void \ +#define FUNC_DEF_UNARY(ex_func, func, cast, fltret); \ +static void \ ex_func(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr)\ -{ \ - struct ex_ex *left; \ - float *op; /* output pointer */ \ - float *lp, *rp; /* left and right vector pointers */ \ - float scalar; \ - int j; \ - \ - left = argv++; \ - \ - FUNC_EVAL_UNARY(left, func, cast, optr, fltret); \ +{ \ + struct ex_ex *left; \ + float *op; /* output pointer */ \ + float *lp, *rp; /* left and right vector pointers */ \ + float scalar; \ + int j; \ + \ + left = argv++; \ + \ + FUNC_EVAL_UNARY(left, func, cast, optr, fltret); \ } /* * ex_min -- if any of the arguments are or the output are vectors, a vector - * of floats is generated otherwise the type of the result is the - * type of the smaller value + * of floats is generated otherwise the type of the result is the + * type of the smaller value */ static void ex_min(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr) { - struct ex_ex *left, *right; - float *op; /* output pointer */ - float *lp, *rp; /* left and right vector pointers */ - float scalar; - int j; + struct ex_ex *left, *right; + float *op; /* output pointer */ + float *lp, *rp; /* left and right vector pointers */ + float scalar; + int j; - left = argv++; - right = argv; + left = argv++; + right = argv; - FUNC_EVAL(left, right, min, (double), (double), optr, 0); + FUNC_EVAL(left, right, min, (double), (double), optr, 0); } /* * ex_max -- if any of the arguments are or the output are vectors, a vector - * of floats is generated otherwise the type of the result is the - * type of the larger value + * of floats is generated otherwise the type of the result is the + * type of the larger value */ static void ex_max(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr) { - struct ex_ex *left, *right; - float *op; /* output pointer */ - float *lp, *rp; /* left and right vector pointers */ - float scalar; - int j; + struct ex_ex *left, *right; + float *op; /* output pointer */ + float *lp, *rp; /* left and right vector pointers */ + float scalar; + int j; - left = argv++; - right = argv; + left = argv++; + right = argv; - FUNC_EVAL(left, right, max, (double), (double), optr, 0); + FUNC_EVAL(left, right, max, (double), (double), optr, 0); } /* @@ -530,17 +530,17 @@ ex_max(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr) static void ex_toint(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr) { - struct ex_ex *left; - float *op; /* output pointer */ - float *lp, *rp; /* left and right vector pointers */ - float scalar; - int j; + struct ex_ex *left; + float *op; /* output pointer */ + float *lp, *rp; /* left and right vector pointers */ + float scalar; + int j; - left = argv++; + left = argv++; -#define toint(x) ((int)(x)) - FUNC_EVAL_UNARY(left, toint, (int), optr, 0); - } +#define toint(x) ((int)(x)) + FUNC_EVAL_UNARY(left, toint, (int), optr, 0); + } #ifdef NT /* No rint in NT land ??? */ @@ -549,27 +549,27 @@ double rint(double x); double rint(double x) { - return (floor(x + 0.5)); + return (floor(x + 0.5)); } #endif /* * ex_rint -- rint() round to the nearest int according to the common - * rounding mechanism + * rounding mechanism */ static void ex_rint(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr) { - struct ex_ex *left; - float *op; /* output pointer */ - float *lp, *rp; /* left and right vector pointers */ - float scalar; - int j; + struct ex_ex *left; + float *op; /* output pointer */ + float *lp, *rp; /* left and right vector pointers */ + float scalar; + int j; - left = argv++; + left = argv++; - FUNC_EVAL_UNARY(left, rint, (double), optr, 1); + FUNC_EVAL_UNARY(left, rint, (double), optr, 1); } /* @@ -578,16 +578,16 @@ ex_rint(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr) static void ex_tofloat(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr) { - struct ex_ex *left; - float *op; /* output pointer */ - float *lp, *rp; /* left and right vector pointers */ - float scalar; - int j; + struct ex_ex *left; + float *op; /* output pointer */ + float *lp, *rp; /* left and right vector pointers */ + float scalar; + int j; - left = argv++; + left = argv++; -#define tofloat(x) ((float)(x)) - FUNC_EVAL_UNARY(left, tofloat, (int), optr, 1); +#define tofloat(x) ((float)(x)) + FUNC_EVAL_UNARY(left, tofloat, (int), optr, 1); } @@ -597,15 +597,15 @@ ex_tofloat(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr) static void ex_pow(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr) { - struct ex_ex *left, *right; - float *op; /* output pointer */ - float *lp, *rp; /* left and right vector pointers */ - float scalar; - int j; - - left = argv++; - right = argv; - FUNC_EVAL(left, right, pow, (double), (double), optr, 1); + struct ex_ex *left, *right; + float *op; /* output pointer */ + float *lp, *rp; /* left and right vector pointers */ + float scalar; + int j; + + left = argv++; + right = argv; + FUNC_EVAL(left, right, pow, (double), (double), optr, 1); } /* @@ -614,15 +614,15 @@ ex_pow(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr) static void ex_sqrt(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr) { - struct ex_ex *left; - float *op; /* output pointer */ - float *lp, *rp; /* left and right vector pointers */ - float scalar; - int j; + struct ex_ex *left; + float *op; /* output pointer */ + float *lp, *rp; /* left and right vector pointers */ + float scalar; + int j; - left = argv++; + left = argv++; - FUNC_EVAL_UNARY(left, sqrt, (double), optr, 1); + FUNC_EVAL_UNARY(left, sqrt, (double), optr, 1); } /* @@ -631,15 +631,15 @@ ex_sqrt(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr) static void ex_exp(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr) { - struct ex_ex *left; - float *op; /* output pointer */ - float *lp, *rp; /* left and right vector pointers */ - float scalar; - int j; + struct ex_ex *left; + float *op; /* output pointer */ + float *lp, *rp; /* left and right vector pointers */ + float scalar; + int j; - left = argv++; + left = argv++; - FUNC_EVAL_UNARY(left, exp, (double), optr, 1); + FUNC_EVAL_UNARY(left, exp, (double), optr, 1); } /* @@ -648,15 +648,15 @@ ex_exp(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr) static void ex_log(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr) { - struct ex_ex *left; - float *op; /* output pointer */ - float *lp, *rp; /* left and right vector pointers */ - float scalar; - int j; + struct ex_ex *left; + float *op; /* output pointer */ + float *lp, *rp; /* left and right vector pointers */ + float scalar; + int j; - left = argv++; + left = argv++; - FUNC_EVAL_UNARY(left, log10, (double), optr, 1); + FUNC_EVAL_UNARY(left, log10, (double), optr, 1); } /* @@ -665,101 +665,101 @@ ex_log(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr) static void ex_ln(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr) { - struct ex_ex *left; - float *op; /* output pointer */ - float *lp, *rp; /* left and right vector pointers */ - float scalar; - int j; + struct ex_ex *left; + float *op; /* output pointer */ + float *lp, *rp; /* left and right vector pointers */ + float scalar; + int j; - left = argv++; + left = argv++; - FUNC_EVAL_UNARY(left, log, (double), optr, 1); + FUNC_EVAL_UNARY(left, log, (double), optr, 1); } static void ex_sin(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr) { - struct ex_ex *left; - float *op; /* output pointer */ - float *lp, *rp; /* left and right vector pointers */ - float scalar; - int j; + struct ex_ex *left; + float *op; /* output pointer */ + float *lp, *rp; /* left and right vector pointers */ + float scalar; + int j; - left = argv++; + left = argv++; - FUNC_EVAL_UNARY(left, sin, (double), optr, 1); + FUNC_EVAL_UNARY(left, sin, (double), optr, 1); } static void ex_cos(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr) { - struct ex_ex *left; - float *op; /* output pointer */ - float *lp, *rp; /* left and right vector pointers */ - float scalar; - int j; + struct ex_ex *left; + float *op; /* output pointer */ + float *lp, *rp; /* left and right vector pointers */ + float scalar; + int j; - left = argv++; + left = argv++; - FUNC_EVAL_UNARY(left, cos, (double), optr, 1); + FUNC_EVAL_UNARY(left, cos, (double), optr, 1); } static void ex_tan(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr) { - struct ex_ex *left; - float *op; /* output pointer */ - float *lp, *rp; /* left and right vector pointers */ - float scalar; - int j; + struct ex_ex *left; + float *op; /* output pointer */ + float *lp, *rp; /* left and right vector pointers */ + float scalar; + int j; - left = argv++; + left = argv++; - FUNC_EVAL_UNARY(left, tan, (double), optr, 1); + FUNC_EVAL_UNARY(left, tan, (double), optr, 1); } static void ex_asin(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr) { - struct ex_ex *left; - float *op; /* output pointer */ - float *lp, *rp; /* left and right vector pointers */ - float scalar; - int j; + struct ex_ex *left; + float *op; /* output pointer */ + float *lp, *rp; /* left and right vector pointers */ + float scalar; + int j; - left = argv++; + left = argv++; - FUNC_EVAL_UNARY(left, asin, (double), optr, 1); + FUNC_EVAL_UNARY(left, asin, (double), optr, 1); } static void ex_acos(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr) { - struct ex_ex *left; - float *op; /* output pointer */ - float *lp, *rp; /* left and right vector pointers */ - float scalar; - int j; + struct ex_ex *left; + float *op; /* output pointer */ + float *lp, *rp; /* left and right vector pointers */ + float scalar; + int j; - left = argv++; + left = argv++; - FUNC_EVAL_UNARY(left, acos, (double), optr, 1); + FUNC_EVAL_UNARY(left, acos, (double), optr, 1); } static void ex_atan(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr) { - struct ex_ex *left; - float *op; /* output pointer */ - float *lp, *rp; /* left and right vector pointers */ - float scalar; - int j; + struct ex_ex *left; + float *op; /* output pointer */ + float *lp, *rp; /* left and right vector pointers */ + float scalar; + int j; - left = argv++; + left = argv++; - FUNC_EVAL_UNARY(left, atan, (double), optr, 1); + FUNC_EVAL_UNARY(left, atan, (double), optr, 1); } /* @@ -768,15 +768,15 @@ ex_atan(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr) static void ex_atan2(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr) { - struct ex_ex *left, *right; - float *op; /* output pointer */ - float *lp, *rp; /* left and right vector pointers */ - float scalar; - int j; - - left = argv++; - right = argv; - FUNC_EVAL(left, right, atan2, (double), (double), optr, 1); + struct ex_ex *left, *right; + float *op; /* output pointer */ + float *lp, *rp; /* left and right vector pointers */ + float scalar; + int j; + + left = argv++; + right = argv; + FUNC_EVAL(left, right, atan2, (double), (double), optr, 1); } /* @@ -785,15 +785,15 @@ ex_atan2(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr) static void ex_fmod(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr) { - struct ex_ex *left, *right; - float *op; /* output pointer */ - float *lp, *rp; /* left and right vector pointers */ - float scalar; - int j; - - left = argv++; - right = argv; - FUNC_EVAL(left, right, fmod, (double), (double), optr, 1); + struct ex_ex *left, *right; + float *op; /* output pointer */ + float *lp, *rp; /* left and right vector pointers */ + float scalar; + int j; + + left = argv++; + right = argv; + FUNC_EVAL(left, right, fmod, (double), (double), optr, 1); } @@ -803,14 +803,14 @@ ex_fmod(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr) static void ex_floor(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr) { - struct ex_ex *left; - float *op; /* output pointer */ - float *lp, *rp; /* left and right vector pointers */ - float scalar; - int j; - - left = argv++; - FUNC_EVAL_UNARY(left, floor, (double), optr, 1); + struct ex_ex *left; + float *op; /* output pointer */ + float *lp, *rp; /* left and right vector pointers */ + float scalar; + int j; + + left = argv++; + FUNC_EVAL_UNARY(left, floor, (double), optr, 1); } @@ -820,57 +820,57 @@ ex_floor(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr) static void ex_ceil(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr) { - struct ex_ex *left; - float *op; /* output pointer */ - float *lp, *rp; /* left and right vector pointers */ - float scalar; - int j; - - left = argv++; - FUNC_EVAL_UNARY(left, ceil, (double), optr, 1); + struct ex_ex *left; + float *op; /* output pointer */ + float *lp, *rp; /* left and right vector pointers */ + float scalar; + int j; + + left = argv++; + FUNC_EVAL_UNARY(left, ceil, (double), optr, 1); } static void ex_sinh(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr) { - struct ex_ex *left; - float *op; /* output pointer */ - float *lp, *rp; /* left and right vector pointers */ - float scalar; - int j; + struct ex_ex *left; + float *op; /* output pointer */ + float *lp, *rp; /* left and right vector pointers */ + float scalar; + int j; - left = argv++; + left = argv++; - FUNC_EVAL_UNARY(left, sinh, (double), optr, 1); + FUNC_EVAL_UNARY(left, sinh, (double), optr, 1); } static void ex_cosh(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr) { - struct ex_ex *left; - float *op; /* output pointer */ - float *lp, *rp; /* left and right vector pointers */ - float scalar; - int j; + struct ex_ex *left; + float *op; /* output pointer */ + float *lp, *rp; /* left and right vector pointers */ + float scalar; + int j; - left = argv++; + left = argv++; - FUNC_EVAL_UNARY(left, cosh, (double), optr, 1); + FUNC_EVAL_UNARY(left, cosh, (double), optr, 1); } static void ex_tanh(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr) { - struct ex_ex *left; - float *op; /* output pointer */ - float *lp, *rp; /* left and right vector pointers */ - float scalar; - int j; + struct ex_ex *left; + float *op; /* output pointer */ + float *lp, *rp; /* left and right vector pointers */ + float scalar; + int j; - left = argv++; + left = argv++; - FUNC_EVAL_UNARY(left, tanh, (double), optr, 1); + FUNC_EVAL_UNARY(left, tanh, (double), optr, 1); } @@ -878,81 +878,81 @@ ex_tanh(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr) static void ex_asinh(t_expr *e, long argc, struct ex_ex *argv, struct ex_ex *optr) { - struct ex_ex *left; - float *op; /* output pointer */ - float *lp, *rp; /* left and right vector pointers */ - float scalar; - int j; + struct ex_ex *left; + float *op; /* output pointer */ + float *lp, *rp; /* left and right vector pointers */ + float scalar; + int j; - left = argv++; + left = argv++; - FUNC_EVAL_UNARY(left, asinh, (double), optr, 1); + FUNC_EVAL_UNARY(left, asinh, (double), optr, 1); } static void ex_acosh(t_expr *e, long argc, struct ex_ex *argv, struct ex_ex *optr) { - struct ex_ex *left; - float *op; /* output pointer */ - float *lp, *rp; /* left and right vector pointers */ - float scalar; - int j; + struct ex_ex *left; + float *op; /* output pointer */ + float *lp, *rp; /* left and right vector pointers */ + float scalar; + int j; - left = argv++; + left = argv++; - FUNC_EVAL_UNARY(left, acosh, (double), optr, 1); + FUNC_EVAL_UNARY(left, acosh, (double), optr, 1); } static void ex_atanh(t_expr *e, long argc, struct ex_ex *argv, struct ex_ex *optr) { - struct ex_ex *left; - float *op; /* output pointer */ - float *lp, *rp; /* left and right vector pointers */ - float scalar; - int j; + struct ex_ex *left; + float *op; /* output pointer */ + float *lp, *rp; /* left and right vector pointers */ + float scalar; + int j; - left = argv++; + left = argv++; - FUNC_EVAL_UNARY(left, atanh, (double), optr, 1); + FUNC_EVAL_UNARY(left, atanh, (double), optr, 1); } #endif static int ex_dofact(int i) { - int ret = 0; + int ret = 0; - if (i) - ret = 1; - else - return (0); + if (i) + ret = 1; + else + return (0); - do { - ret *= i; - } while (--i); + do { + ret *= i; + } while (--i); - return(ret); + return(ret); } static void ex_fact(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr) { - struct ex_ex *left; - float *op; /* output pointer */ - float *lp, *rp; /* left and right vector pointers */ - float scalar; - int j; + struct ex_ex *left; + float *op; /* output pointer */ + float *lp, *rp; /* left and right vector pointers */ + float scalar; + int j; - left = argv++; + left = argv++; - FUNC_EVAL_UNARY(left, ex_dofact, (int), optr, 0); + FUNC_EVAL_UNARY(left, ex_dofact, (int), optr, 0); } static int ex_dorandom(int i1, int i2) { - return(i1 + (((i2 - i1) * (rand() & 0x7fffL)) >> 15)); + return(i1 + (((i2 - i1) * (rand() & 0x7fffL)) >> 15)); } /* * ex_random -- return a random number @@ -960,30 +960,30 @@ ex_dorandom(int i1, int i2) static void ex_random(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr) { - struct ex_ex *left, *right; - float *op; /* output pointer */ - float *lp, *rp; /* left and right vector pointers */ - float scalar; - int j; - - left = argv++; - right = argv; - FUNC_EVAL(left, right, ex_dorandom, (int), (int), optr, 0); + struct ex_ex *left, *right; + float *op; /* output pointer */ + float *lp, *rp; /* left and right vector pointers */ + float scalar; + int j; + + left = argv++; + right = argv; + FUNC_EVAL(left, right, ex_dorandom, (int), (int), optr, 0); } static void ex_abs(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr) { - struct ex_ex *left; - float *op; /* output pointer */ - float *lp, *rp; /* left and right vector pointers */ - float scalar; - int j; + struct ex_ex *left; + float *op; /* output pointer */ + float *lp, *rp; /* left and right vector pointers */ + float scalar; + int j; - left = argv++; + left = argv++; - FUNC_EVAL_UNARY(left, fabs, (double), optr, 0); + FUNC_EVAL_UNARY(left, fabs, (double), optr, 0); } /* @@ -992,231 +992,231 @@ ex_abs(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr) static void ex_if(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr) { - struct ex_ex *left, *right, *cond, *res; - float *op; /* output pointer */ - float *lp, *rp; /* left and right vector pointers */ - float *cp; /* condition pointer */ - float leftvalue, rightvalue; - int j; - - cond = argv++; - left = argv++; - right = argv; - - switch (cond->ex_type) { - case ET_VEC: - case ET_VI: - if (optr->ex_type != ET_VEC) { - if (optr->ex_type == ET_VI) { - /* SDY remove this test */ - post("expr~: Int. error %d", __LINE__); - return; - } - optr->ex_type = ET_VEC; - optr->ex_vec = (t_float *) - fts_malloc(sizeof (t_float) * e->exp_vsize); - } - op = optr->ex_vec; - j = e->exp_vsize; - cp = cond->ex_vec; - switch (left->ex_type) { - case ET_INT: - leftvalue = left->ex_int; - switch (right->ex_type) { - case ET_INT: - rightvalue = right->ex_int; - while (j--) { - if (*cp++) - *op++ = leftvalue; - else - *op++ = rightvalue; - } - return; - case ET_FLT: - rightvalue = right->ex_flt; - while (j--) { - if (*cp++) - *op++ = leftvalue; - else - *op++ = rightvalue; - } - return; - case ET_VEC: - case ET_VI: - rp = right->ex_vec; - while (j--) { - if (*cp++) - *op++ = leftvalue; - else - *op++ = *rp; - rp++; - } - return; - case ET_SYM: - default: - post_error((fts_object_t *) e, - "expr: FUNC_EVAL(%d): bad right type %ld\n", - __LINE__, right->ex_type); - return; - } - case ET_FLT: - leftvalue = left->ex_flt; - switch (right->ex_type) { - case ET_INT: - rightvalue = right->ex_int; - while (j--) { - if (*cp++) - *op++ = leftvalue; - else - *op++ = rightvalue; - } - return; - case ET_FLT: - rightvalue = right->ex_flt; - while (j--) { - if (*cp++) - *op++ = leftvalue; - else - *op++ = rightvalue; - } - return; - case ET_VEC: - case ET_VI: - rp = right->ex_vec; - while (j--) { - if (*cp++) - *op++ = leftvalue; - else - *op++ = *rp; - rp++; - } - return; - case ET_SYM: - default: - post_error((fts_object_t *) e, - "expr: FUNC_EVAL(%d): bad right type %ld\n", - __LINE__, right->ex_type); - return; - } - case ET_VEC: - case ET_VI: - lp = left->ex_vec; - switch (right->ex_type) { - case ET_INT: - rightvalue = right->ex_int; - while (j--) { - if (*cp++) - *op++ = *lp; - else - *op++ = rightvalue; - lp++; - } - return; - case ET_FLT: - rightvalue = right->ex_flt; - while (j--) { - if (*cp++) - *op++ = *lp; - else - *op++ = rightvalue; - lp++; - } - return; - case ET_VEC: - case ET_VI: - rp = right->ex_vec; - while (j--) { - if (*cp++) - *op++ = *lp; - else - *op++ = *rp; - lp++; rp++; - } - return; - case ET_SYM: - default: - post_error((fts_object_t *) e, - "expr: FUNC_EVAL(%d): bad right type %ld\n", - __LINE__, right->ex_type); - return; - } - case ET_SYM: - default: - post_error((fts_object_t *) e, - "expr: FUNC_EVAL(%d): bad left type %ld\n", - __LINE__, left->ex_type); - return; - } - case ET_INT: - if (cond->ex_int) - res = left; - else - res = right; - break; - case ET_FLT: - if (cond->ex_flt) - res = left; - else - res = right; - break; - case ET_SYM: - default: - post_error((fts_object_t *) e, - "expr: FUNC_EVAL(%d): bad condition type %ld\n", - __LINE__, cond->ex_type); - return; - } - switch(res->ex_type) { - case ET_INT: - if (optr->ex_type == ET_VEC) { - ex_mkvector(optr->ex_vec, (float)res->ex_int, - e->exp_vsize); - return; - } - *optr = *res; - return; - case ET_FLT: - if (optr->ex_type == ET_VEC) { - ex_mkvector(optr->ex_vec, (float)res->ex_flt, - e->exp_vsize); - return; - } - *optr = *res; - return; - case ET_VEC: - case ET_VI: - if (optr->ex_type != ET_VEC) { - if (optr->ex_type == ET_VI) { - /* SDY remove this test */ - post("expr~: Int. error %d", __LINE__); - return; - } - optr->ex_type = ET_VEC; - optr->ex_vec = (t_float *) - fts_malloc(sizeof (t_float) * e->exp_vsize); - } - memcpy(optr->ex_vec, res->ex_vec, e->exp_vsize*sizeof(t_float)); - return; - case ET_SYM: - default: - post_error((fts_object_t *) e, - "expr: FUNC_EVAL(%d): bad res type %ld\n", - __LINE__, res->ex_type); - return; - } - + struct ex_ex *left, *right, *cond, *res; + float *op; /* output pointer */ + float *lp, *rp; /* left and right vector pointers */ + float *cp; /* condition pointer */ + float leftvalue, rightvalue; + int j; + + cond = argv++; + left = argv++; + right = argv; + + switch (cond->ex_type) { + case ET_VEC: + case ET_VI: + if (optr->ex_type != ET_VEC) { + if (optr->ex_type == ET_VI) { + /* SDY remove this test */ + post("expr~: Int. error %d", __LINE__); + return; + } + optr->ex_type = ET_VEC; + optr->ex_vec = (t_float *) + fts_malloc(sizeof (t_float) * e->exp_vsize); + } + op = optr->ex_vec; + j = e->exp_vsize; + cp = cond->ex_vec; + switch (left->ex_type) { + case ET_INT: + leftvalue = left->ex_int; + switch (right->ex_type) { + case ET_INT: + rightvalue = right->ex_int; + while (j--) { + if (*cp++) + *op++ = leftvalue; + else + *op++ = rightvalue; + } + return; + case ET_FLT: + rightvalue = right->ex_flt; + while (j--) { + if (*cp++) + *op++ = leftvalue; + else + *op++ = rightvalue; + } + return; + case ET_VEC: + case ET_VI: + rp = right->ex_vec; + while (j--) { + if (*cp++) + *op++ = leftvalue; + else + *op++ = *rp; + rp++; + } + return; + case ET_SYM: + default: + post_error((fts_object_t *) e, + "expr: FUNC_EVAL(%d): bad right type %ld\n", + __LINE__, right->ex_type); + return; + } + case ET_FLT: + leftvalue = left->ex_flt; + switch (right->ex_type) { + case ET_INT: + rightvalue = right->ex_int; + while (j--) { + if (*cp++) + *op++ = leftvalue; + else + *op++ = rightvalue; + } + return; + case ET_FLT: + rightvalue = right->ex_flt; + while (j--) { + if (*cp++) + *op++ = leftvalue; + else + *op++ = rightvalue; + } + return; + case ET_VEC: + case ET_VI: + rp = right->ex_vec; + while (j--) { + if (*cp++) + *op++ = leftvalue; + else + *op++ = *rp; + rp++; + } + return; + case ET_SYM: + default: + post_error((fts_object_t *) e, + "expr: FUNC_EVAL(%d): bad right type %ld\n", + __LINE__, right->ex_type); + return; + } + case ET_VEC: + case ET_VI: + lp = left->ex_vec; + switch (right->ex_type) { + case ET_INT: + rightvalue = right->ex_int; + while (j--) { + if (*cp++) + *op++ = *lp; + else + *op++ = rightvalue; + lp++; + } + return; + case ET_FLT: + rightvalue = right->ex_flt; + while (j--) { + if (*cp++) + *op++ = *lp; + else + *op++ = rightvalue; + lp++; + } + return; + case ET_VEC: + case ET_VI: + rp = right->ex_vec; + while (j--) { + if (*cp++) + *op++ = *lp; + else + *op++ = *rp; + lp++; rp++; + } + return; + case ET_SYM: + default: + post_error((fts_object_t *) e, + "expr: FUNC_EVAL(%d): bad right type %ld\n", + __LINE__, right->ex_type); + return; + } + case ET_SYM: + default: + post_error((fts_object_t *) e, + "expr: FUNC_EVAL(%d): bad left type %ld\n", + __LINE__, left->ex_type); + return; + } + case ET_INT: + if (cond->ex_int) + res = left; + else + res = right; + break; + case ET_FLT: + if (cond->ex_flt) + res = left; + else + res = right; + break; + case ET_SYM: + default: + post_error((fts_object_t *) e, + "expr: FUNC_EVAL(%d): bad condition type %ld\n", + __LINE__, cond->ex_type); + return; + } + switch(res->ex_type) { + case ET_INT: + if (optr->ex_type == ET_VEC) { + ex_mkvector(optr->ex_vec, (float)res->ex_int, + e->exp_vsize); + return; + } + *optr = *res; + return; + case ET_FLT: + if (optr->ex_type == ET_VEC) { + ex_mkvector(optr->ex_vec, (float)res->ex_flt, + e->exp_vsize); + return; + } + *optr = *res; + return; + case ET_VEC: + case ET_VI: + if (optr->ex_type != ET_VEC) { + if (optr->ex_type == ET_VI) { + /* SDY remove this test */ + post("expr~: Int. error %d", __LINE__); + return; + } + optr->ex_type = ET_VEC; + optr->ex_vec = (t_float *) + fts_malloc(sizeof (t_float) * e->exp_vsize); + } + memcpy(optr->ex_vec, res->ex_vec, e->exp_vsize*sizeof(t_float)); + return; + case ET_SYM: + default: + post_error((fts_object_t *) e, + "expr: FUNC_EVAL(%d): bad res type %ld\n", + __LINE__, res->ex_type); + return; + } + } /* - * ex_imodf - extract signed integral value from floating-point number + * ex_imodf - extract signed integral value from floating-point number */ static double imodf(double x) { - double xx; + double xx; - modf(x, &xx); - return (xx); + modf(x, &xx); + return (xx); } FUNC_DEF_UNARY(ex_imodf, imodf, (double), 1); @@ -1228,9 +1228,9 @@ FUNC_DEF_UNARY(ex_imodf, imodf, (double), 1); static double fracmodf(double x) { - double xx; + double xx; - return(modf(x, &xx)); + return(modf(x, &xx)); } FUNC_DEF_UNARY(ex_modf, fracmodf, (double), 1); diff --git a/pd/extra/expr~/vexp_if.c b/pd/extra/expr~/vexp_if.c index b183b620..08dc55c3 100644 --- a/pd/extra/expr~/vexp_if.c +++ b/pd/extra/expr~/vexp_if.c @@ -30,8 +30,8 @@ /* * Feb 2002 - added access to variables * multiple expression support - * new short hand forms for fexpr~ - * now $y or $y1 = $y1[-1] and $y2 = $y2[-1] + * new short hand forms for fexpr~ + * now $y or $y1 = $y1[-1] and $y2 = $y2[-1] * --sdy */ @@ -44,7 +44,7 @@ static char *exp_version = "0.4"; extern struct ex_ex *ex_eval(struct expr *expr, struct ex_ex *eptr, - struct ex_ex *optr, int n); + struct ex_ex *optr, int n); #ifdef PD static t_class *expr_class; @@ -68,51 +68,51 @@ t_int *expr_perform(t_int *w); static void expr_list(t_expr *x, t_symbol *s, int argc, const fts_atom_t *argv) { - int i; - - if (argc > MAX_VARS) argc = MAX_VARS; - - for (i = 0; i < argc; i++) - { - if (argv[i].a_type == A_FLOAT) - { - if (x->exp_var[i].ex_type == ET_FI) - x->exp_var[i].ex_flt = argv[i].a_w.w_float; - else if (x->exp_var[i].ex_type == ET_II) - x->exp_var[i].ex_int = argv[i].a_w.w_float; - else if (x->exp_var[i].ex_type) - pd_error(x, "expr: type mismatch"); - } - else if (argv[i].a_type == A_SYMBOL) - { - if (x->exp_var[i].ex_type == ET_SI) - x->exp_var[i].ex_ptr = (char *)argv[i].a_w.w_symbol; - else if (x->exp_var[i].ex_type) - pd_error(x, "expr: type mismatch"); - } - } - expr_bang(x); + int i; + + if (argc > MAX_VARS) argc = MAX_VARS; + + for (i = 0; i < argc; i++) + { + if (argv[i].a_type == A_FLOAT) + { + if (x->exp_var[i].ex_type == ET_FI) + x->exp_var[i].ex_flt = argv[i].a_w.w_float; + else if (x->exp_var[i].ex_type == ET_II) + x->exp_var[i].ex_int = argv[i].a_w.w_float; + else if (x->exp_var[i].ex_type) + pd_error(x, "expr: type mismatch"); + } + else if (argv[i].a_type == A_SYMBOL) + { + if (x->exp_var[i].ex_type == ET_SI) + x->exp_var[i].ex_ptr = (char *)argv[i].a_w.w_symbol; + else if (x->exp_var[i].ex_type) + pd_error(x, "expr: type mismatch"); + } + } + expr_bang(x); } static void expr_flt(t_expr *x, t_float f, int in) { - if (in > MAX_VARS) - return; + if (in > MAX_VARS) + return; - if (x->exp_var[in].ex_type == ET_FI) - x->exp_var[in].ex_flt = f; - else if (x->exp_var[in].ex_type == ET_II) - x->exp_var[in].ex_int = f; + if (x->exp_var[in].ex_type == ET_FI) + x->exp_var[in].ex_flt = f; + else if (x->exp_var[in].ex_type == ET_II) + x->exp_var[in].ex_int = f; } static t_class *exprproxy_class; typedef struct _exprproxy { - t_pd p_pd; - int p_index; - t_expr *p_owner; - struct _exprproxy *p_next; + t_pd p_pd; + int p_index; + t_expr *p_owner; + struct _exprproxy *p_next; } t_exprproxy; t_exprproxy *exprproxy_new(t_expr *owner, int indx); @@ -121,63 +121,63 @@ void exprproxy_float(t_exprproxy *p, t_floatarg f); t_exprproxy * exprproxy_new(t_expr *owner, int indx) { - t_exprproxy *x = (t_exprproxy *)pd_new(exprproxy_class); - x->p_owner = owner; - x->p_index = indx; - x->p_next = owner->exp_proxy; - owner->exp_proxy = x; - return (x); + t_exprproxy *x = (t_exprproxy *)pd_new(exprproxy_class); + x->p_owner = owner; + x->p_index = indx; + x->p_next = owner->exp_proxy; + owner->exp_proxy = x; + return (x); } void exprproxy_float(t_exprproxy *p, t_floatarg f) { - t_expr *x = p->p_owner; - int in = p->p_index; + t_expr *x = p->p_owner; + int in = p->p_index; - if (in > MAX_VARS) - return; + if (in > MAX_VARS) + return; - if (x->exp_var[in].ex_type == ET_FI) - x->exp_var[in].ex_flt = f; - else if (x->exp_var[in].ex_type == ET_II) - x->exp_var[in].ex_int = f; + if (x->exp_var[in].ex_type == ET_FI) + x->exp_var[in].ex_flt = f; + else if (x->exp_var[in].ex_type == ET_II) + x->exp_var[in].ex_int = f; } /* method definitions */ static void expr_ff(t_expr *x) { - t_exprproxy *y; - int i; - - y = x->exp_proxy; - while (y) - { - x->exp_proxy = y->p_next; + t_exprproxy *y; + int i; + + y = x->exp_proxy; + while (y) + { + x->exp_proxy = y->p_next; #ifdef PD - pd_free(&y->p_pd); + pd_free(&y->p_pd); #else /*MSP */ - /* SDY find out what needs to be called for MSP */ + /* SDY find out what needs to be called for MSP */ #endif - y = x->exp_proxy; - } - for (i = 0 ; i < x->exp_nexpr; i++); - if (x->exp_stack[i]) - fts_free(x->exp_stack[i]); + y = x->exp_proxy; + } + for (i = 0 ; i < x->exp_nexpr; i++); + if (x->exp_stack[i]) + fts_free(x->exp_stack[i]); /* * SDY free all the allocated buffers here for expr~ and fexpr~ * check to see if there are others */ - for (i = 0; i < MAX_VARS; i++) { - if (x->exp_p_var[i]) - fts_free(x->exp_p_var[i]); - if (x->exp_p_res[i]) - fts_free(x->exp_p_res[i]); - if (x->exp_tmpres[i]) - fts_free(x->exp_tmpres[i]); - } + for (i = 0; i < MAX_VARS; i++) { + if (x->exp_p_var[i]) + fts_free(x->exp_p_var[i]); + if (x->exp_p_res[i]) + fts_free(x->exp_p_res[i]); + if (x->exp_tmpres[i]) + fts_free(x->exp_tmpres[i]); + } } @@ -185,61 +185,61 @@ expr_ff(t_expr *x) static void expr_bang(t_expr *x) { - int i; + int i; #ifdef EXPR_DEBUG - { - struct ex_ex *eptr; - - for (i = 0, eptr = x->exp_var; ; eptr++, i++) - { - if (!eptr->ex_type) - break; - switch (eptr->ex_type) - { - case ET_II: - fprintf(stderr,"ET_II: %d \n", eptr->ex_int); - break; - - case ET_FI: - fprintf(stderr,"ET_FT: %f \n", eptr->ex_flt); - break; - - default: - fprintf(stderr,"oups\n"); - } - } - } + { + struct ex_ex *eptr; + + for (i = 0, eptr = x->exp_var; ; eptr++, i++) + { + if (!eptr->ex_type) + break; + switch (eptr->ex_type) + { + case ET_II: + fprintf(stderr,"ET_II: %d \n", eptr->ex_int); + break; + + case ET_FI: + fprintf(stderr,"ET_FT: %f \n", eptr->ex_flt); + break; + + default: + fprintf(stderr,"oups\n"); + } + } + } #endif - /* banging a signal or filter object means nothing */ - if (!IS_EXPR(x)) - return; - - for (i = x->exp_nexpr - 1; i > -1 ; i--) { - if (!ex_eval(x, x->exp_stack[i], &x->exp_res[i], 0)) { - /*fprintf(stderr,"expr_bang(error evaluation)\n"); */ - /* SDY now that we have mutiple ones, on error we should - * continue - return; - */ - } - switch(x->exp_res[i].ex_type) { - case ET_INT: - outlet_float(x->exp_outlet[i], - (t_float) x->exp_res[i].ex_int); - break; - - case ET_FLT: - outlet_float(x->exp_outlet[i], x->exp_res[i].ex_flt); - break; - - case ET_SYM: - /* CHANGE this will have to be taken care of */ - - default: - post("expr: bang: unrecognized result %ld\n", x->exp_res[i].ex_type); - } - } + /* banging a signal or filter object means nothing */ + if (!IS_EXPR(x)) + return; + + for (i = x->exp_nexpr - 1; i > -1 ; i--) { + if (!ex_eval(x, x->exp_stack[i], &x->exp_res[i], 0)) { + /*fprintf(stderr,"expr_bang(error evaluation)\n"); */ + /* SDY now that we have mutiple ones, on error we should + * continue + return; + */ + } + switch(x->exp_res[i].ex_type) { + case ET_INT: + outlet_float(x->exp_outlet[i], + (t_float) x->exp_res[i].ex_int); + break; + + case ET_FLT: + outlet_float(x->exp_outlet[i], x->exp_res[i].ex_flt); + break; + + case ET_SYM: + /* CHANGE this will have to be taken care of */ + + default: + post("expr: bang: unrecognized result %ld\n", x->exp_res[i].ex_type); + } + } } static t_expr * @@ -249,320 +249,320 @@ expr_new(t_symbol *s, int ac, t_atom *av) Nexpr_new(t_symbol *s, int ac, t_atom *av) #endif { - struct expr *x; - int i, ninlet; - struct ex_ex *eptr; - t_atom fakearg; - int dsp_index; /* keeping track of the dsp inlets */ + struct expr *x; + int i, ninlet; + struct ex_ex *eptr; + t_atom fakearg; + int dsp_index; /* keeping track of the dsp inlets */ /* * SDY - we may need to call dsp_setup() in this function */ - if (!ac) - { - ac = 1; - av = &fakearg; - SETFLOAT(&fakearg, 0); - } + if (!ac) + { + ac = 1; + av = &fakearg; + SETFLOAT(&fakearg, 0); + } #ifdef PD - /* - * figure out if we are expr, expr~, or fexpr~ - */ - if (!strcmp("expr", s->s_name)) { - x = (t_expr *)pd_new(expr_class); - SET_EXPR(x); - } else if (!strcmp("expr~", s->s_name)) { - x = (t_expr *)pd_new(expr_tilde_class); - SET_EXPR_TILDE(x); - } else if (!strcmp("fexpr~", s->s_name)) { - x = (t_expr *)pd_new(fexpr_tilde_class); - SET_FEXPR_TILDE(x); - } else { - post("expr_new: bad object name '%s'"); - /* assume expr */ - x = (t_expr *)pd_new(expr_class); - SET_EXPR(x); - } + /* + * figure out if we are expr, expr~, or fexpr~ + */ + if (!strcmp("expr", s->s_name)) { + x = (t_expr *)pd_new(expr_class); + SET_EXPR(x); + } else if (!strcmp("expr~", s->s_name)) { + x = (t_expr *)pd_new(expr_tilde_class); + SET_EXPR_TILDE(x); + } else if (!strcmp("fexpr~", s->s_name)) { + x = (t_expr *)pd_new(fexpr_tilde_class); + SET_FEXPR_TILDE(x); + } else { + post("expr_new: bad object name '%s'"); + /* assume expr */ + x = (t_expr *)pd_new(expr_class); + SET_EXPR(x); + } #else /* MSP */ - /* for now assume an expr~ */ - x = (t_expr *)pd_new(expr_tilde_class); - SET_EXPR_TILDE(x); -#endif - - /* - * initialize the newly allocated object - */ - x->exp_proxy = 0; - x->exp_nivec = 0; - x->exp_nexpr = 0; - x->exp_error = 0; - for (i = 0; i < MAX_VARS; i++) { - x->exp_stack[i] = (struct ex_ex *)0; - x->exp_outlet[i] = (t_outlet *)0; - x->exp_res[i].ex_type = 0; - x->exp_res[i].ex_int = 0; - x->exp_p_res[i] = (t_float *)0; - x->exp_var[i].ex_type = 0; - x->exp_var[i].ex_int = 0; - x->exp_p_var[i] = (t_float *)0; - x->exp_tmpres[i] = (t_float *)0; - x->exp_vsize = 0; - } - x->exp_f = 0; /* save the control value to be transformed to signal */ - - - if (expr_donew(x, ac, av)) - { - pd_error(x, "expr: syntax error"); + /* for now assume an expr~ */ + x = (t_expr *)pd_new(expr_tilde_class); + SET_EXPR_TILDE(x); +#endif + + /* + * initialize the newly allocated object + */ + x->exp_proxy = 0; + x->exp_nivec = 0; + x->exp_nexpr = 0; + x->exp_error = 0; + for (i = 0; i < MAX_VARS; i++) { + x->exp_stack[i] = (struct ex_ex *)0; + x->exp_outlet[i] = (t_outlet *)0; + x->exp_res[i].ex_type = 0; + x->exp_res[i].ex_int = 0; + x->exp_p_res[i] = (t_float *)0; + x->exp_var[i].ex_type = 0; + x->exp_var[i].ex_int = 0; + x->exp_p_var[i] = (t_float *)0; + x->exp_tmpres[i] = (t_float *)0; + x->exp_vsize = 0; + } + x->exp_f = 0; /* save the control value to be transformed to signal */ + + + if (expr_donew(x, ac, av)) + { + pd_error(x, "expr: syntax error"); /* SDY the following coredumps why? - pd_free(&x->exp_ob.ob_pd); + pd_free(&x->exp_ob.ob_pd); */ - return (0); - } - - ninlet = 1; - for (i = 0, eptr = x->exp_var; i < MAX_VARS ; i++, eptr++) - if (eptr->ex_type) { - ninlet = i + 1; - } - - /* - * create the new inlets - */ - for (i = 1, eptr = x->exp_var + 1, dsp_index=1; iex_type) - { - case 0: - /* nothing is using this inlet */ - if (i < ninlet) + return (0); + } + + ninlet = 1; + for (i = 0, eptr = x->exp_var; i < MAX_VARS ; i++, eptr++) + if (eptr->ex_type) { + ninlet = i + 1; + } + + /* + * create the new inlets + */ + for (i = 1, eptr = x->exp_var + 1, dsp_index=1; iex_type) + { + case 0: + /* nothing is using this inlet */ + if (i < ninlet) #ifdef PD - floatinlet_new(&x->exp_ob, &eptr->ex_flt); + floatinlet_new(&x->exp_ob, &eptr->ex_flt); #else /* MSP */ - inlet_new(&x->exp_ob, "float"); + inlet_new(&x->exp_ob, "float"); #endif - break; + break; - case ET_II: - case ET_FI: - p = exprproxy_new(x, i); + case ET_II: + case ET_FI: + p = exprproxy_new(x, i); #ifdef PD - inlet_new(&x->exp_ob, &p->p_pd, &s_float, &s_float); + inlet_new(&x->exp_ob, &p->p_pd, &s_float, &s_float); #else /* MSP */ - inlet_new(&x->exp_ob, "float"); + inlet_new(&x->exp_ob, "float"); #endif - break; + break; - case ET_SI: + case ET_SI: #ifdef PD - symbolinlet_new(&x->exp_ob, (t_symbol **)&eptr->ex_ptr); + symbolinlet_new(&x->exp_ob, (t_symbol **)&eptr->ex_ptr); #else /* MSP */ - inlet_new(&x->exp_ob, "symbol"); + inlet_new(&x->exp_ob, "symbol"); #endif - break; + break; - case ET_XI: - case ET_VI: - if (!IS_EXPR(x)) { - dsp_index++; + case ET_XI: + case ET_VI: + if (!IS_EXPR(x)) { + dsp_index++; #ifdef PD - inlet_new(&x->exp_ob, &x->exp_ob.ob_pd, - &s_signal, &s_signal); + inlet_new(&x->exp_ob, &x->exp_ob.ob_pd, + &s_signal, &s_signal); #else /* MSP */ - inlet_new(&x->exp_ob, "signal"); + inlet_new(&x->exp_ob, "signal"); #endif - break; - } else - post("expr: internal error expr_new"); - default: - pd_error(x, "expr: bad type (%lx) inlet = %d\n", - eptr->ex_type, i + 1, 0, 0, 0); - break; - } - } - if (IS_EXPR(x)) { - for (i = 0; i < x->exp_nexpr; i++) - x->exp_outlet[i] = outlet_new(&x->exp_ob, 0); - } else { - for (i = 0; i < x->exp_nexpr; i++) - x->exp_outlet[i] = outlet_new(&x->exp_ob, - gensym("signal")); - x->exp_nivec = dsp_index; - } - /* - * for now assume a 64 sample size block but this may change once - * expr_dsp is called - */ - x->exp_vsize = 64; - for (i = 0; i < x->exp_nexpr; i++) { - x->exp_p_res[i] = fts_calloc(x->exp_vsize, sizeof (t_float)); - x->exp_tmpres[i] = fts_calloc(x->exp_vsize, sizeof (t_float)); - } - for (i = 0; i < MAX_VARS; i++) - x->exp_p_var[i] = fts_calloc(x->exp_vsize, sizeof (t_float)); - - return (x); + break; + } else + post("expr: internal error expr_new"); + default: + pd_error(x, "expr: bad type (%lx) inlet = %d\n", + eptr->ex_type, i + 1, 0, 0, 0); + break; + } + } + if (IS_EXPR(x)) { + for (i = 0; i < x->exp_nexpr; i++) + x->exp_outlet[i] = outlet_new(&x->exp_ob, 0); + } else { + for (i = 0; i < x->exp_nexpr; i++) + x->exp_outlet[i] = outlet_new(&x->exp_ob, + gensym("signal")); + x->exp_nivec = dsp_index; + } + /* + * for now assume a 64 sample size block but this may change once + * expr_dsp is called + */ + x->exp_vsize = 64; + for (i = 0; i < x->exp_nexpr; i++) { + x->exp_p_res[i] = fts_calloc(x->exp_vsize, sizeof (t_float)); + x->exp_tmpres[i] = fts_calloc(x->exp_vsize, sizeof (t_float)); + } + for (i = 0; i < MAX_VARS; i++) + x->exp_p_var[i] = fts_calloc(x->exp_vsize, sizeof (t_float)); + + return (x); } t_int * expr_perform(t_int *w) { - int i, j; - t_expr *x = (t_expr *)w[1]; - struct ex_ex res; - int n; - - /* sanity check */ - if (IS_EXPR(x)) { - post("expr_perform: bad x->exp_flags = %d", x->exp_flags); - abort(); - } - - if (x->exp_flags & EF_STOP) { - for (i = 0; i < x->exp_nexpr; i++) - memset(x->exp_res[i].ex_vec, 0, - x->exp_vsize * sizeof (float)); - return (w + 2); - } - - if (IS_EXPR_TILDE(x)) { - /* - * if we have only one expression, we can right on - * on the output directly, otherwise we have to copy - * the data because, outputs could be the same buffer as - * inputs - */ - if ( x->exp_nexpr == 1) - ex_eval(x, x->exp_stack[0], &x->exp_res[0], 0); - else { - res.ex_type = ET_VEC; - for (i = 0; i < x->exp_nexpr; i++) { - res.ex_vec = x->exp_tmpres[i]; - ex_eval(x, x->exp_stack[i], &res, 0); - } - n = x->exp_vsize * sizeof(t_float); - for (i = 0; i < x->exp_nexpr; i++) - memcpy(x->exp_res[i].ex_vec, x->exp_tmpres[i], - n); - } - return (w + 2); - } - - if (!IS_FEXPR_TILDE(x)) { - post("expr_perform: bad x->exp_flags = %d - expecting fexpr", - x->exp_flags); - return (w + 2); - } - /* - * since the output buffer could be the same as one of the inputs - * we need to keep the output in a different buffer - */ - for (i = 0; i < x->exp_vsize; i++) for (j = 0; j < x->exp_nexpr; j++) { - res.ex_type = 0; - res.ex_int = 0; - ex_eval(x, x->exp_stack[j], &res, i); - switch (res.ex_type) { - case ET_INT: - x->exp_tmpres[j][i] = (t_float) res.ex_int; - break; - case ET_FLT: - x->exp_tmpres[j][i] = res.ex_flt; - break; - default: - post("expr_perform: bad result type %d", res.ex_type); - } - } - /* - * copy inputs and results to the save buffers - * inputs need to be copied first as the output buffer can be - * same as an input buffer - */ - n = x->exp_vsize * sizeof(t_float); - for (i = 0; i < MAX_VARS; i++) - if (x->exp_var[i].ex_type == ET_XI) - memcpy(x->exp_p_var[i], x->exp_var[i].ex_vec, n); - for (i = 0; i < x->exp_nexpr; i++) { - memcpy(x->exp_p_res[i], x->exp_tmpres[i], n); - memcpy(x->exp_res[i].ex_vec, x->exp_tmpres[i], n); - } - return (w + 2); + int i, j; + t_expr *x = (t_expr *)w[1]; + struct ex_ex res; + int n; + + /* sanity check */ + if (IS_EXPR(x)) { + post("expr_perform: bad x->exp_flags = %d", x->exp_flags); + abort(); + } + + if (x->exp_flags & EF_STOP) { + for (i = 0; i < x->exp_nexpr; i++) + memset(x->exp_res[i].ex_vec, 0, + x->exp_vsize * sizeof (float)); + return (w + 2); + } + + if (IS_EXPR_TILDE(x)) { + /* + * if we have only one expression, we can right on + * on the output directly, otherwise we have to copy + * the data because, outputs could be the same buffer as + * inputs + */ + if ( x->exp_nexpr == 1) + ex_eval(x, x->exp_stack[0], &x->exp_res[0], 0); + else { + res.ex_type = ET_VEC; + for (i = 0; i < x->exp_nexpr; i++) { + res.ex_vec = x->exp_tmpres[i]; + ex_eval(x, x->exp_stack[i], &res, 0); + } + n = x->exp_vsize * sizeof(t_float); + for (i = 0; i < x->exp_nexpr; i++) + memcpy(x->exp_res[i].ex_vec, x->exp_tmpres[i], + n); + } + return (w + 2); + } + + if (!IS_FEXPR_TILDE(x)) { + post("expr_perform: bad x->exp_flags = %d - expecting fexpr", + x->exp_flags); + return (w + 2); + } + /* + * since the output buffer could be the same as one of the inputs + * we need to keep the output in a different buffer + */ + for (i = 0; i < x->exp_vsize; i++) for (j = 0; j < x->exp_nexpr; j++) { + res.ex_type = 0; + res.ex_int = 0; + ex_eval(x, x->exp_stack[j], &res, i); + switch (res.ex_type) { + case ET_INT: + x->exp_tmpres[j][i] = (t_float) res.ex_int; + break; + case ET_FLT: + x->exp_tmpres[j][i] = res.ex_flt; + break; + default: + post("expr_perform: bad result type %d", res.ex_type); + } + } + /* + * copy inputs and results to the save buffers + * inputs need to be copied first as the output buffer can be + * same as an input buffer + */ + n = x->exp_vsize * sizeof(t_float); + for (i = 0; i < MAX_VARS; i++) + if (x->exp_var[i].ex_type == ET_XI) + memcpy(x->exp_p_var[i], x->exp_var[i].ex_vec, n); + for (i = 0; i < x->exp_nexpr; i++) { + memcpy(x->exp_p_res[i], x->exp_tmpres[i], n); + memcpy(x->exp_res[i].ex_vec, x->exp_tmpres[i], n); + } + return (w + 2); } static void expr_dsp(t_expr *x, t_signal **sp) { - int i, nv; - int newsize; - - x->exp_error = 0; /* reset all errors */ - newsize = (x->exp_vsize != sp[0]->s_n); - x->exp_vsize = sp[0]->s_n; /* record the vector size */ - for (i = 0; i < x->exp_nexpr; i++) { - x->exp_res[i].ex_type = ET_VEC; - x->exp_res[i].ex_vec = sp[x->exp_nivec + i]->s_vec; - } - for (i = 0, nv = 0; i < MAX_VARS; i++) - /* - * the first inlet is always a signal - * - * SDY We are warning the user till this limitation - * is taken away from pd - */ - if (!i || x->exp_var[i].ex_type == ET_VI || - x->exp_var[i].ex_type == ET_XI) { - if (nv >= x->exp_nivec) { - post("expr_dsp int. err nv = %d, x->exp_nive = %d", - nv, x->exp_nivec); - abort(); - } - x->exp_var[i].ex_vec = sp[nv]->s_vec; - nv++; - } - /* we always have one inlet but we may not use it */ - if (nv != x->exp_nivec && (nv != 0 || x->exp_nivec != 1)) { - post("expr_dsp internal error 2 nv = %d, x->exp_nive = %d", - nv, x->exp_nivec); - abort(); - } - - dsp_add(expr_perform, 1, (t_int *) x); - - /* - * The buffer are now being allocated for expr~ and fexpr~ - * because if we have more than one expression we need the - * temporary buffers, The save buffers are not really needed - if (!IS_FEXPR_TILDE(x)) - return; - */ - /* - * if we have already allocated the buffers and we have a - * new size free all the buffers - */ - if (x->exp_p_res[0]) { - if (!newsize) - return; - /* - * if new size, reallocate all the previous buffers for fexpr~ - */ - for (i = 0; i < x->exp_nexpr; i++) { - fts_free(x->exp_p_res[i]); - fts_free(x->exp_tmpres[i]); - } - for (i = 0; i < MAX_VARS; i++) - fts_free(x->exp_p_var[i]); - - } - for (i = 0; i < x->exp_nexpr; i++) { - x->exp_p_res[i] = fts_calloc(x->exp_vsize, sizeof (t_float)); - x->exp_tmpres[i] = fts_calloc(x->exp_vsize, sizeof (t_float)); - } - for (i = 0; i < MAX_VARS; i++) - x->exp_p_var[i] = fts_calloc(x->exp_vsize, sizeof (t_float)); + int i, nv; + int newsize; + + x->exp_error = 0; /* reset all errors */ + newsize = (x->exp_vsize != sp[0]->s_n); + x->exp_vsize = sp[0]->s_n; /* record the vector size */ + for (i = 0; i < x->exp_nexpr; i++) { + x->exp_res[i].ex_type = ET_VEC; + x->exp_res[i].ex_vec = sp[x->exp_nivec + i]->s_vec; + } + for (i = 0, nv = 0; i < MAX_VARS; i++) + /* + * the first inlet is always a signal + * + * SDY We are warning the user till this limitation + * is taken away from pd + */ + if (!i || x->exp_var[i].ex_type == ET_VI || + x->exp_var[i].ex_type == ET_XI) { + if (nv >= x->exp_nivec) { + post("expr_dsp int. err nv = %d, x->exp_nive = %d", + nv, x->exp_nivec); + abort(); + } + x->exp_var[i].ex_vec = sp[nv]->s_vec; + nv++; + } + /* we always have one inlet but we may not use it */ + if (nv != x->exp_nivec && (nv != 0 || x->exp_nivec != 1)) { + post("expr_dsp internal error 2 nv = %d, x->exp_nive = %d", + nv, x->exp_nivec); + abort(); + } + + dsp_add(expr_perform, 1, (t_int *) x); + + /* + * The buffer are now being allocated for expr~ and fexpr~ + * because if we have more than one expression we need the + * temporary buffers, The save buffers are not really needed + if (!IS_FEXPR_TILDE(x)) + return; + */ + /* + * if we have already allocated the buffers and we have a + * new size free all the buffers + */ + if (x->exp_p_res[0]) { + if (!newsize) + return; + /* + * if new size, reallocate all the previous buffers for fexpr~ + */ + for (i = 0; i < x->exp_nexpr; i++) { + fts_free(x->exp_p_res[i]); + fts_free(x->exp_tmpres[i]); + } + for (i = 0; i < MAX_VARS; i++) + fts_free(x->exp_p_var[i]); + + } + for (i = 0; i < x->exp_nexpr; i++) { + x->exp_p_res[i] = fts_calloc(x->exp_vsize, sizeof (t_float)); + x->exp_tmpres[i] = fts_calloc(x->exp_vsize, sizeof (t_float)); + } + for (i = 0; i < MAX_VARS; i++) + x->exp_p_var[i] = fts_calloc(x->exp_vsize, sizeof (t_float)); } /* @@ -571,13 +571,13 @@ expr_dsp(t_expr *x, t_signal **sp) static void expr_verbose(t_expr *x) { - if (x->exp_flags & EF_VERBOSE) { - x->exp_flags &= ~EF_VERBOSE; - post ("verbose off"); - } else { - x->exp_flags |= EF_VERBOSE; - post ("verbose on"); - } + if (x->exp_flags & EF_VERBOSE) { + x->exp_flags &= ~EF_VERBOSE; + post ("verbose off"); + } else { + x->exp_flags |= EF_VERBOSE; + post ("verbose on"); + } } /* @@ -586,7 +586,7 @@ expr_verbose(t_expr *x) static void expr_start(t_expr *x) { - x->exp_flags &= ~EF_STOP; + x->exp_flags &= ~EF_STOP; } /* @@ -595,120 +595,120 @@ expr_start(t_expr *x) static void expr_stop(t_expr *x) { - x->exp_flags |= EF_STOP; + x->exp_flags |= EF_STOP; } static void fexpr_set_usage(void) { - post("fexpr~: set val ..."); - post("fexpr~: set {xy}[#] val ..."); + post("fexpr~: set val ..."); + post("fexpr~: set {xy}[#] val ..."); } /* * fexpr_tilde_set -- set previous values of the buffers - * set val val ... - sets the first elements of output buffers - * set x val ... - sets the elements of the first input buffer - * set x# val ... - sets the elements of the #th input buffers - * set y val ... - sets the elements of the first output buffer - * set y# val ... - sets the elements of the #th output buffers + * set val val ... - sets the first elements of output buffers + * set x val ... - sets the elements of the first input buffer + * set x# val ... - sets the elements of the #th input buffers + * set y val ... - sets the elements of the first output buffer + * set y# val ... - sets the elements of the #th output buffers */ static void fexpr_tilde_set(t_expr *x, t_symbol *s, int argc, t_atom *argv) { - t_symbol *sx; - int vecno; - int i, nargs; - - if (!argc) - return; - sx = atom_getsymbolarg(0, argc, argv); - switch(sx->s_name[0]) { - case 'x': - if (!sx->s_name[1]) - vecno = 0; - else { - vecno = atoi(sx->s_name + 1); - if (!vecno) { - post("fexpr~.set: bad set x vector number"); - fexpr_set_usage(); - return; - } - if (vecno >= MAX_VARS) { - post("fexpr~.set: no more than %d inlets", - MAX_VARS); - return; - } - vecno--; - } - if (x->exp_var[vecno].ex_type != ET_XI) { - post("fexpr~-set: no signal at inlet %d", vecno + 1); - return; - } - nargs = argc - 1; - if (!nargs) { - post("fexpr~-set: no argument to set"); - return; - } - if (nargs > x->exp_vsize) { - post("fexpr~.set: %d set values larger than vector size(%d)", - nargs, x->exp_vsize); - post("fexpr~.set: only the first %d values will be set", - x->exp_vsize); - nargs = x->exp_vsize; - } - for (i = 0; i < nargs; i++) { - x->exp_p_var[vecno][x->exp_vsize - i - 1] = - atom_getfloatarg(i + 1, argc, argv); - } - return; - case 'y': - if (!sx->s_name[1]) - vecno = 0; - else { - vecno = atoi(sx->s_name + 1); - if (!vecno) { - post("fexpr~.set: bad set y vector number"); - fexpr_set_usage(); - return; - } - vecno--; - } - if (vecno >= x->exp_nexpr) { - post("fexpr~.set: only %d outlets", x->exp_nexpr); - return; - } - nargs = argc - 1; - if (!nargs) { - post("fexpr~-set: no argument to set"); - return; - } - if (nargs > x->exp_vsize) { - post("fexpr~-set: %d set values larger than vector size(%d)", - nargs, x->exp_vsize); - post("fexpr~.set: only the first %d values will be set", - x->exp_vsize); - nargs = x->exp_vsize; - } - for (i = 0; i < nargs; i++) { - x->exp_p_res[vecno][x->exp_vsize - i - 1] = - atom_getfloatarg(i + 1, argc, argv); - } - return; - case 0: - if (argc > x->exp_nexpr) { - post("fexpr~.set: only %d outlets available", - x->exp_nexpr); - post("fexpr~.set: the extra set values are ignored"); - } - for (i = 0; i < x->exp_nexpr && i < argc; i++) - x->exp_p_res[i][x->exp_vsize - 1] = - atom_getfloatarg(i, argc, argv); - return; - default: - fexpr_set_usage(); - return; - } - return; + t_symbol *sx; + int vecno; + int i, nargs; + + if (!argc) + return; + sx = atom_getsymbolarg(0, argc, argv); + switch(sx->s_name[0]) { + case 'x': + if (!sx->s_name[1]) + vecno = 0; + else { + vecno = atoi(sx->s_name + 1); + if (!vecno) { + post("fexpr~.set: bad set x vector number"); + fexpr_set_usage(); + return; + } + if (vecno >= MAX_VARS) { + post("fexpr~.set: no more than %d inlets", + MAX_VARS); + return; + } + vecno--; + } + if (x->exp_var[vecno].ex_type != ET_XI) { + post("fexpr~-set: no signal at inlet %d", vecno + 1); + return; + } + nargs = argc - 1; + if (!nargs) { + post("fexpr~-set: no argument to set"); + return; + } + if (nargs > x->exp_vsize) { + post("fexpr~.set: %d set values larger than vector size(%d)", + nargs, x->exp_vsize); + post("fexpr~.set: only the first %d values will be set", + x->exp_vsize); + nargs = x->exp_vsize; + } + for (i = 0; i < nargs; i++) { + x->exp_p_var[vecno][x->exp_vsize - i - 1] = + atom_getfloatarg(i + 1, argc, argv); + } + return; + case 'y': + if (!sx->s_name[1]) + vecno = 0; + else { + vecno = atoi(sx->s_name + 1); + if (!vecno) { + post("fexpr~.set: bad set y vector number"); + fexpr_set_usage(); + return; + } + vecno--; + } + if (vecno >= x->exp_nexpr) { + post("fexpr~.set: only %d outlets", x->exp_nexpr); + return; + } + nargs = argc - 1; + if (!nargs) { + post("fexpr~-set: no argument to set"); + return; + } + if (nargs > x->exp_vsize) { + post("fexpr~-set: %d set values larger than vector size(%d)", + nargs, x->exp_vsize); + post("fexpr~.set: only the first %d values will be set", + x->exp_vsize); + nargs = x->exp_vsize; + } + for (i = 0; i < nargs; i++) { + x->exp_p_res[vecno][x->exp_vsize - i - 1] = + atom_getfloatarg(i + 1, argc, argv); + } + return; + case 0: + if (argc > x->exp_nexpr) { + post("fexpr~.set: only %d outlets available", + x->exp_nexpr); + post("fexpr~.set: the extra set values are ignored"); + } + for (i = 0; i < x->exp_nexpr && i < argc; i++) + x->exp_p_res[i][x->exp_vsize - 1] = + atom_getfloatarg(i, argc, argv); + return; + default: + fexpr_set_usage(); + return; + } + return; } /* @@ -717,74 +717,74 @@ fexpr_tilde_set(t_expr *x, t_symbol *s, int argc, t_atom *argv) static void fexpr_tilde_clear(t_expr *x, t_symbol *s, int argc, t_atom *argv) { - t_symbol *sx; - int vecno; - int i, nargs; - - /* - * if no arguement clear all input and output buffers - */ - if (!argc) { - for (i = 0; i < x->exp_nexpr; i++) - memset(x->exp_p_res[i], 0, x->exp_vsize*sizeof(float)); - for (i = 0; i < MAX_VARS; i++) - if (x->exp_var[i].ex_type == ET_XI) - memset(x->exp_p_var[i], 0, - x->exp_vsize*sizeof(float)); - return; - } - if (argc > 1) { - post("fexpr~ usage: 'clear' or 'clear {xy}[#]'"); - return; - } - - sx = atom_getsymbolarg(0, argc, argv); - switch(sx->s_name[0]) { - case 'x': - if (!sx->s_name[1]) - vecno = 0; - else { - vecno = atoi(sx->s_name + 1); - if (!vecno) { - post("fexpr~.clear: bad clear x vector number"); - return; - } - if (vecno >= MAX_VARS) { - post("fexpr~.clear: no more than %d inlets", - MAX_VARS); - return; - } - vecno--; - } - if (x->exp_var[vecno].ex_type != ET_XI) { - post("fexpr~-clear: no signal at inlet %d", vecno + 1); - return; - } - memset(x->exp_p_var[vecno], 0, x->exp_vsize*sizeof(float)); - return; - case 'y': - if (!sx->s_name[1]) - vecno = 0; - else { - vecno = atoi(sx->s_name + 1); - if (!vecno) { - post("fexpr~.clear: bad clear y vector number"); - return; - } - vecno--; - } - if (vecno >= x->exp_nexpr) { - post("fexpr~.clear: only %d outlets", x->exp_nexpr); - return; - } - memset(x->exp_p_res[vecno], 0, x->exp_vsize*sizeof(float)); - return; - return; - default: - post("fexpr~ usage: 'clear' or 'clear {xy}[#]'"); - return; - } - return; + t_symbol *sx; + int vecno; + int i, nargs; + + /* + * if no arguement clear all input and output buffers + */ + if (!argc) { + for (i = 0; i < x->exp_nexpr; i++) + memset(x->exp_p_res[i], 0, x->exp_vsize*sizeof(float)); + for (i = 0; i < MAX_VARS; i++) + if (x->exp_var[i].ex_type == ET_XI) + memset(x->exp_p_var[i], 0, + x->exp_vsize*sizeof(float)); + return; + } + if (argc > 1) { + post("fexpr~ usage: 'clear' or 'clear {xy}[#]'"); + return; + } + + sx = atom_getsymbolarg(0, argc, argv); + switch(sx->s_name[0]) { + case 'x': + if (!sx->s_name[1]) + vecno = 0; + else { + vecno = atoi(sx->s_name + 1); + if (!vecno) { + post("fexpr~.clear: bad clear x vector number"); + return; + } + if (vecno >= MAX_VARS) { + post("fexpr~.clear: no more than %d inlets", + MAX_VARS); + return; + } + vecno--; + } + if (x->exp_var[vecno].ex_type != ET_XI) { + post("fexpr~-clear: no signal at inlet %d", vecno + 1); + return; + } + memset(x->exp_p_var[vecno], 0, x->exp_vsize*sizeof(float)); + return; + case 'y': + if (!sx->s_name[1]) + vecno = 0; + else { + vecno = atoi(sx->s_name + 1); + if (!vecno) { + post("fexpr~.clear: bad clear y vector number"); + return; + } + vecno--; + } + if (vecno >= x->exp_nexpr) { + post("fexpr~.clear: only %d outlets", x->exp_nexpr); + return; + } + memset(x->exp_p_res[vecno], 0, x->exp_vsize*sizeof(float)); + return; + return; + default: + post("fexpr~ usage: 'clear' or 'clear {xy}[#]'"); + return; + } + return; } #ifdef PD @@ -792,68 +792,68 @@ fexpr_tilde_clear(t_expr *x, t_symbol *s, int argc, t_atom *argv) void expr_setup(void) { - /* - * expr initialization - */ - expr_class = class_new(gensym("expr"), (t_newmethod)expr_new, - (t_method)expr_ff, sizeof(t_expr), 0, A_GIMME, 0); - class_addlist(expr_class, expr_list); - exprproxy_class = class_new(gensym("exprproxy"), 0, - 0, sizeof(t_exprproxy), CLASS_PD, 0); - class_addfloat(exprproxy_class, exprproxy_float); - - /* - * expr~ initialization - */ - expr_tilde_class = class_new(gensym("expr~"), (t_newmethod)expr_new, - (t_method)expr_ff, sizeof(t_expr), 0, A_GIMME, 0); - class_addmethod(expr_tilde_class, nullfn, gensym("signal"), 0); - CLASS_MAINSIGNALIN(expr_tilde_class, t_expr, exp_f); - class_addmethod(expr_tilde_class,(t_method)expr_dsp, gensym("dsp"), 0); - class_sethelpsymbol(expr_tilde_class, gensym("expr")); - /* - * fexpr~ initialization - */ - fexpr_tilde_class = class_new(gensym("fexpr~"), (t_newmethod)expr_new, - (t_method)expr_ff, sizeof(t_expr), 0, A_GIMME, 0); - class_addmethod(fexpr_tilde_class, nullfn, gensym("signal"), 0); - class_addmethod(fexpr_tilde_class,(t_method)expr_start, - gensym("start"), 0); - class_addmethod(fexpr_tilde_class,(t_method)expr_stop, - gensym("stop"), 0); - - class_addmethod(fexpr_tilde_class,(t_method)expr_dsp,gensym("dsp"), 0); - class_addmethod(fexpr_tilde_class, (t_method)fexpr_tilde_set, - gensym("set"), A_GIMME, 0); - class_addmethod(fexpr_tilde_class, (t_method)fexpr_tilde_clear, - gensym("clear"), A_GIMME, 0); - class_addmethod(fexpr_tilde_class,(t_method)expr_verbose, - gensym("verbose"), 0); - class_sethelpsymbol(fexpr_tilde_class, gensym("expr")); - - - - post("expr, expr~, fexpr~ version %s under GNU General Public License ", exp_version); + /* + * expr initialization + */ + expr_class = class_new(gensym("expr"), (t_newmethod)expr_new, + (t_method)expr_ff, sizeof(t_expr), 0, A_GIMME, 0); + class_addlist(expr_class, expr_list); + exprproxy_class = class_new(gensym("exprproxy"), 0, + 0, sizeof(t_exprproxy), CLASS_PD, 0); + class_addfloat(exprproxy_class, exprproxy_float); + + /* + * expr~ initialization + */ + expr_tilde_class = class_new(gensym("expr~"), (t_newmethod)expr_new, + (t_method)expr_ff, sizeof(t_expr), 0, A_GIMME, 0); + class_addmethod(expr_tilde_class, nullfn, gensym("signal"), 0); + CLASS_MAINSIGNALIN(expr_tilde_class, t_expr, exp_f); + class_addmethod(expr_tilde_class,(t_method)expr_dsp, gensym("dsp"), 0); + class_sethelpsymbol(expr_tilde_class, gensym("expr")); + /* + * fexpr~ initialization + */ + fexpr_tilde_class = class_new(gensym("fexpr~"), (t_newmethod)expr_new, + (t_method)expr_ff, sizeof(t_expr), 0, A_GIMME, 0); + class_addmethod(fexpr_tilde_class, nullfn, gensym("signal"), 0); + class_addmethod(fexpr_tilde_class,(t_method)expr_start, + gensym("start"), 0); + class_addmethod(fexpr_tilde_class,(t_method)expr_stop, + gensym("stop"), 0); + + class_addmethod(fexpr_tilde_class,(t_method)expr_dsp,gensym("dsp"), 0); + class_addmethod(fexpr_tilde_class, (t_method)fexpr_tilde_set, + gensym("set"), A_GIMME, 0); + class_addmethod(fexpr_tilde_class, (t_method)fexpr_tilde_clear, + gensym("clear"), A_GIMME, 0); + class_addmethod(fexpr_tilde_class,(t_method)expr_verbose, + gensym("verbose"), 0); + class_sethelpsymbol(fexpr_tilde_class, gensym("expr")); + + + + post("expr, expr~, fexpr~ version %s under GNU General Public License ", exp_version); } void expr_tilde_setup(void) { - expr_setup(); + expr_setup(); } void fexpr_tilde_setup(void) { - expr_setup(); + expr_setup(); } #else /* MSP */ void main(void) { setup((t_messlist **)&expr_tilde_class, (method)Nexpr_new, - (method)expr_ff, (short)sizeof(t_expr), 0L, A_GIMME, 0); + (method)expr_ff, (short)sizeof(t_expr), 0L, A_GIMME, 0); addmess((method)expr_dsp, "dsp", A_CANT, 0); // dsp method dsp_initclass(); } @@ -866,21 +866,21 @@ main(void) int ex_getsym(char *p, fts_symbol_t *s) { - *s = gensym(p); - return (0); + *s = gensym(p); + return (0); } const char * ex_symname(fts_symbol_t s) { - return (fts_symbol_name(s)); + return (fts_symbol_name(s)); } /* * max_ex_tab -- evaluate this table access - * eptr is the name of the table and arg is the index we - * have to put the result in optr - * return 1 on error and 0 otherwise + * eptr is the name of the table and arg is the index we + * have to put the result in optr + * return 1 on error and 0 otherwise * * Arguments: * the expr object @@ -893,70 +893,70 @@ max_ex_tab(struct expr *expr, fts_symbol_t s, struct ex_ex *arg, struct ex_ex *optr) { #ifdef PD - t_garray *garray; - int size, indx; - t_float *vec; - - if (!s || !(garray = (t_garray *)pd_findbyclass(s, garray_class)) || - !garray_getfloatarray(garray, &size, &vec)) - { - optr->ex_type = ET_FLT; - optr->ex_flt = 0; - pd_error(expr, "no such table '%s'", s->s_name); - return (1); - } - optr->ex_type = ET_FLT; - - switch (arg->ex_type) { - case ET_INT: - indx = arg->ex_int; - break; - case ET_FLT: - /* strange interpolation code deleted here -msp */ - indx = arg->ex_flt; - break; - - default: /* do something with strings */ - pd_error(expr, "expr: bad argument for table '%s'\n", fts_symbol_name(s)); - indx = 0; - } - if (indx < 0) indx = 0; - else if (indx >= size) indx = size - 1; - optr->ex_flt = vec[indx]; + t_garray *garray; + int size, indx; + t_float *vec; + + if (!s || !(garray = (t_garray *)pd_findbyclass(s, garray_class)) || + !garray_getfloatarray(garray, &size, &vec)) + { + optr->ex_type = ET_FLT; + optr->ex_flt = 0; + pd_error(expr, "no such table '%s'", s->s_name); + return (1); + } + optr->ex_type = ET_FLT; + + switch (arg->ex_type) { + case ET_INT: + indx = arg->ex_int; + break; + case ET_FLT: + /* strange interpolation code deleted here -msp */ + indx = arg->ex_flt; + break; + + default: /* do something with strings */ + pd_error(expr, "expr: bad argument for table '%s'\n", fts_symbol_name(s)); + indx = 0; + } + if (indx < 0) indx = 0; + else if (indx >= size) indx = size - 1; + optr->ex_flt = vec[indx]; #else /* MSP */ - /* - * table lookup not done for MSP yet - */ - post("max_ex_tab: not complete for MSP yet!"); - optr->ex_type = ET_FLT; - optr->ex_flt = 0; -#endif - return (0); + /* + * table lookup not done for MSP yet + */ + post("max_ex_tab: not complete for MSP yet!"); + optr->ex_type = ET_FLT; + optr->ex_flt = 0; +#endif + return (0); } int max_ex_var(struct expr *expr, fts_symbol_t var, struct ex_ex *optr) { - optr->ex_type = ET_FLT; - if (value_getfloat(var, &(optr->ex_flt))) { - optr->ex_type = ET_FLT; - optr->ex_flt = 0; - pd_error(expr, "no such var '%s'", var->s_name); - return (1); - } - return (0); + optr->ex_type = ET_FLT; + if (value_getfloat(var, &(optr->ex_flt))) { + optr->ex_type = ET_FLT; + optr->ex_flt = 0; + pd_error(expr, "no such var '%s'", var->s_name); + return (1); + } + return (0); } #ifdef PD /* this goes to the end of this file as the following functions * should be defined in the expr object in MSP */ -#define ISTABLE(sym, garray, size, vec) \ +#define ISTABLE(sym, garray, size, vec) \ if (!sym || !(garray = (t_garray *)pd_findbyclass(sym, garray_class)) || \ - !garray_getfloatarray(garray, &size, &vec)) { \ - optr->ex_type = ET_FLT; \ - optr->ex_int = 0; \ - error("no such table '%s'", sym->s_name); \ - return; \ + !garray_getfloatarray(garray, &size, &vec)) { \ + optr->ex_type = ET_FLT; \ + optr->ex_int = 0; \ + error("no such table '%s'", sym->s_name); \ + return; \ } /* @@ -965,25 +965,25 @@ if (!sym || !(garray = (t_garray *)pd_findbyclass(sym, garray_class)) || \ void ex_size(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr) { - t_symbol *s; - t_garray *garray; - int size; - t_float *vec; + t_symbol *s; + t_garray *garray; + int size; + t_float *vec; - if (argv->ex_type != ET_SYM) - { - post("expr: size: need a table name\n"); - optr->ex_type = ET_INT; - optr->ex_int = 0; - return; - } + if (argv->ex_type != ET_SYM) + { + post("expr: size: need a table name\n"); + optr->ex_type = ET_INT; + optr->ex_int = 0; + return; + } - s = (fts_symbol_t ) argv->ex_ptr; + s = (fts_symbol_t ) argv->ex_ptr; - ISTABLE(s, garray, size, vec); + ISTABLE(s, garray, size, vec); - optr->ex_type = ET_INT; - optr->ex_int = size; + optr->ex_type = ET_INT; + optr->ex_int = size; } /* @@ -993,29 +993,29 @@ ex_size(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr) void ex_sum(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr) { - t_symbol *s; - t_garray *garray; - int size; - t_float *vec, sum; - int indx; + t_symbol *s; + t_garray *garray; + int size; + t_float *vec, sum; + int indx; - if (argv->ex_type != ET_SYM) - { - post("expr: sum: need a table name\n"); - optr->ex_type = ET_INT; - optr->ex_int = 0; - return; - } + if (argv->ex_type != ET_SYM) + { + post("expr: sum: need a table name\n"); + optr->ex_type = ET_INT; + optr->ex_int = 0; + return; + } - s = (fts_symbol_t ) argv->ex_ptr; + s = (fts_symbol_t ) argv->ex_ptr; - ISTABLE(s, garray, size, vec); + ISTABLE(s, garray, size, vec); - for (indx = 0, sum = 0; indx < size; indx++) - sum += vec[indx]; + for (indx = 0, sum = 0; indx < size; indx++) + sum += vec[indx]; - optr->ex_type = ET_FLT; - optr->ex_flt = sum; + optr->ex_type = ET_FLT; + optr->ex_flt = sum; } @@ -1026,40 +1026,40 @@ ex_sum(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr) void ex_Sum(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr) { - t_symbol *s; - t_garray *garray; - int size; - t_float *vec, sum; - int indx, n1, n2; - - if (argv->ex_type != ET_SYM) - { - post("expr: sum: need a table name\n"); - optr->ex_type = ET_INT; - optr->ex_int = 0; - return; - } - - s = (fts_symbol_t ) argv->ex_ptr; - - ISTABLE(s, garray, size, vec); - - if (argv->ex_type != ET_INT || argv[1].ex_type != ET_INT) - { - post("expr: Sum: boundries have to be fix values\n"); - optr->ex_type = ET_INT; - optr->ex_int = 0; - return; - } - n1 = argv->ex_int; - n2 = argv[1].ex_int; - - for (indx = n1, sum = 0; indx < n2; indx++) - if (indx >= 0 && indx < size) - sum += vec[indx]; - - optr->ex_type = ET_FLT; - optr->ex_flt = sum; + t_symbol *s; + t_garray *garray; + int size; + t_float *vec, sum; + int indx, n1, n2; + + if (argv->ex_type != ET_SYM) + { + post("expr: sum: need a table name\n"); + optr->ex_type = ET_INT; + optr->ex_int = 0; + return; + } + + s = (fts_symbol_t ) argv->ex_ptr; + + ISTABLE(s, garray, size, vec); + + if (argv->ex_type != ET_INT || argv[1].ex_type != ET_INT) + { + post("expr: Sum: boundries have to be fix values\n"); + optr->ex_type = ET_INT; + optr->ex_int = 0; + return; + } + n1 = argv->ex_int; + n2 = argv[1].ex_int; + + for (indx = n1, sum = 0; indx < n2; indx++) + if (indx >= 0 && indx < size) + sum += vec[indx]; + + optr->ex_type = ET_FLT; + optr->ex_flt = sum; } /* @@ -1071,35 +1071,35 @@ ex_avg(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr) { /* SDY - look into this function */ #if 0 - fts_symbol_t s; - fts_integer_vector_t *tw = 0; - - if (argv->ex_type != ET_SYM) - { - post("expr: avg: need a table name\n"); - optr->ex_type = ET_INT; - optr->ex_int = 0; - } - - s = (fts_symbol_t ) argv->ex_ptr; - - tw = table_integer_vector_get_by_name(s); - - if (tw) - { - optr->ex_type = ET_INT; - - if (! fts_integer_vector_get_size(tw)) - optr->ex_int = 0; - else - optr->ex_int = fts_integer_vector_get_sum(tw) / fts_integer_vector_get_size(tw); - } - else - { - optr->ex_type = ET_INT; - optr->ex_int = 0; - post("expr: avg: no such table %s\n", fts_symbol_name(s)); - } + fts_symbol_t s; + fts_integer_vector_t *tw = 0; + + if (argv->ex_type != ET_SYM) + { + post("expr: avg: need a table name\n"); + optr->ex_type = ET_INT; + optr->ex_int = 0; + } + + s = (fts_symbol_t ) argv->ex_ptr; + + tw = table_integer_vector_get_by_name(s); + + if (tw) + { + optr->ex_type = ET_INT; + + if (! fts_integer_vector_get_size(tw)) + optr->ex_int = 0; + else + optr->ex_int = fts_integer_vector_get_sum(tw) / fts_integer_vector_get_size(tw); + } + else + { + optr->ex_type = ET_INT; + optr->ex_int = 0; + post("expr: avg: no such table %s\n", fts_symbol_name(s)); + } #endif } @@ -1113,50 +1113,50 @@ ex_Avg(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr) { /* SDY - look into this function */ #if 0 - fts_symbol_t s; - fts_integer_vector_t *tw = 0; - - if (argv->ex_type != ET_SYM) - { - post("expr: Avg: need a table name\n"); - optr->ex_type = ET_INT; - optr->ex_int = 0; - } - - s = (fts_symbol_t ) (argv++)->ex_ptr; - - tw = table_integer_vector_get_by_name(s); - - if (! tw) - { - optr->ex_type = ET_INT; - optr->ex_int = 0; - post("expr: Avg: no such table %s\n", fts_symbol_name(s)); - return; - } - - if (argv->ex_type != ET_INT || argv[1].ex_type != ET_INT) - { - post("expr: Avg: boundries have to be fix values\n"); - optr->ex_type = ET_INT; - optr->ex_int = 0; - return; - } - - optr->ex_type = ET_INT; - - if (argv[1].ex_int - argv->ex_int <= 0) - optr->ex_int = 0; - else - optr->ex_int = (fts_integer_vector_get_sub_sum(tw, argv->ex_int, argv[1].ex_int) / - (argv[1].ex_int - argv->ex_int)); + fts_symbol_t s; + fts_integer_vector_t *tw = 0; + + if (argv->ex_type != ET_SYM) + { + post("expr: Avg: need a table name\n"); + optr->ex_type = ET_INT; + optr->ex_int = 0; + } + + s = (fts_symbol_t ) (argv++)->ex_ptr; + + tw = table_integer_vector_get_by_name(s); + + if (! tw) + { + optr->ex_type = ET_INT; + optr->ex_int = 0; + post("expr: Avg: no such table %s\n", fts_symbol_name(s)); + return; + } + + if (argv->ex_type != ET_INT || argv[1].ex_type != ET_INT) + { + post("expr: Avg: boundries have to be fix values\n"); + optr->ex_type = ET_INT; + optr->ex_int = 0; + return; + } + + optr->ex_type = ET_INT; + + if (argv[1].ex_int - argv->ex_int <= 0) + optr->ex_int = 0; + else + optr->ex_int = (fts_integer_vector_get_sub_sum(tw, argv->ex_int, argv[1].ex_int) / + (argv[1].ex_int - argv->ex_int)); #endif } /* * ex_store -- store a value in a table - * if the index is greater the size of the table, - * we will make a modulo the size of the table + * if the index is greater the size of the table, + * we will make a modulo the size of the table */ void @@ -1164,35 +1164,35 @@ ex_store(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr) { /* SDY - look into this function */ #if 0 - fts_symbol_t s; - fts_integer_vector_t *tw = 0; - - if (argv->ex_type != ET_SYM) - { - post("expr: store: need a table name\n"); - } - - s = (fts_symbol_t ) (argv++)->ex_ptr; - - tw = table_integer_vector_get_by_name(s); - - if (! tw) - { - optr->ex_type = ET_INT; - optr->ex_int = 0; - post("expr: store: no such table %s\n", fts_symbol_name(s)); - return; - } - - if (argv->ex_type != ET_INT || argv[1].ex_type != ET_INT) - { - post("expr: store: arguments have to be integer\n"); - optr->ex_type = ET_INT; - optr->ex_int = 0; - } - - fts_integer_vector_set_element(tw, argv->ex_int < 0 ? 0 : argv->ex_int % fts_integer_vector_get_size(tw), argv[1].ex_int); - *optr = argv[1]; + fts_symbol_t s; + fts_integer_vector_t *tw = 0; + + if (argv->ex_type != ET_SYM) + { + post("expr: store: need a table name\n"); + } + + s = (fts_symbol_t ) (argv++)->ex_ptr; + + tw = table_integer_vector_get_by_name(s); + + if (! tw) + { + optr->ex_type = ET_INT; + optr->ex_int = 0; + post("expr: store: no such table %s\n", fts_symbol_name(s)); + return; + } + + if (argv->ex_type != ET_INT || argv[1].ex_type != ET_INT) + { + post("expr: store: arguments have to be integer\n"); + optr->ex_type = ET_INT; + optr->ex_int = 0; + } + + fts_integer_vector_set_element(tw, argv->ex_int < 0 ? 0 : argv->ex_int % fts_integer_vector_get_size(tw), argv[1].ex_int); + *optr = argv[1]; #endif } @@ -1209,7 +1209,7 @@ pd_error(void *object, char *fmt, ...) /* SDY vsprintf(error_string, fmt, ap); */ post(fmt, ap); - va_end(ap); + va_end(ap); /* SDY fprintf(stderr, "error: %s\n", error_string); error_object = object; -- cgit v1.2.1