Yazoo

Yazoo is a command-line, interpreted scripting language which provides a ready-made environment for C or C++ functions. A user embeds his own routines into the language by referencing them in one of Yazoo's own source files, then recompiling Yazoo. When Yazoo is run, it will bring up a command prompt where the user can define and manipulate variables, arrays, scripted functions, read and write files, etc. -- and, call his embedded functions. Since only the standard C libraries are used, Yazoo should work on just about any platform.

Yazoo scripting is a minimalist affair: classes, sets, functions, function arguments, etc. are all the same thing. The simplicity of this scheme eases the learning curve. But it also buys the language a lot of generality -- Yazoo permits many exotic programming constructs that are rare in a scripting language, but have proven eminently useful in the author's hands.

The Yazoo download consists of: C/C++ source files; a Makefile; essential ".zoo" scripts; and documentation.

What is new in this release:

• Bugs fixed:
• problems defining proxy members while resizing the array; e.g. proxy_array[+1] @:: { }
• 'return q' now works when 'q' is void
• a problem where large unsigned integers would print as '0'
• go() could get stuck inside array elements
• read_string() (and ReadTable()) couldn't read exponents with plus signs (e.g. 1e+1)
• problems reading and writing numbers close to the double-precision underflow limit
• a problem with ReadTable() when trying to resize lists
• a problem with ReadTable() when a two-dimensional table has only a single element
• a problem using SaveTable() with null tables
• a copy() crash when the first argument was primitive and the second argument was composite
• a problem with go() that crept in when the # operator was introduced
• occasional crash when start.zoo tried to flag an error
• a warning message under some compilers (extrnl.c)
• SaveTable() now makes sure to de-alias tables if it's called improperly
• an error in SaveTable() when passed a non-composite 'table'
• an error flagged at the wrong location
• an awkwardly-flagged error when the calculator tried to print a self-referencing object
• Improvements:
• removed the 'this.' prefix when defining variables. This will cause problems in procedures that define variables with the same name as global variables!
• a = @b now works when b is void. This means that 'trap(x)' is no longer the way to detect void members; use 'if x == @nothing' instead.
• added an 'underflow' runtime warning code
• added cat() to user.zoo
• added Save() which tries all directory paths (it is analogous to Load())
• SaveTable() now tries all directory paths
• added ls() which prints out variables in current directory
• added compile_and_do_in() to user.zoo
• added round() which works to nearest integer
• sped up resizing of tables using ReadTable()

What is new in version 1.4:

• Bugs fixed:
• improved run()'s case-sensitive handling of filenames when run.CleanUp is set
• to true
• erroneous error message when exiting or returning from user.zoo
• bugs in ReadTable() involving resizing of tables
• problems in error messages from ReadTable()
• Improvements:
• added # operator to replace RunCode(), RunConstructor()
• added ';' as an alternate symbol for 'code'
• calculator defaults to 'on'
• add lowercase()/uppercase() functions to user.zoo
• added error codes to ReadTable()

What is new in version 1.3.1:

• A fix to a long-standing bug that sometimes crashed the program when using go().
• The new auto-cleanup feature of run(), also introduced in the last posting, has been having unreproducible problems and it is possible that this bug-fix takes care of that too.
• Two improvements considerably enhance the calculator: 1) its use of sprint() rather than print(), and 2) the introduction of an 'ans' variable such as one often finds in scientific-programming environments.

What is new in version 1.3.0.1:

• Fixed a bug.

What is new in version 1.3:

