checking in version 0.38test5.

Oops, I realize I forgot some more nice files, will add them and re-commit.

svn path=/trunk/; revision=2010

12 files changed, 259 insertions, 244 deletions

diff --git a/pd/extra/README.txt b/pd/extra/README.txt
index aaac513a..850e3032 100644
--- a/pd/extra/README.txt
+++ b/pd/extra/README.txt
@@ -1,15 +1,8 @@
 This is the README file for the "extras" library, consisting of Pd
 objects which are too specialized or otherwise non-canonical for
-inclusion into Pd proper. Except as noted otherwise, all
-included materiels are Copyright 1999 Miller Puckette and others.
-Permission is granted to use this software for any purpose, commercial
-or noncommercial, as long as this notice is included with all copies.
-
-NEITHER THE AUTHORS NOR THEIR EMPLOYERS MAKE ANY WARRANTY, EXPRESS
-OR IMPLIED, IN CONNECTION WITH THIS SOFTWARE!
-
-Note that "expr" is under the GPL, which is more restrictive than Pd's own
-license agreement.
+inclusion into Pd proper.   These files are open source; see 
+LICENSE.txt in this distribution for details.
+Note however that "expr" is GPL (the rest is all BSD).
 
 This package should run in Pd under linux, MSW, or Mac OSX.
 You can additionally compile fiddle~. bonk~, and paf~ for Max/MSP.
@@ -23,11 +16,13 @@ choose - find the "best fit" of incoming vector with stored profiles
 paf~ -- phase aligned formant generator
 loop~ -- sample looper
 expr -- arithmetic expression evaluation (Shahrokh Yadegari)
+pique - fft-based peak finder
+lrshift~ - left or right shift an audio vector
 
 abstractions:
 hilbert~ - Hilbert transform for SSB modulation
 complex-mod~ - ring modulation for complex (real+imaginary) audio signals
-rev1~ - experimental reverberator
+rev1~, etc. - reverberators
 
 These objects are part of the regular Pd distribution as of Pd version
 0.30.  Macintosh versions of fiddle~, bonk~, and paf~ are available
diff --git a/pd/extra/bonk~/makefile b/pd/extra/bonk~/makefile
index 979dd2b7..578f7b8d 100644
--- a/pd/extra/bonk~/makefile
+++ b/pd/extra/bonk~/makefile
@@ -60,9 +60,9 @@ pd_linux: $(NAME).pd_linux
 
 .SUFFIXES: .pd_linux
 
-LINUXCFLAGS = -DPD -O2 -funroll-loops -fomit-frame-pointer \
-    -Wall -W -Wshadow -Wstrict-prototypes -Werror \
-    -Wno-unused -Wno-parentheses -Wno-switch
+LINUXCFLAGS = -DPD -O2 -funroll-loops -fomit-frame-pointer -fPIC \
+    -Wall -W -Wshadow -Wstrict-prototypes \
+    -Wno-unused -Wno-parentheses -Wno-switch $(CFLAGS)
 
 LINUXINCLUDE =  -I../../src
 
diff --git a/pd/extra/choice/help-choice.pd b/pd/extra/choice/help-choice.pd
index df46ddc0..0677db87 100644
--- a/pd/extra/choice/help-choice.pd
+++ b/pd/extra/choice/help-choice.pd
@@ -1,30 +1,47 @@
-#N canvas 16 5 488 531 12;
-#X obj 8 186 choice;
+#N canvas 16 5 609 600 12;
+#X obj 8 195 choice;
 #X msg 41 86 print;
 #X msg 29 63 clear;
-#X msg 8 34 add 1 0 0 \, add 0 1 0 \, add 0 0 1 \, add 1 1 1 \, add 1 1 0;
-#X obj 77 162 pack 0 0 0;
-#X floatatom 182 120;
-#X floatatom 148 120;
-#X floatatom 115 120;
-#X obj 77 142 f;
-#X msg 77 120 bang;
-#X floatatom 8 207;
-#X obj 53 187 choice 1;
-#X floatatom 53 208;
+#X msg 8 34 add 1 0 0 \, add 0 1 0 \, add 0 0 1 \, add 1 1 1 \, add
+1 1 0;
+#X obj 77 171 pack 0 0 0;
+#X floatatom 182 125 0 0 0 0 - - -;
+#X floatatom 148 125 0 0 0 0 - - -;
+#X floatatom 115 125 0 0 0 0 - - -;
+#X obj 77 147 f;
+#X msg 77 125 bang;
+#X floatatom 8 216 0 0 0 0 - - -;
+#X obj 71 196 choice 1;
+#X floatatom 71 217 0 0 0 0 - - -;
 #X obj 76 4 choice;
-#X text 122 5 - search for a best match to an incoming list;
-#X text 19 234 The choice object holds a list of vectors \, each having up to ten elements. When sent a list of numbers \, it outputs the index of the known vector that matches most closely. The quality of the match is the dot product of the two vectors after normalizing them \, i.e. \, the vector whose direction is closest to that of the input wins.;
-#X text 19 316 If given a nonzero creation argument \, choice tries to avoid repetitious outputs by weighting less recently output vectors preferentially.;
-#X text 18 354 You can use this to choose interactively between a number of behaviors depending on their attributes. For example \, you might have stored a number of melodies \, of which some are syncopated \, some chromatic \, some are more than 100 years old \, some are bugle calls \, and some are Christmas carols. You could then ask to find a syncopated bugle call (1 \, 0 \, 0 \, 1 \, 0) and you'll get the thing most closely matching the request.;
-#X text 17 461 You can use numbers other than 0 and 1 to indicate relative strengths of the attributes \, or even use negative numbers to indicate opposites \, either in the incoming lists or in the stored ones.;
-#X text 273 513 updated for Pd version-0.30;
-#X text 72 63 delete all stored vectors;
-#X text 394 36 add vectors;
-#X text 81 85 debugging printout;
+#X text 135 3 - search for a best match to an incoming list;
+#X text 19 243 The choice object holds a list of vectors \, each having
+up to ten elements. When sent a list of numbers \, it outputs the index
+of the known vector that matches most closely. The quality of the match
+is the dot product of the two vectors after normalizing them \, i.e.
+\, the vector whose direction is closest to that of the input wins.
+;
+#X text 19 340 If given a nonzero creation argument \, choice tries
+to avoid repetitious outputs by weighting less recently output vectors
+preferentially.;
+#X text 20 389 You can use this to choose interactively between a number
+of behaviors depending on their attributes. For example \, you might
+have stored a number of melodies \, of which some are syncopated \,
+some chromatic \, some are more than 100 years old \, some are bugle
+calls \, and some are Christmas carols. You could then ask to find
+a syncopated bugle call (1 \, 0 \, 0 \, 1 \, 0) and you'll get the
+thing most closely matching the request.;
+#X text 19 514 You can use numbers other than 0 and 1 to indicate relative
+strengths of the attributes \, or even use negative numbers to indicate
+opposites \, either in the incoming lists or in the stored ones.;
+#X text 320 572 updated for Pd version-0.30;
+#X text 79 62 delete all stored vectors;
+#X text 498 34 add vectors;
+#X text 94 84 debugging printout;
 #X text 69 104 tweak the numbers and hit "bang" to input a list;
