Lua-Users Wiki

http://lua-users.org/wiki
Admin
Lua-Users Wiki is a community-maintained wiki providing comprehensive documentation, tutorials, code...
Tokens:1,065,324
Snippets:11,465
Trust Score:9.4
Update:5 months ago
Show doc for...
Tokens:
Raw
### LuaUnit with Setup and Teardown

Source: http://lua-users.org/wiki/UnitTesting

An advanced LuaUnit example showcasing setUp and tearDown functions for test initialization and cleanup. It includes tests for both addition and subtraction functions, demonstrating multiple test classes and individual test execution.

```lua
-- Some super function to test
function my_super_function( arg1, arg2 ) return arg1 + arg2 end
function my_bad_function( arg1, arg2 ) return arg1 - arg2 end

-- Unit testing starts
require('luaunit')

-- now, we perform all the tests on int in one test class
-- and the tests on float in another one
-- when your test grows, you will have many test classes

TestWithInt = {} --class
    function TestWithInt:setUp() 
        -- this function is run before each test, so that multiple
        -- tests can share initialisations
        self.a = 1
        self.b = 2
    end

    function TestWithInt:tearDown() 
        -- this function is executed after each test
        -- here, we have nothing to do so we could have avoid
        -- declaring it
    end

    function TestWithInt:testSuperFunction()
        result = my_super_function( self.a, self.b )
        assertEquals( type(result), 'number' )
        assertEquals( result, 3 )
    end

    function TestWithInt:testBadFunction()
        result = my_bad_function( self.a, self.b )
        assertEquals( type(result), 'number' )
        assertEquals( result, -1 )
    end

    function TestWithInt:testThatFails()
        -- you can test anything with assertEquals
        assertEquals( self.a, 1 )
        assertEquals( type(self.a), 'number' )
        -- will fail
        assertEquals( 'hop', 'bof' )
    end
-- class TestWithInt

TestWithFloat = {} --class
    function TestWithFloat:setUp() 
        -- this function is run before each test, so that multiple
        -- tests can share initialisations
        self.a = 1.1
        self.b = 2.1
    end

    function TestWithFloat:tearDown() 
        -- this function is executed after each test
        -- here, we have nothing to do so we could have avoid
        -- declaring it
    end

    function TestWithFloat:testSuperFunction()
        result = my_super_function( self.a, self.b )
        assertEquals( type(result), 'number' )
        -- will fail
        assertEquals( result, 3 )
    end

    function TestWithFloat:testBadFunction()
        result = my_bad_function( self.a, self.b )
        assertEquals( type(result), 'number' )
        -- will work, but only by chance :-)
        assertEquals( result, -1 )
    end
-- class TestWithFloat

LuaUnit:run()

```

--------------------------------

### Quick Start Installation and Usage

Source: http://lua-users.org/wiki/SourceOptimizer

Instructions for downloading, compiling Metalua, and setting up the Source Optimizer tool. Shows how to run the optimizer on a Lua file.

```bash
Download tar file from http://github.com/fab13n/metalua/tree/0.5-branch .

tar xzvf fab13n-metalua-28e8e1037ab33d96c123667f4c3fc94b5aca83bc.tar.gz
mv fab13n-metalua-28e8e1037ab33d96c123667f4c3fc94b5aca83bc metalua
cd metalua && make

Download sourceoptimizer.mlua and place in metalua/build/lib/dmlib .
Download sourceoptimize.lua and place in metalua/ .
Download fib.lua example and place in metalua/ .

./build/bin/metalua sourceoptimize.lua fib.lua
# or
./build/bin/metalua sourceoptimize.lua fib.lua  | lua - 

```

--------------------------------

### Run LuaSocket Examples

Source: http://lua-users.org/wiki/LuaModuleLuaSocket

Example command to run LuaSocket examples using the loadmodule function. Ensure you have a Lua interpreter with loadmodule support.

```bash
lua -e 'assert(loadmodule("socket"))' -f check_links.lua http://www.lua-users.org
```

--------------------------------

### Install Basic Prerequisites

Source: http://lua-users.org/wiki/LuaWsapi

Installs essential development libraries and build tools required for compiling software.

```bash
apt-get install libreadline-dev build-essential unzip
```

--------------------------------

### Lua Bot Command Examples

Source: http://lua-users.org/wiki/LuaBot

Demonstrates how to interact with the Lua Bot using its command-line interface. Use '!api' to get function documentation and 'lua>' to execute scripts.

```text
<cladhaire> !api pcall
<lua_bot> Documentation for 'pcall' can be found at http://www.lua.org/manual/5.1/manual.html#pdf-pcall
```

```text
<cladhaire> lua> for k,v in pairs(_G) do print(k) end
<lua_bot> clad|office: tostring, os, getfenv, pairs, assert, tonumber, strsplit, load, _G, coroutine, loadstring, pp, prettyprint, string,
xpcall, bit, _VERSION, strtrim, table, strjoin, strconcat, setmetatable, next, ipairs, rawequal, collectgarbage, rawset, print, math, pcall,
unpack, type, select, rawget, getmetatable,...
```

--------------------------------

### Example .SciTE.favs for Linux

Source: http://lua-users.org/wiki/SciteFavs

This is an example of how to list favorite files in the .SciTE.favs file for Linux. Each path should be on a new line.

```text
/path/to/some file.txt
/some.html
```

--------------------------------

### XML Build Rule Example

Source: http://lua-users.org/wiki/LuaBuildBou

An example of an XML-based notation for build rules, presented as a tool-agnostic format.

