From cee98b59f1adf987b6dcbc771299bb9d6d75b843 Mon Sep 17 00:00:00 2001 From: Guenter Geiger Date: Thu, 8 Aug 2002 16:42:32 +0000 Subject: added missing tildes svn path=/trunk/; revision=81 --- pd/extra/expr~/LICENSE.txt | 341 ++++++++ pd/extra/expr~/README | 67 ++ pd/extra/expr~/fts_to_pd.h | 41 + pd/extra/expr~/help-expr.pd | 231 +++++ pd/extra/expr~/makefile | 160 ++++ pd/extra/expr~/vexp.c | 1948 +++++++++++++++++++++++++++++++++++++++++++ pd/extra/expr~/vexp.h | 233 ++++++ pd/extra/expr~/vexp_fun.c | 828 ++++++++++++++++++ pd/extra/expr~/vexp_if.c | 931 +++++++++++++++++++++ 9 files changed, 4780 insertions(+) create mode 100644 pd/extra/expr~/LICENSE.txt create mode 100644 pd/extra/expr~/README create mode 100644 pd/extra/expr~/fts_to_pd.h create mode 100644 pd/extra/expr~/help-expr.pd create mode 100644 pd/extra/expr~/makefile create mode 100644 pd/extra/expr~/vexp.c create mode 100644 pd/extra/expr~/vexp.h create mode 100644 pd/extra/expr~/vexp_fun.c create mode 100644 pd/extra/expr~/vexp_if.c (limited to 'pd/extra/expr~') 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. + + + Copyright (C) 19yy + + 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. + + , 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 +#include +#include +#include +#include + +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 +#include +#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 + +#define __STRICT_BSD__ +#include +#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 +#include + + +#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; iex_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 -- cgit v1.2.1