Lua C Configuring The Require Method

  1. Lua C Configuring The Require Method Pdf
  2. Lua C Configuring The Require Method Code

Being an embedded language, Lua has no notion of a “main” program; it only works embedded in a host client. Lua is provided as a library of C functions to be linked to host applications. The host can invoke functions in the library to execute a piece of code in Lua, write and read Lua variables, and register C functions to be called by Lua. The Lua module embeds Lua into NGINX and by leveraging NGINX's subrequests, allows the integration of Lua threads into the NGINX event model. From the above error, we can know easily that adding a do statement before print statement is required as per the Lua structure. Run Time Errors In case of runtime errors, the program executes successfully, but it can result in runtime errors due to mistakes in input or mishandled functions. For more complex configuration scenarios, such as adding entire new server blocks, you can use the method described above to inject an include directive to the Nginx configuration, pointing to a file containing your additional Nginx settings. For example, if you create a file called my-server.kong.conf with the following contents. We choose the Visual C 8 compiler to build the LuaBinaries executables. Up to Visual C version 6, the C run time library was called 'msvcrt.dll' and this DLL is today included in all modern Windows systems (W2K, WinXP, Vista and 7).

This tutorial follows on from the FunctionsTutorial.

Passing arguments

Since Lua is dynamically typed and has no need for function type declaration, checking the number and type of arguments required for a function seems somewhat redundant. Lua deals gracefully with mismatched numbers of calling and formal function arguments. Formal function arguments receive a default value of nil if they are not filled. Where too many arguments are passed they are simply ignored. No type is specified for each argument as they are dynamically typed. i.e. we only need to know the type of an object when we use it, not when we reference it. We'll use the following function as an example:

Here's what happens when we call it with no arguments: Notice that each of the arguments defaulted to the value Error running lua method loadsharedi3dfilefinishednil, or no value, and we don't get an error. Here's what happens when we pass too many arguments: Again, no error and the last argument is ignored. Because Lua is dynamically typed we can pass any argument type. e.g. we can pass strings in as well as numbers or references.

Variable arguments

It is often useful to have variable numbers of arguments to a function. e.g. the printf(format,...) function in C. One way Lua does this is by placing the variable argument list into an array table called arg, usable by the function. e.g.,

Lua C Configuring The Require Method Pdf

Note: In 5.2 arg is deprecated and three periods (...) can be used instead with similar effect.

In this example we can only see that this is a table. We could use table.foreach(table,function) to print out the values of the variable argument table, but using pairs() is better, since table.foreach() is deprecated in Lua 5.1.

From looking at an empty variable argument list it is easy to see that an extra table pair is added to provide the number of elements in the table, arg.n. In this case the number of arguments is zero. Let's try passing variable numbers of arguments:

Lua c configuring the require method code

Another way is to use ... as a placeholder:

The ... has an additional advantage in that it avoids the small performance penalty in constructing the arg table.


A useful function for variable arguments is unpack(). This takes a table and returns a list of variables, e.g.:

Lua C Configuring The Require Method Code

This can be used with variable argument lists as follows:

It can also be used to pass a variable number of arguments to a function as follow:

To understand how unpack works, look at this slow pseudo implementation:

Taken from the lua reference manual: [chapter 5.1 - Multiple Results].

Multiple return values

Lua can return more than one value from a function. This is done by returning a comma separated list of values:

The above function could have a variable number of return values if we construct a table, containing the values, and use unpack. E.g.,

Values as a table

We can also return the values in a table. To do this we add curly brackets around the function call, which will construct a table, i.e.:

{ function_name ( args ) }

Here is an example using the previous function example:

Single Value

If a function returns multiple values, but we only want the first value, we put a parenthesis around the function call, i.e.

( function_name ( args ) )
Here is an example:

The same could be achieved by returning a table and taking the first element but the above syntax is more efficient. E.g.,

RecentChanges · preferences
edit · history
Last edited April 5, 2013 12:40 am GMT (diff)

A Simplified Way to Declare Lua Classes

Out of the box, Lua does not have a class system, but its powerful metaprogramming facilities makes defining classic objects straightforward. In fact, there's a number of ways of doing this; together with the unfamiliar notation, this makes object-orientation in Lua seem a little intimidating at first.

The method described here is the most common and flexible method, using metatables. A table's behavior can be customized by giving it a metatable. For instance, if the metatable has an __index function, then any failed attempt to look up something in the table will be passed to __index. If __index is itself a table, the symbol will be looked up in that table. (Please see the excellent discussion in PiL [1]) Here is the basic idea:

Here, Account objects are represented by tables, which contain precisely one field, the balance. Lua tries to look up withdraw in acc, and cannot find it. Because acc has a metatable that defines __index, it will then look up withdraw in that metatable. So acc:withdraw(100) is actually the call Account.withdraw(acc,100). We could have actually put withdraw directly into acc, but this would be wasteful and inflexible - adding a new method would require a change to the create function, etc.

A simplified way of creating classes

I'll define a function class which does all this (and more) transparently.

In this scheme, one supplies an initialization function to the new class, and a 'constructor' is automatically generated.

Simple inheritance is supported. For example, here a base class Animal is defined, and several specific kinds of animals are declared. All classes made using class have a is_a method, which you can use to find out the actual class at runtime:

All Animal does is define __tostring, which Lua will use whenever a string representation is needed of the object. In turn, this relies on speak, which is not defined. So it's what C++ people would call an abstract base class; the specific derived classes like Dog define speak. Please note that if derived classes have their own initialization functions, they must explicitly call init for their base class.

Implementation of class()

class() uses two tricks. It allows you to construct a class using the call notation (like Dog('fido') above) by giving the class itself a metatable which defines __call. It handles inheritance by copying the fields of the base class into the derived class. This isn't the only way of doing inheritance; we could make __index a function which explicitly tries to look a function up in the base class(es). But this method will give better performance, at a cost of making the class objects somewhat fatter. Each derived class does keep a field _base that contains the base class, but this is to implement is_a.

Note that modification of a base class at runtime will not affect its subclasses.


If this change is made:
then we alternately may declare classes in this way:
BTW, you may note that class.lua also works for operators:
'init' may alternately be renamed '__init' since it is a private function like __add and resembling Python's __init__ [2].
In the original version, the argument called 'ctor' is actually the init method, as shown by the (previous) statement . I changed this argument's name to 'init'. --DeniSpir
An alternative class builder (tested with lua 5.3) --ThaBubble

See Also

RecentChanges · preferences
edit · history
Last edited June 6, 2017 6:22 pm GMT (diff)