Man Linux: Main Page and Category List


       luac - Lua compiler


       luac [ options ] [ filenames ]


       luac  is  the  Lua compiler.  It translates programs written in the Lua
       programming language into binary files that can be loaded and  executed
       with lua_dofile in C or with dofile in Lua.

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

       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  (‘‘endianess’’)  is
       different.   On  the  other  hand,  binary  files  created  on a 16-bit
       platform cannot be read in a 32-bit platform.

       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 stdin as a source file.

       The  internal  format  of  the binary files produced by luac may change
       when  a  new  version  of  Lua  is  released.   We  try   to   maintain
       compatibility  even  for  binary  files, but it is not always possible.
       So, save the source files of all Lua programs that you precompile.


       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 can be a source file because all files  are  loaded  before
              the output file is written.

       -p     load files but do not generate any output file.  Used mainly for
              syntax checking or testing precompiled chunks:  corrupted  files
              will  probably  generate  errors  when  loaded.  For a thourough
              integrity test, use -t.

       -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 might not  contain
              the full information they usually do.

       -t     perform  a thourough integrity test of precompiled chunks.  Code
              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.

       -v     print version information.


       luac.out       default output file




       Error messages should be self explanatory.


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

                              2000/10/06 15:11:21                      LUAC(1)