fexl - Function EXpression Language
Fexl is a simple but powerful scripting language. It allows you to manipulate numbers, strings, streams, and functions easily and reliably, all within a secure "sandbox".
Go into the source code directory:
Build the code and test its validity:
That runs the test/run script and compares its output with the reference output in test/run.out. If everything works as expected, you should see no output. However, if you run on a 32-bit system you will see some inconsequential differences in the output of test/b18.fexl, which measures memory usage, and also test/b17.fexl, which deliberately tries to run out of memory.
There is no "installation" as such. You just put the Fexl code anywhere you like, build it, and run it from there. There is no script to copy it to /usr or anything like that.
My approach is to create a ~/bin/fexl script which does this:
exec ~/project/fexl/bin/fexl "$@"
So the "fexl" script in my search path runs the real executable right where I built it, setting argv to its full path name, allowing it to resolve the names of any files it might need that come bundled with the distribution. That way I don't have to rely on non-portable features like "/proc/self/exe" to locate the executable.
To build the code:
To erase the output files and build the code from scratch:
To erase the output files:
To do a verbose build, showing all the commands:
To build the code and run a fexl program:
To build the code and see the test output:
To build the code and check the test output:
To source the handy shell aliases that I use for development:
To time the test output:
To time a long series of calculations and output:
To see the current version number (http://semver.org):
Guide to source code
main routine is in fexl.c.
eval routine is in value.c.
value structure is defined in value.h, and documented in value.c.
The memory.c file implements a disciplined approach to memory usage which
verifies that there are no memory leaks during execution. Also see
drop in value.c, which implement the reference counting mechanism.
The "test" directory contains the Fexl test suite.
The interpreter creates an initial value which represents your entire program. It then evaluates that value, reducing it one step at a time until it reaches a final value. Each step may possibly create side effects -- after all, the entire purpose of a computer program is to create side effects. However, the purely functional aspect of Fexl allows you to isolate those side effects as far as you like.
A value is either an atom or a pair. An atom represents either a built-in function (with a pointer to a C function), or a piece of data (e.g. long, double, string, file, etc.) A pair represents the functional application of a value on the left side to a value on the right side.
The initial value is fully resolved and contains no symbols, so the interpreter does not have to do any symbol lookups or bindings during evaluation.
"On the Building Blocks of Mathematical Logic", Moses Schönfinkel, 1924
"Typed Representation of Objects by Functions", Jørgen Steensgaard-Madsen, 1989
This code is copyright 2011 by Patrick Chkoreff (firstname.lastname@example.org). See the LICENSE file for details.