Awka Stuff:

Home of Awka
Specifics
Downloads
Change Log
Bug Tracker
Awka-ELM
Awka-ELM Libraries
Future Plans
Comparisons
Contributors

AWKA FORUM


Other Stuff:

Xglobe Maps
About Me...


Generously hosted by SourceForge...

• Serves me right - "run the test suite before releasing snapshots". The final change I made to 51 seriously broke getline. I apologise to all who were affected by this.
  
• The print function was unusually slow when you gave it a comma-separated output list; now it's quicker.
  
• A few minor regular expression speed enhancements.
  

• Finally overcame a translator memory error introduced by the snapshot 48 local function override fix.
  
• Changed translator so that calls to split() will use FIELDWIDTHS if it is active and no field separator is specified.
  
• Fixed a library problem that occasionally caused FIELDWIDTHS splits to return incorrect results.
  
• This script: { print; getline<"another.file"; print } will now work. Previously it read one line from the input file, then read only from "another.file".
  

• Yet more regexp backslash adjustments, which I really hate making as they can so easily introduce new problems - lets hope not.
  
• Rationalised the buffered input functions, as they were written in such a complex fashion that I was having difficulty understanding how they worked. The new design is much simpler, and a bit faster as well. Another benefit is that the -Wi flag, which makes input from stdin line- buffered, will now respect the value of RS.
  
• Eliminated some unnecessary strcmp() calls from awka_getline and awka_print(), thus improving performance (a bit).
  

• The unbuffered getline from /dev/stdin, introduced in snapshot 47, should now work on platforms that don't actually have a /dev/stdin device.
  
• Oops, the local function override fix in 48 introduced some new errors, which in turn have now been fixed. Code in haste, debug forever...
  
• A new feature, passing command-line parameter "-a[wkaversion]" to a compiled executable will cause its awka version (really?) to be printed - nice idea Eiso 8-).
  
• Configure script edited to use diff instead of cmp for the test suite under DJGPP.
  

• Gensub bugfix - it now returns the altered variable as a string rather than the faulty behaviour of casting it to a number.
  
• Local functions that override the extended builtins can now be defined anywhere, rather than having to precede the BEGIN section.
  
• Yet another backslash fix: regular expressions used in match statements no longer need their backslashes to be double escaped - eg /\\/ {print} will work, previously you needed /\\\\/ {print}.
  

• Corrected some old translator code that prevented exit statements at the end of BEGIN sections from working.
  
• Gawk gensub function introduced.
  
• getline input from "/dev/xxx" streams is now unbuffered to match the behaviour of other awk implementations.
  

• This code: BEGIN { $1="x";$0="y";print $0 } will now print "y" rather than "x".
  
