NAME

       luac - Lua compiler

SYNOPSIS

       luac [ options ] [ filenames ]

DESCRIPTION

       luac  is  the  Lua  compiler.  It translates programs written in the Lua programming language into binary
       files that can be latter loaded and executed.

       The main advantages of precompiling chunks are: faster loading, protecting source code from user changes,
       and off-line syntax checking.

       Pre-compiling  does  not  imply faster execution because in Lua chunks are always compiled into bytecodes
       before being executed.  luac simply allows those bytecodes to be saved in a file for later execution.

       luac produces a single output file containing the bytecodes for all source files given.  By default,  the
       output file is named luac.out, but you can change this with the -o option.

       The  binary  files created by luac are portable to all architectures with the same word size.  This means
       that binary files created on a 32-bit platform (such as Intel) can be  read  without  change  in  another
       32-bit  platform  (such  as  Sparc),  even if the byte order (``endianness'') is different.  On the other
       hand, binary files created on a 16-bit platform cannot be read in a 32-bit platform, nor vice-versa.

       In the command line, you can mix text files containing Lua source and binary files containing precompiled
       chunks.   This  is  useful  to  combine  several precompiled chunks, even from different (but compatible)
       platforms, into a single precompiled chunk.

       You can use - to indicate the standard input as a source file and -- to signal the end of  options  (that
       is, all remaining arguments will be treated as files even if they start with -).

       The internal format of the binary files produced by luac is likely to change when a new version of Lua is
       released.  So, save the source files of all Lua programs that you precompile.

OPTIONS

       Options must be separate.

       -l     produce a listing of the compiled bytecode for Lua's virtual machine.  Listing bytecodes is useful
              to  learn  about Lua's virtual machine.  If no files are given, then luac loads luac.out and lists
              its contents.

       -o file
              output to file, instead of the default luac.out.  The output file may be a source file because all
              files are loaded before the output file is written.  Be careful not to overwrite precious files.

       -p     load  files  but do not generate any output file.  Used mainly for syntax checking and for testing
              precompiled chunks: corrupted files  will  probably  generate  errors  when  loaded.   Lua  always
              performs  a  thorough  integrity  test  on  precompiled chunks.  Bytecode that passes this test is
              completely safe, in the sense that it will not  break  the  interpreter.   However,  there  is  no
              guarantee  that such code does anything sensible.  (None can be given, because the halting problem
              is unsolvable.)  If no files are given, then luac loads  luac.out  and  tests  its  contents.   No
              messages are displayed if the file passes the integrity test.

       -s     strip  debug  information  before  writing  the  output file.  This saves some space in very large
              chunks, but if errors occur when running these chunks, then the error messages may not contain the
              full information they usually do (line numbers and names of locals are lost).

       -v     show version information.

FILES

       luac.out       default output file

SEE ALSO

       lua(1)
       http://www.lua.org/

DIAGNOSTICS

       Error messages should be self explanatory.

AUTHORS

       L. H. de Figueiredo, R. Ierusalimschy and W. Celes (lua@tecgraf.puc-rio.br)

                                               2002/12/13 11:45:12                                       LUAC(1)