```xml
<program name="first" compile_deps="common.h" libs="user32,kerner32">
one, two
</program>
```

--------------------------------

### Install Apache and FastCGI

Source: http://lua-users.org/wiki/LuaWsapi

Installs the Apache web server and the FastCGI module and development libraries.

```bash
apt-get install apache2 libfcgi libfcgi-dev libapache2-mod-fcgid
```

--------------------------------

### Example SciTE.favs for Windows

Source: http://lua-users.org/wiki/SciteFavs

This is an example of how to list favorite files in the SciTE.favs file for Windows. Each path should be on a new line.

```text
C:\path\to\some file.txt
C:\some.html
```

--------------------------------

### Simple io.readuntil Example

Source: http://lua-users.org/wiki/ReadDefinedChunks

A basic example demonstrating how to use io.readuntil to read lines from a file until the end of the file is reached.

```lua
-- a simple example without using all the specials
local Handle=io.open('File','r')
local ReadUntil=io.readuntil(Handle)
repeat
   Line=coroutine.resume(ReadUntil,'\n',true)
   if Line then

   end
until Line==nil

```

--------------------------------

### Get Query String

Source: http://lua-users.org/wiki/CgiUtils

Retrieves the QUERY_STRING environment variable, typically used for GET requests. This is a common starting point for parsing URL parameters.

```lua
str = os.getenv("QUERY_STRING")
...
```

--------------------------------

### Get Next UTF-8 Character (Lua C Function)

Source: http://lua-users.org/wiki/ValidateUnicodeString

Lua C function to get the next UTF-8 character and its byte length from a string starting at a given position. Requires the string and the starting position (1-based index) as arguments. Errors if the index is invalid or the string contains invalid UTF-8.

```c
int sarn_utf8_next_func(lua_State* L)
{
	const char *str;
	size_t pos, clen;
	char utf8[5];
	
	str = luaL_checkstring(L, 1);
	pos = luaL_checklong(L, 2);
	if (strlen(str)<pos) {
		lua_pushnil(L);
		return 1;
	}
	memset(utf8, '\0', sizeof(utf8));
	
	if (pos == 0)
		return luaL_error(L, "bad index value : 0");
	
	clen = sarn_utf8_next((unsigned char *)str+pos-1);
	if (!clen)
		return luaL_error(L, INVALID_UTF8);
	
	lua_pushnumber(L, pos+clen);
	strncpy(utf8, str+pos-1, clen);
	lua_pushstring(L, utf8);
	return 2;
}
```

--------------------------------

### Basic ex.spawn Usage Examples

Source: http://lua-users.org/wiki/MauroIazzi

Demonstrates various ways to call `ex.spawn` with different argument structures and command specifications.

```lua
proc = ex.spawn"/bin/echo"

```

```lua
proc = ex.spawn{"/bin/echo", "hello", "world"}

```

```lua
proc = ex.spawn{command="/bin/echo", "echo", "hello", "world"} --big difference

```

```lua
proc = ex.spawn{argv = {"lua", "-e", 'print"Hello world\n"'}} -- equivalent to Mark's example

```

```lua
proc = ex.spawn{"lua", "-e", 'print"Hello world\n"'}

```

```lua
proc = ex.spawn{"lua", "-e", 'print"Hello world\n"', env=ex.environ()}

```

```lua
proc = ex.spawn{"/usr/bin/lua", "-e", 'print"Hello world\n"', env=false} -- this uses a void env

```

```lua
proc = ex.spawn{"/usr/bin/lua", "-e", 'print"Hello world\n"', env="equivalent"} -- this uses a void env

```

```lua
proc = ex.spawn{command='/usr/bin/vim', "ex", "ex.c"} -- starts vim in "ex" mode

```

```lua
proc = ex.spawn{command='/bin/busybox', argv = {"ls", "ex.c" }} -- ls ex.c

```

```lua
proc = ex.spawn{command='/bin/busybox', argv = {"cp", "ex.c", 'ex2.c'}} -- cp ex.c ex2.c, same binary

```

```lua
proc = ex.spawn{"echo", "hello", "world", env={ PATH="/bin" } }

```

```lua
proc = ex.spawn{"echo", "hello", "world", env={ "PATH=/bin" } } --same as before

```

--------------------------------

### Get Character Byte Values - Lua

Source: http://lua-users.org/wiki/StringLibraryTutorial

Use string.byte to get the numerical code of characters in a string. Indices start at 1 and can be negative. Out-of-range indices return no value.

```lua
> = string.byte("ABCDE")      -- no index, so the First character
65
> = string.byte(" ") --Whitespace also has its own numerical code
32
> = string.byte("H A I") -- Thus, #s of this string is 5 not 3
> = string.byte("ABCDE",1)    -- indexes start at 1
65
> = string.byte("ABCDE",0)    -- we're not using C
> = string.byte("ABCDE",100)  -- index out of range, no value returned
> = string.byte("ABCDE",3,4)
67      68
> s = "ABCDE"
> = s:byte(3,4)               -- can apply directly to string variable
67      68
```

--------------------------------

### Range Iterator Example Calls

Source: http://lua-users.org/wiki/RangeIterator

A collection of example calls to the range iterator function, showcasing various combinations of start, stop, and step arguments, including positive and negative steps, and single-argument usage.

```lua
for i in range( 10) print(i) end -- iterate 1 to 10, increment by 1
```

```lua
for i in range(-10) print(i) end -- iterate -1 to -10, decrement by 1
```

