Attachment #18710 for bug #28007





char *atoif(char *s, long int *value, long int *type);

static struct ex_ex *ex_lex(struct expr *exp_gentoo, long int *n);
struct ex_ex *ex_match(struct ex_ex *eptr, long int op);
struct ex_ex *ex_parse(struct expr *exp_gentoo, struct ex_ex *iptr,
					struct ex_ex *optr, long int *argc);
struct ex_ex *ex_eval(struct expr *exp_gentoo, struct ex_ex *eptr,
						struct ex_ex *optr, int i);

int expr_donew(struct expr *expr, int ac, t_atom *av);
struct ex_ex *eval_func(struct expr *exp_gentoo,struct ex_ex *eptr,
						struct ex_ex *optr, int i);
struct ex_ex *eval_tab(struct expr *exp_gentoo, struct ex_ex *eptr,
						struct ex_ex *optr, int i);
struct ex_ex *eval_var(struct expr *exp_gentoo, struct ex_ex *eptr,
						struct ex_ex *optr, int i);
struct ex_ex *eval_store(struct expr *exp_gentoo, struct ex_ex *eptr,
						struct ex_ex *optr, int i);
struct ex_ex *eval_sigidx(struct expr *exp_gentoo, 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 vsize,				            /* vector size */
	   float *curvec, float *prevec);   /* current and previous table */
t_ex_func *find_func(char *s);
void ex_dzdetect(struct expr *exp_gentoo);

#define	MAX_ARGS	10
extern t_ex_func ex_funcs[];

struct ex_ex nullex;

void set_tokens (char *s);
int getoken (struct expr *exp_gentoo, struct ex_ex *eptr);
void ex_print (struct ex_ex *eptr);
#ifdef MSP
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.
 */ 
int

 *	     It will also put the number of the nodes in *n.
 */
struct ex_ex *
ex_lex(struct expr *exp_gentoo, long int *n)
{
	struct ex_ex *list_arr;
	struct ex_ex *exptr;

			exptr = &(list_arr)[non];
		}

		if (getoken(exp_gentoo, exptr)) {
			fts_free(list_arr);
			return ((struct ex_ex *)0);
		}

#define DZC(ARG1,OPR,ARG2)	(ARG1 OPR ARG2)

