🚀 go-pugleaf

If you have lots of memory to play with for code space, one really
simple solution to try is to make as many of the functions inline
as possible.  Another simple fix that might work with TC (I can't
recall for sure how the compiler treats variable declarations, but
this works on many ANSI C compilers), is to delay declarations until
the block you will use the variable in.  Example:
     Before:                     After:
     void foo(char * s) {        void foo(char * s) {
     int i;                      if (s) {
     if (s) {                      int i;
       i = 1;                      i = 1;
     }                           }
     ...                         ...
     }                           }
 
The example is very simple and brain-dead, but the point is this: since
variables reside (mostly) on the stack, and (generally) live until the
end of the block of their declaration, push them further down into the
nested blocks, particularly if the variables sometimes won't be used.
This way you shorten the average life of data on the stack and sometimes
avoid unused variables ever being created.  With deeply nested recursion
this can make a difference.  However, this will only work if the compiler
doesn't optimize out the declaration to do one single stack adjustment
when the function is entered.
 
ciao for now
   Reid