```lua
for i in range(7, -2) print(i) end -- iterate 7 to -2, decrement by 1
```

```lua
for i in range(3, 27, 3) print(i) end -- iterate 3 to 27, increment by 3
```

```lua
for i in range(0, 1, -1) print(i) end -- iterate 0 to 1, decrementing by 1 (loop forever downward)
```

--------------------------------

### Example of module execution

Source: http://lua-users.org/wiki/ModuleExecutionProposal

Demonstrates how a module 'my.app' can be executed as a script, receiving arguments via `io.read` and `...`.

```lua
-- my/app.lua
print("hello", io.read"*a", ...)
local i=0; while arg[i] do print(i, arg[i]); i=i-1 end
```

```bash
$ echo -n 123 | lua -p my.app 3 4 5
hello   123     3       4       5
0       my.app
-1      -p
-2      lua
```

--------------------------------

### Complex Coroutine Example in Lua

Source: http://lua-users.org/wiki/CoroutinesTutorial

This example showcases coroutines by simulating a loop that alternates between odd and even number processing, using `coroutine.yield` and `coroutine.resume`. It requires no special setup beyond standard Lua.

```lua
> function odd(x)
>>   print('A: odd', x)
>>   coroutine.yield(x)
>>   print('B: odd', x)
>> end
> 
> function even(x)
>>   print('C: even', x)
>>   if x==2 then return x end
>>   print('D: even ', x)
>> end
> 
> co = coroutine.create(
>>   function (x) 
>>     for i=1,x do
>>       if i==3 then coroutine.yield(-1) end
>>       if i % 2 == 0 then even(i) else odd(i) end
>>     end
>>   end)
> 
> count = 1
> while coroutine.status(co) ~= 'dead' do
>>   print('----', count) ; count = count+1
>>   errorfree, value = coroutine.resume(co, 5)
>>   print('E: errorfree, value, status', errorfree, value, coroutine.status(co))
>> end
----    1
A: odd  1
E: errorfree, value, status     true    1       suspended
----    2
B: odd  1
C: even 2
E: errorfree, value, status     true    -1      suspended
----    3
A: odd  3
E: errorfree, value, status     true    3       suspended
----    4
B: odd  3
C: even 4
D: even         4
A: odd  5
E: errorfree, value, status     true    5       suspended
----    5
B: odd  5
E: errorfree, value, status     true    nil     dead
>
```

--------------------------------

### Example __gc Metamethod with Boxed Check

Source: http://lua-users.org/wiki/UserDataRefinement

This example demonstrates a __gc metamethod for a C structure 'Foo'. It uses lua_tocpeer to get the C structure pointer and lua_isboxed to conditionally free the storage if the userdata is boxed.

```c
int foo_gc (lua_State *L) {
    Foo *self = lua_tocpeer(L, 1);
    foo_destruct(self);  // delete self's references
    if (lua_isboxed(L, 1)) foo_free(self); // free self's storage
    return 0;
  }
```

--------------------------------

### Lua to C Compiler Example

Source: http://lua-users.org/wiki/LuaFish

Demonstrates the usage of a preliminary Lua to C compiler. It shows how to compile a Lua script and then execute the resulting C code.

```bash
$ lua 1.lua 
25 

$ lua lib/luafish/lua2c.lua 1.lua | gcc -xc - 

$ ./a.out 
25.000000
```

--------------------------------

### Complete FSM Example

Source: http://lua-users.org/wiki/FiniteStateMachine

A runnable example demonstrating FSM definition, parsing, and execution with sample actions and transitions. Compatible with Lua 5.0 and 5.1.

```lua
function action1()
 print("action1")
end

function action2()
 print("action2")
end


function FSM(t)
  local a = {}
  for _,v in ipairs(t) do
    local old, event, new, action = v[1], v[2], v[3], v[4]
    if a[old] == nil then a[old] = {}
    end
    a[old][event] = {new = new, action = action}
  end
  return a
end

fsm = FSM{
  {"state1", "event1", "state2", action1},
  {"state1", "event2", "state3", action2},
}

local a = fsm["state1"]["event1"]
a.action()
state = a.new
```

--------------------------------

### Example: Sequence with Alternation and Anchoring

Source: http://lua-users.org/wiki/ExPattern

Tests a sequence pattern that includes an alternation and an anchored start, demonstrating how anchoring affects matching.

```lua
-- example
local m = P('foo', P'bar'+P'baz', 'qux'):compile()
assert(str(m('afoobazfoobarquxbar', 'foobarqux')))
local m = P('^foo', P'bar'+P'baz', 'qux'):compile() -- anchored
assert(str(m('afoobazfoobarquxbar', '')))
assert(str(m('foobarquxbar', '')))
```

--------------------------------

### Lua Usage Example for Array

Source: http://lua-users.org/wiki/ObjectProperties

Demonstrates how to create and use the C-implemented array in Lua, including setting and getting values and checking the size.

```lua
o = array:new(3)

print(o:size())

o[1] = 1
o[2] = 2
o[3] = 3

print(o:get(2))
o:set(3, -1)
print(o[3])

```

--------------------------------

### Startup Script Configuration

Source: http://lua-users.org/wiki/SciteScriptManager

This configuration indicates the script that should be executed at startup. It's part of the ext.lua setup for Scite.

```lua
ext.lua.startup.script_
```

--------------------------------

### Get CPU time with os.clock()

Source: http://lua-users.org/wiki/OsLibraryTutorial

Returns the CPU time used by the Lua program since it started, in seconds. Useful for performance measurement.

