Lua 5.1 / LuaJIT Quick Summary (part 2: advanced topics)

modular

-- load the foo module (foo.lua):
local foo = require "foo"

-- use a module function:
foo.this()
foo.that()

-- this is the foo module, i.e. foo.lua

-- create the module table
local foo = {}

-- add some functions to the module:
foo.this = function()
    print('this')
end
foo.that = function()
    print('that')
end

-- return the module table
return foo

local resume, yield = coroutine.resume, coroutine.yield

-- this function will be used to create a coroutine:

local function loop()
    print("hello!")
    local x = 0
    while true do
        -- pause function here:
        yield(x)
        -- continues here:
        x = x + 1
        print(x)
    end
end

-- create the coroutine:
local c = coroutine.create(loop)

-- the first resume runs from the start of the loop() function to the first yield():
coroutine.resume(c) -- prints: hello!

-- each subsequent resume runs from the last paused yield() to the next yield():
coroutine.resume(c) -- prints: 1
coroutine.resume(c) -- prints: 2

-- a metatable for pairs
local pair_meta = {}

-- a metamethod function for how to add two pairs together:
pair_meta.__add = function(a, b)
local p = {
  a[1]+b[1],
  a[2]+b[2],
}
-- result is also a pair:
setmetatable(p, pair_meta)
  return p
end

-- a constructor for pairs:
function make_pair(x, y)
  local p = { x, y }
  -- tell p to look in pair_meta for how to handle metamethod events:
  setmetatable(p, pair_meta)
  return p
end

-- create two pairs:
local p1 = make_pair(2, 3)
local p2 = make_pair(4, 5)

-- add them (creates a new pair):
local p3 = p1 + p2
print(p3[1], p3[2]) -- prints: 6 8

local animal = {}

function animal:isalive() print("yes!") end

local dog = {}
function dog:talk() print("bark!") end

-- create metatable for dog, that refers to animal for unknown keys:
local dog_meta = { __index = animal }

-- apply metatable to dog:
setmetatable(dog, dog_meta)

-- test it:
dog:talk()  -- prints: bark!
dog:isalive() -- prints: yes!

animal:talk() -- error!

local ffi = require "ffi"

-- create an array of five numbers (initialized with zeroes by default):
local arr = ffi.new("double[5]")
local arr = ffi.new("double[?]", 5)

-- create an array of five numbers (initialized with 1, 2, 3, 4, 5):
local arr = ffi.new("double[5]", 1, 2, 3, 4, 5)
local arr = ffi.new("double[?]", 5, 1, 2, 3, 4, 5)
local arr = ffi.new("double[5]", {1, 2, 3, 4, 5})
local arr = ffi.new("double[?]", 5, {1, 2, 3, 4, 5})

arr[2] = 4.2
print(arr[2])     --> prints 4.2

-- create declarations of C types in a long string:
local cdefs = [[

    typedef struct { 
        int a;
        double b;
    } foo;

    typedef struct {
        foo first;
        foo second;
    } foopair;

]]
-- add these types the the FFI:
ffi.cdef(cdefs)

-- create a new "foo" type with all members set to zero:
local myfoo = ffi.new("foo")

-- create a new "foo" type with specific values:
local myfoo = ffi.new("foo", { 100, 4.2 })

print(myfoo.a)         --> prints 100
print(myfoo.b)        --> prints 4.2

-- create a new "foopair":
local myfoopair = ffi.new("foopair", { { 100, 4.2 }, { 200, 3.14 } })

print(myfoo.second.a)     --> prints 200

-- load the "libsndfile" dynamic library:
local lib = ffi.load("libsndfile-1.dll")

-- declare one of the functions exported by the library
-- (usually we would declare them all at once, but here we just declare one for the example)
ffi.cdef [[
    const char * sf_version_string();
]]

-- use this function by indexing the library:
local version = lib.sf_version_string()

-- version is a cdata of type "const char *"
-- (i.e. an immutable array of bytes)
-- we can turn it into a Lua string using ffi.string:
print(ffi.string(version))

Lua 5.1 / LuaJIT Quick Summary (part 2: advanced topics)

Modules

Coroutines

Metatables

LuaJIT FFI