HISTORY of changes

Syntax description:
	* Bug fix
	+ New feature
	- Note/change
	: Obsolete/old stuff

------------------------------------------------------------------------------

11	
	* Cleaned up a bit more, and made more functions return proper error
	  messages.

	+ Seven new error messages have been added to help debugging FPL
	  programs. The new ones are more specified of what exactly the error
	  is. Of course I remade a few details to make them use the new
	  errors.

10.7	* Accessing a string array with i.e foobar[-1] now generates
	  'illegal array "foobar" error!' instead of previous 'out of reach
	  error!'.

	* The since a long time known, but very-hard-to-find bug that made FPL
	  loose control of the line number in error messages is now removed.
	  It occured in situations like:

		if/while ( FALSE )
		  STATEMENT;

          The newlines between 'STATEMENT' and the following statement were
	  then counted twice...!

	* A single exported/global string variable that was assigned at
	  declaration time wasn't properly taken care of. Later use of the
	  variable could lead to crashes!

10.6	* FPLTAG_KIDNAP_CACHED was fixed and should be working now!

	- Since we're planning a release (software based on FPL) on OS/2, all
	  packages from now is gonna be multi-platform. It means a few things:
	  o ASCII formatted docs will be included as well as the .guide ones.
	  o Binary versions of FPL.DLL (OS/2) and FPLlib.so (Intel SVR4 UNIX)
	    will be included.

10.5	* Assigning a global/exported string variable after it had been
	  "globalfied", did cause a crash!

	* Deleting a global/exported variable with DelIdentifier was not
	  healthy...

	+ Made both fplDealloc() and fplDealloca() capable of freeing memory
	  allcated both with fplAlloc() and fplAlloca(). They're now virtually
	  the same function.

	+ Introducing the FPLREF_ARRAY_RESIZE... This tag to fplReference()
	  enables the host program to resize the array to which a reference
	  was sent as parameter to a function.

	* Using 'resize' on arrays that were declared as global/exported
	  did result in system crashes!

	* Improved the error message when trying to refer to non-existing
	  or negative array fields. Could previously easily contain the wrong
	  variable name.
	  Did the same to illegal 'resize' operations.

10.4	+ Added FPLSEND_GETRETURNINT, which returns a pointer to the value
	  returned by a program. If no value was returned, this will return
	  NULL.

	* Fixed the fplExecuteXXXXXX() invokes that allow strings to get
	  returned so that the string pointer is set to NULL if a string
	  wasn't returned. Previous versions didn't touch the pointer in such
	  situations.

10.3	* Fixed another small detail with the nested runnings and failure.
	  Nobody has experienced any trouble with it though.

10.2	* Execution of nested files (and an error in a nested level) could
	  lead to files being cached accidentaly, which could lead to serious
	  confusion!

10.1	+ FPL now offers external variables to be added just like functions
	  have been a long time. With the function fplAddVariable(), they
	  will be added and recognized instantly by FPL. Added variables are
	  always read-only, and all reads from them causes the interface
	  function to get called as in a regular external function case, and
	  the returned value (with 'fplSend()') will be the result of the
	  variable read. The fplArgument struct has been extended with an
	  extra member which will hold the default variable result, the result
	  that will be the variable contents if the interface function doesn't
	  return anything.

	* Fixed some serious errors when FPL found 'const' variables. It did
	  not prevent some changes, and some changes caused peculiar error
	  messages!

	* Fixed a bug in the fplAllocString() which made the fplReference()
	  or fplSend() where the string could be used to cause damage to
	  the system's memory list.

10.0	FPL VERSION 10
	~~~~~~~~~~~~~~
	We've now reached version 10. The version number increase is because
	of the following reasons:

	+ The expression parsing is now 100% C compatible to the very last
	  detail AFAIK!! Expressions like the following are now treated the
	  C-style way:

	  1) if(a++ && b++)...  the right part is only executed if the left
	     part was evaluated TRUE

	  2) if(a++ || b++)... the right part is only executed if the left
	     part was evaluated FALSE

	  3) if(a ? b++ : c++ )... "b++" is only executed if 'a' evaluates
	     TRUE, and "c++" if 'a' evaluates FALSE

	+ FPL now allows array references sent as parameters to functions. Such
	  parameters are declared as "int *array[]" or simply "int *[]" for
	  integer arrays.

	+ fplReference() now features:
	  FPLREF_TYPE_ARRAY is now a valid type bit returned by the FPLREF_TYPE
	  tag.
	  FPLREF_ARRAY_ITEM lets you set which array item you want to read or
	  write. The strings/ints are still read with the previous tags for
	  those purposes (or the new ones described below).
	  FPLREF_ARRAY_INFO gives you information about the looks of the
	  referenced array variable.
	  FPLREF_SET_MY_STRING makes a normal string valid as new string for
	  a referenced variable. The length can be set with...
	  FPLREF_SET_MY_STRLEN defines the length of the string set with the
	  tag above.

	+ fplInit() features this new tag:
	  FPLTAG_PREVENT_RUNNING_SAME which will make FPL to abort any tries
	  to run a program that already is cashed. The FPLTAG_REREAD_CHANGES
	  tag still works fine with this though.

	+ fplSend() features these new tags:
	  FPLSEND_RESULT which will give fplSend() a long to store results in.
	  FPLSEND_IS_FILE_CACHED will give information regarding if the
	  specified file is cached (held in memory) or not.

	+ sprintf() is a new FPL function. Features all ANSI C %-codes plus
	  a few additional ones:
	  %o - octal number
	  %b - binary number
	  %n - number of characters
	  %P - pointer shown with uppercase letters