```lua
> = os.clock()
11056.989
```

--------------------------------

### MaxGUI Application Setup

Source: http://lua-users.org/wiki/MaxGuiExample

Sets up a basic MaxGUI application window with labels, panels, and a text area. Includes loading custom fonts and images, and handling window close events. Ensure all required pixmaps and fonts are available.

```lua
--******************************************************************************
--*                                                                            *
--*                                Main Program                                *
--*                                                                            *
--******************************************************************************

--**** provide a few application-specific definitions ****

  local Title    = "MaxGUI_00";
  local Subtitle = "very first experiments with MaxGUI and Lua";

--**** load some application-specific images ****

  local Icon = loadPixmap("Lua-Logo.png");
--  Icon = maskPixmap(Icon, 212,208,200);    -- does not work
  if (Icon == nil) then error("unable to load 'Lua-Logo.png'"); end;

  local sunkenLine = loadPixmap("sunkenLine.png");
  if (sunkenLine == nil) then error("unable to load 'sunkenLine.png'"); end;

--**** load any application-specific fonts ****

  local TitleFont    = loadGuiFont("Arial", 12, true, true, false);
  local SubtitleFont = loadGuiFont("Arial",  9, true, false,false);
  local TextFont     = loadGuiFont("Arial",  8, false,false,false);
  local BoldFont     = loadGuiFont("Arial",  8, true, false,false);
  if (TitleFont == nil) or (SubtitleFont == nil) or (TextFont == nil) or (BoldFont == nil) then
    error("unable to load all requested fonts");
  end;

--**** setup the application window ****

  local Window = createWindow(Title.." - "..Subtitle, 20,20, 320,240, nil,
    WINDOW_TITLEBAR + WINDOW_RESIZABLE + WINDOW_CLIENTCOORDS); -- + WINDOW_STATUS);
    setMinWindowSize(Window, 320,240);

    local IconView = createPanel(2,4, 32,32, Window);
      setPanelPixmap (IconView, Icon, PANELPIXMAP_CENTER);
      setGadgetLayout(IconView, EDGE_ALIGNED,0,EDGE_ALIGNED,0);
    local TitleLabel = createLabel(Title, 36,2, 282,18, Window, LABEL_RIGHT);
      setGadgetFont  (TitleLabel,TitleFont);
      setGadgetLayout(TitleLabel, 0,EDGE_ALIGNED,EDGE_ALIGNED,0);
    local SubtitleLabel = createLabel(Subtitle, 36,22, 282,16, Window, LABEL_RIGHT);
      setGadgetFont  (SubtitleLabel,SubtitleFont);
      setGadgetLayout(SubtitleLabel, 0,EDGE_ALIGNED,EDGE_ALIGNED,0);
    local UpperSeparator = createPanel(2,40, 316,2, Window);
      setPanelPixmap (UpperSeparator, sunkenLine, PANELPIXMAP_TILE);
      setGadgetLayout(UpperSeparator, EDGE_ALIGNED,EDGE_ALIGNED,EDGE_ALIGNED,0);
    local ClientArea = createTextArea(2,44, 316,174, Window, TEXTAREA_READONLY);
      setGadgetLayout(ClientArea, EDGE_ALIGNED,EDGE_ALIGNED,EDGE_ALIGNED,EDGE_ALIGNED);
      setGadgetColor (ClientArea, 128,128,128, true)
    local LowerSeparator = createPanel(2,220, 316,2, Window);
      setPanelPixmap (LowerSeparator, sunkenLine, PANELPIXMAP_TILE);
      setGadgetLayout(LowerSeparator, EDGE_ALIGNED,EDGE_ALIGNED,0,EDGE_ALIGNED);
    local Statusbar = createLabel("(no special action required)", 2,224, 316,18, Window);
      setGadgetFont  (Statusbar,TextFont);
      setGadgetLayout(Statusbar, EDGE_ALIGNED,EDGE_ALIGNED,0,EDGE_ALIGNED);
--  setStatusText(Window, "(no special action required)");
  showGadget(Window);

--**** handle any incoming events... ****

  while true do
    waitEvent();
    if (EventId() == EVENT_WINDOWCLOSE) then break; end;
  end;
```

--------------------------------

### Minimal Lua 5.2 Usage Example in Free Pascal

Source: http://lua-users.org/wiki/LuaInFreePascal

Demonstrates initializing Lua 5.2, opening libraries, executing a string containing Lua 5.2 specific functions, and closing the state.

```pascal
uses lua52; (* 5.2 change *)

var L: Plua_State;
    result: integer;

begin
    L := luaL_newstate(); (* 5.2 change *)
    luaL_openlibs(L);
    result := luaL_dostring(L, 'print (unpack,table.unpack)');
    lua_close(L);         
end.
```

--------------------------------

### MRE p.24 Example: Currency Matching

Source: http://lua-users.org/wiki/ExPattern

Matches currency strings starting with '$' followed by digits, optionally including a decimal point and two more digits.

```lua
-- MRE p.24
local m = ( P'%$[0-9]+' * P'%.[0-9][0-9]?'^-1 ):compile() 
assert(str(m('$20.00')) == '$20.00')
assert(str(m('$20')) == '$20')
assert(str(m('$20.00.00')) == '$20.00')
```

--------------------------------

### Basic Inlining Example

Source: http://lua-users.org/wiki/SourceOptimizer

Demonstrates the source optimization process by showing an input Lua script and its transformed output after inlining.

