JalV2 README
============
Included in this archive:

README.txt       : this file

jalv2.pdf        : JALv2 language documentation
jalv2opt.pdf     : JALv2 compiler options
jalv2pragmal.pdf : JALv2 pragmas

jalv2.exe        : Windows 32-bit binary 
jalv2_64.exe     : Windows 64-bit binary 
jalv2-i686       : Linux 32-bit binary
jalv2-x86-64     : Linux 64-bit binary
jalv2-osx        : MacOS 64-bit binary

Compiler issues can be registered and found at: https://github.com/jallib/jalv2compiler/issues

For device files and include files visit: https://github.com/jallib/jallib/tree/master/include/device

History
=======
2.5r9 -- 12 january 2025
         * Fixed issue#33: Constant string does not work for PIC16F883
         * Fixed issue#35: Compiler adds additional but non functioning code due to partial implementation.

2.5r8 -- 16 may 2023
         * Fixed issue#28: Program goes haywire when using look-up tables for fonts and code size becomes bigger than 16k.
         * Fixed issue#30: Const arrays limited to 16k.
		 * Fixed issue#31: Direct accessing an element in an array does not work for const word array and const dword array.
		 
2.5r7 -- 29 january 2023
         * Fixed issue#27: Compiler gives a hardware stack INFINITE message even when the hardware stack is big enough.
		 * Added -Wstringop-overflow=0 compiler flag to compile for MacOS under Virtual Box (thanks to Rob H)

2.5r6 -- 29 october 2021
         * Added 64-bit compiler for MacOS
         * Removed -Werror compiler warnings for Windows 64-bit compiler and MacOS compiler
		 
2.5r5 -- 23 september 2021
         * Fixed issue#19: Compiler generates an assert when an inline procedure is called frequently.
         * Fixed issue#20: Compiler does not accept single character constants.
         * Fixed issue#23: Error in calculation using sdword type.
		 * Fixed issue#24: Error in if condition depending on the order of variable declaration.
		 
2.5r4 -- 26 December 2020 
		 * Fixed Issue#10: JAL Compiler does not process hexadecimal ASCII constant escaping correctly
		 * Fixed Issue#14: Compiler does not handle access to data area correct for some PICs
		                  (compiler pragma 'numbanks' replaced by pragma 'inst') 
		 * Fixed Issue#15: Segmenation fault (fixed with help of Kyle, thanks!)
		 * Fixed all -Werror compiler build warnings for Windows 32-bit compiler plus 32-bit & 64-bit Linux compilers. 
		   Still some -Werror compiler build warnings left for Windows 64-bit compiler.
		 * Fixed Issue#16: Curious warnings (fixed again with help of Kyle, thanks!)
		 
2.5r3 -- 15 september 2019 
         * fixed Issue#8: Compiler generated unexplainable skip-error problem
		 * Created the JAL Windows compilers using a different compiler. This because the 32-bit version of the
		   JAL Windows Compiler created via Visual Studio showed a random - but still correct - behavior in 
		   allocation variables to data space. The newly created JAL Windows compilers (both 32-bit and 64-bit) 
		   were created using the TDM-GCC compiler instead of the Visual Studio (2019) compiler. 
		   This fixes the random behavior of the 32-bit JAL Windows compiler. Both the Linux compilers and Windows
		   compilers now create the exact same output.

2.5r2 -- 12 January 2019
         * fixed Issue#6: Compiler handles index in constant array of records incorrectly 

2.5r1 -- 18 December 2018 
         * fixed Issue#1: Compiler generates incorrect error when using 'whereis()' 
		                  if variable optimization is set to 'yes'
					      Note: This may introduce a slight increase in usage of data space
         * fixed Issue#2: Compiler passes incorrect parameter when adding a constant 
		                  to a variable in combination with inline (thanks Kyle!)
		 * fixed an uninitialized variable problem in the compiler code (effect unknown)
		 
2.5   -- 18 September 2018
         * fixed Issue#4: JAL Compiler jalv2.4q6 does not support new PICs with 64 banks
		                  (new compiler pragma 'numbanks' added) 

-------- 12 September 2018: Kyle York retiring after a job well done,  
                            compiler maintenance taken over by Rob Jansen

2.4q6 -- 25 October 2016
         * create 32 & 64 bit linux files
         * create an ISR pre-amble & save the state variables there
           (allows for some optimization not allowed elsewhere)
         * add and subtract of arrays on 14 bit hybrids failed
         * passing structure pointers into arrays failed

2.4q5 -- 29 December 2015
         * allow whereis() on variables
         * fix whereis() in expressions

2.4q4 -- 25 December 2015
         * fixed large lookup tables
         * fixed data error with inline assembly on hybrid chips
         * fixed error when using lookup tables in expressions on 16 bit chips

2.4q3 -- 27 September 2014
         * fixed exponent adjust when floating multiply/divide by an integral
           power of 2
         * allow exponent adjust when floating multiply/divide by a floating
           power of 2
         * allow negative numbers in exponent adjust
         * fixed some documentation types and examples (thanks Rob!)
         * fixed the float_to_ascii routine to be more useful
         * floating point constant folding was broken

2.4q2 -- 23 January 2014
         * fixed floating point constant 0
         * incorrect movlp_nop usage
         * fixed branching optimizer on conditional branch
         * fixed a bug in pic_multiply_create_fn16

