#############
				FUTURE of FPL
				#############

  Here follows a list with some ideas for the future of FPL. These are the
items that feel are most important (in a very approximate order of
importance):

* Static string caching. A given number of static strings that are used in an
  FPL program run will be stored while the program is running. Each time the
  static string is reffered, it will be read from the cache. Especially loops
  using [large] static strings will get a major speed increase. Will get
  switched on first when using FPLTAG_STRINGSTACKSIZE.

  (Also in subject of changing is the way FPL scans a string. It might get
  faster if FPL did count the string length first, and then did _one_ alloc in
  the beginning instead of reallocing and parsing the string and the same
  time.)

* Full C-style expression parsing. Today FPL uses the handicapped, always-
  read-the-entire-expression habit which is not at satisfactory!

* FPLTAG_HOOK_LOAD, replace FPL's load functions. Enable compressed/encrypted
  programs or add path searching for programs or...

* Support array declaration and assigning without speciying array size (as in
  regular C). I.e, "int array[]={0, 2, 3, 4, 12};"

* FPLSEND_WATCH_SYMBOL. Get more information about a specific FPL symbol.
  Variables *and* functions.

* 'enum' support.

* (AMIGA) StackSwap() swap stack i a neat way. New flag options is also on
  its way: FPLTAG_HANDSOFF_STACK which will make FPL give the host program
  its stack back when the interface program is called. Thus enabling that
  program to use stack checkings and expansions as much as it pleases...

* Multithread support. Run multiple FPL program simultanously sharing global
  data. (Probably done by adding fplAddThread() and fplDelThread().) I still
  haven't got a system independent resource locking method, and will probably
  *not* find one. Locks will be done in different way depending on the OS
  capabilties.

* FPLTAG_QUERY_CACHE
  Runtime-query the interface function whether to cache or not. The query
  will be done after the other cache options has been read and taken effect.
  That is, using no chache will never query, caching only exports will only
  query if there is any exports and so on....

* FPLTAG_QUERY_OVERRUN_SYMBOLS
  Whether a second exported symbol should just overrun the previous one with
  the same name.

* some kind of locale support to make error string appear in the user's
  native language. Amiga has wonderful support (V38+) for this, but how
  should I do this system independent?

* (Amiga) Flush memory caches when the library Expunge() vector is called.
  (Which is done when doing an "avail flush" or when the system is short of
  memory.)

* (Amiga) ARexx library emulator that can call and take advantage of ARexx
  libraries (libraries done to be called from ARexx). Will most likely be
  implemented as a funclib.

* Tokenizer/compiler (under development, will not be implemented until FPL
  is more stable and does not expand this much!).
  
* Make 'char' and 'short' variables and arrays take no more memory than
  they should. (8 resp. 16 bits each.)
  
* Pointers will be implemented. At first only to all the numeric
  variable types that exist today, 'int', 'long', 'char' and 'short'.
  Of course any number of pointer levels. such as "char *********p;".
  
* malloc() and a lot of other clean and pure C library functions
  will be added.
  
* Structures.
  
* Float variables and expressions
  
* Reading SAS/C pragma files to be able to call AmigaDOS shared
  libraries straight from FPL.
  
* FPL symbolic debugger. This will be able to use together with any
  software using FPL! I think I will get someone to help me code this...
  
* Storing all local symbol information in some kind of simulated
  stack to be able to call direct function calls to absolute addresses
  in memory to functions refering to data stored in the FPL program.
  Adding such functions will have to be done in some kind of
  OpenLibrary() way, or like an OS/2 and UNIX shared library function
  access solution (setting up a function that associates function
  identifiers with absolute memory addresses). An already working
  software with FPL interface should be able to call another compiled
  program using this function. No interpreting overhead!!!
  
* Now we should be able to interpret any C program with only a small
  preparation.