```lua
-- input:
local y=-1
local function square(x) return x*x end
local function g(x) return x >= 0 and square(square(x))+1 or 1 end
while (function() y = g(y)^(1/4) return y < 2 end)() do
  print(y)
end

-- output:
local y = - 1
while 1 do
   local __v13x = y
   local __v10 = 0 <= __v13x
   if __v10 then
      local __v12x = __v13x
      local __v14x = __v12x * __v12x
      __v10 = __v14x * __v14x + 1
   end
   local __v11 = __v10
   if not __v11 then
      __v11 = 1
   end
   y = __v11 ^ (1 / 4)
   if not (y < 2) then
      break
   end
   print (y)
end

```

--------------------------------

### Yieldable for loop example setup

Source: http://lua-users.org/wiki/YieldableForLoops

This Lua code sets up coroutine functions and defines helper functions for input and message generation to demonstrate yieldable for loops.

```lua
local yield, resume, create, costatus =
  coroutine.yield, coroutine.resume, coroutine.create, coroutine.status

local function input(prompt)
  local inf, outf = io.stdin, io.stderr
  return function()
    outf:write(prompt," ")
    return inf:read()
  end
end

-- These could be quite a bit more complex
function eachmsg()
  return yield
end

-- This isn't actually used in this demo, but it could be :)
getmsg = coroutine.yield

-- This would probably be more complicated in a real app, too. 
function responder(name) 
 local n = 0 
 print(name.." is born!")
 for msg in eachmsg() do
   n = n + 1
   if msg == "goodbye" then break
   else print(name.." heard "..msg)
   end
 end
 print(name.." departs this vale of tears, after listening to "..n.." utterances")
end
```

--------------------------------

### Minimal Lua 5.1 Usage Example in Free Pascal

Source: http://lua-users.org/wiki/LuaInFreePascal

A basic example demonstrating how to initialize Lua, open libraries, execute a string, and close the Lua state in Free Pascal.

```pascal
uses lua, lualib, lauxlib;

var L: Plua_State;
    result: integer;

begin
    L := lua_open(); luaL_openlibs(L);
    result := lua_dostring(L, 
'for k in string.gmatch("a,b,c,d,e,f,g,h","([^,]+),") do print(k) end'
);
    lua_close(L);
end.
```

--------------------------------

### Configure Lua Startup Script

Source: http://lua-users.org/wiki/SciteMacroExpander

Configuration to load the macro expansion Lua script on SciTE startup. Requires an absolute path.

```properties
ext.lua.startup.script=$(SciteDefaultHome)/macro.lua
```

--------------------------------

### Get Next UTF-8 Character and Position

Source: http://lua-users.org/wiki/ValidateUnicodeString

Use `string.nextutf8` to retrieve the character at a given position and the starting position of the next character. This is useful for iterating through UTF-8 strings.

```lua
pos, char = string.nextutf8(string, orig_pos)
```

--------------------------------

### Listing Directory Contents with LunaticPython

Source: http://lua-users.org/wiki/FileSystemOperations

This example demonstrates how to list directory contents using Python's os.listdir function through the LunaticPython library. Ensure Python is installed and accessible.

```lua
require "python".import("os").listdir(".")
```

--------------------------------

### Main Application Fiber Setup (C++)

Source: http://lua-users.org/wiki/NonBlockingLuaExecutionWithWindowsFibers

This C++ code sets up the primary and Lua fibers. It initializes the Lua state, converts the main thread to a fiber, creates a new fiber for the Lua script, and enters a loop that switches between the two fibers. Pressing a key terminates the application.

```cpp
#ifndef _WIN32_WINNT
#define _WIN32_WINNT 0x0400 // Necessary to enable fiber functions.
#endif
#include <Windows.h>
#include <conio.h>

extern "C"
{
#include "lua.h"
#include "lualib.h"
#include "lauxlib.h"
}

LPVOID g_PrimaryFiber = NULL;
LPVOID g_LuaFiber = NULL;
lua_State* pLua = NULL;

VOID CALLBACK LuaFiberProc(PVOID lpParameter)
{
    luaL_dofile(pLua, "Script.lua");
}

int main()
{
    pLua = luaL_newstate();
    luaL_openlibs(pLua);

    g_PrimaryFiber = ConvertThreadToFiber(NULL);
    g_LuaFiber = CreateFiber(0, LuaFiberProc, NULL);
    for (;;)
    {
        if (_kbhit())
        {
            printf("This program has successfully used fibers!\n");
            printf("Goodbye.\n");
            return 0;
        }
        SwitchToFiber(g_LuaFiber);
    }
}
```

--------------------------------

### Realistic Lua Execution with State Management

Source: http://lua-users.org/wiki/LuaGenericCall

This example shows a more complete implementation, opening a Lua state, loading libraries, executing a script, and handling potential errors before closing the state.

```c
lua_State* L = lua_open();
luaL_openlibs(L);
const char* errmsg = lua_genpcall(L, "print 'Hello World!'", "");
if(errmsg)
  fprintf(stderr, "Lua error: %s\n", errmsg);
lua_close(L);
```

--------------------------------

### Fuzzy String Matching Example in Lua

Source: http://lua-users.org/wiki/LuaFuzzy

Demonstrates how to use the `fuzzy` function to compare strings and get a similarity score. This requires the `fuzzy` module to be loaded via `loadmodule`.

```lua
loadmodule("fuzzy")
thetext = [[A lnger Text to saerch]] 
searchstr = "longer"
print(fuzzy(thetext,searchstr))
-- gives about 54.54 
-- while 
print(fuzzy(thetext,"lnger")) 
-- gives 100, a complete match 

```