2.4q  -- 13 November 2013
         * don't allow bit offset placement to non-bit variables
           (var BYTE x at y:2)
         * allow `VAR xx AT rec['.'member]['['subscript']']...'  
         * allow non-bit variables to declare byte offets
           (VAR BYTE x AT y + 2)
         * fixed and returned an optimization that reduces code size
           when an empty if block is found:
             IF cond THEN
             END IF
           (thanks Albert!)
         * minor optimization. In this sequence: `movwf val; movf val,w'
           remove the second as redundant. This happens with the `pass
           result in w' and `return result in w' code.
         * an inline assembly move to a constant location did not set
           the data bits correctly (movwf 0x90).
         * assign from constant was completely munged in most cases
         * fixed documentation errors (thanks Rob!)
         * expanded documentation for records
         * minor code generation optimization in equality operators
         * beginning of floating point support
         * fixed an error that caused false positives with branch errors
         * clear out last multiply/divide values when branching
         * always inline some multiplies on the 16 bit cores
         * fixed a problem in binary AND and binary OR when val1 is shared
           and val2 is not *or* dst is in a different bank than val2
         * parsed assignment within a procedure definition (default parameter)
           but default parameters are not allowed. (Rob)
         * re-ordered some optimizations for tigher code (Michael)  
         * detect if a function is declared but not defined
         * when assigning from a pointer of smaller type, the calle to
           extend the sign was missing (Michael)
         * variables manually placed in shared regions must have the SHARED
           flag set (this is internal to the compiler. A variable allocated
           in a shared region will now act correctly. Formerly, the shared
           attribute was missing in this case.)
         * fixed variable allocator  
         * fixed SHARED testing in the event that part, but not all of a
           variable is shared
         * cleaned up new warning from gcc 4.7.2
         * fixed string constant initialization when the string contains an
           embedded '\0'
         * 16 bit inline multiply did not setup indirection correctly  
         * added `asm reset'
         * for _usec_delay, if the PIC temporary varaiable is in shared
           space, emit NOP instead of the datahi/datalo instructions.
         * fixed data skip errors.
         * upcasting a constant value causes incorrect code to be generated
         * fixed MULF (thanks again Michael).
         * fixed a bug in the skip conditional optimizer (thanks again Michael)
         * cmd_analyze() didn't handle assembly properly
         * inline assembly, using the `bank' prefix doesn't work correctly
           on the 14 bit hybrids
         * fixed stack depth reporting  
         * fixed w optimization removals

2.4p  -- 3 Sep 2012
         * added -fastmath which does:
           + create different multiply functions for different sizes. Normally
             one multiply function is created representing the largest
             operands used
           + if a multiply is only used once, inline it
         * as a side effect of above, multiplication with differently sized
           operands has been optimized to only loop enough for the smallest
           operand
         * use native MULWF instruction on 16 bit cores
         * on 16 bit cores, multiplies <= WORD * WORD are always done inline
         * fixed bug in the branchbit optimizer  
         * added, `SHARED,' to the variable definition part of the 
           documentation, and explicitly stated that variable allocations are
           never done from the SHARED regions.
         * a direct inline assembly `goto' or `call' was missed by the
           optimizer
         * broke 16 bit addition/subtraction of different sized variables
         * uncovered latent bug resulting in incorrect multiplication
           creation
         * fixed 16 bit emulator  
         * a bug where a variable, only initialized by assignment to
           the return value of a function, could be incorrectly
           optimized away
         * passing a constant array element into an inline function
           fails
         * an extra division was required when '/' and '%' are used
           next to each other (patch sent by Geoffrey Hausheer)
         * -fastmath, where the destination is the same as one of the
           operands failed (Geoffrey Hausheer)
         * fix a missing multiply due to confusion between 
           pic_multiply_inline16bit and pic_multiply_inline (Geoffrey Hausheer)
         * on 16 bit cores, inline multiplies of 1 x 3 (Geoffrey Hausheer)
         * long-chain if/elsif/... clauses in which one entry is TRUE
           does not correctly skip further entries leading to incorrect
           warnings (Rob)
         * fixed 14 bit hybrid branch optimization (Per)
         * allow string constants to be passed directly to procedures:
           eg: string_out("hello")
         * fixed re-entrancy bug
         * On 16 bit systems ISR entry assumes the saved variables exist
           in bank 0 which is rarely if ever the case
         * implemented `pragma frame' which forces all variables in a procedure
           to be placed together in a single block
         * the source line numbers in the ASM file were off by one.  
           (Arcady)
         * lfsr should use the value instead of the base directly
         * loading an array into a pointer should use the value instead
           of using the variable directly
         * when an array is passed to a function, it should be marked `assigned'
           because the function might assign an element
         * it was possible to define a variable as a flexible array. This should
           only be allowed as parameters.

2.4o  -- 8 May 2011
         * src/jal/build.sh was missing from the source package
         * generalized the PIC optimizer, converted the various
           optimizers (data, branch, movlp, movbsr) to use the
           new code.
         * don't allow variables named built-in functions
           (COUNT/WHEREIS/DEFINED)
         * FOR cexpr... where cexpr is one larger than a variable
           could otherwise hold (eg, 256 for a BYTE variable) will
           now work correctly.
         * FOR var... now works correctly. Formerly, if var was modified
           withing the loop the results could change.
         * Fixed documentation of FOR and the example for tasks.
         * There are times when a parameter to an inline function
           *cannot* be replaced (eg, if a constant is passed to a parameter,
           and the parameter is the master of another variable).
           bugreport_20100920
         * Moved the `# errors, # warnings' output to the very end,
           averting the confusion over how a file with errors or warnings
           will report `0, 0'
         * Added another error -- universal arrays require a constant
           subscript
         * A function returning a multi-bit caused the compiler to crash
         * Introduced records:
           RECORD id IS
             type id0 [ '[' cexpr ']' ][, ...]
             ...
           END RECORD  
         * assign from str[0] fails when str is an array reference  
         * add/subtract on 16 bit cores, where the destination is
           multi-byte and volatile does *not* need to be done in a
           temporary as is needed with the 12/14 bit cores.
         * casting with bits doesn't work correctly  
         * bit indexing of arrays doesn't work correctly
         * fixed report where flexible arrays fail in 2.4o
           (bad fix to assign from str[0])
         * put the compiler version into the log file  
         * The following: DWORD(t & !0xf) caused a compiler failure
         * Expanded the optimization sections of the JALv2 Compiler
           Options and JALv2 PRAGMAs documents.
         * Blindly checking for equality with (-1U) can lead to issues
           on machines with varying integer sizes (for example, a 64-bit
           machine with 32-bit unsigned, but 64-bit size_t)
         * Minor record issues: COUNT(xx.yy) and USING xx.yy did not
           work (xx was never fully dereferenced).
         * Fixed flexible arrays (accidently removed a counter bump)