-#X text 115 187 creation argument to avoid repeated outout;
-#X text 85 208 output is the index of best match \, counting from zero;
+#X text 151 197 creation argument to avoid repeated outout;
+#X text 108 219 output is the index of best match \, counting from
+zero;
 #X connect 0 0 10 0;
 #X connect 1 0 0 0;
 #X connect 2 0 0 0;
diff --git a/pd/extra/choice/makefile b/pd/extra/choice/makefile
index 10021e24..7345eed7 100644
--- a/pd/extra/choice/makefile
+++ b/pd/extra/choice/makefile
@@ -60,9 +60,9 @@ pd_linux: $(NAME).pd_linux
 
 .SUFFIXES: .pd_linux
 
-LINUXCFLAGS = -DPD -O2 -funroll-loops -fomit-frame-pointer \
-    -Wall -W -Wshadow -Wstrict-prototypes -Werror \
-    -Wno-unused -Wno-parentheses -Wno-switch
+LINUXCFLAGS = -DPD -O2 -funroll-loops -fomit-frame-pointer  -fPIC \
+    -Wall -W -Wshadow -Wstrict-prototypes \
+    -Wno-unused -Wno-parentheses -Wno-switch $(CFLAGS)
 
 LINUXINCLUDE =  -I../../src
 
diff --git a/pd/extra/expr~/makefile b/pd/extra/expr~/makefile
index 942615f4..042380dd 100644
--- a/pd/extra/expr~/makefile
+++ b/pd/extra/expr~/makefile
@@ -79,9 +79,9 @@ SGIINCLUDE =  -I/usr/people/msp/pd/pd/src
 LINUXOBJ =  vexp.pd_linux_o vexp_fun.pd_linux_o vexp_if.pd_linux_o
 .SUFFIXES: .pd_linux_o
 
-LINUXCFLAGS = -DPD -O2 -funroll-loops -fomit-frame-pointer \
-    -Wall -W -Wshadow -Wstrict-prototypes  \
-    -Wno-unused -Wno-parentheses -Wno-switch
+LINUXCFLAGS = -DPD -O2 -funroll-loops -fomit-frame-pointer -fPIC \
+    -Wall -W -Wshadow -Wstrict-prototypes \
+    -Wno-unused -Wno-parentheses -Wno-switch $(CFLAGS)
 
 LINUXINCLUDE =  -I../../src
 
diff --git a/pd/extra/expr~/vexp.c b/pd/extra/expr~/vexp.c
index d75ab539..c0001e1f 100644
--- a/pd/extra/expr~/vexp.c
+++ b/pd/extra/expr~/vexp.c
@@ -78,23 +78,23 @@
 
 char *atoif(char *s, long int *value, long int *type);
 
-static struct ex_ex *ex_lex(struct expr *exp, long int *n);
+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 *exp, struct ex_ex *iptr,
+struct ex_ex *ex_parse(struct expr *expr, struct ex_ex *iptr,
 					struct ex_ex *optr, long int *argc);