--------------------------------

### Example: Paint Function in wxLua

Source: http://lua-users.org/wiki/ExtractingWxClasses

Demonstrates how to get a wxWidgets object (wxPaintDC) from Lua using its class name and tag, then access it in C++. Remember to dereference the `class_tag` member.

```cpp
int Paint(lua_State* L)
{
	wxLuaState wxlState(L);
	wxPaintDC *dc;

	unsigned int tag;
	wxLuaBindClass* wxl_class;

	wxl_class = wxlState.GetLuaClass("wxPaintDC");     // get the WXLUACLASS
	tag = *wxl_class->class_tag;                       // remember to dereference the class_tag member!
	dc = (wxPaintDC*)wxlState.GetUserDataType(1, tag); // get the actual object

	  // ///////////////////////// //
	 //    Paint code goes here   //
	// ///////////////////////// //

	return 0;
}

```

--------------------------------

### Package System Usage Syntax

Source: http://lua-users.org/wiki/PackageSystem

Illustrates the basic syntax for using a package with optional arguments.

```lua
use "packagename" {options}
```

--------------------------------

### Require and Use a Module

Source: http://lua-users.org/wiki/AlternativeModuleDefinitions

Demonstrates how to load and use a previously defined module.

```lua
-- test1.lua
local m1=require "module1"
m1.dump(m1)
```

--------------------------------

### Get Lua C Flags with pkg-config

Source: http://lua-users.org/wiki/BuildingModules

Use pkg-config to retrieve the necessary compiler flags for Lua C headers. Assumes Lua was installed under the package name 'lua5.1'.

```bash
LUA_CFLAGS=`pkg-config lua5.1 --cflags`
```

--------------------------------

### os.spawn with command and zeroth argument

Source: http://lua-users.org/wiki/MauroIazzi

Demonstrates using `os.spawn` with a specified command and an explicit zeroth argument for different scenarios.

```lua
os.spawn{command="/bin/echo", [0]="echo", "hello", "world"}

```

```lua
os.spawn{command="/usr/bin/vim", [0]="ex", "ex.c"}

```

```lua
os.spawn{command="/bin/busybox", args={[0]="ls", "ex.c"}}

```

```lua
os.spawn{command="/bin/busybox", args={[0]="cp", "ex.c", "ex2.c"}}

```

--------------------------------

### Example Compilation Command

Source: http://lua-users.org/wiki/SimpleLuaApiExample

This command compiles the C program, linking against the Lua library. The include and library paths may need adjustment based on your system's Lua installation.

```bash
cc -o test test.c -I/usr/local/include -L/usr/local/lib -llua -lm

```

--------------------------------

### Minimal Lua 5.3 Usage Example in Free Pascal

Source: http://lua-users.org/wiki/LuaInFreePascal

Shows how to initialize Lua 5.3, open libraries, execute a string with UTF8 handling, and close the Lua state, including the use of the 'dynlibs' unit.

```pascal
uses lua53, dynlibs;

var L: Plua_State;
    result: integer;

begin
    L := luaL_newstate(); 
    luaL_openlibs(L);
    result := luaL_dostring(L, 
'print ("`Hélène` has ".utf8.len"Hélène".." UTF8 characters.")');
    lua_close(L);         
end.
```

--------------------------------

### Bignum Library Initialization in Lua

Source: http://lua-users.org/wiki/HammingNumbersVariant

Initializes a limited bignum library within a Lua do-block. This setup is intended to provide basic support for large numbers required by the Hamming number examples.

```lua
do
  -- very limited bignum stuff; just enough for the examples here.
  -- Please feel free to improve it.
  local base = 1e15
```

--------------------------------

### Example Usage of Sorted Iteration in Lua

Source: http://lua-users.org/wiki/SortedIteration

Demonstrates the difference between normal iteration with pairs() and sorted iteration using the custom orderedPairs() function. No special setup is needed beyond defining the orderedPairs functions.

```lua
t = {
    ['a'] = 'xxx',
    ['b'] = 'xxx',
    ['c'] = 'xxx',
    ['d'] = 'xxx',
    ['e'] = 'xxx',
}

print("Normal iterating with pairs")
for key, val in pairs(t) do
    print(key.." : "..val)
end

print("Ordered iterating")
for key, val in orderedPairs(t) do
    print(key.." : "..val)
end

--[[ Result:
Normal iterating with pairs
a : xxx
c : xxx
b : xxx
e : xxx
d : xxx
Ordered iterating
a : xxx
b : xxx
c : xxx
d : xxx
e : xxx
]]

```

--------------------------------

### Lua Persistent Tables: VM Setup for Get

Source: http://lua-users.org/wiki/PersistentTablesSqlite

Prepares the SQLite virtual machine (VM) for retrieving a value. It resets the VM, binds the table TID, and binds the key (handling encoded strings).

```lua
local _persist_vm_setup = function (lp,vm,TID,k)
  local key,kyp = _persist_key_kyp(lp,k) -- this must come before vm:reset since it might use vm
  assert(vm:reset()==sqlite3.OK,"db reset error")
  assert(vm:bind(1,TID)==sqlite3.OK,"db TID bind error")
  if kyp=="e"
  then
    assert(vm:bind_blob(2,key)==sqlite3.OK,"db Key bind error")
  else
    assert(vm:bind(2,key)==sqlite3.OK,"db Key bind error")
  end
  assert(vm:bind(3,kyp)==sqlite3.OK,"db Kyp bind error")
end
```