2.4n  -- 2 June 2010
         * added inline assembly statement mulwf (thanks hawkdavid52)
         * pic_value_is_zero doesn't work with pointers
           (bugreport_20100502)
         * broken arrays passed to functions
           (bugreport_20100523)
         * fixed `asm bank <var>' for 16 bit cores
         * Implicitly created pseudo-variables must be created in the same
           block as the true variable (bugreport_20100506).
         * On the 16 bit cores, if a pseudo-variable is implicitly created,
           the l_main label is somehow deleted causing the generated
           code to not work.
         * minor optimization when using 'case' with bit values.
           assign the bit to a temporary first to avoid shifting/masking
           for each case.
         * 'case 0' on a multi-bit variable fails
         * Added 14 bit hybrid support (thanks Rob!)
         * Fixed the defined() operator to return a bit (as documented)
           so no more warnings or need to compare with 'true'
         * Issue a diagnostic if a value overflows a UNIVERSAL (is > 32 bits)
           (bugreport_20100424)
         * Allow octal constants (0q...)
         * In some circumstances an aliased value would get confused
         * Invalid assert on add with the 14 bit hybrid
         * The logic in UNIVERSAL value overflow was wrong, causing a
           spurious message in edge cases.
         * The MOVLB optimizer was not seeing functions only called
           indirectly.
         * Added '\\' to the language documentation.  

2.4m  -- 26 Dec 2009
         * Fixed documentation for '-include'
         * Added '[no-]asm', '[no-]codfile', '[no-]log', '[no-]lst'
           '[no-]hex'.
         * IF expr THEN END IF caused the compiler to crash
         * Software stack was not being calculated when -no-variable-reuse
           in effect.
         * Directly accessing the 0th element (ch = buf[0]) of a
           pointer caused either an assertion failure or a segfault
         * Fixed COD generation
         * Added ID programming support with PRAGMA ID and
           PRAGMA IDDATA
         * Added 'movlb 0' to the ISR preamble on 16 bit cores
         * Fixed `db' & `dw' on 16 bit cores
         * Fixed PC which was formerly 16 bits, but can be 32 bits
           on the 16 bit cores.
         * Restructed the archive directory layout
         * Converted the three major guides (jalv2, jalv2opt, jalv2pragma)
           to docbook format in the hopes that this will help me keep
           everything up to date.
         * EEPROM data on the 16 bit cores started at location 0
           ('cause the variable created was only 16 bits, whereas
           eeprom on the 16 bit cores starts higher than 0xffff).
         * a re-entrant function taking an array parameter caused an
           invalid assertion failure
         * in some cases a SEGFAULT would occur when passing an
           array parameter
         * turned on const comparison warnings (when a comparison 
           is always TRUE or FALSE)
         * turned on overflow warnings (when a universal value is
           used that does not fit with its counterpart)
         * fixed COD file generation
         * check function parameters for type & overflow
         * comparing a single bit variable and a single bit constant
           does not work if -no-expr_reduce is set.
         * emit an error if an attempt is made to create a bit
           array (bit arrays are not supported).
         * added `pragma bootloader bloader' and `pragma bootloader loader18'
         * fixed `pramga' --> `pragma' in the inline error message
         * fixed the TRIS parameters in the online manual
         * added `addwfc' to inline assembly
         * fixed aliasing at different block levels (eg, an alias
           in a procedure referencing a global)

2.4l  --  7 Aug 2009
         * -const-detect ordered the constant big endian instead
           if little endian
         * 16 bit code generation fixed to match mpasm (namely,
           the PC is shown in bytes not words)
         * Added inline assembly: reset
         * A procedure taking a volatile parameter and also
           re-entrant would cause an assert()
         * Changed re-rentrant entry/exit to *not* use stkpush/pop  
         * A re-entrant *function's* return value was over-written
           if there were any non-volatile OUT paramters
         * added a numeric option to -loader18 to set the offset
           Examples:
             -loader18      : starts the code at 2048
             -loader18 4096 : starts the code a 4096
         * Added units to jalpragm.txt to explain that for
           `PRAGMA CODE size', size is in WORDs for 12/14 bit
           cores, and BYTEs for 16 bit cores (thanks MicroChip!).
           This follows from the second bullet above.
         * Included inclue assembly opcodes: rlcf/rlncf/rrcf/rrncf  
         * Fixed 16-bit code to use rrcf instead of rrf
         * Make sure variables don't span banks even if the banks
           are contiguous (a problem seen on 16 bit cores).
         * `ALIAS...IS' should work even if the underlying variable
           is only a pseudo-variable
         * Output of `Code area' was screwy on 16 bit cores  
         * Changed `pragma code' on the 18 series to use bytes instead
           of words

2.4k  -- 08 May 2009
         * very minor optimization for bit value return
         * B00059: compiler generated 'put for bits doesn't work
         * B00058: compiler generated 'put doesn't work
         * B00057: cannot pass volatile bit out parameter
         * fixed jalpragm.txt to match the code
         * B00060: cannot assign to a multi-bit on 16 bit cores
         * cleaned up signed/unsigned and truncation warnings
         * B00061: 16 bit cores should save TBLPTR/TABLAT on ISR
         * B00039: FSR should be saved if used in an ISR
         * B00063: IF cond THEN...generates bad code in some cases
         * databits aren't set correctly on indirectly called functions
         * if an indirect function used no data space *and* called other
           functions that *did* use data space, the space for those data
           would not be correctly allocated.

2.4j  -- 12 Mar 2009
         * B00052: Allow any characters in an include filename except
           ';' and '--'. Also, the filename may neither begin
           nor end with a space.
         * B00053: Added _warn, _error, and _debug (Thanks Sebastien!)  
         * B00054: Fixed `pragma error' to display any text on the line after
           the pragma
         * B00050: If `-loader18' was used, the code wouldn't skip over
           any preamble.
         * B00051: `const blah = 0x400; var word x at blah' failed miserably
         * passing an array element into an inline procedure failed
           (always only passed the first element of the array)
         * B00056: added 'tblrd' and 'tblwr' to inline assembly  
         * fixed comparing signed constants
         * in some instances assigning a negative number to a signed variable
           that can clearly contain it resulted in signed/unsigned mismatch
         * Removed OS/2 Makefiles
         * Issue warning when multi-byte string is used in an expression
           (x = "abc" * 2 --> only 'a' is used)
         * *Always* set the 2nd high bit when passing constant arrays  

