Step 1: Writing a C function that Lua can call. C/C functions that are called from lua need to take as an input parameter the lua state. The parameters can be examined on the call stack using the functions luatointeger, luatonumber, etc (described above). The first parameter is at index 1, the second parameter is at index 2, and so on. How to call c dll from latest lua 5.3. UPDATED: Problem solved. The dll must not be statically linking to lua, otherwise it crashes with a multiple Lua VMs detected exception. The code blow actually works fine, just leave it here in case someone got this problem too. And wireshark uses lua5.2 because there's a 'lua52.dll' in it's folder. .Whenever a function call appears last in a list of expressions, Lua will append all of the results of the function to the list.Otherwise, Lua uses just the first result and ignores the rest (if there are no results, Lua uses nil) a, b = maxmin(2, 3) print(a, b) 3 2 a, b, c = 1, maxmin(2, 3) print(a, b, c) 1 3 2.

Lua 5.3 Call Function From C++
Lua 5.3 Call Function From Command
Lua 5.3 Call Function From Cli

by Roberto Ierusalimschy, Luiz Henrique de Figueiredo, Waldemar Celes

This section describes the lexis, the syntax, and the semantics of Lua. In other words, this section describes which tokens are valid, how they can be combined, and what their combinations mean.

Language constructs will be explained using the usual extended BNF notation, in which {a} means 0 or more a's, and [a] means an optional a. Non-terminals are shown like non-terminal, keywords are shown like kword, and other terminal symbols are shown like '='. The complete syntax of Lua can be found in Complete Syntax at the end of this manual.

1 – Lexical Conventions

Lua is a free-form language. It ignores spaces (including new lines) and comments between lexical elements (tokens), except as delimiters between names and keywords.

Names (also called identifiers) in Lua can be any string of letters, digits, and underscores, not beginning with a digit and not being a reserved word. Identifiers are used to name variables, table fields, and labels.

The following keywords are reserved and cannot be used as names:

Lua is a case-sensitive language: and is a reserved word, but And and AND are two different, valid names. As a convention, programs should avoid creating names that start with an underscore followed by one or more uppercase letters (such as _VERSION).

The following strings denote other tokens:

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]), and ''' (apostrophe [single quote]). A backslash followed by a real newline results in a newline in the string. The escape sequence 'z' skips the following span of white-space characters, including line breaks; it is particularly useful to break and indent a long literal string into multiple lines without adding the newlines and spaces into the string contents.

Strings in Lua can contain any 8-bit value, including embedded zeros, which can be specified as '0'. More generally, we can specify any byte in a literal string by its numeric value. This can be done with the escape sequence xXX, where XX is a sequence of exactly two hexadecimal digits, or with the escape sequence ddd, where ddd is a sequence of up to three decimal digits. (Note that if a decimal escape sequence is to be followed by a digit, it must be expressed using exactly three digits.)

The UTF-8 encoding of a Unicode character can be inserted in a literal string with the escape sequence u{XXX} (note the mandatory enclosing brackets), where XXX is a sequence of one or more hexadecimal digits representing the character code point.

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 literal starts with an opening long bracket of any level and ends at the first closing long bracket of the same level. It can contain any text except a closing bracket of the same level. Literals in this bracketed form can run for several lines, do not interpret any escape sequences, and ignore long brackets of any other level. Any kind of end-of-line sequence (carriage return, newline, carriage return followed by newline, or newline followed by carriage return) is converted to a simple newline.

Any byte in a literal string not explicitly affected by the previous rules represents itself. However, Lua opens files for parsing in text mode, and the system file functions may have problems with some control characters. So, it is safer to represent non-text data as a quoted literal with explicit escape sequences for non-text characters.

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 literal strings below denote the same string:

A numeric constant (or numeral) can be written with an optional fractional part and an optional decimal exponent, marked by a letter 'e' or 'E'. Lua also accepts hexadecimal constants, which start with 0x or 0X. Hexadecimal constants also accept an optional fractional part plus an optional binary exponent, marked by a letter 'p' or 'P'. A numeric constant with a fractional dot or an exponent denotes a float; otherwise it denotes an integer. Examples of valid integer constants are

Examples of valid float constants are

A comment starts with a double hyphen (--) anywhere outside a string. If the text immediately after -- is not an opening long bracket, the comment is a short comment, which runs until the end of the line. Otherwise, it is a long comment, which runs until the corresponding closing long bracket. Long comments are frequently used to disable code temporarily.

2 – Variables

Variables are places that store values. There are three kinds of variables in Lua: global variables, local variables, and table fields.

A single name can denote a global variable or a local variable (or a function's formal parameter, which is a particular kind of local variable):

Name denotes identifiers, as defined in Lexical Conventions.

Any variable name is assumed to be global unless explicitly declared as a local (see Local Declarations). Local variables are lexically scoped: local variables can be freely accessed by functions defined inside their scope (see Visibility Rules).

Before the first assignment to a variable, its value is nil.

Square brackets are used to index a table:

The meaning of accesses to table fields can be changed via metatables (see Metatables and Metamethods).

The syntax var.Name is just syntactic sugar for var['Name']:

An access to a global variable x is equivalent to _ENV.x. Due to the way that chunks are compiled, _ENV is never a global name (see Environments and the Global Environment).

3 – Statements

Lua supports an almost conventional set of statements, similar to those in Pascal or C. This set includes assignments, control structures, function calls, and variable declarations.

3.1 – Blocks

A block is a list of statements, which are executed sequentially:

Lua has empty statements that a

Lua 5.3 Call Function From C