-struct ex_ex *ex_eval(struct expr *exp, struct ex_ex *eptr,
+struct ex_ex *ex_eval(struct expr *expr, 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,struct ex_ex *eptr,
+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 *eval_tab(struct expr *exp, struct ex_ex *eptr,
+struct ex_ex *eval_tab(struct expr *expr, struct ex_ex *eptr,
 						struct ex_ex *optr, int i);
-struct ex_ex *eval_var(struct expr *exp, struct ex_ex *eptr,
+struct ex_ex *eval_var(struct expr *expr, struct ex_ex *eptr,
 						struct ex_ex *optr, int i);
-struct ex_ex *eval_store(struct expr *exp, struct ex_ex *eptr,
+struct ex_ex *eval_store(struct expr *expr, struct ex_ex *eptr,
 						struct ex_ex *optr, int i);
-struct ex_ex *eval_sigidx(struct expr *exp, struct ex_ex *eptr,
+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 */
@@ -102,7 +102,7 @@ static int cal_sigidx(struct ex_ex *optr,	/* The output value */
 	   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);
+void ex_dzdetect(struct expr *expr);
 
 #define	MAX_ARGS	10
 extern t_ex_func ex_funcs[];
@@ -110,7 +110,7 @@ extern t_ex_func ex_funcs[];
 struct ex_ex nullex;
 
 void set_tokens (char *s);
-int getoken (struct expr *exp, struct ex_ex *eptr);
+int getoken (struct expr *expr, struct ex_ex *eptr);
 void ex_print (struct ex_ex *eptr);
 #ifdef MSP
 void atom_string(t_atom *a, char *buf, unsigned int bufsize);
@@ -294,7 +294,7 @@ error:
  *	     It will also put the number of the nodes in *n.
  */
 struct ex_ex *
-ex_lex(struct expr *exp, long int *n)
+ex_lex(struct expr *expr, long int *n)
 {
 	struct ex_ex *list_arr;
 	struct ex_ex *exptr;
@@ -323,7 +323,7 @@ ex_lex(struct expr *exp, long int *n)
 			exptr = &(list_arr)[non];
 		}
 
-		if (getoken(exp, exptr)) {
+		if (getoken(expr, exptr)) {
 			fts_free(list_arr);
 			return ((struct ex_ex *)0);
 		}
@@ -684,7 +684,7 @@ ex_parse(struct expr *x, struct ex_ex *iptr, struct ex_ex *optr, long int *argc)
 #define DZC(ARG1,OPR,ARG2)	(ARG1 OPR ARG2)
 
 #define	EVAL(OPR); 							\
-eptr = ex_eval(exp, ex_eval(exp, eptr, &left, idx), &right, idx);	\
+eptr = ex_eval(expr, ex_eval(expr, eptr, &left, idx), &right, idx);	\
 switch (left.ex_type) {							\
 case ET_INT:								\
 	switch(right.ex_type) {						\
@@ -692,7 +692,7 @@ 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 < exp->exp_vsize; j++)		\
+			for (j = 0; j < expr->exp_vsize; j++)		\
 				*op++ = scalar;				\
 		} else {						\
 			optr->ex_type = ET_INT;				\
@@ -703,7 +703,7 @@ case 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->exp_vsize; j++)		\
+			for (j = 0; j < expr->exp_vsize; j++)		\
 				*op++ = scalar;				\
 		} else {						\
 			optr->ex_type = ET_FLT;				\
@@ -720,19 +720,19 @@ case ET_INT:								\
 			}						\
 			optr->ex_type = ET_VEC;				\
 			optr->ex_vec = (t_float *)			\
-			  fts_malloc(sizeof (t_float)*exp->exp_vsize);	\
+			  fts_malloc(sizeof (t_float)*expr->exp_vsize);	\
 		}							\
 		scalar = left.ex_int;					\
 		rp = right.ex_vec;					\
 		op = optr->ex_vec;					\
-		for (i = 0; i < exp->exp_vsize; i++) {			\
+		for (i = 0; i < expr->exp_vsize; i++) {			\
 			*op++ = DZC (scalar, OPR, *rp);			\
 			rp++;						\
 		}							\
 		break;							\
 	case ET_SYM:							\
 	default:							\
-		post_error((fts_object_t *) exp, 		   	\
+		post_error((fts_object_t *) expr, 		   	\
 		      "expr: ex_eval(%d): bad right type %ld\n",	\
 					      __LINE__, right.ex_type);	\
 		nullret = 1;						\
@@ -744,7 +744,7 @@ case ET_FLT:								\
 		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->exp_vsize; j++)		\
+			for (j = 0; j < expr->exp_vsize; j++)		\
 				*op++ = scalar;				\
 		} else {						\
 			optr->ex_type = ET_FLT;				\
@@ -755,7 +755,7 @@ 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 < exp->exp_vsize; j++)		\
+			for (j = 0; j < expr->exp_vsize; j++)		\
 				*op++ = scalar;				\
 		} else {						\
 			optr->ex_type = ET_FLT;				\
@@ -771,19 +771,19 @@ case ET_FLT:								\
 			}						\
 			optr->ex_type = ET_VEC;				\
 			optr->ex_vec = (t_float *)			\
-			  fts_malloc(sizeof (t_float)*exp->exp_vsize);	\
+			  fts_malloc(sizeof (t_float)*expr->exp_vsize);	\
 		}							\
 		scalar = left.ex_flt;					\
 		rp = right.ex_vec;					\
 		op = optr->ex_vec;					\
-		for (i = 0; i < exp->exp_vsize; i++) {			\
+		for (i = 0; i < expr->exp_vsize; i++) {			\
 			*op++ = DZC(scalar, OPR, *rp);			\
 			rp++;						\
 		}							\
 		break;							\
 	case ET_SYM:							\
 	default:							\
-		post_error((fts_object_t *) exp, 		   	\
+		post_error((fts_object_t *) expr, 		   	\
 		      "expr: ex_eval(%d): bad right type %ld\n",	\
 					      __LINE__, right.ex_type);	\
 		nullret = 1;						\
@@ -798,21 +798,21 @@ case ET_VI:								\
 		}							\
 		optr->ex_type = ET_VEC;					\
 		optr->ex_vec = (t_float *)				\
-		  fts_malloc(sizeof (t_float)*exp->exp_vsize);		\
+		  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 < exp->exp_vsize; i++) {			\
+		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 < exp->exp_vsize; i++) {			\
+		for (i = 0; i < expr->exp_vsize; i++) {			\
 			*op++ = DZC(*lp, OPR, scalar);			\
 			lp++;						\
 		}							\
@@ -820,7 +820,7 @@ case ET_VI:								\
 	case ET_VEC:							\
 	case ET_VI:							\
 		rp = right.ex_vec;					\
-		for (i = 0; i < exp->exp_vsize; i++) {			\
+		for (i = 0; i < expr->exp_vsize; i++) {			\
 			/*						\
 			 * on a RISC processor one could copy		\
 			 * 8 times in each round to get a considerable	\
@@ -832,7 +832,7 @@ case ET_VI:								\
 		break;                                                  \
 	case ET_SYM:							\
 	default:							\
-		post_error((fts_object_t *) exp, 		   	\
+		post_error((fts_object_t *) expr, 		   	\
 		      "expr: ex_eval(%d): bad right type %ld\n",	\
 					      __LINE__, right.ex_type);	\
 		nullret = 1;						\
@@ -840,7 +840,7 @@ case ET_VI:								\
 	break;								\
 case ET_SYM:								\
 default:								\
-		post_error((fts_object_t *) exp, 		   	\
+		post_error((fts_object_t *) expr, 		   	\
 		      "expr: ex_eval(%d): bad left type %ld\n",		\
 					      __LINE__, left.ex_type);	\
 }									\
@@ -850,12 +850,12 @@ break;
  * evaluate a unary operator, TYPE is applied to float operands
  */
 #define EVAL_UNARY(OPR, TYPE) 						\
-	eptr = ex_eval(exp, eptr, &left, idx);				\
+	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),\
-							exp->exp_vsize);\
+							expr->exp_vsize);\
 			break;						\
 		}							\
 		optr->ex_type = ET_INT;					\
@@ -864,7 +864,7 @@ break;
 	case ET_FLT:							\
 		if (optr->ex_type == ET_VEC) {				\
 			ex_mkvector(optr->ex_vec, OPR (TYPE left.ex_flt),\
-							exp->exp_vsize);\
+							expr->exp_vsize);\
 			break;						\
 		}							\
 		optr->ex_type = ET_FLT;					\
@@ -872,20 +872,20 @@ break;
 		break;							\
 	case ET_VI:							\
 	case ET_VEC:							\
-		j = exp->exp_vsize;					\
+		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)*exp->exp_vsize);	\
+			  fts_malloc(sizeof (t_float)*expr->exp_vsize);	\
 		}							\
 		op = optr->ex_vec;					\
 		lp = left.ex_vec;					\
-		j = exp->exp_vsize;					\
+		j = expr->exp_vsize;					\
 		for (i = 0; i < j; i++)					\
 			*op++ = OPR (TYPE *lp++);			\
 		break;							\
 	default:							\