2.4i  -- 01 Dec 2008
         * Adding suffix to displayed version (2.4i)
         * Inline function return wasn't being handled correctly
         * Inline function parameters that are not used directly
           (only used via another variable placed `at' the parameter)
           weren't working correctly.
         * Compiler directives (``if cexpr...'') incorrectly opened
           a new block
         * Passing an array element into an inlined function
           doesn't work (drops the array index)
         * Occasionally the compiler would spit out a bunch
           of nuisance messages due to some orphaned list elements
         * Fixed documentation (target_clock, not _target_clock)

2.4h  -- 15 Sept 2008
         * fixed all warnings with '-W -Wall'
         * added makefiles from Rob
         * added `pragma speed' and `pragma size'
         * fixed `movlb' generation
         * fixed HEX generation on 16 bit cores
         * allow TRIS 5 - 9 (formerly was 5 - 7)
         * introduced pragma nostack
         * return zero on success, system dependent non-zero on failure
         * minimize the amount of pic_state saved in an interrupt
         * changed to new makefile

2.4g  -- ?? June 2008
         * using `AT cexpr' instead of `AT var' doesn't work
           with function parameters

2.4f  --  (unreleased)
         * B00042 : Inline assembly using conditional operations might get
                    optimized away
         * B00041 : inlining a function or procedure that takes a
                    volatile parameter results in `invalid operation'

2.4e  -- 22 May 2008
         * B00040 : x - C, where x is 2-bytes doesn't work if the LSB of C
                    is 0, and C >= x

2.4d  --  5 May 2008
         * B00036 : Inline parameters that are specifically located
                    are incorrectly replaced with locals.
         * B00037 : Division fails due to invalid assumptions about
                    subtraction (gordon)
         * B00038 : multi-bit assignment is not shifting the result
                    into the correct bits

2.4c  --  4 April 2008
         * optimized `x + -1' and `x - -1'
         * crash: x = x - x
         * optimized `y = x + x' --> y = x << 1
         * optimized 12/14 bit addition and subtraction
         * optimized shifts
         * optimized decrement
         * fixed 16 bit lookup table generation (thanks diego)
         * added jalpragm.txt to the distribution
         * B00035: compiler crashes with lookup tables on 16 bit cores

2.4b  -- 17 March 2008
         * B00028: "opt pass has gone infinite"
         * B00029: `forever loop end loop' hangs compiler
         * B00031: inline assembly might incorrectly use bank
                   and page operators on 16 bit cores
         * B00032: `exit loop' request for all loop types
         * B00033: `repeat...until' construct
         
2.4a  --  6 March 2008
         * B00027 -- wrong registers used when receiving the result 
                     of a function in an inlined function (gordon)
         * B00026 -- Loop optimization bug with nested IFs (wouter)
         * B00024 -- Compiler is re-using state variables that are in 
                     use in some cases (joep)
         * Minor FOR loop optimization -- if we know the loop will
           be executed at least once (controlling expression is
           constant > 0), no need to initially jump over the body.
2.4   -- 23 January 2008
         * initial 16 bit support
         * added '-loader18' to support bootloaders on the 16 bit cores
         * fixed B00022 (multiple files on the command line crash the compiler)
         * fixed B00015 (temporary used in FOR loops overwritten)
         * comments on `CASE...OF...'' lines now show in resulting .asm file
         * ORG is twice what is should be on the 12/14 bit cores
           (Thanks Gordon)
         * Only 1/2 of each _fuse is put into the HEX file
           (Thanks Bert)
         * Fixed infinite recursion in the BSR analyzer (Thanks Gordon)
         * Fixed c18c* chipdef files, and added some 18f* ones.
         * Variables used in an interrupt procedure were allocated twice
         * Volatile variables used in an interrupt procedure were allocated
           multiple times.
         * Incorrect config bits in the HEX file for the 18 series  
         * fixed B00023 (aliased variables in inline functions don't work)
         * fixed B00021 (cannot alias pseudo-variables)

2.2.4 -- 23 June 2007
         * fixed -bloader (thanks N.Muto)
         * fixed flexible strings (thanks N.Muto)
         * fixed spurious `requires boolean expression' (thanks Bert)
         * fixed multi-byte decrement
         * fixed const shift right (ex, 5 >> x) and shift right
           arithmetic
         * added `use ./jalv2 --help' for help if the compiler
           is run without any source file (thanks Sunish)
         * added "/help" "/h" and "/?" as aliases for --help  

2.2.3 -- 20 June 2007
         * flexible array support
           Flexible arrays are a special array format when passing
           parameters to a procedure or function, defined as follows:

             PROCEDURE test_proc(BYTE IN str[]) IS
               ...blah...
             END PROCEDURE

           Now, str is used just like any other array (the COUNT()
           operator still works). The difference is arrays of any
           length can be passed in, for example:

           BYTE       str1[] = "this is a test"
           CONST BYTE str2[] = "another test"

           test_proc(str1)
           test_proc(str2)

           One caveat here is since the array is passed by reference,
           not value, any modifications to the array will show up.
           If a CONST is passed into a procedure that modifies the
           array, an error will be generated, but unfortunately will
           be non-obvious.

         * fixed software stack generation
         * fixed variable allocator bug (which made the amount of
           data used jump substantially in some situations).
         * changed variable names to avoid collisions
         * removed 'addlw' and 'sublw' (for 12 bit support)
         * added a new compiler flag: '-include {name}' which is
           an implicit `include name' before parsing the program
         * any source path to the file being compiled is included
           as the first include path
         * multiple include directives (and paths) allowed
         * universal types now transformed to the type of the intializer
         * optimized multi-bit assignment
         * looped shift-right in some conditions instead of
           generating a bunch of code
         * warn if an IF or WHILE expression isn't boolean
         * An unknown token in a include file now generates an error
         * Constant expressions are now assigned the correct type
           (instead of universal)
         * Now generate '.COD' file for debugging information
         * Include files for MPLAB integration

2.2.2 -- 10 May 2007
         * complete 12 & 14 bit support
           nb: division on the 12 bit is sketchy due to memory requirements
         * 12 bit emulator support
         * chipdef/16f505.jal
         * new pragmas *required* by all chips:
           pragma target cpu pic_xxx
             define the target cpu. pic_xxx already defined in chipdef.jal
           pragma target bank xxx
             define the target bank size (14 bit = 0x80, 12 bit = 0x20)
           pragma target page xxx
             define the target page size (14 bit = 0x0800, 12 bit = 0x0200)
         * fixed bugs in:
             arithmetic shift right
             x && 1 -- code generation error
             assign to bit

2.2.1 --  7 May 2007
         * A rare bug in the databit optimization code can cause the
           compiler to crash due to infinite recursion
         * Initial 12 bit support

2.2   --  2 May 2007 -- bug fix release

2.1.4 -- 25 April 2007
         * fixed a rare variable allocation bug which would cause two
           active variables to share the same memory location
         * minor change in the assembly output to show the procedure
           in which a variable is defined as part of the EQU
         * fixed -no-variable-reuse  

2.1.3 -- 19 April 2007
         * asm generation in two cases would set the destination
           for movwf causing MPLAB to barf
         * assign to bit broken if the offset is greater than 0
         * better universal type support
         * check for subscript out of range (when using constant subscripts)
         * if the left side of a rotate right is signed, the operation
           will be an arithmetic (sign preserving) shift
         * smarter warnings about signed/unsigned and truncation when
           dealing with universal types

2.1.2 -- 31 March 2006
         * IMPORTANT! Renamed _pic_add_accum to _pic_accum. This is
           *required* for add and subtract and must either be placed
           at the same offset in each bank or, preferably, in the shared
           area!
         * complete rewrite of the operator code including test generator
         * added an (incomplete) emulator to assist in checking the operators
           "-emu" : run the emulator. This will show each instruction as it's
           run unless "-quiet" is also set.
         * new instruction:
             ASSERT expr
           will stop the emulator if expr is not TRUE
         * minor optimization when returning the value of a function  
         * adding preliminary casting
             type [* sz] ( expr )
         * added patches suggested by Mark Gross (64-bit clean,
           fixes to the RICK_PIC code generator)
           
2.1   -- 27 November 2006 fixes:
         * variables were erroneously marked as either unused or unassigned
           in certain circumstances causing the assignment to be silently 
           dropped
         * In some circumstances a re-entrant call would not be setup 
           correctly (specifically, if an IN variable is not marked auto)
         * empty parameter list not allowed in call (aka, `something' works,
           whereas `something()' fails).
         * added '-screamer' bootloader option  

2.0.7 -- 12 October 2006 fixes:
         * Allow string in `pragma eedata' (pragma eedata "this is a test")
         * new keyword : defined(), returns 1 if a label is defined, 0 if not
           IF DEFINED(var) THEN ... END IF
         * new constant : JAL_VERSION holds the version value
           major * 1000 + minor (currently 2_001)
         * assembly output of `movfw' was wrong (no negative effect other
           than not being able to compile with MPLAB)

2.0.6 -- 27 September 2006 fixes:
         * long table preamble was wrong -- when incrementing pclath
           on overflow, the result went into W instead of into pclath
           causing only the first part of the table to print
         * assembler blocks were completely ignored

2.0.5 -- 25 September 2006 fixes:
         * fixed the clear variable startup code
         * added long lookup table support
         * allow `var +/- x' in inline assembly
         * allow a bunch of pre-defined macros in inline assembly
           (see README.asm)
         * allow 'db,' 'dw,' 'ds' in inline assembly
         * new keyword : whereis (see the example in README.asm)
         * all command line options that effect compilation can be
           over-ridden with pragmas (pragmas take precedence)
         * new pragma : pragma fast-interrupt
           fast-interrupt will save & restore W, STATUS, and PCLATH
           but nothing else. There are no restrictions, but logically
           the interrupt procedure should be completely inline
           assembly to prevent corruption of _pic_state
         * hex in string didn't work (ex, "\xff"  

2.0.4 -- 16 August 2006 fixes:
         * changed some branch optimizations
         * fixed W load optimization for volatile variables
         * changed const detection algorithm
         * fixed CASE statement
         * changed lookup table and pre-user order to guarantee lookup
           tables don't span 256 byte boundaries & minimize the amount of
           code not subject to optimization
         * added compiler name & version, and CLI used to compile to the
           top of the assembly file to aid debugging

2.0.3  -- 4 August 2006 fixes:
         * `a - C', with C a constant failed (became `a + C')
         * added W load optimization (see -redundant-reduce)
         * fixed lookup tables with multi-byte elements
         * changed error if a call is made with too many or too few parameters

