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  latter  loaded  and

       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 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.


       luac.out       default output file




       Error messages should be self explanatory.


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

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