• Bugs fixed:
• a potentially fatal problem of neglecting the null character at the end of start.zoo or other starting script
• load() and save() were carelessly using ASCII mode rather than binary, which caused problems on PCs
• two more memory leaks & one referencing error (potential 3rd mem. leak)
• the calculator didn't work in the previous version
• multiple bugs involving [^..], [+..], +[..], =! or function calls to the left of a define/equate-at/etc. operator
• problems where the [+..] / +[..] operators would append to hidden members
• crashes involving size-0 proxy arrays
• problems w/ the calculator printing registers (masked by earlier calc. problem, but this problem in previous versions as well)
• a problem that caused slow resizing of large arrays
• disassemble() printed the wrong variable names on 64-bit machines
• resize() now allows a void final argument
• an awkward disassembled error when the user types "return my_array[a, b]" from the command prompt
• command-prompt crash after returning multiple indices of an array
• a problem flagging errors on lines beginning with |**|-style comments
• disassemble() crashed when given null scripts
• Improvements:
• configured Yazoo so it can be embedded in/invoked by C code; also run recursively from within Yazoo
• upon rerunning a script, run() first deletes the members it defined last time: no more trap(remove ..) needed
• added go()/pwd for changing/viewing the command prompt's workspace variable
• added reference comparison operators: '== @' and '/= @'
• added a proxy-define operator: '#::'
• made load() faster and more memory-efficient
• strings print '\D\n' as a single end-of-line
• run() can return the result of a script's return statement
• added sum(), mean() functions to user.zoo
• added char(), C_string() functions to user.zoo
• transform() now allows the user to tailor the search path of transformed code
• throw() can tailor the location of the thrown error and throw warnings as well
• run() will allow warnings in the script to appear at the command line (assuming no intervening trap() after the warning)
• disassemble() can skip over expressions in compiled bytecode
• replaced RunHobbish() with a more functional do_in() routine in user.zoo
• added RunCode() in user.zoo; RunConstructor() is now a special case of this routine
• consistently reading bytecode as slongs
• now properly using the NULL pointer rather than 0 in the C code
• improved some error messages
• Miscellaneous:
• changed the bytecode words for the array-insertion operators ([+..], +[..]) and delete
• eliminated CheckType() from user.zoo -"trap(a = @b)" is usually better
• eliminated exists() from user.zoo -"exists("a")" was largely redundant with "trap(a)"

What is new in version 1.2:

• The 1.2 version of Yazoo has just been delivered pre-term after a number of fatal errors on 64-bit machines came to light last week. Yazoo is a command-line interpreted scripting language, which the user is intended to customize by embedding his own C or C++ routines into the language. The novelty of Yazoo script is the way that the rules behind its conservative-looking syntax can be extrapolated to produce many rare and useful scripting constructs, which the author has not encountered in other languages.
• The really critical change in the present version was the removal of those assumptions about integer sizes that caused immediate crashes. This has necessitated another significant adjustment: the register R_ulong has gone from unsigned to signed, and so renamed R_slong. The renaming can in principle cause backwards-compatibility issues, although fortunately the integer register rarely needs to be invoked explicitly. Finally, regarding something uninteresting to most users but time-consuming for the author, the C/C++ source files have undergone stylistic renovation: they've been (finally) commented, and their formatting has been improved.
• Because this red-faced author scrambled a bit to post the current release, it is possible that 64-bit bugs lurk yet in the code. If this is so, then another, amended version will likely be be forthcoming in a very few days, as the author uses his program avidly.

What is new in version 1.1:

• Bugs fixed:
• incorrectly-flagged error messages in almost any script with inlined constants
• the append-code operator ':' didn't work properly in certain contexts, e.g. within a code-substitution operator
• forced-equate didn't copy array elements in the right order when multiple indices were given explicitly (e.g. a[*] =! ..., ... = b[1, 2])
• numerical issues when printing numbers at the edge of double-precision resolution
• incorrectly-flagged error messages following endif, endf or endw
• wrong member names in member-not-found errors from files run by user.zoo
• the first number returned by random() wasn't entirely random
• copy() didn't check for self-references
• an error in SaveTable() when the second dimension of a table was sized to zero
• sort() threw an unnecessary error for length-0 lists
• misreading of the null comment '|***|' with an odd number of '*'s
• Improvements:
• search paths of new {} definitions now always go through the script that defined it, NOT necessarily the enclosing script ***
• added resize() to user.zoo
• added min(), max() functions to user.zoo
• sort() now sorts lists as well as tables
• new() accepts different source variables for type and data
• copy() returns an error code
• better argument checking for SaveTable()