*lua-lexical*

                                               *lua-names* *lua-identifiers*
Names (also called identifiers) in Lua can be any string of letters, digits,
and underscores, not beginning with a digit. This coincides with the
definition of identifiers in most languages. (The definition of letter depends
on the current locale: any character considered alphabetic by the current
locale can be used in an identifier.) Identifiers are used to name variables
and table fields.

The following keywords are reserved and cannot be used as names:
>
       and       break     do        else      elseif
       end       false     for       function  if
       in        local     nil       not       or
       repeat    return    then      true      until     while
<
Lua is a case-sensitive language: `and` is a reserved word, but `And` and `AND` are
two different, valid names. As a convention, names starting with an underscore
followed by uppercase letters (such as `_VERSION`) are reserved for internal
global variables used by Lua.

The following strings denote other tokens:
>
       +     -     *     /     %     ^     #
       ==    ~=    <=    >=    <     >     =
       (     )     {     }     [     ]
       ;     :     ,     .     ..    ...
<
                                                                *lua-literal*
Literal strings can be delimited by matching single or double quotes, and can
contain the following C-like escape sequences:

    - `\a`  bell
    - `\b`  backspace
    - `\f`  form feed
    - `\n`  newline
    - `\r`  carriage return
    - `\t`  horizontal tab
    - `\v`  vertical tab
    - `\\`  backslash
    - `\"`  quotation mark (double quote)
    - `\'`  apostrophe (single quote)

Moreover, a backslash followed by a real newline results in a newline in the
string. A character in a string may also be specified by its numerical value
using the escape sequence `\ddd`, where `ddd` is a sequence of up to three
decimal digits. (Note that if a numerical escape is to be followed by a digit,
it must be expressed using exactly three digits.) Strings in Lua may contain
any 8-bit value, including embedded zeros, which can be specified as `\0`.

To put a double (single) quote, a newline, a backslash, or an embedded zero
inside a literal string enclosed by double (single) quotes you must use an
escape sequence. Any other character may be directly inserted into the
literal. (Some control characters may cause problems for the file system, but
Lua has no problem with them.)

Literal strings can also be defined using a long format enclosed by long
brackets. We define an opening long bracket of level n as an opening square
bracket followed by n equal signs followed by another opening square bracket.
So, an opening long bracket of level 0 is written as `[[`, an opening long
bracket of level 1 is written as `[=[`, and so on.
A closing long bracket is defined similarly; for instance, a closing long
bracket of level 4 is written as `]====]`. A long string starts with an
opening long bracket of any level and ends at the first closing long bracket
of the same level. Literals in this bracketed form may run for several lines,
do not interpret any escape sequences, and ignore long brackets of any other
level. They may contain anything except a closing bracket of the proper level.

For convenience, when the opening long bracket is immediately followed by a
newline, the newline is not included in the string. As an example, in a system
using ASCII (in which `a` is coded as 97, newline is coded as 10, and `1` is
coded as 49), the five literals below denote the same string:
>lua
       a = 'alo\n123"'
       a = "alo\n123\""
       a = '\97lo\10\04923"'
       a = [[alo
       123"]]
       a = [==[
       alo
       123"]==]
<
                                                            *lua-numconstant*
A numerical constant may be written with an optional decimal part and an
optional decimal exponent. Lua also accepts integer hexadecimal constants,