--------------------------------

### Simple Lua C API Example: Loading and Running a Script

Source: http://lua-users.org/wiki/SampleCode

A basic example demonstrating how to interface with Lua from C. This program loads and runs a Lua script file, sets Lua variables, and retrieves a return value.

```C
//[[ SimpleLuaApiExample
//
// Simple intro to interfacing to Lua from C: C program loads/runs a Lua script file,
// sets Lua variables and retrieves return value (example)
//]]

#include <stdio.h>
#include <lua.h> // Lua core API
#include <lauxlib.h> // Lua auxiliary functions
#include <lualib.h> // Lua standard libraries

int main() {
    // Create a new Lua state
    lua_State *L = luaL_newstate();
    if (L == NULL) {
        fprintf(stderr, "Error creating Lua state\n");
        return 1;
    }

    // Load standard Lua libraries
    luaL_openlibs(L);

    // --- Load and run a Lua script --- 
    const char *lua_script_file = "my_script.lua"; // Assume this file exists
    printf("Loading and running Lua script: %s\n", lua_script_file);

    // Load the script into the Lua stack
    if (luaL_loadfile(L, lua_script_file) || lua_pcall(L, 0, LUA_MULTRET, 0) != LUA_OK) {
        fprintf(stderr, "Error running script: %s\n", lua_tostring(L, -1));
        lua_pop(L, 1); // Pop error message
        lua_close(L);
        return 1;
    }
    printf("Script executed successfully.\n\n");

    // --- Set a Lua variable from C --- 
    const char *var_name = "greeting";
    const char *var_value = "Hello from C!";
    lua_pushstring(L, var_value);
    lua_setglobal(L, var_name);
    printf("Set Lua global variable '%s' to '%s'\n\n", var_name, var_value);

    // --- Retrieve a return value from Lua --- 
    // Assume 'my_script.lua' defines a function 'calculate_sum' that returns a number
    lua_getglobal(L, "calculate_sum"); // Push the function onto the stack
    if (lua_isfunction(L, -1)) {
        // Push arguments for the function (e.g., 5 and 10)
        lua_pushnumber(L, 5);
        lua_pushnumber(L, 10);

        // Call the function with 2 arguments, expecting 1 return value
        if (lua_pcall(L, 2, 1, 0) == LUA_OK) {
            if (lua_isnumber(L, -1)) {
                double result = lua_tonumber(L, -1);
                printf("Called Lua function 'calculate_sum(5, 10)', result: %.2f\n", result);
            } else {
                fprintf(stderr, "Lua function 'calculate_sum' did not return a number.\n");
            }
            lua_pop(L, 1); // Pop the return value
        } else {
            fprintf(stderr, "Error calling Lua function: %s\n", lua_tostring(L, -1));
            lua_pop(L, 1); // Pop error message
        }
    } else {
        fprintf(stderr, "Lua function 'calculate_sum' not found.\n");
        lua_pop(L, 1); // Pop the non-function value
    }

    // Close the Lua state
    lua_close(L);
    printf("\nLua state closed.\n");

    return 0;
}

/*
Example my_script.lua:

print("Inside my_script.lua!")

-- Accessing the variable set from C
if greeting then
  print("C says: " .. greeting)
else
  print("Greeting variable not set by C.")
end

-- Function to be called from C
function calculate_sum(a, b)
  print(string.format("Lua: calculate_sum(%d, %d) called.", a, b))
  return a + b
end

return "Script finished successfully"
*/

```

--------------------------------

### List Partition Example

Source: http://lua-users.org/wiki/SymbolicDifferentiation

Demonstrates the behavior of the List.partition function with different input types and predicate functions.

```lua
List{1,2,3,4}:partition(function(x) return x > 2 end)
--> {false={1,2},true={3,4}}
List{'one',math.sin,10,20,{1,2}}:partition(type)
--> {function={function: 00369110},string={one},number={10,20},table={{{1,2}} }
```

--------------------------------

### Lua Scheduler Example with Wait Function

Source: http://lua-users.org/wiki/SituationScheduler

Demonstrates starting two concurrent tasks using a scheduler. The `wait` function pauses a coroutine until a specified time, returning a condition for the scheduler. Ensure `simsch` library is available.

```lua
-- Wait is a function that tells the scheduler to
-- wait for some number of seconds before restarting
-- the script.
function wait(seconds, start)
	local t = (start or os.clock()) + seconds
	coroutine.yield(
		function() return os.clock() >= t end)
end

-- Two pretty much identical functions that differ
-- only in the label they print and the amount of
-- time they wait between prints.
simsch.start(
	function ()
		for i=1,10 do
			wait(1)
			print("One ", i)
		end
	end)

simsch.start(
	function ()
		for i=1,10 do
			wait(1.6)
			print("Two ", i)
		end
	end)
	
-- Start it up
simsch.run()

```

--------------------------------

### Bind Shortcut to Editor Actions with OnEditorLine and OnChar

Source: http://lua-users.org/wiki/SciteExtMan

Utilize OnEditorLine and OnChar events to create custom shortcuts for editor actions. This example demonstrates binding Alt+X to a command that installs a temporary OnChar handler for subsequent character input.

```lua
 scite_Command 'AltX|do_altx_commands|Alt+X'

 function do_altx_commands()
    editor:BeginUndoAction()
    scite_OnChar('once',function (ch) 
       editor:EndUndoAction()
       editor:Undo()
       if ch == 's' then
          print('ess')
       elseif ch == 'f' then
          editor:BeginUndoAction()
          scite_OnEditorLine(handle_line)
        end
       return true
    end)
  end


```