#define	EVAL(OPR); 							\
eptr = ex_eval(exp_gentoo, ex_eval(exp_gentoo, eptr, &left, idx), &right, idx);	\
switch (left.ex_type) {							\
case ET_INT:								\
	switch(right.ex_type) {						\

		if (optr->ex_type == ET_VEC) {				\
			op = optr->ex_vec;				\
			scalar = (float)DZC(left.ex_int, OPR, right.ex_int); \
			for (j = 0; j < exp_gentoo->exp_vsize; j++)		\
				*op++ = scalar;				\
		} else {						\
			optr->ex_type = ET_INT;				\

		if (optr->ex_type == ET_VEC) {				\
			op = optr->ex_vec;				\
			scalar = DZC(((float)left.ex_int), OPR, right.ex_flt);\
			for (j = 0; j < exp_gentoo->exp_vsize; j++)		\
				*op++ = scalar;				\
		} else {						\
			optr->ex_type = ET_FLT;				\

			}						\
			optr->ex_type = ET_VEC;				\
			optr->ex_vec = (t_float *)			\
			  fts_malloc(sizeof (t_float)*exp_gentoo->exp_vsize);	\
		}							\
		scalar = left.ex_int;					\
		rp = right.ex_vec;					\
		op = optr->ex_vec;					\
		for (i = 0; i < exp_gentoo->exp_vsize; i++) {			\
			*op++ = DZC (scalar, OPR, *rp);			\
			rp++;						\
		}							\
		break;							\
	case ET_SYM:							\
	default:							\
		post_error((fts_object_t *) exp_gentoo, 		   	\
		      "expr: ex_eval(%d): bad right type %ld\n",	\
					      __LINE__, right.ex_type);	\
		nullret = 1;						\

		if (optr->ex_type == ET_VEC) {				\
			op = optr->ex_vec;				\
			scalar = DZC((float) left.ex_flt, OPR, right.ex_int); \
			for (j = 0; j < exp_gentoo->exp_vsize; j++)		\
				*op++ = scalar;				\
		} else {						\
			optr->ex_type = 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 < exp_gentoo->exp_vsize; j++)		\
				*op++ = scalar;				\
		} else {						\
			optr->ex_type = ET_FLT;				\

			}						\
			optr->ex_type = ET_VEC;				\
			optr->ex_vec = (t_float *)			\
			  fts_malloc(sizeof (t_float)*exp_gentoo->exp_vsize);	\
		}							\
		scalar = left.ex_flt;					\
		rp = right.ex_vec;					\
		op = optr->ex_vec;					\
		for (i = 0; i < exp_gentoo->exp_vsize; i++) {			\
			*op++ = DZC(scalar, OPR, *rp);			\
			rp++;						\
		}							\
		break;							\
	case ET_SYM:							\
	default:							\
		post_error((fts_object_t *) exp_gentoo, 		   	\
		      "expr: ex_eval(%d): bad right type %ld\n",	\
					      __LINE__, right.ex_type);	\
		nullret = 1;						\

		}							\
		optr->ex_type = ET_VEC;					\
		optr->ex_vec = (t_float *)				\
		  fts_malloc(sizeof (t_float)*exp_gentoo->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 < exp_gentoo->exp_vsize; i++) {			\
			*op++ = DZC(*lp, OPR, scalar);			\
			lp++;						\
		}							\
		break;                                                  \
	case ET_FLT:							\
		scalar = right.ex_flt;					\
		for (i = 0; i < exp_gentoo->exp_vsize; i++) {			\
			*op++ = DZC(*lp, OPR, scalar);			\
			lp++;						\
		}							\

	case ET_VEC:							\
	case ET_VI:							\
		rp = right.ex_vec;					\
		for (i = 0; i < exp_gentoo->exp_vsize; i++) {			\
			/*						\
			 * on a RISC processor one could copy		\
			 * 8 times in each round to get a considerable	\

		break;                                                  \
	case ET_SYM:							\
	default:							\
		post_error((fts_object_t *) exp_gentoo, 		   	\
		      "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 *) exp_gentoo, 		   	\
		      "expr: ex_eval(%d): bad left type %ld\n",		\
					      __LINE__, left.ex_type);	\
}									\

 * evaluate a unary operator, TYPE is applied to float operands
 */
#define EVAL_UNARY(OPR, TYPE) 						\
	eptr = ex_eval(exp_gentoo, 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),\
							exp_gentoo->exp_vsize);\
			break;						\
		}							\
		optr->ex_type = ET_INT;					\

	case ET_FLT:							\
		if (optr->ex_type == ET_VEC) {				\
			ex_mkvector(optr->ex_vec, OPR (TYPE left.ex_flt),\
							exp_gentoo->exp_vsize);\
			break;						\
		}							\
		optr->ex_type = ET_FLT;					\

		break;							\
	case ET_VI:							\
	case ET_VEC:							\
		j = exp_gentoo->exp_vsize;					\
		if (optr->ex_type != ET_VEC) {				\
			optr->ex_type = ET_VEC;				\
			optr->ex_vec = (t_float *)			\
			  fts_malloc(sizeof (t_float)*exp_gentoo->exp_vsize);	\
		}							\
		op = optr->ex_vec;					\
		lp = left.ex_vec;					\
		j = exp_gentoo->exp_vsize;					\
		for (i = 0; i < j; i++)					\
			*op++ = OPR (TYPE *lp++);			\
		break;							\
	default:							\
		post_error((fts_object_t *) exp_gentoo,			\
			"expr: ex_eval(%d): bad left type %ld\n",	\
					      __LINE__, left.ex_type);	\
		nullret++;						\

 * ex_dzdetect -- divide by zero detected
 */