-		post_error((fts_object_t *) exp,			\
+		post_error((fts_object_t *) expr,			\
 			"expr: ex_eval(%d): bad left type %ld\n",	\
 					      __LINE__, left.ex_type);	\
 		nullret++;						\
@@ -903,23 +903,23 @@ ex_mkvector(t_float *fp, t_float x, int size)
  * ex_dzdetect -- divide by zero detected
  */
 void
-ex_dzdetect(struct expr *exp)
+ex_dzdetect(struct expr *expr)
 {
 	char *etype;
 
-	if (!exp->exp_error & EE_DZ) {
-		if (IS_EXPR(exp))
+	if (!expr->exp_error & EE_DZ) {
+		if (IS_EXPR(expr))
 			etype = "expr";
-		else if (IS_EXPR_TILDE(exp))
+		else if (IS_EXPR_TILDE(expr))
 			etype = "expr~";
-		else if (IS_FEXPR_TILDE(exp))
+		else if (IS_FEXPR_TILDE(expr))
 			etype = "fexpr~";
 		else {
 			post ("expr -- ex_dzdetect internal error");
 			etype = "";
 		}
 		post ("%s divide by zero detected", etype);
-		exp->exp_error |= EE_DZ;
+		expr->exp_error |= EE_DZ;
 	}
 }
 		
@@ -938,7 +938,7 @@ need to be freed
 look into the variable nullret
 */
 struct ex_ex *
-ex_eval(struct expr *exp, struct ex_ex *eptr, struct ex_ex *optr, int idx)
+ex_eval(struct expr *expr, struct ex_ex *eptr, struct ex_ex *optr, int idx)
 /* the expr object data pointer */
 /* the operation stack */
 /* the result pointer */
@@ -961,7 +961,7 @@ ex_eval(struct expr *exp, struct ex_ex *eptr, struct ex_ex *optr, int idx)
 	case ET_INT:
 		if (optr->ex_type == ET_VEC)
 			ex_mkvector(optr->ex_vec, (float) eptr->ex_int,
-								exp->exp_vsize);
+								expr->exp_vsize);
 		else
 			*optr = *eptr;
 		return (++eptr);
@@ -969,14 +969,14 @@ ex_eval(struct expr *exp, struct ex_ex *eptr, struct ex_ex *optr, int idx)
 	case ET_FLT:
 
 		if (optr->ex_type == ET_VEC)
-			ex_mkvector(optr->ex_vec, eptr->ex_flt, exp->exp_vsize);
+			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 *) exp,
+			post_error((fts_object_t *) expr,
 			      "expr: ex_eval: cannot turn string to vector\n");
 			return (exNULL);
 		}
@@ -984,55 +984,55 @@ ex_eval(struct expr *exp, struct ex_ex *eptr, struct ex_ex *optr, int idx)
 		return (++eptr);
 	case ET_II:
 		if (eptr->ex_int == -1) {
-			post_error((fts_object_t *) exp,
+			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)exp->exp_var[eptr->ex_int].ex_int,
-			       					exp->exp_vsize);
+			       (t_float)expr->exp_var[eptr->ex_int].ex_int,
+			       					expr->exp_vsize);
 		} else {
 			optr->ex_type = ET_INT;
-			optr->ex_int = exp->exp_var[eptr->ex_int].ex_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 *) exp,
+			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,
-			     exp->exp_var[eptr->ex_int].ex_flt, exp->exp_vsize);
+			     expr->exp_var[eptr->ex_int].ex_flt, expr->exp_vsize);
 		} else {
 			optr->ex_type = ET_FLT;
-			optr->ex_flt = exp->exp_var[eptr->ex_int].ex_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 *) exp,
+			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 *) exp,
+			post_error((fts_object_t *) expr,
 				"expr: ex_eval: inlet number not set\n");
 			return (exNULL);
 		}
 		optr->ex_type = ET_SYM;
-		optr->ex_ptr = exp->exp_var[eptr->ex_int].ex_ptr;
+		optr->ex_ptr = expr->exp_var[eptr->ex_int].ex_ptr;
 		return(++eptr);
 
 	case ET_VI:
 		if (optr->ex_type != ET_VEC)
-			*optr = exp->exp_var[eptr->ex_int];
-		else if (optr->ex_vec != exp->exp_var[eptr->ex_int].ex_vec)
-			memcpy(optr->ex_vec, exp->exp_var[eptr->ex_int].ex_vec,
-					exp->exp_vsize * sizeof (t_float));
+			*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) {
@@ -1042,7 +1042,7 @@ ex_eval(struct expr *exp, struct ex_ex *eptr, struct ex_ex *optr, int idx)
 			eptr->ex_int = 0;
 		} else if (optr->ex_vec != eptr->ex_vec) {
 			memcpy(optr->ex_vec, eptr->ex_vec,
-					exp->exp_vsize * sizeof (t_float));
+					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");
@@ -1059,12 +1059,12 @@ abort();
 		/* short hand for $x?[0] */
 
 		/* SDY delete the following check */
-		if (!IS_FEXPR_TILDE(exp) || optr->ex_type==ET_VEC) {
-			post("%d:exp->exp_flags = %d", __LINE__,exp->exp_flags);
+		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 = exp->exp_var[eptr->ex_int].ex_vec[idx];
+		optr->ex_flt = expr->exp_var[eptr->ex_int].ex_vec[idx];
 		return(++eptr);
 	case ET_YOM1:
 		/*
@@ -1075,51 +1075,51 @@ abort();
 		optr->ex_type = ET_FLT;
 		if (idx == 0)
 			optr->ex_flt =
-			exp->exp_p_res[eptr->ex_int][exp->exp_vsize - 1];
+			expr->exp_p_res[eptr->ex_int][expr->exp_vsize - 1];
 		else
-			optr->ex_flt=exp->exp_tmpres[eptr->ex_int][idx-1];
+			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(exp) || optr->ex_type==ET_VEC) {
-			post("%d:exp->exp_flags = %d", __LINE__,exp->exp_flags);
+		if (!IS_FEXPR_TILDE(expr) || optr->ex_type==ET_VEC) {
+			post("%d:expr->exp_flags = %d", __LINE__,expr->exp_flags);
 			abort();
 		}
-		return (eval_sigidx(exp, eptr, optr, idx));
+		return (eval_sigidx(expr, eptr, optr, idx));
 			
 	case ET_TBL:
 	case ET_SI:
-		return (eval_tab(exp, eptr, optr, idx));
+		return (eval_tab(expr, eptr, optr, idx));
 	case ET_FUNC:
-		return (eval_func(exp, eptr, optr, idx));
+		return (eval_func(expr, eptr, optr, idx));
 	case ET_VAR:
-		return (eval_var(exp, eptr, optr, idx));
+		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 *) exp,
+		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 *) exp,
+		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 *) exp,
+		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(exp, eptr, optr, idx));
+		return (eval_store(expr, eptr, optr, idx));
 	case OP_NOT:
 		EVAL_UNARY(!, +);
 	case OP_NEG:
@@ -1168,14 +1168,14 @@ abort();
  */
 #undef DZC
 #define DZC(ARG1,OPR,ARG2)	(((ARG2)?(((int)ARG1) OPR ((int)ARG2)) \
-							: (ex_dzdetect(exp),0)))
+							: (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(exp),0)))
+#define DZC(ARG1,OPR,ARG2)	(((ARG2)?(ARG1 OPR ARG2):(ex_dzdetect(expr),0)))
 	case OP_DIV:
 		EVAL(/);
 	case OP_LP:
@@ -1185,7 +1185,7 @@ abort();
 	case OP_COMMA:
 	case OP_SEMI:
 	default:
-		post_error((fts_object_t *) exp, "expr: ex_print: bad op 0x%x\n", eptr->ex_op);
+		post_error((fts_object_t *) expr, "expr: ex_print: bad op 0x%x\n", eptr->ex_op);
 		return (exNULL);
 	}
 
@@ -1210,7 +1210,7 @@ abort();
  *		 appropriate function
  */
 struct ex_ex *
-eval_func(struct expr *exp, struct ex_ex *eptr, struct ex_ex *optr, int idx)
+eval_func(struct expr *expr, struct ex_ex *eptr, struct ex_ex *optr, int idx)
 /* the expr object data pointer */
 /* the operation stack */
 /* the result pointer */
@@ -1224,16 +1224,16 @@ eval_func(struct expr *exp, struct ex_ex *eptr, struct ex_ex *optr, int idx)
 		return (exNULL);
 	}
 	if (f->f_argc > MAX_ARGS) {
-		post_error((fts_object_t *) exp, "expr: eval_func: asking too many arguments\n");
+		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(exp, eptr, &args[i], idx);
+		eptr = ex_eval(expr, eptr, &args[i], idx);
 	}
-	(*f->f_func)(exp, f->f_argc, args, optr);
+	(*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);
@@ -1248,7 +1248,7 @@ eval_func(struct expr *exp, struct ex_ex *eptr, struct ex_ex *optr, int idx)
  *		  and call ex_eval on the right operator
  */
 struct ex_ex *
-eval_store(struct expr *exp, struct ex_ex *eptr, struct ex_ex *optr, int idx)
+eval_store(struct expr *expr, struct ex_ex *eptr, struct ex_ex *optr, int idx)
 /* the expr object data pointer */
 /* the operation stack */
 /* the result pointer */
@@ -1261,7 +1261,7 @@ eval_store(struct expr *exp, struct ex_ex *eptr, struct ex_ex *optr, int idx)
 
 post("store called\n");
 ex_print(eptr);
-eptr = ex_eval(exp, ++eptr, optr, idx);
+eptr = ex_eval(expr, ++eptr, optr, idx);
 return (eptr);
 
 #ifdef notdef /* SDY */
@@ -1270,8 +1270,8 @@ return (eptr);
 	if (eptr->ex_type == ET_VAR) {
 		var = (char *) eptr->ex_ptr;
 
-		eptr = ex_eval(exp, ++eptr, &arg, idx);
-		(void)max_ex_var_store(exp, (t_symbol *)var, &arg, optr);
+		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);
 	}
@@ -1287,16 +1287,16 @@ return (eptr);
 	case ET_SI:
 		if ((eptr + 1)->ex_type == OP_LB) {
 		}
-		if (!exp->exp_var[eptr->ex_int].ex_ptr) {
-				if (!(exp->exp_error & EE_NOTABLE)) {
+		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");
-					exp->exp_error |= EE_NOTABLE;
+					expr->exp_error |= EE_NOTABLE;
 				}
 				badleft++;
 		} else
-			tbl = (char *) exp->exp_var[eptr->ex_int].ex_ptr;
+			tbl = (char *) expr->exp_var[eptr->ex_int].ex_ptr;
 		break;
 	case ET_TBL:
 	}
@@ -1307,7 +1307,7 @@ return (eptr);
  * eval_tab -- evaluate a table operation
  */
 struct ex_ex *
-eval_tab(struct expr *exp, struct ex_ex *eptr, struct ex_ex *optr, int idx)
+eval_tab(struct expr *expr, struct ex_ex *eptr, struct ex_ex *optr, int idx)
 /* the expr object data pointer */
 /* the operation stack */
 /* the result pointer */
@@ -1317,35 +1317,35 @@ eval_tab(struct expr *exp, struct ex_ex *eptr, struct ex_ex *optr, int idx)
 	int notable = 0;
 	
 	if (eptr->ex_type == ET_SI) {
-		if (!exp->exp_var[eptr->ex_int].ex_ptr) {
+		if (!expr->exp_var[eptr->ex_int].ex_ptr) {
 /* SDY post_error() does not work in MAX/MSP yet
-				post_error((fts_object_t *) exp,
+				post_error((fts_object_t *) expr,
 				     "expr: syntax error: no string for inlet %d\n", eptr->ex_int + 1);
 */
-				if (!(exp->exp_error & EE_NOTABLE)) {
+				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");
-					exp->exp_error |= EE_NOTABLE;
+					expr->exp_error |= EE_NOTABLE;
 				}
 				notable++;
 		} else
-			tbl = (char *) exp->exp_var[eptr->ex_int].ex_ptr;
+			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 *) exp, "expr: eval_tbl: bad type %ld\n", eptr->ex_type);
+		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(exp, ++eptr, &arg, idx);
+	eptr = ex_eval(expr, ++eptr, &arg, idx);
 
 	optr->ex_type = ET_INT;
 	optr->ex_int = 0;
 	if (!notable)
-		(void)max_ex_tab(exp, (t_symbol *)tbl, &arg, optr);
+		(void)max_ex_tab(expr, (t_symbol *)tbl, &arg, optr);
 	if (arg.ex_type == ET_VEC)
 		fts_free(arg.ex_vec);
 	return (eptr);
@@ -1355,7 +1355,7 @@ eval_tab(struct expr *exp, struct ex_ex *eptr, struct ex_ex *optr, int idx)
  * eval_var -- evaluate a variable
  */
 struct ex_ex *
-eval_var(struct expr *exp, struct ex_ex *eptr, struct ex_ex *optr, int idx)
+eval_var(struct expr *expr, struct ex_ex *eptr, struct ex_ex *optr, int idx)
 /* the expr object data pointer */
 /* the operation stack */
 /* the result pointer */
@@ -1365,24 +1365,24 @@ eval_var(struct expr *exp, struct ex_ex *eptr, struct ex_ex *optr, int idx)
 	int novar = 0;
 	
 	if (eptr->ex_type == ET_SI) {
-		if (!exp->exp_var[eptr->ex_int].ex_ptr) {
+		if (!expr->exp_var[eptr->ex_int].ex_ptr) {
 /* SDY post_error() does not work in MAX/MSP yet
-post_error((fts_object_t *) exp,
+post_error((fts_object_t *) expr,
 "expr: syntax error: no string for inlet %d\n", eptr->ex_int + 1);
 */
-				if (!(exp->exp_error & EE_NOVAR)) {
+				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");
-					exp->exp_error |= EE_NOVAR;
+					expr->exp_error |= EE_NOVAR;
 				}
 				novar++;
 		} else
-			var = (char *) exp->exp_var[eptr->ex_int].ex_ptr;
+			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 *) exp, "expr: eval_tbl: bad type %ld\n", eptr->ex_type);
+		post_error((fts_object_t *) expr, "expr: eval_tbl: bad type %ld\n", eptr->ex_type);
 		novar++;
 
 	}