--------------------------------

### Getopt Usage Example

Source: http://lua-users.org/wiki/PosixGetOpt

Demonstrates how to use the getopt function to parse command-line arguments. The function iterates through options and their arguments, yielding them for processing.

```lua
--
-- opt is either the option character, "?", or ":".
--
-- If opt is the option character, arg is either a string or false--if optstring
-- did not specify a required argument.
--
-- If opt is either "?" or ":", then arg is the unknown option or the option
-- lacking the required argument. Like the standard says, there's really only
-- one scenario for ":" to ever be returned. And per the standard, unless
-- optstring begins with a colon, "?" is returned instead.
--
for opt, arg in getopt(":a:b", ...) do
        print("opt:", opt, "arg:", arg)
end


```

--------------------------------

### Independent Scopes in Closures in Lua

Source: http://lua-users.org/wiki/ScopeTutorial

Demonstrates that each call to a function that creates local variables results in a new, independent scope. This example creates two independent sets of 'get' and 'set' functions using closures, each managing its own 'v' variable.

```lua
local function f()
  local v = 0
  local function get()
    return v
  end
  local function set(new_v)
    v = new_v
  end
  return {get=get, set=set}
end

local t, u = f(), f()
print(t.get()) --> 0
print(u.get()) --> 0
t.set(5)
u.set(6)
print(t.get()) --> 5
print(u.get()) --> 6
```

--------------------------------

### Static Type Checking with LuaFish

Source: http://lua-users.org/wiki/LuaFish

This example demonstrates LuaFish's static type checking. It uses macros like REQUIRE, NOGLOBALS, TYPED, and NUMBER to enforce type safety and detect errors at compile time. Ensure LuaFish 0.4 or later is installed.

```lua
-- type_usage2.lua
-- LuaFish static type checking example.
-- Using math library.
-- Requires LuaFish 0.4.
--
-- Note: CAPS identifiers are typically macros.

-- Compile-time import of static typing macros NUMBER, STRING, and TYPED
REQUIRE 'luafish.type'

-- disable global variable usage
NOGLOBALS()

-- Compile-time import of static type definitions for standard modules.
local math = REQUIRE 'math'
local _G = REQUIRE '_G'

local print = _G.print

-- False conditional demonstrates that static type checking is done
-- at compile-time.
if false then
  print(math.sqrt) -- ok
  --print(math.asdf) -- compile error: asdf not in math

  --print(math.sqrt('one')) -- compile error: arg must be number
  -- print(math.sqrt(2,3)) -- compile error: num args
  -- print(math.sqrt(-1)) -- compile error: arg must be non-negative
  print(math.sqrt(2)) -- ok

  local x = 2  -- weak, implicit type Number
  --x() -- compiler error: not callable
  x = print() -- implicit type not unknown after calling unknown function
  x() -- ok now

  -- Note: compare this to the above.
  local x = TYPED(-3) -- bind strong, implicit type to lexical
  --local x = NUMBER(-3)  -- alternate form with explicit type
  --x() -- compile error: not callable
  x = print() -- does not modify strong type
  --x() -- compile error: not callable

  local x = -3
  --print(math.sqrt(x)) -- compile error: arg must be non-negative
  x = x + 2
  --print(math.sqrt(x)) -- compile error: arg must be non-negative
  x = x + 1
  print(math.sqrt(x)) -- ok

  --math.sqrt(math.sin(-math.pi/2)) -- compile error: arg must be non-negative

  local x = STRING(print()) -- bind string type, unknown value f() 
  x = 5 -- doesn't affect strong type
        -- TODO: we could guard against such assignment.
  --print(math.sqrt(x)) -- compile error: arg must be number

  local sqrt = math.sqrt
  -- print(sqrt(-2)) -- compile error: arg must be non-negative

  local sqrt = TYPED(math.sqrt)
  -- print(sqrt(-2)) -- compile error: arg must be non-negative
end

print 'type_usage2.lua : done'

```

--------------------------------

### Interactive Lua Session Example

Source: http://lua-users.org/wiki/WikiStructure

Demonstrates syntax highlighting for interactive Lua sessions. Use 'Lua' highlighting for general compatibility.

```lua
> = "test if [["
test if [[
> = "test]]"
test]]

```

--------------------------------

### Install ansicolors Module

Source: http://lua-users.org/wiki/AnsiTerminalColors

Install the ansicolors module using LuaRocks. This command fetches and installs the package and its dependencies.

```bash
luarocks install ansicolors
```

```bash
luarocks doc ansicolors
```

--------------------------------

### Install lua-repl via LuaRocks

Source: http://lua-users.org/wiki/LuaRepl

Use this command to install the lua-repl package using LuaRocks. Ensure LuaRocks is installed and configured.

```bash
luarocks install luarepl
```

--------------------------------

### Basic Method Chaining Example

Source: http://lua-users.org/wiki/MethodChainingWrapper

Demonstrates basic method chaining on strings using custom functions.

```Lua
("  test  "):trim():repeatchars(2):upper() --> "TTEESSTT"

(function(x,y) return x*y end):curry(2) --> (function(y) return 2*y end)
```

--------------------------------

### Install Lua-SDL2 Module

Source: http://lua-users.org/wiki/LuaModuleLuaSdl

Use LuaRocks to install the lua-sdl2 module. Ensure SDL 2 development packages are installed on your system.

```bash
luarocks install lua-sdl2
```
Tokens:
Raw