added missing tildes

svn path=/trunk/; revision=81

9 files changed, 4780 insertions, 0 deletions

diff --git a/pd/extra/expr~/LICENSE.txt b/pd/extra/expr~/LICENSE.txt
new file mode 100644
index 00000000..a52b16e4
--- /dev/null
+++ b/pd/extra/expr~/LICENSE.txt
@@ -0,0 +1,341 @@
+
+		    GNU GENERAL PUBLIC LICENSE
+		       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.
+                       59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Library General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+		    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+			    NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
+	    How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) 19yy  <name of author>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    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
+
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) 19yy name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Library General
+Public License instead of this License.
diff --git a/pd/extra/expr~/README b/pd/extra/expr~/README
new file mode 100644
index 00000000..28fccf84
--- /dev/null
+++ b/pd/extra/expr~/README
@@ -0,0 +1,67 @@
+
+You can get more inofrmation on the expr object at
+http://www.crca.ucsd.edu/~yadegari/expr.html
+
+-----------
+
+New in Version 0.3
+-Full function functionality
+
+------------
+
+The object "expr" is used for expression evaluaion of control data.
+
+Expr~ and fexpr~ are extentions to the expr object to work with vectors.
+The expr~ object is designed to efficiently combine signal and control
+stream processing by vector operations on the basis of the block size of
+the environment.
+
+fexpr~ object provides a flexible mechanism for building FIR and
+IIR filters by evaluating expressions on a sample by sample basis
+and providing access to prior samples of the input and output audio
+streams. When fractional offset is used, fexpr~ uses linear interpolation
+to determine the value of the indexed sample. fexpr~ evaluates the
+expression for every single sample and at every evaluation previous
+samples (limited by the audio vector size) can be accessed. $x is used to
+denote a singnal input whose samples we would like to access. The syntax
+is $x followed by the inlet number and indexed by brackets, for example
+$x1[-1] specifies the previous sample of the first inlet. Therefore,
+if we are to build a simple filter which replaces every sample by
+the average of that sample and its previous one, we would use "fexpr~
+($x1[0]+$x1[-1])/2 ". For ease of when the brackets are omitted, the
+current sample is implied, so we can right the previous filter expression
+as follows:  " fexpr~ ($x1+$x1[-1])/2". To build IIR filters $y is used
+to access the previous samples of the output stream.
+
+The three objects expr, expr~, and fexpr~ are implemented in the same object
+so the files expr~.pd_linux and fexpr~.pd_linux are links to expr.pd_linux
+This release has been compiled and tested on Linux 6.0.
+
+--------
+
+Here are some syntax information: (refer to help-expr.pd for examples)
+ 
+Syntyax:
+The syntax is very close to how expression are written in
+C. Variables are specified as follows where the '#' stands
+for the inlet number:
+$i#: integer input variable
+$f#: float input variable
+$s#: symbol input variable
+
+Used for expr~ only:
+$v#: signal (vector) input (vector by vector evaluation)
+
+Used for fexpr~ only:
+$x#[n]: the sample from inlet # indexed by n, where n has to
+	satisfy 0 => n >= -vector size,
+	($x# is a shorthand for $x#[0], specifying the current sample)
+
+$y[n]: the output value indexed by n, where n has to
+	satisfy 0 > n >= -vector size,
+
+
+I'll appreciate hearing about bugs, comments, suggestions, ...
+
+Shahrokh Yadegari (sdy@ucsd.edu)
+1/29/02
diff --git a/pd/extra/expr~/fts_to_pd.h b/pd/extra/expr~/fts_to_pd.h
new file mode 100644
index 00000000..57b0382c
--- /dev/null
+++ b/pd/extra/expr~/fts_to_pd.h
@@ -0,0 +1,41 @@
+/* fts_to_pd.h -- alias some fts names to compile in Pd.
+
+copyright 1999 Miller Puckette;
+permission is granted to use this file for any purpose.
+*/
+
+
+#define fts_malloc malloc
+#define fts_calloc calloc
+#define fts_free free
+#define fts_realloc realloc
+#define fts_atom_t t_atom
+#define fts_object_t t_object
+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;
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+#include <errno.h>
+
+void pd_error(void *object, char *fmt, ...);
+
+#endif /* MSP */
+
+#define post_error pd_error
+#define fts_is_floatg(x) ((x)->a_type == A_FLOAT)
+
+#define fts_new_symbol_copy gensym
+
+#define fts_symbol_name(x) ((x)->s_name)
diff --git a/pd/extra/expr~/help-expr.pd b/pd/extra/expr~/help-expr.pd
new file mode 100644
index 00000000..98ca696f
--- /dev/null
+++ b/pd/extra/expr~/help-expr.pd
@@ -0,0 +1,231 @@
+#N canvas 0 0 1024 745 10;
+#X obj 75 416 expr 1;
+#X floatatom 239 384 0 0 0;
+#X floatatom 75 446 0 0 0;
+#X msg 75 388 bang;
+#X obj 143 414 expr 2 + 3;
+#X msg 143 387 bang;
+#X floatatom 143 442 0 0 0;
+#X floatatom 238 442 0 0 0;
+#X obj 238 414 expr 2+$f1;
+#X floatatom 76 485 0 0 0;
+#X floatatom 76 542 0 0 0;
+#X obj 76 514 expr $f1 * $f2;
+#X floatatom 155 485 0 0 0;
+#N canvas 0 0 450 300 graph1 0;
+#X coords 0 10 10 0 200 150 1;
+#X array array1 10 float 0;
+#X restore 472 362 graph;
+#X floatatom 77 580 0 0 0;
+#X floatatom 77 636 0 0 0;
+#X floatatom 236 484 0 0 0;
+#X floatatom 236 541 0 0 0;
+#X obj 236 513 expr $s2[$f1];
+#X msg 309 485 symbol array1;
+#X obj 77 608 expr sin(2 * 3.14159 * $f1 / 360);
+#X msg 429 554 \; array1 1 4 2 8 5 6 1 4 2 8 5 6;
+#X text 81 345 expr examples:;
+#X text 66 10 expression evaluation family - expr \, expr~ \, fexpr~
+;
+#X text 66 188 Syntyax:;
+#X text 67 260 $f#: float input variable;
+#X text 68 275 $s#: symbol input variable;
+#X text -37 708 expr~ examples:;
+#X obj 30 911 print~;
+#X msg 67 890 bang;
+#X obj 30 832 sig~ 440;
+#X floatatom 103 849 0 0 0;
+#X floatatom 30 809 0 0 0;
+#X obj 30 872 expr~ $v1*$f2;
+#X obj 139 912 print~;
+#X msg 155 891 bang;
+#X floatatom 139 824 0 0 0;
+#X floatatom 212 826 0 0 0;
+#X floatatom 411 847 0 0 0;
+#X floatatom 298 823 0 0 0;
+#X obj 298 850 osc~;
+#X msg 526 670 \; pd dsp 0;
+#X msg 448 672 \; pd dsp 1;
+#X text 451 649 audio on;
+#X text 534 648 audio off;
+#X text 274 314 comment;
+#X text 9 792 vector times scalar;
+#X text 141 792 vector;
+#X obj 297 910 dac~;
+#X text 295 801 frequency;
+#X text 427 829 amplitude;
+#X text 497 116 Used for expr~ only:;
+#X text 499 139 $v#: signal (vector) input (vector by vector evaluation)
+;
+#X text 494 172 Used for fexpr~ only:;
+#X text 495 242 $y[n]: the output value indexed by n where n has to
+satisfy 0 > n >= -vector size.;
+#X text 489 282 (the vector size can be changed by the "block~" object.)
+;
+#X text 493 191 $x#[n]: the sample from inlet # indexed by n where
+n has to satisfy 0 => n >= -vector size \, ($x# is a shorthand for
+$x#[0] \, specifying the current sample);
+#X floatatom 81 1300 0 0 0;
+#X floatatom 214 1319 0 0 0;
+#X msg 181 1279 -10;
+#X text 8 1099 fexpr~ examples:;
+#X obj 80 1567 print~;
+#X msg 88 1547 bang;
+#X floatatom 80 1471 0 0 0;
+#X obj 80 1500 sig~ 1;
+#X obj 81 1343 fexpr~ ($x1[$f2]+$x1)/2;
+#X obj 80 1528 fexpr~ $x1+$y[-1];
+#X floatatom 590 1362 0 0 0;
+#X floatatom 750 1383 0 0 0;
+#X obj 585 1452 dac~;
+#X obj 587 1403 fexpr~ ($x1[$f2/1000]+$x1)/2;
+#X msg 819 1313 0 10000;
+#X obj 750 1364 line 0;
+#X msg 753 1314 -10000;
+#X obj 75 1385 dac~;
+#X text 51 1223 Simple FIR filter;
+#X text 512 1130 Simple FIR filter using fractional offset;
+#X msg 659 1314 -10000 10000;
+#X obj 590 1383 osc~ 2205;
+#X msg 599 1339 1102.5;
+#X msg 817 1338 0 10000;
+#X msg 751 1339 -20000;
+#X msg 657 1339 -20000 10000;
+#X msg 590 1314 2205;
+#X text 88 1611 end;
+#X msg 503 1308 start;
+#X msg 505 1330 stop;
+#X msg 12 1280 start;
+#X msg 11 1305 stop;
+#X msg 30 1465 start;
+#X msg 29 1490 stop;
+#X obj 446 1331 loadbang;
+#X obj -27 1491 loadbang;
+#X obj -44 1305 loadbang;
+#X text 572 1287 frequency;
+#X text 662 1296 of the simple filter;
+#X msg 248 1278 -20;
+#X obj 81 1321 osc~ 2205;
+#X msg 111 1277 1102.5;
+#X msg 65 1277 2205;
+#X msg 215 1278 0;
+#X text 78 1441 simple accumulator defined as and an IIR filter;
+#X obj 139 871 expr~ $v1*$v2;
+#X text 7 1144 NOTE: fexpr~ could use lots of CPU power \, by default
+fexpr~ is on when it is loaded. In this page we are turning them off
+with loadbang \, so to hear them you have to turn them on explicitly.
+You can use the "start" and "stop" messages to start and stop fexpr~
+and expr~;
+#X text 65 101 expr~ is used for expression evaluaion of signal data
+on the vector by vector basis;
+#X text 66 85 expr is used for expression evaluaion of control data
+;
+#X text 661 1284 index defining the frequency;
+#X text 50 1236 -10 offset will fully filter audio frequency of 2205
+\, and -20 offset will filter audio at frequency of 1102.5;
+#X text 514 1211 Thus \, the offset -10000 will filter audio at frequency
+of 2205 and the offset value -20000 will filter the audio at frequency
+of 1102.5.;
+#X text 513 1157 When fractional offset is used \, fexpr~ determines
+indexed by linear interpolation. In the following example the offset
+value is divided by 1000 \, thus we can continuously change the offset
+without an audible click in the output.;
+#X text 243 1314 If you change this value you;
+#X text 245 1326 hear a click;
+#X text 77 670 make sure you turn on audio for the expr~ and fexpr~
+examples;
+#X text 64 38 For a more detailed documentaion refer to http://www.crca.ucsd.edu/~yadegari/expr.html
+;
+#X text 67 203 The syntax is very close to how expressions are written
+in C. Variables are specified as follows where the '#' stands for the
+inlet number:;
+#X text 68 246 $i#: integer input variable;
+#X text 67 138 fexpr~ is used for expression evaluaion on sample level
+data \; i.e. \, filter design. Warning: fexpr~ is very cpu intensive.
+;
+#X floatatom 792 826 5 0 0;
+#X obj 545 875 tabsend~ a1;
+#N canvas 0 0 450 300 graph4 0;
+#X coords 0 1 63 -1 200 140 1;
+#X array a1 64 float 0;
+#X restore 546 897 graph;
+#X obj 545 852 expr~ max(min($v1 \, $f2/10) \, -$f2/10);
+#X obj 545 828 osc~ 4000;
+#X text 13 730 NOTES: the first inlet of expr~ cannot be a $f1 or $i1
+\, this may change in later releases;
+#X text 535 775 A simple limiter example;
+#X text 718 800 Move the value below between 0 and 10 to change the
+limiter threshold;
+#X obj 410 714 vsl 15 128 0 127 0 0 empty empty empty 20 8 0 8 -262144
+-1 -1 0 1;
+#X obj 297 871 expr~ $v1*$f2/128;
+#X text 641 12 updated for Pd 0.35-35 test 8 and expr* 0.3;
+#X connect 0 0 2 0;
+#X connect 1 0 8 0;
+#X connect 3 0 0 0;
+#X connect 4 0 6 0;
+#X connect 5 0 4 0;
+#X connect 8 0 7 0;
+#X connect 9 0 11 0;
+#X connect 11 0 10 0;
+#X connect 12 0 11 1;
+#X connect 14 0 20 0;
+#X connect 16 0 18 0;
+#X connect 18 0 17 0;
+#X connect 19 0 18 1;
+#X connect 20 0 15 0;
+#X connect 29 0 28 0;
+#X connect 30 0 33 0;
+#X connect 31 0 33 1;
+#X connect 32 0 30 0;
+#X connect 33 0 28 0;
+#X connect 35 0 34 0;
+#X connect 36 0 102 0;
+#X connect 37 0 102 1;
+#X connect 38 0 126 1;
+#X connect 39 0 40 0;
+#X connect 40 0 126 0;
+#X connect 57 0 97 0;
+#X connect 58 0 65 1;
+#X connect 59 0 58 0;
+#X connect 62 0 61 0;
+#X connect 63 0 64 0;
+#X connect 64 0 66 0;
+#X connect 65 0 74 0;
+#X connect 65 0 74 1;
+#X connect 66 0 61 0;
+#X connect 67 0 78 0;
+#X connect 68 0 70 1;
+#X connect 70 0 69 0;
+#X connect 70 0 69 1;
+#X connect 71 0 72 0;
+#X connect 72 0 68 0;
+#X connect 73 0 72 0;
+#X connect 77 0 72 0;
+#X connect 78 0 70 0;
+#X connect 79 0 67 0;
+#X connect 80 0 72 0;
+#X connect 81 0 72 0;
+#X connect 82 0 72 0;
+#X connect 83 0 67 0;
+#X connect 85 0 70 0;
+#X connect 86 0 70 0;
+#X connect 87 0 65 0;
+#X connect 88 0 65 0;
+#X connect 89 0 66 0;
+#X connect 90 0 66 0;
+#X connect 91 0 86 0;
+#X connect 92 0 90 0;
+#X connect 93 0 88 0;
+#X connect 96 0 58 0;
+#X connect 97 0 65 0;
+#X connect 98 0 57 0;
+#X connect 99 0 57 0;
+#X connect 100 0 58 0;
+#X connect 102 0 34 0;
+#X connect 117 0 120 1;
+#X connect 120 0 118 0;
+#X connect 121 0 120 0;
+#X connect 125 0 38 0;
+#X connect 126 0 48 0;
+#X connect 126 0 48 1;
diff --git a/pd/extra/expr~/makefile b/pd/extra/expr~/makefile
new file mode 100644
index 00000000..d0175a8a
--- /dev/null
+++ b/pd/extra/expr~/makefile
@@ -0,0 +1,160 @@
+
+current: expr.pd_linux expr~.pd_linux fexpr~.pd_linux
+
+install: install_linux
+
+clean: clean_linux
+
+clobber: clobber_linux
+
+PDEXTERN=/usr/local/lib/pd/externs
+
+# ----------------------- NT -----------------------
+
+pd_nt: expr.dll
+
+NTOBJ =  vexp.obj vexp_fun.obj vexp_if.obj
+
+PDNTCFLAGS = /W3 /WX /DNT /DPD /nologo
+VC="C:\Program Files\Microsoft Visual Studio\Vc98"
+
+PDNTINCLUDE = /I. /I\tcl\include /I\ftp\pd\src /I$(VC)\include
+
+PDNTLDIR = $(VC)\lib
+PDNTLIB = $(PDNTLDIR)\libc.lib \
+	$(PDNTLDIR)\oldnames.lib \
+	$(PDNTLDIR)\kernel32.lib \
+	\ftp\pd\bin\pd.lib 
+
+.c.obj:
+	cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c $*.c
+
+expr.dll: $(NTOBJ)
+	link /dll /export:expr_setup /export:expr_tilde_setup \
+	    /export:fexpr_tilde_setup  $(NTOBJ) $(PDNTLIB)
+	ren vexp.dll expr.dll
+	copy expr.dll ..\expr.dll
+	copy expr.dll ..\expr~.dll
+	copy expr.dll ..\fexpr~.dll
+	copy help-expr.pd ..\help-expr.pd
+
+# ----------------------- IRIX 5.x -----------------------
+
+pd_irix5: 
+
+.SUFFIXES: .pd_irix5
+
+SGICFLAGS5 = -o32 -DPD -DSGI -O2
+
+
+SGIINCLUDE =  -I/usr/people/msp/pd/pd/src
+
+.c.pd_irix5:
+	cc $(SGICFLAGS5) $(SGIINCLUDE) -o $*.o -c $*.c
+	ld -elf -shared -rdata_shared -o $*.pd_irix5 $*.o
+	rm $*.o
+
+# ----------------------- IRIX 6.x -----------------------
+
+pd_irix6: 
+
+.SUFFIXES: .pd_irix6
+
+SGICFLAGS6 = -DPD -DSGI -n32 \
+	-OPT:roundoff=3 -OPT:IEEE_arithmetic=3 -OPT:cray_ivdep=true \
+	-Ofast=ip32
+
+SGICFLAGS5 = -DPD -O2 -DSGI
+
+SGIINCLUDE =  -I/usr/people/msp/pd/pd/src
+
+.c.pd_irix6:
+	cc $(SGICFLAGS6) $(SGIINCLUDE) -o $*.o -c $*.c
+	ld -elf -shared -rdata_shared -o $*.pd_irix6 $*.o
+	rm $*.o
+
+# ----------------------- LINUX i386 -----------------------
+
+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 -Werror \
+    -Wno-unused -Wno-parentheses -Wno-switch
+
+LINUXINCLUDE =  -I../../src
+
+.c.pd_linux_o:
+	cc -g $(LINUXCFLAGS) $(LINUXINCLUDE) -o $*.pd_linux_o -c $*.c
+
+expr.pd_linux: $(LINUXOBJ)
+	ld -export_dynamic  -shared -o expr.pd_linux $(LINUXOBJ) -lc -lm
+	strip --strip-unneeded expr.pd_linux
+	rm -f ../expr.pd_linux
+	ln -s expr~/expr.pd_linux ..
+
+expr~.pd_linux: expr.pd_linux
+	ln -s expr.pd_linux expr~.pd_linux
+	ln -s expr~/expr~.pd_linux ..
+	
+fexpr~.pd_linux: expr.pd_linux
+	ln -s expr.pd_linux fexpr~.pd_linux
+	ln -s expr~/fexpr~.pd_linux ..
+
+install_linux:
+	install expr.pd_linux $(PDEXTERN)
+	rm -f $(PDEXTERN)/expr~.pd_linux
+	rm -f $(PDEXTERN)/fexpr~.pd_linux
+	cd $(PDEXTERN); \
+	ln -s expr.pd_linux expr~.pd_linux; \
+	ln -s expr.pd_linux fexpr~.pd_linux
+
+linux_clean:
+	rm -f *.pd_linux_o *.o
+
+linux_clobber: clean
+	rm -f expr.pd_linux expr.pd_irix6
+
+# ----------------------- MAC OSX -----------------------
+
+pd_darwin: expr.pd_darwin expr~.pd_darwin fexpr~.pd_darwin
+MACOSXOBJ =  vexp.pd_darwin_o vexp_fun.pd_darwin_o vexp_if.pd_darwin_o
+.SUFFIXES: .pd_darwin_o
+
+MACOSXCFLAGS = -DMACOSX -DPD -O2 -Wall -W -Wshadow -Wstrict-prototypes \
+    -Wno-unused -Wno-parentheses -Wno-switch
+
+MACOSXINCLUDE =  -I../../src
+
+.c.pd_darwin_o:
+	cc -g $(MACOSXCFLAGS) $(MACOSXINCLUDE) -o $*.pd_darwin_o -c $*.c
+
+expr.pd_darwin: $(MACOSXOBJ)
+	cc -bundle -undefined suppress  -flat_namespace \
+		-o expr.pd_darwin $(MACOSXOBJ)  -lm
+	rm -f ../expr.pd_darwin
+	ln -s expr~/expr.pd_darwin ..
+
+expr~.pd_darwin: expr.pd_darwin
+	ln -s expr.pd_darwin expr~.pd_darwin
+	rm -f ../expr~.pd_darwin
+	ln -s expr~/expr~.pd_darwin ..
+
+fexpr~.pd_darwin: expr.pd_darwin
+	ln -s expr.pd_darwin fexpr~.pd_darwin
+	rm -f ../fexpr~.pd_darwin
+	ln -s expr~/fexpr~.pd_darwin ..
+
+install_darwin:
+	install expr.pd_darwin $(PDEXTERN)
+	rm -f $(PDEXTERN)/expr~.pd_darwin
+	rm -f $(PDEXTERN)/fexpr~.pd_darwin
+	cd $(PDEXTERN); \
+	ln -s expr.pd_darwin expr~.pd_darwin; \
+	ln -s expr.pd_darwin fexpr~.pd_darwin
+
+darwin_clean:
+	rm -f *.pd_darwin_o *.o
+
+darwin_clobber: clean
+	rm -f expr.pd_darwin expr.pd_irix6
diff --git a/pd/extra/expr~/vexp.c b/pd/extra/expr~/vexp.c
new file mode 100644
index 00000000..dddf6efa
--- /dev/null
+++ b/pd/extra/expr~/vexp.c
@@ -0,0 +1,1948 @@
+/*
+ * jMax
+ * Copyright (C) 1994, 1995, 1998, 1999 by IRCAM-Centre Georges Pompidou, Paris, France.
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ * 
+ * See file LICENSE for further informations on licensing terms.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * 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.
+ * 
+ * Based on Max/ISPW by Miller Puckette.
+ *
+ * Authors: Maurizio De Cecco, Francois Dechelle, Enzo Maggi, Norbert Schnell.
+ *
+ */
+
+/* "expr" was written by Shahrokh Yadegari c. 1989. -msp */
+/* "expr~" and "fexpr~" conversion by Shahrokh Yadegari c. 1999,2000 */
+
+/*
+ * vexp.c -- a variable expression evaluator
+ *
+ * This modules implements an expression evaluator using the
+ * operator-precedence parsing.  It transforms an infix expression
+ * to a prefix stack ready to be evaluated.  The expression sysntax
+ * is close to that of C.  There are a few operators that are not
+ * supported and functions are also recognized.  Strings can be
+ * passed to functions when they are quoted in '"'s. "[]" are implememted
+ * as an easy way of accessing the content of tables, and the syntax
+ * table_name[index].
+ * Variables (inlets) are specified with the following syntax: $x#,
+ * where x is either i(integers), f(floats), and s(strings); and #
+ * is a digit that coresponds to the inlet number.  The string variables
+ * can be used as strings when they are quoted and can also be used as
+ * table names when they are followed by "[]".
+ *
+ * signal vectors have been added to this implementation:
+ * $v# denotes a signal vector
+ * $x#[index]  is the value of a sample at the index of a the signal vector
+ * $x# is the shorthand for $x#[0]
+ * $y[index]   is the value of the sample output at the index of a the
+ *             signal output
+ * "index" for $x#[index] has to have this range (0 <= index < vectorsize)
+ * "index" for $y[index]  has to have this range (0 <  index < vectorsize)
+ */
+
+#include <string.h>
+#include <stdlib.h>
+#include "vexp.h" 
+
+#ifndef MSP
+#ifndef MACOSX
+/*
+ *stdlib.h produces a redefinition of _alloca()
+ * why, I do not know?
+ */
+#include "stdlib.h"
+#endif
+#endif
+char *atoif(char *s, long int *value, long int *type);
+
+static struct ex_ex *ex_lex(struct expr *exp, 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 *optr, long int *argc);
+struct ex_ex *ex_eval(struct expr *exp, 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,
+						struct ex_ex *optr, int i);
+struct ex_ex *eval_tab(struct expr *exp, 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 *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 *exp);
+
+#define	MAX_ARGS	10
+extern t_ex_func ex_funcs[];
+
+struct ex_ex nullex;
+
+void set_tokens (char *s);
+int getoken (struct expr *exp, struct ex_ex *eptr);
+void ex_print (struct ex_ex *eptr);
+#ifdef MSP
+void atom_string(t_atom *a, char *buf, unsigned int bufsize);
+
+void atom_string(t_atom *a, char *buf, unsigned int bufsize)
+{
+    char tbuf[30];
+    switch(a->a_type)
+    {
+    case A_SEMI: strcpy(buf, ";"); break;
+    case A_COMMA: strcpy(buf, ","); break;
+#ifdef PD
+    case A_POINTER:
+        strcpy(buf, "(pointer)");
+        break;
+#endif
+    case A_FLOAT:
+        sprintf(tbuf, "%g", a->a_w.w_float);
+        if (strlen(tbuf) < bufsize-1) strcpy(buf, tbuf);
+        else if (a->a_w.w_float < 0) strcpy(buf, "-");
+        else  strcat(buf, "+");
+        break;
+    case A_LONG:
+        sprintf(tbuf, "%d", a->a_w.w_long);
+        if (strlen(tbuf) < bufsize-1) strcpy(buf, tbuf);
+        else if (a->a_w.w_float < 0) strcpy(buf, "-");
+        else  strcat(buf, "+");
+        break;
+    case A_SYMBOL:
+    {   
+        char *sp;       
+        unsigned int len;
+        int quote;
+        for (sp = a->a_w.w_symbol->s_name, len = 0, quote = 0; *sp; sp++, len++)
+            if (*sp == ';' || *sp == ',' || *sp == '\\' ||
+                (*sp == '$' && sp == a->a_w.w_symbol->s_name && sp[1] >= '0'
+                    && sp[1] <= '9'))
+                quote = 1;
+        if (quote)
+        {
+            char *bp = buf, *ep = buf + (bufsize-2);
+            sp = a->a_w.w_symbol->s_name;
+            while (bp < ep && *sp)
+            {
+                if (*sp == ';' || *sp == ',' || *sp == '\\' ||
+                    (*sp == '$' && bp == buf && sp[1] >= '0' && sp[1] <= '9'))
+                        *bp++ = '\\';
+                *bp++ = *sp++;
+            }
+            if (*sp) *bp++ = '*';
+            *bp = 0;
+            /* post("quote %s -> %s", a->a_w.w_symbol->s_name, buf); */
+        }
+        else
+        {
+            if (len < bufsize-1) strcpy(buf, a->a_w.w_symbol->s_name);
+            else
+            {
+                strncpy(buf, a->a_w.w_symbol->s_name, bufsize - 2);
+                strcpy(buf + (bufsize - 2), "*");
+            }
+        }
+    }
+        break;
+#ifdef PD
+    case A_DOLLAR:
+        sprintf(buf, "$%d", a->a_w.w_index);
+        break;
+    case A_DOLLSYM:
+        sprintf(buf, "$%s", a->a_w.w_symbol->s_name);
+		break;
+#else /* MAX */
+ case A_DOLLAR:
+        sprintf(buf, "$%s", a->a_w.w_symbol->s_name);
+        break;
+#endif
+    default:
+        post("atom_string bug");
+    }
+}
+#endif /* MSP */
+/*
+ * expr_donew -- create a new "expr" object.  
+ *	     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;
+
+	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);
+
+#else /* MSP */
+{
+    char *buf = getbytes(0), *newbuf;
+    int length = 0;
+    char string[250];
+    t_atom *ap;
+    int indx;
+
+    for (ap = av, indx = 0; indx < ac; indx++, ap = ++av) {
+        int newlength;
+        if ((ap->a_type == A_SEMI || ap->a_type == A_COMMA) &&
+                length && buf[length-1] == ' ') length--;
+        atom_string(ap, string, 250);
+        newlength = length + strlen(string) + 1;
+        if (!(newbuf = t_resizebytes(buf, length, newlength))) break;
+        buf = newbuf;
+        strcpy(buf + length, string);
+        length = newlength;
+        if (ap->a_type == A_SEMI) buf[length-1] = '\n';
+        else buf[length-1] = ' ';
+    }
+
+    if (length && buf[length-1] == ' ') {
+        if (newbuf = t_resizebytes(buf, length, length-1))
+        {
+            buf = newbuf;
+            length--;
+        }
+    }
+    exp_string = buf;
+    exp_strlen  = length;
+}
+#endif
+	exp_string = (char *)t_resizebytes(exp_string, exp_strlen,exp_strlen+1);
+	exp_string[exp_strlen] = 0;
+	set_tokens(exp_string);
+	list = ex_lex(expr, &max_node);
+	set_tokens((char *)0);
+	if (!list) {		/* syntax error */
+		return (1);
+	}
+	expr->exp_stack = (struct ex_ex *)fts_malloc(max_node *
+							sizeof (struct ex_ex));
+	ret = ex_match(list, (long)0);
+	if (!ret)		/* syntax error */
+		goto error;
+	ret = ex_parse(expr, list, expr->exp_stack, (long *)0);
+	if (ret) {
+		*ret = nullex;
+		/* print the stack that been built */
+		t_freebytes(exp_string, exp_strlen+1);
+		return (0);
+	}
+error:
+	fts_free(expr->exp_stack);
+	expr->exp_stack = 0;
+	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.
+ */
+struct ex_ex *
+ex_lex(struct expr *exp, 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(exp, 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
+ */
+/* 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:
+		case ET_VO:
+			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_type != ET_OP) {
+				post("expr: syntax error: bad string '%s'\n", eptr->ex_ptr);
+				return (exNULL);
+			}
+			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 {
+				post("expr: syntax error: bad string '%s'\n", eptr->ex_ptr);
+				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).
+ *
+ * 	       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_VI:
+			if (!count && !eptr[1].ex_type) {
+				*optr++ = *eptr;
+				return (optr);
+			}
+			break;
+		case ET_XI:
+		case ET_VO:
+		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(exp, ex_eval(exp, 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 < exp->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 < exp->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)*exp->exp_vsize);	\
+		}							\
+		scalar = left.ex_int;					\
+		rp = right.ex_vec;					\
+		op = optr->ex_vec;					\
+		for (i = 0; i < exp->exp_vsize; i++) {			\
+			*op++ = DZC (scalar, OPR, *rp);			\
+			rp++;						\
+		}							\
+		break;							\
+	case ET_SYM:							\
+	default:							\
+		post_error((fts_object_t *) exp, 		   	\
+		      "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 < exp->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 < exp->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)*exp->exp_vsize);	\
+		}							\
+		scalar = left.ex_flt;					\
+		rp = right.ex_vec;					\
+		op = optr->ex_vec;					\
+		for (i = 0; i < exp->exp_vsize; i++) {			\
+			*op++ = DZC(scalar, OPR, *rp);			\
+			rp++;						\
+		}							\
+		break;							\
+	case ET_SYM:							\
+	default:							\
+		post_error((fts_object_t *) exp, 		   	\
+		      "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)*exp->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++) {			\
+			*op++ = DZC(*lp, OPR, scalar);			\
+			lp++;						\
+		}							\
+		break;                                                  \
+	case ET_FLT:							\
+		scalar = right.ex_flt;					\
+		for (i = 0; i < exp->exp_vsize; i++) {			\
+			*op++ = DZC(*lp, OPR, scalar);			\
+			lp++;						\
+		}							\
+		break;                                                  \
+	case ET_VEC:							\
+	case ET_VI:							\
+		rp = right.ex_vec;					\
+		for (i = 0; i < exp->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 *) exp, 		   	\
+		      "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, 		   	\
+		      "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(exp, 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);\
+			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),\
+							exp->exp_vsize);\
+			break;						\
+		}							\
+		optr->ex_type = ET_FLT;					\
+		optr->ex_flt = OPR (TYPE left.ex_flt);			\
+		break;							\
+	case ET_VI:							\
+	case ET_VEC:							\
+		j = exp->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);	\
+		}							\
+		op = optr->ex_vec;					\
+		lp = left.ex_vec;					\
+		j = exp->exp_vsize;					\
+		for (i = 0; i < j; i++)					\
+			*op++ = OPR (TYPE *lp++);			\
+		break;							\
+	default:							\
+		post_error((fts_object_t *) exp,			\
+			"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;
+}
+
+/*
+ * ex_dzdetect -- divide by zero detected
+ */
+void
+ex_dzdetect(struct expr *exp)
+{
+	char *etype;
+
+	if (!exp->exp_error & EE_DZ) {
+		if (IS_EXPR(exp))
+			etype = "expr";
+		else if (IS_EXPR_TILDE(exp))
+			etype = "expr~";
+		else if (IS_FEXPR_TILDE(exp))
+			etype = "fexpr~";
+		else {
+			post ("expr -- ex_dzdetect internal error");
+			etype = "";
+		}
+		post ("%s divide by zero detected", etype);
+		exp->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.
+ */
+
+/* SDY
+all the returns in this function need to be changed so that the code
+ends up at the end to check for newly allocated right and left vectors which
+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)
+/* the expr object data pointer */
+/* the operation stack */
+/* 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,
+								exp->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->exp_vsize);
+		else
+			*optr = *eptr;
+		return (++eptr);
+
+	case ET_SYM:
+		if (optr->ex_type == ET_VEC) {
+			post_error((fts_object_t *) exp,
+			      "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 *) exp,
+			    "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);
+		} else {
+			optr->ex_type = ET_INT;
+			optr->ex_int = exp->exp_var[eptr->ex_int].ex_int;
+		}
+		return (++eptr);
+	case ET_FI:
+		if (eptr->ex_int == -1) {
+			post_error((fts_object_t *) exp,
+			    "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);
+		} else {
+			optr->ex_type = ET_FLT;
+			optr->ex_flt = exp->exp_var[eptr->ex_int].ex_flt;
+		}
+		return (++eptr);
+
+	case ET_VSYM:
+		if (optr->ex_type == ET_VEC) {
+			post_error((fts_object_t *) exp,
+			    "expr: IntErr. vsym in for vec out\n");
+			return (exNULL);
+		}
+		if (eptr->ex_int == -1) {
+			post_error((fts_object_t *) exp,
+				"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;
+		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));
+		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,
+					exp->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:
+		/* 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);
+			abort();
+		}
+		optr->ex_type = ET_FLT;
+		optr->ex_flt = exp->exp_var[eptr->ex_int].ex_vec[idx];
+		return(++eptr);
+	case ET_VO:
+	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);
+			abort();
+		}
+		return (eval_sigidx(exp, eptr, optr, idx));
+			
+	case ET_TBL:
+	case ET_SI:
+		return (eval_tab(exp, eptr, optr, idx));
+	case ET_FUNC:
+		return (eval_func(exp, eptr, optr, idx));
+	case ET_OP:
+		break;
+	case ET_STR:
+	case ET_LP:
+	case ET_LB:
+	default:
+		post_error((fts_object_t *) exp,
+			"expr: ex_eval: unexpected type %d\n", eptr->ex_type);
+		return (exNULL);
+	}
+	if (!eptr[1].ex_type) {
+		post_error((fts_object_t *) exp,
+					"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,
+					"expr: ex_eval: not enough nodes 2\n");
+		return (exNULL);
+	}
+
+	switch((eptr++)->ex_op) {
+	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(||);
+/*
+ * 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(exp),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)))
+	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 *) exp, "expr: ex_print: bad op 0x%x\n", eptr->ex_op);
+		return (exNULL);
+	}
+
+
+/* SDY 
+all the returns in the function need to be changed to come here
+to make sure that we are freeing any allocated buffer pointed to
+by left and right vectors
+*/
+
+	/*
+	 * 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
+ */
+struct ex_ex *
+eval_func(struct expr *exp, struct ex_ex *eptr, struct ex_ex *optr, int idx)
+/* the expr object data pointer */
+/* 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 *) exp, "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);
+	}
+	(*f->f_func)(exp, 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_tab --
+ */
+struct ex_ex *
+eval_tab(struct expr *exp, struct ex_ex *eptr, struct ex_ex *optr, int idx)
+/* the expr object data pointer */
+/* the operation stack */
+/* the result pointer */
+{
+	struct ex_ex arg;
+	char *tbl = (char *) 0;
+	int notable = 0;
+	
+	if (eptr->ex_type == ET_SI) {
+		if (!exp->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->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;
+				}
+				notable++;
+		} else
+			tbl = (char *) exp->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);
+		notable++;
+
+	}
+	arg.ex_type = 0;
+	arg.ex_int = 0;
+	eptr = ex_eval(exp, ++eptr, &arg, idx);
+
+	optr->ex_type = ET_INT;
+	optr->ex_int = 0;
+	if (!notable)
+		(void)max_ex_tab(exp, (t_symbol *)tbl, &arg, optr);
+	return (eptr);
+}
+
+/*
+ * 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)
+/* the expr object data pointer */
+/* the operation stack */
+/* 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(exp, 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 (!(exp->exp_error & EE_BI_INPUT)) {
+				exp->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, 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;
+				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);
+				post("fexpr~: no error report till next reset");
+			}
+		}
+
+	/*
+	 * indexing an output vector
+	 */
+	} else if (eptr->ex_type == ET_VO) {
+		/* 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;
+				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 = 0;
+		}
+		if (cal_sigidx(optr, i, rem_i, idx, exp->exp_vsize,
+					     exp->exp_tmpres, exp->exp_p_res)) {
+			if (!(exp->exp_error & EE_BI_OUTPUT)) {
+				exp->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);
+			}
+		}
+	} 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)
+ */
+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 */
+{
+	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);
+}
+
+static char *exp_str;
+/*
+ * set_tokens -- set a new string for reading tokens
+ */
+
+void
+set_tokens(char *s)
+{
+	exp_str = s;
+}
+/*
+ * getoken -- return 1 on syntax error otherwise 0
+ */
+int
+getoken(struct expr *exp, struct ex_ex *eptr)
+{
+	char *p;
+	long i;
+
+	if (!exp_str) {
+		post("expr: getoken: expression string not set\n");
+		return (0);
+	}
+retry:
+	if (!*exp_str) {
+		eptr->ex_type = 0;
+		eptr->ex_int = 0;
+		return (0);
+	}
+	eptr->ex_type = ET_OP;
+	switch (*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 (*exp_str == '=') {
+			eptr->ex_op = OP_NE;
+			exp_str++;
+		} else
+			eptr->ex_op = OP_NOT;
+		break;
+	case '<':
+		switch (*exp_str) {
+		case '<':
+			eptr->ex_op = OP_SL;
+			exp_str++;
+			break;
+		case '=':
+			eptr->ex_op = OP_LE;
+			exp_str++;
+			break;
+		default:
+			eptr->ex_op = OP_LT;
+			break;
+		}
+		break;
+	case '>':
+		switch (*exp_str) {
+		case '>':
+			eptr->ex_op = OP_SR;
+			exp_str++;
+			break;
+		case '=':
+			eptr->ex_op = OP_GE;
+			exp_str++;
+			break;
+		default:
+			eptr->ex_op = OP_GT;
+			break;
+		}
+		break;
+	case '=':
+		if (*exp_str++ != '=') {
+			post("expr: syntax error: =\n");
+			return (1);
+		}
+		eptr->ex_op = OP_EQ;
+		break;
+
+	case '&':
+		if (*exp_str == '&') {
+			exp_str++;
+			eptr->ex_op = OP_LAND;
+		} else
+			eptr->ex_op = OP_AND;
+		break;
+
+	case '|':
+		if ((*exp_str == '|')) {
+			exp_str++;
+			eptr->ex_op = OP_LOR;
+		} else
+			eptr->ex_op = OP_OR;
+		break;
+	case '$':
+		switch (*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(exp)) {
+				eptr->ex_type = ET_VI;
+				break;
+			}
+			post("$v? works only for expr~");
+			post("expr: syntax error: %s\n", &exp_str[-2]);
+			return (1);
+		case 'X':
+		case 'x':
+			if (IS_FEXPR_TILDE(exp)) {
+				eptr->ex_type = ET_XI;
+				break;
+			}
+			post("$x? works only for fexpr~");
+			post("expr: syntax error: %s\n", &exp_str[-2]);
+			return (1);
+		case 'y':
+		case 'Y':
+			if (IS_FEXPR_TILDE(exp)) {
+				eptr->ex_type = ET_VO;
+				/*$y takes no number */
+				goto noinletnum;
+			}
+			post("$y works only for fexpr~");
+		default:
+			post("expr: syntax error: %s\n", &exp_str[-2]);
+			return (1);
+		}
+		p = atoif(exp_str, &eptr->ex_op, &i);
+		if (!p) {
+			post("expr: syntax error: %s\n", &exp_str[-2]);
+			return (1);
+		}
+		if (i != ET_INT) {
+			post("expr: syntax error: %s\n", 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 out of range: %s\n",
+								     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(exp) ||  IS_EXPR_TILDE(exp)) &&
+   (eptr->ex_type==ET_II || eptr->ex_type==ET_FI || eptr->ex_type==ET_SI)) {
+	post("first inlet of expr~ for fexpr~ can only be a vector");
+	return (1);
+}
+		/* record the inlet type and check for consistency */
+		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_str);
+			return (1);
+		}
+		exp_str = p;
+noinletnum:
+		break;
+	case '"':
+		{
+			struct ex_ex ex;
+
+			p = exp_str;
+			if (!*exp_str || *exp_str == '"') {
+				post("expr: syntax error: empty symbol: %s\n", --exp_str);
+				return (1);
+			}
+			if (getoken(exp, &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 (*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(--exp_str, &eptr->ex_int, &eptr->ex_type);
+		if (!p)
+			return (1);
+		exp_str = p;
+		break;
+
+	default:
+		/*
+		 * has to be a string, it should either be a 
+		 * function or a table 
+		 */
+		p = --exp_str;
+		for (i = 0; name_ok(*p); i++)
+			p++;
+		if (!i) {
+			post("expr: syntax error: %s\n", exp_str);
+			return (1);
+		}
+		eptr->ex_ptr = (char *)fts_malloc(i + 1);
+		strncpy(eptr->ex_ptr, exp_str, (int) i);
+		(eptr->ex_ptr)[i] = 0;
+		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);
+}
+
+/*
+ * atoif -- ascii to float or integer (understands hex numbers also)
+ */
+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++;
+	}
+}
+
+/*
+ * find_func -- returns a pointer to the found function structure
+ *		otherwise it returns 0
+ */
+t_ex_func *
+find_func(char *s)
+{
+	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);
+}
+
+
+/*
+ * ex_print -- print an expression array
+ */
+
+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:
+			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_VO:
+			post("$y");
+			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_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
+void ABORT( void) {bug("expr");}
+#endif
diff --git a/pd/extra/expr~/vexp.h b/pd/extra/expr~/vexp.h
new file mode 100644
index 00000000..dd93d2b8
--- /dev/null
+++ b/pd/extra/expr~/vexp.h
@@ -0,0 +1,233 @@
+/*
+ * jMax
+ * Copyright (C) 1994, 1995, 1998, 1999 by IRCAM-Centre Georges Pompidou, Paris, France.
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ * 
+ * See file LICENSE for further informations on licensing terms.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * 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.
+ * 
+ * Based on Max/ISPW by Miller Puckette.
+ *
+ * Authors: Maurizio De Cecco, Francois Dechelle, Enzo Maggi, Norbert Schnell.
+ *
+ */
+
+/* "expr" was written by Shahrokh Yadegari c. 1989. -msp */
+/* "expr~" and "fexpr~" conversion by Shahrokh Yadegari c. 1999,2000 */
+
+#define MSP
+#ifdef PD
+#undef MSP
+#endif
+
+#ifdef PD
+#include "m_pd.h"
+#else /* MSP */
+#include "ext.h"
+#include "z_dsp.h"
+#endif
+
+#include "fts_to_pd.h"
+/* 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_outlet void
+#endif
+*/
+
+/*
+ * Currently the maximum number of variables (inlets) that are supported
+ * is 10.
+ */
+
+#define	MAX_VARS	9
+#define	MINODES		10 /* was 200 */
+
+/* terminal defines */
+
+/*
+ * operations
+ * (x<<16|y) x defines the level of precedence,
+ * the lower the number the lower the precedence
+ * 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	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)
+
+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 */
+};
+#define	exNULL	((struct ex_ex *)0)
+
+/* defines for ex_type */
+#define	ET_INT		0x1		/* an int */
+#define	ET_FLT		0x2		/* a float */
+#define ET_OP		0x3		/* operator */
+#define	ET_STR		0x4		/* string */
+#define ET_TBL		0x5		/* a table, the content is a pointer */
+#define	ET_FUNC		0x6		/* a function */
+#define	ET_SYM		0x7		/* symbol ("string") */
+#define	ET_VSYM		0x8		/* variable symbol ("$s?") */
+				/* we treat parenthesis and brackets */
+				/* special to keep a pointer to their */
+				/* match in the content */
+#define	ET_LP		0x9		/* left parenthesis */
+#define	ET_LB		0x10		/* left bracket */
+#define	ET_II		0x11		/* and integer inlet */
+#define	ET_FI		0x12		/* float inlet */
+#define	ET_SI		0x13		/* string inlet */
+#define	ET_VI		0x14		/* signal inlet */
+#define	ET_VEC		0x15		/* allocated signal vector */
+				/* special types for fexpr~ */
+#define	ET_VO		0x16		/* vector output for fexpr~ */
+#define	ET_XI		0x17		/* vector input for fexpr~ */
+#define	ET_XI0		0x18		/* shorthand for $x?[0] */
+
+/* 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_STOP		0x08	/* is it stopped used for expr~ and fexpr~ */
+
+#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) \
+               ((((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_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 */
+
+typedef struct expr {
+#ifdef PD
+	t_object exp_ob;
+#else /* MSP */
+	t_pxobject exp_ob;
+#endif
+	int	exp_flags;		/* are we expr~, fexpr~, or expr */
+	int	exp_error;		/* reported errors */
+	t_outlet *exp_outlet;
+#ifdef PD
+	struct _exprproxy *exp_proxy;
+#else /* MAX */
+	void *exp_proxy[MAX_VARS];
+	long exp_proxy_id;
+#endif
+	struct ex_ex *exp_stack;
+	struct ex_ex exp_var[MAX_VARS];
+	struct ex_ex exp_res;		/* the evluation result */
+	t_float *exp_p_var[MAX_VARS];
+	t_float *exp_p_res;		/* the previous evaluation result */
+	t_float *exp_tmpres;		/* 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 */
+} t_ex_func;
+
+/* function prototypes for pd-related functions called withing vexp.h */
+
+extern int max_ex_tab(struct expr *expr, t_symbol *s, struct ex_ex *arg, struct ex_ex *optr);
+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);
+
+#ifdef NT
+#pragma warning (disable: 4305 4244)
+
+#define abort ABORT
+void ABORT(void);
+#endif
diff --git a/pd/extra/expr~/vexp_fun.c b/pd/extra/expr~/vexp_fun.c
new file mode 100644
index 00000000..2879d96b
--- /dev/null
+++ b/pd/extra/expr~/vexp_fun.c
@@ -0,0 +1,828 @@
+/*
+ * jMax
+ * Copyright (C) 1994, 1995, 1998, 1999 by IRCAM-Centre Georges Pompidou, Paris, France.
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ * 
+ * See file LICENSE for further informations on licensing terms.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * 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.
+ * 
+ * Based on Max/ISPW by Miller Puckette.
+ *
+ * Authors: Maurizio De Cecco, Francois Dechelle, Enzo Maggi, Norbert Schnell.
+ *
+ */
+
+/* "expr" was written by Shahrokh Yadegari c. 1989. -msp */
+/* Nov. 2001 - conversion for expr~ --sdy */
+
+/*
+ * 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.
+ */
+
+#include <stdlib.h>
+
+#define __STRICT_BSD__
+#include <math.h>
+#undef __STRICT_BSD__
+
+
+#include "vexp.h"
+
+/* forward declarations */
+
+static void ex_min(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_max(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_toint(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_rint(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_tofloat(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_pow(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_exp(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_log(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_ln(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_sin(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_cos(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_asin(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_acos(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_tan(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_atan(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_sinh(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_cosh(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_asinh(t_expr *expr, long argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_acosh(t_expr *expr, long argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_tanh(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_atanh(t_expr *expr, long argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_atan2(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_sqrt(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_fact(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_random(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_abs(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+
+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},
+	{"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},
+#ifndef NT
+	{"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},
+#endif
+	{0,		0,		0}
+};
+
+/*
+ * FUN_EVAL --
+ */
+#define	FUNC_EVAL(left, right, func, leftfuncast, rightfuncast, optr) \
+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 {						\
+			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_INT;				\
+			optr->ex_int = (int)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);	\
+}
+
+/*
+ * evaluate a unary operator, TYPE is applied to float operands
+ */
+#define FUNC_EVAL_UNARY(left, func, leftcast, optr)		\
+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;						\
+	}							\
+	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)
+
+/*
+ * ex_min -- if any of the arfuments 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
+ */
+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;
+
+	left = argv++;
+	right = argv;
+
+	/* minimum needs no cast, as it is not a real function */
+	FUNC_EVAL(left, right, min, (double), (double), optr);
+}
+
+/*
+ * ex_max -- if any of the arfuments 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
+ */
+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;
+
+	left = argv++;
+	right = argv;
+
+	/* minimum needs no cast, as it is not a real function */
+	FUNC_EVAL(left, right, max, (double), (double), optr);
+}
+
+/* SDY changed to new form up to here */
+
+/*
+ * ex_toint -- convert to integer
+ */
+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;
+
+	left = argv++;
+
+#define toint(x)	((int)(x))
+	FUNC_EVAL_UNARY(left, toint, (int), optr);
+}
+
+#ifdef NT
+/* No rint in NT land ??? */
+double rint(double x);
+
+double
+rint(double x)
+{
+	return (floor(x + 0.5));
+}
+#endif
+
+/*
+ * ex_rint -- rint() round to the nearest int according to the common
+ *	      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;
+
+	left = argv++;
+
+
+	FUNC_EVAL_UNARY(left, rint, (double), optr);
+
+#ifdef old
+
+	if (argv->ex_type == ET_INT)
+		*optr = *argv;
+	else if (argv->ex_type == ET_FLT) {
+		optr->ex_type = ET_FLT;
+#ifdef NT		/* no rint() in NT??? */
+		optr->ex_flt = floor(argv->ex_flt + 0.5);
+#else
+		optr->ex_flt = rint(argv->ex_flt);
+#endif
+	} else {
+/* SDY what does this mean? this is wrong!!???? */
+		optr->ex_type = ET_INT;
+		optr->ex_int = (int)argv->ex_ptr;
+	}
+#endif
+}
+
+/*
+ * ex_tofloat -- convert to float
+ */
+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;
+
+	left = argv++;
+
+#define tofloat(x)	((float)(x))
+	FUNC_EVAL_UNARY(left, toint, (int), optr);
+}
+
+
+/*
+ * ex_pow -- the power of
+ */
+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);
+}
+
+/*
+ * ex_sqrt -- square root
+ */
+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;
+
+	left = argv++;
+
+	FUNC_EVAL_UNARY(left, sqrt, (double), optr);
+}
+
+/*
+ * ex_exp -- e to the power of
+ */
+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;
+
+	left = argv++;
+
+	FUNC_EVAL_UNARY(left, exp, (double), optr);
+}
+
+/*
+ * ex_log -- 10 based logarithm
+ */
+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;
+
+	left = argv++;
+
+	FUNC_EVAL_UNARY(left, log10, (double), optr);
+}
+
+/*
+ * ex_ln -- natural log
+ */
+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;
+
+	left = argv++;
+
+	FUNC_EVAL_UNARY(left, log, (double), optr);
+}
+
+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;
+
+	left = argv++;
+
+	FUNC_EVAL_UNARY(left, sin, (double), optr);
+}
+
+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;
+
+	left = argv++;
+
+	FUNC_EVAL_UNARY(left, cos, (double), optr);
+}
+
+
+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;
+
+	left = argv++;
+
+	FUNC_EVAL_UNARY(left, tan, (double), optr);
+}
+
+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;
+
+	left = argv++;
+
+	FUNC_EVAL_UNARY(left, asin, (double), optr);
+}
+
+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;
+
+	left = argv++;
+
+	FUNC_EVAL_UNARY(left, acos, (double), optr);
+}
+
+
+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;
+
+	left = argv++;
+
+	FUNC_EVAL_UNARY(left, atan, (double), optr);
+}
+
+/*
+ *ex_atan2 --
+ */
+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);
+}
+
+
+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;
+
+	left = argv++;
+
+	FUNC_EVAL_UNARY(left, sinh, (double), optr);
+}
+
+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;
+
+	left = argv++;
+
+	FUNC_EVAL_UNARY(left, cosh, (double), optr);
+}
+
+
+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;
+
+	left = argv++;
+
+	FUNC_EVAL_UNARY(left, tanh, (double), optr);
+}
+
+
+#ifndef NT
+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;
+
+	left = argv++;
+
+	FUNC_EVAL_UNARY(left, asinh, (double), optr);
+}
+
+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;
+
+	left = argv++;
+
+	FUNC_EVAL_UNARY(left, acosh, (double), optr);
+}
+
+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;
+
+	left = argv++;
+
+	FUNC_EVAL_UNARY(left, atanh, (double), optr);
+}
+#endif
+
+static int
+ex_dofact(int i)
+{
+	int ret = 0;
+
+	if (i)
+		ret = 1;
+	else
+		return (0);
+
+	do {
+		ret *= i;
+	} while (--i);
+
+	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;
+
+	left = argv++;
+
+	FUNC_EVAL_UNARY(left, ex_dofact,  (int), optr);
+}
+
+static int
+ex_dorandom(int i1, int i2)
+{
+	return(i1 + (((i2 - i1) * (rand() & 0x7fffL)) >> 15));
+}
+/*
+ * ex_random -- return a random number
+ */
+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);
+}
+
+
+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;
+
+	left = argv++;
+
+	FUNC_EVAL_UNARY(left, fabs, (double), optr);
+}
+
diff --git a/pd/extra/expr~/vexp_if.c b/pd/extra/expr~/vexp_if.c
new file mode 100644
index 00000000..6d86ff1c
--- /dev/null
+++ b/pd/extra/expr~/vexp_if.c
@@ -0,0 +1,931 @@
+/*
+ * jMax
+ * Copyright (C) 1994, 1995, 1998, 1999 by IRCAM-Centre Georges Pompidou, Paris, France.
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ * 
+ * See file LICENSE for further informations on licensing terms.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * 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.
+ * 
+ * Based on Max/ISPW by Miller Puckette.
+ *
+ * Authors: Maurizio De Cecco, Francois Dechelle, Enzo Maggi, Norbert Schnell.
+ *
+ */
+
+/* "expr" was written by Shahrokh Yadegari c. 1989. -msp */
+/* "expr~" and "fexpr~" conversion by Shahrokh Yadegari c. 1999,2000 */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+
+#include "vexp.h"
+#ifndef MSP
+#ifndef MACOSX
+/*
+ * the compiler on mac seems not to like this, perhaps we could get away with
+ * not having it at all.
+ */
+#include "stdlib.h"
+#endif
+#endif
+#include "string.h"
+
+static char *exp_version = "0.3";
+
+extern struct ex_ex *ex_eval(struct expr *exp, struct ex_ex *eptr,
+						struct ex_ex *optr, int n);
+
+#ifdef PD
+static t_class *expr_class;
+static t_class *expr_tilde_class;
+static t_class *fexpr_tilde_class;
+#else /* MSP */
+void *expr_tilde_class;
+#endif
+
+
+/*------------------------- expr class -------------------------------------*/
+
+extern int expr_donew(struct expr *expr, int ac, t_atom *av);
+
+/*#define EXPR_DEBUG*/
+
+static void expr_bang(t_expr *x);
+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 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");
+		}
+	}
+	expr_bang(x);
+}
+
+static void
+expr_flt(t_expr *x, t_float f, int in)
+{
+	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;
+}
+
+static t_class *exprproxy_class;
+
+typedef struct _exprproxy {
+	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);
+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);
+}
+
+void
+exprproxy_float(t_exprproxy *p, t_floatarg f)
+{
+	t_expr *x = p->p_owner;
+	int in = p->p_index;
+
+	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;
+}
+
+/* method definitions */
+static void
+expr_ff(t_expr *x)
+{
+	t_exprproxy *y;
+	
+	y = x->exp_proxy;
+	while (y)
+	{
+		x->exp_proxy = y->p_next;
+#ifdef PD
+		pd_free(&y->p_pd);
+#else /*MSP */
+	/* SDY find out what needs to be called for MSP */
+
+#endif
+		y = x->exp_proxy;
+	}
+	if (x->exp_stack)
+		fts_free(x->exp_stack);
+/*
+ * SDY free all the allocated buffers here for expr~ and fexpr~
+ */
+}
+
+static void
+expr_bang(t_expr *x)
+{
+
+#ifdef EXPR_DEBUG
+	{
+		int i;
+		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;
+
+	if (!ex_eval(x, x->exp_stack, &x->exp_res, 0))
+	{
+		/*       fprintf(stderr,"expr_bang(error evaluation)\n"); */
+		return;
+	}
+
+
+	switch(x->exp_res.ex_type)
+	{
+	case ET_INT:
+		outlet_float(x->exp_outlet,  (t_float) x->exp_res.ex_int);
+		break;
+
+	case ET_FLT:
+		outlet_float(x->exp_outlet,  x->exp_res.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.ex_type);
+	}
+}
+
+static t_expr *
+#ifdef PD
+expr_new(t_symbol *s, int ac, t_atom *av)
+#else /* MSP */
+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 */
+
+
+/*
+ * SDY - we may need to call dsp_setup() in this function
+ */
+
+	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);
+	}
+#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_stack = (struct ex_ex *)0;
+	x->exp_proxy = 0;
+	x->exp_nivec = 0;
+	x->exp_error = 0;
+	x->exp_outlet = (t_outlet *)0;
+	x->exp_res.ex_type = 0;
+	x->exp_res.ex_int = 0;
+	x->exp_p_res = (t_float *)0;
+	x->exp_tmpres = (t_float *)0;
+	for (i = 0; i < MAX_VARS; i++) {
+		x->exp_var[i].ex_type = 0;
+		x->exp_var[i].ex_int = 0;
+		x->exp_p_var[i] = (t_float *)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);
+*/
+		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; i<ninlet ; i++, eptr++)
+	{
+		t_exprproxy *p;
+		switch (eptr->ex_type)
+		{
+		case 0:
+			/* nothing is using this inlet */
+			if (i < ninlet)
+#ifdef PD
+				floatinlet_new(&x->exp_ob, &eptr->ex_flt);
+#else /* MSP */
+				inlet_new(&x->exp_ob, "float");
+#endif
+			break;
+
+		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);
+#else /* MSP */
+			inlet_new(&x->exp_ob, "float");
+#endif
+			break;
+
+		case ET_SI:
+#ifdef PD
+			symbolinlet_new(&x->exp_ob, (t_symbol **)&eptr->ex_ptr);
+#else /* MSP */
+			inlet_new(&x->exp_ob, "symbol");
+#endif
+			break;
+
+		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);
+#else /* MSP */
+				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)) {
+		x->exp_outlet = outlet_new(&x->exp_ob, 0);
+	} else {
+#ifdef PD
+		x->exp_outlet = outlet_new(&x->exp_ob,  gensym("signal"));
+#else /* MSP */
+		x->exp_outlet = outlet_new(&x->exp_ob,  "signal");
+#endif
+		x->exp_nivec = dsp_index;
+	}
+
+	return (x);
+}
+
+t_int *
+expr_perform(t_int *w)
+{
+	int i;
+	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) {
+		memset(x->exp_res.ex_vec, 0, x->exp_vsize * sizeof (float));
+		return (w + 2);
+	}
+
+	if (IS_EXPR_TILDE(x)) {
+		ex_eval(x, x->exp_stack, &x->exp_res, 0);
+		return (w + 2);
+	}
+
+	if (!IS_FEXPR_TILDE(x)) {
+		post("expr_perform: bad x->exp_flags = %d - expecting fexpr",
+								x->exp_flags);
+		abort();
+	}
+	/*
+	 * 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++) {
+		res.ex_type = 0;
+		res.ex_int = 0;
+		ex_eval(x, x->exp_stack, &res, i);
+		switch (res.ex_type) {
+		case ET_INT:
+			x->exp_tmpres[i] = (t_float) res.ex_int;
+			break;
+		case ET_FLT:
+			x->exp_tmpres[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);
+	memcpy(x->exp_p_res, x->exp_tmpres, n);
+	memcpy(x->exp_res.ex_vec, x->exp_tmpres, 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 */
+	x->exp_res.ex_type = ET_VEC;
+	x->exp_res.ex_vec =  sp[x->exp_nivec]->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);
+
+	if (!IS_FEXPR_TILDE(x))
+		return;
+	if (x->exp_p_res) {
+		if (!newsize)
+			return;
+		/*
+		 * if new size, reallocate all the previous buffers for fexpr~
+		 */
+		fts_free(x->exp_p_res);
+		fts_free(x->exp_tmpres);
+		for (i = 0; i < MAX_VARS; i++)
+			fts_free(x->exp_p_var[i]);
+
+	}
+	x->exp_p_res = fts_calloc(x->exp_vsize, sizeof (t_float));
+	x->exp_tmpres = 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));
+}
+
+/*
+ * expr_start -- turn on expr processing for now only used for fexpr~
+ */
+static void
+expr_start(t_expr *x)
+{
+	x->exp_flags &= ~EF_STOP;
+}
+
+/*
+ * expr_stop -- turn on expr processing for now only used for fexpr~
+ */
+static void
+expr_stop(t_expr *x)
+{
+	x->exp_flags |= EF_STOP;
+}
+
+#ifdef PD
+
+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);
+
+	/*
+	 * 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);
+
+	post("expr, expr~, fexpr~ version %s under GNU General Public License ", exp_version);
+
+}
+
+void
+expr_tilde_setup(void)
+{
+	expr_setup();
+}
+
+void
+fexpr_tilde_setup(void)
+{
+	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);
+        addmess((method)expr_dsp, "dsp", A_CANT, 0); // dsp method
+        dsp_initclass();
+}
+#endif
+
+
+/* -- the following functions use Pd internals and so are in the "if" file. */
+
+
+int ex_getsym(char *p, fts_symbol_t *s)
+{
+	*s = gensym(p);
+	return (0);
+}
+
+const char *
+ex_symname(fts_symbol_t 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
+ *
+ * Arguments:
+ *  the expr object
+ *  table 
+ *  the argument 
+ *  the result pointer 
+ */
+int
+max_ex_tab(struct expr *exp,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_int = 0;
+		pd_error(exp, "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(exp, "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);
+}
+
+#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)			    	      \
+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;								\
+}
+
+/*
+ * ex_size -- find the size of a table
+ */
+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;
+
+	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;
+
+	ISTABLE(s, garray, size, vec);
+
+	optr->ex_type = ET_INT;
+	optr->ex_int = size;
+}
+
+/*
+ * ex_sum -- calculate the sum of all elements of a table
+ */
+
+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;
+
+	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);
+
+	for (indx = 0, sum = 0; indx < size; indx++)
+		sum += vec[indx];
+
+	optr->ex_type = ET_FLT;
+	optr->ex_flt = sum;
+}
+
+
+/*
+ * ex_Sum -- calculate the sum of table with the given boundries
+ */
+
+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;
+}
+
+/*
+ * ex_avg -- calculate the avarage of a table
+ */
+
+void
+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));
+	}
+#endif
+}
+
+
+/*
+ * ex_Avg -- calculate the avarage of table with the given boundries
+ */
+
+void
+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));
+#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
+ */
+
+void
+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];
+#endif
+}
+
+#else /* MSP */
+
+void 
+pd_error(void *object, char *fmt, ...)
+{
+    va_list ap;
+    t_int arg[8];
+    int i;
+    static int saidit = 0;
+    va_start(ap, fmt);
+/* SDY
+    vsprintf(error_string, fmt, ap);
+ */ post(fmt, ap);
+ 	va_end(ap);
+/* SDY
+    fprintf(stderr, "error: %s\n", error_string);
+    error_object = object;
+*/
+    if (!saidit)
+    {
+        post("... you might be able to track this down from the Find menu.");
+        saidit = 1;
+    }
+}
+#endif