@@ -1390,7 +1390,7 @@ post_error((fts_object_t *) exp,
 	optr->ex_type = ET_INT;
 	optr->ex_int = 0;
 	if (!novar)
-		(void)max_ex_var(exp, (t_symbol *)var, optr);
+		(void)max_ex_var(expr, (t_symbol *)var, optr);
 	return (++eptr);
 }
 
@@ -1398,7 +1398,7 @@ post_error((fts_object_t *) exp,
  * eval_sigidx -- evaluate the value of an indexed signal for fexpr~
  */
 struct ex_ex *
-eval_sigidx(struct expr *exp, struct ex_ex *eptr, struct ex_ex *optr, int idx)
+eval_sigidx(struct expr *expr, struct ex_ex *eptr, struct ex_ex *optr, int idx)
 /* the expr object data pointer */
 /* the operation stack */
 /* the result pointer */
@@ -1413,7 +1413,7 @@ eval_sigidx(struct expr *exp, struct ex_ex *eptr, struct ex_ex *optr, int idx)
 
 	arg.ex_type = 0;
 	arg.ex_int = 0;
-	reteptr = ex_eval(exp, eptr + 1, &arg, idx);
+	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 */
@@ -1431,8 +1431,8 @@ eval_sigidx(struct expr *exp, struct ex_ex *eptr, struct ex_ex *optr, int idx)
 	 */
 	if (eptr->ex_type == ET_XI) {
 		if (fi > 0) {
-			if (!(exp->exp_error & EE_BI_INPUT)) {
-				exp->exp_error |= EE_BI_INPUT;
+			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");
@@ -1443,15 +1443,15 @@ eval_sigidx(struct expr *exp, struct ex_ex *eptr, struct ex_ex *optr, int idx)
 			i = 0;
 			rem_i = 0;
 		}
-		if (cal_sigidx(optr, i, rem_i, idx, exp->exp_vsize,
-					exp->exp_var[eptr->ex_int].ex_vec,
-						exp->exp_p_var[eptr->ex_int])) {
-			if (!(exp->exp_error & EE_BI_INPUT)) {
-				exp->exp_error |= EE_BI_INPUT;
+		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",
-					exp->exp_vsize);
+					expr->exp_vsize);
 				post("fexpr~: no error report till next reset");
 			}
 		}
@@ -1462,8 +1462,8 @@ eval_sigidx(struct expr *exp, struct ex_ex *eptr, struct ex_ex *optr, int idx)
 	} else if (eptr->ex_type == ET_YO) {
 		/* for output vectors index of zero is not legal */
 		if (fi >= 0) {
-			if (!(exp->exp_error & EE_BI_OUTPUT)) {
-				exp->exp_error |= EE_BI_OUTPUT;
+			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");
@@ -1471,21 +1471,21 @@ eval_sigidx(struct expr *exp, struct ex_ex *eptr, struct ex_ex *optr, int idx)
 			}
 			i = -1;
 		}
-		if (eptr->ex_int >= exp->exp_nexpr) {
+		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, exp->exp_vsize,
-			     exp->exp_tmpres[eptr->ex_int],
-		     				exp->exp_p_res[eptr->ex_int])) {
-			if (!(exp->exp_error & EE_BI_OUTPUT)) {
-				exp->exp_error |= EE_BI_OUTPUT;
+		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",
-					exp->exp_vsize);
+					expr->exp_vsize);
 			}
 		}
 	} else {
@@ -1552,30 +1552,30 @@ cal_sigidx(struct ex_ex *optr,	/* The output value */
  * getoken -- return 1 on syntax error otherwise 0
  */
 int
-getoken(struct expr *exp, struct ex_ex *eptr)
+getoken(struct expr *expr, struct ex_ex *eptr)
 {
 	char *p;
 	long i;
 
 
-	if (!exp->exp_str) {
+	if (!expr->exp_str) {
 		post("expr: getoken: expression string not set\n");
 		return (0);
 	}
 retry:
-	if (!*exp->exp_str) {
+	if (!*expr->exp_str) {
 		eptr->ex_type = 0;
 		eptr->ex_int = 0;
 		return (0);
 	}
-	if (*exp->exp_str == ';') {
-		exp->exp_str++;
+	if (*expr->exp_str == ';') {
+		expr->exp_str++;
 		eptr->ex_type = 0;
 		eptr->ex_int = 0;
 		return (0);
 	}
 	eptr->ex_type = ET_OP;
-	switch (*exp->exp_str++) {
+	switch (*expr->exp_str++) {
 	case '\\':
 	case ' ':
 	case '\t':
@@ -1621,21 +1621,21 @@ retry:
 		eptr->ex_op = OP_LB;
 		break;
 	case '!':
-		if (*exp->exp_str == '=') {
+		if (*expr->exp_str == '=') {
 			eptr->ex_op = OP_NE;
-			exp->exp_str++;
+			expr->exp_str++;
 		} else
 			eptr->ex_op = OP_NOT;
 		break;
 	case '<':
-		switch (*exp->exp_str) {
+		switch (*expr->exp_str) {
 		case '<':
 			eptr->ex_op = OP_SL;
-			exp->exp_str++;
+			expr->exp_str++;
 			break;
 		case '=':
 			eptr->ex_op = OP_LE;
-			exp->exp_str++;
+			expr->exp_str++;
 			break;
 		default:
 			eptr->ex_op = OP_LT;
@@ -1643,14 +1643,14 @@ retry:
 		}
 		break;
 	case '>':
-		switch (*exp->exp_str) {
+		switch (*expr->exp_str) {
 		case '>':
 			eptr->ex_op = OP_SR;
-			exp->exp_str++;
+			expr->exp_str++;
 			break;
 		case '=':
 			eptr->ex_op = OP_GE;
-			exp->exp_str++;
+			expr->exp_str++;
 			break;
 		default:
 			eptr->ex_op = OP_GT;
@@ -1658,39 +1658,39 @@ retry:
 		}
 		break;
 	case '=':
-		if (*exp->exp_str++ != '=') {
+		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 (*exp->exp_str != '=')
+		if (*expr->exp_str != '=')
 			eptr->ex_op = OP_STORE;
 		else {
-			exp->exp_str++;
+			expr->exp_str++;
 			eptr->ex_op = OP_EQ;
 		}
 		break;
 */
 
 	case '&':
-		if (*exp->exp_str == '&') {
-			exp->exp_str++;
+		if (*expr->exp_str == '&') {
+			expr->exp_str++;
 			eptr->ex_op = OP_LAND;
 		} else
 			eptr->ex_op = OP_AND;
 		break;
 
 	case '|':
-		if ((*exp->exp_str == '|')) {
-			exp->exp_str++;
+		if ((*expr->exp_str == '|')) {
+			expr->exp_str++;
 			eptr->ex_op = OP_LOR;
 		} else
 			eptr->ex_op = OP_OR;
 		break;
 	case '$':
-		switch (*exp->exp_str++) {
+		switch (*expr->exp_str++) {
 		case 'I':
 		case 'i':
 			eptr->ex_type = ET_II;
@@ -1705,32 +1705,32 @@ retry:
 			break;
 		case 'V':
 		case 'v':
-			if (IS_EXPR_TILDE(exp)) {
+			if (IS_EXPR_TILDE(expr)) {
 				eptr->ex_type = ET_VI;
 				break;
 			}
 			post("$v? works only for expr~");
-			post("expr: syntax error: %s\n", &exp->exp_str[-2]);
+			post("expr: syntax error: %s\n", &expr->exp_str[-2]);
 			return (1);
 		case 'X':
 		case 'x':
-			if (IS_FEXPR_TILDE(exp)) {
+			if (IS_FEXPR_TILDE(expr)) {
 				eptr->ex_type = ET_XI;
-				if (isdigit(*exp->exp_str))
+				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", &exp->exp_str[-2]);
+			post("expr: syntax error: %s\n", &expr->exp_str[-2]);
 			return (1);
 		case 'y':
 		case 'Y':
-			if (IS_FEXPR_TILDE(exp)) {
+			if (IS_FEXPR_TILDE(expr)) {
 				eptr->ex_type = ET_YO;
 				/*$y takes no number */
-				if (isdigit(*exp->exp_str))
+				if (isdigit(*expr->exp_str))
 					break;
 				/* for $y[] is a shorhand for $y1[] */
 				eptr->ex_int = 0;
@@ -1738,16 +1738,16 @@ retry:
 			}
 			post("$y works only for fexpr~");
 		default:
-			post("expr: syntax error: %s\n", &exp->exp_str[-2]);
+			post("expr: syntax error: %s\n", &expr->exp_str[-2]);
 			return (1);
 		}
-		p = atoif(exp->exp_str, &eptr->ex_op, &i);
+		p = atoif(expr->exp_str, &eptr->ex_op, &i);
 		if (!p) {
-			post("expr: syntax error: %s\n", &exp->exp_str[-2]);
+			post("expr: syntax error: %s\n", &expr->exp_str[-2]);
 			return (1);
 		}
 		if (i != ET_INT) {
-			post("expr: syntax error: %s\n", exp->exp_str);
+			post("expr: syntax error: %s\n", expr->exp_str);
 			return (1);
 		}
 		/*
@@ -1756,7 +1756,7 @@ retry:
 		 */
 		if (!eptr->ex_op || (eptr->ex_op)-- > MAX_VARS) {
 		 post("expr: syntax error: inlet or outlet out of range: %s\n",
-							     exp->exp_str);
+							     expr->exp_str);
 			return (1);
 		}
 
@@ -1768,7 +1768,7 @@ retry:
 		 * illegal for fexr~
 		 */
 		if (eptr->ex_op == 0 &&
-		   (IS_FEXPR_TILDE(exp) ||  IS_EXPR_TILDE(exp)) &&
+		   (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");
@@ -1779,25 +1779,25 @@ retry:
 			/* it is an outlet  for fexpr~*/
 			/* no need to do anything */
 			;
-		} else if (!exp->exp_var[eptr->ex_op].ex_type)
-			exp->exp_var[eptr->ex_op].ex_type = eptr->ex_type;
-		else if (exp->exp_var[eptr->ex_op].ex_type != eptr->ex_type) {
-			post("expr: syntax error: inlets can only have one type: %s\n", exp->exp_str);
+		} 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);
 		}
-		exp->exp_str = p;
+		expr->exp_str = p;
 noinletnum:
 		break;
 	case '"':
 		{
 			struct ex_ex ex;
 
-			p = exp->exp_str;
-			if (!*exp->exp_str || *exp->exp_str == '"') {
-				post("expr: syntax error: empty symbol: %s\n", --exp->exp_str);
+			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(exp, &ex))
+			if (getoken(expr, &ex))
 				return (1);
 			switch (ex.ex_type) {
 			case ET_STR:
@@ -1815,7 +1815,7 @@ noinletnum:
 				post("expr: syntax error: bad symbol name: %s\n", p);
 				return (1);
 			}
-			if (*exp->exp_str++ != '"') {
+			if (*expr->exp_str++ != '"') {
 				post("expr: syntax error: missing '\"'\n");
 				return (1);
 			}
@@ -1832,10 +1832,10 @@ noinletnum:
 	case '7':
 	case '8':
 	case '9':
-		p = atoif(--exp->exp_str, &eptr->ex_int, &eptr->ex_type);
+		p = atoif(--expr->exp_str, &eptr->ex_int, &eptr->ex_type);
 		if (!p)
 			return (1);
-		exp->exp_str = p;
+		expr->exp_str = p;
 		break;
 
 	default:
@@ -1843,17 +1843,17 @@ noinletnum:
 		 * has to be a string, it should either be a 
 		 * function or a table 
 		 */
-		p = --exp->exp_str;
+		p = --expr->exp_str;
 		for (i = 0; name_ok(*p); i++)
 			p++;
 		if (!i) {
-			post("expr: syntax error: %s\n", exp->exp_str);
+			post("expr: syntax error: %s\n", expr->exp_str);
 			return (1);
 		}
 		eptr->ex_ptr = (char *)fts_malloc(i + 1);
-		strncpy(eptr->ex_ptr, exp->exp_str, (int) i);
+		strncpy(eptr->ex_ptr, expr->exp_str, (int) i);
 		(eptr->ex_ptr)[i] = 0;
-		exp->exp_str = p;
+		expr->exp_str = p;
 		/*
 		 * we mark this as a string and later we will change this
 		 * to either a function or a table
diff --git a/pd/extra/expr~/vexp_if.c b/pd/extra/expr~/vexp_if.c
index c75013ba..b183b620 100644
--- a/pd/extra/expr~/vexp_if.c
+++ b/pd/extra/expr~/vexp_if.c
@@ -39,12 +39,11 @@
 #include <string.h>
 #include <stdlib.h>
 
-
 #include "vexp.h"
 
 static char *exp_version = "0.4";
 
-extern struct ex_ex *ex_eval(struct expr *exp, struct ex_ex *eptr,
+extern struct ex_ex *ex_eval(struct expr *expr, struct ex_ex *eptr,
 						struct ex_ex *optr, int n);
 
 #ifdef PD
@@ -81,13 +80,15 @@ expr_list(t_expr *x, t_symbol *s, int argc, const fts_atom_t *argv)
 				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 pd_error(x, "expr: type mismatch");
+			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 pd_error(x, "expr: type mismatch");
+			else if (x->exp_var[i].ex_type)
+			    pd_error(x, "expr: type mismatch");
 		}
 	}
 	expr_bang(x);
@@ -888,7 +889,8 @@ ex_symname(fts_symbol_t s)
  *  the result pointer 
  */
 int
-max_ex_tab(struct expr *exp,fts_symbol_t s,struct ex_ex *arg,struct ex_ex *optr)
+max_ex_tab(struct expr *expr, fts_symbol_t s, struct ex_ex *arg,
+    struct ex_ex *optr)
 {
 #ifdef PD
 	t_garray *garray;
@@ -900,7 +902,7 @@ max_ex_tab(struct expr *exp,fts_symbol_t s,struct ex_ex *arg,struct ex_ex *optr)
 	{
 		optr->ex_type = ET_FLT;
 		optr->ex_flt = 0;
-		pd_error(exp, "no such table '%s'", s->s_name);
+		pd_error(expr, "no such table '%s'", s->s_name);
 		return (1);
 	}
 	optr->ex_type = ET_FLT;
@@ -915,7 +917,7 @@ max_ex_tab(struct expr *exp,fts_symbol_t s,struct ex_ex *arg,struct ex_ex *optr)
 		break;
 
 	default:	/* do something with strings */
-		pd_error(exp, "expr: bad argument for table '%s'\n", fts_symbol_name(s));
+		pd_error(expr, "expr: bad argument for table '%s'\n", fts_symbol_name(s));
 		indx = 0;
 	}
 	if (indx < 0) indx = 0;
@@ -933,13 +935,13 @@ max_ex_tab(struct expr *exp,fts_symbol_t s,struct ex_ex *arg,struct ex_ex *optr)
 }
 
 int
-max_ex_var(struct expr *exp, fts_symbol_t var, struct ex_ex *optr)
+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(exp, "no such var '%s'", var->s_name);
+		pd_error(expr, "no such var '%s'", var->s_name);
 		return (1);
 	}
 	return (0);
diff --git a/pd/extra/fiddle~/fiddle~.c b/pd/extra/fiddle~/fiddle~.c
index 3c0b2719..594c2ff4 100644
--- a/pd/extra/fiddle~/fiddle~.c
+++ b/pd/extra/fiddle~/fiddle~.c
@@ -1125,7 +1125,8 @@ int sigfiddle_doinit(t_sigfiddle *x, long npoints, long npitch,
     if (npitch <= 0) npitch = 0;
     else if (npitch > MAXNPITCH) npitch = MAXNPITCH;
     if (npeakanal && !npitch) npitch = 1;
-
+    if (!npoints)
+    	npoints = DEFAULTPOINTS;
     if (!sigfiddle_setnpoints(x, npoints))
     {
 	error("fiddle~: out of memory");
diff --git a/pd/extra/fiddle~/makefile b/pd/extra/fiddle~/makefile
index 313bc504..bda5303e 100644
--- a/pd/extra/fiddle~/makefile
+++ b/pd/extra/fiddle~/makefile
@@ -60,9 +60,9 @@ pd_linux: $(NAME).pd_linux
 
 .SUFFIXES: .pd_linux
 
-LINUXCFLAGS = -DPD -O2 -funroll-loops -fomit-frame-pointer \
-    -Wall -W -Wshadow -Wstrict-prototypes -Werror \
-    -Wno-unused -Wno-parentheses -Wno-switch
+LINUXCFLAGS = -DPD -O2 -funroll-loops -fomit-frame-pointer  -fPIC \
+    -Wall -W -Wshadow -Wstrict-prototypes  \
+    -Wno-unused -Wno-parentheses -Wno-switch $(CFLAGS)
 
 LINUXINCLUDE =  -I../../src
 
diff --git a/pd/extra/loop~/makefile b/pd/extra/loop~/makefile
index eb58997d..9585cebe 100644
--- a/pd/extra/loop~/makefile
+++ b/pd/extra/loop~/makefile
@@ -61,9 +61,9 @@ pd_linux: $(NAME).pd_linux
 
 .SUFFIXES: .pd_linux
 
-LINUXCFLAGS = -DPD -O2 -funroll-loops -fomit-frame-pointer \
-    -Wall -W -Wshadow -Wstrict-prototypes -Werror \
-    -Wno-unused -Wno-parentheses -Wno-switch
+LINUXCFLAGS = -DPD -O2 -funroll-loops -fomit-frame-pointer  -fPIC \
+    -Wall -W -Wshadow -Wstrict-prototypes \
+    -Wno-unused -Wno-parentheses -Wno-switch $(CFLAGS)
 
 LINUXINCLUDE =  -I../../src
 
diff --git a/pd/extra/lrshift~/makefile b/pd/extra/lrshift~/makefile
index 4fee4687..d278e82a 100644
--- a/pd/extra/lrshift~/makefile
+++ b/pd/extra/lrshift~/makefile
@@ -61,9 +61,9 @@ pd_linux: $(NAME).pd_linux
 
 .SUFFIXES: .pd_linux
 
-LINUXCFLAGS = -DPD -O2 -funroll-loops -fomit-frame-pointer \
-    -Wall -W -Wshadow -Wstrict-prototypes -Werror \
-    -Wno-unused -Wno-parentheses -Wno-switch
+LINUXCFLAGS = -DPD -O2 -funroll-loops -fomit-frame-pointer  -fPIC \
+    -Wall -W -Wshadow -Wstrict-prototypes \
+    -Wno-unused -Wno-parentheses -Wno-switch $(CFLAGS)
 
 LINUXINCLUDE =  -I../../src
 
diff --git a/pd/extra/pique/makefile b/pd/extra/pique/makefile
index 1c1f9326..dd9a3350 100644
--- a/pd/extra/pique/makefile
+++ b/pd/extra/pique/makefile
@@ -60,9 +60,9 @@ pd_linux: $(NAME).pd_linux
 
 .SUFFIXES: .pd_linux
 
-LINUXCFLAGS = -DPD -O2 -funroll-loops -fomit-frame-pointer \
-    -Wall -W -Wshadow -Wstrict-prototypes -Werror \
-    -Wno-unused -Wno-parentheses -Wno-switch
+LINUXCFLAGS = -DPD -O2 -funroll-loops -fomit-frame-pointer -fPIC \
+    -Wall -W -Wshadow -Wstrict-prototypes \
+    -Wno-unused -Wno-parentheses -Wno-switch $(CFLAGS)
 
 LINUXINCLUDE =  -I../../src