• Regular expressions with box brackets [] inside other brackets, such as /[[]/, will now work again (broken in snapshot 45).
  
• Variable names, held in the _gvar[] structure, were not being null terminated, and this was causing problems with -v arguments under SGI 6.5 - problem fixed.
  

• Completed string regular expression change commenced in the previous snapshot - it will now work when the RE is in a string variable as well as for string constants.
  
• Regular expressions with a / enclosed in [] or () are now supported.
  
• Prevented potential free of null pointers in init.c.
  

• Failure to read from an input file (eg awka -x '{print}' -- nosuchfile) will now cause an error message, as is the case with gawk. Calls to getline do not produce an error if it fails, as this is handled by getline's return value.
  
• If you deleted an ARGV element, then called getline, the deleted element returned as an empty string. This 'feature' has been removed - a deleted ARGV element will stay deleted.
  
• An array bounds error that occurred when SORTTYPE is used has been fixed.
  
• The string "[\\t]", when used as a regular expression will now be treated like /[\t]/ rather than /[\\t]/. This change makes behaviour more compatible with other awks.
  

• (s ~ r) expressions will now return 0 or 1, rather than the position in s that matched r.
  
• Fixed a bug in the regexp module caused by an uninitialised variable. I've converted this module to ANSI-C to prevent this type of error occurring again.
  
• The awka library will now try to intercept fatal signals, such as segmentation faults, rather than core-dumping. You can turn this off by defining a_DUMP_ON_ERROR in config.h after running configure.
  
• New feature: argcount() within a function will return the number of arguments passed to the function; outside a function will return 0.
  
• New feature: argval(n[, arg, arg...]) within a function will return the variable passed as the n'th argument; outside a function will return a 'null' variable (ie. 0 or ""). If the n'th argument is an array variable, you can also define array elements. Examples:- 'BEGIN { abc(5,3) } function abc(a,b,c) { for (i=1; i<=argcount(); i++) print argval(i) }', and 'BEGIN { a[3,4] = "hello"; abc(a) } function abc(a) { print argval(1, 3, 4) }'
  
• New feature: getawkvar(name[, arg, arg...]) will return the value of the global variable "name". For example, try: 'BEGIN { a=4; print getawkvar("a") }', or 'BEGIN { a[3,4] = "hello"; print getawkvar("a", 3, 4) }'
  

• The DJGPP/Cygwin32 fix now breaks configure under Unixes! Another correction, hopefully all is now well.
  
• Another error in the generation of the ARGV array has been corrected.
  
• The labels produced in the translated code have been modified to overcome a problem with the HPUX C compiler.
  
• The use of '&' in gsub is now supported. From the gawk manpage:- "An & in the replacement text is replaced with the text that was actually matched. Use \& to get a literal &."
  
• The support for --prefix and --exec-prefix in configure broke the setup of config.h, affecting awka -x on some platforms.
  

• Error in handling awka -x combined with -- arguments has been fixed.
  
• The introduction of DJGPP into the configure script's test for .exe extensions broke the test under Cygwin32 - this has been corrected.
  
• Included DJGPP-related enhancements to Makefile.in, and improved the contents of INSTALL.djg.
  
• Corrected an error in the conversion of split() arrays to hash arrays.
  
• When reading from a file not on the filelist, getline was failing to close the file handle after reaching the end, even if close() was called. Large numbers of such files in a script meant that the operating system's maximum number of open files was in danger of being breached. The error has now been corrected.
  

• DJGPP now supported, thanks to the effort put in by Peter J. Farley III and Nethanel Elzas. See INSTALL for details on how to compile Awka in this environment.
  
• The configure --exec-prefix, --prefix, --bindir, --libdir, --includedir and --mandir options can now be used to determine where make install puts its files on your system. See configure --help for more details.
  
• SORTTYPE builtin variable introduced. This variable controls how output of 'for (i in j)' is sorted - see manpage for more details.
  
• The use of a * character in a printf format string to insert a length out of the argument list (eg "%*s",3,str) was supported for widths; now it is also supported for precisions (eg "%3.*g").
  
• User-defined functions are now suffixed by _fn instead of _awkfn - this makes future implementation of extended functions libraries easier.
  

• Prevented some duplicate use of temporary variables, a potential cause of memory problems.
  
• Now freeing I/O buffer upon reaching the end of a file. Previously, this took excessive memory when large numbers of files (100 or more) were used.
  
• Fixed a cause of memory problems when calling split() with an empty string for the separator.
  
• array.c will no longer treat empty strings as zero integers (ie. a[""] will be different to a[0]).
  
• Corrected a translation error that was sometimes reversing logic on numeric comparisons (this error was introduced in snapshot 33).
  

• The "temp" char in the a_VAR structure was not being initialised for some builtin variables, and this was causing problems in variable assignments. In particular, the amsal5 and parsecsv tests were failing, but all should be well now.
  
• Changed test/Makefile.in to execute ./xx instead of xx, thus supporting users who don't have . in their PATH. Also reduced the number of files opened concurrently in the manyfiles test.
  
• Under some circumstances, library code was trying to free the same variable twice - surprisingly Linux and many other platforms didn't complain about this, but at least Irix core-dumped. Problem fixed.
  
• Fixed a minor memory leak that occurred under rare circumstances with user-defined functions.
  
• Variables set using the -v var=val command-line option are now treated as numbers if their value is numeric.
  
• ARGV held one too many arguments (ie ARGC == 2, and (2 in ARGV)) - this corrected, but hopefully no new problems as a result, as messing with ARGV/ARGC is fairly tricky.
  
• Manpage updated to reflect previous addition of FIELDWIDTHS.
  

• Improved the order-of-execution fix below - it shouldn't hit performance quite as hard now.
  
• Spaces between builtin function names and parentheses, eg. 'sin (a)' is supported by most AWKs, however the spaces are not allowed for user-defined functions. This is to prevent code like 'a = this that (x="4")' from having 'that' incorrectly treated as a function. Awka now supports this policy; previously it allowed spaces for user-defined functions, causing the above example to fail.
  
• Another (y in z) fix, correcting an error introduced by the fix in the previous snapshot.
  

• The code 'x["y"]; z = ("y" in x)' was setting z to 0, not 1 as it should have. Now it works properly - this does not affect 'if ("y" in x)', which was already correct.
  
• The order-of-execution of function arguments was wrong. The code 'a=1; printf "%d %d\n",a,++a' would print "2 2" rather than "1 2" due to this problem. My present fix is overkill, ensuring correctness at potential cost to speed, but them's the breaks.
  

• Oops! The translator fix in snapshot 34 introduced errors when RSTART used in a script - now fixed.
  

• Plugged a nasty memory leak that occurred under rare conditions in user function calls.
  
• Added some more parentheses protection for assignments within truth condition expressions in the translated code.
  
• Added the internal variable RT, which complements use of RS as a regular expression.
  

• Fixed a translation bug to do with over-zealous optimization of local function variables (introduced back in snapshot 25).
  
• Due to a strange addition to the return variable, awka's rand() function was sometimes returning values larger than 1. This has been fixed.
  
• If you set environment variable BUILDLIB to "so", libawka will be built as a shared object library rather than a static archive. Only do this if your C compiler supports the -shared argument. You may have problems with make test - if so, try doing a make install first.
  

• RS as a regular expression now introduced.
  
• Setting element 0 in an array created by split was overwriting element 1. This anomaly has been corrected.
  

• 'if (i in j)' always returned true if 'j' was created by split, and 'i' was any positive integer. Now it should behave itself.
  
• Some more regexp to string conversion speed optimisation, and some tidying of the enhancements introduced in snapshot 30.
  

• Fixed a memory leak that sometimes occurred when regexps were being cast to strings and vice versa.
  
• When execution reaches main pattern section, FILENAME will be set to a default value of "-" rather than "", providing it has not been previously set to some other value.
  
• The (s)printf function had a static buffer for temporary memory needs, on the assumption that it would never be fully used. Bad assumption - now we have a dynamic buffer.
  
• The backslash parsing code in the (s)printf function was causing scripts like 'BEGIN { printf "\\" }' to misbehave. The code was obsolescent, and has been removed.
  
• Scripts that cast variables from regular expressions to strings & back again will now run much faster.
  

• Introduced FIELDWIDTHS, which behaves in the same way as gawk's variable of the same name.
  
• Also introduced SAVEWIDTHS. This variable contains a space-separated list of widths, similar to FIELDWIDTHS. When FIELDWIDTHS is active and SAVEWIDTHS is set to a valid format string, any rebuilding of $0 will seek to use the widths specified in the SAVEWIDTHS format. This means short field values will be padded with spaces, and long ones will be truncated. Fields additional to those specified in the format will be separated by OFS.
  
• The function that formats strings for (s)printf was sometimes failing to allocate sufficient memory, resulting in array bounds overruns. Some more explicit logic has corrected this.
  

• Fixed test/Makefile.in - the argtest2 script will work now.
  
• More rationalisation of malloc/realloc methods.
  
• Fixed a problem in performing gsub over /^.*|whatever/ type expressions.
  
• Removed the annoying (but harmless) warnings when compiling awka.
  

• The concatenation of multiple array subscripts, last reviewed in snapshot 24, needed another small adjustment.
  
• Removed some unneccesary causes of memory free, malloc and realloc operations.
  
• In lib/Makefile.in, there were two ../regexp/regexp.o rules, which was confusing make on some systems.
  
• New Feature: you can now specify command-line arguments to be embedded in the executable, using awka -a 'args'. See the manpage for more details.
  

• Some more parentheses protection for assign operations within truth expressions, this time for 'x = (y = (a in b || c in b))'.
  

• Optimisation tweak involving a reduction in the use of memcpy. Scripts that have lots of functions and/or string manipulation should be faster.
  
• Another optimisation, this time introducing some more intelligent tracking of variable types returned by builtin functions.
  
• Re-implemented a gsub bugfix that was previously done in snapshot 4. The problem had been re-introduced by the snapshot 20 rework of gsub.
  

• Small fix required in the concatenation of multiple array subscripts.
  
• gsub(var, whatever, var), where the same variable is both the target and the regular expression, was not previously catered for but will now work properly.
  
• Another small fix in varcpy, to correct an incomplete copy where the source variable was a regular expression.
  
• Some number formats (eg 2.34567e-02) were not being handled properly, causing incorrect behaviour - this has been fixed.
  

• Ensured assignments used in truth expressions (eg. if ((x = y) > 3)) are protected by parentheses in the generated code.
  
• The code 'x *= y' will now be translated using '*=' rather than 'x = x * y'. As well as being correct, this eliminates some potential compile errors.
  
• Calls to builtin functions within conditional expressions will no longer cause parse errors.
  

• A small translation error in parsing conditional expressions has been corrected.
  
• A gsub error in replacing entire strings with "" has been corrected.
  
• Comparison of uninitialised variables with int(whatever) was causing problems, but is now working properly.
  
• The regexp functions now call awka_error() rather than their own error function.
  
• Passing an uninitialised variable to sub() or gsub() was causing a regexp error message, but is now ok.
  
• Some circumstances were causing $0 not to be updated followinga change in a $n variable. The fix for this was tricky, and I did not enjoy making it - I am hoping it has not created other problems.
  

• The code 'function foo() {bar()}' contains a call to an undefined function bar() within a function that itself is never called. Hence the error about bar() not being defined has been removed.
  
• Fixed a translation error that occurred when multiple range patterns were used.
  
• Corrected an error in the parsing of backslashes on some regular expressions. Thanks go to John H. Dubois III for his work in tracking this bug down.

• Fixed a small error in the gsub function (introduced in the Snapshot 20 rework.
  
• Fixed a translation error triggered by some uses of range patterns.
  
• Some small optimisations of function parameter handling.
  

• Fixed a minor memory leak.
  
• Getline was setting the target variable to an empty string when the input file could not be read. The proper behaviour appears to be leaving the variable alone - this is what getline now does.
  
• The management of local function variables was a little bit loose, and could confuse itself under some circumstances. It has now been tightened up.
  
• Running delete(x), where x is an array that has not been initialised yet, would produce a core-dump. Now its ok.
  
• Local function array variables were not being identified as arrays before runtime. This sometimes resulted in unusual side-effects. The translator has been improved to overcome this problem.
  
• In interactive mode (-Wi), the length of incoming lines is now being calculated correctly.
  
• Performance enhancements: new test for exact-string searching in regexps, reworked & simplified gsub function, revisited garbage collection methods, optimised $n access methods.
  

• The translator was producing code for 'for (i in j)' loops that contained an uninitialised variable. This was sporadically causing core dumps, and has now been fixed.
  
• The compile error in Snapshot 18 has been fixed. Don't know how that one slipped through!
  
• The alterations in 14 had not been carried through to the function that converts split arrays to hash arrays. For local function array variables, this was causing core dumps.
  

• LinuxPPC 5.0 now supported.
  
• Both the translator and the library now have the same definition of awka_error(). Not a major change - it's really for my benefit.
  
• A key variable monitoring memory allocation for i/o streams is now being initialized correctly. This fixes the previously mentioned SGI file read problem.
  
• New memory-debug module added. It is activated by defining MEM_DEBUG in config.h. It provides basic protection against array bounds errors, failure to initialize allocated memory and read/write of freed memory. Like all memory debugging schemes, it will make programs run slowly - its really for use in tracking down problems in the library, such as the uninitialized variable fixed above.
  

• Fixed a minor problem in parsing backslash characters within regular expressions.
  
• Reworked some dangerous code in var.c that could have resulted in using uninitialized variables, leading to memory corruption.
  
• Checking against division by zero was sometimes producing spurious math errors, although under very rare circumstances. This now fixed.
  
• Some performance enhancements (without introducing new bugs, honest!)
  
• Interactive mode is now available using the -Wi option on the executable's command line. See man page for more details.
  

• Removed a subtle cause of memory corruption from array.c. This _may_ resolve the file read problems some users are experiencing under SGI (here's hoping).
  

• Thoroughly re-worked the 'garbage collection' code that manages temporary variables. The old method was overly restrictive, and could break under certain conditions. A lot more thought has gone into the new design.
  
• Renamed regexp functions regcomp() and regexec() to avoid conflicts with system libraries.
  

• The Library is now released under the Awka Library License (see file LIBLICENSE.txt.
  
• Some mods to array.c to improve multi-dimensional array performance, and a new benchmark test file (array3).
  
• Ensured variables are freed properly after execution, preventing leakage where code is integrated with a user application and called multiple times.
  
• Fixed some silly errors in the sorted output of 'for (bugs in awka)' loops.
  
• Removed a whole stack of function inlining from the library. Instead of speeding things up, it was slowing everything down.
  
• The 'function hello(RS) {;}' bug has been fixed - it will now compile and run correctly.
  
• Fixed some translation problems relating to RE's, also fixed a core-dump where a variable was being set to a string, then an RE, then a string again.
  
• The 'function xx(yy) {print yy} function yy(xx) {xx(++xx)} BEGIN {yy(2)}' problem has been fixed - it will now compile and run correctly. This basically clears my known bug list, _and_ (hopefully) I no longer need to transfer to the Gawk parser!
  

• Small change to Makefile.in to prevent some 'mkdir -p' commands from failing on make install.
  
• Revised the manpage.
  
• 'for (i in j)' loops in the main pattern section of a program will now compile correctly.
  
• Enhanced the ltrim, rtrim and trim functions. You may now pass a second (string) argument, containing characters to be trimmed. Without the second arg the functions will still trim whitespace.
  
• Range Patterns are now supported (at long last!)
  
• Defining NO_BIN_CHARS in config.h will cause awka-generated executables to replace binary characters in the input data with spaces, at the cost of some speed degradation.
  
• Defining SLOW_HASH in config.h will cause array hashing to be generated from the entire index string, rather than a truncated part of it (default method). Your average case will be worse with this method, but the worst-case performance will not be nearly as bad.
  
• Functions that are never called will not be translated. This reduces the size of output and therefore of the compiled executable. It should greatly improve the efficiency of including files containing libraries of AWK functions.
  
• User-defined AWK functions and variables will override the extended builtin
  functions. This was previously attempted way back in Patch 5. I really hope it works properly this time!
  
• '-o filename' option added to awka command-line. In conjunction with -X and -x, it allows you to specify the filename of the generated executable.
  

• -s switch added to awka command-line. This will cause output from 'for (x in y)' loops to be sorted in ascending order. If an array has both string and integer keys, the ints will come first, followed by the strings. Note that this may run slower than the non-sorted version, as it does a quick-sort of the list before each loop.
  
• The parse error encountered when using 'x++ / y' has been fixed, thanks to a patch from Mike Brennan.
  
• Making a recursive function call from within a 'for (i in j)' loop will now work correctly.
  
• Small change in array.c to prevent yet another cause of core-dumps.
  
• Reworked awka command-line option '--' to eradicate some errors in passing arguments. Also added -help command-line option for the compiled executables.
  
• Small fix in translate.c, removing some parentheses that didn't belong.
  
• The 'totitle' function now converts the first letter in every word to uppercase, rather than the first letter only, eg:
  old: totitle("i shall return") returned "I shall return"
  new: totitle("i shall return") returns "I Shall Return"
  
• Reversed order of changes in this file to make for easier reading.
  

• Fixed (I hope) the wanton leakage of memory that occurred if you used return or next within a 'for (i in j)' loop.
  
• Fixed another array.c that caused segfaults when deleting an element in an array indexed by both strings and ints. Made another fix to ensure hashing doesn't suffer on these types of arrays.
  
• Fixed a backslash bug that was inherited from mawk. 'print "\{ hello \}"' will now print "{ hello }" rather than "\{ hello \}". This was a major change that could well have introduced new problems, although the test suite works ok.
  
• On some occasions, NF was not being set until $n was read - this has been corrected.
  
• Small tweak in array.c to optimise performance for arrays containing both string and int indexes.
  

• Introduced the alength() builtin function. This takes an array variable as its argument, and returns the number of elements in the array.
  
• Fixed a bug in array.c that caused storage of strings & ints when only storage of ints was required. What a waste of space.
  
• Setting an array variable from the command-line (eg "-v x=1 'BEGIN { x[1]=2 }'") will now produce an error message about using an array as a scalar. This is a dark corner of AWK, and neither gawk or nawk seem to handle it logically.
  
• Getline should return -1 when it fails to open a file. Awka's getline was returning 0.
  

• Fixed an uninitialized variable problem in the translator that sometimes caused it to crash.
  
• Multiple print arguments (eg print a,b,c) will now be separated on output using OFS - it was previously using a space character.
  
• Added another example in the benchmark directory, showing how awka performs using nested for-loops (worth a look).
  

• The conversion of an 'int' indexed array to a dual int & string array, introduced in 06 below, had a bug or two that led to core dumps - not now.
  
• Replaced mkdirhier with mkdir -p (used in make install).
  
• configure should find ranlib now.
  

• An array bounds error in io.c has been fixed - this should hopefully correct some reported bugs that I was previously unable to replicate.
  

• The code 'BEGIN { if (x<0) print "bad" }' will no longer print "bad" (x is an uninitialised variable)
  
• Added some extra parentheses to mathematical expressions, as some were being incorrectly parsed.
  
• Reluctantly modified array method to store int keys without conversion to strings. This substantially boosts performance, but of course opens the door for more bugs, given the number of changes required. It also uses more memory (or it _can_, depending on your script).
  
• And another major change - string variables now track the amount of memory allocated as well as string length, thus avoiding unnecessary realloc calls. This increases the size of an a_VAR by 4 bytes, which uses a bucketload extra memory for large arrays. A memory chip is cheaper than a super-fast CPU.
  
• Another translation fix similar to 05 below - 'x = a || (b && c)' will work.
  
• Fixed a getline bug that caused a premature halt to reading input.
  
• Added patch level number to -v output.
  

• Code such as 'x = ((a == 1) || (b == 2))' will now parse correctly.
  
• User-defined function names should no longer conflict with functions in system libraries.
  
• The Henry Spencer library now used for both libawka.a and translator, avoiding spurious parse errors generated by mawk's rexp.
  
• Variable names will no longer conflict with user-defined function names. Code such as 'function b(a) { print a } function a(b) { b(b) } BEGIN { a(3) }' should now work, and this time nothing else should be broken!
  
  NOTE: The intention was to remove conflict between functions and local vars, but it will actually apply to all vars (gawk will not allow this). This can be dangerous, particularly when combined with...
  
• Variable names will override builtin function names. The intention was to support code using variables with the same names as the new extended functions, but actually many other builtins are also affected.
  
• The split bug 'fixed' in 04 below, has now been fixed. Really.
  

• An array overrun in the translator has been fixed - it produced core dumps on SCO, but remained hidden on most other platforms.
  
• Improved hash algorithm, after seeing some input that caused too many collisions.
  
• This code: 'x = "1"; y = 2; x += y' produced a value for x of 2, not 3. It is now correct.
  
• A variable with dual numeric & string status was dropping its numeric value after being run through sub or gsub. Now it will retain its numeric status if the gsub'd string is, by nature, a numeric.
  
• When $1..$n are changed, $0 should be rebuilt before next use. This was not happening when $0 was being passed to sub or gsub. It is now.
  
• Numeric local function variables are now initialised between function calls.
  
• A split bug, where old values were still accessible after subsequent calls to split, has been fixed.
  
• There was a subtle bug in split RE's with OR characters, eg / *|^x|,/ This has been corrected.
  

• Fix to 01 below - overriding some functions would have caused core-dumps. Note that you cannot override the getline, split, print, printf, length or match functions.
  
• -W exec option added to the command-line parse function in init.c in the library. This is similar to mawk, in that all following command-line options will be treated as filenames and inserted into the ARGV array.
  
• Optimised awka_strconcat(), and section in awka_doln() that rebuilds $0. Also improved _awka_isnumber().
  
• print() will now use the more efficient awka_argn (n=0,1,2,3) where possible.
  
• Some minor changes to awka.ac.m4 and Makefile.in to ensure ranlib only runs when it actually exists, and to chmod permissions on the library, header file and translator executable on install.
  
• Fixed a subtle logic bug with 'if (i in j)' expressions.
  

• Local Functions will override builtin functions
  
• split(a, b, z x) will no longer core-dump
  
• using 'for (i in j)' where j was created by split should now work
  

Andrew Sumner - (andrewsumner at users.sourceforge.net)
visitors since I added this counter.