JALv2 Homepage

Welcome to the JALv2 homepage. JALv2 is a rewrite of Wouter van Ooijen's famous Just Another Language.

More JAL bits and libraries can be found:

jallib -- libraries for everything: http://code.google.com/p/jallib/
Rob Hamerling's Homepage for all Microchip device files: http://www.robh.nl/
Single Multiple with Constant Calculator: http://www.casadeyork.com/jalv2/cmul.cgi
Original JAL: www.voti.nl/jal/index_1.html
Stef's PIC Pages: http://pic.flappie.nl
Wattystuff: http://www.wattystuff.net/tiki/tiki-index.php?page=PIC+Micro
Bert van Dam Pages: http://www.vandam.tk/
Yahoo Group: http://tech.groups.yahoo.com/group/jallist

Release history:

2.4p -- 3 Sep 2011

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)

Lastest release files (JALv2 2.4o):

README.txt: archive/README.txt
Binaries (win32 and linux with chipdef files): archive/jalv24p.zip
Sources: archive/jalv24psrc.zip