2.0.2  -- 3 August 2006 fixes:
         * LOOP construct changed -- instead of
             while var < expr
           use
             while var != expr

         * Added a warning if the control variable in a LOOP is changed
         * functions returning BITs were broken
         * don't generate code when function return values are ignored
           (was assigning to a temporary)
         * promotion from bit to byte wasn't handled correctly
         * assigning from a single bit to an array didn't setup the array
           correctly
         * compiler crash if all space from the first bank was allocated  
         * negated universal constants weren't promoted correctly  
         * branchhi_[set|clr] were omitted on processors with 4K or less
           code memory which broken the assembly file for delays
         * changed delay code to guarantee the delay is *at least* the
           amount requested (occasionally, it could be one cycle short)
         * some work on changing the errors to be more useful
         * rewrote the binary add code generator
         * created `jalopts.txt' which explains the compiler options
         * started new naming convention
           major "." minor "." beta

2.00  -- 31 July 2006 fixes:
         * procedure calls wouldn't pass const parameters except in W
         * data area definition in c16f877.jal and c16f876.jal were wrong
           (missing 0x10 bytes in banks 2 & 3)
         * off by one error in the variable allocation functions caused
           one byte to always remain unallocated in the bank

2.00  -- 29 July 2006 fixes:
         * !0x80 wasn't properly promoted to 2 bytes
         * minor bit optimization
             x = x | 0x80  --> bsf x,7
             x = x & !0x80 --> bcf x,7
         * added compiler option '-const-detect' which enables an aggressive
           constant detection optimizer in the compiler. This looks for
           variables that are either only assigned once, or are always 
           assigned the same value and marks them const
         * added compiler option '-temp-reduce' which enables the compiler to
           optimize space used by temporary variables in complex expressions
         * added "PRAGMA INLINE" which forces a procedure or function to be
           inlined
         * DWORD lookup tables were not being created correctly
         * binary OR with a constant and src & dst unequal failed
         * watcom C makefile changes courtesy of Mat Nieuwenhoven
         * fixed PIC optimizer bug to not remove anything that follows a 
           conditional operator
         * changed Makefiles so `make depend' would only include files local 
           to this project
         * removed pjal references from README.txt (starting on 8 June '06)
         * added a new construct:

           BLOCK
             statement(s)
           END BLOCK

           Any variables defined in the block are local to that block
           (the flow control constructs: IF, FOR, WHILE, et.al.  already use 
           an implied block, this just allows for an explicit one). This 
           identical to BEGIN...END in PASCAL but follows more along the
           lines of JAL syntax

         * added a new flow control construct:

           CASE expr OF
             cexpr["," cexpr2...] ":" statement
             ...
             [OTHERWISE] statement
           END CASE

           Again, this is a JAL-ized version from PASCAL. Currently the code
           generated is almost identical to using a bunch of 
           IF/ELSIF/ELSE/END IF statements but one day I might make it a
           jump table.
         * expanded pseudo variables to allow an index parameter (creating
           virtual arrays)
         * removed some bad `const's from the source courtesy of 
           Daniel Serpell
         * cleaned up some compiler warnings

2.00  --  8 June 2006 fixes:
         * various chipdef file fixes (thanks Stef & Vasille)
         * added _usec_delay

2.00  -- 24 May 2006 fixes:
         * removed implicit assumption that shifted values are always
           a power of 2
         * changes how out of range shifts worked. Previously, given a 32
           bit value x, the result of:
              x >> 35
           was to set x to 0, whereas the result of:
              x >> y (where y is 35)
           resulted in:
              x >> (y & 31)
           This has been changed -- if a shift is out of range, the result
           is x.
         * minor Makefile corrections
         * unused volatile variables were being allocated
         * the not operator on single bit values failed if the two
           values resided in different banks
         * forced all volatile variables to be allocated first. this means
           that volatile variables local to a procedure will be considered
           static (the space won't be re-used by other variables, and recursive
           functions will not get a separate copy).
         * added '-clear' compiler option which clears all user data areas
           on program entry (note: volatile, user-placed variables, and
           unused data areas are not cleared).
         * allow "\0" embedded in strings
         * use C style string initialization, eg:
             var byte string[] = "abc" "def" "ghi"
           is the same as
             var byte string[] = "abcdefghi"

2.00  -- 15 May 2006 fixes:
         * right shift multi-byte variable by a constant >= 8 failed
         * right shift where the destination and second value are the
           same failed
         * variable places AT an element of an array will always go to
           the zeroth element
         * multi-byte signed constants weren't working correctly  

2.00  --  3 May 2006 fixes:
         * fixed shift by non-constant 0
         * fixed shift right from a larger value to a smaller
         * multiple fuse words weren't being written to the HEX file
         * bit temporaries would occasionally end up with the same name
         * bit temporary variables might not be allocated

2.00  -- 19 April 2006 fixes:
         * extended the `pragma target fuses' to require a config number
           (starting at 0). For example:
           pragma target fuses 0 1234
         * an empty ELSIF clause would skip the wrong statement
         * assignment to a constant array (aka lookup table) caused
           the compiler to crash
         * shift produced incorrect code
         * arguments to a function marked recursive whose parameters are
           placed (for example, var byte x at _port_b_buffer) wouldn't
           work correctly

2.00  -- 17 March 2006 fixes:
         * a function called indirectly with a BYTE parameter was incorrectly
           passing the parameter in W
         * fixed `x = x + 1`  

2.00  -- 16 March 2006 fixes:
         * a function called both directly and indirectly would not work
           correctly when called directly

0.95  -- 16 March 2006 fixes:
         * word = word - 100 incorrectly turned into word = word + 156
           (100, a byte, was incorrectly negated into a byte instead
           of a word).
         * bit AND/OR/XOR fail miserably if the values are not in the
           same bank (val1 & val2 in different banks always fail,
           sometimes if dst isn't in the same bank as val1 & val2 it
           also fails).
         * allow multiple config words (see c16f8x.jal)
         * fixed SEGFAULT on missing END IF
         * fixed A + A (was doing A + 1 instead of A << 1)
         * change "A = B + A" to "A + A + B"
         * if a constant expression is used in a FOR statement, and
           a variable with the USING clause, if the variable cannot
           hold the constant expression value an error is generated
         * changed name to `jal 2.0'  

0.90  --  2 March 2006 fixes:
         * I broke variable promotion in the last build when the same
           variable is used as a destination.

0.90  --  1 March 2006 fixes:
         * include files not ending in an end of line have one appended.
         * fixed HEX code generation for btfsc/btfss
         * overlapping variables (using 'at') might be incorrectly
           optimized away, causing problems with external assembly.
         * fixed right shifting from a larger type to a smaller
         * the results of binary expressions using unnamed or universal 
           constants take on the type of the other operand (fixes the
           x < 0 problem)

0.90  -- 24 February 2006 fixes:
         * aliases from a smaller name to a larger one cause page faults
         * page and databits fail after a CALL

0.90  -- 23 February 2006 fixes:
         * multiply & divide now work reliably when different sizes are
           used
         * `hardware stack overflow' is now an error. The compiler switch
           `-warn-stack-overflow' changes this to a warning
         * if a procedure is only called by an indirect procedure its
           variables were not being allocated
         * if an alias was used against something with a 'get or 'put 
           procedure, the proper 'get or 'put procedure wouldn't be found
         * target_chip *must* now be defined using `pragma target chip ...'
           this information is passed to the code generator to be included
           at the top of the assembly file
         * fixed two mistakes in c16f87x.jal
         * added check to `is' clause to make sure the alias has a compatible
           type
         * fixed HEX code generation for arrays  
         * turned on TASK functions -- start and suspend
         
0.90  --  1 February 2006 fixes:
         * the expression `x - x' wasn't optimized out at the p-code layer
           causing the PIC generator to fail
         * cannot use an array element in an `at' expression  
         * removed some errant printf's() used for debugging
         * cannot use an array element in asm instructions
         * state not saved correctly on ISR entry/exit
         * arrays can be passed into functions 
         * arrays can be used in assignments
         * arrays and constants don't need explicit sizes, eg
           var byte x[] = { 1, 2, 3, 4, 5 }
           var byte x[] = "this is a test"
         * new keyword, COUNT(x), returns the number of elements in array x,
           and can be used anywhere a constant is expected. For example:
             var byte x[] = "hello"
             var word y[count(x)]
         * procedure(byte in out x) now works correctly if x has 'put
           procedure
         * fixed resolving like-named variables and pseudo functions  
0.90  -- 19 January 2006 fixes:
         * an OUT parameter can now be either a 'put procedure or an array
           element
         * UNIVERSAL constants work as expected
         * ``if (array(n)) then...'' works
         * the compiler version is written when `pjal' is executed by itself

0.90  --  1 January 2006 fixes:
         * call to retlw changes to movlw (was deleted)
         * intrinsicly generate 'get & 'put routines if necessary
         * lookup tables were crossing 256 byte boundaries
         * assembly output wasn't always correct
         * changed to arithmetic shift right for signed numbers
         * allow inline assembly jump or call to constant
         * fixed multi-byte shifting
         * fixed multi-byte andb/orb/xorb
         * partially fixed recursive functions
         
0.90  -- 24 December 2005 fixes:
         * fixed x = y >> # where x is volatile

0.90  -- 21 December 2005 fixes:
         * fixed compiler directives; anything past ``IF 0 THEN...''
           is now skipped entirely (no processing, so it can be used
           for block comments)
         * unless the debug flag is set, the assembly file will stop
           at the `end' statement
         * added `-nocodegen' argument. When this is present no assembly
           code is generated
         * added `-Wdirectives' argument. When this is present any compiler
           directives found will show up as warnings
         * fixed bit constants, for example:
           CONST dummy = true
           will now create a bit constant instead of a byte constant
         * changed the variable allocation such that
           PRAGMA TARGET CHIP x
           and
           CONST TARGET_CHIP x
           create the same type of variable.
         * the code size displayed was off by 1 (it was showing the greatest
           value of the PC, which ignored the last instruction).

0.90  -- 15 December 2005 fixes:
         * in some situations parameters would be incorrectly marked
           CONST

0.90  -- 14 December 2005 fixes:
         * a bug in bit-variable allocation could cause unexpected
           aliasing
         * and/or/xor from single bit to single bit where the destination
           and one of the operands are the same would fail
         * and/or/xor from single bit to single bit logic was restructured
         * temporary reduction was broken during the code restructure
           so it has been removed for the time being

0.90  --  7 December 2005 fixes:
         * return value in w doesn't work except in the explicit
           case (eg, return x)
         * when a value is returned in w, it should be the first
           one assigned as the other assignments might destroy the
           contents of W

0.90  -- 28 November 2005 fixes:
         * bit inversion on assign bit --> bit (non-volatile, the volatile
           case was handled in the 23 November fix)
         * an unassigned temporary was being used in certain function calls
           causing odd results
         * introduced boolean temporaries and changed all relationals
           to return a boolean

0.90  -- 26 November 2005 fixes:
         * bugs in branch optimizer caused the produced code size
           to explode after certain boundaries, and also to fail
           after about 4K
         * another bug in the branch optimizer would fail if a label
           ended up on a 2K boundary
         * constant sign extension logic was wrong
         * equality operator with constants was wrong in some cases
         * arrays with multi-byte entries were wrong (offset was added
           to _ind)
         * added branch[hi|lo]_nop when debugging so the assembly file
           will compile

0.90  -- 23 November 2005 fixes:
         * unary bit operators now work as expected
         * bit inversion on assign bit --> bit

0.90  -- 21 November 2005 fixes:
         * fixed a branch bit optimizer bug
         * added `signed/unsigned mismatch'' and ``assignment to smaller
           type'' warnings
         * added `-Wno-conversion' and `-Wno-truncate' to turn off the
           above warnings
         * added `errorlevel -306' to suppress the page boundary warnings
           in MPASM
         * added `errorlevel -302' to suppress the `access outside of bank
           0'' warnings in MPASM
         * fixed annoying bit where if the first statement after an include
           had an error, the error would be reported at the end of the
           included file
         * fixed an error in the increment & decrement operators where
           the statement, ``return x+1'' would try to store the result at
           location 0

0.90  -- 19 November 2005 fixes:
         * Variables in procedures called in interrupt context were not
           allocated correctly
         * The relational inverses were incorrect in some paths
         * The constant 0 wasn't handled correctly which caused !0
           to also be 0.

0.90  -- 17 November 2005 fixes:
         * assign to a volatile single bit inverted the result
         * incorrect use of free() could have caused memory corruption
           (but for some reason didn't)
         * passing parameters to a routine that doesn't take any
           parameters caused the compiler to crash

0.90  -- 14 November 2005 fixes:
         * fixed relationals used in expressions (y = x <= z)
         * minor optimization when the destination is a non-volatile bit
         * fixed equalities used in expressions (y = x == z)
         * minor optimization when the destination is a non-volatile bit
         * fixed a bug in the pic branch optimizer -- infinite loops were
           not detected causing an infinite loop in the optimizer
         * fixed a bug in the pic conditional branch code -- in addition
           to the relational and equality operators the logical, not,
           and complement operators should also be allowed.
         * in JAL, '!' is bitwise complement, not logical  
         * if a variable is assigned but not used, do not eliminate it
           if it has a master and the master is used

0.90  -- 12 November 2005 fixes:
         * an alias parameter whose master was volatile in a 'put routine 
           didn't compiler correctly
         * did not have the correct logic for relational inverse
         * the FOR loop didn't work correctly

0.90  --  9 November 2005 fixes:
         * shadowing a byte parameter wasn't working
         * added the `using' clause I claim to support in the FOR loop
         * fixed a bug in array indexing
         * optimized multiply & divide -- if the same parameter are used
           the function is not called (since the result will be the same)
           for example:
               x = n % 10
               y = n / 10
           since the result of (n/10) is still in the accumulators, this
           becomes
               x = n % 10
               y = pic_div_quotient
         * fixed a bug in the relational operators
         * fixed a bug in the signed relational operators
         * allow `pragma' in assembler blocks
         * allow labels on lines by themselves in assembler blocks
         * fixed three indirect function bugs
           * if a parameter to an 'put function is never used, don't
             try to assign to it
           * always assume an indirect function is used if called
             indirectly
           * assign function --> function ptr wasn't working
         * work on stack depth calculations ; currently assumes that
           an indirect function does not call any other functions
         * volatile is now inherited. for example:
           ---
           var volatile byte port_b_direction at {0x86, 0x186}
           var bit pin_b0_direction at port_b_direction : 0

           pin_b0_direction = low
           ---

           formerly, pin_b0_direction would be optimized out because
           it is never used. Now, since it refers to port_b_direction
           and port_b_direction is volatile, it is not optimized away.
         * changed `-nopcode' to `-pcode'
         * reduced code size for relational branching
         * fixed assembly from constant lookup tables
         * fixed passing bits or arrays in W
         * fixed multi-byte decrement
         * fixed signed divide
         * added identities:
           x / -1 = -x
           x * -1 = -x
         * fixed multi-byte lookup table assignments
         * untyped constants now use the smallest possible representation

0.90  --  2 November 2005 fixes:
         * fixed bit constants
         * added some more optimizations
            * x == 0 --> !x
            * x != 0 --> !!x
            * x == 1, x a single bit --> !!x
            * x != 1, x a single bit -->  !x
         * fixed a bug in the conditional branch ahead optimization:
            goto [true|false] val lbl1
            goto lbl2
            lbl1:
            -->
            goto [false|true] val lbl2
         * fixed a cosmetic bug where branchhi_clr was changed to 
           branchlo_clr when unneeded but kept
         * fixed a bug where the internal program counter was incorrect
           causing the resulting HEX file to be wrong
         * added another optimization
           * x ^ 255 --> comf x
         * fixed a bug translating branchlo_[set|clr] from inline assembly to 
           pic asm  
         * fixed indirect calls (volatile parameters)  
         * added `-long_start' flag to force the first 3 instructions to be a
           long jump to the program start. This is needed by some bootloaders.
           

0.90  -- 31 October 2005 fixes:
         * ``if (!x) then ...'' would compile the same as ``if (x) then...''
         * the inline-assembly function, ``asm bank movfw x'' would always
            set the high & low bank bits
         * added a couple of branch optimizations:
            * _temp = !x
              branch [true|false] _temp, ...
              --> branch [false|true] x, ...
            * _temp = !!x
              branch [true|false] _temp, ...
              --> branch [true|false] x, ...
         * fixed NOT and LOGICAL operators      
         * fixed `pragma keep [bank|data]'
         * fixed `a = b +/- c', where c is a variable
         * fixed `a = b +/- c', where c is a constant

0.90  -- Initial release -- 30 October 2005