void
ex_dzdetect(struct expr *exp_gentoo)
{
	char *etype;

	if (!exp_gentoo->exp_error & EE_DZ) {
		if (IS_EXPR(exp_gentoo))
			etype = "expr";
		else if (IS_EXPR_TILDE(exp_gentoo))
			etype = "expr~";
		else if (IS_FEXPR_TILDE(exp_gentoo))
			etype = "fexpr~";
		else {
			post ("expr -- ex_dzdetect internal error");
			etype = "";
		}
		post ("%s divide by zero detected", etype);
		exp_gentoo->exp_error |= EE_DZ;
	}
}


/*
 * ex_eval -- evaluate the array of prefix expression

look into the variable nullret
*/
struct ex_ex *
ex_eval(struct expr *exp_gentoo, struct ex_ex *eptr, struct ex_ex *optr, int idx)
/* the expr object data pointer */
/* the operation stack */
/* the result pointer */

	case ET_INT:
		if (optr->ex_type == ET_VEC)
			ex_mkvector(optr->ex_vec, (float) eptr->ex_int,
								exp_gentoo->exp_vsize);
		else
			*optr = *eptr;
		return (++eptr);

	case ET_FLT:

		if (optr->ex_type == ET_VEC)
			ex_mkvector(optr->ex_vec, eptr->ex_flt, exp_gentoo->exp_vsize);
		else
			*optr = *eptr;
		return (++eptr);

	case ET_SYM:
		if (optr->ex_type == ET_VEC) {
			post_error((fts_object_t *) exp_gentoo,
			      "expr: ex_eval: cannot turn string to vector\n");
			return (exNULL);
		}

		return (++eptr);
	case ET_II:
		if (eptr->ex_int == -1) {
			post_error((fts_object_t *) exp_gentoo,
			    "expr: ex_eval: inlet number not set\n");
			return (exNULL);
		}
		if (optr->ex_type == ET_VEC) {
			ex_mkvector(optr->ex_vec,
			       (t_float)exp_gentoo->exp_var[eptr->ex_int].ex_int,
			       					exp_gentoo->exp_vsize);
		} else {
			optr->ex_type = ET_INT;
			optr->ex_int = exp_gentoo->exp_var[eptr->ex_int].ex_int;
		}
		return (++eptr);
	case ET_FI:
		if (eptr->ex_int == -1) {
			post_error((fts_object_t *) exp_gentoo,
			    "expr: ex_eval: inlet number not set\n");
			return (exNULL);
		}
		if (optr->ex_type == ET_VEC) {
			ex_mkvector(optr->ex_vec,
			     exp_gentoo->exp_var[eptr->ex_int].ex_flt, exp_gentoo->exp_vsize);
		} else {
			optr->ex_type = ET_FLT;
			optr->ex_flt = exp_gentoo->exp_var[eptr->ex_int].ex_flt;
		}
		return (++eptr);

	case ET_VSYM:
		if (optr->ex_type == ET_VEC) {
			post_error((fts_object_t *) exp_gentoo,
			    "expr: IntErr. vsym in for vec out\n");
			return (exNULL);
		}
		if (eptr->ex_int == -1) {
			post_error((fts_object_t *) exp_gentoo,
				"expr: ex_eval: inlet number not set\n");
			return (exNULL);
		}
		optr->ex_type = ET_SYM;
		optr->ex_ptr = exp_gentoo->exp_var[eptr->ex_int].ex_ptr;
		return(++eptr);

	case ET_VI:
		if (optr->ex_type != ET_VEC)
			*optr = exp_gentoo->exp_var[eptr->ex_int];
		else if (optr->ex_vec != exp_gentoo->exp_var[eptr->ex_int].ex_vec)
			memcpy(optr->ex_vec, exp_gentoo->exp_var[eptr->ex_int].ex_vec,
					exp_gentoo->exp_vsize * sizeof (t_float));
		return(++eptr);
	case ET_VEC:
		if (optr->ex_type != ET_VEC) {

			eptr->ex_int = 0;
		} else if (optr->ex_vec != eptr->ex_vec) {
			memcpy(optr->ex_vec, eptr->ex_vec,
					exp_gentoo->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");

			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();
		}

		/* short hand for $x?[0] */

		/* SDY delete the following check */
		if (!IS_FEXPR_TILDE(exp_gentoo) || optr->ex_type==ET_VEC) {
			post("%d:exp->exp_flags = %d", __LINE__,exp_gentoo->exp_flags);
			abort();
		}
		optr->ex_type = ET_FLT;
		optr->ex_flt = exp_gentoo->exp_var[eptr->ex_int].ex_vec[idx];
		return(++eptr);
	case ET_YOM1:
		/*

		optr->ex_type = ET_FLT;
		if (idx == 0)
			optr->ex_flt =
			exp_gentoo->exp_p_res[eptr->ex_int][exp_gentoo->exp_vsize - 1];
		else
			optr->ex_flt=exp_gentoo->exp_tmpres[eptr->ex_int][idx-1];
		return(++eptr);
		
	case ET_YO:
	case ET_XI:
		/* SDY delete the following */
		if (!IS_FEXPR_TILDE(exp_gentoo) || optr->ex_type==ET_VEC) {
			post("%d:exp->exp_flags = %d", __LINE__,exp_gentoo->exp_flags);
			abort();
		}
		return (eval_sigidx(exp_gentoo, eptr, optr, idx));
			
	case ET_TBL:
	case ET_SI:
		return (eval_tab(exp_gentoo, eptr, optr, idx));
	case ET_FUNC:
		return (eval_func(exp_gentoo, eptr, optr, idx));
	case ET_VAR:
		return (eval_var(exp_gentoo, eptr, optr, idx));
	case ET_OP:
		break;
	case ET_STR:
	case ET_LP:
	case ET_LB:
	default:
		post_error((fts_object_t *) exp_gentoo,
			"expr: ex_eval: unexpected type %d\n", eptr->ex_type);
		return (exNULL);
	}
	if (!eptr[1].ex_type) {
		post_error((fts_object_t *) exp_gentoo,
					"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 *) exp_gentoo,
					"expr: ex_eval: not enough nodes 2\n");
		return (exNULL);
	}

	switch((eptr++)->ex_op) {
	case OP_STORE:
		return (eval_store(exp_gentoo, eptr, optr, idx));
	case OP_NOT:
		EVAL_UNARY(!, +);
	case OP_NEG:

 */
#undef DZC
#define DZC(ARG1,OPR,ARG2)	(((ARG2)?(((int)ARG1) OPR ((int)ARG2)) \
							: (ex_dzdetect(exp_gentoo),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(exp_gentoo),0)))
	case OP_DIV:
		EVAL(/);
	case OP_LP:

	case OP_COMMA:
	case OP_SEMI:
	default:
		post_error((fts_object_t *) exp_gentoo, "expr: ex_print: bad op 0x%x\n", eptr->ex_op);
		return (exNULL);
	}


 *		 appropriate function
 */
