Ravi Alpha Release 0.6 - Windows and Ubuntu 64-bit

This release contains mostly bug fixes and following changes:

• The Windows build is now against LLVM 3.7 (latest snapshot).
• The Ubuntu Linux build is now against LLVM 3.6.1.
• This release contains an experimental feature - array slices. A slice allows a portion of a Ravi array to be treated as if it is an array - this allows efficient access to the underlying array elements. Following new functions are available:

  • table.intarray(num_elements, initial_value) - creates an integer array of specified size, and initializes with initial value. The return type is integer[]

  • table.numarray(num_elements, initial_value) - creates an number array of specified size, and initializes with initial value. The return type is number[]

  • table.slice(array, start_index, num_elements) - creates a slice from an existing array - allowing efficient access to the underlying array elements.

    The functions are currently part of the table module but this may change in future.
    For an example use of these functions please see the matmul1.ravi benchmark program in the repository. Note that this feature is highly experimental and not very well tested.

• For performance reasons the Ravi array data structure has an extra element at index 0 - this element is not counted by the length operator nor is it visible when using pairs() and ipairs() to iterate over the array. However this element can be accessed directly by using index 0. Note that slices also allow access to the element at index 0 - this can have unexpected results so the recommended usage is to use array indices 1 to n as in Lua.
• This release also has an alternative JIT implementation using libgccjit, but this is still work in progress, hence binaries are not released yet. Please refer to Ravi documentation for further details and status of this implementation.

Ravi Alpha Release 0.5 - Windows and Ubuntu 64-bit

This release has following changes:

• Performance of JITed code has improved due to addition of a missing DataLayout pass in the JIT compilation phase.
• In auto mode the JIT compiler is now used if the function contains a fornum loop, or is larger than 150 Lua instructions or is executed more than 50 times. The last two parameters can be changed by the ravi.auto() function.
• A fornum loop that uses an integer index with known positive step (i.e. literal or default) uses a more optimized code.
• This release has been modified to ensure that JITed code is only executed within the Lua main thread; this change allows coroutines to work albeit in interpreted mode
• This version is also being built and tested on MAC OSX (Yosemite) 64-bit - although a binary for this OS is not included, so you will need to build from source.

Known issue:

• For reasons still to be determined, on Windows a call to pcall() can sometimes fail with an exception about invalid or misaligned stack (see issue 30).

This release includes a Ubuntu binary.
Note that on Ubuntu you need to set PATH and LD_LIBRARY_PATH variables for the shared library to be found.

Please note following limitations in this release:

1. JIT compilation not yet supported for bitwise operations, and for operations involving typed up-values.
2. The Lua C API has not been fully tested for Ravi extensions so please do not use the C API yet.
3. Coroutines are executed in interpreted mode (only main thread can execute JITed code).
4. Debug API not supported for JITed code.
5. Tail calls handled as normal calls - so will cause stack overflow for recursive calls (max 110 levels).
6. Note that by default JIT compilation is not enabled - refer see documentation referred to below.
7. Expect lots of bugs.
8. Please read the latest documentation (http://the-ravi-programming-language.readthedocs.org/en/latest/) for details of what works and what doesn't , and how to enable JIT compilation

Ravi Alpha Release 0.4 - Windows and Ubuntu 64-bit

This release has a fixes for following bug:

• Issue 26 - upvalues can subvert static types
• Issue 25 - pairs() does not work with Ravi arrays
• Issue 24 - ipairs() does not work with Ravi arrays
• Issue 9 - Lua C API handing of Ravi arrays - initial work on this

This release includes a Ubuntu binary.
Note that on Ubuntu you need to set PATH and LD_LIBRARY_PATH variables for the shared library to be found.

Please note following limitations in this release:

1. JIT compilation not yet supported for bitwise operations
2. The Lua C API has not been fully tested for Ravi extensions so please do not use the C API yet.
3. Coroutines not supported in JIT mode
4. Debug API not supported for JITed code
5. Tail calls handled as normal calls - so will cause stack overflow for recursive calls (max 110 levels)
6. Note that by default JIT compilation is not enabled - refer see documentation referred to below.
7. Expect lots of bugs
8. Please read the latest documentation (http://the-ravi-programming-language.readthedocs.org/en/latest/) for details of what works and what doesn't , and how to enable JIT compilation

Ravi Alpha Release 0.3 - Windows 64-bit

This release has a fix for following bug:

• Issue 23 - the JIT compilation of OP_RAVI_TOARRAYI, OP_RAVI_TOARRAYF, OP_RAVI_MOVEAI and OP_RAVI_MOVEAF had bugs that caused these opcodes to always fail

Please note following limitations in this release:

1. JIT compilation not yet supported for bitwise operations
2. The Lua C API has not been tested for Ravi extensions so please do not use the C API yet.
3. Coroutines not supported in JIT mode
4. Debug API not supported for JITed code
5. Tail calls handled as normal calls - so will cause stack overflow for recursive calls (max 110 levels)
6. Expect lots of bugs
7. Please read the latest documentation (http://the-ravi-programming-language.readthedocs.org/en/latest/) for details of what works and what doesn't , and how to enable JIT compilation
8. Note that by default JIT compilation is not enabled - refer to above mentioned documentation.
9. pairs() and ipairs() do not work on Ravi arrays yet.
10. Up-values can be used to subvert the type of a local variable with static typing

Ravi Alpha Release 0.2 - Windows 64-bit

Second alpha release of Ravi.

This release has fixes for following issues:

• ravi.compile(), ravi.iscompiled(), ravi.dumplua() and ravi.dumpllvm() cause a crash if the argument is a C function

Please note following limitations in this release:

1. JIT compilation not yet supported for bitwise operations
2. The Lua C API has not been tested for Ravi extensions so please do not use the C API yet
3. Coroutines not supported in JIT mode
4. Debug API not supported for JITed code
5. Tail calls handled as normal calls - so will cause stack overflow for recursive calls (max 110 levels)
6. Expect lots of bugs
7. Please read the latest documentation (http://the-ravi-programming-language.readthedocs.org/en/latest/) for details of what works and what doesn't , and how to enable JIT compilation
8. Note that by default JIT compilation is not enabled - refer to above mentioned documentation.

Note: the source attachments do not include above bug fix (as by mistake I created the release before committing the change) - obtain latest source if you would like to build this yourself.

Ravi Alpha Release 0.1 - Windows 64-bit

First alpha release of Ravi.
Please note following limitations:

1. JIT compilation not yet supported for bitwise operations
2. The Lua C API has not been tested for Ravi extensions so will definitely cause failures
3. Coroutines not supported in JIT mode
4. Debug API not supported for JITed code
5. Tail calls handled as normal calls - so will cause stack overflow for recursive calls (max 110 levels)
6. Expect lots of bugs
7. Please read the latest documentation (https://github.com/dibyendumajumdar/ravi) for details of what works and what doesn't , and how to enable JIT compilation