I also have added the flag -std=gnu0x to the C compiler flags. This is necessary to get things including CodeSourcery libraries to compile without a warning, but is technically beta, so may (unlikely) cause issues. To get the other mbeds working there will probably have to be fewer flags set here and more set in the cmakeheader file. The defaults lua globals will be avaiable. Moreover the libraries defined in preload.c are embedded. If you want to embed lua VM code, use the default luac compiler and run glua on the its output. As described in the lua manual, the lua bytecode is compatible across machine with the same word size and byte order.

Lua C Download
Compile Flags Lua C Embed Code

byLuiz Henrique de Figueiredo,Roberto Ierusalimschy,and Waldemar Celes

In recent years, a multitude of little languages have been proposed for extendingand customizing applications. In general, these extension languages should havethe following attributes:

Clear and simple syntax (since it is not the main language for most of itsusers).
Small size and small implementation (so the cost of adding it tothe host will not be too high).
Good and run until the end of the line. Lua supportsmultiple assignment; for example, x, y = y, x swaps the values of xand y. Likewise, functions can return multiple values.
Lua is a dynamically typed language. This means that values have types butvariables don't, so there are no type or variable declarations. Internally, eachvalue has a tag that identifies its type; the tag can be queried at run time withthe built-in function type. Variables are typeless and can hold values ofany type. Lua's garbage collection keeps track of which values are being used,discarding those that are not.
Lua provides the types nil, string, number, userdata, function, and table. nil is the type of the valuenil; its main property is that it is different from any othervalue. This is handy to use as the initial value of variables, for instance. Thetype number represents floating-point real numbers. string has theusual meaning. Type user data corresponds to a generic void* pointer in C,and represents host objects in Lua. All of these types are useful, but theflexibility of Lua is due to functions and tables, the product of two key lessonsfrom Lisp and Scheme:
- Functions should be first-class values.
- Languages should have asingle and strong unifying data constructor (lists in Lisp, tables in Lua).
Function values in Lua can be stored into variables, passed as parameters toother functions, stored in tables, and the like.
When you declare a function in Lua (see Listing Two),the function body is precompiled into bytecodes, creating a functionvalue. This value is assigned to a global variable with the given name. Cfunctions, on the other hand, are provided by the host program through anappropriate call to the API. Lua cannot call C functions that have not beenregistered by their host. Therefore, the host has complete control over what aLua program can do, including any potentially dangerous access to the operatingsystem.
Tables
Tables are for Lua what lists are for Lisp: powerful]. Sets also can be easily implemented by storingtheir elements as indices of a table. Note that tables (and therefore sets) neednot be homogeneous; they can store values of all types simultaneously, includingfunctions and tables.
Lua provides a constructor, a special kind of expression to create tables, thatis handy for initializing lists, arrays, records, etc.See Example 1.
User-Defined Constructors
Sometimes you need finer control over the data structures you are building.Following the philosophy of providing only a few general metamechanisms, Luaprovides user-defined constructors. These constructors are writtenname{..}, which is a more intuitive version ofname({..}). In other words, with such a constructor, atable is created, initialized, and passed as a parameter to a function. Thisfunction can do whatever initialization is needed, such as dynamic type checking,initialization of absent fields, and auxiliary} and think about'windows,' not plain tables. Moreover, because constructors are expressions, theycan be nested to describe more complex structures in a declarative style, as inListing Four.
Object-Oriented Programming
Because functions are first-class values, table fields can refer to functions.This is a step toward object-oriented programming, and one made easier by simplersyntax for defining and calling methods.
A method definition is written as Example 2(a),which is equivalent to Example 2(b). Inother words, defining a method is equivalent to defining a function, with ahidden first parameter called self and storing the functionin a table field.
A method call is written as receiver: method(params), which is translatedto receiver.method(receiver,params). The receiver of the method is passedas the first argument of the method, giving the expected meaning to the parameterself.
These constructions do not provide information hiding, so purists may (correctly)claim that an important part of object orientation is missing. Moreover, Lua doesnot provide classes; each object carries its own method-dispatch tables.Nevertheless, these constructions are extremely light, and classes can besimulated using inheritance, as is common in other prototype-based languages,such as Self.
Fallbacks
Because Lua is an untyped language, many abnormal run-time events can happen:arithmetic operations being applied to nonnumerical operands, nontable valuesbeing indexed, nonfunction values being called. In typed, stand-alone languages,some of these conditions are flagged by the compiler; others result in abortingthe program at run time. It's rude for an embedded language to abort its hostprogram, so embedded languages usually provide hooks for error handling.
In Lua, these hooks are called 'fallbacks' and are also used for handlingsituations that are not strictly error conditions, such as accessing an absentfield in a table and signaling garbage collection. Lua provides default fallbackhandlers, but you can set your own handlers by calling the built-in functionsetfallback with two arguments: a string identifying the fallbackcondition (see Table 1), and the function to becalled whenever the condition occurs. setfallback returns the old fallbackfunction, so you can chain fallback handlers if necessary
Inheritance via Fallbacks
One of the most interesting uses of fallbacks is in implementing inheritance inLua. Simple inheritance allows an object to look for the value of an absent fieldin another object called its 'parent;' in particular, this field can be a method.This mechanism is a kind of object inheritance, in contrast to the moretraditional class inheritance adopted in Smalltalk and C++.
One way to implement simple inheritance in Lua is to store the parent object in adistinct field, parent for instance, and set an 'index' fallback function;see Listing Five. This code defines a functionInherit and sets it as the index fallback. Whenever Lua attempts toaccess a field that is absent in an object, the fallback mechanism calls thefunction Inherit. This function first checks whether the object has afield parent containing a table value. If so, it attempts to access thedesired field in the parent object. If the field is not present in the parent,the fallback is automatically called again. This process is repeated 'upwards'until a value for the field is found or the parent chain ends. When betterperformance is needed, the same inheritance scheme can be implemented in C usingLua's API.
Reflexive Facilities
Being an interpreted language, Lua provides some reflexive facilities. Oneexample is the function type, already mentioned. Other powerful reflexivefunctions are next, which traverses a table, and nextvar, whichtraverses all global variables. The function next gets two arguments, atable and an index in the table, and returns a 'next' index in someimplementation-dependent order. (Recall that tables are implemented as hashtables.) It also returns the value associated with the index in the table.(Recall that functions in Lua can return multiple values.) The functionnextvar has similar behavior, but it traverses the global variablesinstead of the indices of a table.
An interesting example using reflexivity is dynamic typing. As noted before, Luahas no static typing. However, sometimes i

Tables

User-Defined Constructors

Object-Oriented Programming

Fallbacks

Inheritance via Fallbacks

Reflexive Facilities

Compile Flags Lua C Embed