I’ve been spending a lot of time lately writing Fennel andcontributing to its compiler. Since it’s a language that compiles toLua, that also means spending a lot of time getting to know Lua. Thisarticle will be focused on Lua (though I’ll address Fennel from timeto time in the footnotes).

Note that SOLNOEXCEPTIONS will also disable sol::protectedfunction ’s ability to catch C errors you throw from C functions bound to Lua that you are calling through that API. So, only turn off exceptions in sol if you’re sure you’re never going to use exceptions ever. Of course, if you are ALREADY not using Exceptions, you don’t have to particularly worry about this and now you.
Both data and properties can be marked as read-only at the time of registration. This is different from const; the values of these objects can be modified on the C side, but Lua scripts cannot change them.Code samples that follow are in C or Lua, depending on context. For brevity of exposition code samples in C assume the traditional variable luaState. L is defined, and that a using.
So look up Bugsack and BugGrabber on curse (need both, one is the core other is GUI). And now you can diagnose errors properly in future. Yes you can just turn errors off but that's about as recommended as putting fingers in your ears and going 'lalalalalala'. Your gameplay experience will suffer ignoring errors.

The first step is to define the function. All C or C functions that will be called from Lua will be called using a pointer of this type: typedef int (.luaCFunction) (luaState.L); In other words, functions must have a Lua interpreter as the only argument and return only an integer. Since a Lua interpreter is used for the argument, the.

Lua is a neat, elegant, and relatively simple language. I find itparticularly notable for its embeddability into other programs;capability of hosting many different styles of programming; and theexcellent performance of one of its implementations,LuaJIT. In many ways, it feels like a more elegant andrestrained JavaScript - it supports tail call elimination^[1] andcoroutines, it doesn’t have the confusing var/letdistinction (though it lacked a feature like const until Lua 5.4),and it doesn’t privilege class syntax over other styles of programming(object oriented programming can be done in Lua with metatables, butit’s not given special syntax like it is in JS).

That said, it has aspects that are undoubtedly quirky - arrays anddictionaries are unified into 'tables', whose integer indices start at1; the standard library is unusually minimal, a nod to itsembeddability; it, like JavaScript, makes the immense error of makingvariables global by default and local only when you ask. Curiously, italso supports a quite uncommon language feature: multiple returnvalues (which we’ll call “multivals” for brevity’s sake). It is thislast subject that we’ll be unpacking more about today.

Since Lua is a dynamic language (as opposed to, say, Go) multiplereturns are implemented in a rather odd way. This isn’t explored in asmuch detail as I’d like in Lua’s documentation, so I wanted to providea one-stop resource that explains everything I can think to write downabout this idiosyncratic part of the language.

A spoiler: unfortunately, multivals will turn out to be somewhatunderwhelming for use in code you care about. They’re awkward to workwith, have numerous gotchas, are a maintenance hazard, and don’tperform notably better (that I know of) than their primaryalternative, tables. This is not a very useful article, unless youhave a use for knowing minutiae about Lua’s behavior.

Let’s dive in!

An Introduction to Multivals - `1, 2, 3`, `unpack`, and `...`

There are three primary ways to represent a multival in Lua. Each ofthese has their own distinct uses. Each of the following code snippetsproduces the same multival:

A multival literal: 1, 2, 3. (Note that this does not includetable literals like {1, 2, 3}).
Unpacking a table: table.unpack({1, 2, 3})
The vararg, ..., in a function: local function x(...) return ... end x(1, 2, 3)

Multivals can be packed into a table by simply calling them:

To manipulate multivals, we can use two techniques: functionsignatures and select:

In order to get values from the end of a multival, we have threeoptions. The first is recursion:

Lua Throw Error From C Corp

The second is packing the multival into a table. There are two ways todo this, both of which are demonstrated below:

The final way of getting values from the end of a multival is selectcombined with select('#', ...) (which we’ll dig into more later on):

The Vararg: A Second-Class Value

When you start working with multivals, they might seem prettystraightforward. As long as you’re working on something that uses alist with fixed length or that can be expressed by iterating throughthe head and tail of a list, it seems like working with multivalsshould be nice and predictable.

The first issue you’ll likely run into if you try to use multivalsheavily comes from expecting them to work the same way the rest of Luadoes. In short, Lua’s local variables use what’s called lexicalscope. This means that the scope of a variable definition is theblock of code that you see it contained in in your source codefile. It doesn’t matter what order other functions are called in, orwhether they’re called at all - the definitions of local variables canbe determined just by looking at the structure of the code. This is asopposed to dynamic scope, where the variables defined at a givenpoint are dependent on the runtime of the program itself. Lua’sglobal variables effectively use dynamic scope.

As discussed above, there’s only three ways to refer to a multival:calling a function for its return values, literally inserting multiplevalues separated by commas, or using the vararg symbol ... as afunction argument. It’s this last case that we’re interested in.

When you use ... in the signature of a function, you must place itat the end of the argument list. (This is what prevents you -syntactically, at least - from accessing the end of ... withouteither assigning the whole thing to individual variables, recursingthrough it, or packing it into a table.)

You also can’t assign the whole thing to a variable, because assigninga ... to a variable means unpacking the multival and assigning thefirst value to the variable - or multiple values, if that’sspecified. For example:

There’s one additional rule about the vararg, however, that’s veryunlike the behavior of the rest of Lua. You can only use a varargwithin the function where it is defined. This prevents you from, forinstance, saving the vararg into a closure:

This fails to run with the following error: cannot use '...' outside a vararg function near '...'. This means that, while you can use... in two nested functions, each ... can only refer to the varargof the function that’s currently running. You can’t capture ...within a closure to persist it. Effectively, ... is not lexicallyscoped, but rather a dynamically scoped variable with certain extrarules like not being reassignable and not being usable outside afunction that defined it.

Another way to put this would be to say that Lua’s multivals are“second class” values. You might be familiar with languages that havesecond class functions, which can’t be assigned to variables or passedas a parameter to a functions. This is similar, with the notableexception that we can pass the vararg to another function. We justcan’t save it in a variable, save it in a closure, or manipulate it incertain ways.

Cutoff Multivals

Lua Throw Error From C Function

Passing multivals to functions and packing them into tables is prettystraightforward, but there’s one major gotcha about it we haven’t goneover yet. Take a look at the following example:

As the second pair of print expressions demonstrates, a functioncall can only return multiple values into a multival if it is the lastthing in the multival. F

An Introduction to Multivals - 1, 2, 3, unpack, and ...

Lua Throw Error From C Corp

The Vararg: A Second-Class Value

Cutoff Multivals

Lua Throw Error From C Function

An Introduction to Multivals - `1, 2, 3`, `unpack`, and `...`