struct ex_ex *
eval_func(struct expr *exp_gentoo, struct ex_ex *eptr, struct ex_ex *optr, int idx)
/* the expr object data pointer */
/* the operation stack */
/* the result pointer */

		return (exNULL);
	}
	if (f->f_argc > MAX_ARGS) {
		post_error((fts_object_t *) exp_gentoo, "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(exp_gentoo, eptr, &args[i], idx);
	}
	(*f->f_func)(exp_gentoo, 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);

 *		  and call ex_eval on the right operator
 */
struct ex_ex *
eval_store(struct expr *exp_gentoo, struct ex_ex *eptr, struct ex_ex *optr, int idx)
/* the expr object data pointer */
/* the operation stack */
/* the result pointer */


post("store called\n");
ex_print(eptr);
eptr = ex_eval(exp_gentoo, ++eptr, optr, idx);
return (eptr);

#ifdef notdef /* SDY */

 * eval_tab -- evaluate a table operation
 */
struct ex_ex *
eval_tab(struct expr *exp_gentoo, struct ex_ex *eptr, struct ex_ex *optr, int idx)
/* the expr object data pointer */
/* the operation stack */
/* the result pointer */

	int notable = 0;
	
	if (eptr->ex_type == ET_SI) {
		if (!exp_gentoo->exp_var[eptr->ex_int].ex_ptr) {
/* SDY post_error() does not work in MAX/MSP yet
				post_error((fts_object_t *) exp,
				     "expr: syntax error: no string for inlet %d\n", eptr->ex_int + 1);
*/
				if (!(exp_gentoo->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");
					exp_gentoo->exp_error |= EE_NOTABLE;
				}
				notable++;
		} else
			tbl = (char *) exp_gentoo->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 *) exp_gentoo, "expr: eval_tbl: bad type %ld\n", eptr->ex_type);
		notable++;

	}
	arg.ex_type = 0;
	arg.ex_int = 0;
	eptr = ex_eval(exp_gentoo, ++eptr, &arg, idx);

	optr->ex_type = ET_INT;
	optr->ex_int = 0;
	if (!notable)
		(void)max_ex_tab(exp_gentoo, (t_symbol *)tbl, &arg, optr);
	if (arg.ex_type == ET_VEC)
		fts_free(arg.ex_vec);
	return (eptr);

 * eval_var -- evaluate a variable
 */
