478 lines
13 KiB
C
478 lines
13 KiB
C
=pod
|
|
|
|
LuaJIT
|
|
|
|
=head1 Extensions
|
|
|
|
=over
|
|
|
|
=item * LuaJIT
|
|
|
|
=over
|
|
|
|
=item * Download E<rchevron>
|
|
|
|
=item * Installation
|
|
|
|
=item * Running
|
|
|
|
=back
|
|
|
|
=item * Extensions
|
|
|
|
=over
|
|
|
|
=item * FFI Library
|
|
|
|
=over
|
|
|
|
=item * FFI Tutorial
|
|
|
|
=item * ffi.* API
|
|
|
|
=item * FFI Semantics
|
|
|
|
=back
|
|
|
|
=item * jit.* Library
|
|
|
|
=item * Lua/C API
|
|
|
|
=item * Profiler
|
|
|
|
=back
|
|
|
|
=item * Status
|
|
|
|
=over
|
|
|
|
=item * Changes
|
|
|
|
=back
|
|
|
|
=item * FAQ
|
|
|
|
=item * Performance E<rchevron>
|
|
|
|
=item * Wiki E<rchevron>
|
|
|
|
=item * Mailing List E<rchevron>
|
|
|
|
=back
|
|
|
|
LuaJIT is fully upwards-compatible with Lua 5.1. It supports all
|
|
E<rchevron> standard Lua library functions and the full set of
|
|
E<rchevron> Lua/C API functions.
|
|
|
|
LuaJIT is also fully ABI-compatible to Lua 5.1 at the linker/dynamic
|
|
loader level. This means you can compile a C module against the
|
|
standard Lua headers and load the same shared library from either Lua
|
|
or LuaJIT.
|
|
|
|
LuaJIT extends the standard Lua VM with new functionality and adds
|
|
several extension modules. Please note this page is only about
|
|
I<functional> enhancements and not about performance enhancements, such
|
|
as the optimized VM, the faster interpreter or the JIT compiler.
|
|
|
|
=head2 Extensions Modules
|
|
|
|
LuaJIT comes with several built-in extension modules:
|
|
|
|
=head2 C<bit.*> E<mdash> Bitwise operations
|
|
|
|
LuaJIT supports all bitwise operations as defined by E<rchevron> Lua
|
|
BitOp:
|
|
|
|
bit.tobit bit.tohex bit.bnot bit.band bit.bor bit.bxor
|
|
bit.lshift bit.rshift bit.arshift bit.rol bit.ror bit.bswap
|
|
|
|
This module is a LuaJIT built-in E<mdash> you don't need to download or
|
|
install Lua BitOp. The Lua BitOp site has full documentation for all
|
|
E<rchevron> Lua BitOp API functions. The FFI adds support for 64 bit
|
|
bitwise operations, using the same API functions.
|
|
|
|
Please make sure to C<require> the module before using any of its
|
|
functions:
|
|
|
|
local bit = require("bit")
|
|
|
|
An already installed Lua BitOp module is ignored by LuaJIT. This way
|
|
you can use bit operations from both Lua and LuaJIT on a shared
|
|
installation.
|
|
|
|
=head2 C<ffi.*> E<mdash> FFI library
|
|
|
|
The FFI library allows calling external C functions and the use of C
|
|
data structures from pure Lua code.
|
|
|
|
=head2 C<jit.*> E<mdash> JIT compiler control
|
|
|
|
The functions in this module control the behavior of the JIT compiler
|
|
engine.
|
|
|
|
=head2 C API extensions
|
|
|
|
LuaJIT adds some extra functions to the Lua/C API.
|
|
|
|
=head2 Profiler
|
|
|
|
LuaJIT has an integrated profiler.
|
|
|
|
=head2 Enhanced Standard Library Functions
|
|
|
|
=head2 C<xpcall(f, err [,args...])> passes arguments
|
|
|
|
Unlike the standard implementation in Lua 5.1, C<xpcall()> passes any
|
|
arguments after the error function to the function which is called in a
|
|
protected context.
|
|
|
|
=head2 C<loadfile()> etc. handle UTF-8 source code
|
|
|
|
Non-ASCII characters are handled transparently by the Lua source code
|
|
parser. This allows the use of UTF-8 characters in identifiers and
|
|
strings. A UTF-8 BOM is skipped at the start of the source code.
|
|
|
|
=head2 C<tostring()> etc. canonicalize NaN and E<plusmn>Inf
|
|
|
|
All number-to-string conversions consistently convert non-finite
|
|
numbers to the same strings on all platforms. NaN results in C<"nan">,
|
|
positive infinity results in C<"inf"> and negative infinity results in
|
|
C<"-inf">.
|
|
|
|
=head2 C<tonumber()> etc. use builtin string to number conversion
|
|
|
|
All string-to-number conversions consistently convert integer and
|
|
floating-point inputs in decimal, hexadecimal and binary on all
|
|
platforms. C<strtod()> is I<not> used anymore, which avoids numerous
|
|
problems with poor C library implementations. The builtin conversion
|
|
function provides full precision according to the IEEE-754 standard, it
|
|
works independently of the current locale and it supports hex
|
|
floating-point numbers (e.g. C<0x1.5p-3>).
|
|
|
|
=head2 C<string.dump(f [,strip])> generates portable bytecode
|
|
|
|
An extra argument has been added to C<string.dump()>. If set to
|
|
C<true>, 'stripped' bytecode without debug information is generated.
|
|
This speeds up later bytecode loading and reduces memory usage. See
|
|
also the C<-b> command line option.
|
|
|
|
The generated bytecode is portable and can be loaded on any
|
|
architecture that LuaJIT supports, independent of word size or
|
|
endianness. However the bytecode compatibility versions must match.
|
|
Bytecode stays compatible for dot releases (x.y.0 E<rarr> x.y.1), but
|
|
may change with major or minor releases (2.0 E<rarr> 2.1) or between
|
|
any beta release. Foreign bytecode (e.g. from Lua 5.1) is incompatible
|
|
and cannot be loaded.
|
|
|
|
Note: C<LJ_GC64> mode requires a different frame layout, which implies
|
|
a different, incompatible bytecode format for ports that use this mode
|
|
(e.g. ARM64 or MIPS64) or when explicitly enabled for x64. This may be
|
|
rectified in the future.
|
|
|
|
=head2 C<table.new(narray, nhash)> allocates a pre-sized table
|
|
|
|
An extra library function C<table.new()> can be made available via
|
|
C<require("table.new")>. This creates a pre-sized table, just like the
|
|
C API equivalent C<lua_createtable()>. This is useful for big tables if
|
|
the final table size is known and automatic table resizing is too
|
|
expensive.
|
|
|
|
=head2 C<table.clear(tab)> clears a table
|
|
|
|
An extra library function C<table.clear()> can be made available via
|
|
C<require("table.clear")>. This clears all keys and values from a
|
|
table, but preserves the allocated array/hash sizes. This is useful
|
|
when a table, which is linked from multiple places, needs to be cleared
|
|
and/or when recycling a table for use by the same context. This avoids
|
|
managing backlinks, saves an allocation and the overhead of incremental
|
|
array/hash part growth.
|
|
|
|
Please note this function is meant for very specific situations. In
|
|
most cases it's better to replace the (usually single) link with a new
|
|
table and let the GC do its work.
|
|
|
|
=head2 Enhanced PRNG for C<math.random()>
|
|
|
|
LuaJIT uses a Tausworthe PRNG with period 2^223 to implement
|
|
C<math.random()> and C<math.randomseed()>. The quality of the PRNG
|
|
results is much superior compared to the standard Lua implementation
|
|
which uses the platform-specific ANSI rand().
|
|
|
|
The PRNG generates the same sequences from the same seeds on all
|
|
platforms and makes use of all bits in the seed argument.
|
|
C<math.random()> without arguments generates 52 pseudo-random bits for
|
|
every call. The result is uniformly distributed between 0.0 and 1.0.
|
|
It's correctly scaled up and rounded for C<math.random(n [,m])> to
|
|
preserve uniformity.
|
|
|
|
=head2 C<io.*> functions handle 64 bit file offsets
|
|
|
|
The file I/O functions in the standard C<io.*> library handle 64 bit
|
|
file offsets. In particular this means it's possible to open files
|
|
larger than 2 Gigabytes and to reposition or obtain the current file
|
|
position for offsets beyond 2 GB (C<fp:seek()> method).
|
|
|
|
=head2 C<debug.*> functions identify metamethods
|
|
|
|
C<debug.getinfo()> and C<lua_getinfo()> also return information about
|
|
invoked metamethods. The C<namewhat> field is set to C<"metamethod">
|
|
and the C<name> field has the name of the corresponding metamethod
|
|
(e.g. C<"__index">).
|
|
|
|
=head2 Fully Resumable VM
|
|
|
|
The LuaJIT VM is fully resumable. This means you can yield from a
|
|
coroutine even across contexts, where this would not possible with the
|
|
standard Lua 5.1 VM: e.g. you can yield across C<pcall()> and
|
|
C<xpcall()>, across iterators and across metamethods.
|
|
|
|
=head2 Extensions from Lua 5.2
|
|
|
|
LuaJIT supports some language and library extensions from Lua 5.2.
|
|
Features that are unlikely to break existing code are unconditionally
|
|
enabled:
|
|
|
|
=over
|
|
|
|
=item * C<goto> and C<::labels::>.
|
|
|
|
=item * Hex escapes C<'\x3F'> and C<'\*'> escape in strings.
|
|
|
|
=item * C<load(string|reader [, chunkname [,mode [,env]]])>.
|
|
|
|
=item * C<loadstring()> is an alias for C<load()>.
|
|
|
|
=item * C<loadfile(filename [,mode [,env]])>.
|
|
|
|
=item * C<math.log(x [,base])>.
|
|
|
|
=item * C<string.rep(s, n [,sep])>.
|
|
|
|
=item * C<string.format()>: C<%q> reversible. C<%s> checks
|
|
C<__tostring>. C<%a> and C<"%A> added.
|
|
|
|
=item * String matching pattern C<%g> added.
|
|
|
|
=item * C<io.read("*L")>.
|
|
|
|
=item * C<io.lines()> and C<file:lines()> process C<io.read()> options.
|
|
|
|
=item * C<os.exit(status|true|false [,close])>.
|
|
|
|
=item * C<package.searchpath(name, path [, sep [, rep]])>.
|
|
|
|
=item * C<package.loadlib(name, "*")>.
|
|
|
|
=item * C<debug.getinfo()> returns C<nparams> and C<isvararg> for
|
|
option C<"u">.
|
|
|
|
=item * C<debug.getlocal()> accepts function instead of level.
|
|
|
|
=item * C<debug.getlocal()> and C<debug.setlocal()> accept negative
|
|
indexes for varargs.
|
|
|
|
=item * C<debug.getupvalue()> and C<debug.setupvalue()> handle C
|
|
functions.
|
|
|
|
=item * C<debug.upvalueid()> and C<debug.upvaluejoin()>.
|
|
|
|
=item * Lua/C API extensions: C<lua_version()> C<lua_upvalueid()>
|
|
C<lua_upvaluejoin()> C<lua_loadx()> C<lua_copy()> C<lua_tonumberx()>
|
|
C<lua_tointegerx()> C<luaL_fileresult()> C<luaL_execresult()>
|
|
C<luaL_loadfilex()> C<luaL_loadbufferx()> C<luaL_traceback()>
|
|
C<luaL_setfuncs()> C<luaL_pushmodule()> C<luaL_newlibtable()>
|
|
C<luaL_newlib()> C<luaL_testudata()> C<luaL_setmetatable()>
|
|
|
|
=item * Command line option C<-E>.
|
|
|
|
=item * Command line checks C<__tostring> for errors.
|
|
|
|
=back
|
|
|
|
Other features are only enabled, if LuaJIT is built with
|
|
C<-DLUAJIT_ENABLE_LUA52COMPAT>:
|
|
|
|
=over
|
|
|
|
=item * C<goto> is a keyword and not a valid variable name anymore.
|
|
|
|
=item * C<break> can be placed anywhere. Empty statements (C<;;>) are
|
|
allowed.
|
|
|
|
=item * C<__lt>, C<__le> are invoked for mixed types.
|
|
|
|
=item * C<__len> for tables. C<rawlen()> library function.
|
|
|
|
=item * C<pairs()> and C<ipairs()> check for C<__pairs> and
|
|
C<__ipairs>.
|
|
|
|
=item * C<coroutine.running()> returns two results.
|
|
|
|
=item * C<table.pack()> and C<table.unpack()> (same as C<unpack()>).
|
|
|
|
=item * C<io.write()> and C<file:write()> return file handle instead of
|
|
C<true>.
|
|
|
|
=item * C<os.execute()> and C<pipe:close()> return detailed exit
|
|
status.
|
|
|
|
=item * C<debug.setmetatable()> returns object.
|
|
|
|
=item * C<debug.getuservalue()> and C<debug.setuservalue()>.
|
|
|
|
=item * Remove C<math.mod()>, C<string.gfind()>.
|
|
|
|
=item * C<package.searchers>.
|
|
|
|
=item * C<module()> returns the module table.
|
|
|
|
=back
|
|
|
|
Note: this provides only partial compatibility with Lua 5.2 at the
|
|
language and Lua library level. LuaJIT is API+ABI-compatible with Lua
|
|
5.1, which prevents implementing features that would otherwise break
|
|
the Lua/C API and ABI (e.g. C<_ENV>).
|
|
|
|
=head2 Extensions from Lua 5.3
|
|
|
|
LuaJIT supports some extensions from Lua 5.3:
|
|
|
|
=over
|
|
|
|
=item * Unicode escape C<'\u{XX...}'> embeds the UTF-8 encoding in
|
|
string literals.
|
|
|
|
=item * The argument table C<arg> can be read (and modified) by
|
|
C<LUA_INIT> and C<-e> chunks.
|
|
|
|
=item * C<io.read()> and C<file:read()> accept formats with or without
|
|
a leading C<*>.
|
|
|
|
=item * C<table.move(a1, f, e, t [,a2])>.
|
|
|
|
=item * C<coroutine.isyieldable()>.
|
|
|
|
=item * Lua/C API extensions: C<lua_isyieldable()>
|
|
|
|
=back
|
|
|
|
=head2 C++ Exception Interoperability
|
|
|
|
LuaJIT has built-in support for interoperating with C++ exceptions. The
|
|
available range of features depends on the target platform and the
|
|
toolchain used to compile LuaJIT:
|
|
|
|
Platform
|
|
|
|
Compiler
|
|
|
|
Interoperability
|
|
|
|
POSIX/x64, DWARF2 unwinding
|
|
|
|
GCC 4.3+, Clang
|
|
|
|
B<Full>
|
|
|
|
ARM C<-DLUAJIT_UNWIND_EXTERNAL>
|
|
|
|
GCC, Clang
|
|
|
|
B<Full>
|
|
|
|
Other platforms, DWARF2 unwinding
|
|
|
|
GCC, Clang
|
|
|
|
B<Limited>
|
|
|
|
Windows/x64
|
|
|
|
MSVC or WinSDK
|
|
|
|
B<Full>
|
|
|
|
Windows/x86
|
|
|
|
Any
|
|
|
|
B<Full>
|
|
|
|
Other platforms
|
|
|
|
Other compilers
|
|
|
|
B<No>
|
|
|
|
B<Full interoperability> means:
|
|
|
|
=over
|
|
|
|
=item * C++ exceptions can be caught on the Lua side with C<pcall()>,
|
|
C<lua_pcall()> etc.
|
|
|
|
=item * C++ exceptions will be converted to the generic Lua error
|
|
C<"C++ exception">, unless you use the C call wrapper feature.
|
|
|
|
=item * It's safe to throw C++ exceptions across non-protected Lua
|
|
frames on the C stack. The contents of the C++ exception object pass
|
|
through unmodified.
|
|
|
|
=item * Lua errors can be caught on the C++ side with C<catch(...)>.
|
|
The corresponding Lua error message can be retrieved from the Lua
|
|
stack.
|
|
|
|
=item * Throwing Lua errors across C++ frames is safe. C++ destructors
|
|
will be called.
|
|
|
|
=back
|
|
|
|
B<Limited interoperability> means:
|
|
|
|
=over
|
|
|
|
=item * C++ exceptions can be caught on the Lua side with C<pcall()>,
|
|
C<lua_pcall()> etc.
|
|
|
|
=item * C++ exceptions will be converted to the generic Lua error
|
|
C<"C++ exception">, unless you use the C call wrapper feature.
|
|
|
|
=item * C++ exceptions will be caught by non-protected Lua frames and
|
|
are rethrown as a generic Lua error. The C++ exception object will be
|
|
destroyed.
|
|
|
|
=item * Lua errors B<cannot> be caught on the C++ side.
|
|
|
|
=item * Throwing Lua errors across C++ frames will B<not> call C++
|
|
destructors.
|
|
|
|
=back
|
|
|
|
B<No interoperability> means:
|
|
|
|
=over
|
|
|
|
=item * It's B<not> safe to throw C++ exceptions across Lua frames.
|
|
|
|
=item * C++ exceptions B<cannot> be caught on the Lua side.
|
|
|
|
=item * Lua errors B<cannot> be caught on the C++ side.
|
|
|
|
=item * Throwing Lua errors across C++ frames will B<not> call C++
|
|
destructors.
|
|
|
|
=back
|
|
|
|
----
|
|
|
|
Copyright E<copy> 2005-2017 Mike Pall E<middot> Contact
|
|
|
|
=cut
|
|
|
|
#Pod::HTML2Pod conversion notes:
|
|
#From file extensions.html
|
|
# 17733 bytes of input
|
|
#Mon May 14 13:19:16 2018 agentzh
|
|
# No a_name switch not specified, so will not try to render <a name='...'>
|
|
# No a_href switch not specified, so will not try to render <a href='...'>
|