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)