struct ex_ex *
eval_var(struct expr *exp_gentoo, struct ex_ex *eptr, struct ex_ex *optr, int idx)
/* the expr object data pointer */
/* the operation stack */
/* the result pointer */

	int novar = 0;
	
	if (eptr->ex_type == ET_SI) {
		if (!exp_gentoo->exp_var[eptr->ex_int].ex_ptr) {
/* SDY post_error() does not work in MAX/MSP yet
post_error((fts_object_t *) exp,
"expr: syntax error: no string for inlet %d\n", eptr->ex_int + 1);
*/
				if (!(exp_gentoo->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");
					exp_gentoo->exp_error |= EE_NOVAR;
				}
				novar++;
		} else
			var = (char *) exp_gentoo->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 *) exp_gentoo, "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(exp_gentoo, (t_symbol *)var, optr);
	return (++eptr);
}


 * eval_sigidx -- evaluate the value of an indexed signal for fexpr~
 */
struct ex_ex *
eval_sigidx(struct expr *exp_gentoo, struct ex_ex *eptr, struct ex_ex *optr, int idx)
/* the expr object data pointer */
/* the operation stack */
/* the result pointer */


	arg.ex_type = 0;
	arg.ex_int = 0;
	reteptr = ex_eval(exp_gentoo, eptr + 1, &arg, idx);
	if (arg.ex_type == ET_FLT) {
		fi = arg.ex_flt;		/* float index */
		i = (int) arg.ex_flt;		/* integer index */

	 */
	if (eptr->ex_type == ET_XI) {
		if (fi > 0) {
			if (!(exp_gentoo->exp_error & EE_BI_INPUT)) {
				exp_gentoo->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");

			i = 0;
			rem_i = 0;
		}
		if (cal_sigidx(optr, i, rem_i, idx, exp_gentoo->exp_vsize,
					exp_gentoo->exp_var[eptr->ex_int].ex_vec,
						exp_gentoo->exp_p_var[eptr->ex_int])) {
			if (!(exp_gentoo->exp_error & EE_BI_INPUT)) {
				exp_gentoo->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",
					exp_gentoo->exp_vsize);
				post("fexpr~: no error report till next reset");
			}
		}

	} else if (eptr->ex_type == ET_YO) {
		/* for output vectors index of zero is not legal */
		if (fi >= 0) {
			if (!(exp_gentoo->exp_error & EE_BI_OUTPUT)) {
				exp_gentoo->exp_error |= EE_BI_OUTPUT;
				post("fexpr~: bad output index, (%f)", fi);
				ex_print(eptr);
				post("fexpr~: no error report till next reset");

			}
			i = -1;
		}
		if (eptr->ex_int >= exp_gentoo->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, exp_gentoo->exp_vsize,
			     exp_gentoo->exp_tmpres[eptr->ex_int],
		     				exp_gentoo->exp_p_res[eptr->ex_int])) {
			if (!(exp_gentoo->exp_error & EE_BI_OUTPUT)) {
				exp_gentoo->exp_error |= EE_BI_OUTPUT;
				post("fexpr~: bad output index, (%f)", fi);
				ex_print(eptr);
				post("fexpr~: index assumed to be = -%d",
					exp_gentoo->exp_vsize);
			}
		}
	} else {

 * getoken -- return 1 on syntax error otherwise 0
 */
int
getoken(struct expr *exp_gentoo, struct ex_ex *eptr)
{
	char *p;
	long i;


	if (!exp_gentoo->exp_str) {
		post("expr: getoken: expression string not set\n");
		return (0);
	}
retry:
	if (!*exp_gentoo->exp_str) {
		eptr->ex_type = 0;
		eptr->ex_int = 0;
		return (0);
	}
	if (*exp_gentoo->exp_str == ';') {
		exp_gentoo->exp_str++;
		eptr->ex_type = 0;
		eptr->ex_int = 0;
		return (0);
	}
	eptr->ex_type = ET_OP;
	switch (*exp_gentoo->exp_str++) {
	case '\\':
	case ' ':
	case '\t':

		eptr->ex_op = OP_LB;
		break;
	case '!':
		if (*exp_gentoo->exp_str == '=') {
			eptr->ex_op = OP_NE;
			exp_gentoo->exp_str++;
		} else
			eptr->ex_op = OP_NOT;
		break;
	case '<':
		switch (*exp_gentoo->exp_str) {
		case '<':
			eptr->ex_op = OP_SL;
			exp_gentoo->exp_str++;
			break;
		case '=':
			eptr->ex_op = OP_LE;
			exp_gentoo->exp_str++;
			break;
		default:
			eptr->ex_op = OP_LT;

		}
		break;
	case '>':
		switch (*exp_gentoo->exp_str) {
		case '>':
			eptr->ex_op = OP_SR;
			exp_gentoo->exp_str++;
			break;
		case '=':
			eptr->ex_op = OP_GE;
			exp_gentoo->exp_str++;
			break;
		default:
			eptr->ex_op = OP_GT;

		}
		break;
	case '=':
		if (*exp_gentoo->exp_str++ != '=') {
			post("expr: syntax error: =\n");
			return (1);
		}

*/

	case '&':
		if (*exp_gentoo->exp_str == '&') {
			exp_gentoo->exp_str++;
			eptr->ex_op = OP_LAND;
		} else
			eptr->ex_op = OP_AND;
		break;

	case '|':
		if ((*exp_gentoo->exp_str == '|')) {
			exp_gentoo->exp_str++;
			eptr->ex_op = OP_LOR;
		} else
			eptr->ex_op = OP_OR;
		break;
	case '$':
		switch (*exp_gentoo->exp_str++) {
		case 'I':
		case 'i':
			eptr->ex_type = ET_II;

			break;
		case 'V':
		case 'v':
			if (IS_EXPR_TILDE(exp_gentoo)) {
				eptr->ex_type = ET_VI;
				break;
			}
			post("$v? works only for expr~");
			post("expr: syntax error: %s\n", &exp_gentoo->exp_str[-2]);
			return (1);
		case 'X':
		case 'x':
			if (IS_FEXPR_TILDE(exp_gentoo)) {
				eptr->ex_type = ET_XI;
				if (isdigit(*exp_gentoo->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", &exp_gentoo->exp_str[-2]);
			return (1);
		case 'y':
		case 'Y':
			if (IS_FEXPR_TILDE(exp_gentoo)) {
				eptr->ex_type = ET_YO;
				/*$y takes no number */
				if (isdigit(*exp_gentoo->exp_str))
					break;
				/* for $y[] is a shorhand for $y1[] */
				eptr->ex_int = 0;

			}
			post("$y works only for fexpr~");
		default:
			post("expr: syntax error: %s\n", &exp_gentoo->exp_str[-2]);
			return (1);
		}
		p = atoif(exp_gentoo->exp_str, &eptr->ex_op, &i);
		if (!p) {
			post("expr: syntax error: %s\n", &exp_gentoo->exp_str[-2]);
			return (1);
		}
		if (i != ET_INT) {
			post("expr: syntax error: %s\n", exp_gentoo->exp_str);
			return (1);
		}
		/*

		 */
		if (!eptr->ex_op || (eptr->ex_op)-- > MAX_VARS) {
		 post("expr: syntax error: inlet or outlet out of range: %s\n",
							     exp_gentoo->exp_str);
			return (1);
		}


		 * illegal for fexr~
		 */
		if (eptr->ex_op == 0 &&
		   (IS_FEXPR_TILDE(exp_gentoo) ||  IS_EXPR_TILDE(exp_gentoo)) &&
		   (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");

			/* it is an outlet  for fexpr~*/
			/* no need to do anything */
			;
		} else if (!exp_gentoo->exp_var[eptr->ex_op].ex_type)
			exp_gentoo->exp_var[eptr->ex_op].ex_type = eptr->ex_type;
		else if (exp_gentoo->exp_var[eptr->ex_op].ex_type != eptr->ex_type) {
			post("expr: syntax error: inlets can only have one type: %s\n", exp_gentoo->exp_str);
			return (1);
		}
		exp_gentoo->exp_str = p;
noinletnum:
		break;
	case '"':
		{
			struct ex_ex ex;

			p = exp_gentoo->exp_str;
			if (!*exp_gentoo->exp_str || *exp_gentoo->exp_str == '"') {
				post("expr: syntax error: empty symbol: %s\n", --exp_gentoo->exp_str);
				return (1);
			}
			if (getoken(exp_gentoo, &ex))
				return (1);
			switch (ex.ex_type) {
			case ET_STR:

				post("expr: syntax error: bad symbol name: %s\n", p);
				return (1);
			}
			if (*exp_gentoo->exp_str++ != '"') {
				post("expr: syntax error: missing '\"'\n");
				return (1);
			}

	case '7':
	case '8':
	case '9':
		p = atoif(--exp_gentoo->exp_str, &eptr->ex_int, &eptr->ex_type);
		if (!p)
			return (1);
		exp_gentoo->exp_str = p;
		break;

	default:

		 * has to be a string, it should either be a 
		 * function or a table 
		 */
		p = --exp_gentoo->exp_str;
		for (i = 0; name_ok(*p); i++)
			p++;
		if (!i) {
			post("expr: syntax error: %s\n", exp_gentoo->exp_str);
			return (1);
		}
		eptr->ex_ptr = (char *)fts_malloc(i + 1);
		strncpy(eptr->ex_ptr, exp_gentoo->exp_str, (int) i);
		(eptr->ex_ptr)[i] = 0;
		exp_gentoo->exp_str = p;
		/*
		 * we mark this as a string and later we will change this
		 * to either a function or a table




 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.


static char *exp_version = "0.4";

extern struct ex_ex *ex_eval(struct expr *exp_gentoo, struct ex_ex *eptr,
						struct ex_ex *optr, int n);

#ifdef PD

 *  the result pointer 
 */
int
max_ex_tab(struct expr *exp_gentoo,fts_symbol_t s,struct ex_ex *arg,struct ex_ex *optr)
{
#ifdef PD
	t_garray *garray;

	{
		optr->ex_type = ET_FLT;
		optr->ex_flt = 0;
		pd_error(exp_gentoo, "no such table '%s'", s->s_name);
		return (1);
	}
	optr->ex_type = ET_FLT;

		break;

	default:	/* do something with strings */
		pd_error(exp_gentoo, "expr: bad argument for table '%s'\n", fts_symbol_name(s));
		indx = 0;
	}
	if (indx < 0) indx = 0;

}

int
max_ex_var(struct expr *exp_gentoo, 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(exp_gentoo, "no such var '%s'", var->s_name);
		return (1);
	}
	return (0);

Lines 69-75 Link Here

(-)src/s_audio_jack.c (-1 / +1 lines)
69	static int	69	static int
70	srate (jack_nframes_t srate, void *arg)	70	srate (jack_nframes_t srate, void *arg)
71	{	71	{
72	printf ("jack: sample rate %ld/sec\n", srate);	72	printf ("jack: sample rate %ld/sec\n", (long int)srate);
73	sys_dacsr = srate;	73	sys_dacsr = srate;
74	return 0;	74	return 0;
75	}	75	}

Return to bug 28007

Lines 13-19 Link Here

(-)extra/expr~/vexp_if.c (-7 / +7 lines)
13	* but WITHOUT ANY WARRANTY; without even the implied warranty of	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15	* GNU General Public License for more details.	15	* GNU General Public License for more details.
16	*	16	*
17	* You should have received a copy of the GNU General Public License	17	* You should have received a copy of the GNU General Public License
18	* along with this program; if not, write to the Free Software	18	* along with this program; if not, write to the Free Software
19	* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.	19	* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
Lines 44-50 Link Here
44		44
45	static char *exp_version = "0.4";	45	static char *exp_version = "0.4";
46		46
47	extern struct ex_ex ex_eval(struct expr exp, struct ex_ex *eptr,	47	extern struct ex_ex ex_eval(struct expr exp_gentoo, struct ex_ex *eptr,
48	struct ex_ex *optr, int n);	48	struct ex_ex *optr, int n);
49		49
50	#ifdef PD	50	#ifdef PD
Lines 888-894 Link Here
888	* the result pointer	888	* the result pointer
889	*/	889	*/
890	int	890	int
891	max_ex_tab(struct expr exp,fts_symbol_t s,struct ex_ex arg,struct ex_ex *optr)	891	max_ex_tab(struct expr exp_gentoo,fts_symbol_t s,struct ex_ex arg,struct ex_ex *optr)
892	{	892	{
893	#ifdef PD	893	#ifdef PD
894	t_garray *garray;	894	t_garray *garray;
Lines 900-906 Link Here
900	{	900	{
901	optr->ex_type = ET_FLT;	901	optr->ex_type = ET_FLT;
902	optr->ex_flt = 0;	902	optr->ex_flt = 0;
903	pd_error(exp, "no such table '%s'", s->s_name);	903	pd_error(exp_gentoo, "no such table '%s'", s->s_name);
904	return (1);	904	return (1);
905	}	905	}
906	optr->ex_type = ET_FLT;	906	optr->ex_type = ET_FLT;
Lines 915-921 Link Here
915	break;	915	break;
916		916
917	default: /* do something with strings */	917	default: /* do something with strings */
918	pd_error(exp, "expr: bad argument for table '%s'\n", fts_symbol_name(s));	918	pd_error(exp_gentoo, "expr: bad argument for table '%s'\n", fts_symbol_name(s));
919	indx = 0;	919	indx = 0;
920	}	920	}
921	if (indx < 0) indx = 0;	921	if (indx < 0) indx = 0;
Lines 933-945 Link Here
933	}	933	}
934		934
935	int	935	int
936	max_ex_var(struct expr exp, fts_symbol_t var, struct ex_ex optr)	936	max_ex_var(struct expr exp_gentoo, fts_symbol_t var, struct ex_ex optr)
937	{	937	{
938	optr->ex_type = ET_FLT;	938	optr->ex_type = ET_FLT;
939	if (value_getfloat(var, &(optr->ex_flt))) {	939	if (value_getfloat(var, &(optr->ex_flt))) {
940	optr->ex_type = ET_FLT;	940	optr->ex_type = ET_FLT;
941	optr->ex_flt = 0;	941	optr->ex_flt = 0;
942	pd_error(exp, "no such var '%s'", var->s_name);	942	pd_error(exp_gentoo, "no such var '%s'", var->s_name);
943	return (1);	943	return (1);
944	}	944	}
945	return (0);	945	return (0);