lua api c++

lua c++ api подготовка проекта
Начальная проверка

#include<iostream>
using namespace std;

int main(int argc, char *argv[]) {

return 0;
};


Проверка lua

#include<iostream>
#include"incude/lua.hpp"
using namespace std;

int main(int argc, char *argv[]) {

return 0;
};

lua api c++. Работа со стеком.

#include<iostream>
#include"lua/lua.hpp"
using namespace std;

//Стек(англ.stack — стопка; читается стэк) — абстрактный тип данных, представляющий собой список элементов,
//организованных по принципу LIFO(англ.last in — first out, «последний вошёл — первым вышел»)
int main(int argc, char *argv[]) {

    lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    lua_pushnumber(L, 10);// отправить в стек число.
    lua_pushnumber(L, 20);// отправить в стек число.
    lua_pushnumber(L, 30);// отправить в стек число.
    int number = lua_tonumber(L, -3);// получить 10 из стека 1
    cout << number << endl;
    int number2 = lua_tonumber(L, -2);// получить 20 из стека 2
    cout << number2 << endl;
    int number3 = lua_tonumber(L, -1);// получить 30 из стека 3
    cout << number3 << endl;

    lua_close(L);// закрыть состояние
return 0;
};


lua c++ api. Работа со стеком. Полезность отрицательных индексов стека.

int main(int argc, char *argv[]) {lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/

    lua_pushnumber(L, 10);// 1
    lua_pushnumber(L, 20);// 2
    lua_pushnumber(L, 30);// 3
    /* стек выглядит так
    3 = 30    -1 = 30
    2 = 20    -2 = 20
    1 = 10    -3 = 10
    */
    cout << lua_tonumber(L, -1) << endl;// 30
    lua_pop(L, 1);// удалить n элементы из стека с его вершины. Если 3, выводится 0.
    cout << lua_tonumber(L, -1) << endl;// 20
    lua_close(L);// закрыть состояние
    cin.get();//ожидает ввода символа программа завершается.
    return 0;}


еще пример.

int checklua(lua_State *L, const char *file) {
    int status = luaL_loadfile(L, file);// проверка есть ли ошибки.
    try {
        if (status == 0) {// если нет ошибки в файле.
            luaL_dofile(L, file);// запуск файла, в которым все происходит.
            return 0;
        }
        else {
            string x = lua_tostring(L, -1);
            throw x;
        }
    }
    catch (string x) {
        cout << x << endl;
        //luaL_error(L,"error");
    }
};

template <class T>
void pushlua(lua_State * L, const T & value) {// функция добавление любого значение в стек.
    if constexpr (std::is_same_v<T, std::string>)
        lua_pushstring(L, value.c_str());
    else if constexpr (std::is_array_v<T> && std::is_same_v<std::remove_extent_t<T>, char>)
        lua_pushstring(L, value);
    else if constexpr (std::is_same_v<T, int>)
        lua_pushinteger(L, value);
    else if constexpr (std::is_same_v<T, double>)
        lua_pushnumber(L, value);
    else if constexpr (std::is_same_v<T, bool>)
        lua_pushboolean(L, value);
    else
        std::cerr << "I do not know what to do :(" << std::endl;
};

void showstack(lua_State* L) {// вывести весь стек.
    int i = lua_gettop(L);/* получаем количество элементов в стеке.*/
    cout << "\n  the number on the stack = " << i << "\n\n\n";
    int j = (i) * -1-1;
    i = -1;
    for (i; i > j; i--) {
        int t = lua_type(L, i);
        cout << "\t " << i << "  " << (j - i) * -1 << "\t";
        if (LUA_TSTRING == t) {
            cout << lua_tostring(L, i) << endl;
        }
        if (LUA_TNUMBER == t) {
            double x = lua_tonumber(L, i);
            int x2 = (int)x;
            if (x == x2) { cout << x2 << endl; }
            else { cout << x << endl; }
        }
        if (LUA_TBOOLEAN == t) {
            cout << lua_toboolean(L, i) << endl;
        }
        if (LUA_TLIGHTUSERDATA == t) {
            cout << "LIGHTUSERDATA " << endl;
        }
        if (LUA_TTABLE == t) {
            cout << "LUA_TTABLE " << endl;
        }
        if (LUA_TFUNCTION == t) {
            cout << "LUA_TFUNCTION " << endl;
        }
        if (LUA_TUSERDATA == t) {
            cout << "LUA_TUSERDATA " << endl;
        }
        if (LUA_TNIL == t) {
            cout << "LUA_TNIL " << endl;
        }
    }
};

int main() {
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    pushlua(L, 10);// отправить любое значение в стек.
    pushlua(L, 20);// отправить любое значение в стек.
    pushlua(L, 30);// отправить любое значение в стек.
    showstack(L);// вывести стек.

    cin.get();//ожидает ввода символа.

    pushlua(L, "a");// отправить любое значение в стек.
    pushlua(L, "b");// отправить любое значение в стек.
    pushlua(L, "c");// отправить любое значение в стек.
    showstack(L);// вывести стек.

    cin.get();//ожидает ввода символа.

    lua_pop(L, 4); //удалить 4 элемента из стека.

    showstack(L);// вывести стек.

    cin.get();//ожидает ввода символа.

Выводится.


  the number on the stack = 3


         -1  3  30
         -2  2  20
         -3  1  10


  the number on the stack = 6


         -1  6  c
         -2  5  b
         -3  4  a
         -4  3  30
         -5  2  20
         -6  1  10


  the number on the stack = 2


         -1  2  20
         -2  1  10


C:\Users\e\source\repos\Project1luaapi\Debug\Project1luaapi.exe (процесс 4608) завершает работу с кодом 0.
Чтобы закрыть это окно, нажмите любую клавишу…

lua c++ api. Получение значения переменных из lua.

#include<iostream>
#include<string>
#include"lua/lua.hpp"
using namespace std;
int main() {
    lua_State *L = luaL_newstate();
    luaL_openlibs(L);
    luaL_dofile(L, "man.lua");
    lua_getglobal(L, "x");
    lua_getglobal(L, "y");
    lua_getglobal(L, "z");
    int x = lua_tonumber(L, 1);
    cout << x << endl;
    string y = lua_tostring(L, 2);
    cout << y << endl;
    bool z = lua_toboolean(L, 3);
    cout << z << endl;
    lua_close(L);
    return 0;

lua
x=3
y="jh"
z =false

lua c++ api. Получение значения переменных из lua с помощью отрицательных индексов стека.

int checklua(lua_State *L, const char *file) {
    int status = luaL_loadfile(L, file);// проверка есть ли ошибки.
    try {
        if (status == 0) {// если нет ошибки в файле.
            luaL_dofile(L, file);// запуск файла, в которым все происходит.
            return 0;
        }
        else {
            string x = lua_tostring(L, -1);
            throw x;
        }
    }
    catch (string x) {
        cout << x << endl;
        //luaL_error(L,"error");
    }
};

int main() {int t;
    lua_State *L = luaL_newstate();
   checklua(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
    lua_getglobal(L, "x");// получить значение глобальной переменной x.

    t = lua_type(L, -1);
    if (LUA_TSTRING == t) { cout << "string x " << lua_tostring(L, -1) << endl; }
    else { cout << "not string  x " << endl; }

    lua_getglobal(L, "y");// получить значение глобальной переменной x.
    t = lua_type(L, -1);
    if (LUA_TSTRING == t) { cout << "string y " << lua_tostring(L, -1) << endl; }
    else { cout << "not string  y " << endl; }

    int n = lua_gettop(L);/* получаем количество элементов в стеке.*/
    cout <<"\nthe number on the stack = "  << n<<"\n";
    lua_settop(L, 0);// уст кол-во элементов в стеке. 0 - очистить стек.

       n = lua_gettop(L);/* получаем количество элементов в стеке.*/
    cout << "\nthe number on the stack = " << n << "\n";

    lua_close(L);// закрыть состояние
    cin.get();//ожидает ввода символа программа завершается.

    return 0;
}

Lua
y="i str"
x=23

выводится.

not string  x
string y i str

the number on the stack = 3

the number on the stack = 0


lua c++ api. Функции вывода элементов из стека и добавление лобого значение в стек.


int checklua(lua_State *L, const char *file) {
    int status = luaL_loadfile(L, file);// проверка есть ли ошибки.
    try {
        if (status == 0) {// если нет ошибки в файле.
            luaL_dofile(L, file);// запуск файла, в которым все происходит.
            return 0;
        }
        else {
            string x = lua_tostring(L, -1);
            throw x;
        }
    }
    catch (string x) {
        cout << x << endl;
        //luaL_error(L,"error");
    }
};
int main() {
    lua_State *L = luaL_newstate();
    checklua(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
   pushlua(L, "yes");// отправить любое значение в стек.
    pushlua(L,true);// отправить любое значение в стек.
    pushlua(L,100);// отправить любое значение в стек.
    pushlua(L,33.23);// отправить любое значение в стек.
    pushlua(L, "no");// отправить любое значение в стек.
    pushlua(L, 202);// отправить любое значение в стек.
    showstack(L);
    lua_pushvalue(L, 3);// отправляет копию элемент на вершину стека.
    showstack(L);
    lua_close(L);// закрыть состояние
    cin.get();//ожидает ввода символа программа завершается.
    return 0;
};


Выводится на экран.


  the number on the stack = 6


         6  202
         5  no
         4  33.23
         3  100
         2  1
         1  yes

  the number on the stack = 7


         7  100
         6  202
         5  no
         4  33.23
         3  100
         2  1
         1  yes



lua c++ api. Функции вывода элементов через отрицательные индексы из стека и добавление лобого значение в стек.

int checklua(lua_State *L, const char *file) {
    int status = luaL_loadfile(L, file);// проверка есть ли ошибки.
    try {
        if (status == 0) {// если нет ошибки в файле.
            luaL_dofile(L, file);// запуск файла, в которым все происходит.
            return 0;
        }
        else {
            string x = lua_tostring(L, -1);
            throw x;
        }
    }
    catch (string x) {
        cout << x << endl;
        //luaL_error(L,"error");
    }
};

int main() {
    lua_State *L = luaL_newstate();
    pushlua(L, "yes");// отправить любое значение в стек.
    pushlua(L, true);// отправить любое значение в стек.
    pushlua(L, 100);// отправить любое значение в стек.
    pushlua(L, 33.23);// отправить любое значение в стек.
   pushlua(L, "no");// отправить любое значение в стек.
    pushlua(L, 202);// отправить любое значение в стек.
    showstack(L);
    lua_pushvalue(L, -3);// отправляет копию элемент на вершину стека.
    showstack(L);
    lua_close(L);// закрыть состояние
    cin.get();//ожидает ввода символа программа завершается.
    return 0;
}


Выводится

  the number on the stack = 6


         -1  202
         -2  no
         -3  33.23
         -4  100
         -5  1
         -6  yes

  the number on the stack = 7


         -1  33.23
         -2  202
         -3  no
         -4  33.23
         -5  100
         -6  1
         -7  yes


lua c++ api. Получение значения переменных из lua,  обработка ошибок в lua.


int checklua(lua_State *L, const char *file) {
    int status = luaL_loadfile(L, file);// проверка есть ли ошибки.
    try {if (status == 0) {// если нет ошибки в файле.
            luaL_dofile(L, file);// запуск файла, в которым все происходит.
    return 0;}
    else {  string x =lua_tostring(L, -1);
    throw x;    }
    }
    catch (string x) {
        cout << x << endl;
        //luaL_error(L,"error");
    }
};

int main() {
    lua_State *L = luaL_newstate();
    luaL_openlibs(L);
    checklua(L, "main.lua");
    lua_getglobal(L, "x");
    int x = lua_tonumber(L, -1);

    cout << x << endl;
    lua_close(L);
    return 0;
};

Lua

X=23


lua c++ api. Получение значение переменной любого типа из lua.

using namespace std;

int checklua(lua_State *L, const char *file) {
    int status = luaL_loadfile(L, file);// проверка есть ли ошибки.
    try {if (status == 0) {// если нет ошибки в файле.
            luaL_dofile(L, file);// запуск файла, в которым все происходит.
    return 0;}
    else {  string x =lua_tostring(L, -1);
    throw x;    }
    }
    catch (string x) {
        cout << x << endl;
        //luaL_error(L,"error");
    }
};

int main(int argc, char *argv[]) {

    lua_State *L = luaL_newstate();
    luaL_openlibs(L);//открыть все стандартные библиотеки lua.
    checklua(lua, "main.lua");// Загружает и запускает заданный файл. Файл в котором все происходит.
    lua_getglobal(L, "x");// получить значение x
    if (lua_isnumber(L, 1)) {//  если 1 позиция в стеке число.
        int number = lua_tonumber(L, 1);// получить число.
        cout << "number x = " << number << endl;}

    else if (lua_isstring(L, 1)) {//  если 1 позиция в стеке строка.
        string str = lua_tostring(L, 1);// получить строка.
        cout << "string x = " << str << endl;}

    else if (lua_isboolean(L, 1)) {//  если 1 позиция в стеке булевая переменная.
        bool bo = lua_toboolean(L, 1);// получить булевая переменная.
        cout << "bool x = " << bo << endl;}
    else {  cout << "not x " <<endl;}
    lua_close(L);// закрыть состояние
    cin.get();//ожидает ввода символа программа завершается.
return 0;
}

Lua
 x=false



lua c++ api. Узнать тип переменной.

int main() {
    lua_State *L = luaL_newstate();
    luaL_openlibs(L);//открыть все стандартные библиотеки lua.
    checklua(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
    lua_getglobal(L, "x");// получить значение глобальной переменной x.
    int t = lua_type(L, 1); /* LUA_TNIL, LUA_TNUMBER, LUA_TBOOLEAN, LUA_TSTRING, LUA_TTABLE, LUA_TFUNCTION, LUA_TUSERDATA, LUA_TTHREAD,
    и LUA_TLIGHTUSERDATA.*/
    if (LUA_TSTRING == t){
        cout << "string x " << lua_tostring(L, 1) << endl;  }
    if (LUA_TNUMBER == t) {
        double x = lua_tonumber(L, 1);
        int x2 = (int)x;
        if (x==x2){ cout << "number int x "<<x2 << endl;}
        else {cout << "number double x "<< x << endl;   }   }
    if (LUA_TBOOLEAN == t) {    cout << "bool x = " << lua_toboolean(L, 1) << endl;
    }
    if (LUA_TNIL == t) { // если x нет.
        cout << "not x " << endl;   }
    lua_close(L);// закрыть состояние

    cin.get();//ожидает ввода символа программа завершается.

    return 0;
}

Lua
x=20.1

lua api. Определение типа переменной в lua через структуру.

using namespace std;
struct st{ string str; int x2; double x; bool bo;
double copyx = x; int copyx2 = x2; bool bo2 = bo;// это нужно,чтобы, избежать вывода мусор.
st(){}
st(string str) {
    this->str = str;}
st(int x2) {
    this->x2 = x2;}
st(double x) {
    this->x = x;}
st(bool bo) {
    this->bo = bo;}
void show() {
    if (str != "") {
        cout << str << endl;    };
    if (x != copyx) {
        cout << x << endl;  };
    if (x2 != copyx2) {
        cout << x2 << endl; };
    if (bo != bo2) {
    cout << bo << endl; };};
};

st getvar(lua_State *lua, const char *var ) {
    lua_getglobal(lua, var);// получить значение x
    st s;
    if (LUA_TSTRING == lua_type(lua, -1)) {// если  строка.
        s.str = lua_tostring(lua, -1);
        lua_pop(lua, 1);
        return s;   }
    if (LUA_TNUMBER == lua_type(lua, -1)) {// значение число.
        double x = lua_tonumber(lua, -1);
        int x2 = (int)x;
        if (x == x2) { s.x2=x2;
        lua_pop(lua, 1);
        return s;       }
        else {  s.x=x;
        lua_pop(lua, 1);
        return s;   }
    }

    if (LUA_TBOOLEAN == lua_type(lua, -1)) {// значение булевая переменная.
        s.bo = lua_toboolean(lua, 1);
        lua_pop(lua, 1);
        return s;
    }

    if (LUA_TNIL == lua_type(lua, -1)) { { cout << "not x " << endl; }
    }
}


int checklua(lua_State *L, const char *file) {
    int status = luaL_loadfile(L, file);// проверка есть ли ошибки.
    try {if (status == 0) {// если нет ошибки в файле.
            luaL_dofile(L, file);// запуск файла, в которым все происходит.
    return 0;}
    else {  string x =lua_tostring(L, -1);
    throw x;    }
    }
    catch (string x) {
        cout << x << endl;
        //luaL_error(L,"error");
    }
};

int main(int argc, char *argv[]) {

    lua_State *L = luaL_newstate();
    luaL_openlibs(L);//открыть все стандартные библиотеки lua.
    checklua(L, "main.lua");// Загружает и запускает заданный файл. Файл в котором все происходит.
    st t = getvar(L, "y");
    t.show();
    lua_close(L);// закрыть состояние
    cin.get();//ожидает ввода символа программа завершается.
    return 0;
}

Lua


x =10.3
y="hi lua"
z=true



Отправка в стек любого значение.

void pushtolua(lua_State *L, const char* v) {
    lua_pushstring(L, v);
}

void pushtolua(lua_State *L, int v) {
    lua_pushinteger(L, v);
}

void pushtolua(lua_State *L, double v) {
    lua_pushnumber(L, v);
}

void pushtolua(lua_State *L, bool v) {
    lua_pushboolean(L, v);
}

int main(int argc, char *argv[]) {
    lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    checkerror(L, LUA);//Функция проверка на ошибки.
    pushlua(L, 10);
    pushlua(L, 10.20);
    pushlua(L, "10");
    pushlua(L, true);
    showstack(L);

    lua_close(L);

    return 0;
}

lua c++ api. Присвовение значение переменной в lua.

int main(int argc, char *argv[]) {

    lua_State *L = luaL_newstate();
    luaL_openlibs(L);//открыть все стандартные библиотеки lua.
    lua_pushinteger(L, 30);// отправить целое число в стек.
    lua_setglobal(L, "c");// уст значение переменной в lua.
    checklua(L, "main.lua");// Загружает и запускает заданный файл. Файл в котором все происходит.
    lua_pcall(L, 0, 0, 0);// вызов функции в lua файле. 1 параметр кол-во передаваемых, кол-во возвращаемых, обработчик ошибок.
    lua_close(L);// закрыть состояние
    cin.get();//ожидает ввода символа программа завершается.
    return 0;
}

Lua

print(c)

выводится 30.


lua c++ api. функция вывода ключей и значений таблицы.

int pri(lua_State *L, const char t[] ) {// передаем указатель на состояние.
    lua_getglobal(L, t);// получить значение глобальной переменной, таблица.
    lua_assert(lua_istable(L, -1));// проверить является 1 элемент стека таблицей.
    if (LUA_TTABLE == lua_type(L, -1)) {// это таблица.
    lua_pushnil(L);//кладем на вершину стека NULL
  while (lua_next(L, 1) != 0) {/* получает ключ из стека и отправляет пару ключ - значение из таблицы.
      Ключ имеет - 2, а значение - 1.*/
        if (LUA_TSTRING == lua_type(L, -2)) {// если ключ строка.
        if (LUA_TNUMBER == lua_type(L, -1)) {// значение число.
        cout << "key " << lua_tostring(L, -2) << " value " << lua_tonumber(L, -1) << endl;}
        lua_pop(L, 1);// удалить n элементы из стека.
        }
    }
}
return 1;// вернуть 1.
};
int main() {
    lua_State *L = luaL_newstate();
    luaL_openlibs(L);
    checklua(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
    pri(L,"t");// вывести ключи и значения таблицы.
    lua_pcall(L, 0, 0, 0);// вызов функции в lua файле. 1 параметр кол-во передаваемых, кол-во возвращаемых, обработчик ошибок.
    lua_close(L);// закрыть состояние
    cin.get();//ожидает ввода символа программа завершается.
    return 0;}

lua

t= {x=10, y=20, z=30}
t1= {x=1, y=2, z=3}

выводится.
key y value 20
key x value 10
key z value 30


lua c++ api. Функции вывода ключей и значений таблицы, добавление ключа и значение в таблицу.

int checklua(lua_State *L, const char *file) {
    int status = luaL_loadfile(L, file);// проверка есть ли ошибки.
    try {
        if (status == 0) {// если нет ошибки в файле.
            //luaL_dofile(L, file);// запуск файла, в которым все происходит.
            return 0;
        }
        else {
            string x = lua_tostring(L, -1);
            throw x;
            return 0;
        }
    }
    catch (string x) {
        cout << x << endl;
        return 0;
        //luaL_error(L,"error");
    }
};

int pri(lua_State *L, const char t[]) {// передаем указатель на состояние.
    lua_getglobal(L, t);// получить значение глобальной переменной, таблица.
    lua_assert(lua_istable(L, -1));// проверить является 1 элемент стека таблицей.
    if (LUA_TTABLE == lua_type(L, -1)) {// это таблица.
        lua_pushnil(L);//кладем на вершину стека NULL
        while (lua_next(L, 1) != 0) {/* получает ключ из стека и отправляет пару ключ - значение из таблицы.
            Ключ имеет - 2, а значение - 1.*/
            if (LUA_TSTRING == lua_type(L, -2)) {// если ключ строка.
                if (LUA_TNUMBER == lua_type(L, -1)) {// значение число.
                    cout << "key " << lua_tostring(L, -2) << " value " << lua_tonumber(L, -1) << endl;
                }
                lua_pop(L, 1);// удалить n элементы из стека.
            }
        }
    }cout << "\n";
    return 1;// вернуть 1.
}

int addtab(lua_State *L, const char t[], const char key[], int value) {// передаем указатель на состояние.
    lua_getglobal(L, t);// получить значение глобальной переменной, таблицей.
    lua_pushnumber(L, value);// отправить значение в таблицу..
    lua_setfield(L, -2, key);// уст ключ для него.
    lua_getglobal(L, t);// получить значение глобальной переменной, таблицей.
    lua_getfield(L, -1, key);// отправить ключ в таблицу.
    return 0;// вернуть 1.
}
int main() {
    lua_State *L = luaL_newstate();
    //checklua(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.

    luaL_dofile(L, "main.lua");// запуск файла, в которым все происходит.
    pri(L, "t");// вывести ключи и значения таблицы.
    addtab(L, "t", "a", 1000);// уст ключ и значение для таблицы
    pri(L, "t");// вывести ключи и значения таблицы.
    addtab(L, "t", "b", 99);// уст ключ и значение для таблицы
    pri(L, "t");// вывести ключи и значения таблицы.
    lua_pcall(L, 0, 0, 0);// вызов функции в lua файле. 1 параметр кол-во передаваемых, кол-во возвращаемых, обработчик ошибок.
    lua_close(L);// закрыть состояние
    cin.get();//ожидает ввода символа программа завершается.
    return 0;
}


lua

t= {x=10, y=20, z=30}
t1= {x=1, y=2, z=3}

выводится.

key z value 30
key y value 20
key x value 10

key z value 30
key y value 20
key x value 10
key a value 1000

key x value 10
key z value 30
key a value 1000
key b value 99
key y value 20

вариант 2.


void getstack(lua_State* L, int pos) {
    if (LUA_TSTRING == lua_type(L, pos)) {
        cout << lua_tostring(L, pos);
    }
    if (LUA_TNUMBER == lua_type(L, pos)) {
        double x = lua_tonumber(L, pos);
        int x2 = (int)x;
        if (x == x2) { cout << x2; }
        else { cout << x; }
    }
    if (LUA_TBOOLEAN == lua_type(L, pos)) {
        cout << (lua_toboolean(L, pos) ? "true " : "false ");
    }
    if (LUA_TNIL == lua_type(L, pos)) {
        cout << "not /n";
    }
    if (LUA_TTABLE == lua_type(L, pos)) {
        cout << "LUA_TTABLE " << endl;
    }
    if (LUA_TFUNCTION == lua_type(L, pos)) {
        cout << "LUA_TFUNCTION " << endl;
    }
    if (LUA_TLIGHTUSERDATA == lua_type(L, pos)) {
        cout << "LIGHTUSERDATA " << endl;
    }
    if (LUA_TTABLE == lua_type(L, pos)) {
        cout << "LUA_TTABLE " << endl;
    }
    if (LUA_TFUNCTION == lua_type(L, pos)) {
        cout << "LUA_TFUNCTION " << endl;
    }
    if (LUA_TUSERDATA == lua_type(L, pos)) {
        cout << "LUA_TUSERDATA " << endl;
    }
    if (LUA_TNIL == lua_type(L, pos)) { // если x нет.
        cout << "nill " << endl;
    }
};
int pri(lua_State* L, const char t[]) {// передаем указатель на состояние.
    lua_getglobal(L, t);// получить значение глобальной переменной, таблица.
    lua_assert(lua_istable(L, -1));// проверить является 1 элемент стека таблицей.
    if (LUA_TTABLE == lua_type(L, -1)) {// это таблица.
        lua_pushnil(L);//кладем на вершину стека NULL
        while (lua_next(L, 1) != 0) {/* получает ключ из стека и отправляет пару ключ - значение из таблицы.
            Ключ имеет - 2, а значение - 1.*/
            cout << "key "; getstack(L, -2); cout << " value "; getstack(L, -1); cout << endl;
            lua_pop(L, 1);// удалить n элементы из стека.
        }

    }
return 0;// вернуть 1.
};
int main() {
    lua_State* L = luaL_newstate();
    luaL_openlibs(L);
    luaL_dofile(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
    pri(L, "t");// вывести ключи и значения таблицы.
    lua_close(L);// закрыть состояние
    return 0;
};





lua c++ api. Работа с таблицей.

int main() {
    lua_State *L = luaL_newstate();
    luaL_openlibs(L);//открыть все стандартные библиотеки lua.
    checklua(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
    lua_getglobal(L, "t");// получить значение глобальной переменной, таблица.
    lua_assert(lua_istable(L, 1));// проверить является 1 элемент стека таблицей.
    lua_pushstring(L, "x");// отправить ключ x в стек.
    lua_gettable(L, 1);// получить значение по ключу из стека.
    lua_assert(lua_isnumber(L, 2));// проверить является значение 2 элемента стека число.
    int x = lua_tonumber(L, 2);
    lua_getglobal(L, "t");// получить значение глобальной переменной таблица.
    lua_pushstring(L, "y");
    lua_gettable(L, 1);
    lua_assert(lua_isstring(L, 4));
    string y = lua_tostring(L, 4);
    lua_getglobal(L, "t");// получить значение глобальной переменной, таблицей.
    lua_getfield(L, 5, "z");// отправить ключ в таблицу.
    lua_assert(lua_isboolean(L, 5));
    bool z = lua_toboolean(L, 5);// получить булевое значение по ключу.
    lua_getglobal(L, "t");// получить значение глобальной переменной, таблицей.
    lua_pushstring(L, "dog");// отправить значение в таблицу.
    lua_setfield(L, 5, "a");// уст ключ для него.
    lua_getglobal(L, "t");// получить значение глобальной переменной, таблицей.
    lua_getfield(L, 5, "a");// отправить ключ в таблицу.
    lua_assert(lua_isstring(L, 5));
    string a = lua_tostring(L, -1);
    cout << "x = " << x << "\ny = " << y << "\nz = " << z << "\na = " << a << endl;
    lua_close(L);// закрыть состояние

    cin.get();//ожидает ввода символа программа завершается.

    return 0;
}

Lua

t= {x=300,y="ok you y",z=true}


lua c++ api. Работа с таблицей 2.


int main() {
    lua_State *L = luaL_newstate();
    luaL_openlibs(L);//открыть все стандартные библиотеки lua.
    checklua(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
    lua_getglobal(L, "t");// получить значение глобальной переменной, таблица.
    lua_assert(lua_istable(L, 1));// проверить является 1 элемент стека таблицей.
    lua_pushstring(L, "x");// отправить ключ x в стек.
    lua_gettable(L, 1);{// получить значение по ключу из стека.
    int t = lua_type(L, 2); /*Возвращает тип значения в указанном допустимом индексе или LUA_TNONE для недопустимого индекса
    (то есть индекса для «пустой» позиции стека). Типы возвращаемых lua_type кодируются с помощью следующих констант,
    определенных в lua.h: LUA_TNIL, LUA_TNUMBER, LUA_TBOOLEAN, LUA_TSTRING, LUA_TTABLE, LUA_TFUNCTION, LUA_TUSERDATA, LUA_TTHREAD,
    и LUA_TLIGHTUSERDATA.*/
    switch (t) {
    case LUA_TSTRING:// если строка.
        cout << "string x "<< lua_tostring(L, 2) << endl;
        break;
    case LUA_TBOOLEAN:// если булевая.
        cout <<"bool x = "<< lua_toboolean(L, 2)<<  endl;
        break;
    case LUA_TNUMBER:  // если число.
        cout << "number x = "<< lua_tonumber(L, 2) << endl;
        break;
    case LUA_TNIL:  // если x нет.
        cout << "not x " << endl;
        break;
    default:  // иначе.
        cout <<"other x = "<< lua_typename(L, t) << endl;
        break;  } }
    lua_close(L);// закрыть состояние

    cin.get();//ожидает ввода символа программа завершается.

    return 0;
}

Lua

t= {x="20"}


lua c++ api. Работа с таблицей. Извлечение из таблицы ключа и значение.


int pri(lua_State *lua) {// передаем указатель на состояние.

    if (LUA_TTABLE == lua_type(lua, 1)) {// это таблица.
        lua_pushnil(lua);//кладем на вершину стека NULL
        while (lua_next(lua, 1) !=0) {/* получает ключ из стека и отправляет пару ключ - значение из таблицы
          по заданному индексу(«следующая» пара после заданного ключа). Если в таблице больше нет элементов.
          Ключ имеет - 2, а значение - 1.*/
        if (LUA_TSTRING == lua_type(lua, -2)) {// если ключ строка.
            if (LUA_TNUMBER == lua_type(lua, -1)) {// значение число.
                cout << "key " << lua_tostring(lua, -2) << " value " << lua_tonumber(lua, -1) << endl;}

            if (LUA_TSTRING == lua_type(lua, -1)) {// значение строка.
            cout << "key " << lua_tostring(lua, -2) << " value " << lua_tostring(lua, -1) << endl; }
            lua_pop(lua, 1);// удалить n элементы из стека.
        }}
}
    return 1;// вернуть 1.
}
int main() {
    lua_State *L = luaL_newstate();
    luaL_openlibs(L);//открыть все стандартные библиотеки lua.
    lua_register(L, "pri", pri);// регистрируем функцию- имя состояние, имя функ в lua, имя функ тут.
    checklua(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
    lua_pcall(L, 0, 0, 0);// вызов функции в lua файле. 1 параметр кол-во передаваемых, кол-во возвращаемых, обработчик ошибок.
    lua_close(L);// закрыть состояние
    cin.get();//ожидает ввода символа программа завершается.
    return 0;
}

Lua

t={z="kj", x=23, y="dog",a=30,b=33}
pri(t)



lua c++ api работа с таблицей. Функция принимающую таблицу для изменения значений ключей.

#include<iostream>
#include<string>
#include<vector>

#include"include/lua.hpp"
using namespace std;

int pri(lua_State *L) {// передаем указатель на состояние.

    vector<string>v; // вектор для хранение ключей таблиции.
    if (LUA_TNUMBER != lua_type(L, 2)) {//проверка, второй аргумент является числом.
    cout << "bad second argument in function " << endl;
    return 1;   };
    int n = lua_tonumber(L, 2);
    if (LUA_TTABLE == lua_type(L, 1)) {
        cout << "\nthis is table \n" << endl;
        lua_pushnil(L);//кладем на вершину стека NULL.
        while (lua_next(L, 1) != 0) {// получает ключ из стека и отправляет пару ключ - значение из таблицы.

            if (LUA_TSTRING == lua_type(L, -2)) {// значение число.
                cout << "key " << lua_tostring(L, -2) << " value ";
                v.push_back(lua_tostring(L, -2));
                double x = lua_tonumber(L, -1);
                int x2 = (int)x;
                if (x == x2) {// int
                    cout << "number int  " << x2 << endl;   }
                else { cout << "number double " << x << endl; }
                lua_pop(L, 1);// удалить n элементы из стека.
            }
        }
    }
    else {  cout << "NOT table " << endl;
        if (LUA_TSTRING == lua_type(L, 1)) {
            cout << "this string " << lua_tostring(L, 1) << endl;   }
        if (LUA_TNUMBER == lua_type(L, 1)) {
            double x = lua_tonumber(L, 1);
            int x2 = (int)x;
            if (x == x2) { cout << "this number int " << x2 << endl; }
            else { cout << "this number double this " << x << endl; }
        }
        if (LUA_TBOOLEAN == lua_type(L, 1)) { cout << "this bool " << lua_toboolean(L, 1) << endl; }
        if (LUA_TNIL == lua_type(L, 1)) { // если нет.
            cout << "Nothing was passed.  " << endl;}
    }
    for (auto i : v){
        const char* x = i.c_str(); // из строки массив char.
        lua_getglobal(L, "t");// получить значение глобальной переменной, таблицей.
        lua_pushinteger(L, n);// отправить значение в таблицу.
        lua_setfield(L, 1, x);// уст ключ для него.
        lua_getglobal(L, "t");// получить значение глобальной переменной, таблицей.
        lua_getfield(L, 1, x);// отправить ключ в таблицу.
}
    return 1;// вернуть 1.
}
int main() {
    lua_State *L = luaL_newstate();
    luaL_openlibs(L);//открыть все стандартные библиотеки lua.
    lua_register(L, "pri", pri);// регистрируем функцию- имя состояние, имя функ в lua, имя функ тут.
    checklua(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
    lua_pcall(L, 0, 0, 0);// вызов функции в lua файле. 1 параметр кол-во передаваемых, кол-во возвращаемых, обработчик ошибок.
    lua_close(L);// закрыть состояние
    cin.get();//ожидает ввода символа программа завершается.
    return 0;
}


Lua

t={x=1, y=2 ,a=3,b=4}
a=nil

for k,v in pairs(t) do
    print(k,v)
end
pri(a,100)

    print("\n After \n")
for k,v in pairs(t) do
    print(k,v)
end


lua c++ api. Отправить таблицу с ключами и значением в lua.


int checklua(lua_State *L, const char *file) {
    int status = luaL_loadfile(L, file);// проверка есть ли ошибки.
    try {
        if (status == 0) {// если нет ошибки в файле.
            luaL_dofile(L, file);// запуск файла, в которым все происходит.
            return 0;
        }
        else {
            string x = lua_tostring(L, -1);
            throw x;
        }
    }
    catch (string x) {
        cout << x << endl;
        //luaL_error(L,"error");
    }
};
int main() {
    lua_State *L = luaL_newstate();
    luaL_openlibs(L);
    lua_newtable(L); /*создать пустую таблицу */

    lua_pushstring(L, "key x"); /* отправить ключ в стек */
    lua_pushstring(L, "value x"); /* отправить значение ключа в стек. */
    lua_rawset(L, -3); /*Сохраняет пару в таблице */
    lua_pushstring(L, "key y"); /* */
    lua_pushstring(L, "value y"); /*  */
    lua_rawset(L, -3); /*Сохраняет пару в таблице */
    lua_setglobal(L, "foo");// уст имя таблицы в lua.

    checklua(L, "main.lua");
    lua_close(L);
    return 0;
};

Lua

print(foo)
for k,v in pairs(foo) do
print(k.." "..v)
end

выводит

table: 013154E0
key x value x
key y value y

еще так можно.

void addkeyintab(lua_State *L, const char* key, const char* value){

    lua_pushstring(L, key); /* отправить ключ в стек */
    lua_pushstring(L, value); /* отправить значение ключа в стек. */
    lua_rawset(L, -3); /*Сохраняет пару в таблице */
}
void addkeyintab(lua_State *L, const char* key, int value) {

    lua_pushstring(L, key); /* отправить ключ в стек */
    lua_pushinteger(L, value); /* отправить значение ключа в стек. */
    lua_rawset(L, -3); /*Сохраняет пару в таблице */
}
int main() {lua_State *L = luaL_newstate();
    luaL_openlibs(L);
    lua_newtable(L); /*создать пустую таблицу */
    addkeyintab(L, "key y", "10"); /*добавить ключ и значение в таблицу */
    addkeyintab(L, "key x", 10); /*добавить ключ и значение в таблицу */
    lua_setglobal(L, "foo");// уст имя таблицы в lua.

    checklua(L, "main.lua");
    showstack(L);// вывести стек.
    lua_close(L);
    return 0;
};

Lua

print(foo)
for k,v in pairs(foo) do
print(k.." "..v)
end

Выводится

table: 00855520
key x 10
key y 10

  the number on the stack = 0


lua c++ api. Запуск lua файла.

#include"include/lua.hpp"

using namespace std;

int checklua(lua_State *L, const char *file) {
    int status = luaL_loadfile(L, file);// проверка есть ли ошибки.
    try {
        if (status == 0) {// если нет ошибки в файле.
            luaL_dofile(L, file);// запуск файла, в которым все происходит.
            return 0;
        }
        else {
            string x = lua_tostring(L, -1);
            throw x;
        }
    }
    catch (string x) {
        cout << x << endl;
        //luaL_error(L,"error");
    }
};


int main(int argc, char *argv[]) {

    lua_State *L = luaL_newstate();
    luaL_openlibs(L);//открыть все стандартные библиотеки lua.
    checklua(L, "main.lua");// Загружает и запускает заданный файл. Файл в котором все происходит.
    lua_pcall(L, 0, 0, 0);// вызов функции в lua файле. 1 параметр кол-во передаваемых, кол-во возвращаемых, обработчик ошибок.
    lua_close(L);// закрыть состояние
    cin.get();//ожидает ввода символа программа завершается.
return 0;
}

Lua
a = 3
b = 6
c= a+b
print(c)

lua c++ api. Регистрация новой C функции в lua.

int q(lua_State *L) {// передаем указатель на состояние.
    int x = lua_tonumber(L, 1); // получаем 1 элемент из стека.
    x = x * x;
   //cout << x << endl;
    lua_pushnumber(L, x);// умножаем x и отправляет в стек.
    return 1;// вернуть 1.
}
int main() {
    lua_State *L = luaL_newstate();
    luaL_openlibs(L);//открыть все стандартные библиотеки lua.
    lua_register(L, "q", q);// регистрируем функцию- имя состояние, имя функ в lua, имя функ тут.
    checklua(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
    lua_pcall(L, 0, 0, 0);// вызов функции в lua файле. 1 параметр кол-во передаваемых, кол-во возвращаемых, обработчик ошибок.
    lua_close(L);// закрыть состояние
    cin.get();//ожидает ввода символа программа завершается.
    return 0;}

lua
x = q(2)
print(x)



lua c++ api. Регистрация C функции в lua.


int foo(lua_State *L) {

    int x= lua_tonumber(L, -1);
    cout << x << endl;
    return 0; /* number of results */
}
int main(int argc, char *argv[]) {

    lua_State *L = luaL_newstate();
    luaL_openlibs(L);//открыть все стандартные библиотеки lua.
    lua_register(L, "foo", foo);// регистрируем функцию- имя состояние, имя функ в lua, имя функ тут.

    checklua(L, "main.lua");
    lua_pcall(L, 0, 0, 0);// вызов функции в lua файле. 1 параметр кол-во передаваемых, кол-во возвращаемых, обработчик ошибок.
    lua_close(L);// закрыть состояние
    cin.get();//ожидает ввода символа программа завершается.
    return 0;
}


Lua
foo(2)

lua c++ api. Запуск C функции в lua.


int checklua(lua_State *L, const char *file) {
    int status = luaL_loadfile(L, file);// проверка есть ли ошибки.
    try {if (status == 0) {// если нет ошибки в файле.
            luaL_dofile(L, file);// запуск файла, в которым все происходит.
    return 0;}
    else {  string x =lua_tostring(L, -1);
    throw x;    }
    }
    catch (string x) {
        cout << x << endl;
        //luaL_error(L,"error");
    }
};
int foo(lua_State *L) {
    cout << "hi foo c++" << endl;
    return 0;
}
int main() {
    lua_State *L = luaL_newstate();
    luaL_openlibs(L);
    checklua(L, "main.lua");
    lua_pushcfunction(L, foo);// отправить c функцию в стек.
    lua_pcall(L, 0, 0, 0);// вызвать функцию foo.
    lua_close(L);
    return 0;
};


Lua

Foo()


lua c++ api. Запуск функции на lua, с возвращаемыми параметрами.

int main() {
    lua_State *L = luaL_newstate();
    luaL_openlibs(L);//открыть все стандартные библиотеки lua.
    checklua(L, "main.lua");
    lua_getglobal(L, "pri");// получаем из lua функцию pri.
    lua_pushnumber(L, 5);// отправляем в стек число.
    lua_pushnumber(L, 10);// отправляем в стек число.

    lua_pcall(L, 2, 1, 0);// вызов функции, передаем 2 параметра, возвращаем 1.
    cout << lua_tonumber(L, 1) << endl;// получаем из стека возвращаемое значение из функции.
    lua_close(L);// закрыть состояние
    cin.get();//ожидает ввода символа программа завершается.

    return 0;
}

Lua

function pri(x,y)
sum = x+y
return sum
end


lua c++ api. Вызов определенной функции из lua.

int main() {
    lua_State *L = luaL_newstate();
    int x = 5, y = 6;
    luaL_dofile(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
    lua_getglobal(L, "f"); /* вызываемая функция */
    lua_pushnumber(L, x); /* поместить на стек 1-й аргумент */
    lua_pushnumber(L, y); /* поместить на стек 2-й аргумент */
    if (lua_pcall(L, 2, 1, 0) != 0) {/* вызвать функцию (2 аргумента, 1 результат) */
        luaL_error(L, "error running function 'f': %s", lua_tostring(L, -1));}/* получить результат */
    cout << lua_tonumber(L, -1) << "\n";
    lua_pop(L, 1);
    lua_close(L);
    cin.get();//ожидает ввода символа программа завершается.
    return 0;
}

Lua

function f(x, y)
    return (x*y)
end


lua c++ api. Функция, принимающая переменное количество аргументов.

//Эта функция может принимать переменное число параметров через L
int pri(lua_State * L) {// передаем указатель на состояние.
    int n = lua_gettop(L);/* получаем количество параметров переданных в функцию.
    Возвращает индекс верхнего элемента в стеке. Поскольку индексы начинаются с 1, этот результат
    равен количеству элементов в стеке (и поэтому 0 означает пустой стек).*/
    cout <<"count elements "<< n << endl;
    for (int i = 1; i <= n; ++i) {
    int t = lua_type(L, i); /* LUA_TNIL, LUA_TNUMBER, LUA_TBOOLEAN, LUA_TSTRING, LUA_TTABLE, LUA_TFUNCTION, LUA_TUSERDATA, LUA_TTHREAD,
       и LUA_TLIGHTUSERDATA.*/
    if (LUA_TSTRING == t) {
            cout <<i << " string = " << lua_tostring(L, i) << endl;}
    if (LUA_TNUMBER == t) {
            double x = lua_tonumber(L, i);
            int x2 = (int)x;
            if (x == x2) { cout << i<<" number int = " << x2 << endl; }
            else { cout << i<<" number double = " << x << endl; }}
    if (LUA_TBOOLEAN == t) {cout <<i<< " bool = " << lua_toboolean(L, i) << endl;   }

    }
    return 1;// вернуть 1.
}
int main() {
    lua_State *L = luaL_newstate();
    luaL_openlibs(L);//открыть все стандартные библиотеки lua.
    lua_register(L, "pri", pri);// регистрируем функцию- имя состояние, имя функ в lua, имя функ тут.
    checklua(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
    lua_pcall(L, 0, 0, 0);// вызов функции в lua файле. 1 параметр кол-во передаваемых, кол-во возвращаемых, обработчик ошибок.
    lua_close(L);// закрыть состояние
    cin.get();//ожидает ввода символа программа завершается.
    return 0;
}

Lua

pri(2,"youtube", false, 6,"end",5.236, true)



lua c++ api. мета таблицы.


void addkeyintab(lua_State *L, const char* key, int value) {
    lua_pushstring(L, key); /* отправить ключ в стек */
    lua_pushinteger(L, value); /* отправить значение ключа в стек. */
    lua_rawset(L, -3); /*Сохраняет пару в таблице */
}
struct vec{ static int vector(lua_State* L) {// методы классы должны быть статик.
        lua_newtable(L); //создать новую таблицу.
        addkeyintab(L, "x", 0);// установить значение ключа таблицы.
        luaL_getmetatable(L, "mt");// получить мета таблицу.
        lua_setmetatable(L, -2);
        return 1;   }

    static int __add(lua_State* L)  {
        lua_pushstring(L, "x");
        lua_gettable(L, -3);
        int firts = lua_tonumber(L, -1);

        lua_pushstring(L, "x");
        lua_gettable(L, -3);
        int second = lua_tonumber(L, -1);

        vec::vector(L);// вывоз метода обнулиние таблицы суммы ключей.
        lua_pushstring(L, "z");// ключ таблицы со значение ее суммы.
        lua_pushnumber(L, firts + second);// сумму отправить в стек как ключ таблицы.
        lua_rawset(L, -3);// уст таблицу без мета.методов.
        return 1;
    }
};

const char * LUA_FILE = R"(
        v1 = vector()   -- v1 is a table
        v2 = vector() -- v2 is a table
        v1.x = 5  v2.x = 18
        v3 = v1 + v2
        result = v3.z)";
int main(){lua_State* L = luaL_newstate();

lua_pushcfunction(L, vec::vector);
lua_setglobal(L, "vector");

luaL_newmetatable(L, "mt");
lua_pushstring(L, "__add");
lua_pushcfunction(L, vec::__add);
lua_settable(L, -3);

luaL_dostring(L, LUA_FILE);

lua_getglobal(L, "result");
cout << "result = " <<lua_tonumber(L, -1)<< endl;
lua_close(L);
}


lua c++ api. мета таблицы 2.


struct Sprite { int x;// структура.

    Sprite() : x(0) {}//конструктор по умолчанию.

    ~Sprite() { cout << "destror "<< this << endl; }

    void set(int x) {this->x = x;}// уст значение x.

    void show() {
        printf("sprite(%p): x = %d\n", this, x);
    }
};

int create(lua_State* L) {// создать структуру.
    void* st = lua_newuserdata(L, sizeof(Sprite));// выделить память под польз.данные отправить в стек.
    new (st) Sprite();//выделить память под новый объект класса.
    luaL_getmetatable(L, "mt");// получить мета таблицу.
    lua_setmetatable(L, -2);// уст мета таблицу.
    return 1;
};

int set(lua_State* L) {
    Sprite* sprite = (Sprite*)lua_touserdata(L, -2);// получить польз.данные.
    int x = lua_tonumber(L, -1);
    sprite->set(x);// вызов метода класса, уст значение x
    return 0;
};

int show(lua_State* L) {
    Sprite* sprite = (Sprite*)lua_touserdata(L, -1);
    sprite->show();
    return 0;
};
int DestroySprite(lua_State* L) {
    Sprite* sprite = (Sprite*)lua_touserdata(L, -1);
    sprite->~Sprite();
    return 0;
};

const char* LUA_FILE = R"(
        sprite = create()
        set( sprite, 5 )
        show( sprite )
        set( sprite, 12 )
        show( sprite )
        sprite2 = create()
        set( sprite2, 33 )
        show( sprite2 )
        )";

int main() {lua_State* L = luaL_newstate();

    luaL_newmetatable(L, "mt");// создать метп таблицу.
    lua_pushstring(L, "__gc");// отправить в стек сборщик мусора.
    lua_pushcfunction(L, DestroySprite);// установить значение ключа, как вызов деструктор.
    lua_settable(L, -3);// установить таблицу.

    lua_pushcfunction(L, create);// отправить ключ как функцию в стек.
    lua_setglobal(L, "create");
    lua_pushcfunction(L, set);// отправить ключ как функцию в стек.
    lua_setglobal(L, "set");
    lua_pushcfunction(L, show);// отправить ключ как функцию в стек.
    lua_setglobal(L, "show");

    luaL_dostring(L, LUA_FILE);

    lua_close(L);
}


lua c++ api. мета таблицы 3.


static int numberOfSpritesExisting = 0;

struct Sprite
{
    int x;
    int y;

    Sprite() : x(0), y(0)
    {
        numberOfSpritesExisting++;
    }

    ~Sprite()
    {
        numberOfSpritesExisting--;
    }

    void Move(int velX, int velY)
    {
        x += velX;
        y += velY;
    }

    void Draw()
    {
        printf("sprite(%p): x = %d, y = %d\n", this, x, y);
    }
};

int CreateSprite(lua_State* L){
    void* pointerToASprite = lua_newuserdata(L, sizeof(Sprite));
    new (pointerToASprite) Sprite();
    luaL_getmetatable(L, "SpriteMetaTable");
    lua_assert(lua_istable(L, -1));
    lua_setmetatable(L, -2);
    return 1;
};

int DestroySprite(lua_State* L){
    Sprite* sprite = (Sprite*)lua_touserdata(L, -1);
    sprite->~Sprite();
    return 0;
};

int MoveSprite(lua_State* L){
    Sprite* sprite = (Sprite*)lua_touserdata(L, -3);
    lua_Number velX = lua_tonumber(L, -2);
    lua_Number velY = lua_tonumber(L, -1);
    sprite->Move((int)velX, (int)velY);
    return 0;
};

int DrawSprite(lua_State* L){
    Sprite* sprite = (Sprite*)lua_touserdata(L, -1);
    sprite->Draw();
    return 0;
};

const char* LUA_FILE = R"(
    sprite = Sprite.new()
    sprite:Move( 5, 7 )     -- Sprite.Move( sprite, 5, 7 )
    sprite:Draw()
    sprite:Move( 1, 2 )
    sprite:Draw()
    sprite2 = Sprite.new()
    sprite2:Move( 3, 3 )
    sprite2:Draw()
        -- sprite   -> sprite is a userdatum
        --      has a metatable called SpriteMetaTable
        --          dont have Move(), use the __index metamethod
        --          __index metamethod is a table which is Sprite
        --          Sprite has a field called Move(), invoke that
        --          Move() is a c function
        --          invoke, pass the userdatum as the first parameter.
        )";


int main() {
    lua_State* L = luaL_newstate();

    lua_newtable(L);
    int spriteTableIdx = lua_gettop(L);
    lua_pushvalue(L, spriteTableIdx);
    lua_setglobal(L, "Sprite");

    lua_pushcfunction(L, CreateSprite);
    lua_setfield(L, -2, "new");
    lua_pushcfunction(L, MoveSprite);
    lua_setfield(L, -2, "Move");
    lua_pushcfunction(L, DrawSprite);
    lua_setfield(L, -2, "Draw");

    luaL_newmetatable(L, "SpriteMetaTable");
    lua_pushstring(L, "__gc");
    lua_pushcfunction(L, DestroySprite);
    lua_settable(L, -3);

    lua_pushstring(L, "__index");
    lua_pushvalue(L, spriteTableIdx);
    lua_settable(L, -3);

    luaL_dostring(L, LUA_FILE);
    lua_close(L);

    lua_assert(numberOfSpritesExisting == 0);
    return 0;
}


lua c++ api. мета таблицы 4.


static int numberOfSpritesExisting = 0;

struct Sprite {
    int x;
    int y;

    Sprite() : x(0), y(0)
    {
        numberOfSpritesExisting++;
    }

    ~Sprite()
    {
        numberOfSpritesExisting--;
    }

    void Move(int velX, int velY)
    {
        x += velX;
        y += velY;
    }

    void Draw()
    {
        printf("sprite(%p): x = %d, y = %d\n", this, x, y);
    }
};

auto CreateSprite = [](lua_State* L) -> int
{
    void* pointerToASprite = lua_newuserdata(L, sizeof(Sprite));
    new (pointerToASprite) Sprite();
    luaL_getmetatable(L, "mt");
    lua_assert(lua_istable(L, -1));
    lua_setmetatable(L, -2);
    return 1;
};

auto DestroySprite = [](lua_State* L) -> int
{
    Sprite* sprite = (Sprite*)lua_touserdata(L, -1);
    sprite->~Sprite();
    return 0;
};

auto MoveSprite = [](lua_State* L) -> int
{
    Sprite* sprite = (Sprite*)lua_touserdata(L, -3);
    lua_Number velX = lua_tonumber(L, -2);
    lua_Number velY = lua_tonumber(L, -1);
    sprite->Move((int)velX, (int)velY);
    return 0;
};

auto DrawSprite = [](lua_State* L) -> int
{
    Sprite* sprite = (Sprite*)lua_touserdata(L, -1);
    sprite->Draw();
    return 0;
};

auto SpriteIndex = [](lua_State* L) -> int
{
    lua_assert(lua_isuserdata(L, -2));
    lua_assert(lua_isstring(L, -1));

    Sprite* sprite = (Sprite*)lua_touserdata(L, -2);
    const char* index = lua_tostring(L, -1);
    if (strcmp(index, "x") == 0)
    {
        lua_pushnumber(L, sprite->x);
        return 1;
    }
    else if (strcmp(index, "y") == 0)
    {
        lua_pushnumber(L, sprite->y);
        return 1;
    }
    else
    {
        lua_getglobal(L, "Sprite");
        lua_pushstring(L, index);
        lua_rawget(L, -2);
        return 1;
    }
};

const char* LUA_FILE = R"(
    sprite = Sprite.new()
    sprite:Move( 6, 7 )     -- Sprite.Move( sprite, 6, 7 )
    sprite:Draw()
    temp_x = sprite.x
    )";
int main(){
    lua_State* L = luaL_newstate();

    lua_newtable(L);
    int spriteTableIdx = lua_gettop(L);
    lua_pushvalue(L, spriteTableIdx);
    lua_setglobal(L, "Sprite");

    lua_pushcfunction(L, CreateSprite);
    lua_setfield(L, -2, "new");
    lua_pushcfunction(L, MoveSprite);
    lua_setfield(L, -2, "Move");
    lua_pushcfunction(L, DrawSprite);
    lua_setfield(L, -2, "Draw");

    luaL_newmetatable(L, "mt");
    lua_pushstring(L, "__gc");
    lua_pushcfunction(L, DestroySprite);
    lua_settable(L, -3);

    lua_pushstring(L, "__index");
    lua_pushcfunction(L, SpriteIndex);
    lua_settable(L, -3);

    int doResult = luaL_dostring(L, LUA_FILE);
    if (doResult != LUA_OK)
    {
        printf("Error: %s\n", lua_tostring(L, -1));
    }

    lua_getglobal(L, "temp_x");
    lua_Number temp_x = lua_tonumber(L, -1);
    lua_assert(temp_x == 6);

    lua_close(L);

    lua_assert(numberOfSpritesExisting == 0);
}


lua c++ api. Функции для работы с указателем.

struct st { int number =10;
    int *x = &number;
    st() { this->x = *&x; }
    st(int number) { this->number = *&number; }
};
int create(lua_State* L) {//Функция создания объекта структуры.
   int x = lua_tonumber(L, -1);
   void *s = lua_newuserdata(L, sizeof(st));/*Эта функция выделяет новый блок памяти с заданным размером,*/
   new(s) st(x);  luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при
     заданном приемлемом индексе.*/
   lua_setmetatable(L, 1);//получает таблицу из стека и уст ее в качестве  новой метатаблицы для значения с заданным допустимым индексом.
    return 1;
};

int show(lua_State* L) {
    st *s = (st*)lua_touserdata(L, -1);;// получаем польз. данные.
    cout << "andress " << &(s->x) <<" value " << *(s->x)<<endl;// адрес памяти
    s->~st();//вызов метода деструктор.
    return 0;
};

int checklua(lua_State *L, const char *file) {
    int status = luaL_loadfile(L, file);// проверка есть ли ошибки.
    try {if (status == 0) {// если нет ошибки в файле.
            luaL_dofile(L, file);// запуск файла, в которым все происходит.
    return 0;}
    else {  string x =lua_tostring(L, -1);
    throw x;    }
    }
    catch (string x) {
        cout << x << endl;
        //luaL_error(L,"error");
    }
};

int main() {lua_State* L = luaL_newstate();
    lua_newtable(L);
    lua_pushcfunction(L, create);//уст указатель на функцию C++ и создает внутри Lua
    lua_setglobal(L, "get"); //получает значение из стека и уст значение global name.
    lua_pushcfunction(L, show);
    lua_setglobal(L, "show"); //получает значение из стека и уст значение global name.
    luaL_newmetatable(L, "mt");/*int luaL_newmetatable (lua_State * L, const    char * t); */
    lua_settable(L, 2);
    checklua(L, "main.lua");// Загружает и запускает заданный файл. файл в котором все происходит.
    lua_close(L);// закрыть состояние
    cin.get();//ожидает ввода символа программа завершается.
    return 0;
}



lua c++ api. Работа с указателем.

int get_point_number(lua_State *L) {// передаем указатель на состояние
    int s = 10;//значение переменной по умолчанию.
    int *a = &s;// указатель на переменную.
    (int*)lua_newuserdata(L, sizeof(a));// выделяет памяти с заданным размером,
    //помещает в стек пользовательские данные и возвращает этот адрес.
    if (LUA_TNUMBER == lua_type(L, 1)) {
        double x = lua_tonumber(L, 1);
        int x2 = (int)x;
        if (x == x2) { lua_pushinteger(L, x);// отправить в стек целое число.
            cout << "this number int " << x2 << endl;       }
        else { cout << "this number double this " << x << endl;
        lua_pushnumber(L, x);   }
    }
    else {  cout <<"the default number  "<< s  << endl;
        lua_pushinteger(L, s);}
    return 2;// вернуть 2.
}
int getpoint(lua_State *L) {// передаем указатель на состояние
    if (LUA_TUSERDATA == lua_type(L, 1)) {// если это польз. данные.
        void *x = lua_touserdata(L, 1);/*Если значение в данном приемлемом индексе является полными данными пользователя,
 возвращает адрес его блока. Если значение является легким userdata, возвращает его указатель. В противном случае возвращается NULL.*/
        cout << "address point " << x << endl;  }
    return 1;// вернуть 1.
}
int main() {
    lua_State *L = luaL_newstate();
    luaL_openlibs(L);//открыть все стандартные библиотеки lua.
    lua_pushcfunction(L, get_point_number);//уст указатель на функцию C++ и создает внутри Lua
    lua_setglobal(L, "getpointnum"); //получает значение из стека и уст значение global name.
    lua_pushcfunction(L, getpoint);//уст указатель на функцию C++ и создает внутри Lua
    lua_setglobal(L, "getpoint"); //получает значение из стека и уст значение global name.
    luaL_dofile(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
    lua_pcall(L, 0, 0, 0);// вызов функции в lua файле.
    lua_close(L);// закрыть состояние
    cin.get();//ожидает ввода символа программа завершается.
    return 0;
}

Lua

adress, num =getpointnum(5.3)
--print(adress, num ) --адрес памяти выводится
getpoint(adress)

легкие польз.данные.

int main() {
    lua_State* L = luaL_newstate(); luaL_openlibs(L);
    checkerror(L, LUA);
    lua_State* L1 = lua_newthread(L);
    int ret = 3;
    void *key = &ret;
    cout << key << endl;
    lua_pushlightuserdata(L, key);  /*отправить адресс, который является ключом в стек. */
       const void *v = lua_topointer(L,-1);
       cout << v << endl;
    return 0;
};

Вызывает функцию в защищенном режиме.
Оба nargs и nresults имеют то же значение, что и в lua_call. Если при звонке ошибок нет, lua_pcall ведет себя точно так же lua_call. Однако, если есть какая-либо ошибка, lua_pcall она перехватывает ее, помещает в стек одно значение (сообщение об ошибке) и возвращает код ошибки. Мол lua_call, lua_pcall всегда удаляет функцию и ее аргументы из стека.
Если errfunc равно 0, то сообщение об ошибке, возвращаемое в стеке, является точно исходным сообщением об ошибке. В противном случае errfunc это индекс стека функции обработчика ошибок . (В текущей реализации этот индекс не может быть псевдоиндексом.) В случае ошибок времени выполнения эта функция будет вызываться с сообщением об ошибке, а ее возвращаемое значение будет сообщением, возвращаемым в стеке lua_pcall.
Как правило, функция обработчика ошибок используется для добавления дополнительной отладочной информации к сообщению об ошибке, такой как трассировка стека. Такая информация не может быть собрана после возврата lua_pcall, так как к тому времени стек уже размотан.
lua_pcall Функция возвращает 0 в случае успеха или один из следующих кодов ошибок (определены в lua.h):
LUA_ERRRUN: ошибка во время выполнения.
LUA_ERRMEM: ошибка выделения памяти. Для таких ошибок Lua не вызывает функцию обработчика ошибок.
LUA_ERRERR: ошибка при запуске функции обработчика ошибок.





api lua c++. Реализация ООП через функции. Структура конструктор по умолчанию.

int checklua(lua_State *L, const char *file) {
    int status = luaL_loadfile(L, file);// проверка есть ли ошибки.
    try {
        if (status == 0) {// если нет ошибки в файле.
            luaL_dofile(L, file);// запуск файла, в которым все происходит.
            return 0;
        }
        else {
            string x = lua_tostring(L, -1);
            throw x;
        }
    }
    catch (string x) {
        cout << x << endl;
        //luaL_error(L,"error");
    }
};
struct a {  int x = 30;
a() { this->x = x; }//конструктор по умолчанию
    void show() { cout << "x = " << x << endl; }
~a() { cout << "destory object " << this << endl << endl; }
};
int destroy(lua_State* L) {// Функция вызывает деструктор для объекта.
    a* st = (a*)lua_touserdata(L, -1);/* Если значение в данном приемлемом индексе является полными данными пользователя.*/
    st->~a();//вызов метода деструктор.
    return 0;};

int create(lua_State* L) {//Функция создания объекта структуры.
    void* st = lua_newuserdata(L, sizeof(a));/*Эта функция выделяет новый блок памяти с заданным размером,*/
    new (st) a();// Выделить память под польз. данные.
    luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
    lua_setmetatable(L, 1);//получает таблицу из стека и уст ее в качестве новой метатаблицы для значения с заданным допустимым индексом.
    return 1;};

int show(lua_State* L) {
    a* st = (a*)lua_touserdata(L, -1);// получаем польз. данные.
    st->show();// вызов метода.
    return 0;};

int main() {
    lua_State* L = luaL_newstate();
    lua_newtable(L);
    lua_pushcfunction(L, create);//уст указатель на функцию C++ и создает внутри Lua
    lua_setglobal(L, "get"); //получает значение из стека и уст значение global name.
    lua_pushcfunction(L, show);
    lua_setglobal(L, "show"); //получает значение из стека и уст значение global name.
    luaL_newmetatable(L, "mt");/*int luaL_newmetatable (lua_State * L, const char * t); */
    lua_pushstring(L, "__gc");
    lua_pushcfunction(L, destroy);
    lua_settable(L, 2);
    checklua(L, "main.lua");
    showstack(L);// вывести стек.
    lua_close(L);// закрыть состояние
    cin.get();//ожидает ввода символа программа завершается.
return 0;}

lua
a= get()
show(a)

передача польз. Данных.

struct a {  int x = 3010;
a() { this->x = x; }//конструктор по умолчанию
    void show() { cout << "x = " << x << endl; }
};

int create(lua_State* L) {//    Функция создания объекта структуры.
    void* st = lua_newuserdata(L, sizeof(a));/*Эта функция выделяет новый блок памяти с заданным размером,*/
    new (st) a();// Выделить память под польз. данные.
    luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
    lua_setmetatable(L, 1);//получает таблицу из стека и уст ее в качестве новой метатаблицы для значения с заданным допустимым индексом.
    return 1;};

int destroy(lua_State* L) {// Функция вызывает деструктор для объекта.
    a* st = (a*)lua_touserdata(L, 1);/* Если значение в данном приемлемом индексе является полными данными пользователя.*/
    st->~a();//вызов метода деструктор.
    return 0;};

int show(lua_State* L) {
    a* st = (a*)lua_touserdata(L, -1);
    st->show();
    return 0;};

int main() {
    lua_State* L = luaL_newstate();
    lua_newtable(L);
    lua_pushcfunction(L, create);//уст указатель на функцию C++ и создает внутри Lua
    lua_setglobal(L, "get"); //получает значение из стека и уст значение global name.
    lua_pushcfunction(L, show);
    lua_setglobal(L, "show"); //получает значение из стека и уст значение global name.
    luaL_newmetatable(L, "mt");/*int luaL_newmetatable (lua_State * L, const char * t); */
    lua_pushstring(L, "__gc");
    lua_pushcfunction(L, destroy);
    lua_settable(L, 2);
    luaL_dofile(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
    lua_close(L);// закрыть состояние
    cin.get();//ожидает ввода символа программа завершается.
return 0;
}
Lua

a = get()
show(a)




api lua c++. Реализация ООП через функции 2. Структура конструктор по умолчанию.

struct a {
    int x = 10;
    a() { cout << "create object " << this << endl; }//конструктор по умолчанию

    void show() { cout << "\nobject - " << this << "\tx = " << x <<"\n\n"; }//вывести значение x на экран.

    ~a() { cout << "destory object " << this << endl << endl; }//вызов деструктора.
};

int destroy(lua_State* L) {// Функция вызывает деструктор для объекта.
    cout << "destroy " << endl;
    luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
    a** st = (a**)lua_touserdata(L, -2); // получаем польз. данные.
    //a *b = &**st;
    //b->~a();//вызов метода деструктор.
    delete *st;
    return 0;

};
int create(lua_State* L) {//    Функция создания объекта структуры.
    luaL_newmetatable(L, "mt");// создать мета таблицу.
    lua_pushstring(L, "__gc");// отправить в стек сборщик мусора.
    lua_pushcfunction(L, destroy);// установить значение ключа, как вызов деструктор.

    lua_settable(L, -3);// установить таблицу.
    a** c = (a**)lua_newuserdata(L, sizeof(a*));/*Эта функция выделяет новый блок памяти с заданным размером,*/
    *c = new a();
    luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/

    lua_setmetatable(L, -2); //получает таблицу из стека и уст ее в качестве новой метатаблицы для значения с заданным допустимым индексом.

return 1;
};
int show(lua_State* L) {
    luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
    a** st = (a**)lua_touserdata(L, -2);// получаем польз. данные.
    a *b = &**st;
    b->show();// вызов метода.
    return 0;
};

int main() {
    lua_State* L = luaL_newstate();
    lua_register(L, "create", create );//уст указатель на функцию C++ и создает внутри Lua
    lua_register(L, "show", show); //получает значение из стека и уст значение global name.
    lua_register(L, "__gc", destroy); //получает значение из стека и уст значение global name.
    luaL_dofile(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.

    lua_close(L);// закрыть состояние
    cin.get();//ожидает ввода символа программа завершается.
    return 0;
}


lua
a= create()
show(a)


Выводится
create object 0152FD78

object - 0152FD78       x = 10

destroy
destory object 0152FD78




api lua c++. Реализация ООП через функции 2. 2 класса. Структура конструктор по умолчанию.


struct a {
    int x = 10;
    a() { cout << "create object " << this << endl; }//конструктор по умолчанию

    void show() { cout << "\nobject - " << this << "\tx = " << x << "\n\n"; }//вывести значение x на экран.
    void get() { cout << "\nget "<< "\n\n"; }//вывести значение x на экран.

    ~a() { cout << "destory object " << this << endl << endl; }//вызов деструктора.
};
struct b {
    int y = 10;
    b() { cout << "create object b" << this << endl; }//конструктор по умолчанию

    void get() { cout << "\ngeta " << "\n\n"; }//вывести значение x на экран.

    ~b() { cout << "destory object " << this << endl << endl; }//вызов деструктора.
};
int destroy(lua_State* L) {// Функция вызывает деструктор для объекта.
    cout << "destroy " << endl;
    luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
    a** st = (a**)lua_touserdata(L, -2); // получаем польз. данные.
    //a *b = &**st;
    //b->~a();//вызов метода деструктор.
    delete *st;
    return 0;

};
int create(lua_State* L) {//    Функция создания объекта структуры.
    luaL_newmetatable(L, "mt");// создать мета таблицу.
    lua_pushstring(L, "__gc");// отправить в стек сборщик мусора.
    lua_pushcfunction(L, destroy);// установить значение ключа, как вызов деструктор.

    lua_settable(L, -3);// установить таблицу.
    a** c = (a**)lua_newuserdata(L, sizeof(a*));/*Эта функция выделяет новый блок памяти с заданным размером,*/
    *c = new a();
    luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/

    lua_setmetatable(L, -2); //получает таблицу из стека и уст ее в качестве новой метатаблицы для значения с заданным допустимым индексом.

return 1;
};
int create1(lua_State* L) {//   Функция создания объекта структуры.
    luaL_newmetatable(L, "mt");// создать мета таблицу.
    lua_pushstring(L, "__gc");// отправить в стек сборщик мусора.
    lua_pushcfunction(L, destroy);// установить значение ключа, как вызов деструктор.

    lua_settable(L, -3);// установить таблицу.
    b** c = (b**)lua_newuserdata(L, sizeof(b*));/*Эта функция выделяет новый блок памяти с заданным размером,*/
    *c = new b();
    luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/

    lua_setmetatable(L, -2); //получает таблицу из стека и уст ее в качестве новой метатаблицы для значения с заданным допустимым индексом.

    return 1;
};
int show(lua_State* L) {
    luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
    a** st = (a**)lua_touserdata(L, -2);// получаем польз. данные.
    a *b = &**st;
    b->show();// вызов метода.
    return 0;
};
int get(lua_State* L) {
    luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
    a** st = (a**)lua_touserdata(L, -2);// получаем польз. данные.
    a *b = &**st;
    b->get();// вызов метода.
    return 0;
};

int geta(lua_State* L) {
    luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
    b** st = (b**)lua_touserdata(L, -2);// получаем польз. данные.
    b *c = &**st;
    c->get();// вызов метода.
    return 0;
};

int main() {
    lua_State* L = luaL_newstate();
    lua_register(L, "create", create);//уст указатель на функцию C++ и создает внутри Lua
    lua_register(L, "create1", create1);//уст указатель на функцию C++ и создает внутри Lua
    lua_register(L, "show", show); //получает значение из стека и уст значение global name.
    lua_register(L, "get", get); //получает значение из стека и уст значение global name.
    lua_register(L, "geta", geta); //получает значение из стека и уст значение global name.
    lua_register(L, "__gc", destroy); //получает значение из стека и уст значение global name.
    luaL_dofile(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.

    lua_close(L);// закрыть состояние
    cin.get();//ожидает ввода символа программа завершается.
    return 0;
}





lua
a1 = create()
show(a1)
get(a1)
a2 = create1()
show(a2)
geta(a2)
a3 = create()
show(a3)

Выводится


create object 0157AE00

object - 0157AE00       x = 10


get

create object b01582220

object - 01582220       x = 10


geta

create object 0157FDA0

object - 0157FDA0       x = 10

destroy
destory object 0157FDA0

destroy
destory object 01582220

destroy
destory object 0157AE00





api lua c++. Реализация ООП через функции. Структура, конструктор с парамертами.

struct a {  int x = 10;
a() { this->x = x; cout << "create object " << this << endl;}//конструктор по умолчанию

a(int x) { this->x = x; cout << "create object " << this << endl; }//конструктор с параметрами.
void show() { cout << "\nobject - " << this << "\nx = " << x << endl; }//вывести значение x на экран.

~a() { cout << "destory object " << this << endl << endl; }//вызов деструктора.
};
int destroy(lua_State* L) {// Функция вызывает деструктор для объекта.
    a* st = (a*)lua_touserdata(L, -1);/* Если значение в данном приемлемом индексе является полными данными пользователя.*/
    st->~a();//вызов метода деструктор.
    return 0;};

int create(lua_State* L) {//    Функция создания объекта структуры.
    void* st = lua_newuserdata(L, sizeof(a));/*Эта функция выделяет новый блок памяти с заданным размером,*/

    if (LUA_TNUMBER == lua_type(L, -2)) {// значение число.
        int x = lua_tointeger(L, -2);
        new (st) a(x);// Выделить память под польз. данные.
        luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
        lua_setmetatable(L, -2);//получает таблицу из стека и уст ее в качестве новой метатаблицы для значения с заданным допустимым индексом.
    }
    else {  new (st) a();// Выделить память под польз. данные.
        luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
        lua_setmetatable(L, -2);};//получает таблицу из стека и уст ее в качестве новой метатаблицы для значения с заданным допустимым индексом.
    return 1;};

int show(lua_State* L) {
    a* st = (a*)lua_touserdata(L, -1);// получаем польз. данные.
    st->show();// вызов метода.
    return 0;};

int main() {
    lua_State* L = luaL_newstate();
    lua_newtable(L);
    lua_pushcfunction(L, create);//уст указатель на функцию C++ и создает внутри Lua
    lua_setglobal(L, "get"); //получает значение из стека и уст значение global name.
    lua_pushcfunction(L, show);
    lua_setglobal(L, "show"); //получает значение из стека и уст значение global name.
    luaL_newmetatable(L, "mt");/*int luaL_newmetatable (lua_State * L, const char * t); */
    lua_pushstring(L, "__gc");
    lua_pushcfunction(L, destroy);
    lua_settable(L, -3);
    luaL_dofile(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
    lua_close(L);// закрыть состояние
    cin.get();//ожидает ввода символа программа завершается.
return 0;
}

Lua
a1 = get()
show(a1)
a2 = get(2)
show(a2)
a3 = get(3)
show(a3)

struct a {
    int x = 10;
    a() { cout << "create object " << this << endl; }//конструктор по умолчанию

    void show() { cout << "\nobject - " << this << "\tx = " << x <<"\n\n"; }//вывести значение x на экран.

    ~a() { cout << "destory object " << this << endl << endl; }//вызов деструктора.
};

int create(lua_State* L) {//    Функция создания объекта структуры.
    a** c = (a**)lua_newuserdata(L, sizeof(a*));/*Эта функция выделяет новый блок памяти с заданным размером,*/
    *c = new a();
    luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
    lua_setmetatable(L, -1); //получает таблицу из стека и уст ее в качестве новой метатаблицы для значения с заданным допустимым индексом.

return 1;
};
 int show(lua_State* L) {
    luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/

    a** st = (a**)lua_touserdata(L, -2);// получаем польз. данные.
    (*st)->show();// вызов метода.
    a *b = &**st;
    b->show();// вызов метода.
    return 0;
};

int main() {
    lua_State* L = luaL_newstate();
    lua_register(L, "create", create );//уст указатель на функцию C++ и создает внутри Lua
    lua_register(L, "show", show); //получает значение из стека и уст значение global name.
    luaL_dofile(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
    lua_close(L);// закрыть состояние
    cin.get();//ожидает ввода символа программа завершается.
    return 0;
}

Вариант 2.


struct a{int x=0;
  a() : x() { cout <<"create object "<< this << endl; }//конструктор по умолчанию

    void set(int x){this->x = x;}//уст значение x.

    void show() {cout << "object - " << this << " x = " << x << endl;}
    //вывести значение x на экран.
    ~a() {cout <<"destory object "<< this << endl;  }//вызов деструктора.
};

int create(lua_State* L){// Функция создания объекта структуры.
    void* pointerToAa = lua_newuserdata(L, sizeof(a));/*Эта функция выделяет новый блок памяти с заданным размером,
помещает в стек новые полные пользовательские данные с адресом блока и возвращает этот адрес. Пользовательские данные
представляют значения C в Lua. Полный UserData представляет собой блок памяти. Это объект (например, таблица):
вы должны создать его, у него может быть свой собственный метатабль, и вы можете определить, когда он собирается.
Полные пользовательские данные равны только себе (при необработанном равенстве). Когда Lua собирает полные данные
пользователя с gcметаметодом, Lua вызывает метаметод и помечает данные пользователя как завершенные.
Когда эти пользовательские данные собираются снова, Lua освобождает соответствующую память.*/
    new (pointerToAa) a();// Выделить память под польз. данные.
    luaL_getmetatable(L, "aMetaTable"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.
    Если индекс не является действительным, или если значение не имеет метатаблицы, функция возвращает 0 и не отправляет ничего в стеке.*/
    lua_assert(lua_istable(L, 2));//ловит исключения если ли условия ложное.
    lua_setmetatable(L, 1);//получает таблицу из стека и уст ее в качестве новой метатаблицы для значения с заданным допустимым индексом.
    return 1;
};

int destroy(lua_State* L){// Функция вызывает деструктор для объекта.
    a* st = (a*)lua_touserdata(L, 1);/* Если значение в данном приемлемом индексе является полными данными пользователя,
    возвращает адрес его блока. Если значение является легким userdata, возвращает его указатель.В противном случае возвращается NULL.*/
    st->~a();//вызов метода деструктор.
    return 0;};

int set(lua_State* L){
    a* st = (a*)lua_touserdata(L, 1);
    lua_Number x = lua_tonumber(L, 2);
    st->set((int)x);
    return 0;};

int show(lua_State* L){
    a* st = (a*)lua_touserdata(L, 1);
    st->show();
    return 0;};

int index(lua_State* L){
    lua_assert(lua_isuserdata(L, 1));
    lua_assert(lua_isstring(L, 2));

    a* st = (a*)lua_touserdata(L, 1);
    const char* index = lua_tostring(L, 2);
    if (strcmp(index, "x") == 0){
        lua_pushnumber(L, st->x);
        return 1;   }
    else{lua_getglobal(L, "a");
        lua_pushstring(L, index);
        lua_rawget(L, 3);// Аналогично lua_settable, но делает необработанное назначение(т.Е.Без метаметодов).
        return 1;   }
};

int newindex(lua_State* L){
    lua_assert(lua_isuserdata(L, -3));
    lua_assert(lua_isstring(L, -2));//
    a* st = (a*)lua_touserdata(L, -3);
    const char* index = lua_tostring(L, -2);
    if (strcmp(index, "x") == 0){
        st->x = (int)lua_tonumber(L, -1);   }
    else{lua_assert(false); }
    return 0;
};

int main() {
    lua_State* L = luaL_newstate();
    lua_newtable(L);
    int stTableIdx = lua_gettop(L);
    lua_pushvalue(L, stTableIdx);// отправляет копию элемента с заданным допустимым индексом в стек.
    lua_setglobal(L, "a");// Установить значение глобальной переменной.

    lua_pushcfunction(L, create);/* отправляет функцию C в стек. функция получает указатель на функцию C и отправляет в стек
     значение типа Lua, function которое при вызове вызывает соответствующую функцию C.   Любая функция, которая должна быть
     зарегистрирована в Lua, должна следовать правильному протоколу, чтобы получать свои параметры и возвращать свои результаты*/
    lua_setfield(L, 1, "new");/*(lua_State * L, int index, const char * k); Соответствует ли t[k] = v, где t значение данного
    заданного допустимого индекса и vзначение в верхней части стека. Эта функция извлекает значение из стека. Как и в Lua,
    эта функция может запускать метаметод для события «newindex» (см. §2.8 ). уст ключ для new.   */
    lua_pushcfunction(L, set);
    lua_setfield(L, 1, "set");
    lua_pushcfunction(L, show);
    lua_setfield(L, 1, "show");

    luaL_newmetatable(L, "aMetaTable");/*int luaL_newmetatable (lua_State * L, const char * t); Если в реестре уже есть ключ t,
     возвращает 0. В противном случае создает новую таблицу, которая будет использоваться в качестве метатаблицы
     для пользовательских данных, добавляет ее в реестр с ключом tnameи возвращает 1. В обоих случаях помещает в стек
     окончательное значение, связанное с t реестром.*/
    lua_pushstring(L, "__gc");
    lua_pushcfunction(L, destroy);
    lua_settable(L, 2);

    lua_pushstring(L, "__index");
    lua_pushcfunction(L, index);
    lua_settable(L, 2);

    lua_pushstring(L, "__newindex");
    lua_pushcfunction(L, newindex);
    lua_settable(L, 2);

    int x = luaL_dofile(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.

    if (x == LUA_OK) {  lua_close(L);// если поллучилось открыть файл.
        cin.get();}//ожидает ввода символа программа завершается.

    else {  cout << "Error: "<<lua_tostring(L, -1)<<endl;
        lua_close(L);// закрыть состояние
        cin.get();//ожидает ввода символа программа завершается.
        return 0;   }
}
Lua
st = a.new()
--st:show()
st:set(100)
st:show()
st1 = a.new()
st1:set(200)
st1:show()



выделение памяти.

struct ArenaAllocator
{
    void* m_begin;
    void* m_end;
    char* m_curr;


    ArenaAllocator(void* begin, void* end) :
        m_begin(begin),
        m_end(end),
        m_curr(static_cast<char*>(m_begin) )
    {   }

    void* Allocate(size_t sizeBytes){
        assert(m_curr + sizeBytes < m_end);
        printf("-- allocated from the freelist --\n");
        void* ptr = m_curr;
        m_curr += sizeBytes;
        return ptr;
    }

    void DeAllocate(void* ptr, size_t osize)    {
        assert(ptr != nullptr);     //can't decallocate null!!!
        printf("DeAllocated %d bytes\n", (int)osize);
    }

    void* ReAllocate(void* ptr, size_t osize, size_t nsize){
        printf("ReAllocated %d bytes\n", (int)nsize);
        void* newPtr = Allocate(nsize);
        memcpy(newPtr, ptr, osize);
        DeAllocate(ptr, osize);
        return newPtr;
    }

    static void *l_alloc(void *ud, void *ptr, size_t osize, size_t nsize) {
        ArenaAllocator * pool = static_cast<ArenaAllocator *>(ud);
        if (nsize == 0)
        {
            if (ptr != nullptr)
            {
                pool->DeAllocate(ptr, osize);
            }
            return NULL;
        }
        else
        {
            if (ptr == nullptr)
            {
                return pool->Allocate(nsize);
            }
            else
            {
                return pool->ReAllocate(ptr, osize, nsize);
            }
        }
    }
};
int main() {
    constexpr int pool_size = 1024 * 10;
    char memory[pool_size];
    ArenaAllocator pool(memory, &memory[pool_size-1]);

    lua_State *L = lua_newstate(ArenaAllocator::l_alloc, &pool);
    //luaL_openlibs(L);
    assert(L != nullptr);
    lua_close(L);
    //cin.get();//ожидает ввода символа программа завершается.
    return 0;
}



Нативнный код, позволяет писать lua скрипт в cpp файле, мы можем вносит в него изменения не переключаясь на lua файл, однако изменения, требуют собрать проект заново.

Определение типа переменной и вывод ее на экран.

void showstack(lua_State* L) {
    int i = lua_gettop(L);/* получаем количество элементов в стеке.*/
    cout << "\n  the number on the stack = " << i << "\n\n\n";
    int j = (i) * -1-1;
    i = -1;
    for (i; i > j; i--) {
        int t = lua_type(L, i);
        cout << "\t " << i << "  " << (j - i) * -1 << "\t";
        if (LUA_TSTRING == t) {
            cout << lua_tostring(L, i) << endl;
        }
        if (LUA_TNUMBER == t) {
            double x = lua_tonumber(L, i);
            int x2 = (int)x;
            if (x == x2) { cout << x2 << endl; }
            else { cout << x << endl; }
        }
        if (LUA_TBOOLEAN == t) {cout << "LUA_TBOOLEAN "<< lua_toboolean(L, i) << endl;      }

        if (LUA_TLIGHTUSERDATA == t) {  cout << "LIGHTUSERDATA " << endl;       }

       if (LUA_TTABLE == t) {   cout << "LUA_TTABLE " << endl;  }

        if (LUA_TFUNCTION == t) {   cout << "LUA_TFUNCTION " << endl;   }

        if (LUA_TUSERDATA == t) {cout << "LUA_TUSERDATA " << endl;  }

        if (LUA_TTHREAD == t) { cout << "LUA_TTHREAD " << endl;     }

        if (LUA_TNIL == t) {cout << "LUA_TNIL " << endl;        }
    }
};

void getvar(lua_State* L, const char* var) {
    lua_getglobal(L, var);// получить значение глобальной переменной x.
    if (LUA_TSTRING == lua_type(L, -1)) {
        cout << "string " << var << " = " << lua_tostring(L, -1);
    }
    if (LUA_TNUMBER == lua_type(L, -1)) {
        double x = lua_tonumber(L, -1);
        int x2 = (int)x;
        if (x == x2) { cout << "number int " << var << " = " << x2; }
        else { cout << "number double " << var << " = " << x; }
    }
    if (LUA_TBOOLEAN == lua_type(L, -1)) {
        cout << "bool " << var << " = " << (lua_toboolean(L, -1) ? "true " : "false ");
    }
    if (LUA_TTABLE == lua_type(L, -1)) {
        cout << "LUA_TTABLE " << var << " = " << endl;
    }
    if (LUA_TFUNCTION == lua_type(L, -1)) {
        cout << "LUA_TFUNCTION " << var << " = " << endl;
    }
    if (LUA_TNIL == lua_type(L, -1)) { // если var нет.
        cout << "not " << var;
    }
    cout << endl;
};

void getstack(lua_State* L, int pos) {// Посмотреть позицию в стеке.
    if (LUA_TSTRING == lua_type(L, pos)) {
        cout << lua_tostring(L, pos);
    }
    if (LUA_TNUMBER == lua_type(L, pos)) {
        double x = lua_tonumber(L, pos);
        int x2 = (int)x;
        if (x == x2) { cout << x2; }
        else { cout << x; }
    }
    if (LUA_TBOOLEAN == lua_type(L, pos)) {
        cout << (lua_toboolean(L, pos) ? "true " : "false ");
    }
    if (LUA_TTABLE == lua_type(L, pos)) {
        cout << "LUA_TTABLE " << endl;
    }
    if (LUA_TLIGHTUSERDATA == lua_type(L, pos)) {
        cout << "LIGHTUSERDATA " << endl;
    }
    if (LUA_TTABLE == lua_type(L, pos)) {
        cout << "LUA_TTABLE " << endl;
    }
    if (LUA_TFUNCTION == lua_type(L, pos)) {
        cout << "LUA_TFUNCTION " << endl;
    }
    if (LUA_TUSERDATA == lua_type(L, pos)) {
        cout << "LUA_TUSERDATA " << endl;
    }
    if (LUA_TTHREAD == lua_type(L, pos)) {
        cout << "LUA_TTHREAD " << endl;
    }
    if (LUA_TNIL == lua_type(L, pos)) {
        cout << "nill " << endl;// если NILL.
    }
};

int checkerror(lua_State* L, const char* file) {
    int status = luaL_loadfile(L, file);// проверка есть ли ошибки.
    try {
        if (luaL_dostring(L, file) == LUA_OK) {
            return 0;
        }
        else {
            string x = lua_tostring(L, -1);
            throw x;
            return 0;
        }
    }
    catch (string x) {
        cout << x << endl;
        //luaL_error(L,"error");
        return 0;
    }
};

template <class T>//любое значение отправить в стек.
void pushlua(lua_State * L, const T & value) {
    if constexpr (std::is_same_v<T, std::string>)
        lua_pushstring(L, value.c_str());
    else if constexpr (std::is_array_v<T> && std::is_same_v<std::remove_extent_t<T>, char>)
        lua_pushstring(L, value);
    else if constexpr (std::is_same_v<T, int>)
        lua_pushinteger(L, value);
    else if constexpr (std::is_same_v<T, double>)
        lua_pushnumber(L, value);
    else if constexpr (std::is_same_v<T, bool>)
        lua_pushboolean(L, value);
    else
        std::cerr << "I do not know what to do :(" << std::endl;
};
template <class t1, class t2>
void addkeyintab(lua_State* L, t1 key, t2 value) {
    /* Устанавливает реальное значение t[i] = value  как value, без вызова метаметода. t это таблица, i - любым числом, отличным от nil и NaN,
    а value - значение. Данная функция возвращает table. */
    if (std::is_same_v<t1, const char*> && std::is_same_v<t2, int>) {
        cout << "key string " << key << " int " << value << endl;
        const char* key1 = (const char*)key;
        int value1 = (int)value;
        lua_pushstring(L, key1); /* отправить ключ в стек */
        lua_pushinteger(L, value1); /* отправить значение ключа в стек. */
        lua_rawset(L, -3);  } /*Сохраняет пару в таблице */

    else if (std::is_same_v<t1, int> && std::is_same_v<t2, const char*>) {
        cout << "key int " << key << " string " << value << endl;
        int key1 = (int)key;
        const char* value1 = (const char*)value;
        lua_pushinteger(L, key1); /* отправить ключ в стек */
        lua_pushstring(L, value1); /* отправить значение ключа в стек. */
        lua_rawset(L, -3);  } /*Сохраняет пару в таблице */

    else if (std::is_same_v<t1, const char*> && std::is_same_v<t2, const char*>) {
        cout << "key string " << key << " value string " << value << endl;
        const char* key1 = (const char*)key;
        const char* value1 = (const char*)value;
        lua_pushstring(L, key1); /* отправить ключ в стек */
        lua_pushstring(L, value1); /* отправить значение ключа в стек. */
        lua_rawset(L, -3);} /*Сохраняет пару в таблице */

    else if (std::is_same_v<t1, int> && std::is_same_v<t2, int>) {
        cout << "key int " << key << " value int " << value << endl;
        int key1 = (int)key;
        int value1 = (int)value;
        lua_pushinteger(L, key1); /* отправить ключ в стек */
        lua_pushinteger(L, value1); /* отправить значение ключа в стек. */
        lua_rawset(L, -3); /*Сохраняет пару в таблице */
    }
};

int main(int argc, char *argv[]) {
    const char* LUA = R"(
x = true
)";
    lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    checkerror(L, LUA);//Функция проверка на ошибки.
    getvar(L, "x");

    lua_close(L);

    return 0;


Присвоение значения переменной через отправку в стек.

int main(int argc, char *argv[]) {
    const char* LUA = R"(
print(c)

)";
    lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    pushlua(L, 12);
    lua_setglobal(L, "c");// уст значение переменной в lua.
    checkerror(L, LUA);//Функция проверка на ошибки.

    lua_close(L);

    return 0;
}


Вызов функции в нативном коде через получение переменной.

int main(int argc, char *argv[]) {
const char* LUA = R"(
  function foo()
   return 4
  end )";
    lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    checkerror(L, LUA);//Функция проверка на ошибки.
    lua_getglobal(L, "foo");

    if (lua_isfunction(L, -1)) {
        lua_pcall(L, 0, 1, 0);
        cout << lua_tonumber(L, -1) << endl;    }
    lua_close(L);
    return 0;
}

Вызов функции в нативном коде через присвоение.

int foo(lua_State *L) {
    cout << "hi foo c++" << endl;
    return 0;
};

int main(int argc, char *argv[]) {
    const char* LUA = R"(
foo()

)";
    lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    lua_pushcfunction(L, foo);// отправить c функцию в стек.

    lua_setglobal(L, "foo");// уст для переменной значение в виде функции.

    checkerror(L, LUA);//Функция проверка на ошибки.

    lua_close(L);

    return 0;
};

Вызов функции в нативном коде через отправку в таблицу.

int foo(lua_State *L) {
    cout << "hi foo c++" << endl;
    return 0;
}

int main(int argc, char *argv[]) {
    const char* LUA = R"(
foo()
)";
    lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);

    lua_newtable(L); /*создать пустую таблицу */
    lua_pushcfunction(L, foo);// отправить c функцию в стек как ключ.
    lua_setglobal(L, "foo");// уст для переменой(ключ) значение в новой пустой таблицы в виде функции.

    checkerror(L, LUA);//Функция проверка на ошибки.

    lua_close(L);

    return 0;
};


Вызов функции с параметром в нативном коде через отправку в таблицу.

int foo(lua_State *L) {
    int x = lua_tointeger(L, -1);
    pushlua(L, x * 2);

return 1;
}

int main(int argc, char *argv[]) {
    const char* LUA = R"(
g=foo(12)
print(g)
)";
    lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);

    lua_newtable(L); /*создать пустую таблицу */
    lua_pushcfunction(L, foo);// отправить c функцию в стек.
    lua_setglobal(L, "foo");// уст для переменой(ключ) значение в новой пустой таблицы в виде функции.

    checkerror(L, LUA);//Функция проверка на ошибки.

    lua_close(L);

    return 0;
};

Таблица в стеке, добавления в нее элементов.

int main(int argc, char *argv[]) {
    lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    lua_newtable(L);
    lua_pushstring(L, "key");
    lua_pushnumber(L, 100);
    lua_rawset(L,-3);

    lua_pushstring(L, "key");
    lua_gettable(L, -2);
   cout << lua_tonumber(L,-1) << endl; //Функция 100.

    lua_close(L);

    return 0;
};

Вариант 2.

int main(int argc, char* argv[]) {
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    lua_newtable(L);
    lua_pushnumber(L, 100);
    lua_setfield(L, -2, "key");// уст в таблицу ключ - key со значение 100.

    pushlua(L, "key");
    lua_gettable(L, -2);
    getlaststack(L); //Функция 100.

    lua_close(L);

    return 0;
};

Добавление следующего ключа со значением в таблицу.

int main(int argc, char* argv[]) {
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    lua_newtable(L);

    pushlua(L, "key");
    pushlua(L, 100);
    lua_rawset(L, -3);// table["key"] = 100.

    pushlua(L, "a");
    pushlua(L, 6);
    lua_rawset(L, -3);// table["a"] = 6.


    pushlua(L, "a");
    lua_gettable(L, -2);
    getlaststack(L); // 6.

    lua_close(L);

    return 0;
};


Функция добавление в таблицу нового ключа со значением.

template <class t1, class t2>
void addkeyintab(lua_State* L, t1 key, t2 value) {
    /* Устанавливает реальное значение t[i] = value  как value, без вызова метаметода. t это таблица, i - любым числом, отличным от nil и NaN,
    а value - значение. Данная функция возвращает table. */
    if (std::is_same_v<t1, const char*> && std::is_same_v<t2, int>) {
        cout << "key string " << key << " value int " << value << endl;
        const char* key1 = (const char*)key;
        int value1 = (int)value;
        lua_pushstring(L, key1); /* отправить ключ в стек */
        lua_pushinteger(L, value1); /* отправить значение ключа в стек. */
        lua_rawset(L, -3);  } /*Сохраняет пару в таблице */

    else if (std::is_same_v<t1, int> && std::is_same_v<t2, const char*>) {
        cout << "key int " << key << " value string " << value << endl;
        int key1 = (int)key;
        const char* value1 = (const char*)value;
        lua_pushinteger(L, key1); /* отправить ключ в стек */
        lua_pushstring(L, value1); /* отправить значение ключа в стек. */
        lua_rawset(L, -3);  } /*Сохраняет пару в таблице */

    else if (std::is_same_v<t1, const char*> && std::is_same_v<t2, const char*>) {
        cout << "key string " << key << " value string " << value << endl;
        const char* key1 = (const char*)key;
        const char* value1 = (const char*)value;
        lua_pushstring(L, key1); /* отправить ключ в стек */
        lua_pushstring(L, value1); /* отправить значение ключа в стек. */
        lua_rawset(L, -3);} /*Сохраняет пару в таблице */

    else if (std::is_same_v<t1, int> && std::is_same_v<t2, int>) {
        cout << "key int " << key << " value int " << value << endl;
        int key1 = (int)key;
        int value1 = (int)value;
        lua_pushinteger(L, key1); /* отправить ключ в стек */
        lua_pushinteger(L, value1); /* отправить значение ключа в стек. */
        lua_rawset(L, -3); /*Сохраняет пару в таблице */
    }
};
int main(int argc, char *argv[]) {
const char* LUA = R"(
print(foo)
for k,v in pairs(foo) do
print(k.." "..v)
end

 )";
    lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);

    lua_newtable(L); /*создать пустую таблицу */
    addkeyintab(L, "a", " 10 z "); /*добавить ключ и значение в таблицу */
    addkeyintab(L, "x1", 99); /*добавить ключ и значение в таблицу */
    addkeyintab(L, 100, 10); /*добавить ключ и значение в таблицу */
    addkeyintab(L, 100, "y"); /*добавить ключ и значение в таблицу */
    lua_setglobal(L, "foo");// уст имя таблицы в lua.
    cout << "\n" << endl;
    checkerror(L, LUA);//Функция проверка на ошибки.

    lua_close(L);
    return 0;
};

Выводится.
key string a value string  10 z
key string x1 int 99
key int 100 value int 10
key int 100 string y


table: 009F0830
100 y
x1 99
a  10 z

C:\Users\e\source\repos\Project1luaapi\Debug\Project1luaapi.exe (процесс 6000) завершает работу с кодом 0.
Чтобы закрыть это окно, нажмите любую клавишу…



Функция возвращает таблицу с ключами в качестве функциями.

int square(lua_State* L) {//    Функция создания объекта структуры.
    cout << lua_tonumber(L,-1)*2 << endl;
    return 0;
};
int cube(lua_State* L) {//  Функция создания объекта структуры.
    cout << lua_tonumber(L, -1) * 3 << endl;
    return 0;
};


int create(lua_State* L) {//    Функция создания объекта структуры.
    lua_newtable(L);
    lua_pushcfunction(L, square);
    lua_setfield(L, -2, "square");
    lua_pushcfunction(L, cube);
    lua_setfield(L, -2, "cube");
    return 1;
};

int main(int argc, char* argv[]) {
const char* LUA = R"(

a = create()
a.square(5) --10
a.square(10)--20
a.cube(4)--12
a.cube(6)--18
print(a)
)";
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);

    lua_pushcfunction(L, create);/* отправляет функцию C в стек. функция получает указатель на функцию C и отправляет в стек*/
    lua_setglobal(L, "create");

    checkerror(L, LUA);//Функция проверка на ошибки.

    lua_close(L);

    return 0;
};


Вывод всех ключей и значений неизвестной таблицы.

int pri(lua_State* L, const char t[]) {
    lua_getglobal(L, t);// получить значение глобальной переменной, таблица.
    lua_pushvalue(L, -1);
    lua_pushnil(L);
    while (lua_next(L, -2)) {
        lua_pushvalue(L, -2);
        cout << "key "; getstack(L, -1); cout << " value "; getstack(L, -2); cout << endl;
        lua_pop(L, 2);
    }
    lua_pop(L, 1);
    return 0;
};
int main() {
    const char* LUA = R"(
t= {x=10, y=20, z=30}
)";

    lua_State* L = luaL_newstate();
    luaL_openlibs(L);

    checkerror(L, LUA);//Функция проверка на ошибки.
    pri(L, "t");// вывести ключи и значения таблицы.

    lua_close(L);// закрыть состояние
    return 0;
};

Сохранение всех ключей таблицы в реестре.

int pritab(lua_State* L, const char t[]) {
    int x = 0;
    lua_getglobal(L, t);// получить значение глобальной переменной, таблица.
    lua_pushvalue(L, -1);
    lua_pushnil(L);
    while (lua_next(L, -2)) {
    //. cout << " key ";
        lua_pushvalue(L, -2);
        lua_rawseti(L, LUA_REGISTRYINDEX, x);
        //getstack(L, -2);
        lua_pushvalue(L, -2);
        //cout << "key "; getstack(L, -1); cout << " value "; getstack(L, -2); cout << endl;
        lua_pop(L, 2);
        x++;
    }
    lua_pop(L, 1);
    pushlua(L, x);
    return 1;
};
int main() {
    const char* LUA = R"(
t= {x=10, y=20, z=30}
)";

    lua_State* L = luaL_newstate();
    luaL_openlibs(L);

    checkerror(L, LUA);//Функция проверка на ошибки.
    pritab(L, "t");// вывести ключи и значения таблицы.
    int len = lua_tointeger(L,-1);
    for (int i = 0; i < len; i++){
    lua_rawgeti(L, LUA_REGISTRYINDEX, i);/* вернуть значение для ключа в реестр. */
    cout << "key "; getstack(L, -1);  cout << endl;}
    lua_close(L);// закрыть состояние
    return 0;
};

Вывод всех значений ключей из реестра.

int pritab(lua_State* L, const char t[]) {
    int x = 0;
    lua_getglobal(L, t);// получить значение глобальной переменной, таблица.
    lua_pushvalue(L, -1);
    lua_pushnil(L);
    while (lua_next(L, -2)) {
        //. cout << " key ";
        lua_pushvalue(L, -2);
        lua_rawseti(L, LUA_REGISTRYINDEX, x);
        //getstack(L, -2);
        lua_pushvalue(L, -2);
        //cout << "key "; getstack(L, -1); cout << " value "; getstack(L, -2); cout << endl;
        lua_pop(L, 2);
        x++;
    }
    lua_pop(L, 1);
    pushlua(L, x);
    return 1;
};
int main() {
    const char* LUA = R"(
t= {x=10, y=20, z=30}
)";

    lua_State* L = luaL_newstate();
    luaL_openlibs(L);

    checkerror(L, LUA);//Функция проверка на ошибки.
    pritab(L, "t");// вывести ключи и значения таблицы.
    int len = lua_tointeger(L, -1);
    lua_pop(L, 1);
    for (int i = 0; i < len; i++) {
        lua_rawgeti(L, LUA_REGISTRYINDEX, i);/* вернуть значение для ключа в реестр. */

        cout << "key "; getstack(L, -1);

        lua_getglobal(L, "t");
        lua_pushvalue(L, -2);
        lua_gettable(L, -4);
        cout << " value "; getstack(L, -1);  cout << endl;
        lua_pop(L, 3);

    }
    lua_close(L);// закрыть состояние
    return 0;
};


Отправить в стек таблицу.

int rettab(lua_State* L) {// Функция отправить в стек таблицу.
    lua_newtable(L);
    for (int i = 1; i < 10; i++){
    pushlua(L, i);
    pushlua(L, i*10);
    lua_rawset(L, -3);
    }
    return 1;
};

int main(int argc, char* argv[]) {
    const char* LUA = R"(

a = rettab()
print(a[3]) --30
)";
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);

    lua_pushcfunction(L, rettab);/* отправляет функцию C в стек. функция получает указатель на функцию C и отправляет в стек*/
    lua_setglobal(L, "rettab");

    checkerror(L, LUA);//Функция проверка на ошибки.

    lua_close(L);

    return 0;
};

Отправить таблицу в функцию.

int readtab(lua_State* L) {// Функция отправить в стек таблицу.
    if (LUA_TTABLE == lua_type(L, -1)) {

        lua_pushinteger(L, 1);

        lua_gettable(L, -2);
        int x = lua_tointeger(L, -1);
        getstack(L, -1); cout << endl;
        lua_pop(L, 1);
        lua_pushinteger(L, 2);
        lua_gettable(L, -2);
        int y = lua_tointeger(L, -1);
        getstack(L, -1); cout << endl;
        lua_pop(L, 1);
        lua_pushinteger(L, 3);
        lua_gettable(L, -2);
        int z = lua_tointeger(L, -1);
        getstack(L, -1); cout << endl;
        lua_pop(L, 1);

    }
    return 0;
};

int main(int argc, char* argv[]) {
    const char* LUA = R"(
t = {10,20,30}
 readtab(t)
)";
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);

    lua_pushcfunction(L, readtab);/* отправляет функцию C в стек. функция получает указатель на функцию C и отправляет в стек*/
    lua_setglobal(L, "readtab");

    checkerror(L, LUA);//Функция проверка на ошибки.

    lua_close(L);

    return 0;
};


Модуль с. Писать модули для lua на c++.

int q(lua_State* L) {
    int d = lua_tonumber(L, -1);
    pushlua(L, d * 2);
    return 1; /*число умножено на 2*/
}
int foo(lua_State * L) {
    int d = lua_tonumber(L, -1);
    pushlua(L, d * 3);
    return 1; /*число умножено на 3*/
}
 struct luaL_Reg mylib[] = {
    { "q", q },{ "foo", foo }, { NULL, NULL } /*регистрация функций, на вершину отправим NULL NULL*/
};

int lua_lib(lua_State * L) {
    luaL_newlib(L, mylib);/*void luaL_newlib (lua_State * L, const luaL_Reg lib []); Создает новую таблицу и
      регистрирует там свои функции в списке lib. Это реализовано в виде следующего макроса:
  (luaL_newlibtable (L, lib), luaL_setfuncs (L, l, 0))
  Массив lib должен быть фактическим массивом, а не указателем на него.*/
  return 1;
}

int main(int argc, char* argv[]) {
    const char* LUA = R"(
 mylib = require 'mylib'
print(mylib.q(2))
print(mylib.foo(2)) )";
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);

    luaL_requiref(L, "mylib", lua_lib, 1);/* модуль. void luaL_requiref (lua_State * L, const char * modname,
 lua_CFunction cfunc, int glb); Если modname еще нет, package.loaded, вызывает функцию cfunc со строкой modname
 в качестве аргумента и устанавливает результат вызова package.loaded[modname], как если бы эта функция была вызвана
 require. Если glb это правда, также сохраняет модуль в глобальном modname. Оставляет копию модуля в стеке.*/
    checkerror(L, LUA);//Функция проверка на ошибки.

    return 0;
};


Реестр глобальная таблица.


int main(int argc, char* argv[]) {
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);

    pushlua(L, 9);//отправить значение для ключа 12.
    lua_rawseti(L, LUA_REGISTRYINDEX, 12);// отправить ключ в реестре. установить ключ со значение в реестр.

    lua_rawgeti(L, LUA_REGISTRYINDEX, 12);/* вернуть значение для ключа в реестр. */
    getlaststack(L);// 9

    lua_close(L);

    return 0;
};


Реестр передача значение между функциями.

int show(lua_State* L) {
    lua_rawgeti(L, LUA_REGISTRYINDEX, 12);/* вернуть значение для ключа в реестр. */
    getlaststack(L);// 100
    return 0;
};
int create(lua_State * L) {//   Функция создания объекта структуры.
    pushlua(L, 100);//отправить значение для ключа 12.
    lua_rawseti(L, LUA_REGISTRYINDEX, 12);// отправить ключ в реестре. установить ключ со значение в реестр.
    return 0;
};

int main(int argc, char* argv[]) {
    const char* LUA = R"(
create()
show()
)";
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);

    lua_newtable(L);
    lua_pushcfunction(L, create);
    lua_setglobal(L, "create");// уст глоб имя в таблице как С функцию.

    lua_pushcfunction(L, show);
    lua_setglobal(L, "show");

    checkerror(L, LUA);//Функция проверка на ошибки.

    lua_close(L);

    return 0;
};


Реестр, отправка и получение значение по уникальному ключу. В качестве ключей ссылка на псевдоиндекс.


int main(int argc, char* argv[]) {
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);

    int ref = luaL_ref(L, LUA_REGISTRYINDEX); /*Возвращает ссылку - это уникальный целочисленный ключ. Для значения в реестре*/

    pushlua(L, 9);//отправить значение для ключа ref.
    lua_rawseti(L, LUA_REGISTRYINDEX, ref);// установить ключ со значение в реестр.

    pushlua(L, ref);
    lua_rawgeti(L, LUA_REGISTRYINDEX, ref);/* вернуть значение для ключа в реестр. */
    getlaststack(L);// 9

    lua_close(L);

    return 0;
};


Работа в реестр. Отправка значение переменной в реестр, получение из него.

int main(int argc, char* argv[]) {
    const char* LUA = R"(
x=4
 )";
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    checkerror(L, LUA);//Функция проверка на ошибки.
    lua_getglobal(L, "x");
    int ref = luaL_ref(L, LUA_REGISTRYINDEX); /*Создает и возвращает ссылку в таблице в индексе t для объекта на вершине стека(и извлекает объект).
    Ссылка - это уникальный целочисленный ключ. Пока вы не добавляете вручную целочисленные ключи в таблицу t, вы luaL_ref гарантируете уникальность возвращаемого ключа. Вы можете получить объект, на который ссылается ссылка r, вызывая lua_rawgeti(L, t, r).
Функция luaL_unref освобождает ссылку и связанный с ней объект.
    Если объект на вершине стека равен нулю, luaL_ref возвращает константу LUA_REFNIL. Константа LUA_NOREF
гарантированно будет отличаться от любой ссылки, возвращаемой luaL_ref.*/


    lua_rawgeti(L, LUA_REGISTRYINDEX, ref);
    cout <<"x = "<< lua_tonumber(L, -1) << endl;
    lua_rawseti(L, LUA_REGISTRYINDEX, ref);/*
    Функции, которые API предоставляет для работы с массивами:

    void lua_rawgeti (lua_State * L, int index, int key);
    void lua_rawseti (lua_State * L, int index, int key); Описание lua_rawgeti и lua_rawseti немного сбивает с толку,
    поскольку включает в себя два индекса:
    index указывает, где таблица находится в стеке;
    key относится к тому, где элемент находится в таблице.
    Вызов lua_rawgeti(L, t, key) эквивалентен последовательности lua_pushnumber (L, ключ); lua_rawget (L, t);

    когда t положительно (в противном случае вы должны компенсировать новый элемент в стеке).
    Вызов lua_rawseti(L, t, key)(опять же для t положительного) эквивалентен
    lua_pushnumber (L, ключ);
    lua_insert (L, -2); // поставить `ключ 'ниже предыдущего значения
    lua_rawset (L, t); Обратите внимание, что обе функции используют необработанные операции.
    Они быстрее и, в любом случае, таблицы, используемые в качестве массивов, редко используют метаметоды.
     В качестве конкретного примера использования этих функций мы могли бы переписать тело цикла
     из нашей предыдущей l_dirфункции из

        lua_pushnumber (L, i ++); // ключ  /
        lua_pushstring (L, entry-> d_name); / значение /
    lua_settable(L, -3);
                                           */
    luaL_unref(L, LUA_REGISTRYINDEX, ref); // удалить значение по ключу ref.
    cout << lua_tonumber(L, -1) << endl;

    lua_close(L);

    return 0;
};


Выводится.

x = 4
0

Вариант 2.

int main(int argc, char* argv[]) {
    const char* LUA = R"(
x=4
 )";
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    checkerror(L, LUA);//Функция проверка на ошибки.
    int ref = luaL_ref(L, LUA_REGISTRYINDEX); /*Создает и возвращает ссылку в таблице в индексе t для объекта на вершине стека(и извлекает объект).*/

    lua_getglobal(L, "x");

    lua_rawseti(L, LUA_REGISTRYINDEX, ref);/* установить в таблице*/

    lua_rawgeti(L, LUA_REGISTRYINDEX, ref);/* получить значение по ключу */
    cout << "x = " ;
    getlaststack(L);

//  luaL_unref(L, LUA_REGISTRYINDEX, ref); // удалить значение по ключу ref.

    lua_rawgeti(L, LUA_REGISTRYINDEX, ref);/*              */
    getlaststack(L);

    lua_close(L);

    return 0;
};


Уникальность ключа в реестре, обеспечивается адресом в памяти переменной.
Использовать lua_settable и lua_gettable.

int main(int argc, char* argv[]) {
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    static char Key = 'k';// лучше стастик переменная.

    lua_pushlightuserdata(L, &Key);  /* отправить адрес памяти переменной в стек */
    lua_pushstring(L, &Key);  /* отправить значение в стек */
    lua_settable(L, LUA_REGISTRYINDEX);  /* уст ключа и значение таблице реестре.  */

    lua_pushlightuserdata(L, &Key);  /*отправить адрес, который является ключом в стек. */
    lua_gettable(L, LUA_REGISTRYINDEX);  /* получить таблицу и значение ключа будет в -1 */
    cout << lua_tostring(L, -1) << endl;// k

    lua_close(L);
    return 0;
};


Реестр способен хранить польз. данные, ключ может их адрес в пямяти.

int main(int argc, char* argv[]) {
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);

    static char Key = 'k';// лучше стастик переменная.

    lua_pushlightuserdata(L, &Key);  /* отправить адресс в стек */
    lua_rawsetp(L, LUA_REGISTRYINDEX,  &Key);/* Имеет ли эквивалент t[k] = v, где t таблица,
 k указатель, представленный в виде легких пользовательских данных, и v значение в верхней части стека.
 Эта функция извлекает значение из стека. Не вызывает метаметоды.*/

    lua_pushlightuserdata(L, &Key);  /*отправить адресс, который является ключом в стек. */
    lua_rawgetp(L, LUA_REGISTRYINDEX, &Key); /* получить таблицу и значение ключа будет в -1 */

    char* k = (char*)lua_touserdata(L, -1);// получить польз.данные.
    cout << k <<" adress "<< &k << endl;// k.

    lua_close(L);
    return 0;
};

int main(int argc, char* argv[]) {
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);

     int Key = 100;// лучше стастик переменная.

    lua_pushlightuserdata(L, &Key);  /* отправить адресс в стек */
    lua_rawsetp(L, LUA_REGISTRYINDEX, &Key);/* Имеет ли эквивалент t[k] = v, где t таблица,
 k указатель, представленный в виде легких пользовательских данных, и v значение в верхней части стека.
 Эта функция извлекает значение из стека. Не вызывает метаметоды.*/

    lua_pushlightuserdata(L, &Key);  /*отправить адресс, который является ключом в стек. */
    lua_rawgetp(L, LUA_REGISTRYINDEX, &Key); /* получить таблицу и значение ключа будет в -1 */

    int* k = (int*)lua_touserdata(L, -1);// получить польз.данные.
    cout << *k << " adress " << &k << endl;// 100.

    lua_close(L);
    return 0;
};

Реестр адрес переменной k ключ.

int main(int argc, char* argv[]) {
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    static char k = 'key';// лучше стастик переменная она выступает ключом в реестре.

    int i = 5;
    lua_pushlightuserdata(L, &i);  /* отправить адрес памяти числа 5 в стек */
    lua_rawsetp(L, LUA_REGISTRYINDEX, &k);  /* уст ключ в реестре адрес k.
 void lua_rawsetp (lua_State * L, int index, const void * p);  Записывает ли эквивалент t[p] = v,
где t таблица с заданным индексом, p как легкие пользовательские данные и v является значением в верхней части стека.

Эта функция извлекает значение из стека. Назначение является необработанным,  */

    lua_pushlightuserdata(L, &i);  /*отправить адрес памяти, который является ключом в стек.*/

    lua_rawgetp(L, LUA_REGISTRYINDEX, &k);/* получить значение по ключу адрес k*/
    int* number = (int*)lua_touserdata(L, -1);// получить польз.данные.

    cout << *number << " adress " << number << endl;// 5.


    lua_close(L);
    return 0;
};

Реестр. Передача значение из функции в ключ возвращаемой таблицы.

int show(lua_State* L) {
    luaL_getmetatable(L, "mt"); /* получить метатаблицу.*/
    lua_pushstring(L, "key");//отправить key, чтобы получить ref
    lua_gettable(L, -2);
    int ref = lua_tonumber(L, -1);
    lua_rawgeti(L, LUA_REGISTRYINDEX, ref);/* получить значение по ключу ref.*/

    getlaststack(L);
    return 0;
};
int create(lua_State * L) {//   Функция создания объекта структуры.
    lua_gettable(L, -3);// получить глоб. таблицу.
    luaL_newmetatable(L, "mt");// создать мета таблицу.
    lua_pushcfunction(L, show);
    lua_setfield(L, -2, "show");// ключ таблицы является функцией.
    int ref = luaL_ref(L, LUA_REGISTRYINDEX);// получить уникальный ключ.
    pushlua(L, 5);// значение для ключа. mt.ref = 5.
    lua_rawseti(L, LUA_REGISTRYINDEX, ref); /* уст ключ со значением 5 в реестре адрес. */

    lua_setmetatable(L, -2); //уст метатаблицу.

    lua_gettable(L, -2);// получить таблицу.
    luaL_getmetatable(L, "mt"); /* получить метатаблицу.*/

    lua_pushstring(L, "key");// это ключ для получение ref.
    lua_pushnumber(L, ref);
    lua_rawset(L, -3);

    luaL_getmetatable(L, "mt"); /* получить метатаблицу.*/
    return 1;
};

int main(int argc, char* argv[]) {
    const char* LUA = R"(
a = create()
a.show()
)";
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);

    lua_newtable(L);
    lua_pushcfunction(L, create);
    lua_setglobal(L, "create");// уст глоб имя в таблице как С функцию.


    checkerror(L, LUA);//Функция проверка на ошибки.

    lua_close(L);

    return 0;
};

Реестр. Передача числа из функции в ключ возвращаемой таблицы с помощью мета таблицы.

int show(lua_State* L) {
    luaL_getmetatable(L, "mt"); /* получить метатаблицу.*/
    lua_pushstring(L, "key");//отправить key, чтобы получить ref
    lua_gettable(L, -2);
    int ref = lua_tonumber(L, -1);
    lua_rawgeti(L, LUA_REGISTRYINDEX, ref);/* получить значение по ключу ref.*/

    getlaststack(L);
    return 0;
};
int create(lua_State * L) {//
    int k = lua_tointeger(L, -1);
    lua_gettable(L, -4);// получить глоб. таблицу.
    luaL_newmetatable(L, "mt");// создать мета таблицу.
    lua_pushcfunction(L, show);
    lua_setfield(L, -2, "show");// ключ таблицы является функцией.
    int ref = luaL_ref(L, LUA_REGISTRYINDEX);// получить уникальный ключ.

    pushlua(L, k);// значение для ключа. mt.ref = 5.
    lua_rawseti(L, LUA_REGISTRYINDEX, ref); /* уст ключ со значением 5 в реестре адрес. */

    lua_setmetatable(L, -2); //уст метатаблицу.

    lua_gettable(L, -3);// получить таблицу.
    luaL_getmetatable(L, "mt"); /* получить метатаблицу.*/

    lua_pushstring(L, "key");// это ключ для получение ref.
    lua_pushnumber(L, ref);
    lua_rawset(L, -3);

    luaL_getmetatable(L, "mt"); /* получить метатаблицу.*/
    return 1;
};

int main(int argc, char* argv[]) {
    const char* LUA = R"(
a = create(6)
a.show()
)";
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);

    lua_newtable(L);
    lua_pushcfunction(L, create);
    lua_setglobal(L, "create");// уст глоб имя в таблице как С функцию.


    checkerror(L, LUA);//Функция проверка на ошибки.

    lua_close(L);

    return 0;
};


Реестр хранить мета таблицу с польз.данными.

int main(int argc, char* argv[]) {
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);

    luaL_newmetatable(L, "mt");// создать мета таблицу.
    luaL_getmetatable(L, "mt"); /* получить метатаблицу.*/

    lua_pushstring(L, "key");// это ключ для получение 5.

    a** c = (a * *)lua_newuserdata(L, sizeof(a*));/*Эта функция выделяет новый блок памяти с заданным размером,*/
    *c = new a();

    lua_rawsetp(L, LUA_REGISTRYINDEX, "mt");  /* уст ключ в реестре адрес k.  */


    lua_pushstring(L, "key");// это ключ для получение объекта.*/
    lua_rawgetp(L, LUA_REGISTRYINDEX, "mt");/* получить значение по ключу key объект*/

    a** st = (a** )lua_touserdata(L, -1);// получаем польз. данные.
    a * b = &**st;
    b->show();// вызов метода.

    b->~a();//вызов метода деструктор.

    lua_close(L);
    return 0;
};

Реестр и метатаблицы, реализация ооп через таблицу с функциями.

struct a {  int x = 10;
    a() { cout << "create object " << this << endl; }//конструктор по умолчанию

    void show() { cout << "\nobject - " << this << "\tx = " << x << "\n\n"; }//вывести значение x на экран.

    ~a() { cout << "destory object " << this << endl << endl; }//вызов деструктора.
};


int destroy(lua_State* L) {// Функция вызывает деструктор для объекта.
    lua_pushstring(L, "key");// это ключ для получение объекта.*/
    lua_rawgetp(L, LUA_REGISTRYINDEX, "mt");/* получить значение (объект) по ключу key */
    a** st = (a * *)lua_touserdata(L, -1);// получаем польз. данные.
    a * b = &**st;
    b->~a();//вызов метода деструктор.
    return 0;
};

int show(lua_State * L) {
    lua_pushstring(L, "key");// это ключ для получение объекта.*/
    lua_rawgetp(L, LUA_REGISTRYINDEX, "mt");/* получить значение (объект) по ключу key */
    a** st = (a * *)lua_touserdata(L, -1);// получаем польз. данные.
    a * b = &**st;
    b->show();// вызов метода.
    return 0;
};
int create(lua_State * L) {//   Функция создания объекта структуры.
    lua_newtable(L);
    luaL_newmetatable(L, "mt");// создать мета таблицу.
    lua_pushcfunction(L, destroy);
    lua_setfield(L, -2, "__gc");

    lua_pushstring(L, "key");// это ключ для получение объекта.

    a** c = (a * *)lua_newuserdata(L, sizeof(a*));/*Эта функция выделяет новый блок памяти с заданным размером,*/
    luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
    *c = new a();
    lua_setmetatable(L, -2); //получает таблицу из стека и уст ее в качестве новой метатаблицы для значения с заданным допустимым индексом.

    lua_rawsetp(L, LUA_REGISTRYINDEX, "mt");  /* уст ключ в реестре адрес k.  */
    luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
    lua_pushcfunction(L, show);
    lua_setfield(L, -2, "show");

    return 1;
};

int main(int argc, char* argv[]) {
    const char* LUA = R"(

a = create()
a.show()

)";
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);

    lua_pushcfunction(L, create);
    lua_setglobal(L, "create");//уст указатель на функцию C++ и создает внутри Lua

    checkerror(L, LUA);//Функция проверка на ошибки.

    lua_close(L);

    return 0;
};


Метатаблица, передача значение между функциями.


int show(lua_State* L) {
    luaL_getmetatable(L, "mt"); /* получить метатаблицу.*/
    lua_pushstring(L, "key");//отправить key, чтобы получить ref
    lua_gettable(L, -2);
    cout << lua_tonumber(L, -1) << " == 5" << endl;//должно быть 5.
    return 0;
};
int create(lua_State * L) {//   Функция создания объекта структуры.
    luaL_newmetatable(L, "mt");// создать мета таблицу.
    luaL_getmetatable(L, "mt"); /* получить метатаблицу.*/

    lua_pushstring(L, "key");// это ключ для получение 5.
    lua_pushnumber(L, 5);// значение ключа key это 5.
    lua_settable(L, -3);// установить таблицу.
    return 1;
};

int main(int argc, char* argv[]) {
    const char* LUA = R"(
create()
show()
)";
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);

    lua_newtable(L);
    lua_pushcfunction(L, create);
    lua_setglobal(L, "create");// уст глоб имя в таблице как С функцию.

    lua_pushcfunction(L, show);
    lua_setglobal(L, "show");

    checkerror(L, LUA);//Функция проверка на ошибки.

    lua_close(L);

    return 0;
};


Метатаблица, передача польз.данных(объекта структуры) между функциями.


struct a {
    int x = 10;
    a() { cout << "create object " << this << endl; }//конструктор по умолчанию

    void show() { cout << "\nobject - " << this << "\tx = " << x << "\n\n"; }//вывести значение x на экран.

    ~a() { cout << "destory object " << this << endl << endl; }//вызов деструктора.
};

int destroy(lua_State* L) {// Функция вызывает деструктор для объекта.
    cout << "destroy " << endl;
    luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
    a** st = (a * *)lua_touserdata(L, -2); // получаем польз. данные.
    a * b = &**st;
    b->~a();//вызов метода деструктор.
    return 0;

};

int show(lua_State* L) {
    luaL_getmetatable(L, "mt"); /* получить метатаблицу.*/
    lua_pushstring(L, "key");//отправить key, чтобы получить объект.
    lua_gettable(L, -2);
    a** st = (a * *)lua_touserdata(L, -1);// получаем польз. данные.
    a * b = &**st;
    b->show();// вызов метода.
    b->~a();//вызов метода деструктор.

    return 0;
};
int create(lua_State * L) {//   Функция создания объекта структуры.
    luaL_newmetatable(L, "mt");// создать мета таблицу.
    luaL_getmetatable(L, "mt"); /* получить метатаблицу.*/

    lua_pushstring(L, "key");// это ключ для получение 5.

    a** c = (a **)lua_newuserdata(L, sizeof(a*));/*Эта функция выделяет новый блок памяти с заданным размером,*/
    *c = new a();

    lua_settable(L, -3);// установить таблицу.
    return 1;
};

int main(int argc, char* argv[]) {
    const char* LUA = R"(
create()
show()
)";
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);

    lua_newtable(L);
    lua_pushcfunction(L, create);
    lua_setglobal(L, "create");// уст глоб имя в таблице как С функцию.

    lua_pushcfunction(L, show);
    lua_setglobal(L, "show");

    checkerror(L, LUA);//Функция проверка на ошибки.

    lua_close(L);

    return 0;
};









int destroy(lua_State* L) {// Функция вызывает деструктор для объекта.
    cout << "destroy " << endl;
    luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
    a** st = (a * *)lua_touserdata(L, -2); // получаем польз. данные.
    a *b = &**st;

    b->~a();//вызов метода деструктор.
    return 0;

};

int show(lua_State * L) {

    cout << "show " << endl;
    luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
    cout << lua_type(L,-2) << endl;
    //a** st = (a * *)lua_touserdata(L, -2);// получаем польз. данные.
    //a * b = &**st;
    //b->show();// вызов метода.
    return 0;
};
    //lua_newtable(L);
    //luaL_newmetatable(L, "mt");// создать мета таблицу.
    //pushlua(L, "__gc");
    //lua_pushcfunction(L, destroy);
    //lua_settable(L, -3); //получает таблицу из стека и уст ее в качестве новой метатаблицы для значения с заданным допустимым индексом.

int create(lua_State* L) {//    Функция создания объекта структуры.
    lua_newtable(L);
    luaL_newmetatable(L, "mt");// создать мета таблицу.
    lua_pushcfunction(L, destroy);
    lua_setfield(L, -2, "__gc");

    a** c = (a * *)lua_newuserdata(L, sizeof(a*));/*Эта функция выделяет новый блок памяти с заданным размером,*/
    luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
    *c = new a();
    lua_setmetatable(L, -2); //получает таблицу из стека и уст ее в качестве новой метатаблицы для значения с заданным допустимым индексом.

    lua_gettable(L, -3);
    luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/

   lua_pushcfunction(L, show);
    lua_setfield(L, -2, "show");
    luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/

    return 1;
};

int main(int argc, char* argv[]) {
const char* LUA = R"(

a= create()
a.show()

)";
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);

    lua_pushcfunction(L, create);
    lua_setglobal(L, "create");//уст указатель на функцию C++ и создает внутри Lua

    checkerror(L, LUA);//Функция проверка на ошибки.

    lua_close(L);

    return 0;
};



По указателю.
int destroy(lua_State* L) {// Функция вызывает деструктор для объекта.
    cout << "destroy " << endl;
    luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
    a* st = (a* )lua_touserdata(L, -2); // получаем польз. данные.

    st->~a();//вызов метода деструктор.
    return 0;
};

int create(lua_State * L) {//   Функция создания объекта структуры.
    lua_newtable(L);
    luaL_newmetatable(L, "mt");// создать мета таблицу.
    pushlua(L, "__gc");
    lua_pushcfunction(L, destroy);
    lua_settable(L, -3); //получает таблицу из стека и уст ее в качестве новой метатаблицы для значения с заданным допустимым индексом.


    a* c = (a *)lua_newuserdata(L, sizeof(a));/*Эта функция выделяет новый блок памяти с заданным размером,*/
    luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
    c = new a();
    lua_setmetatable(L, -2); //получает таблицу из стека и уст ее в качестве новой метатаблицы для значения с заданным допустимым индексом.

    return 1;
};


Через реестр.

struct a {
    int x = 10;
    a() { cout << "create object " << this << endl; }//конструктор по умолчанию

    void show() { cout << "\nobject - " << this << "\tx = " << x << "\n\n"; }//вывести значение x на экран.

    ~a() { cout << "destory object " << this << endl << endl; }//вызов деструктора.
};

int destroy(lua_State* L) {// Функция вызывает деструктор для объекта.
    cout << "destroy " << endl;
    luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
    a** st = (a * *)lua_touserdata(L, -2); // получаем польз. данные.
    a *b = &**st;

    b->~a();//вызов метода деструктор.


    return 0;

};

int show(lua_State * L) {

luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/

    lua_pushstring(L, "key");
    lua_gettable(L, -2);
    cout << lua_tonumber(L, -1)<<"ref \n";
    int ref = 3;
    pushlua(L, ref);
    lua_rawgetp(L, LUA_REGISTRYINDEX, &ref);/* получить значение по ключу адрес k*/

    //getlaststack(L);
cout << lua_type(L,-1) << endl;
//  a** st = (a * *)lua_touserdata(L, -1);// получаем польз. данные.
//  a * b = &**st;
//  b->show();// вызов метода.
    return 0;
};
int create(lua_State* L) {//    Функция создания объекта структуры.
    lua_gettable(L, -3);
    luaL_newmetatable(L, "mt");// создать мета таблицу.
    lua_pushcfunction(L, destroy);
    lua_setfield(L, -2, "__gc");

    lua_pushcfunction(L, show);
    lua_setfield(L, -2, "show");
    int ref = luaL_ref(L, LUA_REGISTRYINDEX);

    //luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
    a** c = (a * *)lua_newuserdata(L, sizeof(a*));/*Эта функция выделяет новый блок памяти с заданным размером,*/
    *c = new a();
    lua_rawsetp(L, LUA_REGISTRYINDEX, &ref);  /* уст ключ в реестре адрес k.  */

    lua_setmetatable(L, -2); //получает таблицу из стека и уст ее в качестве новой метатаблицы для значения с заданным допустимым индексом.

    lua_gettable(L, -2);
    luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/

    lua_pushcfunction(L, show);
    lua_setfield(L, -2, "show");
    lua_pushstring(L, "key");
    lua_pushnumber(L, ref);
    lua_rawset(L, -3);

    cout << ref<<" kkmj\n";

    luaL_getmetatable(L, "mt"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
    return 1;
};

int main(int argc, char* argv[]) {
const char* LUA = R"(

a= create()
a.show()

)";
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);

    lua_newtable(L);
    lua_pushcfunction(L, create);
    lua_setglobal(L, "create");//уст указатель на функцию C++ и создает внутри Lua

    checkerror(L, LUA);//Функция проверка на ошибки.

    lua_close(L);

    return 0;
};

Реестр. Передача значение между функциями через метатаблицу.

int show(lua_State * L) {
    luaL_getmetatable(L, "mt"); /* получить метатаблицу.*/
    lua_pushstring(L, "key");//отправить key, чтобы получить ref
    lua_gettable(L, -2);
    int ref = lua_tonumber(L, -1);
    lua_rawgetp(L, LUA_REGISTRYINDEX, &ref);/* получить значение по ключу ref.*/
    cout << lua_tonumber(L, -1) << " value 5" << endl;//должно быть 5.
    return 0;
};
int create(lua_State * L) {//   Функция создания объекта структуры.
    lua_gettable(L, -3);// получить глоб. таблицу.
    luaL_newmetatable(L, "mt");// создать мета таблицу.
    int ref = luaL_ref(L, LUA_REGISTRYINDEX);// получить уникальный ключ.
    pushlua(L, 5);// отправить значение для ключа. mt.ref = 5.
    lua_rawsetp(L, LUA_REGISTRYINDEX, &ref); /* уст ключ со значением 5 в реестре адрес. */

    lua_pushstring(L, "key");// это ключ для получение ref.
    lua_pushnumber(L, ref);

    lua_setmetatable(L, -2); //уст метатаблицу.
    luaL_getmetatable(L, "mt"); /* получить метатаблицу.*/
    return 1;
};

int main(int argc, char* argv[]) {
    const char* LUA = R"(
create()
show()
)";
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);

    lua_newtable(L);
    lua_pushcfunction(L, create);
    lua_setglobal(L, "create");// уст глоб имя в таблице как С функцию.

    lua_pushcfunction(L, show);
    lua_setglobal(L, "show");

    checkerror(L, LUA);//Функция проверка на ошибки.

    lua_close(L);

    return 0;
};

Выводится.
5 value 5

C:\Users\e\source\repos\Project1luaapi\Debug\Project1luaapi.exe (процесс 2764) завершает работу с кодом 0.
Чтобы закрыть это окно, нажмите любую клавишу…

Реестр. Передача в функцию числа, возвращаем из другой функции.

int show(lua_State* L) {
    luaL_getmetatable(L, "mt"); /* получить метатаблицу.*/

    pushlua(L, "key");
    lua_gettable(L, -2);
    int ref = lua_tonumber(L, -1);
    cout << "in func show regis key " << ref  << endl;
    lua_rawgetp(L, LUA_REGISTRYINDEX, &ref);/* получить значение по ключу ref.*/

    cout << lua_tonumber(L, -1) << " value 5" << endl;//должно быть 5.
    return 0;
};
int create(lua_State * L) {//   Функция создания объекта структуры.
    int k = lua_tonumber(L, -1);
    cout << k << endl;// 5
    int ref = luaL_ref(L, LUA_REGISTRYINDEX);// получить уникальный ключ.
    cout <<"in func create regis key " << ref  << endl;

    luaL_newmetatable(L, "mt");// создать мета таблицу.
    luaL_getmetatable(L, "mt"); /* получить метатаблицу.*/
    lua_gettable(L, -2);// получить глоб. таблицу.
    pushlua(L, k);// значение для ключа. mt.ref = 5.
    lua_rawsetp(L, LUA_REGISTRYINDEX, &k); /* уст ключ со значением 5 в реестре адрес. */
    lua_setmetatable(L, -2); //уст метатаблицу.
    luaL_getmetatable(L, "mt"); /* получить метатаблицу.*/
    pushlua(L, "key");// это ключ для получение ref.
    pushlua(L, ref);
    lua_settable(L, -3);
return 1;
};

int main(int argc, char* argv[]) {
    const char* LUA = R"(
create(5)
show()
)";
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);

    lua_newtable(L);
    lua_pushcfunction(L, create);
    lua_setglobal(L, "create");// уст глоб имя в таблице как С функцию.

    lua_pushcfunction(L, show);
    lua_setglobal(L, "show");

    checkerror(L, LUA);//Функция проверка на ошибки.

    lua_close(L);

    return 0;
};
Выводится.
5
in func create regis key 3
in func show regis key 3
5 value 5

C:\Users\e\source\repos\Project1luaapi\Debug\Project1luaapi.exe (процесс 5912) завершает работу с кодом 0.
Чтобы закрыть это окно, нажмите любую клавишу…


test1.lua
x = 1
function hi()
    print("hi1");
    print(x);
end
hi()
test2.lua
x =2
function hi()
    print("hi2");
    print(x);
end
hi()


int main(int argc, char *argv[]) {

    lua_State* L = luaL_newstate();
    luaL_openlibs(L);

    const char* file1 = "test1.lua";
    const char* file2 = "test2.lua";

    //We load the file
    luaL_loadfile(L, file1);
    //Create _ENV tables
    lua_newtable(L);
    //Create metatable
    lua_newtable(L);
    //Get the global table
    lua_getglobal(L, "_G");
    lua_setfield(L, -2, "__index");
    //Set global as the metatable
    lua_setmetatable(L, -2);
    //Push to registry with a unique name.
    //I feel like these 2 steps could be merged or replaced but I'm not sure how
    lua_setfield(L, LUA_REGISTRYINDEX, "test1");
    //Retrieve it.
    lua_getfield(L, LUA_REGISTRYINDEX, "test1");
    //Set the upvalue (_ENV)
    lua_setupvalue(L, 1, 1);
    //Run chunks
    lua_pcall(L, 0, LUA_MULTRET, 0);

    //Repeat
    luaL_loadfile(L, file2);
    lua_newtable(L);
    lua_newtable(L);
    lua_getglobal(L, "_G");
    lua_setfield(L, -2, "__index");
    lua_setmetatable(L, -2);
    lua_setfield(L, LUA_REGISTRYINDEX, "test2");
    lua_getfield(L, LUA_REGISTRYINDEX, "test2");
    lua_setupvalue(L, 1, 1);
    lua_pcall(L, 0, LUA_MULTRET, 0);

    //Retrieve the table containing the functions of the chunk
    lua_getfield(L, LUA_REGISTRYINDEX, "test1");
    //Get the function we want to call
    lua_getfield(L, -1, "hi");
    //Call it
    lua_call(L, 0, 0);
    //Repeat
    lua_getfield(L, LUA_REGISTRYINDEX, "test2");
    lua_getfield(L, -1, "hi");
    lua_call(L, 0, 0);
    lua_getfield(L, LUA_REGISTRYINDEX, "test2");
    lua_getfield(L, -1, "hi");
    lua_call(L, 0, 0);
    lua_getfield(L, LUA_REGISTRYINDEX, "test1");
    lua_getfield(L, -1, "hi");
    lua_call(L, 0, 0);


    lua_close(L);// закрыть состояние
    cin.get();//ожидает ввода символа программа завершается.

    return 0;
}


Замыкание.

struct Sprite
    {
        int x;
        int y;

        Sprite() : x(0), y(0) {}
        ~Sprite() {}

        void Move(int velX, int velY)
        {
            x += velX;
            y += velY;
        }

        void Draw()
        {
            printf("sprite(%p): x = %d, y = %d\n", this, x, y);
        }
    };

    struct SpriteManager
    {
        std::vector<Sprite*> m_sprites;
        int numberOfSpritesExisting = 0;
        int numberOfSpritesMade = 0;

        void LookAfterSprite(Sprite* sprite)
        {
            numberOfSpritesExisting++;
            numberOfSpritesMade++;
            m_sprites.push_back(sprite);
        }

        void ForgetSprite(Sprite* sprite)
        {
            int i = 0;
            for (auto& s : m_sprites)
            {
                if (s == sprite)
                {
                    numberOfSpritesExisting--;
                    m_sprites.erase(m_sprites.begin() + i);
                    return;
                }
                i++;
            }
        }
    };

    SpriteManager spriteManager;

    int CreateSprite(lua_State* L){
        SpriteManager* sm = (SpriteManager*)lua_touserdata(L, lua_upvalueindex(1));
        lua_assert(sm);

        void* pointerToASprite = lua_newuserdata(L, sizeof(Sprite));
        new (pointerToASprite) Sprite();
        luaL_getmetatable(L, "SpriteMetaTable");
        lua_assert(lua_istable(L, -1));
        lua_setmetatable(L, -2);

        lua_newtable(L);
        lua_setuservalue(L, 1);

        sm->LookAfterSprite((Sprite*)pointerToASprite);

        return 1;
    };

    int DestroySprite(lua_State* L){
        SpriteManager* sm = (SpriteManager*)lua_touserdata(L, lua_upvalueindex(1));
        lua_assert(sm);

        Sprite* sprite = (Sprite*)lua_touserdata(L, -1);
        sm->ForgetSprite(sprite);
        sprite->~Sprite();
        return 0;
    };

    int MoveSprite(lua_State* L){
        Sprite* sprite = (Sprite*)lua_touserdata(L, -3);
        lua_Number velX = lua_tonumber(L, -2);
        lua_Number velY = lua_tonumber(L, -1);
        sprite->Move((int)velX, (int)velY);
        return 0;
    };

    int DrawSprite(lua_State* L){
        Sprite* sprite = (Sprite*)lua_touserdata(L, -1);
        sprite->Draw();
        return 0;
    };

    int SpriteIndex(lua_State* L){
        lua_assert(lua_isuserdata(L, -2));  //1
        lua_assert(lua_isstring(L, -1));    //2

        Sprite* sprite = (Sprite*)lua_touserdata(L, -2);
        const char* index = lua_tostring(L, -1);
        if (strcmp(index, "x") == 0)
        {
            lua_pushnumber(L, sprite->x);
            return 1;
        }
        else if (strcmp(index, "y") == 0)
        {
            lua_pushnumber(L, sprite->y);
            return 1;
        }
        else
        {
            lua_getuservalue(L, 1);
            lua_pushvalue(L, 2);
            lua_gettable(L, -2);
            if (lua_isnil(L, -1))
            {
                lua_getglobal(L, "Sprite");
                lua_pushstring(L, index);
                lua_rawget(L, -2);
            }
            return 1;
        }
    };

    int SpriteNewIndex(lua_State* L){
        lua_assert(lua_isuserdata(L, -3));  //1
        lua_assert(lua_isstring(L, -2));    //2
                                        // -1 - value we want to set    //3

        Sprite* sprite = (Sprite*)lua_touserdata(L, -3);
        const char* index = lua_tostring(L, -2);
        if (strcmp(index, "x") == 0)
        {
            sprite->x = (int)lua_tonumber(L, -1);
        }
        else if (strcmp(index, "y") == 0)
        {
            sprite->y = (int)lua_tonumber(L, -1);
        }
        else
        {
            lua_getuservalue(L, 1); //1
            lua_pushvalue(L, 2);    //2
            lua_pushvalue(L, 3);    //3
            lua_settable(L, -3);    //1[2] = 3
        }

        return 0;
    };

int main(int argc, char *argv[]) {
    const char* LUA_FILE = R"(
        sprite = Sprite.new()
        sprite:Move( 6, 7 )     -- Sprite.Move( sprite, 6, 7 )
        sprite:Draw()
        sprite.y = 10
        sprite.zzz = 99
        sprite.x = sprite.zzz
        sprite:Draw()
        Sprite.new()
        Sprite.new()
        )";

    lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);

    lua_newtable(L);
    int spriteTableIdx = lua_gettop(L);
    lua_pushvalue(L, spriteTableIdx);
    lua_setglobal(L, "Sprite");

    constexpr int NUMBER_OF_UPVALUES = 1;
    lua_pushlightuserdata(L, &spriteManager);
    lua_pushcclosure(L, CreateSprite, NUMBER_OF_UPVALUES);
    lua_setfield(L, -2, "new");
    lua_pushcfunction(L, MoveSprite);
    lua_setfield(L, -2, "Move");
    lua_pushcfunction(L, DrawSprite);
    lua_setfield(L, -2, "Draw");

    luaL_newmetatable(L, "SpriteMetaTable");
    lua_pushstring(L, "__gc");
    lua_pushlightuserdata(L, &spriteManager);
    lua_pushcclosure(L, DestroySprite, NUMBER_OF_UPVALUES);
    lua_settable(L, -3);

    lua_pushstring(L, "__index");
    lua_pushcfunction(L, SpriteIndex);
    lua_settable(L, -3);

    lua_pushstring(L, "__newindex");
    lua_pushcfunction(L, SpriteNewIndex);
    lua_settable(L, -3);

    int doResult = luaL_dostring(L, LUA_FILE);
    if (doResult != LUA_OK)
    {
        printf("Error: %s\n", lua_tostring(L, -1));
    }

    lua_close(L);

    lua_assert(spriteManager.numberOfSpritesExisting == 0);
    lua_assert(spriteManager.numberOfSpritesMade == 3);

    cin.get();//ожидает ввода символа программа завершается.
    return 0;
}


struct Sprite
    {
        int x;

        Sprite() : x(0) {}
        ~Sprite() {}

        void Move(int velX)
        {
            x += velX;
        }

        void Draw()
        {
            printf("sprite(%p): x = %d\n", this, x);
        }
    };

    struct SpriteManager
    {
        std::vector<Sprite*> m_sprites;
        void ForgetSprite(Sprite* sprite)
        {
            int i = 0;
            for (auto& s : m_sprites)
            {
                if (s == sprite){
                    m_sprites.erase(m_sprites.begin() + i);
                    return;
                }
                i++;
            }
        }
    };

SpriteManager sp;

    int CreateSprite(lua_State* L){

        SpriteManager* sm = (SpriteManager*)lua_touserdata(L, lua_upvalueindex(1));
        void* pointerToASprite = lua_newuserdata(L, sizeof(Sprite));
        new (pointerToASprite) Sprite();
        luaL_getmetatable(L, "mt");
        lua_setmetatable(L, -2);
        lua_newtable(L);
        lua_setuservalue(L, 1);
        return 1;
    };

    int DestroySprite(lua_State* L){
        SpriteManager* sm = (SpriteManager*)lua_touserdata(L, lua_upvalueindex(1));
        Sprite* sprite = (Sprite*)lua_touserdata(L, -1);
        sm->ForgetSprite(sprite);
        sprite->~Sprite();
        return 0;
    };

    int DrawSprite(lua_State* L){
        Sprite* sprite = (Sprite*)lua_touserdata(L, -2);
        sprite->Move(lua_tonumber(L, -1));
        sprite->Draw();
        return 0;
    };

    int SpriteIndex(lua_State* L){

        Sprite* sprite = (Sprite*)lua_touserdata(L, -2);
        const char* index = lua_tostring(L, -1);
            lua_getuservalue(L, 1);
            lua_pushvalue(L, 2);
            lua_gettable(L, -2);

            lua_getglobal(L, "sprite");
            lua_pushstring(L, index);
            lua_rawget(L, -2);

            return 1;
    };


int main(int argc, char *argv[]) {
    const char* LUA_FILE = R"(
        sp = sprite.new()
        sp:draw(6)
        )";

    lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);

    lua_newtable(L);
    lua_pushvalue(L, 1);
    lua_setglobal(L, "sprite");

    lua_pushlightuserdata(L, &sp);
    lua_pushcclosure(L, CreateSprite, 1);
    lua_setfield(L, -2, "new");
    lua_pushcfunction(L, DrawSprite);
    lua_setfield(L, -2, "draw");

    luaL_newmetatable(L, "mt");
    lua_pushstring(L, "__gc");
    lua_pushlightuserdata(L, &sp);
    lua_pushcclosure(L, DestroySprite, 1);
    lua_settable(L, -3);

    lua_pushstring(L, "__index");
    lua_pushcfunction(L, SpriteIndex);
    lua_settable(L, -3);
    luaL_dostring(L, LUA_FILE);

    lua_close(L);

    cin.get();//ожидает ввода символа программа завершается.
    return 0;
};


Замыкание 2.

struct Sprite
    {
        int x;

        Sprite() : x(0) {}
        ~Sprite() {}

        void Move(int velX)
        {
            x += velX;
        }

        void Draw()
        {
            printf("sprite(%p): x = %d\n", this, x);
        }
    };

    struct SpriteManager
    {
        std::vector<Sprite*> m_sprites;
        void ForgetSprite(Sprite* sprite)
        {
            int i = 0;
            for (auto& s : m_sprites)
            {
                if (s == sprite){
                    m_sprites.erase(m_sprites.begin() + i);
                    return;
                }
                i++;
            }
        }
    };
    int pri(lua_State* L) { cout << "pri " << endl;
    return 0;
    }
SpriteManager sp;

    int CreateSprite(lua_State* L){
        SpriteManager* sm = (SpriteManager*)lua_touserdata(L, lua_upvalueindex(1));
        void* pointerToASprite = lua_newuserdata(L, sizeof(Sprite));
        new (pointerToASprite) Sprite();
        luaL_getmetatable(L, "mt");
        lua_setmetatable(L, -2);
        lua_newtable(L);
        lua_setuservalue(L, 1);
        return 1;
    };

    int DestroySprite(lua_State* L){
        SpriteManager* sm = (SpriteManager*)lua_touserdata(L, lua_upvalueindex(1));
        Sprite* sprite = (Sprite*)lua_touserdata(L, -1);
        sm->ForgetSprite(sprite);
        sprite->~Sprite();
        return 0;
    };

    int DrawSprite(lua_State* L){
        Sprite* sprite = (Sprite*)lua_touserdata(L, -2);
        sprite->Move(lua_tonumber(L, -1));
        sprite->Draw();
        return 0;
    };

    int SpriteIndex(lua_State* L){

        Sprite* sprite = (Sprite*)lua_touserdata(L, -2);
        const char* index = lua_tostring(L, -1);
            lua_getuservalue(L, 1);
            lua_pushvalue(L, 2);
            lua_gettable(L, -2);

            lua_getglobal(L, "sprite");
            lua_pushstring(L, index);
            lua_rawget(L, -2);

            return 1;
    };


int main(int argc, char *argv[]) {
    const char* LUA_FILE = R"(
        sp = sprite.new()
        sp:draw(6)
        )";

    lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);

    lua_newtable(L);
    lua_pushvalue(L, 1);
    lua_setglobal(L, "sprite");

    lua_pushlightuserdata(L, &sp);
    lua_pushcclosure(L, CreateSprite, 1);
    lua_setfield(L, -2, "new");
    lua_pushcfunction(L, DrawSprite);
    lua_setfield(L, -2, "draw");

    luaL_newmetatable(L, "mt");
    lua_pushstring(L, "__gc");
    lua_pushlightuserdata(L, &sp);
    lua_pushcclosure(L, DestroySprite, 1);
    lua_settable(L, -3);

    lua_pushstring(L, "__index");
    lua_pushcfunction(L, SpriteIndex);
    lua_settable(L, -3);
    luaL_dostring(L, LUA_FILE);

    lua_close(L);

    cin.get();//ожидает ввода символа программа завершается.
    return 0;
}

Замыкание 3

struct Sprite
{
    int x;

    Sprite() : x(0) { cout << " sp" << endl; }
    ~Sprite() { cout << " des " << endl; }

};


int pri(lua_State* L) {
    cout << "pri " << endl;
    return 0;
}

int CreateSprite(lua_State* L) {
    void* pointerToASprite = lua_newuserdata(L, sizeof(Sprite));
    new (pointerToASprite) Sprite();
    luaL_getmetatable(L, "mt");
    lua_setmetatable(L, -2);
    lua_newtable(L);
    lua_setuservalue(L, 1);
    return 1;
};

int DestroySprite(lua_State* L) {
    Sprite* sprite = (Sprite*)lua_touserdata(L, -1);
    sprite->~Sprite();
    return 0;
};


int main(int argc, char *argv[]) {
    const char* LUA_FILE = R"(
        sp = sprite.new()
        )";

    lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);

    lua_newtable(L);
    lua_pushvalue(L, 1);
    lua_setglobal(L, "sprite");

    lua_pushinteger(L, 2);
    lua_pushcclosure(L, CreateSprite, 1);
    lua_setfield(L, -2, "new");

    luaL_newmetatable(L, "mt");
    lua_pushstring(L, "__gc");

    lua_pushinteger(L, 2);
    lua_pushcclosure(L, DestroySprite, 1);
    lua_settable(L, -3);

    luaL_dostring(L, LUA_FILE);

    lua_close(L);

    cin.get();//ожидает ввода символа программа завершается.
    return 0;
}

Замыкание 4.

int pri(lua_State* L) {
    showstack(L);
    cout << "pri " << endl;
    return 0;
}

int CreateSprite(lua_State* L) {
    cout << "cre " << endl;
    lua_gettable(L, -2);
    lua_setuservalue(L, 1);
    return 1;
};

int main(int argc, char *argv[]) {
    const char* LUA_FILE = R"(
        sp = sprite.new()
        )";

    lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);

    lua_newtable(L);
    lua_pushvalue(L, 1);
    lua_setglobal(L, "sprite");

    lua_pushinteger(L, 2);
    lua_pushcclosure(L, pri, 1);
    lua_setfield(L, -2, "new");

    luaL_dostring(L, LUA_FILE);
    lua_close(L);

    cin.get();//ожидает ввода символа программа завершается.
    return 0;
}

Замыкание 5.

static int newcounter(lua_State *L) {
    cout << lua_tonumber(L, -1) << endl;
    cout << " new" << endl;
    int val = lua_tointeger(L, lua_upvalueindex(1));
    lua_pushinteger(L, 1);  /* new value */
    lua_copy(L, -1, lua_upvalueindex(1));  /* update upvalue */
    return 1;
}
static int counter(lua_State *L) {
    cout << "coun " << endl;
    lua_pushinteger(L, 10);
    lua_pushcclosure(L, newcounter, 1);
    return 1;  /* return new value */
}


int main(int argc, char *argv[]) {
    const char* LUA = R"(
 c1 = counter()
    print(c1(), c1(), c1())   --> 1    2    3
     -- c2 = newcounter()
      --print(c2(), c2(), c1())   --> 1    2    4

        )";

    lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    //lua_newtable(L);

    //lua_pushnumber(L, 142);
    lua_register(L,"counter", counter);// отправить c функцию в стек.
    luaL_dostring(L, LUA);
    //lua_pushnumber(L, 142);
  lua_pushcclosure(L, newcounter, 1);

//  lua_settable(L, -3);

    lua_pcall(L, 0, 0, 0);// вызвать функцию foo.

    lua_close(L);

    cin.get();//ожидает ввода символа программа завершается.
    return 0;
}


Замыкание 6.


static int newcounter(lua_State *L) {
    int val = lua_tointeger(L, lua_upvalueindex(1));/*Возвращает псевдоиндекс, который представляет
    i-ковою внешнюю локальную переменную (upvalue) выполняемой функции.*/
    lua_pushinteger(L, ++val);  /*  новое  значение    */
    lua_pushvalue(L, -1);   /*дублирует    его  */
    lua_replace(L, lua_upvalueindex(1));/*  обновляет  верхнее  значение*/
    return 1;
}
static int counter(lua_State *L) {
    lua_pushinteger(L, 0);
    lua_pushcclosure(L, newcounter, 1);
    return 1;  /* return new value */
}

int main(int argc, char *argv[]) {
    const char* LUA = R"(
   c1 = counter()
   print(c1(), c1(), c1())   --> 1    2    3
   )";

    lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);

    lua_register(L,"counter", counter);// отправить c функцию в стек.
    checkerror(L, LUA);

    lua_pushcclosure(L, newcounter, 1);/* Помещает в стек новое C замыкание. При создании C функций, можно увязать
с ней некоторые значения, таким образом создавая C замыкания (closure); затем эти значения будут доступны функции
каждый раз при её вызове. Для связывания значений с C функцией, вначале эти значения помещаются в стек
(когда имеется несколько значений, первое значение помещается первым). Затем вызывается lua_pushcclosure для
создания и помещения в стек C функции, с аргументом n, сообщающим сколько значений будет связано с этой функцией.
lua_pushcclosure также выводит из стека эти значения. Макс значением для n является 255. При n равным нулю,
эта функция создает легкую C функцию, которая является просто указателем на C функцию. В этом случае, она никогда
не вызывает ошибку памяти.*/

    lua_close(L);
    return 0;

};

Замыкание 7.


int newcounter(lua_State* L) {
    int val = lua_tointeger(L, lua_upvalueindex(1));/*Возвращает псевдоиндекс, который представляет
    i-ковою внешнюю локальную переменную (upvalue) выполняемой функции.*/
    lua_pushinteger(L, val++);  /*  новое  значение    */
    lua_pushvalue(L, -1);   /*дублирует    его  */
    lua_replace(L, lua_upvalueindex(1));/*  обновляет верхнее значение. снимает значение с вершины стека
                и устанавливает его как значение элемента с заданным индексом.*/
    return 1;
}
int counter(lua_State * L) {
    lua_pushinteger(L, 1);
    lua_pushcclosure(L, newcounter, 1);/* Помещает в стек новое C замыкание. При создании C функций, можно увязать
с ней некоторые значения, таким образом создавая C замыкания (closure); затем эти значения будут доступны функции
каждый раз при её вызове. Для связывания значений с C функцией, вначале эти значения помещаются в стек
(когда имеется несколько значений, первое значение помещается первым). Затем вызывается lua_pushcclosure для
создания и помещения в стек C функции, с аргументом n, сообщающим сколько значений будет связано с этой функцией.
lua_pushcclosure также выводит из стека эти значения. Макс значением для n является 255. При n равным нулю,
эта функция создает легкую C функцию, которая является просто указателем на C функцию. В этом случае, она никогда
не вызывает ошибку памяти.*/

    return 1;  /* return new value */
}

int main(int argc, char* argv[]) {
    const char* LUA = R"(
   c = counter()
   print(c(), c(), c())   --> 1    2    3
   )";

    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);

    lua_register(L, "counter", counter);// отправить c функцию в стек.
    checkerror(L, LUA);


    lua_close(L);
    return 0;

};




luaL_setfuncs

int foo1(lua_State * L){
    cout << "foo1 " << endl;
    return 0;
}

int foo2(lua_State * L) {
    cout << "foo2 " << endl;
    return 0;
}

void RegisterFoo(lua_State * L){
    luaL_Reg sFooRegs[] =
    {
        { "foo1", foo1 },
        { "foo2", foo2 },
        { NULL, NULL }
    };

    luaL_newmetatable(L, "luaL_Foo");

    // Register the C functions _into_ the metatable we just created.
    luaL_setfuncs(L, sFooRegs, 0);/*    void luaL_setfuncs(lua_State * L, const luaL_Reg * l, int nup);
    Регистрирует все функции в массиве l(см.luaL_Reg) В таблице на вершине стека(ниже необязательных
    значений повышений).Когда nupне ноль, все функции создаются с nup общими значениями повышения, которые
    должны быть предварительно помещены в стек поверх таблицы библиотеки. Эти значения выталкиваются
    из стека после регистрации.*/

    lua_pushvalue(L, -1);
    lua_setfield(L, -1, "__index");

    lua_setglobal(L, "Foo");
}
int main(int argc, char *argv[]) {
    const char* LUA = R"(
Foo.foo1()
Foo.foo2()
   )";

    lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    RegisterFoo(L);
    checkerror(L, LUA);

    lua_close(L);
    return 0;
};

Еще пример.


int foo1(lua_State* L) {
    int val = lua_tointeger(L, lua_upvalueindex(1));/*Возвращает псевдоиндекс, который представляет
   i-ковою внешнюю локальную переменную (upvalue) выполняемой функции.*/
    cout << "foo " << val << endl;
    return 0;
};

int foo2(lua_State* L) {
    int val = lua_tointeger(L, lua_upvalueindex(1));/*Возвращает псевдоиндекс, который представляет
i-ковою внешнюю локальную переменную (upvalue) выполняемой функции.*/
    cout << "foo2 " << val << endl;
    return 0;
};

void RegisterFoo(lua_State* L) {
    luaL_Reg sFooRegs[] =
    {
        { "foo1", foo1 },
        { "foo2", foo2 },
        { NULL, NULL }
    };

    luaL_newmetatable(L, "luaL_Foo");

    lua_pushinteger(L, 1);
    // Register the C functions _into_ the metatable we just created.
    luaL_setfuncs(L, sFooRegs, 1);/* void luaL_setfuncs(lua_State * L, const luaL_Reg * l, int nup);
    Регистрирует все функции в массиве l) В таблице на вершине стека(ниже необязательных
    значений повышений).Когда nupне ноль, все функции создаются с nup общими значениями повышения, которые
    должны быть предварительно помещены в стек поверх таблицы библиотеки. Эти значения выталкиваются
    из стека после регистрации.*/

    lua_pushvalue(L, -1);
    lua_setfield(L, -1, "__index");

    lua_setglobal(L, "Foo");
}

int main(int argc, char* argv[]) {
    const char* LUA = R"(
Foo.foo1()
Foo.foo2()
   )";

    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    RegisterFoo(L);
    checkerror(L, LUA);

    lua_close(L);

    return 0;
};

Мета метод _index

int main(int argc, char* argv[]) {
const char* LUA = R"(
foo={} foo.key="value"
bar = setmetatable({},{__index=foo},print("index\n") )
print(bar.key)-- value
)";
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    checkerror(L, LUA);//Функция проверка на ошибки.
    lua_close(L);

    return 0;
};



Потоки. Многопоточность — это принцип построения программы, при котором несколько блоков могут выполняться одновременно и не мешать друг другу.


Lua. Это по сути однопоточная система.
lua_State * lua_newthread ( lua_State * L);
Создает новый поток, помещает его в стек и возвращает указатель на объект lua_State, представляющий этот новый поток. Новое состояние, возвращаемое этой функцией, совместно использует с исходным состоянием все глобальные объекты (например, таблицы), но имеет независимый стек выполнения.
Не существует явной функции для закрытия или уничтожения потока. Потоки подлежат сборке мусора, как и любой объект Lua.

Без вызова потока. Вызов функции в одном потоке.

int foo(lua_State* L) {
    cout << " func foo c++ " << L << endl;
    return 0;
};

int main(int argc, char* argv[]) {
    const char* LUA = R"(
foo()

)";
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    lua_State* L1 = lua_newthread(L);
    lua_pushcfunction(L, foo);// отправить c функцию в стек.
    showstack(L); cout <<  endl;
    lua_setglobal(L, "foo");// уст для переменной значение в виде функции.
        luaL_dostring(L, LUA);
    cout <<"\n";
    showstack(L);
    cout << "\n adrees L  "<<  L << "\n adrees L1 "<< L1 << "\n";
    lua_close(L);

    return 0;
};

Эта функция возвращает указатель на lua_State, представляющее новой поток, а также отправить новой поток в стек как значение типа "thread". Например, после выполнения оператора L1 = lua_newthread(L);
у нас будет два потока, L1 и L, которые будут внутренне ссылаться на одно и то же состояние Lua. Каждый поток обладает собственным стеком.
Новый поток L1 начинает с пустого стека; у старого потока L есть новый поток на вершине стека:
printf("%d\n", lua_gettop(L1)); --> 0
printf("%s\n", luaL_typename(L, -1)); --> thread

За исключением главноого, все потоки подвержены сборке мусора, как и любой другой объект Lua. Когда вы создаете новый поток, то значение, которое отправляется в стек, гарантирует, что эта поток не
является мусором. Вы никогда не должны использовать поток, который должным образом не привязан к состоянию. (Главный поток внутренне привязан с самого начала, поэтому о нем можно не беспокоиться.)


Функция вызвается в 2 потоках.

int main(int argc, char* argv[]) {
    const char* LUA = R"(
foo()

)";
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    lua_State* L1 = lua_newthread(L);
    lua_pushcfunction(L, foo);// отправить c функцию в стек.
    showstack(L); cout << "\n";

    lua_setglobal(L, "foo");// уст для переменной значение в виде функции.
    luaL_dostring(L, LUA);
    showstack(L1);  cout << "\n";// Стек потока L1 пуст.
    luaL_dostring(L1, LUA);
    cout << "\n adrees L  " << L << "\n adrees L1 " << L1 << "\n";
    lua_close(L);

    return 0;
};

Вариант 2

int main(int argc, char* argv[]) {
    const char* LUA = R"(
foo()

)";
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    lua_State* L1 = lua_newthread(L);
    lua_pushcfunction(L, foo);// отправить c функцию в стек.
    showstack(L); cout <<"\n";

    lua_setglobal(L, "foo");// уст для переменной значение в виде функции.
    luaL_dostring(L, LUA);
    lua_xmove(L, L1, 1);// Снимает с L1 элементов передает L.
    showstack(L1);  cout << "\n";
    luaL_dostring(L1, LUA);
    cout << "\n adrees L  "<<  L << "\n adrees L1 "<< L1 << "\n";
    lua_close(L);

    return 0;
};

Запуск 2 функций в 2 потоках.

const char* LUA = R"(
function foo()
for i = 1, 3 do
print(" func foo "..i.."\n")
end     end

function main()
for i = 1, 3 do
print(" func main "..i.."\n")
end  end
)";
int main(int argc, char* argv[]) {
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    lua_State* L1 = lua_newthread(L);
    checkerror(L, LUA);
    lua_getglobal(L, "main");
    lua_pcall(L, 0, 0, 0);// запустить функцию main в потоке L.

    lua_getglobal(L1, "foo");// запустить функцию foo в потоке L1.
    lua_pcall(L1, 0, 0, 0);

    lua_close(L);
    return 0;
};



Функции выполняются поочередно в двух потоках.

Для запуска выполнения сопрограммы мы используем lua_resume так же, как мы используем lua_pcall: мы заталкиваем функцию для вызова, заталкиваем ее аргументы и вызываем lua_resume,
 передавая в narg число аргументов. (Параметр from — это нить, которая совершает вызов.) Данное поведение также очень похоже на lua_pcall, но с тремя отличиями.

Во-первых, у lua_resume нет параметра для числа требуемых  результатов; она всегда возвращает все значения из вызванной функции.

Во-вторых, у нее нет параметра для обработчика сообщений; ошибка не раскручивает стек, поэтому после нее вы можете изучить стек.

 В-третьих, если выполняемая функция уступает управление, то lua_resume возвращает особый код LUA_YIELD и оставляет поток в состоянии, из которого она может быть возобновлена позже.

Когда lua_resume возвращает LUA_YIELD, видимая часть стека потока содержит только значения, переданные yield. Вызов lua_gettop вернет число выработанных значений. Для перемещения этих значений
В другой потоке мы можем использовать lua_xmove. Чтобы возобновить приостановленный поток, мы вновь вызываем lua_resume. При таких вызовах Lua считает, что все значения в стеке должны быть возвращены вызовом yield. Например, если вы не трогаете стек потока между возвращением из lua_resume и следующим возобновлением, то yield вернет именно те значения, которые он выработал при уступке управления. Обычно мы запускаем сопрограмму с функцией Lua в качестве ее тела. Эта функция Lua может вызывать другие функции, и любая из этих функций порой может уступать управление, завершая вызов lua_resume.


int my_yield(lua_State* L) {
    return lua_yield(L, 0);/*Эта функция должна вызываться только как возвращаемое выражение функции C следующим образом:
    return lua_yield(L, res); Когда функция C вызывает lua_yield таким образом, запущенная сопрограмма приостанавливает
    свое выполнение, и вызов lua_resume этой запущенной процедуры возвращается. Параметр res - это число значений из стека,
    которые передаются как результаты lua_resume.*/
};
const char* LUA = R"(
function foo()
print(" func foo \n")
end

function main()
for i = 1, 3 do
print(" func main "..i.."\n")
my_yield()
end  end
)";
int main(int argc, char* argv[]) {
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    lua_State* L1 = lua_newthread(L);
    cout << "\n";
    lua_register(L, "my_yield", my_yield);
    checkerror(L, LUA);
    lua_getglobal(L, "main");
    while (true) {
        int ret = lua_resume(L, L1, 0); /* Запускает и продолжает сопрограмму в данном потоке L.
    вы отправляйте в стек главную функцию и её аргументы; затем вызываете lua_resume,nargs - кол-во аргументов.
    Вызов возвращается, когда приостанавливается или завершается. При возвращении, стек содержит все значения,
    переданные в lua_yield, или возвращенныеции. Чтобы продолжить сопрограмму, вы удаляете все результаты
    из последнего lua_yield, отправьте в её стек только значения, передаваемые в качестве результатов из yield, и
    затем вызываете lua_resume.   Параметр L представляет сопрограмму, которая продолжает L. */
        if (ret == LUA_YIELD) {
            lua_getglobal(L1, "foo");
            lua_pcall(L1, 0, 0, 0);
        }
        else if (ret == 0) {

            break;
        }
    };

    lua_close(L);
    return 0;
};

1.

Функции выполняются поочередно в двух потоках с передачей значение в main.

int my_yield(lua_State* L) {
    return lua_yield(L, 0);/*Эта функция должна вызываться только как возвращаемое выражение функции C следующим образом:
    return lua_yield(L, res); Когда функция C вызывает lua_yield таким образом, запущенная сопрограмма приостанавливает
    свое выполнение, и вызов lua_resume этой запущенной процедуры возвращается. Параметр res - это число значений из стека,
    которые передаются как результаты lua_resume.*/
};

const char* LUA = R"(
function foo()
print(" func foo \n")
end

function main(n)
for i = 1, 3 do
print(" func main "..n.."\n")
my_yield()
end  end
)";
int main(int argc, char* argv[]) {
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    lua_State* L1 = lua_newthread(L);

    lua_register(L, "my_yield", my_yield);// регистрация функций.
    checkerror(L, LUA);
    lua_getglobal(L, "main");// получить функцию.
    lua_pushinteger(L, 10); // передаем в функцию main 10.
    while (true) {
        int ret = lua_resume(L, L1, 1); /* Запускает и продолжает сопрограмму в данном потоке L.
    вы отправляйте в стек главную функцию и её аргументы; затем вызываете lua_resume,nargs - кол-во аргументов.
    Вызов возвращается, когда приостанавливается или завершается. При возвращении, стек содержит все значения,
    переданные в lua_yield, или возвращенные. Чтобы продолжить сопрограмму, вы удаляете все результаты
    из последнего lua_yield, отправьте в её стек только значения, передаваемые в качестве результатов из yield, и
    затем вызываете lua_resume.   Параметр L представляет сопрограмму, которая продолжает L. */
        if (ret == LUA_YIELD) {
            lua_getglobal(L1, "foo");
            lua_pcall(L1, 0, 0, 0);
        }
        else if (ret == 0) {

            break;
        }
    };

    lua_close(L);
    return 0;
};

2.
Функции выполняются поочередно в двух потоках с передачей значение из main в foo.

const char* LUA = R"(
function foo(x)
x=x*10
print(" func foo "..x.."\n")
end

function main()
for i = 1, 3 do
print(" func main "..i.."\n")
my_yield(i)
end  end
)";
int main(int argc, char* argv[]) {
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    lua_State* L1 = lua_newthread(L);

    lua_register(L, "my_yield", my_yield);// регистрация функций.
    checkerror(L, LUA);
    lua_getglobal(L, "main");// получить функцию.
    while (true) {
        int ret = lua_resume(L, L1, 0);

        if (ret == LUA_YIELD) {
            lua_getglobal(L1, "foo");
            lua_xmove(L, L1, 1);/*перемещает значение Lua между двумя стеками в
            одном и том же состоянии.*/
            lua_pcall(L1, 1, 0, 0);
        }
        else if (ret == 0) {/*Когда функция lua_resume возвращается, стек содержит все значения,
        переданные в lua_yield, или все значения, возвращенные телом функции.*/
        //showstack(L);
            break;
        }
    };

    lua_close(L);
    return 0;
};

3.
int my_yield(lua_State* L) {

    lua_State* L1 = lua_newthread(L);
    lua_pushthread(L1);

    return lua_yield(L, 0);/*Эта функция должна вызываться только как возвращаемое выражение функции C следующим образом:
    return lua_yield(L, res); Когда функция C вызывает lua_yield таким образом, запущенная сопрограмма приостанавливает
    свое выполнение, и вызов lua_resume этой запущенной процедуры возвращается. Параметр res - это число значений из стека,
    которые передаются как результаты lua_resume.*/
};
const char* LUA = R"(
function foo()
print(" func foo \n")
end

function main()
for i = 1, 3 do
print(" func main "..i.."\n")
my_yield(foo)
end  end
)";
int main(int argc, char* argv[]) {
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    lua_register(L, "my_yield", my_yield);
    cout << "\n";
    checkerror(L, LUA);
    lua_getglobal(L, "main");
    while (true) {
        int ret = lua_resume(L, NULL, 0); /* Запускает и продолжает сопрограмму в данном потоке L. */
        if (ret == LUA_YIELD) {
            lua_State* L1 = lua_tothread(L, -1);

            lua_getglobal(L1, "foo");
            lua_pcall(L1, 0, 0, 0);
        }
        else if (ret == 0) {

            break;
        }
    };

    lua_close(L);
    return 0;
};



Функции выполняются поочередно в двух потоках с передачей значение в main из main в foo.

const char* LUA = R"(
function foo(x)
x=x*10
print(" func foo "..x.."\n")
end

function main(n)
for i = 1, 3 do
print(" func main "..n.."\n")
my_yield(i)
end  end
)";
int main(int argc, char* argv[]) {
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    lua_State* L1 = lua_newthread(L);

    lua_register(L, "my_yield", my_yield);// регистрация функций.
    checkerror(L, LUA);
    lua_getglobal(L, "main");// получить функцию.
    lua_pushinteger(L, 10); // передаем в функцию main 10.

    while (true) {
        int ret = lua_resume(L, L1, 1); /* Запускает и продолжает сопрограмму в данном потоке L.
    вы отправляйте в стек главную функцию и её аргументы; затем вызываете lua_resume,nargs - кол-во аргументов.
    Вызов возвращается, когда приостанавливается или завершается. При возвращении, стек содержит все значения,
    переданные в lua_yield, или возвращенные. Чтобы продолжить сопрограмму, вы удаляете все результаты
    из последнего lua_yield, отправьте в её стек только значения, передаваемые в качестве результатов из yield, и
    затем вызываете lua_resume.   Параметр L представляет сопрограмму, которая продолжает L. */

        if (ret == LUA_YIELD) {
            lua_getglobal(L1, "foo");
            lua_xmove(L, L1, 1);/*перемещает значение Lua между двумя стеками в
            одном и том же состоянии.*/
            lua_pcall(L1, 1, 0, 0);
        }
        else if (ret == 0) {/*Когда функция lua_resume возвращается, стек содержит все значения,
        переданные в lua_yield, или все значения, возвращенные телом функции.*/
        //showstack(L);
            break;
        }
    };

    lua_close(L);
    return 0;
};

Функции выполняются поочередно в двух потоках. Вернуть значений из lua_yield.

int my_yield(lua_State* L) {
    return lua_yield(L, 1);/*Эта функция должна вызываться только как возвращаемое выражение функции C следующим образом:
    return lua_yield(L, res); Когда функция C вызывает lua_yieldтаким образом, запущенная сопрограмма приостанавливает
    свое выполнение, и вызов lua_resume этой запущенной процедуры возвращается. Параметр res - это число значений из стека,
    которые передаются как результаты lua_resume.*/
};

const char* LUA = R"(
function foo()
x=10
print(" func foo "..x.."\n")
end

function main()
for i = 1, 3 do
print(" func main "..i.."\n")
my_yield(i)
end  end
)";
int main(int argc, char* argv[]) {
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    lua_State* L1 = lua_newthread(L);

    lua_register(L, "my_yield", my_yield);// регистрация функций.
    checkerror(L, LUA);
    lua_getglobal(L, "main");// получить функцию.
    while (true) {
        int ret = lua_resume(L, L1, 0);

        if (ret == LUA_YIELD) {
            lua_xmove(L, L1, 1);// отравить значение из yield потока L в стек L1.
            lua_getglobal(L1, "foo");
            lua_pcall(L1, 0, 0, 0);
        }
        else if (ret == 0) {/*Когда функция lua_resume возвращается, стек содержит все значения,
        переданные в lua_yield, или все значения, возвращенные телом функции.*/

            break;
        }
    };

showstack(L1);

    lua_close(L);
    return 0;
};


Функции выполняются поочередно в двух потоках с передачей значение в main из main в foo. Вернуть значений из lua_yield.

int my_yield(lua_State* L) {
    return lua_yield(L, 0);/*Эта функция должна вызываться только как возвращаемое выражение функции C следующим образом:
    return lua_yield(L, res); Когда функция C вызывает lua_yield таким образом, запущенная сопрограмма приостанавливает
    свое выполнение, и вызов lua_resume этой запущенной процедуры возвращается. Параметр res - это число значений из стека,
    которые передаются как результаты lua_resume.*/
};

const char* LUA = R"(
function foo(x1)
x= x1 * 10
print(" func foo "..x.."\n")
return x
end

function main(n)
for i = 1, 3 do
print(" func main "..n.."\n")
my_yield(i)
end  end
)";
int main(int argc, char* argv[]) {
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    lua_State* L1 = lua_newthread(L);

    lua_register(L, "my_yield", my_yield);// регистрация функций.
    checkerror(L, LUA);
    lua_getglobal(L, "main");// получить функцию.
    lua_pushinteger(L, 10);
    while (true) {
        int ret = lua_resume(L, L1, 1); /* Запускает и продолжает сопрограмму в данном потоке L.
    вы отправляйте в стек главную функцию и её аргументы; затем вызываете lua_resume,nargs - кол-во аргументов.
    Вызов возвращается, когда приостанавливается или завершается. При возвращении, стек содержит все значения,
    переданные в lua_yield, или возвращенныеции. Чтобы продолжить сопрограмму, вы удаляете все результаты
    из последнего lua_yield, отправьте в её стек только значения, передаваемые в качестве результатов из yield, и
    затем вызываете lua_resume.   Параметр L представляет сопрограмму, которая продолжает L. */

        if (ret == LUA_YIELD) {
            cout << "\n res from func my_yield "<< lua_tointeger(L, -1) << "\n\n";/*Когда lua_resume возвращает LUA_YIELD,
             стек потока содержит значения, переданные yield. число выработанных значений.*/
            lua_getglobal(L1, "foo");
            lua_xmove(L, L1, 1);/*перемещает значение Lua между двумя стеками в
            одном и том же состоянии.*/
            lua_pcall(L1, 1, 0, 0);

        }
        else if (ret == 0) {/*Когда функция lua_resume возвращается, стек содержит все значения,
        переданные в lua_yield, или все значения, возвращенные телом функции.*/
            break;
        }
    };

    lua_close(L);
    return 0;
};

Вариант 2.

int my_yield(lua_State* L) {
    return lua_yield(L, 0);/*Эта функция должна вызываться только как возвращаемое выражение функции C следующим образом:
    return lua_yield(L, res); Когда функция C вызывает lua_yieldтаким образом, запущенная сопрограмма приостанавливает
    свое выполнение, и вызов lua_resume этой запущенной процедуры возвращается. Параметр res - это число значений из стека,
    которые передаются как результаты lua_resume.*/
};

const char* LUA = R"(
function foo(x1)
x= x1 * 10
print(" func foo "..x.."\n")
return x
end

function main(n)
for i = 1, 3 do
print(" func main "..n.."\n")
my_yield(i)
end  end
)";
int main(int argc, char* argv[]) {
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    lua_State* L1 = lua_newthread(L);

    lua_register(L, "my_yield", my_yield);// регистрация функций.
    checkerror(L, LUA);
    lua_getglobal(L, "main");// получить функцию.
    lua_pushinteger(L, 10);
    while (true) {
        int ret = lua_resume(L, L1, 1); /* Запускает и продолжает сопрограмму в данном потоке L.
    вы отправляйте в стек главную функцию и её аргументы; затем вызываете lua_resume,nargs - кол-во аргументов.
    Вызов возвращается, когда приостанавливается или завершается. При возвращении, стек содержит все значения,
    переданные в lua_yield, или возвращенныеции. Чтобы продолжить сопрограмму, вы удаляете все результаты
    из последнего lua_yield, отправьте в её стек только значения, передаваемые в качестве результатов из yield, и
    затем вызываете lua_resume.   Параметр L представляет сопрограмму, которая продолжает L. */

        if (ret == LUA_YIELD) {
            cout << "\n res from func my_yield " << lua_tointeger(L, -1) << "\n\n";/*Когда lua_resume возвращает LUA_YIELD,
             стек потока содержит значения, переданные yield. число выработанных значений.*/
            lua_xmove(L, L1, 1);/*перемещает значение Lua между двумя стеками в
            одном и том же состоянии.*/
            lua_pop(L, 1);
            lua_getglobal(L1, "foo");
            lua_xmove(L, L1, 1);/*перемещает значение Lua между двумя стеками в
            одном и том же состоянии.*/
            lua_pcall(L1, 1, 0, 0);
        }
        else if (ret == 0) {/*Когда функция lua_resume возвращается, стек содержит все значения,
        переданные в lua_yield, или все значения, возвращенные телом функции.*/
            break;
        }

    };
   showstack(L1);
    lua_close(L);
    return 0;
};


Функции main и foo с циклом for, выполняются поочередно в двух потоках.

int my_yield2(lua_State* L) {
    return lua_yield(L, 0);/*Эта функция должна вызываться только как возвращаемое выражение функции C следующим образом:
    return lua_yield(L, res); Когда функция C вызывает lua_yieldтаким образом, запущенная сопрограмма приостанавливает
    свое выполнение, и вызов lua_resume этой запущенной процедуры возвращается. Параметр res - это число значений из стека,
    которые передаются как результаты lua_resume.*/
};


int my_yield(lua_State* L) {
    return lua_yield(L, 0);/*Эта функция должна вызываться только как возвращаемое выражение функции C следующим образом:
    return lua_yield(L, res); Когда функция C вызывает lua_yieldтаким образом, запущенная сопрограмма приостанавливает
    свое выполнение, и вызов lua_resume этой запущенной процедуры возвращается. Параметр res - это число значений из стека,
    которые передаются как результаты lua_resume.*/
};

const char* LUA = R"(
function foo()
for i = 1, 3 do
print(" func foo "..i.."\n")
my_yield2(i)
end
end

function main()
for i = 1, 3 do
print(" func main "..i.."\n")
my_yield(i)
end  end
)";
int main(int argc, char* argv[]) {
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    lua_State* L1 = lua_newthread(L);

    lua_register(L, "my_yield", my_yield);// регистрация функций.
    lua_register(L, "my_yield2", my_yield2);// регистрация функций.
    checkerror(L, LUA);
    lua_getglobal(L, "main");// получить функцию.

    while (true) {
        int ret = lua_resume(L, L1, 0); /* Запускает и продолжает сопрограмму в данном потоке L.
                                        Параметр L представляет сопрограмму, которая продолжает L. */
        if (ret == LUA_YIELD) {
            lua_getglobal(L1, "foo");
            lua_resume(L1, L, 0);
        }
        else if (ret == 0) {/*Когда функция lua_resume возвращается, стек содержит все значения,
        переданные в lua_yield, или все значения, возвращенные телом функции.*/
            break;
        }

    };
    lua_close(L);
    return 0;
};


Функции main и foo с циклом for, выполняются поочередно в двух потоках с поочередным приостановлением.

int my_yield(lua_State* L) {
    return lua_yield(L, 0);/*Эта функция должна вызываться только как возвращаемое выражение функции C следующим образом:
    return lua_yield(L, res); Когда функция C вызывает lua_yield таким образом, запущенная сопрограмма приостанавливает
    свое выполнение, и вызов lua_resume этой запущенной процедуры возвращается. Параметр res - это число значений из стека,
    которые передаются как результаты lua_resume.*/
};

const char* LUA = R"(
function main()
for i = 1, 3 do
print(" func main "..i.."\n")
my_yield()
end  end
function foo()
for i = 1, 3 do
print(" func foo "..i.."\n")
my_yield()
end end

)";
int main(int argc, char* argv[]) {
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    lua_State* L1 = lua_newthread(L);

    lua_register(L, "my_yield", my_yield);// регистрация функций.
    checkerror(L, LUA);
    lua_getglobal(L, "main");// получить функцию.
    int ret, ret1;
    while (true) {
         ret = lua_resume(L, NULL, 0); /* Запускает и продолжает сопрограмму в данном потоке L. */
        if (ret == LUA_YIELD) {
            lua_getglobal(L1, "foo");
            ret1 = lua_resume(L1, NULL, 0);
        }
        else if ((ret == LUA_OK) || (ret1 = LUA_OK)) {break;    }
    };

    lua_close(L);
    return 0;
};

Вариант 2.

int my_yield(lua_State* L) {
    int args = lua_gettop(L);args++;
    lua_State* L1 = lua_newthread(L);
    lua_pushthread(L1);
    return lua_yield(L, args);/* Когда функция C вызывает lua_yield таким образом, запущенная сопрограмма приостанавливает
    свое выполнение, и вызов lua_resume этой запущенной процедуры возвращается.*/
};
int yield(lua_State* L) {return lua_yield(L, 0);/*  Параметр res - это число значений из стека,
    которые передаются как результаты lua_resume.*/
};
const char* LUA = R"(
function foo(x)    x = x or 3
print(" func foo "..x.. " \n")
for i = 1, x do
print(" func foo "..i.."\n")
yield()
end
end

function main()
for i = 1, 3 do
print(" func main "..i.."\n")
if i ==1
then my_yield(foo,9)
else yield()
end
end  end
)";

int main(int argc, char* argv[]) {
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L); lua_State* L1 = NULL;
    lua_register(L, "my_yield", my_yield);
    lua_register(L, "yield",  yield);
    cout << "\n";int ret, ret1;
    checkerror(L, LUA);

    lua_getglobal(L, "main");
    ret = lua_resume(L, NULL, 0); /* Запускает и продолжает сопрограмму в данном потоке L. */
    L1 = lua_tothread(L, -1);lua_pop(L, 1); lua_xmove(L, L1, lua_gettop(L)); lua_remove(L1, 1); int args = lua_gettop(L1);
        for (int i = 1; i > args; i++) {lua_pushvalue(L1, i);}
        args--; ret1 = lua_resume(L1, L, args); lua_xmove(L, L1, 1);

    while (ret =! LUA_OK) {
        ret = lua_resume(L, L1, 0); // main
    if (ret == 0) {     break;  }
    else{
        ret1 = lua_resume(L1, L, 0);// foo
    }
    };

    lua_close(L);
    return 0;
};



Многопоточнось через функцию my_yield.

int my_yield(lua_State* L) {
    return lua_yield(L, 0);/*Эта функция должна вызываться только как возвращаемое
   выражение функции C следующим образом: return lua_yield(L, res); */
};

const char* LUA = R"(
function foo()
print(" func foo \n")
end

function main()
for i = 1, 3 do
print(" func main "..i.."\n")
my_yield()
end  end
)";
int main(int argc, char* argv[]) {
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);

    lua_register(L, "my_yield", my_yield);// регистрация функций.
    lua_State* L1 = lua_newthread(L);
    checkerror(L, LUA);
    lua_getglobal(L, "main");// получить функцию.
    while (true) {
        int ret = lua_resume(L, L1, 0); /* Запускает и продолжает сопрограмму в данном потоке L. */
        if (ret == LUA_YIELD) {
            lua_getglobal(L1, "foo");
            lua_pcall(L1, 0, 0, 0);
        }
        else if (ret == 0) {
            break;
        }
    };

    lua_close(L);
    return 0;
};


Многопоточность через строку кода.

void LUAHook(lua_State* L, lua_Debug* ar) {
    if (ar->currentline == 7) {
        lua_yield(L, 0);
    }
};
const char* LUA = R"(
function foo()
print(" func foo \n")
end

function main()
for i = 1, 3 do
print(" func main "..i.."\n")

end  end
)";
int main() {
    lua_State* L = luaL_newstate(); luaL_openlibs(L);
    checkerror(L, LUA);
    lua_State* L1 = lua_newthread(L);
    lua_sethook(L1, LUAHook, LUA_MASKLINE, 25); // Добавить подсчет счетчика, который сработает после указания числа
    int ret;
    lua_getglobal(L1, "main");// функция lua возобновляется с последней прерванной позиции.
    while (true) {

        ret = lua_resume(L1, L, 0);
        if (ret == LUA_YIELD) {
            lua_getglobal(L, "foo");
            lua_pcall(L, 0, 0, 0);
        }
        if (ret == 0) { break; }
    }
    return 0;
};


Многопоточность через таймер.

void LUAHook(lua_State* L, lua_Debug* ar) {
    lua_yield(L, 0);
};

const char* LUA = R"(
function foo()
print(" func foo \n")
end

function main()
for i = 1, 3 do
print(" func main "..i.."\n")
end  end
)";
int main() {
    lua_State* L = luaL_newstate(); luaL_openlibs(L);
    lua_sethook(L, LUAHook, LUA_MASKCOUNT, 6);  // Добавить подсчет счетчика, который сработает после указания числа
    checkerror(L, LUA);
    lua_State* L1 = lua_newthread(L);
    int ret;
    lua_getglobal(L, "main");// функция lua возобновляется с последней прерванной позиции.

    while (true) {
        if (ret = !0) {
            ret = lua_resume(L, L1, 0);
        };

        if (ret == LUA_YIELD ) {
            lua_getglobal(L1, "foo");
            lua_pcall(L1, 0, 0, 0);
        }
        if (ret == 0) {// Успешно завершение функции.
            break;
        }
    };

    return 0;
};


Многопоточность через событие строки.

void LUAHook(lua_State* L, lua_Debug* ar) {
    lua_yield(L, 0);};
const char* LUA = R"(
function foo()
print(" func foo \n")
end

function main()
for i = 1, 3 do
print(" func main "..i.."\n")

end  end
)";
int main() {
    lua_State* L = luaL_newstate(); luaL_openlibs(L);
    checkerror(L, LUA);
    lua_State* L1 = lua_newthread(L);
    lua_sethook(L1, LUAHook, LUA_MASKLINE, 1);  // Добавить подсчет счетчика, который сработает после указания числа
    int ret;
    lua_getglobal(L1, "main");// функция lua возобновляется с последней прерванной позиции.
    while (true) {

        ret = lua_resume(L1, L, 0);
        if (ret == LUA_YIELD) {
            lua_getglobal(L, "foo");
            lua_pcall(L, 0, 0, 0);
        }
        if (ret == 0) { break; }
    }
    return 0;
};

Многопоточность через отладчик событий.

void LUAHook(lua_State* L, lua_Debug* ar) {
    lua_getglobal(L, "main");  /* функция для ловушки дебага */

    lua_getinfo(L, ">L", ar);// таблица номеров строк с возможностю остановки.
    static vector<int>v;
    if (LUA_TTABLE == lua_type(L, -1)) {
        lua_pushvalue(L, -1);
        lua_pushnil(L);
        while (lua_next(L, -2)) {
            lua_pushvalue(L, -2);
            v.push_back((lua_tointeger(L, -1))); lua_pop(L, 2);
        }
        lua_pop(L, 1);
    };
    for (auto& i : v) {
        if (i == ar->currentline){// текущую строку можно приостановить.
    //  cout << i << endl;
            lua_yield(L, 0);
        }
    }
    v.clear();
};

const char* LUA = R"(
function main()
for i = 1, 3 do
print(" func main "..i.."\n")
end
end
function foo()
for i = 1, 3 do
print(" func foo "..i.."\n")
end end
)";
int main() {
    lua_State* L = luaL_newstate(); luaL_openlibs(L);
    checkerror(L, LUA);
    lua_State* L1 = lua_newthread(L);
    lua_sethook(L, LUAHook, LUA_MASKLINE, 1);   // Добавить подсчет счетчика, который сработает после указания числа
    int ret;
    lua_getglobal(L, "main");// функция lua возобновляется с последней прерванной позиции.
    while (true) {

        ret = lua_resume(L, NULL, 0);
        if (ret == LUA_YIELD) {
            lua_getglobal(L1, "foo");
            lua_pcall(L1, 0, 0, 0);
        }
    if (ret == 0) { break; }
    }
//      cout << ret << endl;
    return 0;
};

2.
static int step = 0;
void LUAHook(lua_State* L, lua_Debug* ar) {

    //cout << ar->lastlinedefined << endl;
    lua_getglobal(L, "main");  /* функция для ловушки дебага */

    lua_getinfo(L, ">L", ar);// таблица номеров строк с возможностю остановки.

    static vector<int>v;
    if (LUA_TTABLE == lua_type(L, -1)) {
        lua_pushvalue(L, -1);
        lua_pushnil(L);
        while (lua_next(L, -2)) {
            lua_pushvalue(L, -2);
            v.push_back((lua_tointeger(L, -1))); lua_pop(L, 2);
        }       lua_pop(L, 1);
    };
    for (auto& i : v) {
        if (i == ar->currentline) {// текущую строку можно приостановить.
            step++;
            if (step > 2 && (i != 2) && (i != 5)) {
            lua_yield(L, 0);//  cout << i << endl;
            }
        }
    }
//  cin.get();
    v.clear();
};

const char* LUA = R"(
function main()
for i = 1, 3 do
print(" func main "..i.."\n")
end
end
function foo()
for i = 1, 2 do
print(" func foo "..i.."\n")
end end
)";
int main() {
    lua_State* L = luaL_newstate(); luaL_openlibs(L);
    checkerror(L, LUA);
    lua_State* L1 = lua_newthread(L);
    lua_sethook(L, LUAHook, LUA_MASKLINE, 1);   // Добавить подсчет счетчика, который сработает после указания числа
    int ret;
    lua_getglobal(L, "main");// функция lua возобновляется с последней прерванной позиции.
    while (true) {

        ret = lua_resume(L, NULL, 0);
        if (ret == LUA_YIELD) {
            lua_getglobal(L1, "foo");
            lua_pcall(L1, 0, 0, 0);
        }
        if (ret == LUA_OK) { break; }
    }
    //      cout << ret << endl;
    return 0;
};

С помощью функции hook.

const char* LUA = R"(
function foo()
for i = 1, 3 do
print(" func foo "..i.."\n")
end  end

function main()
for i = 1, 5 do
print(" func main "..i.."\n")
end  end
)";
void m(lua_State* L, const char* func1, const char* func2) {
    lua_State* L1 = lua_newthread(L);
    lua_sethook(L, LUAHook, LUA_MASKCOUNT, 6);  // Добавить подсчет счетчика, который сработает после указания числа
    lua_sethook(L1, LUAHook, LUA_MASKCOUNT, 5); // Добавить подсчет счетчика, который сработает после указания числа
    int ret;
    lua_getglobal(L, func1);// функция lua возобновляется с последней прерванной позиции.
    lua_resume(L, L1, 0);

    while (true) {
        if (ret = !0) {
            ret = lua_resume(L, L1, 0);
        };

        if (ret == LUA_YIELD ) {
            lua_getglobal(L1, func2);
            ret = lua_resume(L1, L, 0);
        }
        if (ret == 0) {// Успешно завершение функции.
            break;
        }
    };

};
int main() {
    lua_State* L = luaL_newstate(); luaL_openlibs(L);
    checkerror(L, LUA);
    m(L,"main", "foo");
    return 0;
};

Вариант 2.

static int star1 = 0;
bool timer1(int t) {
    double timer = t * 0.001;
    timer -= 0.5;// Погрешность
    static  time_t start_time;
    if (star1 == 0) {
        star1++; start_time = time(NULL);
        return false;
    }
    else {
        if (time(NULL) <= start_time + timer) { return false; }

        else { star1 = 0;   return true; }
    }
};
static int star2 = 0;
bool timer2(int t) {
    double timer = t * 0.001;
    timer -= 0.5;// Погрешность
    static  time_t start_time;
    if (star2 == 0) {
        star2++; start_time = time(NULL);
        return false;
    }
    else {
        if (time(NULL) <= start_time + timer) { return false; }

        else { star2 = 0;   return true; }
    }
};
void LUAHook(lua_State* L, lua_Debug* ar) {
    if (timer1(3000)) {//На столько остановить первый поток.
        cout << "main stop " << endl;
        lua_yield(L, 0);
    }
};
void LUAHook1(lua_State* L, lua_Debug* ar) {
    if (timer2(2000)) {//На столько остановить второй поток.
        cout << "foo stop " << endl;
       lua_yield(L, 0);
    }
};

const char* LUA = R"(
function foo()
for i = 1, 6000 do
print(" func foo "..i.."\n")
end  end

function main()
i ="koi"
while true do
--for i = 1, 80000000000000000000000 do
--print(" func main "..i.."\n")
end  end
)";
void m(lua_State* L, const char* func1, const char* func2) {
    lua_State* L1 = lua_newthread(L);
    lua_sethook(L, LUAHook, LUA_MASKCOUNT, 1);  // Добавить подсчет счетчика, который сработает после указания числа
    lua_sethook(L1, LUAHook1, LUA_MASKCOUNT, 1);    // Добавить подсчет счетчика, который сработает после указания числа
    int ret,ret1;
    lua_getglobal(L, func1);// функция lua возобновляется с последней прерванной позиции.
    ret= lua_resume(L, L1, 0);

    while (true) {
        if (ret == LUA_YIELD) {
            lua_getglobal(L1, func2);
            ret1 = lua_resume(L1, L, 0);}
            if (ret == LUA_OK) {// Успешно завершение функции.
            cout << "end " << endl;
            break;
        }
        if (ret1 = LUA_YIELD) {
            ret = lua_resume(L, L1, 0);
        }
    };
};


static map<lua_State*, lua_State*> l;
int main() {
    lua_State* L = luaL_newstate(); luaL_openlibs(L);
    checkerror(L, LUA);
    m(L, "main", "foo");
    lua_close(L);
    return 0;
};


Вариант 3.

int hookFunc(lua_State* L, lua_Debug* ar) {
    return lua_yield(L, 0);
};

int hookFunc1(lua_State* L, lua_Debug* ar) {
    return lua_yield(L, 0);
};

const char* LUA = R"(
function foo()
for i = 1, 300 do
print(" func foo "..i.."\n")
end
end

function main()
for i = 1, 300 do
print(" func main "..i.."\n")
end  end
)";
int main() {
    lua_State* L = luaL_newstate(); luaL_openlibs(L);
    checkerror(L, LUA);
    lua_State* L1 = lua_newthread(L);
    int time = 80;
    int time1 = 16;
    lua_sethook(L, (lua_Hook)hookFunc, LUA_MASKCOUNT, time);    // Добавить подсчет счетчика, который сработает после указания числа
    lua_getglobal(L, "main");// функция lua возобновляется с последней прерванной позиции.
    lua_resume(L, L1, 0);
        while (LUA_OK != lua_status(L)) {   // пока поток main не завершен.

            if (LUA_YIELD == lua_status(L1)) {// если поток 2 на паузе.
                lua_sethook(L1, (lua_Hook)hookFunc1, LUA_MASKCOUNT, 0);// отключить хук foo.
                cout << " pause foo" << endl;
                lua_sethook(L, (lua_Hook)hookFunc, LUA_MASKCOUNT, time);//включить хук для потока main.
                lua_getglobal(L, "main");
                lua_resume(L, L1, 0);
                lua_sethook(L1, (lua_Hook)hookFunc1, LUA_MASKCOUNT, 0);// отключить хук foo.
            }// main

            if (LUA_YIELD == lua_status(L)) {// если поток main на паузе.
                lua_sethook(L, (lua_Hook)hookFunc, LUA_MASKCOUNT, 0);// отключить хук main.
                lua_sethook(L1, (lua_Hook)hookFunc1, LUA_MASKCOUNT, time1);// включить хук foo.
                cout << " pause main" << endl;
                lua_getglobal(L1, "foo");
                lua_resume(L1, L, 0);// foo
                lua_sethook(L1, (lua_Hook)hookFunc1, LUA_MASKCOUNT, 0);// отключить хук foo.
            }

            if (LUA_OK == lua_status(L1)) {// если поток foo завершен.
                cout << "foo end " << endl;
                lua_sethook(L, (lua_Hook)hookFunc, LUA_MASKCOUNT, 0);// отключить хук main.
                lua_sethook(L1, (lua_Hook)hookFunc1, LUA_MASKCOUNT, 0);// отключить хук foo.
                lua_resume(L, NULL, 0);
            }
            if (LUA_OK == lua_status(L)) { break; }// если поток main  завершен.

        };

    return 0;
};

С помощью класса.


struct ScriptRunner_impl {
    lua_State* L = nullptr;
};
class ScriptRunner
{
public:
    ScriptRunner(lua_State* L, const char* funcrun, unsigned int Count) : m_L(L), m_funcrun(funcrun),
        m_Count(Count), m_pScriptRunner_impl(make_unique<ScriptRunner_impl>()) {
        m_pScriptRunner_impl->L = L;    // Add a count hook that will trigger after "count" number instructions
        lua_sethook(m_pScriptRunner_impl->L, LUAHook, LUA_MASKCOUNT, m_Count);
    }

    void Update(float dt);
    ~ScriptRunner(){}
private:
    lua_State*        m_L;
    const char*       m_funcrun;
    unsigned int      m_Count;
    unique_ptr<ScriptRunner_impl> m_pScriptRunner_impl = nullptr;
};

int func_block(lua_State* L, const char* functionName) {
    int errorState = lua_getglobal(L, functionName);    // lua function is resumed from the last interrupted position.
    errorState = lua_resume(L, L, 0);
    if (errorState == LUA_YIELD) {  // lua function execution is interrupted.
        return 1;
    }
    else if (errorState == LUA_OK) {// lua function is returned successfully.
        return 0;
    }
};
void ScriptRunner::Update(float dt) {
    // Update a lua function with preemptive scheduling.
    int status = func_block(m_pScriptRunner_impl->L, m_funcrun);
    if (status == 0) {  // lua function executed successfully.
        return; }// Run the non script loop
};


const char* LUA = R"(
function main()
i = 0;
while i < 800 do
  i = i + 1;
  print("lua script in control, stack variable count = ", i)
  end
end
)";
int main(int argc, char* argv[]) {
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    int ret = luaL_dostring(L, LUA);
    ScriptRunner scriptRunner(L, "main", 100);
    scriptRunner.Update(1);
    cout << " 2 loop " << endl;
    scriptRunner.Update(1);
    cout << " 3 loop " << endl;
    scriptRunner.Update(1);
    return 0;
};

Вариант 2.


int yield(lua_State* L) {

    return lua_yield(L, 0);/*  Параметр res - это число значений из стека,
    которые передаются как результаты lua_resume.*/
};
void LUAHook(lua_State* L, lua_Debug* ar) {
    lua_yield(L, 0);
};

struct ScriptRunner_impl {
    lua_State* L = nullptr;
};
class ScriptRunner{
public:
    ScriptRunner(lua_State* L, const char* funcrun, unsigned int Count) : m_L(L), m_funcrun(funcrun),
        m_Count(Count), m_pScriptRunner_impl(make_unique<ScriptRunner_impl>()) {
        m_pScriptRunner_impl->L = L;    // Add a count hook that will trigger after "count" number instructions
        lua_sethook(m_pScriptRunner_impl->L, LUAHook, LUA_MASKCOUNT, m_Count);
    }

    void Update(float dt);
    ~ScriptRunner() {}
private:
    lua_State* m_L;
    const char* m_funcrun;
    unsigned int m_Count;
    unique_ptr<ScriptRunner_impl> m_pScriptRunner_impl = nullptr;
};

int func_block(lua_State* L, const char* functionName) {
    int errorState = lua_getglobal(L, functionName);    // lua function is resumed from the last interrupted position.
    errorState = lua_resume(L, L, 0);
    if (errorState == LUA_YIELD) {  // lua function execution is interrupted.
        return 1;
    }
    else if (errorState == LUA_OK) {// lua function is returned successfully.
        return 0;
    }
};
void ScriptRunner::Update(float dt) {
    // Update a lua function with preemptive scheduling.
    int status = func_block(m_pScriptRunner_impl->L, m_funcrun);
    if (status == 0) {  // lua function executed successfully.
        return;
    }// Run the non script loop
};


int my_yield(lua_State* L) {
    int args = lua_gettop(L);args++;
    lua_State* L1 = lua_newthread(L);
    lua_pushthread(L1);
    return lua_yield(L, args);/* Когда функция C вызывает lua_yield таким образом, запущенная сопрограмма приостанавливает
    свое выполнение, и вызов lua_resume этой запущенной процедуры возвращается.*/
};
const char* LUA = R"(
function foo(x)    x = x or 3
print(" func foo "..x.. " \n")
for i = 1, x do
print(" func foo "..i.."\n")
yield()
end
end

function main()
for i = 1, 1200 do
print(" func main "..i.."\n")
if i ==3
then my_yield(foo,3150)
end
end  end
)";
int main(int argc, char* argv[]) {
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L); lua_State* L1 = NULL;
    lua_register(L, "my_yield", my_yield);
    lua_register(L, "yield",  yield);
    cout << "\n"; checkerror(L, LUA);
    lua_getglobal(L, "main");
    lua_resume(L, NULL, 0); /* Запускает и продолжает сопрограмму в данном потоке L. */
    L1 = lua_tothread(L, -1); lua_pop(L, 1); lua_xmove(L, L1, lua_gettop(L));lua_remove(L1, 1);
    int args = lua_gettop(L1);//    cout << args << endl;// Аргументы.

        for (int i = 1; i > args; i++) {lua_pushvalue(L1, i);}
        args--;  lua_resume(L1, L, args);   lua_xmove(L, L1, 1);
  while ( LUA_OK != lua_status(L)) {    // пока поток main не завершен.

      if (LUA_YIELD == lua_status(L1)) {// если поток 2 на паузе.
          cout << " pause foo" << endl;

          ScriptRunner scriptRunner(L, "main", 10);
          scriptRunner.Update(1);
          lua_sethook(L, LUAHook, LUA_MASKCOUNT, 0);// отключить хук main.
        //  cin.get();
      };// main

       if (LUA_YIELD == lua_status(L) && LUA_OK != lua_status(L1)){// если поток main на паузе.
           lua_sethook(L, LUAHook, LUA_MASKCOUNT, 0);// отключить хук main.
         cout << " pause main" << endl;
         lua_resume(L1, NULL, 0);// foo

        }

    if (LUA_OK == lua_status(L1)) {// если поток foo  завершен.
        lua_sethook(L, LUAHook, LUA_MASKCOUNT, 0);// отключить хук main.
    //  cout << "foo end " << endl;
        lua_resume(L, NULL, 0); cout << lua_status(L) << endl; //break;

    }
    if (LUA_OK == lua_status(L)) { break; }// если поток main  завершен.
};
    lua_close(L);
    return 0;
};

Функция продолжения.

Вариант 1.



int hookFunc(lua_State* L, lua_Debug* ar) {
    return lua_yield(L, 0);
};

int hookFunc1(lua_State* L, lua_Debug* ar) {
    return lua_yield(L, 0);
};

/*Внутри себя, Lua использует возможность C - ишного longjmp для выхода(приостановки выполнения) из сопрограммы.
Поэтому, если C - ишная функция foo вызывает функцию API и эта функция API приостанавливает выполнение(непосредственно
сама или косвенно вызывая другую функцию, которая делает выход), Lua не может ничего больше возвратить в foo,
потому что longjmp удалил его фрейм из C - ишного стека. Во избежание проблем такого рода, Lua выдает ошибку всякий раз
при попытке выхода через вызов API, за исключением трех функций : lua_yieldk, lua_callk, и lua_pcallk.
Все эти функции принимают функцию - продолжение(в качестве параметра с именем k) чтобы продолжить выполнение после выхода.
Чтобы объяснить продолжения, следует установить некоторую терминологию. У нас есть функция C вызываемая из Lua,
которую мы будем называть исходной функцией. Эта исходная функция затем вызывает одну из этих трех функций в С - ишном API,
которая будет называться вызываемой функцией, которая затем приостанавливает выполнение текущего потока.
(Это может произойти, когда вызываемой функцией является lua_yieldk, или, когда вызываемая функция - либо lua_callk,
либо lua_pcallk, а функция, вызванная ими, приостанавливает выполнение.)

Предположим, что работающий поток приостанавливается на время выполнения вызываемой функции. После возобновления
работы потока, она, в конечном счете, завершит работу вызываемой функции. Однако, вызываемая функция не может
возвратиться к исходной функции, так как её фрейм в С - ишном стеке был разрушен приостановкой выполнения потока.
Вместо этого, Lua вызывает функцию продолжения(continuation function), которая будет задана в качестве аргумента
вызываемой функции. Как следует из названия, функция продолжения должна продолжить задачу исходной функции.

В качестве иллюстрации, рассмотрим следующую функцию :
int original_function(lua_State* L) { code 1
        status = lua_pcall(L, n, m, h);   calls Lua
 code 2 }
Теперь нужно позволить коду Lua запустить lua_pcall для приостановки. Во - первых, можно переписать нашу функцию вот так :
int k(lua_State* L, int status, lua_KContext ctx) {
     code 2
}
int original_function(lua_State* L) {
    ...   code 1
    return k(L, lua_pcall(L, n, m, h), ctx);
}
В приведенном выше коде, новая функция k является функцией продолжения(с типом lua_KFunction), которая должна выполнять
всю работу, что делала исходная функция после вызова lua_pcall.Теперь нужно сообщить Lua, что он должен вызывать k,
если код Lua выполняемый lua_pcall прерывается каким - то образом(ошибки или выход), так что можно переписать код
следующим образом, заменив lua_pcall на lua_pcallk :
int original_function(lua_State* L) {
     code 1
     return k(L, lua_pcallk(L, n, m, h, ctx2, k), ctx1);
}
Обратите внимание на внешний, явный вызов продолжения : Lua вызовет продолжение только при необходимости, то есть,
в случае ошибок или возобновления после выхода из выполнения.Если вызванная функция возвращается как обычно без
приостановки выполнения когда - либо, lua_pcallk(и lua_callk) также будет возвращаться нормально.
(Конечно, в данном случае вместо вызова продолжения можно сделать аналогичную работу непосредственно внутри исходной функции.)

Помимо Lua состояния, функция продолжения имеет два других параметра : конечное состояние вызова плюс значение контекста(ctx),
которые первоначально были переданы lua_pcallk. (Lua не использует это значение контекста; он только передает это значение из
исходной функции в функцию продолжения.) При выполнении после приостановки, для lua_pcallk, состоянием является тоже самое значение,
что было бы возвращено lua_pcallk, за исключением того, что это LUA_YIELD(вместо LUA_OK).Когда Lua вызывает продолжение,
для lua_yieldk и lua_callk, состоянием всегда будет LUA_YIELD. (Для этих двух функций, Lua не будет вызывать продолжения
в случае ошибок, так как они не обрабатывают ошибки.) Точно также, при использовании lua_callk, следует вызывать функцию
продолжения с LUA_OK в качестве состояния. (Для lua_yieldk, в прямом вызове функции продолжения нет особого смысла, поскольку
lua_yieldk обычно ничего не возвращает.)

Lua рассматривает функцию продолжения как если бы она была исходной функцией. Функция продолжения принимает тот
же самый Lua стек от исходной функции, в том же самом состоянии, как если бы он был возвращен вызываемой функцией.
(Например, после lua_callk функция и её аргументы удаляются из стека и заменяются результатами из вызова.)
Она также имеет те же самые внешние локальные переменные.Все что она возвращает, обрабатывается Lua как если
бы это было возвращено исходной функцией.*/
lua_KFunction cont(lua_State* L){
    showstack(L); lua_getglobal(L, "f");// получить функцию.
    lua_pcall(L, 0, NULL, 0);
    return 0;
}

int my_yield(lua_State* L) {
    cout << " lua  yielding... " << lua_tointeger(L, -1) << "\n";
    //lua_pushinteger(L, lua_tointeger(L, -1) * 2);
    return lua_yieldk(L, 0, lua_yield(L, 0), cont(L));/* int lua_yieldk(lua_State * L, int res, lua_KContext ctx, lua_KFunction k);
    Приостанавливает выполнение сопрограммы(поток).   Когда функция C вызывает lua_yieldk, работающая
    сопрограмма приостанавливает свое выполнение и вызывает lua_resume, которая начинает возврат данной сопрограммы.
    Параметр res - это число значений из стека, которые будут переданы в качестве результатов в lua_resume.
    Когда сопрограмма снова возобновит выполнение, Lua вызовет заданную функцию продолжения k для продолжения выполнения
    приостановленной C функции(смотрите §4.7). Эта функция продолжения получит тот же самый стек от предыдущей функции,
    с n - ным числом результатов, удаленных и замененных посредством аргументов, переданных в lua_resume. Кроме того,
    функция продолжения получает значение ctx, которое было передано в lua_yieldk. Как правило, эта функция ничего
    не возвращает; когда сопрограмма в конце концов возобновляется, она продолжает выполнение функции продолжения.
    Тем не менее, существует один особый случай, который появляется когда эта функция вызывается внутри строковой
    ловушки(смотрите §4.9).В этом случае, lua_yieldk следует вызывать без продолжения(вероятно в виде lua_yield),
    и ловушка должна возвращать сразу после вызова.Lua будет приостановлена и, когда сопрограмма снова возобновит
    выполнение, продолжит нормальное выполнение функции(Lua), которая вызвала ловушку.   Данная функция может выдавать
    ошибку, если она вызвана из нити(thread) с ожиданием C вызова без функции продолжения или из нити, которая не работает
    внутри возобновления(например, основная нить).*/
};
const char* LUA = R"(
function f()
print("func f ")
end

function foo(x)
print("func foo "..x.."\n")
end

function main()
for i = 1, 3 do
my_yield(10)
end  end
)";
int main(int argc, char* argv[]) {
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    lua_State* L1 = lua_newthread(L);

    lua_register(L, "my_yield", my_yield);// регистрация функций.
    checkerror(L, LUA);
    lua_getglobal(L, "main");// получить функцию.
    while (true) {
        int ret = lua_resume(L, L1, 0); /* Запускает и продолжает сопрограмму в данном потоке L.
    вы отправляйте в стек главную функцию и её аргументы; затем вызываете lua_resume,nargs - кол-во аргументов.
    Вызов возвращается, когда приостанавливается или завершается. При возвращении, стек содержит все значения,
    переданные в lua_yield, или возвращенныеции. Чтобы продолжить сопрограмму, вы удаляете все результаты
    из последнего lua_yield, отправьте в её стек только значения, передаваемые в качестве результатов из yield, и
    затем вызываете lua_resume.   Параметр L представляет сопрограмму, которая продолжает L. */

        if (ret == LUA_YIELD) {
            lua_getglobal(L1, "foo");
            lua_xmove(L, L1, 1);
            lua_resume(L1, L, 1);
        }
        else if (ret == 0) {/*Когда функция lua_resume возвращается, стек содержит все значения,
        переданные в lua_yield, или все значения, возвращенные телом функции.*/
        //showstack(L);
            break;
        }
    };


    lua_close(L);
    return 0;
};

Вариант 2.

lua_KFunction cont(lua_State* L);
int yield(lua_State* L) {
    return lua_yield(L, 0);/*  Параметр res - это число значений из стека,
которые передаются как результаты lua_resume.*/
};

int my_yield(lua_State* L, int yieid) {
    return lua_yieldk(L, 0, lua_yield(L, 0), cont(L));/* int lua_yieldk(lua_State * L, int res, lua_KContext ctx, lua_KFunction k);
    Приостанавливает выполнение сопрограммы(поток).   Когда функция C вызывает lua_yieldk, работающая
    сопрограмма приостанавливает свое выполнение и вызывает lua_resume, которая начинает возврат данной сопрограммы.
    Параметр res - это число значений из стека, которые будут переданы в качестве результатов в lua_resume.
    Когда сопрограмма снова возобновит выполнение, Lua вызовет заданную функцию продолжения k для продолжения выполнения
    приостановленной C функции(смотрите §4.7). */
};
int hookFunc(lua_State* L, lua_Debug* ar) { return my_yield(L, 0);// хук./
};

lua_KFunction cont(lua_State* L) {// функция продолжения.
    if (LUA_YIELD == lua_status(L)) {
    cout << " off hook "<< L << endl;
        lua_sethook(L, (lua_Hook)hookFunc, LUA_MASKCOUNT, 0);// отключить хук foo.
    }
    return 0;
};

const char* LUA = R"(
function foo()
for i = 1, 13 do
print(" func foo "..i.."\n")
end
end

function main()
for i = 1, 13 do
print(" func main "..i.."\n")
end  end
)";
int main() {
    lua_State* L = luaL_newstate(); luaL_openlibs(L);
    checkerror(L, LUA);
    lua_State* L1 = lua_newthread(L);
    int time = 10;// сколько работает main.
    int time1 = 8;// сколько работает foo.
    lua_sethook(L, (lua_Hook)hookFunc, LUA_MASKCOUNT, time);// хух для main.
    lua_getglobal(L, "main");
    lua_resume(L, L1, 0);
    while (LUA_OK != lua_status(L)) {   // пока поток main не завершен.

        if (LUA_YIELD == lua_status(L1)) {// если поток 2 на паузе.
            cout << " pause foo" << endl;
            lua_sethook(L, (lua_Hook)hookFunc, LUA_MASKCOUNT, time);//включить хук для потока main.
            lua_resume(L, L1, 0);
        }// main.

        if (LUA_YIELD == lua_status(L)) {// если поток main на паузе.
            lua_sethook(L1, (lua_Hook)hookFunc, LUA_MASKCOUNT, time1);// включить хук foo.
            cout << " pause main" << endl;
            lua_getglobal(L1, "foo");
            lua_resume(L1, L, 0);
        }// foo.

        if (LUA_OK == lua_status(L1)) {// если поток foo завершен.
            cout << "foo end " << endl;
            lua_resume(L, NULL, 0);
        }
        if (LUA_OK == lua_status(L)) { // если поток main  завершен.
            cout << "  main ok" << endl;
            break;
        }
    };

    return 0;
};









void LUAHook(lua_State* L, lua_Debug* ar) {
    lua_yield(L, 0);
};
 const char* LUA = R"(
function foo()
for i = 1, 4 do
print(" func foo \n")
end end

function main()
for i = 1, 3 do
print(" func main "..i.."\n")
if j == nil
then
 foo1()
j=1
end
end  end
)";
int foo1(lua_State* L) {
    lua_State* L1 = lua_newthread(L);
    lua_sethook(L, LUAHook, LUA_MASKLINE, 1);
    lua_getglobal(L1, "foo");
    lua_sethook(L1, LUAHook, LUA_MASKLINE, 1);
    lua_resume(L1, L, 0);


return  0;
};
int main() {
    lua_State* L = luaL_newstate(); luaL_openlibs(L);
    lua_register(L, "foo1", foo1);
    luaL_dostring(L, LUA);
    int ret;
    lua_getglobal(L, "main");// функция lua возобновляется с последней
    //  прерванной позиции.
    ret = lua_resume(L, NULL, 0);


    return 0;
};


Что в lua файле.


void LUAHook(lua_State* L, lua_Debug* ar) {
    lua_getglobal(L, "main");  /* get global 'f' */
    lua_getinfo(L, ">S", ar);
    printf("%s\n", ar->source); /* (n) */

lua_Debug
typedef struct lua_Debug {
  int event;
  const char *name;           /* (n) */
  const char *namewhat;       /* (n) */
  const char *what;           /* (S) */
  const char *source;         /* (S) */
  int currentline;            /* (l) */
  int linedefined;            /* (S) */
  int lastlinedefined;        /* (S) */
  unsigned char nups;         /* (u) число upvalue */
  unsigned char nparams;      /* (u) число параметров */
  char isvararg;              /* (u) */
  char istailcall;            /* (t) */
  char short_src[LUA_IDSIZE]; /* (S) */
  /* private part (отдельная часть) */
  other fields (другие поля)
} lua_Debug;
Структура, используемая для переноса различных частей сведений о функции или записи активации. lua_getstack заполняет только отдельную часть этой структуры, для последующего использования. Для наполнения полезной информацией других полей lua_Debug, вызывайте функцию lua_getinfo.

Поля структуры lua_Debug имеют следующее значение:
source: имя порции (chunk), которая создала функцию. Если source начинается с '@', это значит что функция была определена в файле, где за символом '@' следует имя файла. Если source начинается с '=', то остальная часть его содержимого описана исходником, зависимым от пользователя. В противном случае, функция была определена в строке, где source является этой строкой.
short_src: "печатабельная" версия source, для использования в сообщениях об ошибках.
linedefined: номер строки, с которой начинается определение функции.
lastlinedefined: номер строки, на которой оканчивается определение функции.
what: строка "Lua", если функция является Lua функцией, "C" - если это C функция, "main" - если это основная часть порции (chunk).
currentline: текущая строка, где выполняется данная функция. Если нет доступных сведений о строке, currentline устанавливается равной -1.
name: допустимое имя для заданной функции. Так как функции в Lua являются значениями первого класса, у них нет фиксированного имени: некоторые функции могут быть значением нескольких глобальных переменных, в то время как другие могут только сохраняться в поле таблицы. Функция lua_getinfo проверяет, как функция была названа для поиска соответствующего имени. Если имя найти не удается, то name устанавливается как NULL.
namewhat: поясняет поле name. Значением namewhat может быть "global", "local", "method", "field", "upvalue", или "" (пустая строка), в соответствии с тем, как функция была вызвана. (Lua использует пустую строку когда нет другого выбора, представленного к применению.)
istailcall: значение true, если данный вызов функции был вызван хвостовым вызовом. В этом случае, функция, вызывающая этот уровень не находится в стеке.
nups: число внешних локальных переменных (upvalue) функции.
nparams: число фиксированных (установленных) параметров функции (для C-ишных функций значение всегда равно 0).
isvararg: значение true, если у функции переменное число аргументов т.е. vararg функция (для C-ишных функций значение всегда истинно).

void LUAHook(lua_State* L, lua_Debug* ar) {
    lua_getglobal(L, "main");  /* функция для ловушки дебага */
    lua_getinfo(L, ">L", ar);// таблица номеров строк с возможностю остановки.
    static vector<int>v;
    if (LUA_TTABLE == lua_type(L, -1)) {
        lua_pushvalue(L, -1);
        lua_pushnil(L);
        while (lua_next(L, -2)) {
            lua_pushvalue(L, -2);
            v.push_back((lua_tointeger(L, -1))); lua_pop(L, 2);
        }
        lua_pop(L, 2);
    };
    for (auto& i : v) {
        if (i == ar->currentline ){// текущую строку можно приостановить.
            lua_yield(L, 0);
        }
    }
    v.clear();
};

const char* LUA = R"(
function foo()
for i = 1, 2 do
print(" func foo "..i.."\n")
end end
function main()
for i = 1, 2 do
print(" func main "..i.."\n")
end
end
)";
int main() {
    lua_State* L = luaL_newstate(); luaL_openlibs(L);
    checkerror(L, LUA);
    lua_State* L1 = lua_newthread(L);
    int ret;
    lua_sethook(L, LUAHook, LUA_MASKLINE, 1);   // Добавить подсчет счетчика, который сработает после указания числа
    lua_getglobal(L, "main");// функция lua возобновляется с последней прерванной позиции.

    while (true) {

        ret = lua_resume(L, L1, 0);
        if (ret == LUA_YIELD) {
            lua_getglobal(L1, "foo");
            lua_pcall(L1, 0, 0, 0);
        }
    if (ret == 0) { break; }
    }
    return 0;
};
int checkerror(lua_State* L, const char* file) {
    int status = luaL_loadfile(L, file);// проверка есть ли ошибки.
    try {
        if (luaL_dostring(L, file) == LUA_OK) {
            return 0;
        }
        else {
            string x = lua_tostring(L, -1);
            throw x;
            return 0;
        }
    }
    catch (string x) {
        cout << x << endl;
        return 0;
    }
    return 0;
};
void LUAHook(lua_State* L, lua_Debug* ar) {
    lua_yield(L, 0);
};

const char* LUA = R"(
function foo()
for i = 1, 6 do
print(" func foo "..i.."\n")
end  end

function main()
for i = 1, 9 do
print(" func main "..i.."\n")
end  end
)";
void m(lua_State* L, const char* func1, const char* func2) {
    lua_State* L1 = lua_newthread(L);
    lua_sethook(L, LUAHook, LUA_MASKCOUNT, 6);  // Добавить подсчет счетчика, который сработает после указания числа
    lua_sethook(L1, LUAHook, LUA_MASKCOUNT, 5); // Добавить подсчет счетчика, который сработает после указания числа
    int ret;
    lua_getglobal(L, func1);// функция lua возобновляется с последней прерванной позиции.
    lua_resume(L, L1, 0);

    while (true) {
        if (ret = !0) {
            ret = lua_resume(L, L1, 0);
        };

        if (ret == LUA_YIELD ) {
            lua_getglobal(L1, func2);
            ret = lua_resume(L1, L, 0);
        }
        if (ret == 0) {// Успешно завершение функции.
            break;
        }
    };

};
int main() {
    lua_State* L = luaL_newstate(); luaL_openlibs(L);
    checkerror(L, LUA);
    lua_getglobal(L, "main");// функция lua возобновляется с последней прерванной позиции.
    lua_resume(L, NULL, 0);
    m(L,"main", "foo");
    return 0;
};

Вариант 2.


static int s = 0;
void LUAHook(lua_State* L, lua_Debug* ar) {
    s++;
    if (s > 25) {   //cout << s << endl;
        s = 0;
        lua_yield(L, 0);
    }
};
static int s1 = 0;
void LUAHook1(lua_State* L, lua_Debug* ar) {
    s1++;
    if (s1 > 5) {   //cout << s << endl;
        s1 = 0;
        lua_yield(L, 0);
    }
};

const char* LUA = R"(
function foo()
for i = 1, 6 do
print(" func foo "..i.."\n")
end  end

function main()
for i = 1, 109 do
print(" func main "..i.."\n")
end  end
)";
void m(lua_State* L, const char* func1, const char* func2) {
    lua_State* L1 = lua_newthread(L);
    lua_sethook(L, LUAHook, LUA_MASKCOUNT, 1);  // Добавить подсчет счетчика, который сработает после указания числа
    lua_sethook(L1, LUAHook1, LUA_MASKCOUNT, 1);    // Добавить подсчет счетчика, который сработает после указания числа
    int ret;
    lua_getglobal(L, func1);// функция lua возобновляется с последней прерванной позиции.
    lua_resume(L, L1, 0);

    while (true) {
        if (ret = !0) {
            ret = lua_resume(L, L1, 0);
        };

        if (ret == LUA_YIELD) {
            lua_getglobal(L1, func2);
            ret = lua_resume(L1, L, 0);
        }
        if (ret == 0) {// Успешно завершение функции.
            break;
        }
    };

};
int main() {
    lua_State* L = luaL_newstate(); luaL_openlibs(L);
    checkerror(L, LUA);
    //lua_getglobal(L, "main");// функция lua возобновляется с последней прерванной позиции.
    //.lua_resume(L, NULL, 0);
    m(L, "main", "foo");
    return 0;
};


Сохранение потока в реестре.

    lua_State* L1 = lua_newthread(L);
    lua_pushthread(L);
    lua_rawseti(L, LUA_REGISTRYINDEX, 2);/* установить в таблице*/
    cout << L << endl;

    pushlua(L, 2);
    lua_rawget(L, LUA_REGISTRYINDEX); /* получить таблицу и значение ключа будет в -1 */
    lua_State* L2 = lua_tothread(L, -1);
    cout << L2 << endl;





int my_yield(lua_State* L) {
    lua_yield(L, 1);
    return 1;
}
const char* LUA = R"(
 function foo()
   print("  foo")
 end

function main()
for i = 1, 3 do
   print(" main".."\n")
my_yield()
end  end
)";
int main(int argc, char* argv[]) {
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    lua_register(L, "my_yield", my_yield);
    lua_State* L1 = lua_newthread(L);

    luaL_dostring(L, LUA);
    lua_getglobal(L, "main");

    while (true) {
        if (LUA_YIELD == lua_resume(L, L1, 0)) {
            lua_getglobal(L1, "foo");
            lua_pcall(L1, 0, 0, 0);
        }
        if (LUA_OK == lua_resume(L, L1, 0)) {
            break;
        }
    };

    lua_close(L);
    return 0;
};

int main(int argc, char* argv[]) {
    const char* LUA = R"(
foo()

)";
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    lua_State* L1 = lua_newthread(L);
    lua_pushcfunction(L1, foo);// отправить c функцию в стек.
    luaL_loadfile(L1, LUA);
    lua_setglobal(L1, "foo");// уст для переменной значение в виде функции.
    lua_pushvalue(L1, -1);// Дублируем вершину стека.
    showstack(L1);
    lua_pcall(L1, 0, 0, 0);
    lua_xmove(L1, L, 2);// Снимает с L1 элементов передает L.
    showstack(L); cout << endl;
    lua_pcall(L, 0, 0, 0);
    //  checkerror(L1, LUA);//Функция проверка на ошибки.
    cout << endl << L << endl; cout << L1 << endl;
    lua_close(L);

    return 0;
};


int my_func(lua_State* L) {
    int narg = lua_gettop(L);
    if (narg == 0)
        fprintf(stderr, "[LUA] Hello from lua!\n");
    else
        fprintf(stderr, "[LUA] Hello from lua! Value passed: \"%s\"\n", lua_tostring(L, 1));
    return 0;
};

/* own yield function for use from lua */
/* note that we don't pass/return any arguments from/to our lua
   function, so we always pass 0 to lua_yield and lua_resume */
int my_yield(lua_State* L) {
    fprintf(stderr, "[LUA] Now yielding...\n");
    return lua_yield(L, 0);
}

int main() {
    int ret;

    /* create lua state */
    lua_State* L = luaL_newstate();

    /* register own lua functions */
    /* note that we don't use any lua libraries */
    lua_register(L, "my_func", my_func);
    lua_register(L, "my_yield", my_yield);

    /* load lua code; may use luaL_dofile instead */
    ret = luaL_dostring(L, "function main() my_func(\"Hello, world!\"); my_yield(); for i = 1,9 do my_func(i); if i % 3 == 0 then my_yield(); end end my_yield(); my_func(\"Bye!\"); end");
    //assert(ret == 0); /* may indicate syntax error in our code */

    /* push lua main() function onto the stack */
    lua_getglobal(L, "main");

    /* mainloop which runs "in parallel" to lua main(), switching back and forth */
    fprintf(stderr, "[ C ] Starting mainloop...\n");
    while (1) {
        fprintf(stderr, "[ C ] Running/resuming lua...\n");
        ret = lua_resume(L, NULL, 0);

        if (ret == LUA_YIELD) {
            fprintf(stderr, "[ C ] Lua has yielded!\n");
        }
        else if (ret == 0) {
            fprintf(stderr, "[ C ] Lua has finished!\n");
            break;
        }
        else {
            //  assert(0); /* something gone wrong with lua */
        }

        fprintf(stderr, "[ C ] Hello from C!\n");
    }

    fprintf(stderr, "[ C ] We're done!\n");

    lua_close(L);
    return 0;
};

Вариант 2.

int my_yield(lua_State* L) {
    cout << " lua  yielding...\n";
    return lua_yield(L, 0);
}
const char* LUA = R"(
function main()
for i = 1,3 do
my_yield()
end  end
)";

int main() {
    lua_State* L = luaL_newstate();
    lua_register(L, "my_yield", my_yield);
    checkerror(L, LUA);
    lua_getglobal(L, "main");
    while (true) {int ret = lua_resume(L, NULL, 0);
      if (ret == LUA_YIELD) {   cout << "C++ !\n ";
      }
        else if (ret == 0) { break; }
    };
    lua_close(L);
    return 0;
};

Вариант 3.

int my_yield(lua_State* L) {
    cout << " lua  yielding...\n";
    return lua_yield(L, 0);
}
const char* LUA = R"(
 function foo()
   print("foo")
 end

function main()
for i = 1, 3 do
my_yield()
end  end
)";
int main(int argc, char* argv[]) {
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    lua_register(L, "my_yield", my_yield);
    checkerror(L, LUA);

    lua_getglobal(L, "main");
    while (true) {
        int ret = lua_resume(L, NULL, 0);
        if (ret == LUA_YIELD) {
            lua_getglobal(L, "foo");
            lua_pcall(L, 0, 0, 0);
        }
        else if (ret == 0) {

            break; }
    };



    lua_close(L);
    return 0;
};
Вариант 4

int my_yield(lua_State* L) {
    //cout << " lua  yielding...\n";
    lua_yield(L, 1);
    lua_pushinteger(L, 10);
    showstack(L);
    return 2;
}
const char* LUA = R"(
 function foo()
   print("foo")
 end

function main()
for i = 1, 3 do
my_yield()
end  end
)";
int main(int argc, char* argv[]) {
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    lua_register(L, "my_yield", my_yield);
    checkerror(L, LUA);

    lua_getglobal(L, "main");
    while (true) {
    if (LUA_YIELD == lua_resume(L, L, 0)) {
            lua_getglobal(L, "foo");
            lua_pcall(L, 0, 0, 0);
        }
     if (LUA_OK == lua_resume(L, L, 0)) {
        break; }
    };

    lua_close(L);
    return 0;
};

static int func_k1(lua_State* L)
{
    printf("continuation got %d values\n", lua_gettop(L));
    return 0;
}

static int func(lua_State* L){
lua_pushinteger(L, 10);
    return lua_yield(L, 1, 0, func_k1);
}

int main()
{
    lua_State* L, * T;
    int result, i;
    L = luaL_newstate();
    T = lua_newthread(L);
    lua_pushcfunction(T, func);
    lua_pushstring(T, "starting value 1");
    showstack(L);
    result = lua_resume(T, L, 1);
    if (result == LUA_YIELD)    {
        printf("main thread \n");
        showstack(T);
    }

    lua_close(L);
    return 0;
};


Вариант 5.
int foo(lua_State* L) {
    cout << " func foo c++ " << L << " " << lua_tointeger(L, -1)<< "\n";
    return 0;
};

int my_yield(lua_State* L) {
    //cout << " lua  yielding..." << lua_tointeger(L, -1) << "\n";
    return lua_yield(L, 1);
}
const char* LUA = R"(
foo(n)

function main(n)
for i = 1, 3 do
my_yield(n)
end  end
)";
int main(int argc, char* argv[]) {
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    lua_State* L1 = lua_newthread(L);

    lua_register(L, "my_yield", my_yield);
    lua_register(L, "foo", foo);
    checkerror(L, LUA);
    lua_getglobal(L, "main");
    lua_pushinteger(L, 2);
    while (true) {
        int ret = lua_resume(L, L1, 1);
        if (ret == LUA_YIELD) {
            lua_pushvalue(L, -1);
            lua_getglobal(L1, "foo");
            lua_xmove(L, L1, 1);
            lua_pcall(L1, 1, 0, 0);
        }
        else if (ret == 0) {

            break;
        }
    };



    lua_close(L);
    return 0;
};

Вариант 6.

int foo(lua_State* L) {
    cout << " func foo c++ " << L << " " << lua_tointeger(L, -1)<< "\n";
    return 0;
};

int my_yield(lua_State* L) {
    cout << " lua  yielding..." << lua_tointeger(L, -1) << "\n";
    return lua_yield(L, 1);
}
const char* LUA = R"(
function foo(n)
print(" "..n)
end

function main(n)
for i = 1, 3 do
my_yield(i*n)
end  end
)";
int main(int argc, char* argv[]) {
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    lua_State* L1 = lua_newthread(L);

    lua_register(L, "my_yield", my_yield);
    checkerror(L, LUA);
    lua_getglobal(L, "main");
    lua_pushinteger(L, 2);
    while (true) {
        int ret = lua_resume(L, L1, 1);
        if (ret == LUA_YIELD) {
            lua_pushvalue(L, -1);
            lua_getglobal(L1, "foo");
            lua_xmove(L, L1, 1);
            lua_pcall(L1, 1, 0, 0);
        }
        else if (ret == 0) {

            break;
        }
    };



    lua_close(L);
    return 0;
};

Вариант 7.


int foo(lua_State* L) {
    cout << " func foo c++ " << L << " " << lua_tointeger(L, -1)<< "\n";
    return 0;
};

int my_yield(lua_State* L) {
    cout << " lua  yielding..." << lua_tointeger(L, -1) << "\n";
    return lua_yield(L, 0);
}
const char* LUA = R"(
function foo(x)
print("func foo "..x.."\n")
end

function main(n)
for i = 1, 3 do
my_yield(i*n)
end  end
)";
int main(int argc, char* argv[]) {
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    lua_State* L1 = lua_newthread(L);

    lua_register(L, "my_yield", my_yield);// регистрация функций.
    checkerror(L, LUA);
    lua_getglobal(L, "main");// получить функцию.
    lua_pushinteger(L, 2);// отправить аргументы в функцию main.
    while (true) {
        int ret = lua_resume(L, L1, 1); /* Запускает и продолжает сопрограмму в данном потоке L.
    вы отправляйте в стек главную функцию и её аргументы; затем вызываете lua_resume,nargs - кол-во аргументов.
    Вызов возвращается, когда приостанавливается или завершается. При возвращении, стек содержит все значения,
    переданные в lua_yield, или возвращенныеции. Чтобы продолжить сопрограмму, вы удаляете все результаты
    из последнего lua_yield, отправьте в её стек только значения, передаваемые в качестве результатов из yield, и
    затем вызываете lua_resume.   Параметр L представляет сопрограмму, которая продолжает L. */

        if (ret == LUA_YIELD) {
            lua_getglobal(L1, "foo");
            lua_xmove(L, L1, 1);
            lua_pcall(L1, 1, 0, 0);
        }
        else if (ret == 0) {/*Когда функция lua_resume возвращается, стек содержит все значения,
        переданные в lua_yield, или все значения, возвращенные телом функции.*/
        //showstack(L);
            break;
        }
    };

    lua_close(L);
    return 0;
};


Вариант 7.

/*Внутри себя, Lua использует возможность C - ишного longjmp для выхода(приостановки выполнения) из сопрограммы.
Поэтому, если C - ишная функция foo вызывает функцию API и эта функция API приостанавливает выполнение(непосредственно
сама или косвенно вызывая другую функцию, которая делает выход), Lua не может ничего больше возвратить в foo,
потому что longjmp удалил его фрейм из C - ишного стека. Во избежание проблем такого рода, Lua выдает ошибку всякий раз
при попытке выхода через вызов API, за исключением трех функций : lua_yieldk, lua_callk, и lua_pcallk.
Все эти функции принимают функцию - продолжение(в качестве параметра с именем k) чтобы продолжить выполнение после выхода.
Чтобы объяснить продолжения, следует установить некоторую терминологию. У нас есть функция C вызываемая из Lua,
которую мы будем называть исходной функцией. Эта исходная функция затем вызывает одну из этих трех функций в С - ишном API,
которая будет называться вызываемой функцией, которая затем приостанавливает выполнение текущего потока.
(Это может произойти, когда вызываемой функцией является lua_yieldk, или, когда вызываемая функция - либо lua_callk,
либо lua_pcallk, а функция, вызванная ими, приостанавливает выполнение.)

Предположим, что работающий поток приостанавливается на время выполнения вызываемой функции. После возобновления
работы потока, она, в конечном счете, завершит работу вызываемой функции. Однако, вызываемая функция не может
возвратиться к исходной функции, так как её фрейм в С - ишном стеке был разрушен приостановкой выполнения потока.
Вместо этого, Lua вызывает функцию продолжения(continuation function), которая будет задана в качестве аргумента
вызываемой функции. Как следует из названия, функция продолжения должна продолжить задачу исходной функции.

В качестве иллюстрации, рассмотрим следующую функцию :
int original_function(lua_State* L) { code 1
        status = lua_pcall(L, n, m, h);   calls Lua
 code 2 }
Теперь нужно позволить коду Lua запустить lua_pcall для приостановки. Во - первых, можно переписать нашу функцию вот так :
int k(lua_State* L, int status, lua_KContext ctx) {
     code 2
}
int original_function(lua_State* L) {
    ...   code 1
    return k(L, lua_pcall(L, n, m, h), ctx);
}
В приведенном выше коде, новая функция k является функцией продолжения(с типом lua_KFunction), которая должна выполнять
всю работу, что делала исходная функция после вызова lua_pcall.Теперь нужно сообщить Lua, что он должен вызывать k,
если код Lua выполняемый lua_pcall прерывается каким - то образом(ошибки или выход), так что можно переписать код
следующим образом, заменив lua_pcall на lua_pcallk :
int original_function(lua_State* L) {
     code 1
     return k(L, lua_pcallk(L, n, m, h, ctx2, k), ctx1);
}
Обратите внимание на внешний, явный вызов продолжения : Lua вызовет продолжение только при необходимости, то есть,
в случае ошибок или возобновления после выхода из выполнения.Если вызванная функция возвращается как обычно без
приостановки выполнения когда - либо, lua_pcallk(и lua_callk) также будет возвращаться нормально.
(Конечно, в данном случае вместо вызова продолжения можно сделать аналогичную работу непосредственно внутри исходной функции.)

Помимо Lua состояния, функция продолжения имеет два других параметра : конечное состояние вызова плюс значение контекста(ctx), которые первоначально были переданы lua_pcallk. (Lua не использует это значение контекста; он только передает это значение из исходной функции в функцию продолжения.) При выполнении после приостановки, для lua_pcallk, состоянием является тоже самое значение, что было бы возвращено lua_pcallk, за исключением того, что это LUA_YIELD(вместо LUA_OK).Когда Lua вызывает продолжение, для lua_yieldk и lua_callk, состоянием всегда будет LUA_YIELD. (Для этих двух функций, Lua не будет вызывать продолжения в случае ошибок, так как они не обрабатывают ошибки.) Точно также, при использовании lua_callk, следует вызывать функцию продолжения с LUA_OK в качестве состояния. (Для lua_yieldk, в прямом вызове функции продолжения нет особого смысла, поскольку lua_yieldk обычно ничего не возвращает.)

Lua рассматривает функцию продолжения как если бы она была исходной функцией.Функция продолжения принимает тот
же самый Lua стек от исходной функции, в том же самом состоянии, как если бы он был возвращен вызываемой функцией.
(Например, после lua_callk функция и её аргументы удаляются из стека и заменяются результатами из вызова.)
Она также имеет те же самые внешние локальные переменные.Все что она возвращает, обрабатывается Lua как если
бы это было возвращено исходной функцией.*/
lua_KFunction cont(int x)
{
//  cout << x<< endl;
    return 0;
}

int my_yield(lua_State* L) {
    cout << " lua  yielding... " << lua_tointeger(L, -1) << "\n";
    lua_pushinteger(L, lua_tointeger(L, -1) * 2);
    return lua_yieldk(L, 1, lua_yield(L, 0), cont(0));/* int lua_yieldk(lua_State * L, int res, lua_KContext ctx, lua_KFunction k);
    Приостанавливает выполнение сопрограммы(поток).   Когда функция C вызывает lua_yieldk, работающая
    сопрограмма приостанавливает свое выполнение и вызывает lua_resume, которая начинает возврат данной сопрограммы.
    Параметр res - это число значений из стека, которые будут переданы в качестве результатов в lua_resume.
    Когда сопрограмма снова возобновит выполнение, Lua вызовет заданную функцию продолжения k для продолжения выполнения
    приостановленной C функции(смотрите §4.7). Эта функция продолжения получит тот же самый стек от предыдущей функции,
    с n - ным числом результатов, удаленных и замененных посредством аргументов, переданных в lua_resume. Кроме того,
    функция продолжения получает значение ctx, которое было передано в lua_yieldk. Как правило, эта функция ничего
    не возвращает; когда сопрограмма в конце концов возобновляется, она продолжает выполнение функции продолжения.
    Тем не менее, существует один особый случай, который появляется когда эта функция вызывается внутри строковой
    ловушки(смотрите §4.9).В этом случае, lua_yieldk следует вызывать без продолжения(вероятно в виде lua_yield),
    и ловушка должна возвращать сразу после вызова.Lua будет приостановлена и, когда сопрограмма снова возобновит
    выполнение, продолжит нормальное выполнение функции(Lua), которая вызвала ловушку.   Данная функция может выдавать
    ошибку, если она вызвана из нити(thread) с ожиданием C вызова без функции продолжения или из нити, которая не работает
    внутри возобновления(например, основная нить).*/
};
const char* LUA = R"(
function foo(x)
print("func foo "..x.."\n")
end

function main(n)
for i = 1, n do
my_yield(i)
end  end
)";
int main(int argc, char* argv[]) {
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    lua_State* L1 = lua_newthread(L);

    lua_register(L, "my_yield", my_yield);// регистрация функций.
    checkerror(L, LUA);
    lua_getglobal(L, "main");// получить функцию.
    lua_pushinteger(L, 2);// отправить аргументы в функцию main.
    while (true) {
        int ret = lua_resume(L, L1, 1); /* Запускает и продолжает сопрограмму в данном потоке L.
    вы отправляйте в стек главную функцию и её аргументы; затем вызываете lua_resume,nargs - кол-во аргументов.
    Вызов возвращается, когда приостанавливается или завершается. При возвращении, стек содержит все значения,
    переданные в lua_yield, или возвращенныеции. Чтобы продолжить сопрограмму, вы удаляете все результаты
    из последнего lua_yield, отправьте в её стек только значения, передаваемые в качестве результатов из yield, и
    затем вызываете lua_resume.   Параметр L представляет сопрограмму, которая продолжает L. */

        if (ret == LUA_YIELD) {
            lua_getglobal(L1, "foo");
            lua_xmove(L, L1, 1);
            lua_pcall(L1, 1, 0, 0);
        }
        else if (ret == 0) {/*Когда функция lua_resume возвращается, стек содержит все значения,
        переданные в lua_yield, или все значения, возвращенные телом функции.*/
        //showstack(L);
            break;
        }
    };


    lua_close(L);
    return 0;
};

Вариант 8.

static int timerfirsttread = 0;// таймер для первого потока.
void LUAHook(lua_State* L, lua_Debug* ar) {
    timerfirsttread++;
    if (timerfirsttread > 16) {// сколько будет работать первый поток.
        timerfirsttread = 0; lua_yield(L, 0);
    }
};
int my_yield(lua_State* L) {
    int args = lua_gettop(L);args++;
    lua_State* L1 = lua_newthread(L);
    lua_pushthread(L1);
    return lua_yield(L, args);/* Когда функция C вызывает lua_yield таким образом, запущенная сопрограмма приостанавливает
    свое выполнение, и вызов lua_resume этой запущенной процедуры возвращается.*/
};
int yield(lua_State* L) {return lua_yield(L, 0);/*  Параметр res - это число значений из стека,
    которые передаются как результаты lua_resume.*/
};
const char* LUA = R"(
function foo(x)    x = x or 3
print(" func foo "..x.. " \n")
for i = 1, x do
print(" func foo "..i.."\n")
yield()
end
end

function main()
for i = 1, 320 do
x=i*6
print(" func main "..i.."\n")
if i ==1
then my_yield(foo,40)
end
end  end
)";
int main(int argc, char* argv[]) {
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L); lua_State* L1 = NULL;
    lua_register(L, "my_yield", my_yield);
    lua_register(L, "yield",  yield);
    cout << "\n"; checkerror(L, LUA);
    lua_getglobal(L, "main");
    lua_resume(L, NULL, 0); /* Запускает и продолжает сопрограмму в данном потоке L. */
    L1 = lua_tothread(L, -1); lua_pop(L, 1); lua_xmove(L, L1, lua_gettop(L));lua_remove(L1, 1);
    int args = lua_gettop(L1);//    cout << args << endl;// Аргументы.


        for (int i = 1; i > args; i++) {lua_pushvalue(L1, i);}
        args--; res1 = lua_resume(L1, L, args);
        lua_xmove(L, L1, 1);
  while ( LUA_OK != lua_status(L)) {    // пока поток main не завершен.
       if (LUA_YIELD == lua_status(L1)) {// если поток 2 на паузе.
            lua_sethook(L, LUAHook, LUA_MASKCOUNT, 6);//Пауза после 6 итерации.
            lua_resume(L, L1, 0);
        }// main
        if (LUA_YIELD == lua_status(L)){// если поток main на паузе.
         lua_sethook(L, LUAHook, LUA_MASKCOUNT, 0);// отключить хук.
         lua_resume(L1, L, 0);// foo
        }
    if (LUA_OK == lua_status(L1)) {// если поток foo  завершен.
        lua_sethook(L, LUAHook, LUA_MASKCOUNT, 0);// отключить хук.
        lua_resume(L, NULL, 0);
        lua_settop(L1, 0);
    }
    if (LUA_OK == lua_status(L)) { break; }// если поток main  завершен.
};
    lua_close(L);
    return 0;
};



void LUAHook(lua_State* L, lua_Debug* ar){  lua_yield(L, 0);
};

int NONblock(lua_State* L, const char* functionName, float dt){
    lua_getglobal(L, functionName); // функция lua возобновляется с последней прерванной позиции.


    int ret = lua_resume(L, NULL, NULL);
    if (ret == LUA_YIELD) {
        return 1;
    }
    else if (ret == 0) {    // функция lua возвращается успешно.
        return 0;   }
    else {      // Обработка ошибки lua.
        return -1;  }
};
const char* LUA = R"(
function heavy_function(dt)
 i = 0;
while i < 3 do
  i = i + 1;
  print(" main ", i)
    end
end

function foo()
for i = 1, 3 do
print(" func foo "..i.."\n")
end
end
)";
int main() {
    lua_State* L = luaL_newstate();
    luaL_openlibs(L);

    checkerror(L, LUA);
    lua_sethook(L, LUAHook, LUA_MASKCOUNT, 10); // Добавить подсчет счетчика, который сработает после указания числа
    while (true)
    {
        printf("  lua script resumu \n\n");// Обновляем функцию lua с упреждающим планированием.
        int functionState = NONblock(L, "heavy_function", 0.0);
        if (functionState == 0) {// Успешно завершение функции.
            break;
        }
    }

    return 0;
};


int my_yield(lua_State* L) {
    cout << " lua  yielding... " << lua_tointeger(L, -1) << "\n";
    lua_pushinteger(L, lua_tointeger(L, -1) * 2);
    return  lua_yield(L, 0);
};
const char* LUA = R"(
function foo(x)
print("func foo "..x.."\n")
return 8
end

function main(n)
for i = 1, n do
my_yield(i)
end  end
)";
int main(int argc, char* argv[]) {
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    lua_State* L1 = lua_newthread(L);

    lua_register(L, "my_yield", my_yield);// регистрация функций.
    checkerror(L, LUA);
    lua_getglobal(L, "main");// получить функцию.
    lua_pushinteger(L, 6);// отправить аргументы в функцию main.
    while (true) {
        int ret = lua_resume(L, L1, 1); /* Запускает и продолжает сопрограмму в данном потоке L.
    вы отправляйте в стек главную функцию и её аргументы; затем вызываете lua_resume,nargs - кол-во аргументов.
    Вызов возвращается, когда приостанавливается или завершается. При возвращении, стек содержит все значения,
    переданные в lua_yield, или возвращенныеции. Чтобы продолжить сопрограмму, вы удаляете все результаты
    из последнего lua_yield, отправьте в её стек только значения, передаваемые в качестве результатов из yield, и
    затем вызываете lua_resume.   Параметр L представляет сопрограмму, которая продолжает L. */

        if (ret == LUA_YIELD) {
            int x = lua_tointeger(L, -1);// Из функции foo.
            cout << x << endl;
            lua_getglobal(L1, "foo");
            lua_xmove(L, L1, 1);
            lua_pcall(L1, 1, 0, 0);
        }
        else if (ret == 0) {/*Когда функция lua_resume возвращается, стек содержит все значения,
        переданные в lua_yield, или все значения, возвращенные телом функции.*/
        //showstack(L);
            break;
        }
    };


    lua_close(L);
    return 0;
};








int yield(lua_State* L) {
    return lua_yield(L, 0);/*  Параметр res - это число значений из стека,
которые передаются как результаты lua_resume.*/
};
int hookFunc(lua_State* L, lua_Debug* ar) {
    int  m = L->l_G->seed;
    cout << m << endl;
    return lua_yield(L, 0);
};

int my_yield(lua_State* L) {
    int args = lua_gettop(L);args++;
    lua_State* L1 = lua_newthread(L);
    lua_pushthread(L1);
    return lua_yield(L, args);/* Когда функция C вызывает lua_yield таким образом, запущенная сопрограмма приостанавливает
    свое выполнение, и вызов lua_resume этой запущенной процедуры возвращается.*/
};
const char* LUA = R"(
function foo(x)    x = x or 3
print(" func foo "..x.. " \n")
for i = 1, x do
print(" func foo "..i.."\n")
yield()
end
end

function main()
for i = 1, 1460 do
z=i*6
print(" func main "..i.."\n")
if i ==3
then my_yield(foo,106)
end
end  end
)";
int main(int argc, char* argv[]) {
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L); lua_State* L1 = NULL;
    lua_register(L, "my_yield", my_yield);
    lua_register(L, "yield",  yield);
    cout << "\n"; checkerror(L, LUA);
    lua_getglobal(L, "main");
    lua_resume(L, NULL, 0); /* Запускает и продолжает сопрограмму в данном потоке L. */
    L1 = lua_tothread(L, -1); lua_pop(L, 1); lua_xmove(L, L1, lua_gettop(L));lua_remove(L1, 1);
    int args = lua_gettop(L1);//    cout << args << endl;// Аргументы.

        for (int i = 1; i > args; i++) {lua_pushvalue(L1, i);}
        args--;  lua_resume(L1, L, args);   lua_xmove(L, L1, 1); //showstack(L1);


        //lua_sethook(L, LUAHook, LUA_MASKCOUNT, 6);//Пауза после 6 итерации.
  while ( LUA_OK != lua_status(L)) {    // пока поток main не завершен.

       if (LUA_YIELD == lua_status(L1)) {// если поток 2 на паузе.
         // lua_sethook(L, LUAHook, LUA_MASKCOUNT, 0);// отключить хук main.
        cout << " pause foo" << endl;
          lua_sethook(L, (lua_Hook)hookFunc, LUA_MASKCOUNT, 26);//Пауза после 6 итерации поток main.
          lua_resume(L, L1, 0);
        // lua_sethook(L, LUAHook, LUA_MASKCOUNT, 6);// отключить хук main.
        }// main

       if (LUA_YIELD == lua_status(L)){// если поток main на паузе.
          lua_sethook(L, (lua_Hook)hookFunc,  LUA_MASKCOUNT, 0);// отключить хук main.
         cout << " pause main" << endl;
         lua_resume(L1, L, 0);// foo

        }

    if (LUA_OK == lua_status(L1)) {// если поток foo  завершен.
        cout << "foo end " << endl;
        //lua_sethook(L, LUAHook, LUA_MASKCOUNT, 0);// отключить хук main.
        lua_resume(L, NULL, 0);
    }
    if (LUA_OK == lua_status(L)) { break; }// если поток main  завершен.
};
    lua_close(L);
    return 0;
};





static int func_k1(lua_State* L)
{
    int i;
    printf("continuation got %d values\n", lua_gettop(L));
    return 0;
}

static int func(lua_State* L)
{
    int i;
    lua_pushstring(L, "data 1");
    printf("coroutine yields %d values out of %d:\n", 2, lua_gettop(L));
    return lua_yield(L, 2, 0, func_k1);
}

int main()
{
    lua_State* L, * T;
    int result, i;
    L = luaL_newstate();
    T = lua_newthread(L);
    lua_pushcfunction(T, func);
    lua_pushstring(T, "starting value 1");
    lua_pushstring(T, "starting value 2");
    result = lua_resume(T, L, 2);
    if (result != 0 && result != LUA_YIELD)
        printf("error in first resume: %s\n", lua_tostring(T, -1));
    else
    {
        printf("main thread got %d values:\n", lua_gettop(T));
        for (i = 1; i <= lua_gettop(T); ++i)
        {
            printf("\t%s %s\n", luaL_typename(T, i), lua_type(T,
                i) == LUA_TSTRING ? lua_tostring(T, i) : "");
        }
    }
    lua_pushstring(T, "resumed value 1");
    printf("resuming with 1 argument out of %d:\n", lua_gettop(T));
    for (i = 1; i <= lua_gettop(T); ++i)
    {
        printf("\t%s %s\n", luaL_typename(T, i), lua_type(T,
            i) == LUA_TSTRING ? lua_tostring(T, i) : "");
    }
    result = lua_resume(T, L, 1);
    if (result != 0 && result != LUA_YIELD)
        printf("error in second resume: %s\n", lua_tostring(T, -1));
    lua_close(L);
    return 0;
};

Hi list,

I'm trying to port to C a framework of mine that is basically a
coroutine scheduler hidden under a pseudo-blocking I/O API (not mature
enough to be released, but ask for a URL if interested). I have
several pure-Lua implementations (with various backend dependencies),
and I'm trying to re-implement it in C. That was the perfect occasion
to dive into Lua 5.2's new lua_yieldk feature. But I'm faced with an
oddity, which I believe is either a bug or a documentation problem.

When a first call to lua_resume returns, only the yielded values are
on the stack. Any other values in the thread stack (in the
lua_CFunction that called lua_yieldk) are not accessible (but will be
in the continuation). So far so good. However if I let those return
values there, push a couple other ones, and call lua_resume with nargs
equal to 1 or 2, the continuation receives 1) the non returned value
from the initial coroutine resume at the bottom, 2) the nargs values
passed to the second resume at the top, but also 3) any other yielded
values, and any other pushed values before the second call to
lua_resume. In other words it seems the nargs of a second lua_resume
seems to be ignored, and all values on the thread stack at the moment
of the resume are passed to the continuation function.

Here is a small program showing the problem:

#include <lua.h>
#include <lauxlib.h>
#include <stdlib.h>

static int func_k1(lua_State* L)
{
    int i;
    printf("continuation got %d values\n", lua_gettop(L));
    for (i=1; i<=lua_gettop(L); ++i)
    {
        printf("\t%s %s\n", luaL_typename(L, i), lua_type(L,
i)==LUA_TSTRING ? lua_tostring(L, i) : "");
    }
    return 0;
}

static int func(lua_State* L)
{
    int i;
    lua_pushstring(L, "data 1");
    lua_pushstring(L, "data 2");
    lua_pushstring(L, "yielded value 1");
    lua_pushstring(L, "yielded value 2");
    printf("coroutine yields %d values out of %d:\n", 2, lua_gettop(L));
    for (i=1; i<=lua_gettop(L); ++i)
    {
        printf("\t%s %s\n", luaL_typename(L, i), lua_type(L,
i)==LUA_TSTRING ? lua_tostring(L, i) : "");
    }
    return lua_yieldk(L, 2, 0, func_k1);
}

int main()
{
    lua_State* L,* T;
    int result, i;
    L = luaL_newstate();
    T = lua_newthread(L);
    lua_pushcfunction(T, func);
    lua_pushstring(T, "starting value 1");
    lua_pushstring(T, "starting value 2");
    result = lua_resume(T, L, 2);
    if (result != 0 && result != LUA_YIELD)
        printf("error in first resume: %s\n", lua_tostring(T, -1));
    else
    {
        printf("main thread got %d values:\n", lua_gettop(T));
        for (i=1; i<=lua_gettop(T); ++i)
        {
            printf("\t%s %s\n", luaL_typename(T, i), lua_type(T,
i)==LUA_TSTRING ? lua_tostring(T, i) : "");
        }
    }
    lua_pushstring(T, "resumed value 1");
    lua_pushstring(T, "resumed value 2");
    printf("resuming with 1 argument out of %d:\n", lua_gettop(T));
    for (i=1; i<=lua_gettop(T); ++i)
    {
        printf("\t%s %s\n", luaL_typename(T, i), lua_type(T,
i)==LUA_TSTRING ? lua_tostring(T, i) : "");
    }
    result = lua_resume(T, L, 1);
    if (result != 0 && result != LUA_YIELD)
        printf("error in second resume: %s\n", lua_tostring(T, -1));
    lua_close(L);
    return 0;
}

And here is the output I get:

coroutine yields 2 values out of 6:
        string starting value 1
        string starting value 2
        string data 1
        string data 2
        string yielded value 1
        string yielded value 2
main thread got 2 values:
        string yielded value 1
        string yielded value 2
resuming with 1 argument out of 4:
        string yielded value 1
        string yielded value 2
        string resumed value 1
        string resumed value 2
continuation got 8 values
        string starting value 1
        string starting value 2
        string data 1
        string data 2
        string yielded value 1
        string yielded value 2
        string resumed value 1
        string resumed value 2

Instead I expected the last section to read:
continuation got 5 values
        string starting value 1
        string starting value 2
        string data 1
        string data 2
        string resumed value 2

Did I misinterpret something, or is there a problem somewhere (with
lua_resume, lua_yieldk, or the doc of one of these)?

Doub.

lua_State* CreateThread(lua_State* MainState)
{
    lua_State* thread = lua_newthread(MainState);
    //making the stuff
    return thread;
};
int LuaYield(lua_State* L){
    return lua_yield(L, 1);
};
const char* LUA = R"(
function main()
count = 0
while 1 do
    count = count + 1;
    print("Count:", count);
    yield();
end
end
)";
int main(int argc, char* argv[]) {
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);


    lua_register(L, "yield", LuaYield);
    lua_State* L1 = CreateThread(L);

    luaL_dostring(L, LUA);
    lua_getglobal(L, "main");

    while (true) {
        if (LUA_YIELD == lua_resume(L,NULL, 0)) {
        }
        if (LUA_OK == lua_resume(L, NULL, 0)) {
            break;
        }
    };

    lua_close(L);
    return 0;
};

int main(int argc, char* argv[]) {
    const char* LUA = R"(
foo()

)";
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    lua_State* L1 = lua_newthread(L);
    lua_pushcfunction(L1, foo);// отправить c функцию в стек.
    luaL_loadfile(L1, LUA);
    lua_setglobal(L1, "foo");// уст для переменной значение в виде функции.

    lua_resume(L1, L, 0); /*
    int lua_resume(lua_State *L, lua_State *from, int nargs); Запускает и продолжает сопрограмму в данном потоке L.
    Для запуска подпрограммы, вы отправляйте в стек потока главную функцию и её аргументы; затем вызываете lua_resume,
    nargs - количество аргументов. Этот вызов возвращается, когда сопрограмма приостанавливается или завершается.
    Когда функция возвращается, стек содержит все значения, переданные в lua_yield, или все значения, возвращенные
    телом функции.  lua_resume возвращает LUA_YIELD - если сопрограмма уступила, LUA_OK - если сопрограмма завершила
    свое исполнение без ошибок, или код ошибки в случае ошибок(см.lua_pcall).
    В случае ошибок, стек не раскручивается, так вы можете использовать отладочные API на нём.
    Сообщение об ошибке находится на вершине стека. Чтобы продолжить сопрограмму, вы удаляете все результаты
    из последнего lua_yield, отправьте в её стек только значения, передаваемые в качестве результатов из yield, и
    затем вызываете lua_resume.   Параметр from представляет сопрограмму, которая продолжает L. Если такой сопрограммы
    нет, этот параметр может быть равен NULL.  */
    //lua_pcall(L, 0, 0, 0);

    cout << endl << L << endl; cout << L1 << endl;
    lua_close(L);

    return 0;
};

const char* LUA = R"(
counter= 0
    while true
    do
        print("Sending " .. counter);
        coroutine.yield(counter);
        counter = counter + 1;
    end
)";

int main(int argc, char* argv[]) {
    lua_State* L = luaL_newstate();
    luaL_openlibs(L);

    lua_State* thread1 = lua_newthread(L);
    lua_State* thread2 = lua_newthread(L);

    // load chunk as a function and copy it to the top of each thread stack
    checkerror(L, LUA);
    lua_pushvalue(L, -1);
    lua_xmove(L, thread1, 1);
    lua_pushvalue(L, -1);
//  lua_xmove(L, thread2, 1);

    lua_resume(thread1, NULL, 0);
//  lua_resume(thread2, NULL, 0);
    lua_close(L);// закрыть состояние.

    return 0;
};

int main() {
    const char* LUA = R"(
function loop()
    while counter
    do
        print("Sending " .. counter);
        coroutine.yield(counter);
        counter = counter + 1;
    end
end
)";

    lua_State* L = luaL_newstate();
    luaL_openlibs(L);
    if (!luaL_loadfile(L, LUA)) {
        lua_pcall(L, 0, 0, 0);
        lua_State* L2 = lua_newthread(L);
        lua_getglobal(L2, "loop");

        while (1) {
            puts("while top");
            int res = lua_resume(L2, NULL, 0);
            if (res != 0) {
                break;
            }

            if (lua_isnumber(L2, lua_gettop(L2)) == 1) {
                printf( "Got %d\n", lua_tonumber(L2, lua_gettop(L2))
                );
            }
        }
    }
    lua_close(L);// закрыть состояние
    return 0;
};


int lua_finish(lua_State*) {
    running = false;
    printf("lua_finish called\n");
    return 0;
}
int lua_sleep(lua_State* L) {
    printf("lua_sleep called\n");
    return lua_yield(L, 0);
}
int main() {
    const char* LUA = R"(
print("loop.lua")

local i = 0
while true do
    print("lua_loop iteration")
    sleep()

    i = i + 1
    if i == 4 then
        break
    end
end

finish()
)";

    lua_State* L = luaL_newstate();
    luaL_openlibs(L);
    lua_register(L, "sleep", lua_sleep);
    lua_register(L, "finish", lua_finish);

    lua_State* cL = lua_newthread(L);
    luaL_dofile(cL, LUA);

    while (running) {
        int status;
        status = lua_resume(cL, L, 0);
        if (status == LUA_YIELD) {
            printf("loop yielding\n");
        }
        else {
            running = false; // you can't try to resume if it didn't yield
            // catch any errors below
            if (status == LUA_ERRRUN && lua_isstring(cL, -1)) {
                printf("isstring: %s\n", lua_tostring(cL, -1));
                lua_pop(cL, -1);
            }
        }
    }
    lua_close(L);
    return 0;
};

static lua_State* getco(lua_State* L) {
    lua_State* co = lua_tothread(L, 1);
    luaL_argcheck(L, co, 1, "thread expected");
    return co;
};

static int auxresume(lua_State* L, lua_State* co, int narg) {
    int status;
    if (!lua_checkstack(co, narg)) {
        lua_pushliteral(L, "too many arguments to resume");
        return -1;  /* error flag */
    }
    if (lua_status(co) == LUA_OK && lua_gettop(co) == 0) {
        lua_pushliteral(L, "cannot resume dead coroutine");
        return -1;  /* error flag */
    }
    lua_xmove(L, co, narg);
    status = lua_resume(co, L, narg);
    if (status == LUA_OK || status == LUA_YIELD) {
        int nres = lua_gettop(co);
        if (!lua_checkstack(L, nres + 1)) {
            lua_pop(co, nres);  /* remove results anyway */
            lua_pushliteral(L, "too many results to resume");
            return -1;  /* error flag */
        }
        lua_xmove(co, L, nres);  /* move yielded values */
        return nres;
    }
    else {
        lua_xmove(co, L, 1);  /* move error message */
        return -1;  /* error flag */
    }
};


static int luaB_coresume(lua_State* L) {
    lua_State* co = getco(L);
    int r;
    r = auxresume(L, co, lua_gettop(L) - 1);
    if (r < 0) {
        lua_pushboolean(L, 0);
        lua_insert(L, -2);
        return 2;  /* return false + error message */
    }
    else {
        lua_pushboolean(L, 1);
        lua_insert(L, -(r + 1));
        return r + 1;  /* return true + 'resume' returns */
    }
};


static int luaB_auxwrap(lua_State* L) {
    lua_State* co = lua_tothread(L, lua_upvalueindex(1));
    int r = auxresume(L, co, lua_gettop(L));
    if (r < 0) {
        if (lua_type(L, -1) == LUA_TSTRING) {  /* error object is a string? */
            luaL_where(L, 1);  /* add extra info */
            lua_insert(L, -2);
            lua_concat(L, 2);
        }
        return lua_error(L);  /* propagate error */
    }
    return r;
};


static int luaB_cocreate(lua_State* L) {
    lua_State* NL;
    luaL_checktype(L, 1, LUA_TFUNCTION);
    NL = lua_newthread(L);
    lua_pushvalue(L, 1);  /* move function to top */
    lua_xmove(L, NL, 1);  /* move function from L to NL */
    return 1;
};


static int luaB_cowrap(lua_State* L) {
    luaB_cocreate(L);
    lua_pushcclosure(L, luaB_auxwrap, 1);
    return 1;
};


static int luaB_yield(lua_State* L) {
    return lua_yield(L, lua_gettop(L));
};


static int luaB_costatus(lua_State* L) {
    lua_State* co = getco(L);
    if (L == co) lua_pushliteral(L, "running");
    else {
        switch (lua_status(co)) {
        case LUA_YIELD:
            lua_pushliteral(L, "suspended");
            break;
        case LUA_OK: {
            lua_Debug ar;
            if (lua_getstack(co, 0, &ar) > 0)  /* does it have frames? */
                lua_pushliteral(L, "normal");  /* it is running */
            else if (lua_gettop(co) == 0)
                lua_pushliteral(L, "dead");
            else
                lua_pushliteral(L, "suspended");  /* initial state */
            break;
        }
        default:  /* some error occurred */
            lua_pushliteral(L, "dead");
            break;
        }
    }
    return 1;
};


static int luaB_yieldable(lua_State* L) {
    lua_pushboolean(L, lua_isyieldable(L));
    return 1;
};


static int luaB_corunning(lua_State* L) {
    int ismain = lua_pushthread(L);
    lua_pushboolean(L, ismain);
    return 2;
};

static const luaL_Reg co_funcs[] = {
  {"create", luaB_cocreate},
  {"resume", luaB_coresume},
  {"running", luaB_corunning},
  {"status", luaB_costatus},
  {"wrap", luaB_cowrap},
  {"yield", luaB_yield},
  {"isyieldable", luaB_yieldable},
  {NULL, NULL}
};

LUAMOD_API int luaopen_coroutines(lua_State* L) {
    luaL_newlib(L, co_funcs);
    return 1;
};


const char* LUA = R"(
 mylib = require 'mylib'
 function foo()
   print("foo")
 end
thread4 = mylib.create(function(a, b)
    local c = a+b
    coroutine.yield()
    return c
end)

mylib.resume(thread4, 1, 2)
print(mylib.resume(thread4))

)";
int main(int argc, char* argv[]) {
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);

    luaL_requiref(L, "mylib", luaopen_coroutines, 1);
    checkerror(L, LUA);

    lua_close(L);
    return 0;
};

Вариант 2.

static lua_State* getco(lua_State* L) {
    lua_State* L1 = lua_tothread(L, 1);
    luaL_argcheck(L, L1, 1, "thread expected");
    return L1;
};

static int auxresume(lua_State* L, lua_State* L1, int narg) {
    int status;
    if (!lua_checkstack(L1, narg)) {
        lua_pushliteral(L, "too many arguments to resume");
        return -1;  /* error flag */
    }
    if (lua_status(L1) == LUA_OK && lua_gettop(L1) == 0) {
        lua_pushliteral(L, "cannot resume dead coroutine");
        return -1;  /* error flag */
    }
    lua_xmove(L, L1, narg);
    status = lua_resume(L1, L, narg);
    if (status == LUA_OK || status == LUA_YIELD) {
        int nres = lua_gettop(L1);
        if (!lua_checkstack(L, nres + 1)) {
            lua_pop(L1, nres);  /* remove results anyway */
            lua_pushliteral(L, "too many results to resume");
            return -1;  /* error flag */
        }
        lua_xmove(L1, L, nres);  /* move yielded values */
        return nres;
    }
    else {
        lua_xmove(L1, L, 1);  /* move error message */
        return -1;  /* error flag */
    }
};


static int coresume(lua_State* L) {
    lua_State* L1 = getco(L);
    int r = auxresume(L, L1, lua_gettop(L) - 1);
    if (r < 0) {
        lua_pushboolean(L, 0);
        lua_insert(L, -2);
        return 2;  /* return false + error message */
    }
    else {
        lua_pushboolean(L, 1);
        lua_insert(L, -(r + 1));
        return r + 1;  /* return true + 'resume' returns */
    }
};


static int wrap(lua_State* L) {
    lua_State* L2 = lua_tothread(L, lua_upvalueindex(1));
    int r = auxresume(L, L2, lua_gettop(L));
    if (r < 0) {
        if (lua_type(L, -1) == LUA_TSTRING) {  /* error object is a string? */
            luaL_where(L, 1);  /* add extra info */
            lua_insert(L, -2);
            lua_concat(L, 2);
        }
        return lua_error(L);  /* propagate error */
    }
    return r;
};

static int cocreate(lua_State* L) {
    luaL_checktype(L, 1, LUA_TFUNCTION);
    lua_State* L2 = lua_newthread(L);
    lua_pushvalue(L, 1);  /* move function to top */
    lua_xmove(L, L2, 1);  /* move function from L to NL */
    return 1;
};

static int cowrap(lua_State* L) {
    cocreate(L);
    lua_pushcclosure(L, cowrap, 1);
    return 1;
};

static int coyield(lua_State* L) {
    return lua_yield(L, lua_gettop(L));
};

static int costatus(lua_State* L) {
    lua_State* L1 = getco(L);
    if (L == L1) lua_pushliteral(L, "running");
    else {
        switch (lua_status(L1)) {
        case LUA_YIELD:
            lua_pushliteral(L, "suspended");
            break;
        case LUA_OK: {
            lua_Debug ar;
            if (lua_getstack(L1, 0, &ar) > 0)  /* does it have frames? */
                lua_pushliteral(L, "normal");  /* it is running */
            else if (lua_gettop(L1) == 0)
                lua_pushliteral(L, "dead");
            else
                lua_pushliteral(L, "suspended");  /* initial state */
            break;
        }
        default:  /* some error occurred */
            lua_pushliteral(L, "dead");
            break;
        }
    }
    return 1;
};

static int coyieldable(lua_State* L) {
    lua_pushboolean(L, lua_isyieldable(L));
    return 1;
};

static int corunning(lua_State* L) {
    int ismain = lua_pushthread(L);
    lua_pushboolean(L, ismain);
    return 2;
};

const char* LUA = R"(
th = create(function(a, b)
    local c = a+b
   print("a = "..a.." b = "..b)
    coroutine.yield()
    return c
end)

co, res = resume(th, 1, 2)
print("status = "..tostring(co).." res = ".. tostring(res))

co, res = resume(th)
print("status = "..tostring(co).." res = ".. tostring(res))

co, res = resume(th)
print("status = "..tostring(co).." res = ".. tostring(res))

)";
int main(int argc, char* argv[]) {
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    lua_register(L, "create", cocreate);
    lua_register(L, "resume", coresume);
    checkerror(L, LUA);

    lua_close(L);
    return 0;
};

Вариант 3.

static lua_State* getthread(lua_State* L) {
    lua_State* L1 = lua_tothread(L, 1);
    luaL_argcheck(L, L1, 1, "thread expected"); /*void luaL_argcheck(lua_State * L, int cond,
    int arg, const char* extramsg); Проверяет истинно ли условие cond. Если это не так, выдает ошибку
    со стандартным сообщением об ошибке(смотрите luaL_argerror).*/
    return L1;
};

static int checkresume(lua_State* L, lua_State* L1, int narg) {
    int status;
    if (!lua_checkstack(L1, narg)) {/*Гарантирует, что в стеке есть хотя бы свободные слоты стека.
        Он возвращает false, если не может увеличить стек до этого размера. Эта функция никогда не сжимает стек;
        если стек уже больше нового размера, он остается без изменений.*/
        lua_pushliteral(L, "too many arguments to resume");/*Этот макрос эквивалентен lua_pushlstring, но может
         использоваться только тогда, когда sявляется литеральной строкой. В этих случаях он автоматически
         предоставляет длину строки. */
        return -1;  /* error flag */
    }
    if (lua_status(L1) == LUA_OK && lua_gettop(L1) == 0) {
        lua_pushliteral(L, "cannot resume dead coroutine");
        return -1;  /* error flag */
    }
    lua_xmove(L, L1, narg);
    status = lua_resume(L1, L, narg);
    if (status == LUA_OK || status == LUA_YIELD) {
        int nres = lua_gettop(L1);
        if (!lua_checkstack(L, nres + 1)) {
            lua_pop(L1, nres);  /* remove results anyway */
            lua_pushliteral(L, "too many results to resume");
            return -1;  /* error flag */
        }
        lua_xmove(L1, L, nres);  /* move yielded values */
        return nres;
    }
    else {
        lua_xmove(L1, L, 1);  /* move error message */
        return -1;  /* error flag */
    }
};

static int coresume(lua_State* L) {
    lua_State* L1 = getthread(L);
    int r = checkresume(L, L1, lua_gettop(L) - 1);
    if (r < 0) {
        lua_pushboolean(L, 0);
        lua_insert(L, -2);
        return 2;  /* return false + error message */
    }
    else {
        lua_pushboolean(L, 1);
        lua_insert(L, -(r + 1));
        return r + 1;  /* return true + 'resume' returns */
    }
};




static int cocreate(lua_State* L) {
    luaL_checktype(L, 1, LUA_TFUNCTION);
    lua_State* L2 = lua_newthread(L);
    lua_pushvalue(L, 1);  /* move function to top */
    lua_xmove(L, L2, 1);  /* move function from L to NL */
    return 1;
};

static int coyield(lua_State* L) {
    return lua_yield(L, lua_gettop(L));
};




const char* LUA = R"(
th = create(function(a, b)
    local c = a+b
   print("a = "..a.." b = "..b)
    coroutine.yield()
    return c
end)

co, res = resume(th, 1, 2)
print("status = "..tostring(co).." res = ".. tostring(res))

co, res = resume(th)
print("status = "..tostring(co).." res = ".. tostring(res))

co, res = resume(th)
print("status = "..tostring(co).." res = ".. tostring(res))

)";
int main(int argc, char* argv[]) {
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    lua_register(L, "create", cocreate);
    lua_register(L, "resume", coresume);
    checkerror(L, LUA);

    lua_close(L);
    return 0;
};




Копирование стека и создания нового состояния.
lua_State* copystack(lua_State* L) {
    lua_State* L1 = luaL_newstate();
    int stacksize = lua_gettop(L);
    stacksize++;
    for (int i = 1; i < stacksize; i++) {
        lua_pushvalue(L, i);// копировать на вершину стека.
        lua_xmove(L, L1, 1);// Снимает с L1 элементов передает L.
    };
    return L1;
};
int main(int argc, char* argv[]) {

    lua_State* L = luaL_newstate();
    luaL_openlibs(L);
    for (int i = 1; i < 8; i++) {
        pushlua(L, i*2);    }

    showstack(L);
    lua_State* L1 = copystack(L);
    showstack(L1);
    showstack(L);

    lua_close(L1);
    lua_close(L);
    return 0;
};




Копирование стека между потоками.

lua_State* copystack(lua_State* L) {
    int stacksize = lua_gettop(L);
    stacksize++;
    for (int i = 1; i < stacksize; i++){lua_pushvalue(L, i);
    }

    lua_State* L1 = lua_newthread(L);
    lua_insert(L, 1); stacksize--;
    lua_xmove(L, L1, stacksize);// Снимает с L1 элементов передает L.
    return L1;
};
int main() {
    lua_State* L = luaL_newstate();
    luaL_openlibs(L);
    for (int i = 1; i < 5; i++){pushlua(L, i);
    }

    showstack(L);
    lua_State* L1 = copystack(L);
    showstack(L);
    showstack(L1);

    lua_close(L);
    return 0;
};

Вариант 2.
lua_State* copystack(lua_State* L) {
    lua_State* L1 = lua_newthread(L);
    lua_insert(L, 1);
    int stacksize = lua_gettop(L);
    stacksize++;
    for (int i = 1; i < stacksize; i++) {
        lua_pushvalue(L, i);// копировать на вершину стека.
        lua_xmove(L, L1, 1);// Снимает с L1 элементов передает L.
    };
    lua_remove(L1, 1);//удалить по индексу из стека.
    return L1;
};

const char* LUA = R"(
foo()
)";
const char* LUA1 = R"(
foo1()
)";
int f(lua_State* L) {
    cout << "hi foo c++" << endl;
    return 0;
};
int f1(lua_State* L) {
    for (int i = 0; i < 10; i++)    {
        cout << i << endl;
    }
    return 0;
};

int main(int argc, char* argv[]) {

    lua_State* L = luaL_newstate();
    luaL_openlibs(L);
    lua_register(L, "foo", f);
    lua_register(L, "foo1", f1);

    lua_State* L1 = copystack(L);

    thread th(checkerror, L1, LUA1);
    checkerror(L, LUA);
    th.join();
    lua_close(L);
    return 0;
};

lua_State* movetostack(lua_State* L, lua_State* L1) {
    int stacksize = lua_gettop(L);
    stacksize++;
    for (int i = 1; i < stacksize; i++) {
        if ( LUA_TTHREAD ==lua_type(L, i) )
        {
            continue;
        }
        lua_pushvalue(L, i);// копировать на вершину стека.
        lua_xmove(L, L1, 1);// Снимает с L1 элементов передает L.
    };
    return L1;
};
Поход ооп.

struct state{
    lua_State* L=NULL;
    state() {
        lua_State* L1 = luaL_newstate();
        luaL_openlibs(L1);
         this->L = L1;
        cout << L << endl;
}
    lua_State* get(){
        this->L = L;
        return L;
    }
~state(){
    cout << "dec state " << L << endl;
    lua_close(L);
    }
};

int main(int argc, char* argv[]) {
    state Lua;
    lua_State* L = Lua.get();

    cout << L << endl;
    return 0;
};

lua_State* copystack(lua_State* L);
int newthread(lua_State* L) {// новый поток
//  if (LUA_TSTRING == lua_type(L, -1)){
    //  CMessages::AddMessageJumpQ(L"Create", 4000, 1);//выводит сообщение на экран
    CWorld::Players[CWorld::PlayerInFocus].m_nMoney += 100;// дать денег
//  }
    //char const* funs = Stack<char const*>::get(L, 1);
    //lua_getglobal(L, funs);
    //  LUA_TFUNCTION == lua_type(L, -1))
    return 0;
};

lua_State* copystack(lua_State* L) {
    lua_State* L1 = luaL_newstate();
    luaL_openlibs(L1);
    int stacksize = lua_gettop(L);
    stacksize++;
    for (int i = 1; i < stacksize; i++) {
        lua_pushvalue(L, i);// копировать на вершину стека.
        lua_xmove(L, L1, 1);// Снимает с L1 элементов передает L.
    };
    return L1;
};


alignas - это новая штука с с++11 стандарта и предназначена, чтобы устаканить то, что творится в разных компиляторах. Чтобы не говорили разработчики других языков, но иногда нужно писать немножко низкоуровневого кода, чтобы получить существенный плюс в скорости.
Как известно, процессоры лучше работают с данными в памяти, если они выровнены по границе в 4/8/16 байт. А в некоторых случаях данные обязаны быть выровнены (например, с некоторыми SSE командами и на некоторых ARM процессорах).
Что такое выравнивание по границе? Это просто адрес, который кратен заданной степени двойки. То есть, адрес 24 выровнен по границе 2, 4, 8, но не 16. Адрес 1024 выровнен по 2, 4, 8, 16, 32 и многим другим. Можно сказать и по-другому - адрес, выровненный по границе 16 в бинарном виде заканчивается на 4 нуля.
alignas как раз и заставляет компилятор сделать это выравнивание. Да, часто это идет в ущерб памяти (появляются пустоты), но в некоторых случаях (с SSE) можно получить двукратный прирост просто по той причине, что адрес выровнен по границе 16/32. Почему так происходит? Все просто - современные процессоры уже давно не загружают данные по байту из памяти - они обычно грузят как минимум по 4 байта сразу, более того, грузят по выровненным адресам по границе 4. И если нужно загрузить 4 невыровненных байта, то процессору приходится делать это в три этапа - загружаем первые байт (но при этом загружаем 4 байта), потом загружаем вторую половину, а потом складываем в памяти. А так как операция обращения к памяти - медленная - это длится достаточно долго.
Нужно ли в своем коде постоянно писать выравнивание? Нет, не нужно. Компиляторы достаточно умные и сами могут догадаться. Но есть случаи, когда это лучше сделать.
переменная используется для SSE/MMX.
переменная-массив, достаточно большого размера, по которому нужно будет много итерироваться (бегать).
числодробилки.
Почему расстояние равно 2016, а без него 24?
а на ideone вообще получилось -252:)
alignas говорит "выровняй", а как именно разместить в памяти - это другое дело. В Вашем случае компилятор вначале разместил первую переменную по адресу кратному 16. Вторую, нужно разместить по адресу кратному 1024. Логично, что такое может быть как сразу (потому что первая переменная занимает ровно 16 байт, так и через много-много байт (мы же не знаем адреса первой переменной).
Многие компиляторы в отладочном режиме за массивами всегда добавляют несколько байт - для того, что бы препятствовать классическому выходу за пределы массива на один элемент. Поэтому, чтобы понять, почему там именно 2016 - нужно смотреть в конкретную версию компилятора и параметры компиляции.




int main(int argc, char *argv[]) {
    lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    int *i= NULL;
    lua_pushnumber(L, 10);// отправить в стек число.
    lua_pushstring(L, "yes");
    cout <<  lua_tonumberx(L, 2, i) << endl;// если в позиции не число, то вернет 0.
    /* i булевое значение. */

 cout << i << endl;
    lua_close(L);// закрыть состояние
    cin.get();//ожидает ввода символа программа завершается.

    return 0;
}

    lua_pushstring(L, "yes");
    size_t len;// len длина строки.
    const char *s = lua_tolstring(L, -1, &len);
    cout << s<<"\n " << endl;
    cout << len << endl;


    lua_pushstring(L, "yes");
    lua_copy(L, -1, -2);//копировать из одной позиции в другую.
    cout << lua_tostring(L, -2);



//эта функция берет значение из стека (по индексу -1),
            //и использует его в качестве ключа для поиска по таблице, которая
            //находится в стеке по индексу i, в случае если находит, добавляет в
            //стек пару ключ - значение, следующие в таблице после ключа находившегося в стеке
            //если больше нет значений, ф-я возвращает 0
            //lua_next используется для перебора элементов таблицы

    int n = lua_gettop(L);/* получаем количество элементов в стеке.*/
    cout <<"\nthe number on the stack = "  << n<<"\n";
    lua_settop(L, 0);// уст кол-во элементов в стеке. 0 - очистить стек.

    for (int i = 1; i <= n; ++i) {
        cout << lua_typename(L, i) << endl; }




int main(int argc, char *argv[]) {

    lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);        /* opens the standard libraries */

    char buff[256];
    int error;

    while (fgets(buff, sizeof(buff), stdin) != NULL) {
        error = luaL_loadstring(L, buff) || lua_pcall(L, 0, 0, 0);
        if (error) {
            fprintf(stderr, "%s\n", lua_tostring(L, -1));
            lua_pop(L, 1);  /* pop error message from the stack */
        }
    }

    lua_close(L);// закрыть состояние
    cin.get();//ожидает ввода символа программа завершается.

    return 0;
}






      int getglobint (lua_State *L, const char *var) {
        int isnum, result;
        lua_getglobal(L, var);
        result = (int)lua_tointegerx(L, -1, &isnum);
        if (!isnum)
          error(L, "'%s' should be a number\n", var);
        lua_pop(L, 1);   /* remove result from the stack */
        return result;
      }

      void load (lua_State *L, const char *fname, int *w, int *h) {
        if (luaL_loadfile(L, fname) || lua_pcall(L, 0, 0, 0))
          error(L, "cannot run config. file: %s", lua_tostring(L, -1));
        *w = getglobint(L, "width");
        *h = getglobint(L, "height");
      }




  BLUE = {red = 0, green = 0, blue = 1.0}
      other color definitions

      background = BLUE


        lua_getglobal(L, "background");
        if (!lua_istable(L, -1))
          error(L, "'background' is not a table");

        red = getcolorfield(L, "red");
        green = getcolorfield(L, "green");
        blue = getcolorfield(L, "blue");

  /* assume that table is on the top of the stack */
      int getcolorfield (lua_State *L, const char *key) {
        int result, isnum;
        lua_pushstring(L, key);  /* push key */
        lua_gettable(L, -2);  /* get background[key] */
        result = (int)(lua_tonumberx(L, -1, &isnum) * MAX_COLOR);
        if (!isnum)
          error(L, "invalid component '%s' in color", key);
        lua_pop(L, 1);  /* remove number */
        return result;
      }
  struct ColorTable {
        char *name;
        unsigned char red, green, blue;
      } colortable[] = {
        {"WHITE",   MAX_COLOR, MAX_COLOR, MAX_COLOR},
        {"RED",     MAX_COLOR,         0,         0},
        {"GREEN",           0, MAX_COLOR,         0},
        {"BLUE",            0,         0, MAX_COLOR},
        other colors
        {NULL, 0, 0, 0}  /* sentinel */
      };

  WHITE = {red = 1.0, green = 1.0, blue = 1.0}
      RED   = {red = 1.0, green = 0,   blue = 0}

     /* assume that table is on top */
      void setcolorfield (lua_State *L, const char *index, int value) {
        lua_pushstring(L, index); /* key */
        lua_pushnumber(L, (double)value / MAX_COLOR);  /* value */
        lua_settable(L, -3);
      }

      void setcolor (lua_State *L, struct ColorTable *ct) {
        lua_newtable(L);                 /* creates a table */
        setcolorfield(L, "red", ct->red);
        setcolorfield(L, "green", ct->green);
        setcolorfield(L, "blue", ct->blue);
        lua_setglobal(L, ct->name);      /* 'name' = table */
      }


      int i = 0;
      while (colortable[i].name != NULL)
        setcolor(L, &colortable[i++]);


      void call_va (lua_State *L, const char *func,
                                  const char *sig, ...) {
        va_list vl;
        int narg, nres;  /* number of arguments and results */

        va_start(vl, sig);
        lua_getglobal(L, func);  /* push function */

        push and count arguments (Figure 28.6, “Pushing arguments for the generic call function”)

        nres = strlen(sig);  /* number of expected results */

        if (lua_pcall(L, narg, nres, 0) != 0)  /* do the call */
          error(L, "error calling '%s': %s", func,
                                             lua_tostring(L, -1));

        retrieve results (Figure 28.7, “Retrieving results for the generic call function”)

        va_end(vl);
      }
Figure 28.6. Pushing arguments for the generic call function
        for (narg = 0; *sig; narg++) {  /* repeat for each argument */

          /* check stack space */
          luaL_checkstack(L, 1, "too many arguments");

          switch (*sig++) {

            case 'd':  /* double argument */
              lua_pushnumber(L, va_arg(vl, double));
              break;

            case 'i':  /* int argument */
              lua_pushinteger(L, va_arg(vl, int));
              break;

            case 's':  /* string argument */
              lua_pushstring(L, va_arg(vl, char *));
              break;

            case '>':  /* end of arguments */
              goto endargs;  /* break the loop */

            default:
              error(L, "invalid option (%c)", *(sig - 1));
          }

        }
        endargs: Extending Your Application
245
Figure 28.7. Retrieving results for the generic call function
        nres = -nres;  /* stack index of first result */
        while (*sig) {  /* repeat for each result */
          switch (*sig++) {

            case 'd': {  /* double result */
              int isnum;
              double n = lua_tonumberx(L, nres, &isnum);
              if (!isnum)
                error(L, "wrong result type");
              *va_arg(vl, double *) = n;
              break;
            }

            case 'i': {  /* int result */
              int isnum;
              int n = lua_tointegerx(L, nres, &isnum);
              if (!isnum)
                error(L, "wrong result type");
              *va_arg(vl, int *) = n;
              break;
            }

            case 's': {  /* string result */
              const char *s = lua_tostring(L, nres);
              if (s == NULL)
                error(L, "wrong result type");
              *va_arg(vl, const char **) = s;
              break;
            }

            default:
              error(L, "invalid option (%c)", *(sig - 1));
          }
          nres++;
        }




function is minimal:
      static int l_sin (lua_State *L) {
        double d = luaL_checknumber(L, 1);
        lua_pushnumber(L, sin(d));
        return 1;  /* number of results */
      }
      static int l_dir (lua_State *L) {
        DIR *dir;
        struct dirent *entry;
        int i;
        const char *path = luaL_checkstring(L, 1);

        /* open directory */
        dir = opendir(path);
        if (dir == NULL) {  /* error opening the directory? */
          lua_pushnil(L);  /* return nil... */
          lua_pushstring(L, strerror(errno));  /* and error message */
          return 2;  /* number of results */
        }

        /* create result table */
        lua_newtable(L);
        i = 1;
        while ((entry = readdir(dir)) != NULL) {  /* for each entry */
          lua_pushinteger(L, i++);  /* push key */
          lua_pushstring(L, entry->d_name);  /* push value */
          lua_settable(L, -3);    /* table[i] = entry name */
        }

        closedir(dir);
        return 1;  /* table is already on top */
      }

static int l_dir (lua_State *L) {
         as before
      }
      static const struct luaL_Reg mylib [] = {
        {"dir", l_dir},
        {NULL, NULL}  /* sentinel */
      };


      int luaopen_mylib (lua_State *L) {
        luaL_newlib(L, mylib);
        return 1;
      }
      local mylib = require "mylib"

      int l_map (lua_State *L) {
        int i, n;

        /* 1st argument must be a table (t) */
        luaL_checktype(L, 1, LUA_TTABLE);

        /* 2nd argument must be a function (f) */
        luaL_checktype(L, 2, LUA_TFUNCTION);

        n = luaL_len(L, 1);  /* get size of table */

        for (i = 1; i <= n; i++) {
          lua_pushvalue(L, 2);   /* push f */
          lua_geti(L, 1, i);  /* push t[i] */
          lua_call(L, 1, 1);     /* call f(t[i]) */
          lua_seti(L, 1, i);  /* t[i] = result */
        }

        return 0;  /* no results */
      }

static int l_split (lua_State *L) {
        const char *s = luaL_checkstring(L, 1);      /* subject */
        const char *sep = luaL_checkstring(L, 2);  /* separator */
        const char *e;
        int i = 1;

        lua_newtable(L);  /* result table */

        /* repeat for each separator */
        while ((e = strchr(s, *sep)) != NULL) {
          lua_pushlstring(L, s, e - s);  /* push substring */
          lua_rawseti(L, -2, i++);   /* insert it in table */
          s = e + 1;  /* skip separator */
        }

        /* insert last substring */
        lua_pushstring(L, s);
        lua_rawseti(L, -2, i);

        return 1;  /* return the table */
      }

      static int str_upper (lua_State *L) {
        size_t l;
        size_t i;
        luaL_Buffer b;
        const char *s = luaL_checklstring(L, 1, &l);
        char *p = luaL_buffinitsize(L, &b, l);
        for (i = 0; i < l; i++)
          p[i] = toupper(uchar(s[i]));
        luaL_pushresultsize(&b, l);
        return 1;
      }
static int tconcat (lua_State *L) {
        luaL_Buffer b;
        int i, n;
        luaL_checktype(L, 1, LUA_TTABLE);
        n = luaL_len(L, 1);
        luaL_buffinit(L, &b);
        for (i = 1; i <= n; i++) {
          lua_geti(L, 1, i);  /* get string from table */
          luaL_addvalue(b);   /* add it to the buffer */
        }
        luaL_pushresult(&b);
        return 1;
      }

Статические переменные это реестр.
   /* store a string */
      lua_pushlightuserdata(L, (void *)&Key);  /* push address */
      lua_pushstring(L, myStr);  /* push value */
      lua_settable(L, LUA_REGISTRYINDEX);  /* registry[&Key] = myStr */

      /* retrieve a string */
      lua_pushlightuserdata(L, (void *)&Key);  /* push address */
      lua_gettable(L, LUA_REGISTRYINDEX);  /* retrieve value */
      myStr = lua_tostring(L, -1);  /* convert to string */
We will discuss light userdata in more detail in the section called “Light Userdata”.
To  simplify  the  use  of  variable  addresses  as  unique  keys,  Lua  5.2  introduced  two  new  functions:
lua_rawgetp and lua_rawsetp. They are similar to lua_rawgeti and lua_rawseti, but they
use C pointers (translated to light userdata) as keys. With them, we can write the previous code like this:
      static char Key = 'k';

      /* store a string */
      lua_pushstring(L, myStr);
      lua_rawsetp(L, LUA_REGISTRYINDEX, (void *)&Key);

      /* retrieve a string */
      lua_rawgetp(L, LUA_REGISTRYINDEX, (void *)&Key);
      myStr = lua_tostring(L, -1);
int t_tuple (lua_State  *L) {
        int op  =   luaL_optint(L,  1,  0);
        if  (op ==  0)  {   /*  нет  аргументов?   */
                int i;
                /*  заталкивает  каждое    допустимое    верхнее  значение    в  стек    */
                for (i  =   1;  !lua_isnone(L,  lua_upvalueindex(i));   i++)
                        lua_pushvalue(L,    lua_upvalueindex(i));
                return  i   -   1;  /*  число  значений    в  стеке  */
        }
        else    {   /*  получает    поле    'op'    */
                luaL_argcheck(L,    0   <   op, 1,  "index  out of  range");
                if  (lua_isnone(L,  lua_upvalueindex(op)))
                        return  0;  /*  такого    поля    нет  */
                lua_pushvalue(L,    lua_upvalueindex(op));
                return  1;
        }
} int   t_new   (lua_State  *L) {
        lua_pushcclosure(L, t_tuple,    lua_gettop(L));
        return  1;
}
static  const   struct  luaL_Reg    tuplelib    []  =   {
        {"new", t_new},
        {NULL,  NULL}
};
int luaopen_tuple   (lua_State  *L) {
        luaL_newlib(L,  tuplelib);
        return  1;




INT lua_next ( lua_State * L, INT индекс);
получает ключ из стека и отправляет пару ключ-значение из таблицы по заданному индексу («следующая» пара после заданного ключа). Если в таблице больше нет элементов. Ключ имеет -2, а значение -1.

 lua_next возвращается 0 (и ничего не выдвигается).
Типичный обход выглядит так:
     / * таблица находится в стеке с индексом 't' * /
     lua_pushnil (L); / * первый ключ * /
     while (lua_next (L, t)! = 0) {
       / * использует 'ключ' (в индексе -2) и 'значение' (в индексе -1) * /
       printf ("% s -% s \ n",
              lua_typename (L, lua_type (L, -2)),
              lua_typename (L, lua_type (L, -1)));
       / * удаляет «значение»; держит «ключ» для следующей итерации * /
       lua_pop (L, 1);
     }
При обходе таблицы не вызывайте lua_tolstringнапрямую ключ, если только вы не знаете, что ключ на самом деле является строкой. Напомним, что изменяется значение по заданному индексу; это смущает следующий звонок . lua_tolstring lua_next

недействительными * lua_newuserdata ( lua_State * L, size_t размера);
Эта функция выделяет новый блок памяти с заданным размером, помещает в стек новые полные пользовательские данные с адресом блока и возвращает этот адрес.
Пользовательские данные представляют значения C в Lua. Полный UserData представляет собой блок памяти. Это объект (например, таблица): вы должны создать его, у него может быть свой собственный метатабль, и вы можете определить, когда он собирается. Полные пользовательские данные равны только себе (при необработанном равенстве).
Когда Lua собирает полные данные пользователя с gcметаметодом, Lua вызывает метаметод и помечает данные пользователя как завершенные. Когда эти пользовательские данные собираются снова, Lua освобождает соответствующую память.
недействительный lua_pushlightuserdata ( lua_State * L, недействительный * р);
Помещает легкие пользовательские данные в стек.
Пользовательские данные представляют значения C в Lua. Свет UserData представляет собой указатель. Это значение (например, число): вы не создаете его, у него нет индивидуального метатабора, и оно не собирается (как оно никогда не создавалось). Легкие пользовательские данные равны «любым» легким пользовательским данным с тем же C-адресом.

недействительными * lua_touserdata ( lua_State * L, INT индекс);
Если значение в данном приемлемом индексе является полными данными пользователя, возвращает адрес его блока. Если значение является легким userdata, возвращает его указатель. В противном случае возвращается NULL.


    //cout << lua_tostring(lua, 1)<< endl;
    lua_assert(lua_isstring);
    lua_pop(lua, 1);// удалить n элементы из стека.


cout << "\t " << lua_tostring(L, -4) << endl;
    cout << "\t " << lua_toboolean(L, -3) << endl;
    cout << "\t " << lua_tonumber(L, -2) << endl;
    cout << "\t " << lua_tonumber(L, -1) << endl;*/

static void stackDump(lua_State *L) {
    int i;
    int top = lua_gettop(L); /* глубина стека */
    for (i = 1; i <= top; i++) { /* повторить для каждого уровня */
        int t = lua_type(L, i); switch (t) {
        case LUA_TSTRING: { /* strings */ printf("'%s' ", lua_tostring(L, i)); break;   }
        case LUA_TBOOLEAN: { /* booleans */
            printf(lua_toboolean(L, i) ? "true " : "false "); break;
        case LUA_TNUMBER: { /* numbers */ printf("%g ", lua_tonumber(L, i)); break; }

        default: { /* other values */
            printf("%s ", lua_typename(L, t)); break;  }
                 printf(" "); /* put a separator */     }       }
    }
    printf("\n"); /* end the listing */
    return;
}
int main(int argc, char *argv[]) {

    lua_State *L = luaL_newstate();
    luaL_openlibs(L);//открыть все стандартные библиотеки lua.
    luaL_dofile(L, "main.lua");// Загружает и запускает заданный файл. Файл в котором все происходит.
    lua_pushboolean(L, 1);
    lua_pushnumber(L, 10);
    lua_pushnil(L);
    lua_pushstring(L, "hello");
    stackDump(L);   /* true 10 nil 'hello' */
    lua_pushvalue(L, -4);// копировать элемент в стеке -1.
    stackDump(L);   /* true 10 nil 'hello' true */
    lua_replace(L, 3);// снимает значение с вершины стека и устанавливает его как значение элемента с заданным индексом.
    stackDump(L);   /* true 10 true 'hello' */
    lua_settop(L, 6);
    stackDump(L);   /* true 10 true 'hello' nil nil */
    lua_remove(L, -3);
    stackDump(L);/* true 10 true nil nil */
    lua_settop(L, -5);
    stackDump(L);   /* true */

    lua_close(L);// закрыть состояние
    cin.get();//ожидает ввода символа программа завершается.
    return 0;
}


int main(int argc, char *argv[]) {
constexpr char* LUA_FILE = R"(
  function Return4()
   return 4
 end
  )";
        lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
        luaL_dostring(L, LUA_FILE);
        lua_getglobal(L, "Return4");

        if (lua_iscfunction(L, -1)) {

            lua_pcall(L, 0, 1, 0);

            lua_Number number = lua_tonumber(L, -1);// получить 10 из стека 1
            cout << (int)number << endl;
        }
        lua_close(L);

return 0;
}


#include<iostream>
#include<string>
#include <stdio.h>
#include <string>
#include"lua/lua.hpp"
using namespace std;

int main(int argc, char *argv[]) {
lua_State *lua = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией
 выделения памяти на основе стандартной функции C realloc и затем устанавливает "тревожную" (panic) функцию,
 которая печатает сообщение об ошибке к стандартному выводу ошибки в случае фатальных (неустранимых) ошибок.
 Возвращает новое состояние или значение NULL, если есть ошибка выделения памяти.*/
    luaL_dostring(lua, "x = 2");/*отправляет строку- переменную = 2 в стек. Функция определяется как следующий макрос */
    lua_getglobal(lua, "x");// получить значение x
    if (lua_isnumber(lua, 1)) {//  если 1 позиция в стеке число.
        int number = lua_tonumber(lua, 1);
        cout <<"x = "<< number;
    }
    return 0;
}
    lua_pushcfunction(L, getst);//уст указатель на функцию C++ и создает внутри Lua
    lua_setglobal(L, "getst"); //получает значение из стека и уст значение global name.
    luaL_dofile(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
    //lua_pcall(L, 0, 0, 0);// вызов функции в lua файле.

#include<iostream>
#include"lua/lua.hpp"
using namespace std;
int main() {
    lua_State *lua = luaL_newstate();
    luaL_openlibs(lua);//открыть все стандартные библиотеки lua.
    luaL_dofile(lua, "main.lua");// Загружает и запускает заданный файл. Файл в котором все происходит.
    lua_pcall(lua, 0, 0, 0);// вызов функции в lua файле.  1 параметр кол-во передаваемых, кол-во возвращаемых, обработчик ошибок.

    lua_close(lua);// закрыть состояние
    cin.get();//ожидает ввода символа программа завершается.

    return 0;
}
lua
--print(2362)




int lua_sq(lua_State *L) {// передаем указатель на состояние.
    int x = lua_tonumber(L, 1); // получаем 1 элемент из стека.
    lua_pushnumber(L, x*x);// умножаем x и отправляет в стек.
    return 1;// вернуть 1.
}
int main() {
    lua_State *L = luaL_newstate();
    luaL_openlibs(L);//открыть все стандартные библиотеки lua.
    lua_register(L, "sq", lua_sq);// регистрируем функцию- имя состояние, имя функ в lua, имя функ тут.
    luaL_dofile(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
    lua_pcall(L, 0, 0, 0);// вызов функции, передаем 2 параметра, возвращаем 1.
    lua_close(L);// закрыть состояние
    cin.get();//ожидает ввода символа программа завершается.
return 0;}

на Lua.

print(sq(2))

struct st
{
    int x;

};

int getst(lua_State *L) {// передаем указатель на состояние
    st* sp = (st*)lua_newuserdata(L, sizeof(sp));// выделяет памяти с заданным размером,
    //помещает в стек пользовательские данныеа и возвращает этот адрес.
    int x1;
    if (lua_isnumber(L, 1)) {//  если 1 позиция в стеке число.
         x1 = lua_tonumber(L, 1);} // получаем 1 элемент из стека.
    else x1 = 0;// что мы передим в getst(2), то будет в структуре
    sp->x = x1;
    return 1;// вернуть 1.
}
int main() {
    lua_State *L = luaL_newstate();
    luaL_openlibs(L);//открыть все стандартные библиотеки lua.
    lua_pushcfunction(L, getst);//уст указатель на функцию C++ и создает внутри Lua
    lua_setglobal(L, "getst"); //получает значение из стека и уст значение global name.
    luaL_dofile(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
    //lua_pcall(L, 0, 0, 0);// вызов функции в lua файле.
    lua_getglobal(L, "sp");// получить значение глобальной переменной.
    st* sp = (st*)lua_touserdata(L, -1);// получить значение поля структруры из стека.
    cout << sp->x  << endl;//
    lua_close(L);// закрыть состояние
    cin.get();//ожидает ввода символа программа завершается.
return 0;}

lua
sp=getst()
print(sp)—адрес памяти выводится



#include<iostream>
#include<string>
#include <stdio.h>
#include"lua/lua.hpp"
using namespace std;

int main() {
    lua_State *L = luaL_newstate();
    luaL_openlibs(L);//открыть все стандартные библиотеки lua.
       luaL_dofile(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
    //lua_pcall(L, 0, 0, 0);// вызов функции в lua файле.
    lua_getglobal(L, "t");// получить значение глобальной переменной, таблица.
    lua_assert(lua_istable(L, 1));// проверить является 1 элемент стека таблицей
    lua_pushstring(L, "x");// отправить ключ x в стек.
    lua_gettable(L, 1);// получить значение по ключу из стека.
    lua_assert(lua_isnumber(L, 2));// проверить является значение 2 элемента стека число.
    int x = lua_tonumber(L, 2);
    lua_getglobal(L, "t");// получить значение глобальной переменной таблица.
    lua_pushstring(L, "y");
    lua_gettable(L, 1);
    lua_assert(lua_isstring(L, 4));
    string y = lua_tostring(L, 4);
    lua_getglobal(L, "t");// получить значение глобальной переменной, таблицей.
    lua_getfield(L, 5, "z");// отправить ключ в таблицу.
    lua_assert(lua_isboolean(L, 5));
    bool z = lua_toboolean(L, 5);// получить булевое значение по ключу.
    lua_getglobal(L, "t");// получить значение глобальной переменной, таблицей.
    lua_pushstring(L, "dog");// отправить значение в таблицу.
    lua_setfield(L, 5, "a");// уст ключ для него.
    lua_getglobal(L, "t");// получить значение глобальной переменной, таблицей.
    lua_getfield(L, 5, "a");// отправить ключ в таблицу.
    lua_assert(lua_isstring(L, 5));
    string a = lua_tostring(L, -1);
    cout <<"x = "<<x <<"\ny = "<<y<<"\nz = "<< z << "\na = " << a <<endl;
    lua_close(L);// закрыть состояние
    cin.get();//ожидает ввода символа программа завершается.
return 0;}
lua

t= {x=23,y="yes",z=true}

struct strlua
{   int x;
strlua(int x){
    this->x = x;
}
void st(int x){
    this->x = x;
}

};
int LUA_new(lua_State *S) {
    strlua *p = new strlua(lua_tonumber(S, 1));
    lua_pushlightuserdata(S,p);
    return 0;
}
int LUA_set(lua_State *S){
  strlua *p = (strlua*)lua_touserdata(S,1);
  p->st(lua_tonumber(S, 1 ));
    return 0;
}
int main() {
    lua_State *S = luaL_newstate();
    luaL_openlibs(S);
    lua_register(S, "new", LUA_new);
    lua_register(S,"set", LUA_set);
    luaL_loadfile(S, "man.lua");
    lua_call(S, 0, 0);
    cin.get();
    return 0;

a=new(2)
b=set(3)
print(a)
print(b)
struct color{ char r,g,b;
};
void LUA_set(lua_State *S, string str, color *& pal) {
    lua_getglobal(S, str.c_str());
    lua_pushstring(S, "co");
    lua_gettable(S, -2);
    lua_call(S, 0, 4);
    pal[0] = *(color*)lua_touserdata(S, -4);
    pal[1] = *(color*)lua_touserdata(S, -3);
    pal[2] = *(color*)lua_touserdata(S, -2);
    pal[3] = *(color*)lua_touserdata(S, -1);
    lua_pop(S, 5);
}
int LUA_make(lua_State *S) {
    color *p = (color*)lua_newuserdata(S, sizeof(color));
    new (p) color;
    p->r = lua_tointeger(S, 1);
    p->g = lua_tointeger(S, 2);
    p->b = lua_tointeger(S, 3);
    return 1;
}
int main() {
    lua_State *S = luaL_newstate();
    luaL_openlibs(S);
    lua_register(S,"make", LUA_set);
    lua_register(S, "make", LUA_make);
    luaL_loadfile(S, "man.lua");
    lua_call(S, 0, 0);
    cin.get();
    return 0;
}

int main() {
    lua_State *l = luaL_newstate();
    luaL_openlibs(l);
    luaL_dofile(l, "man.lua");
    lua_close(l);
    return 0;
}

int main() {
    lua_State *l = luaL_newstate();
    luaL_openlibs(l);
    luaL_dofile(l, "man.lua");
    lua_getglobal(l, "pri");
    lua_pushfstring(l, "lua");
    lua_pushnumber(l, 5);
    lua_pcall(l, 2, 0, 0);
    lua_close(l);
    return 0;
}

Lua

function pri(ms,x)
for i=1,x do
print(ms) end
end

это вызывается в lua.
#include<iostream>
#include<string>
#include <stdio.h>
#include <string>
#include"lua/lua.hpp"
using namespace std;

int main() {
    lua_State *L = luaL_newstate();
    luaL_openlibs(L);//открыть все стандартные библиотеки lua.
    luaL_dofile(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
    lua_getglobal(L, "pri");// имя функции, которую вызываем в main.lua.
    lua_pushnumber(L, 3);// отправляем в стек число.
    lua_pushnumber(L, 5);
    lua_pcall(L, 2, 1, 0);// вызов функции, передаем 2 параметра, возвращаем 1.
    cout << lua_tonumber(L, 1) << endl;// получаем из стека возвращаемое значение из функции.
    lua_close(L);// закрыть состояние

return 0;
}

lua

function pri(x,y)
sum = x+y
return sum
end



struct a {
    int x = 0;
    a() : x() { }//конструктор по умолчанию
    void show() { cout << " x = " << x << endl; }~a() { }//вызов деструктора.
};

int create(lua_State* L) {//    Функция создания объекта структуры.
    void* pointerToAa = lua_newuserdata(L, sizeof(a));/*Эта функция выделяет новый блок памяти с заданным размером,*/
    new (pointerToAa) a();// Выделить память под польз. данные.
    luaL_getmetatable(L, "aMetaTable"); /* отправляет в стек метатаблицу значения при заданном приемлемом индексе.*/
    lua_setmetatable(L, 1);//получает таблицу из стека и уст ее в качестве новой метатаблицы для значения с заданным допустимым индексом.
    return 1;};

int destroy(lua_State* L) {// Функция вызывает деструктор для объекта.
    a* st = (a*)lua_touserdata(L, 1);/* Если значение в данном приемлемом индексе является полными данными пользователя,
    возвращает адрес его блока. Если значение является легким userdata, возвращает его указатель.В противном случае возвращается NULL.*/
    st->~a();//вызов метода деструктор.
    return 0;};

int show(lua_State* L) {
    a* st = (a*)lua_touserdata(L, 1);
    st->show();
    return 0;
};

int index(lua_State* L) {
    a* st = (a*)lua_touserdata(L, 1);
    const char* index = lua_tostring(L, 2);
    if (strcmp(index, "x") == 0) {
        lua_pushnumber(L, st->x);
        return 1;
    }
    else {lua_getglobal(L, "a");
        lua_pushstring(L, index);
        lua_rawget(L, 3);// Аналогично lua_settable, но делает необработанное назначение(т.Е.Без метаметодов).
        return 1;
    }
};

int newindex(lua_State* L) {
    a* st = (a*)lua_touserdata(L, -3);
    const char* index = lua_tostring(L, -2);
    if (strcmp(index, "x") == 0) {
        st->x = (int)lua_tonumber(L, -1);   }
    else { lua_assert(false); }
    return 0;
};

int main() {
    lua_State* L = luaL_newstate();
    lua_newtable(L);
    int stTableIdx = lua_gettop(L);
    lua_pushvalue(L, stTableIdx);// отправляет копию элемента с заданным допустимым индексом в стек.
    lua_setglobal(L, "a");// Установить значение глобальной переменной.
    lua_pushcfunction(L, create);/* отправляет функцию C в стек. функция получает указатель на функцию C и отправляет в стек*/
    lua_setfield(L, 1, "new");
    lua_pushcfunction(L, show);
    lua_setfield(L, 1, "show");
    luaL_newmetatable(L, "aMetaTable");/*int luaL_newmetatable (lua_State * L, const char * t); */
    lua_pushstring(L, "__gc");
    lua_pushcfunction(L, destroy);
    lua_settable(L, 2);

    lua_pushstring(L, "__index");
    lua_pushcfunction(L, index);
    lua_settable(L, 2);

    lua_pushstring(L, "__newindex");
    lua_pushcfunction(L, newindex);
    lua_settable(L, 2);

    int x = luaL_dofile(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.

    if (x == LUA_OK) {  lua_close(L);// если поллучилось открыть файл.
        cin.get();  }//ожидает ввода символа программа завершается.

    else {
        cout << "Error: " << lua_tostring(L, -1) << endl;
        lua_close(L);// закрыть состояние
        cin.get();//ожидает ввода символа программа завершается.
        return 0;
    }
}







struct vec
{
    static int vector(lua_State* L)
    {
        lua_newtable(L); //Создает новую пустую таблицу и помещает ее в стек.Это эквивалентно lua_createtable(L, 0, 0
        lua_pushstring(L, "x");
        lua_pushnumber(L, 0);
        lua_settable(L, 1);// уст ключ и значение из стек

        lua_pushstring(L, "y");
        lua_pushnumber(L, 0);
        lua_settable(L, 1);

        luaL_getmetatable(L, "VectorMetaTable");// получает в стек метатаблицу значения с заданным допустимым индексом.
        //Если индекс недопустим или значение не имеет метатаблицы, функция возвращает 0 и ничего не помещает в стек.
        lua_setmetatable(L, -2);// получает таблицу из стека и устанавливает ее в качестве новой метатаблицы для значения
        //с заданным допустимым индексом.

        return 1;
    }

    static int __add(lua_State* L)
    {
    //  printf("__add was called\n");
        lua_assert(lua_istable(L, -2));     // left table
        lua_assert(lua_istable(L, -1));     // right table

        lua_pushstring(L, "x");
        lua_gettable(L, 1);
        lua_Number xfirst = lua_tonumber(L, -1);// получить x из первой таблицы.
        lua_pop(L, 1);

        lua_pushstring(L, "x");
        lua_gettable(L, 2);
        lua_Number xsecond = lua_tonumber(L, -1);// получить x из второй таблицы.
        lua_pop(L, 1);

        lua_Number sum = xfirst + xfirst;// сложить значения x двух таблиц.
        vec::vector(L);
        lua_pushstring(L, "x");
        lua_pushnumber(L, sum);// сумму отправить в стек
        lua_rawset(L, 3); //Аналогичен lua_settable, но выполняет необработанное назначение(т.Е.Без метаметодов).
        return 1;
    }
};

int main() {

    lua_State* L = luaL_newstate();

    lua_pushcfunction(L, vec::vector);
    lua_setglobal(L, "vector");// уст таблицу

    luaL_newmetatable(L, "VectorMetaTable");// уста новую метатаблицу.
    lua_pushstring(L, "__add");
    lua_pushcfunction(L, vec::__add);
    lua_settable(L, -3);

    int x = luaL_dofile(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.

    if (x == LUA_OK){   lua_getglobal(L, "result");
        lua_Number result = lua_tonumber(L, -1);
        printf("result = %d\n", (int)result);
        lua_close(L);
        cin.get();//ожидает ввода символа программа завершается.
    }
    else
    {
        printf("Error: %s\n", lua_tostring(L, -1));
        lua_close(L);// закрыть состояние
        return 0;   }}
lua

    v1 = vector()   -- v1 is a table
        v2 = vector()     -- v2 is a table
        v1.x = 4
        v2.x = 42
        v3 = v1 + v2
        result = v3.x


static int __mul(lua_State* L)  {
        //  printf("__add was called\n");
        lua_assert(lua_istable(L, -2));     // left table
        lua_assert(lua_istable(L, -1));     // right table

        lua_pushstring(L, "x");
        lua_gettable(L, 1);
        lua_Number xfirst = lua_tonumber(L, -1);// получить x из первой таблицы.
        lua_pop(L, 1);

        lua_pushstring(L, "x");
        lua_gettable(L, 2);
        lua_Number xsecond = lua_tonumber(L, -1);// получить x из второй таблицы.
        lua_pop(L, 1);

        lua_Number mul = xfirst * xfirst;// умножить значения x двух таблиц.
        vec::vector(L);
        lua_pushstring(L, "x");
        lua_pushnumber(L, mul);// произведение отправить в стек
        lua_rawset(L, 3); //Аналогичен lua_settable, но выполняет необработанное назначение(т.Е.Без метаметодов).
        return 1;   }
};

int main() {

    lua_State* L = luaL_newstate();

    lua_pushcfunction(L, vec::vector);
    lua_setglobal(L, "vector");// уст таблицу
    lua_pushstring(L, "__mul");
    lua_pushcfunction(L, vec::__mul);
    lua_settable(L, -2);
    int x = luaL_dofile(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.


static int numberOfSpritesExisting = 0;

struct Sprite
{
    int x;
    int y;

    Sprite() : x(0), y(0)
    {
        numberOfSpritesExisting++;
    }

    ~Sprite()
    {
        numberOfSpritesExisting--;
    }

    void Move(int velX, int velY)
    {
        x += velX;
        y += velY;
    }

    void Draw()
    {
        printf("sprite(%p): x = %d, y = %d\n", this, x, y);
    }
};

auto CreateSprite = [](lua_State* L) -> int
{
    void* pointerToASprite = lua_newuserdata(L, sizeof(Sprite));
    new (pointerToASprite) Sprite();
    luaL_getmetatable(L, "SpriteMetaTable");
    lua_assert(lua_istable(L, -1));
    lua_setmetatable(L, -2);
    return 1;
};

auto DestroySprite = [](lua_State* L) -> int
{
    Sprite* sprite = (Sprite*)lua_touserdata(L, -1);
    sprite->~Sprite();
    return 0;
};

auto MoveSprite = [](lua_State* L) -> int
{
    Sprite* sprite = (Sprite*)lua_touserdata(L, -3);
    lua_Number velX = lua_tonumber(L, -2);
    lua_Number velY = lua_tonumber(L, -1);
    sprite->Move((int)velX, (int)velY);
    return 0;
};

auto DrawSprite = [](lua_State* L) -> int
{
    Sprite* sprite = (Sprite*)lua_touserdata(L, -1);
    sprite->Draw();
    return 0;
};

int main() {

    lua_State* L = luaL_newstate();
    luaL_newmetatable(L, "SpriteMetaTable");
    lua_pushstring(L, "__gc");
    lua_pushcfunction(L, DestroySprite);
    lua_settable(L, -3);

    lua_pushcfunction(L, CreateSprite);
    lua_setglobal(L, "CreateSprite");
    lua_pushcfunction(L, MoveSprite);
    lua_setglobal(L, "MoveSprite");
    lua_pushcfunction(L, DrawSprite);
    lua_setglobal(L, "DrawSprite");

    int x = luaL_dofile(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.

    if (x == LUA_OK){

        lua_assert(numberOfSpritesExisting == 0);

        lua_close(L);
        cin.get();//ожидает ввода символа программа завершается.
    }
    else
    {
        printf("Error: %s\n", lua_tostring(L, -1));
        lua_close(L);// закрыть состояние
        return 0;   }}

lua
        sprite = CreateSprite()
        MoveSprite( sprite, 5, 7 )
        DrawSprite( sprite )
        MoveSprite( sprite, 1, 2 )
        DrawSprite( sprite )
        sprite2 = CreateSprite()
        MoveSprite( sprite2, 3, 3 )
        DrawSprite( sprite2 )


 Object Oriented Access

static int numberOfSpritesExisting = 0;

struct Sprite
{
    int x;
    int y;

    Sprite() : x(0), y(0)
    {
        numberOfSpritesExisting++;
    }

    ~Sprite()
    {
        numberOfSpritesExisting--;
    }

    void Move(int velX, int velY)
    {
        x += velX;
        y += velY;
    }

    void Draw()
    {
        printf("sprite(%p): x = %d, y = %d\n", this, x, y);
    }
};

auto CreateSprite = [](lua_State* L) -> int
{
    void* pointerToASprite = lua_newuserdata(L, sizeof(Sprite));
    new (pointerToASprite) Sprite();
    luaL_getmetatable(L, "SpriteMetaTable");
    lua_assert(lua_istable(L, -1));
    lua_setmetatable(L, -2);
    return 1;
};

auto DestroySprite = [](lua_State* L) -> int
{
    Sprite* sprite = (Sprite*)lua_touserdata(L, -1);
    sprite->~Sprite();
    return 0;
};

auto MoveSprite = [](lua_State* L) -> int
{
    Sprite* sprite = (Sprite*)lua_touserdata(L, -3);
    lua_Number velX = lua_tonumber(L, -2);
    lua_Number velY = lua_tonumber(L, -1);
    sprite->Move((int)velX, (int)velY);
    return 0;
};

auto DrawSprite = [](lua_State* L) -> int
{
    Sprite* sprite = (Sprite*)lua_touserdata(L, -1);
    sprite->Draw();
    return 0;
};


int main() {

    lua_State* L = luaL_newstate();
    lua_newtable(L);
    int spriteTableIdx = lua_gettop(L);
    lua_pushvalue(L, spriteTableIdx);
    lua_setglobal(L, "Sprite");

    lua_pushcfunction(L, CreateSprite);
    lua_setfield(L, -2, "new");
    lua_pushcfunction(L, MoveSprite);
    lua_setfield(L, -2, "Move");
    lua_pushcfunction(L, DrawSprite);
    lua_setfield(L, -2, "Draw");

    luaL_newmetatable(L, "SpriteMetaTable");
    lua_pushstring(L, "__gc");
    lua_pushcfunction(L, DestroySprite);
    lua_settable(L, -3);

    lua_pushstring(L, "__index");
    lua_pushvalue(L, spriteTableIdx);
    lua_settable(L, -3);


    int x = luaL_dofile(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.

    if (x == LUA_OK){

        lua_assert(numberOfSpritesExisting == 0);

        lua_close(L);
        cin.get();//ожидает ввода символа программа завершается.
    }
    else
    {
        printf("Error: %s\n", lua_tostring(L, -1));
        lua_close(L);// закрыть состояние
        return 0;   }}


lua

sprite = Sprite.new()
        sprite:Move( 5, 7 )     -- Sprite.Move( sprite, 5, 7 )
        sprite:Draw()
        sprite:Move( 1, 2 )
        sprite:Draw()
        sprite2 = Sprite.new()
        sprite2:Move( 3, 3 )
        sprite2:Draw()
        -- sprite   -> sprite is a userdatum
        --      has a metatable called SpriteMetaTable
        --          dont have Move(), use the __index metamethod
        --          __index metamethod is a table which is Sprite
        --          Sprite has a field called Move(), invoke that
        --          Move() is a c function
        --          invoke, pass the userdatum as the first parameter.


using namespace std;

class MyObject {
private:
    double x;
public:
    MyObject(double x) : x(x) {}
    void set(double x) { this->x = x; }
    double get() const { return this->x; }
};
// Create & return MyObject instance to Lua
static int myobject_new(lua_State* L) {
    double x = luaL_checknumber(L, 1);
    *reinterpret_cast<MyObject**>(lua_newuserdata(L, sizeof(MyObject*))) = new MyObject(x);
    luaL_setmetatable(L, "MyObject" );
    return 1;
}

// Free MyObject instance by Lua garbage collection
static int myobject_delete(lua_State* L) {
    delete *reinterpret_cast<MyObject**>(lua_touserdata(L, 1));
    return 0;
}

// MyObject member functions in Lua
static int myobject_set(lua_State* L) {
    (*reinterpret_cast<MyObject**>(luaL_checkudata(L, 1, "MyObject")))->set(luaL_checknumber(L, 2));
    return 0;
}
static int myobject_get(lua_State* L) {
    lua_pushnumber(L, (*reinterpret_cast<MyObject**>(luaL_checkudata(L, 1, "MyObject")))->get());
    return 1;
}

int main(int argc, char** argv) {
        lua_State* L = luaL_newstate();
        luaL_openlibs(L);
        lua_register(L, "MyObject", myobject_new);
        luaL_newmetatable(L, "MyObject");
        lua_pushcfunction(L, myobject_delete); lua_setfield(L, -2, "__gc");
        lua_pushvalue(L, -1); lua_setfield(L, -2, "__index");
        lua_pushcfunction(L, myobject_set); lua_setfield(L, -2, "set");
        lua_pushcfunction(L, myobject_get); lua_setfield(L, -2, "get");
        lua_pop(L, 1);
        luaL_dofile(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.
        lua_pcall(L, 0, 0, 0);// вызов функции в lua файле. 1 параметр кол-во передаваемых, кол-во возвращаемых, обработчик ошибок.
        lua_close(L);// закрыть состояние
        cin.get();//ожидает ввода символа программа завершается.
        return 0;

}

Lua

local obj = MyObject(42)
print(obj:get())    -- 42
obj:set(-1.5)
print(obj:get())    -- -1.5







("---- Reading Object Properties -----\


static int numberOfSpritesExisting = 0;

struct Sprite
{
    int x;
    int y;

    Sprite() : x(0), y(0)
    {
        numberOfSpritesExisting++;
    }

    ~Sprite()
    {
        numberOfSpritesExisting--;
    }

    void Move(int velX, int velY)
    {
        x += velX;
        y += velY;
    }

    void Draw()
    {
        printf("sprite(%p): x = %d, y = %d\n", this, x, y);
    }
};

auto CreateSprite = [](lua_State* L) -> int
{
    void* pointerToASprite = lua_newuserdata(L, sizeof(Sprite));
    new (pointerToASprite) Sprite();
    luaL_getmetatable(L, "SpriteMetaTable");
    lua_assert(lua_istable(L, -1));
    lua_setmetatable(L, -2);
    return 1;
};

auto DestroySprite = [](lua_State* L) -> int
{
    Sprite* sprite = (Sprite*)lua_touserdata(L, -1);
    sprite->~Sprite();
    return 0;
};

auto MoveSprite = [](lua_State* L) -> int
{
    Sprite* sprite = (Sprite*)lua_touserdata(L, -3);
    lua_Number velX = lua_tonumber(L, -2);
    lua_Number velY = lua_tonumber(L, -1);
    sprite->Move((int)velX, (int)velY);
    return 0;
};

auto DrawSprite = [](lua_State* L) -> int
{
    Sprite* sprite = (Sprite*)lua_touserdata(L, -1);
    sprite->Draw();
    return 0;
};

auto SpriteIndex = [](lua_State* L) -> int
{
    lua_assert(lua_isuserdata(L, -2));
    lua_assert(lua_isstring(L, -1));

    Sprite* sprite = (Sprite*)lua_touserdata(L, -2);
    const char* index = lua_tostring(L, -1);
    if (strcmp(index, "x") == 0)
    {
        lua_pushnumber(L, sprite->x);
        return 1;
    }
    else if (strcmp(index, "y") == 0)
    {
        lua_pushnumber(L, sprite->y);
        return 1;
    }
    else
    {
        lua_getglobal(L, "Sprite");
        lua_pushstring(L, index);
        lua_rawget(L, -2);
        return 1;
    }
};



int main() {

    lua_State* L = luaL_newstate();

    lua_newtable(L);
    int spriteTableIdx = lua_gettop(L);
    lua_pushvalue(L, spriteTableIdx);
    lua_setglobal(L, "Sprite");

    lua_pushcfunction(L, CreateSprite);
    lua_setfield(L, -2, "new");
    lua_pushcfunction(L, MoveSprite);
    lua_setfield(L, -2, "Move");
    lua_pushcfunction(L, DrawSprite);
    lua_setfield(L, -2, "Draw");

    luaL_newmetatable(L, "SpriteMetaTable");
    lua_pushstring(L, "__gc");
    lua_pushcfunction(L, DestroySprite);
    lua_settable(L, -3);

    lua_pushstring(L, "__index");
    lua_pushcfunction(L, SpriteIndex);
    lua_settable(L, -3);



    int x = luaL_dofile(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.

    if (x == LUA_OK){
        lua_getglobal(L, "temp_x");
        lua_Number temp_x = lua_tonumber(L, -1);
        lua_assert(temp_x == 6);

        lua_close(L);

        lua_assert(numberOfSpritesExisting == 0);

        lua_close(L);
        cin.get();//ожидает ввода символа программа завершается.
    }
    else
    {
        printf("Error: %s\n", lua_tostring(L, -1));
        lua_close(L);// закрыть состояние
        return 0;   }}

lua
        sprite = Sprite.new()
        sprite:Move( 6, 7 )     -- Sprite.Move( sprite, 6, 7 )
        sprite:Draw()
        temp_x = sprite.x

Writing Object Properties


static int numberOfSpritesExisting = 0;

struct Sprite
{
    int x;
    int y;

    Sprite() : x(0), y(0)
    {
        numberOfSpritesExisting++;
    }

    ~Sprite()
    {
        numberOfSpritesExisting--;
    }

    void Move(int velX, int velY)
    {
        x += velX;
        y += velY;
    }

    void Draw()
    {
        printf("sprite(%p): x = %d, y = %d\n", this, x, y);
    }
};

auto CreateSprite = [](lua_State* L) -> int
{
    void* pointerToASprite = lua_newuserdata(L, sizeof(Sprite));
    new (pointerToASprite) Sprite();
    luaL_getmetatable(L, "SpriteMetaTable");
    lua_assert(lua_istable(L, -1));
    lua_setmetatable(L, -2);
    return 1;
};

auto DestroySprite = [](lua_State* L) -> int
{
    Sprite* sprite = (Sprite*)lua_touserdata(L, -1);
    sprite->~Sprite();
    return 0;
};

auto MoveSprite = [](lua_State* L) -> int
{
    Sprite* sprite = (Sprite*)lua_touserdata(L, -3);
    lua_Number velX = lua_tonumber(L, -2);
    lua_Number velY = lua_tonumber(L, -1);
    sprite->Move((int)velX, (int)velY);
    return 0;
};

auto DrawSprite = [](lua_State* L) -> int
{
    Sprite* sprite = (Sprite*)lua_touserdata(L, -1);
    sprite->Draw();
    return 0;
};

auto SpriteIndex = [](lua_State* L) -> int
{
    lua_assert(lua_isuserdata(L, -2));
    lua_assert(lua_isstring(L, -1));

    Sprite* sprite = (Sprite*)lua_touserdata(L, -2);
    const char* index = lua_tostring(L, -1);
    if (strcmp(index, "x") == 0)
    {
        lua_pushnumber(L, sprite->x);
        return 1;
    }
    else if (strcmp(index, "y") == 0)
    {
        lua_pushnumber(L, sprite->y);
        return 1;
    }
    else
    {
        lua_getglobal(L, "Sprite");
        lua_pushstring(L, index);
        lua_rawget(L, -2);
        return 1;
    }
};

auto SpriteNewIndex = [](lua_State* L) -> int
{
    lua_assert(lua_isuserdata(L, -3));
    lua_assert(lua_isstring(L, -2));
    // -1 - value we want to set

    Sprite* sprite = (Sprite*)lua_touserdata(L, -3);
    const char* index = lua_tostring(L, -2);
    if (strcmp(index, "x") == 0)
    {
        sprite->x = (int)lua_tonumber(L, -1);
    }
    else if (strcmp(index, "y") == 0)
    {
        sprite->y = (int)lua_tonumber(L, -1);
    }
    else
    {
        lua_assert(false);  //don't want you to write to my native object!!
    }

    return 0;
};

int main() {
    lua_State* L = luaL_newstate();

    lua_newtable(L);
    int spriteTableIdx = lua_gettop(L);
    lua_pushvalue(L, spriteTableIdx);
    lua_setglobal(L, "Sprite");

    lua_pushcfunction(L, CreateSprite);
    lua_setfield(L, -2, "new");
    lua_pushcfunction(L, MoveSprite);
    lua_setfield(L, -2, "Move");
    lua_pushcfunction(L, DrawSprite);
    lua_setfield(L, -2, "Draw");

    luaL_newmetatable(L, "SpriteMetaTable");
    lua_pushstring(L, "__gc");
    lua_pushcfunction(L, DestroySprite);
    lua_settable(L, -3);

    lua_pushstring(L, "__index");
    lua_pushcfunction(L, SpriteIndex);
    lua_settable(L, -3);

    lua_pushstring(L, "__newindex");
    lua_pushcfunction(L, SpriteNewIndex);
    lua_settable(L, -3);

    int x = luaL_dofile(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.

    if (x == LUA_OK){
        lua_getglobal(L, "temp_x");
        lua_Number temp_x = lua_tonumber(L, -1);
        lua_assert(temp_x == 6);
        lua_assert(numberOfSpritesExisting == 0);

        lua_close(L);
        cin.get();//ожидает ввода символа программа завершается.
    }
    else
    {
        printf("Error: %s\n", lua_tostring(L, -1));
        lua_close(L);// закрыть состояние
        return 0;   }}

lua

sprite = Sprite.new()
    sprite:Move( 6, 7 )     -- Sprite.Move( sprite, 6, 7 )
    sprite:Draw()
    sprite.y = 10
    temp_x = sprite.x
    sprite:Draw()

user values

static int numberOfSpritesExisting = 0;

struct Sprite
{
    int x;
    int y;

    Sprite() : x(0), y(0)
    {
        numberOfSpritesExisting++;
    }

    ~Sprite()
    {
        numberOfSpritesExisting--;
    }

    void Move(int velX, int velY)
    {
        x += velX;
        y += velY;
    }

    void Draw()
    {
        printf("sprite(%p): x = %d, y = %d\n", this, x, y);
    }
};

auto CreateSprite = [](lua_State* L) -> int
{
    void* pointerToASprite = lua_newuserdata(L, sizeof(Sprite));
    new (pointerToASprite) Sprite();
    luaL_getmetatable(L, "SpriteMetaTable");
    lua_assert(lua_istable(L, -1));
    lua_setmetatable(L, -2);
    return 1;
};

auto DestroySprite = [](lua_State* L) -> int
{
    Sprite* sprite = (Sprite*)lua_touserdata(L, -1);
    sprite->~Sprite();
    return 0;
};

auto MoveSprite = [](lua_State* L) -> int
{
    Sprite* sprite = (Sprite*)lua_touserdata(L, -3);
    lua_Number velX = lua_tonumber(L, -2);
    lua_Number velY = lua_tonumber(L, -1);
    sprite->Move((int)velX, (int)velY);
    return 0;
};

auto DrawSprite = [](lua_State* L) -> int
{
    Sprite* sprite = (Sprite*)lua_touserdata(L, -1);
    sprite->Draw();
    return 0;
};

auto SpriteIndex = [](lua_State* L) -> int
{
    lua_assert(lua_isuserdata(L, -2));
    lua_assert(lua_isstring(L, -1));

    Sprite* sprite = (Sprite*)lua_touserdata(L, -2);
    const char* index = lua_tostring(L, -1);
    if (strcmp(index, "x") == 0)
    {
        lua_pushnumber(L, sprite->x);
        return 1;
    }
    else if (strcmp(index, "y") == 0)
    {
        lua_pushnumber(L, sprite->y);
        return 1;
    }
    else
    {
        lua_getglobal(L, "Sprite");
        lua_pushstring(L, index);
        lua_rawget(L, -2);
        return 1;
    }
};

auto SpriteNewIndex = [](lua_State* L) -> int
{
    lua_assert(lua_isuserdata(L, -3));
    lua_assert(lua_isstring(L, -2));
    // -1 - value we want to set

    Sprite* sprite = (Sprite*)lua_touserdata(L, -3);
    const char* index = lua_tostring(L, -2);
    if (strcmp(index, "x") == 0)
    {
        sprite->x = (int)lua_tonumber(L, -1);
    }
    else if (strcmp(index, "y") == 0)
    {
        sprite->y = (int)lua_tonumber(L, -1);
    }
    else
    {
        lua_assert(false);  //don't want you to write to my native object!!
    }

    return 0;
};

int main() {
    lua_State* L = luaL_newstate();

    lua_newtable(L);
    int spriteTableIdx = lua_gettop(L);
    lua_pushvalue(L, spriteTableIdx);
    lua_setglobal(L, "Sprite");

    lua_pushcfunction(L, CreateSprite);
    lua_setfield(L, -2, "new");
    lua_pushcfunction(L, MoveSprite);
    lua_setfield(L, -2, "Move");
    lua_pushcfunction(L, DrawSprite);
    lua_setfield(L, -2, "Draw");

    luaL_newmetatable(L, "SpriteMetaTable");
    lua_pushstring(L, "__gc");
    lua_pushcfunction(L, DestroySprite);
    lua_settable(L, -3);

    lua_pushstring(L, "__index");
    lua_pushcfunction(L, SpriteIndex);
    lua_settable(L, -3);

    lua_pushstring(L, "__newindex");
    lua_pushcfunction(L, SpriteNewIndex);
    lua_settable(L, -3);

    int x = luaL_dofile(L, "main.lua");// Загружает и запускает заданный файл. файл в которым все происходит.

    if (x == LUA_OK){
        lua_getglobal(L, "temp_x");
        lua_Number temp_x = lua_tonumber(L, -1);
        lua_assert(temp_x == 6);
        lua_assert(numberOfSpritesExisting == 0);

        lua_close(L);
        cin.get();//ожидает ввода символа программа завершается.
    }
    else
    {
        printf("Error: %s\n", lua_tostring(L, -1));
        lua_close(L);// закрыть состояние
        return 0;   }}

lua
sprite = Sprite.new()
    sprite:Move( 6, 7 )     -- Sprite.Move( sprite, 6, 7 )
    sprite:Draw()
    sprite.y = 10
    temp_x = sprite.x
    sprite:Draw()


const char *c_function = "local a=5 local b=10 local c=a+b return c";

int main(int argc, char *argv[]) {

    lua_State *L = luaL_newstate();
    luaL_openlibs(L);//открыть все стандартные библиотеки lua.
    luaL_dostring(L, c_function);
    int r = luaL_checkinteger(L, -1);
    printf("\nResult = %d", r);




void writelog(const char* x) {
    string path = "lualoader\\log.txt";
    fstream f1; {f1.open(path, fstream::in | fstream::out | fstream::app);
    f1 << x;
    time_t rawtime; struct tm * timeinfo;
    char buffer[80]; time(&rawtime);
    timeinfo = localtime(&rawtime);

    strftime(buffer, sizeof(buffer), " %I:%M:%S %d-%m-%Y", timeinfo);
    string er2(buffer);
    f1<<er2 << "\n"; }
    f1.close();
};

void search(lua_State *L) {
    for (auto const& de : fs::recursive_directory_iterator{ fs::current_path() / "lualoader" })  // папка для поиска
    { if (de.path().extension() == ".lua" || de.path().extension() == ".LUA")
        {   string res = de.path().string();// имя в файла в строку
            char *file = new char[res.size() + 1];
            copy(res.begin(), res.end(), file);
            file[res.size()] = '\0';// преобразуем строку в char.
            int status = luaL_loadfile(L, file);// проверка есть ли ошибки.
            try {
                if (status == 0) {// если нет ошибки в файле.
                    luaL_dofile(L, file);// запуск файла.
                    string s1(file);
                    string load = "loaded ";
                    string er0 = load + s1;
                    delete[] file;
                    char * x = new char[er0.size() + 1];
                    copy(er0.begin(), er0.end(), x);
                    x[er0.size()] = '\0';
                    writelog(x);
                    delete[] x; }//.
                else {delete[] file;
                    string er1 = lua_tostring(L, -1);
                    string er = "could not load ";
                    string er0 = er + er1;
                    char * x = new char[er0.size() + 1];
                    copy(er0.begin(), er0.end(), x);
                    x[er0.size()] = '\0';
                    throw x;delete[] x; }           }
            catch (const char* x) {
                writelog(x);}}}
};


int main(int argc, char *argv[]) {
    lua_State *L = luaL_newstate();
    luaL_openlibs(L);//открыть все стандартные библиотеки lua.
    search(L);
    lua_close(L);// закрыть состояние
//  cin.get();//ожидает ввода символа программа завершается.
    return 0;

void checklua(lua_State *L, char *file) {
    int status = luaL_loadfile(L, file);// проверка есть ли ошибки.
        try {
        if (status == 0) {// если нет ошибки в файле.
            luaL_dofile(L, file);// запуск файла, в которым все происходит.
            string s1(file);
            string load = "loaded ";
            string er0 = load + s1;
                char * x = new char[er0.size() + 1];
                    copy(er0.begin(), er0.end(), x);
                    x[er0.size()] = '\0';
                    writelog(x);}//.
                else {
                    string er1 = lua_tostring(L, -1);
                    string er = "could not load ";
                    string er0 = er + er1;
                    char * x = new char[er0.size() + 1];
                    copy(er0.begin(), er0.end(), x);
                    x[er0.size()] = '\0';
                    throw x;    }           }
            catch (const char* x) {
                writelog(x);}
};


lua memory allocation



int main(){
    struct luamem
    {
        static void *l_alloc(void *ud, void *ptr, size_t osize, size_t nsize) {
            (void)ud; (void)osize;  /* not used */
            if (nsize == 0) {
                free(ptr);
                return NULL;
            }
            else
                return realloc(ptr, nsize);
        }
    };
    void* ud = nullptr;
    lua_State* L = lua_newstate(luamem::l_alloc, ud);
    lua_close(L);
}

struct GlobalAllocator
{
    void* Allocate(size_t sizeBytes)
    {
        return ::operator new(sizeBytes);
    }

    void DeAllocate(void* ptr, size_t /*osize*/)
    {
        assert(ptr != nullptr);     //can't decallocate null!!!
        ::operator delete(ptr);
    }

    void* ReAllocate(void* ptr, size_t osize, size_t nsize)
    {
        size_t bytesToCopy = osize;
        if (nsize < bytesToCopy)
        {
            bytesToCopy = nsize;
        }
        void* newPtr = Allocate(nsize);
        memcpy(newPtr, ptr, bytesToCopy);
        DeAllocate(ptr, osize);
        return newPtr;
    }

    static void *l_alloc(void *ud, void *ptr, size_t osize, size_t nsize) {
        GlobalAllocator * pool = static_cast<GlobalAllocator *>(ud);
        if (nsize == 0)
        {
            if (ptr != nullptr)
            {
                pool->DeAllocate(ptr, osize);
            }
            return NULL;
        }
        else
        {
            if (ptr == nullptr)
            {
                return pool->Allocate(nsize);
            }
            else
            {
                return pool->ReAllocate(ptr, osize, nsize);
            }
        }
    }
};

/*! \brief Allocates from a fixed pool.
*   Aligns all memory to 8 bytes
*   Has a min allocation of 64 bytes
*   Puts all free'd blocks on a free list.
*   Falls back to GlobalAllocator when out of memory. */
struct ArenaAllocator
{
    void* m_begin;
    void* m_end;
    char* m_curr;

    static constexpr int ALIGNMENT = 8;
    static constexpr int MIN_BLOCK_SIZE = ALIGNMENT * 8;

    struct FreeList
    {
        FreeList* m_next;
    };

    FreeList* m_freeListHead;
    GlobalAllocator m_globalAllocator;

    ArenaAllocator(void* begin, void* end) :
        m_begin(begin),
        m_end(end)
    {
        Reset();
    }

    void Reset()
    {
        m_freeListHead = nullptr;
        m_curr = static_cast<char*>(m_begin);
    }

    size_t SizeToAllocate(size_t size)
    {
        size_t allocatedSize = size;
        if (allocatedSize < MIN_BLOCK_SIZE)
        {
            allocatedSize = MIN_BLOCK_SIZE;
        }
        return allocatedSize;
    }

    void* Allocate(size_t sizeBytes)
    {
        size_t allocatedBytes = SizeToAllocate(sizeBytes);
        if (allocatedBytes <= MIN_BLOCK_SIZE && m_freeListHead)
        {
            //printf("-- allocated from the freelist --\n");
            void* ptr = m_freeListHead;
            m_freeListHead = m_freeListHead->m_next;
            return ptr;
        }
        else
        {
            m_curr = (char*)((uintptr_t)m_curr + (ALIGNMENT - 1) & ~(ALIGNMENT - 1));
            if (m_curr + allocatedBytes <= m_end)
            {
                printf("Allocated %d bytes\n", (int)allocatedBytes);
                void* ptr = m_curr;
                m_curr += allocatedBytes;
                return ptr;
            }
            else
            {
                return m_globalAllocator.Allocate(sizeBytes);
            }
        }
    }

    void DeAllocate(void* ptr, size_t osize)
    {
        assert(ptr != nullptr);     //can't decallocate null!!!
        if (ptr >= m_begin && ptr <= m_end)
        {
            size_t allocatedBytes = SizeToAllocate(osize);
            printf("DeAllocated %d bytes\n", (int)allocatedBytes);
            if (allocatedBytes >= MIN_BLOCK_SIZE)
            {
                printf("-- deallocated to the freelist --\n");
                FreeList* newHead = static_cast<FreeList*>(ptr);
                newHead->m_next = m_freeListHead;
                m_freeListHead = newHead;
            }
        }
        else
        {
            m_globalAllocator.DeAllocate(ptr, osize);
        }
    }

    void* ReAllocate(void* ptr, size_t osize, size_t nsize)
    {
        printf("ReAllocated %d bytes\n", (int)nsize);
        size_t bytesToCopy = osize;
        if (nsize < bytesToCopy)
        {
            bytesToCopy = nsize;
        }
        void* newPtr = Allocate(nsize);
        memcpy(newPtr, ptr, bytesToCopy);
        DeAllocate(ptr, osize);
        return newPtr;
    }

    static void *l_alloc(void *ud, void *ptr, size_t osize, size_t nsize) {
        ArenaAllocator * pool = static_cast<ArenaAllocator *>(ud);
        if (nsize == 0)
        {
            if (ptr != nullptr)
            {
                pool->DeAllocate(ptr, osize);
            }
            return NULL;
        }
        else
        {
            if (ptr == nullptr)
            {
                return pool->Allocate(nsize);
            }
            else
            {
                return pool->ReAllocate(ptr, osize, nsize);
            }
        }
    }
};
int main() {
    constexpr int pool_size = 1024 * 10;
    char memory[pool_size];
    ArenaAllocator pool(memory, &memory[pool_size-1]);

    lua_State *L = lua_newstate(ArenaAllocator::l_alloc, &memory);
    //luaL_openlibs(L);
    lua_assert(L != nullptr);
    lua_close(L);
    //cin.get();//ожидает ввода символа программа завершается.
    return 0;
}

pragma once
#include <assert.h>
#include <cstdio>
#include <string.h>

/*! \brief Allocates from global memory (NOTE: does not currently align memory) */
struct GlobalAllocator
{
    void* Allocate(size_t sizeBytes)
    {
        return ::operator new(sizeBytes);
    }

    void DeAllocate(void* ptr, size_t /*osize*/)
    {
        assert(ptr != nullptr);     //can't decallocate null!!!
        ::operator delete(ptr);
    }

    void* ReAllocate(void* ptr, size_t osize, size_t nsize)
    {
        size_t bytesToCopy = osize;
        if (nsize < bytesToCopy)
        {
            bytesToCopy = nsize;
        }
        void* newPtr = Allocate(nsize);
        memcpy(newPtr, ptr, bytesToCopy);
        DeAllocate(ptr, osize);
        return newPtr;
    }

    static void *l_alloc(void *ud, void *ptr, size_t osize, size_t nsize) {
        GlobalAllocator * pool = static_cast<GlobalAllocator *>(ud);
        if (nsize == 0)
        {
            if (ptr != nullptr)
            {
                pool->DeAllocate(ptr, osize);
            }
            return NULL;
        }
        else
        {
            if (ptr == nullptr)
            {
                return pool->Allocate(nsize);
            }
            else
            {
                return pool->ReAllocate(ptr, osize, nsize);
            }
        }
    }
};

/*! \brief Allocates from a fixed pool.
*   Aligns all memory to 8 bytes
*   Has a min allocation of 64 bytes
*   Puts all free'd blocks on a free list.
*   Falls back to GlobalAllocator when out of memory. */
struct ArenaAllocator
{
    void* m_begin;
    void* m_end;
    char* m_curr;

    static constexpr int ALIGNMENT = 8;
    static constexpr int MIN_BLOCK_SIZE = ALIGNMENT * 8;

    struct FreeList
    {
        FreeList* m_next;
    };

    FreeList* m_freeListHead;
    GlobalAllocator m_globalAllocator;

    ArenaAllocator(void* begin, void* end) :
        m_begin(begin),
        m_end(end)
    {
        Reset();
    }

    void Reset()
    {
        m_freeListHead = nullptr;
        m_curr = static_cast<char*>(m_begin);
    }

    size_t SizeToAllocate(size_t size)
    {
        size_t allocatedSize = size;
        if (allocatedSize < MIN_BLOCK_SIZE)
        {
            allocatedSize = MIN_BLOCK_SIZE;
        }
        return allocatedSize;
    }

    void* Allocate(size_t sizeBytes)
    {
        size_t allocatedBytes = SizeToAllocate(sizeBytes);
        if (allocatedBytes <= MIN_BLOCK_SIZE && m_freeListHead)
        {
            //printf("-- allocated from the freelist --\n");
            void* ptr = m_freeListHead;
            m_freeListHead = m_freeListHead->m_next;
            return ptr;
        }
        else
        {
            m_curr = (char*)((uintptr_t)m_curr + (ALIGNMENT - 1) & ~(ALIGNMENT - 1));
            if (m_curr + allocatedBytes <= m_end)
            {
                //printf("Allocated %d bytes\n", (int)allocatedBytes);
                void* ptr = m_curr;
                m_curr += allocatedBytes;
                return ptr;
            }
            else
            {
                return m_globalAllocator.Allocate(sizeBytes);
            }
        }
    }

    void DeAllocate(void* ptr, size_t osize)
    {
        assert(ptr != nullptr);     //can't decallocate null!!!
        if (ptr >= m_begin && ptr <= m_end)
        {
            size_t allocatedBytes = SizeToAllocate(osize);
            //printf("DeAllocated %d bytes\n", (int)allocatedBytes);
            if (allocatedBytes >= MIN_BLOCK_SIZE)
            {
                //printf("-- deallocated to the freelist --\n");
                FreeList* newHead = static_cast<FreeList*>(ptr);
                newHead->m_next = m_freeListHead;
                m_freeListHead = newHead;
            }
        }
        else
        {
            m_globalAllocator.DeAllocate(ptr, osize);
        }
    }

    void* ReAllocate(void* ptr, size_t osize, size_t nsize)
    {
        //printf("ReAllocated %d bytes\n", (int)nsize);
        size_t bytesToCopy = osize;
        if (nsize < bytesToCopy)
        {
            bytesToCopy = nsize;
        }
        void* newPtr = Allocate(nsize);
        memcpy(newPtr, ptr, bytesToCopy);
        DeAllocate(ptr, osize);
        return newPtr;
    }

    static void *l_alloc(void *ud, void *ptr, size_t osize, size_t nsize) {
        ArenaAllocator * pool = static_cast<ArenaAllocator *>(ud);
        if (nsize == 0)
        {
            if (ptr != nullptr)
            {
                pool->DeAllocate(ptr, osize);
            }
            return NULL;
        }
        else
        {
            if (ptr == nullptr)
            {
                return pool->Allocate(nsize);
            }
            else
            {
                return pool->ReAllocate(ptr, osize, nsize);
            }
        }
    }
};



Понимание стека Lua
________________________________________
Я не буду пытаться познакомить вас с языком Lua, в Интернете есть много хороших учебных пособий. Здесь я кратко представлю основную структуру API-интерфейса Lua C, чтобы установить основу для понимания остальной части руководства.

Приятной особенностью языка Lua является то, что интерпретатор не использует глобальные переменные вообще. Это означает, что у вас может быть несколько сред Lua, работающих в разных потоках без каких-либо конфликтов. Это также одна из основных причин того, что встраивание Lua настолько просто, что вам действительно нужно отслеживать только одну переменную для каждой среды выполнения: lua_State.

Я избавлю вас от технических деталей, в основном потому, что я их не знаю, но по сути каждый lua_State поддерживает стек переменных lua. Переменные Lua бывают следующих (в основном) самоочевидных типов: nil, логическое значение, число, строка, функция, пользовательские данные, поток и таблица. Я вернусь к деталям позже, просто помните, что lua_State содержит стек таких переменных, и единственный способ взаимодействия с Lua - через этот стек. Давайте создадим lua_State и поиграем с его стеком, чтобы мы понимали, что происходит.
Код:
lua_State * ls = lua_newstate ( 0 , 0 );

lua_pushinteger (ls, 0 );
lua_pushstring (ls, «это строка, оканчивающаяся нулем.» )
lua_pushboolean (ls, true );

// Теперь стек выглядит следующим образом:
// 3. true
// 2. «это строка с нулевым окончанием».
// 1. 0

Любой, кто раньше использовал стек, скажет вам, что чаще всего ссылаются на вершину стека. В этом случае вершиной стека является элемент 3. Если вам нравится, вы можете обратиться к нему, вызвав lua_gettop, который возвращает количество элементов в стеке, но есть гораздо более простой способ. Вы можете ссылаться на элементы сверху вниз, используя отрицательные индексы. Таким образом, верхний элемент может быть проиндексирован с -1, второй сверху с -2 и так далее. Как вы увидите, вы будете ссылаться на элементы стека с отрицательными индексами довольно часто.
Код:
bool boolval = lua_toboolean (ls, - 1 ); // true
const char * stringval = lua_tostring (ls, - 2 ); // "это строка с нулевым окончанием."
int intval = lua_tointeger (ls, - 3 ); // 0

// Стоит отметить, что только nil переводит в ложное значение, число 0 переводит
// в true, что может удивить большинство программистов на Си.
boolval = lua_toboolean (ls, - 3 ); // правда

Итак, у нас есть несколько элементов стека, мы можем получить к ним доступ, что еще мы можем сделать?
Код:
lua_pop (ls, 1 ); //
вставляем верхний элемент lua_insert (ls, 1 ); // переместить верхний элемент в нижнюю часть стека
lua_pushvalue (ls, - 1 ); // выдвигает копию верхнего элемента

// Теперь стек выглядит следующим образом:
// 3. 0
// 2. 0
// 1. «Это строка с нулем в конце».

lua_settop (ls, 0 ); // удаляет все элементы из стека

Итак, вот основная суть стека. Пожалуйста, обратитесь к вашему дружелюбному руководству Neghborhood Lua для получения более подробной информации, и, конечно, есть намного больше деталей.

функции
________________________________________
Нажатие и выталкивание строк и целых чисел - это весело и хорошо, но что, если вы действительно хотите сделать что-то полезное? Самое распространенное, что хочет сделать разработчик, - это представить функцию C / C ++ или класс C ++ сценарию Lua. Чтобы понять, как выставлять классы, мы должны начать с функций, поэтому давайте погрузимся прямо в.
Код:
// Все функции, доступные для Lua, должны иметь следующую структуру:
int some_lua_function ( lua_State * ls)
{ // Do work ... return number_of_return_values; }




Мы взаимодействуем с Lua исключительно со стеком. В приведенной выше функции стек будет начинаться с параметров, которые были переданы, и вы несете ответственность за передачу возвращаемых значений в стек и указание Lua, сколько их существует. Вот более конкретный пример:
Код:
int move_player (lua_Stack * ls)
{ const int xoffset = lua_tointeger (ls, 1 ); const int yoffset = lua_tointeger (ls, 2 ); const Point p = player-> move (xoffset, yoffset); lua_pushinteger (ls, px); lua_pushinteger (ls, py); возврат 2 ; }










Хорошо, у нас много чего происходит, поэтому давайте сделаем это медленно. Первое, на что нужно обратить внимание, это то, что всякий раз, когда Lua вызывает вашу функцию, она будет давать вам стек, содержащий только параметры функции. Первая часть функции превращает параметры в C / C ++, который мы можем использовать (позже я покажу вам, как быть в безопасности, вызвав luaL_checktype). Вторая часть функции - это работа, выполняемая вашим двигателем. Я оставлю это вашему воображению. Третья часть функции показывает, как мы возвращаем значения в Lua с помощью универсального стека. Последняя строка функции указывает Lua, сколько возвращаемых значений получить.

Теперь, когда мы определили функцию, вот как Lua распознает ее:
Код:
lua_register (ls, "MovePlayer" , move_player);

Хм ... это было легко. Теперь я могу вызывать MovePlayer в моих скриптах Lua! Теперь вы знаете достаточно, чтобы представить свой движок сценариям Lua, но, пожалуйста, следите за обновлениями, я покажу вам, как проверять параметры, обрабатывать ошибки и выставлять классы.

Краткое примечание об API Lua C
________________________________________
Некоторые люди могут чесать голову, задаваясь вопросом, почему в 7 адах кто-то захочет вручную управлять стеком Lua. Это выглядит сложным, это выглядит подверженным ошибкам, почему бы не использовать библиотеку оболочки? Конечно, давай. Если вы хотите использовать библиотеку и находите библиотеку, подходящую для ваших нужд, то обязательно используйте ее. Просто прочитайте следующие несколько строк, прежде чем принять решение.

Управление стеками поддается инкапсуляции, поэтому большую часть сложности можно сделать невидимой. Ручное управление стеками очень быстрое, и Lua - очень быстрый язык, идеальный выбор. Ручное управление стеками не требует никаких дополнительных библиотек или API. Наконец, управление стеками не так уж сложно или сложно. Да, вам нужно потратить некоторое время на API, вам нужно приложить немного усилий, но вам все равно придется приложить усилия для изучения библиотеки-оболочки. В итоге у вас будет невероятно быстрый двигатель, который легко программировать и полностью под вашим контролем. Помимо всего этого, я покажу вам крутой трюк, который значительно упростит управление стеками. Просто
продолжай читать.



таблицы
________________________________________
Столы! Столы! Столы! Если вы не понимаете таблицы, прочитайте документацию по Lua и вернитесь. Столы это все. Нет Луа без таблиц. Вот краткое введение в то, как взаимодействовать с таблицами Lua, используя C API.

Код:
lua_newtable (LS); //
создаем пустую таблицу поверх стека lua_pushstring (ls, "tablekey" ); //
помещает в стек значение, которое мы будем использовать
в качестве ключа таблицы lua_pushinteger (ls, 1337 ); // это будет значение, индексированное указанным ключом

// Теперь стек выглядит так:
// -1. 1337
// -2. "tablekey"
// -3. <table>

// При этом используется верхний элемент в -1 для значения, используется элемент в -2 для ключа и
выполняется запись в // таблицу в указанной позиции, в данном случае в -3. И значение, и ключ
// извлекаются из стека, оставляя новую таблицу сверху.
lua_settable (ls, - 3 );

// Код Lua, эквивалентный приведенному выше C-коду:
// {} ["tablekey"] = 1337

Код достаточно понятен для всех, кто знаком с таблицами Lua, поэтому я быстро перейду к следующему важному вопросу. Где пустая таблица, которую мы создали? У него нет имени, оно существует только в стеке. Чтобы сохранить таблицу, мы должны создать постоянную ссылку на нее, но как? Вот идет вкусный соус Lua. Почти все в Lua - это стол, даже глобальная среда! Таким образом, чтобы превратить нашу новую таблицу в глобальную переменную, мы просто помещаем ее в глобальную таблицу так же, как мы помещаем «1337» в новую таблицу! Итак, продолжаем, где мы остановились:

Код:
lua_pushstring (ls, "mynewtable" );

// Теперь стек выглядит так:
// -1. "mynewtable"
// -2. <table>

// Если вы посмотрите на фрагмент кода выше, вы заметите, что значение должно быть в верхней части
// стека, с ключом под ним, поэтому давайте немного перетасуем стек.
lua_insert (ls, - 2 ); // перемещаем верхний элемент в -2, смещая предыдущий -2 в верхний

// Теперь стек выглядит так:
// -1. <таблица>
// -2. "mynewtable"

// Теперь делаем то же самое, что мы делали выше, но обращаемся к глобальной таблице с помощью специального псевдоиндекса.
lua_settable (ls, LUA_GLOBALSINDEX);

Ta-Da! Мы создали новую глобальную переменную! Таблицы Lua могут использовать что угодно в качестве ключей, включая другие таблицы, но вы чаще всего будете использовать строки в качестве ключей. Lua C API имеет удобные функции для упрощения получения и установки «полей» таблицы, соответственно названных lua_getfield и lua_setfield. С помощью этих полезных функций 2 приведенных выше фрагмента кода можно сжать до:

Код:
lua_newtable (ls);
lua_pushinteger (ls, 1337);
lua_setfield (ls, -2, "tablekey" );
lua_setfield (ls, LUA_GLOBALSINDEX, "mynewtable" );

Давайте рассмотрим скорость и покажем вам очень практический пример того, как выставить синглтон двигателя Lua. В этом примере мы покажем синглтон приложения, который показывает панель предупреждений с текстом.

Код:
// Так или иначе мы устанавливаем этот класс C ++.
AlertPanel * alert = ...;

int alert_show ( lua_State * ls)
{ строковое сообщение; // C ++ строка if (lua_gettop (ls)> 0 && lua_isstring (ls, - 1 )) {
message = lua_tostring (ls, 1 ); } else { // Давайте попробуем получить сообщение по умолчанию. lua_getfield
(ls, LUA_GLOBALSINDEX, "Alert" );
luaL_checktype (ls, - 1 , LUA_TTABLE);
lua_getfield (ls, - 1 , «по умолчанию» ); if (lua_isstring (ls, -1 ))
 message = lua_tostring (ls, - 1 ); }
if (! message.empty ()) { alert-> setMessage (message); alert-> показать (); }
return 0 ; }

 int alert_hide ( lua_State * ls) { alert-> hide (); вернуть 0 ; } // Инициализация интерфейса Lua в некоторой функции ... lua_newtable (ls); lua_pushcfuntion (ls, alert_show); lua_setfield (ls, - 2 , «показать» ); lua_pushcfuntion (ls, alert_hide); lua_setfield (ls, - 2 , «скрыть» );


























lua_pushstring (ls, "Alert" );
lua_insert (ls, - 2 );
lua_settable (ls, LUA_GLOBALSINDEX);

Прежде чем вы уйдете с отвращением, позвольте мне заверить вас, что есть гораздо более простой и удобный способ сделать это, но я хочу убедиться, что вы понимаете основной механизм. Итак, что мы сделали? Посмотрите на следующий код Lua, чтобы увидеть, как мы будем использовать Alert:

Код:
- Настройка одноплодного оповещения с более по умолчанию сообщения.
Предупреждение. default = "Произошла неизвестная ошибка!"

- В случае с ошибкой пользователь должен знать о , предупредить их!
локальный результат, err = pcall (some_function, some_parameters),
если не результат, то
  Alert.show (err)
end

Это очень похоже на класс. На самом деле для многих движков может быть достаточно просто показать группу синглетонов, созданных таким образом. Но чтобы устранить любые опасения по поводу сложного управления таблицами в приведенном выше коде, позвольте мне показать вам гораздо более простой способ сделать то же самое:

Код:
// После объявления функций Alert C ...
static const luaL_reg Alert_funcs [] =
{
    { "show" , alert_show},
    { "hide" , alert_hide},
    { 0 , 0 }
};

// Инициализировать интерфейс Lua в некоторой функции ...
luaL_openlib (ls, "Alert" , Alert_funcs, 0 );
lua_pop (ls, 1 );

Намного проще, нет? Теперь вы знаете, что происходит под капотом, как вы можете создать изящную таблицу с функциями и переменными, и как сделать это быстро и безболезненно. Что-то еще, что вы можете сделать со своими новыми знаниями, - это изменить существующие таблицы Lua. Например, вы можете добавить несколько функций в довольно спартанскую библиотеку «io», возможно, «create_dir» и «destroy_dir». Помните, что вы не модифицируете библиотеку, а расширяете встроенную функцию своего игрового движка (Аргументы счетчика в 3 ... 2 ... 1 ...).

Пользовательские данные, метатаблицы и классы
________________________________________
У Луа нет встроенного понятия о классах. Однако с помощью нескольких невероятно мощных механизмов Lua вы можете создать систему первого класса. Зайдите на lua.org, чтобы найти замечательный выбор учебников о том, как поддерживать классы и наследование. Со своей стороны, я собираюсь показать вам, как представить классы C ++ для Lua так, чтобы деструкторы могли хорошо играть с сборкой мусора Lua.

Чтобы представить класс C ++, который будет собирать мусор Lua, мы будем использовать тип userdata, который в Lua C API представлен указателем void. Вместо того, чтобы пытаться объяснить это, вот полный пример для анализа:

Код:
int monster_create (lua_State * ls)
{ // Monster - это определенный где-то класс C ++ ... Monster * monster = new (lua_newuserdata (ls, sizeof (Monster)) Monster;luaL_getmetatable (ls, "MetaMonster" );    lua_setmetatable (ls, - 2 ); return 1 ;} int monster_destroy (lua_State * ls) {luaL_checktype (ls, 1 , LUA_TUSERDATA);Monster * monster = reinterpret_cast <Monster *> (lua_touserdata (ls, 1 ));монстр-> ~ Monster () ; вернуть 0














  ;
}

int monster_rawr (lua_State * ls)
{
 luaL_checktype (ls, 1 , LUA_TUSERDATA);
 Monster * monster = reinterpret_cast <Monster *> (lua_touserdata (ls, 1 ));
 monster-> Rawr (); // печатает угрожающее "rawr! Я пистолет eet u!" возврат сообщения 0 ; } static const luaL_reg Monster_funcs [] = {     { "create" , monster_create},     { 0 , 0 } }; статический Const luaL_reg Monster_methods [] = { { "__gc"












 , monster_destroy},
 { "rawr" , monster_rawr},
    { 0 , 0 }
};

// Инициализировать интерфейс Lua в некоторой функции ...
luaL_newmetatable (ls, "MetaMonster" );
lua_pushstring (ls, "__index" );
lua_pushvalue (ls, - 2 );
lua_settable (ls, - 3 );

luaL_openlib (ls, 0 , Monster_methods, 0 );
luaL_openlib (ls, "Monster" , Monster_funcs, 0 );

Это достаточно много для понимания, но прежде чем мы проанализируем это, взглянем на то, как наш класс будет использоваться в скрипте Lua:

Код:
местный плохой парень = Monster.create ()

- О нет! Вы расстроили плохого парня!
Badguy: Rawr ()

Там у вас есть класс C ++, появляющийся в скрипте Lua. Теперь давайте посмотрим, как мы попали сюда, шаг за шагом, начиная с monster_create.

Первое, что мы делаем, это создаем экземпляр класса C ++, используя оператор размещения new. Если вы не знакомы с размещением new, то в основном он создает экземпляр класса в памяти, данной ему. В этом случае мы передаем память, которую мы получили от интерпретатора Lua. Это оставляет новый экземпляр пользовательских данных поверх стека. Следующие две строки - это место, где происходит волшебство. Я не буду пытаться объяснить вам метатаблицы, поэтому придется сделать следующее грубое искажение. Я в основном устанавливаю таблицу виртуальных функций экземпляра класса или список функций, которые он поддерживает. Я использую метатабель под названием «MetaMonster», который я создаю далее по фрагменту кода. Наконец, я возвращаю 1, чтобы указать Lua, что пользовательские данные в стеке должны быть возвращены вызывающей стороне monster_create.

Следующая функция, которую мы определили, это monster_destroy. Эта функция будет автоматически вызываться Lua после того, как будет выпущена последняя ссылка на экземпляр монстра. Убедившись, что параметр имеет смысл, мы приводим данные пользователя к нашему типу класса C ++ и вызываем его деструктор. Не вызывайте оператор удаления, Lua будет обрабатывать необработанную память. Вы можете обнулить память, если это заставляет вас чувствовать себя лучше.

Функция monster_rawr - это место, где мы представляем функцию-член Lua. В этом случае это супер-пугающая функция rawr, которая не принимает параметров и не возвращает результатов. При представлении функции-члена первым параметром всегда будут сами пользовательские данные, которые мы создали как экземпляр класса C ++ в monster_create. Для поддержки дополнительных параметров или возвращаемых значений, просто имейте в виду, что параметры будут начинаться с индекса стека 2, например:

Код:
int monster_jump (lua_State * ls)
{
 luaL_checktype (ls, 1 , LUA_TUSERDATA);
 Monster * monster = reinterpret_cast <Monster *> (lua_touserdata (ls, 1 )); // Параметры функции-члена начинаются с индекса стека 2 ... luaL_checktype (ls, 2 , LUA_TNUMBER); const int howhigh = lua_tointeger (ls, 2 ); const bool result = monster-> jump (howhigh); lua_settop (ls, 0 ); lua_pushboolean (ls, результат); возврат 1 ; }











Класс C ++ теперь можно использовать из Lua! Но есть что-то немного странное, что-то не совсем правильное в использовании пользовательских данных в Lua Scipt. Что произойдет, если вы захотите добавить поле в свой класс? Вы должны будете сделать это через C ++ и открыть новое поле с помощью другой функции Lua. Это может быть немного грязно, и, кажется, побеждать цель использования хорошего гибкого языка, такого как Lua. Итак, я собираюсь показать вам, как перейти на следующий уровень и представить класс C ++ в виде таблицы Lua, в которую вы можете добавлять функции и переменные. Ключ к достижению этого - метатаблицы. У нас уже есть монстр, доступный для мета с поддерживаемыми функциями-членами, теперь нам нужно просто поиграть с битами, чтобы при вызове одной из этих функций у нас был доступ к таблице и объекту C ++. Прежде всего, давайте вернемся к созданию монстров,

Код:
int monster_create (lua_State * ls)
{ // Создать таблицу и установить ее метатизируемость. lua_newtable (LS); luaL_getmetatable (ls, "MetaMonster" ); lua_setmetatable (ls, - 2 ); // Monster - это класс C ++, определенный где-то ... Monster * monster = new (lua_newuserdata (ls, sizeof (Monster)) Monster;luaL_getmetatable (ls, "MetaMonster" );lua_setmetatable (ls, - 2 ); // Теперь стек выглядит следующим образом: // 2. <userdata> (наш экземпляр класса C ++) // 1. <table> (с метатабельным MetaMonster)     lua_setfield (ls, - 2














, "core_" ); возврат 1 ; }



Разница здесь в том, что мы начинаем с создания таблицы и установки ее метатизируемой перед созданием пользовательских данных. Затем мы даем userdata такой же метатабельный и помещаем его в новый экземпляр таблицы как поле core_. Можете ли вы увидеть, где это происходит? Теперь наши функции-члены будут принимать таблицу Lua в качестве первого параметра, извлекать поле core_, чтобы получить экземпляр класса C ++, и использовать два в тандеме для создания магии.

Небольшая заметка о метатабле. Мы назначаем метатаблицу дважды, один раз для таблицы и один раз для пользовательских данных. Мы будем использовать функции-члены через таблицу, но только объекты пользовательских данных будут иметь метаметод __gc, когда они готовы к смерти. Поэтому вместо того, чтобы использовать две отдельные метатаблицы, одну для функций-членов и одну для деструктора, я просто собрал их вместе.

Теперь взгляните на новые функции уничтожения и перехода, чтобы увидеть, что произошло.

Код:
// Метаметод __gc будет вызываться только для пользовательских данных.
int monster_destroy (lua_State * ls)
{
 luaL_checktype (ls, 1 , LUA_TUSERDATA); Monster * monster = reinterpret_cast <Monster *> (lua_touserdata (ls, 1 )); monster-> ~ монстр (); вернуть 0 ; } int monster_jump (lua_State * ls) { luaL_checktype (ls, 1 , LUA_TTABLE); lua_getfield (ls, 1 , "core_" ); luaL_checktype (ls, - 1 , LUA_TUSERDATA); Monster * monster = reinterpret_cast












 <Monster *> (lua_touserdata (ls, - 1 )); // Параметры функции-члена начинаются с индекса стека 2 ... luaL_checktype (ls, 2 , LUA_TNUMBER); const int howhigh = lua_tointeger (ls, 2 ); // Мы можем включить таблицу Lua в эту бессмысленную функцию ... int jumpbonus = 0 ; lua_getfield (ls, 1 , "jumpbonus" ); if (lua_isnumber (ls, - 1 )) jumpbonus = lua_tointeger (ls, - 1 ); const int result = monster-> jump (howhigh + jumpbonus); lua_pushboolean (ls, результат);













 возврат 1 ; }


Первое, что делает наша функция-член, это проверяет, что ее первый параметр является таблицей. Затем он извлекает поле core_ и преобразует его в соответствующий экземпляр класса C ++. На данный момент я хотел бы отметить, что мы всегда можем использовать больше проверки ошибок, особенно на этапах отладки проекта. Это было бы провальным логическим провалом, если бы вы как-то заменили core_ другим экземпляром userdata или другим глупым дерьмом. Возможно, вы захотите избежать конфликтов имен, переименовывая core_ во что-то более уникальное, например, core_CANTTOUCHTHIS или, что еще лучше, core_nameofcppclass.

Двигаемся дальше. Наша функция-член теперь имеет стек с таблицей внизу и указатель на экземпляр класса C ++ сверху. Не стесняйтесь сходить с ума. На практике я немного опасаюсь доступа к членам Lua из функций-членов C ++, потому что это создает те же проблемы, что и использование прямых пользовательских данных в качестве экземпляров классов, требует изменения исходного кода C / C ++ и перекомпиляции. Тем не менее, у вас есть возможность, и есть разумные способы, которыми вы можете смешать их.

Мое личное мнение состоит в том, что C ++ должен сосредоточиться на тех функциях, которые он предоставляет, и Lua должен использовать эти функции для достижения ваших целей. Используйте C ++ для строительных блоков, используйте Lua для дизайна.

Код:
badguy = Monster.create ()

- badguy получает специальную атаку ...
badguy.pounce = function (self, howhigh)
self . jumpbonus = howhigh или 2 self : jump () self : rawr () end


Рекомендации
________________________________________
До сих пор я работал с позиции, что объекты создаются в Lua и хранятся там. Однако легко предвидеть времена, когда вы захотите, чтобы ваш движок управлял объектами Lua. В этих случаях вам нужно иметь какую-то ссылку, которую вы можете использовать, чтобы поместить объект Lua в стек. Хотя создать собственную справочную систему не так уж сложно (я оставлю это в качестве упражнения для читателя ... Я всегда хотел написать это!), Lua предлагает очень хороший предварительно протестированный вариант.
Код:
// Учитывая, что мы хотим сохранить ссылку на объект Lua поверх стека ...
const int objectRef = luaL_ref (ls, indexofatable);

// ... что-то происходит, может быть, следующий код находится в другой функции ...

// Поместить объект на вершину стека.
lua_rawgeti (ls, indexofatable, objectRef);

// ... опять же, следующий код может быть где угодно ...
luaL_unref (ls, indexofatable, objectRef);

// Теперь ссылка освобождена, не используйте ее снова.

Что ...!? Что это за индексный бизнес? Ну, ссылки Lua должны где-то жить, поэтому вам нужно указать, в какую таблицу поместить ссылку. Если у вас есть куча экземпляров 'Monster', которые вы хотите сохранить под рукой, то вы можете создать таблицу 'MonsterRef' в глобальном пространстве имен для отслеживания экземпляров 'Monster'. Да ... Я знаю ... это отстойно. Я думал, что ссылки должны были быть легкими и быстрыми. Ну, Луа накрыл это специальным столом; реестр.
Код:
const int objectRef = luaL_ref (ls, LUA_REGISTRYINDEX);

Доступ к реестру осуществляется с помощью специального псевдоиндекса стека, который служит хорошим опрятным местом для хранения ваших ссылок. Он также имеет преимущество в том, что доступ к нему осуществляется очень быстро, поскольку поиск имени для поиска таблицы не требуется. Говоря об этой теме, позвольте мне заверить вас, что у вас нет абсолютно никаких причин беспокоиться о производительности эталонной системы. Когда я только начинал работать с Lua, меня очень беспокоило снижение производительности при поиске ссылок каждый раз, когда к объектам Lua обращались из C ++. Мои опасения были абсолютно необоснованными. Поиск ссылок действительно быстрый, в основном это просто доступ к массиву.

Это подводит меня к общему мнению о производительности Lua: это очень хорошо. Как программист C ++, привыкший к кодированию медиа-конвейеров реального времени, я, естественно, был обеспокоен использованием этого необычного непрозрачного стекового интерфейса. Я думал, что если я хочу получить доступ к объекту Lua, мне нужно просто дать указатель и интерфейс. Хотя я нашел способы подтолкнуть Lua к пределам производительности (в процедурной генерации мира и AI, двух тяжелых процессорных задачах), профилирование показало, что мой чрезвычайно сложный игровой цикл Lua тратит только 2% своего времени на обработку вызовов Lua. Так что дерзайте и используйте справочную систему столько, сколько хотите. Это вряд ли повлияет на производительность.

Хорошие вещи, вот пример того, как мы можем использовать ссылки в нашей игре.
Код:
int world_insert ( lua_State * ls)
{ // Получить параметр self, экземпляр класса C ++ "World" luaL_checktype (ls, 1 , LUA_TTABLE); lua_getfield (ls, 1 , "core_" ); luaL_checktype (ls, - 1 , LUA_TUSERDATA); Мир * мир = reinterpret_cast <Мир *> (lua_touserdata (ls, - 1 )); lua_pop (ls, 1 ); // Получить параметр монстра. luaL_checktype (ls, 2 , LUA_TTABLE); lua_getfield (ls, 2 , "core_" ); luaL_checktype (ls, - 1











 , LUA_TUSERDATA); Monster * monster = reinterpret_cast <Monster *> (lua_touserdata (ls, - 1 )); lua_pop (ls, 1 ); // Получить координаты X и Y. luaL_checktype (ls, 3 , LUA_TNUMBER); luaL_checktype (ls, 4 , LUA_TNUMBER); const Vec2i loc ( lua_tointeger (ls, 3) , lua_tointeger (ls, 4) ) ; const bool result = world-> insert (monster, loc); // Нам нужно хранить ссылку где-нибудь, в этом примере мы // сохраним ее в фактическом экземпляре monster, в целочисленном свойстве















 // с именем 'ref'. if (result && monster-> ref () == LUA_NOREF) { // Мы успешно вставили монстра, давайте сохраним ссылку на него //, так что даже если скрипт Lua отпускает его дескриптор, мы можем / / по-прежнему доступ к нему через наш экземпляр класса "World". // Нам нужен объект, на который мы хотим сослаться сверху стека, // поэтому мы просто вытолкнем все сверху нашего экземпляра монстра, // который находится в позиции стека 2. lua_settop (ls, 2 ); const int ref = luaL_ref (ls, LUA_REGISTRYINDEX); monster-> setRef (ссылка); } lua_pushboolean (ls, результат); возврат 1 ;



















world_remove ( lua_State * ls)
{
 luaL_checktype (ls, 1 , LUA_TTABLE);
 lua_getfield (ls, 1 , "core_" );
 luaL_checktype (ls, - 1 , LUA_TUSERDATA); Мир * мир = reinterpret_cast <Мир *> (lua_touserdata (ls, - 1 ));
 lua_pop (ls, 1 );
luaL_checktype (ls, 2 , LUA_TTABLE); lua_getfield (ls, 2 , "core_" );
luaL_checktype (ls, - 1 , LUA_TUSERDATA); Monster * monster = reinterpret_cast <Monster *> (lua_touserdata (ls, - 1)








 ));
 lua_pop (ls, 1 ); монстр = мир-> удалить (монстр); if (monster) { luaL_unref (ls, LUA_REGISTRYINDEX, monster-> ref ()); monster-> setRef (LUA_NOREF); } return 0 ; }










Здесь происходит немало Мы работаем с гипотетическим классом C ++ под названием «Мир». Мировые объекты хранят монстров и отображают их в цикле рендеринга. Где-то в реализации World он держит указатель Monster, который мы даем ему в вызове insert, но для того, чтобы удерживать таблицу Lua и предотвратить ее уничтожение сборщиком мусора, нам нужно где-то сохранить ссылку. Я бы предпочел полностью исключить Lua из моих реализаций классов C ++, поэтому я собираюсь обрабатывать ссылки прямо здесь, на уровне привязки C ++ / Lua. К сожалению, мне все еще нужно где-то хранить дескриптор Lua, поэтому я решил оставить его в самом экземпляре класса C ++. Ссылки на Lua - это просто старые целые, поэтому мне не нужно импортировать Lua в файл класса, нужно только сделать публичное свойство int с именем ref.
Код:
Monster * monster = new (lua_newuserdata (ls, sizeof (Monster)) Monster; // Мы еще не создали ссылку. Monster-> setRef (LUA_NOREF);




Когда я хочу сохранить экземпляр монстра где-нибудь в своем коде C ++, я создам ссылку на него, а когда экземпляр больше не нужен моему движку, я освобождаю ссылку. Обратите внимание, что нет необходимости освобождать ссылку в метаметоде __gc, потому что этот метод никогда не будет вызываться, пока существует ссылка.

Работа со ссылками может быть подвержена ошибкам, особенно если вы выполняете это во многих различных функциях, поэтому вы можете захотеть написать класс RAII C ++, который будет обрабатывать его для вас. Я храню ссылки только на один вид объектов в моей игре, и на эти объекты ссылаются и не ссылаются в двух четко определенных функциях. Я считаю, что это лучшая стратегия управления ресурсами.

PS. Lua также поддерживает слабые ссылки. Обратитесь к документации Lua для деталей.

      Записан




Большая часть вашей личности без сознания.




Re: Встраивание Lua в C ++
« Ответ # 6: 28 октября 2011 г., 23:43:01»
________________________________________
Делать это аккуратно
________________________________________
Позвольте мне предварить этот раздел заявлением об отказе от ответственности, что в этом нет необходимости, и многие люди могут найти его с дурным вкусом. На этом учебное пособие по Lua C API заканчивается, и если вы довольны необработанным C API, то будьте на моем пути с моим благословением. Ниже приведено несколько специализаций шаблонов и плохо названных макросов препроцессора, сшитых вместе, чтобы сделать немного слишком умный мини-язык для связывания C ++ и Lua. Я повторю то, что я сказал в начале: это хорошо работает для меня, ваш пробег может отличаться.

В программировании есть трюизм, который гласит, что многократное написание утомительного кода увеличит количество ошибок. Возможно, вы заметили много утомительного кода в приведенных выше фрагментах, и вот где я собираюсь это исправить, используя самый ненавистный из всех средств C / C ++, препроцессор.

Препроцессор получил действительно плохой рэп. Как и goto, он изображается как анафема для хорошей разработки программного обеспечения. Я понимаю необходимость информировать людей об опасностях, но абсолютам не место в реальности, и я действительно видел несколько хорошо использованных гото в моей жизни. Зная об опасностях инструмента, мы гораздо лучше подготовлены к безопасному обращению с ним. Так что в следующем разделе учтите, что столкновение имен макросов УБИТ ЩЕНКОВ. Имена макросов, которые я использую, никак не конфликтуют с моим кодом, но могут конфликтовать с вашим.

Я не собираюсь объяснять все тонкости того, что происходит под капотом, потому что мы уже изучали Lua C API в разделах выше. Без лишних слов, вот основной набросок макро-языка макросов для связывания кода C ++ с Lua.

Вот первый компонент языка, как объявлять функции.
Код:
# define Lfunc (NAME) \ int NAME (lua_State * ls) {\ int _stackpos = 1 ; ( Пустоты ) _stackpos; \ bool _opts = true ; ( void ) _opts; \ try {





Обратите внимание на две переменные: _stackpos и _opts. Мы будем использовать их для извлечения параметров функций из стека. Следующее, что вы заметите, это то, что мы открываем блок try. Если вы хотите, чтобы Lua хорошо работал с разматыванием стека C ++ и обработкой исключений, то вам нужно включить исключения C ++ в luaconf.h и скомпилировать исходники Lua в виде кода C ++. Пока вы это делаете, внимательно посмотрите на luaconf.h, потому что он очень хорошо задокументирован, и вы можете найти там несколько интересных вещей.

Для передачи данных туда и обратно мы будем использовать удивительную мощь шаблонов. Компилятор определит тип параметров и возвращаемых значений для нас.
Код:
шаблон < typename T>
T parm_get ( lua_State *, int &) ;

шаблон < typename T>
T opts_get ( lua_State *, int &, T const &, bool &) ;

template < typename T>
int ret_push ( lua_State *, T const &) ;

//
// например, bool
//
typedef bool Lparm_Lbool;
шаблон <> bool parm_get ( lua_State * ls,int & stackpos)
{
 luaL_checktype (ls, stackpos, LUA_TBOOLEAN); вернутьlua_toboolean (ls, stackpos ++); }template<> bool opts_get ( lua_State * ls, int & stackpos, bool const & defaultval, bool & look) {if(look && lua_isboolean (ls, stackpos))вернутьlua_toboolean (ls, stackpos ++); смотреть =ложь; вернутьdefaultval; }template<> int ret_push ( lua_State * ls, bool const & b) {












 lua_pushboolean (ls, b); возврат 1 ; }



Благодаря специализации шаблонов для вышеуказанных типов, мы можем добавить поддержку любых данных, которые могут быть переведены в значения Lua и из них.
Код:
typedef Vec2i Lparm_LVec2i;
template <> Vec2i parm_get ( lua_State * ls, int & stackpos)
{
 luaL_checktype (ls, stackpos, LUA_TNUMBER);
 luaL_checktype (ls, stackpos + 1 , LUA_TNUMBER); return
Vec2i ( lua_tonumber (ls, stackpos ++), lua_tonumber (ls, stackpos ++)); } template <> Vec2i opts_get ( lua_State * ls, int & stackpos, Vec2i const & defaultval, bool & look) { if (look && lua_isnumber (ls, stackpos) && lua_isnumber (ls, stackpos + 1







 )) Возвращают Vec2i ( static_cast < INT > (lua_tointeger (LS, stackpos ++), static_cast < INT > (lua_tointeger (LS, stackpos ++)), смотрите = ложь ; возвращать defaultval; } // ... больше типов здесь ...









В приведенном выше примере мы берем два целых числа и превращаем их в Vec2i. Мы также можем взять таблицу Lua, содержащую поле core_, и превратить ее в экземпляр класса C ++. Просто будьте осторожны, чтобы параметр stackpos указывал на следующий неиспользуемый элемент стека.

Мы также предоставляем поддержку необязательных параметров со значениями по умолчанию. Подойдет любой способный к копированию тип C ++, просто обязательно установите для «look» значение false, если параметр отсутствует, чтобы мы прекратили искать дополнительные параметры, которых там нет.

Теперь посмотрим, как мы используем то, что мы создали, для автоматизации извлечения параметров и возврата значений.
Код:
#define Lparm (ТИП, ИМЯ) \
  Lparm ## _ ## ИМЯ ТИПА = parm_get <Lparm ## _ ## TYPE> (ls, _stackpos); #define Lopts (TYPE, NAME, DEFVAL) \ Lparm ## _ ## TYPE NAME = opts_get <TYPE> (ls, _stackpos, DEFVAL, _opts); #define Lcatch \ } catch (std :: exception const & err) {\ std :: cerr << err.what () << std :: endl; \ } catch (...) {\ std :: cerr << "неизвестное исключение." << endl; \ } #define Lret0 \ Lcatch \ lua_settop (ls, 0 ); \ return 0 ;



















 0 ); \ return ret_push (RET); \ }



Используя описанные выше typedefs, мы можем безопасно и легко извлечь все нужные параметры и вернуть все, что захотим, без какого-либо явного управления стеками Lua. Просто посмотрите на пример:
Код:
Lfunc (MovePointer)
 Lparm (Vec2i, distance)
 Lopts (Lfloat, speed, 1.0 ) const Vec2i pos = Game :: movePointer (distance, speed); Lretv (позы)





Довольно аккуратно! Мы можем легко получить доступ к переменным расстояния и скорости в нашем теле функции. Используя еще немного магии препроцессора, мы можем расширить наш маленький мини-язык для поддержки классов. Вместо того, чтобы переходить к скучным деталям, я покажу вам, как это выглядит, и, если вам нравится то, что вы видите, вы можете скопировать и вставить реализацию ниже.
Код:
Lfunc (Entity_new)
 Linst (Entity)
 Lret1 // Да, есть три (3) подчеркивания Lfunc (Entity ___ gc) luaL_checktype (ls, 1 , LUA_TUSERDATA); Entity * self = (Entity *) lua_touserdata (ls, 1 ); self -> ~ Entity (); Lret0 Lmeth (Entity, get_location) Lretv ( self -> location ()) Lmeth (Entity, move) Lparm (LVec2i, dist) const Vec2i pos = self -> move (dist); Lretv (pos) // Эта функция показывает, как вы можете вручную анализировать таблицу Lua Lmeth (Entity, load_sprite) Lparm (Lstring, идент) if (




















 self -> sprite (идент))
 { cerr << "Невозможно загрузить спрайт" " << идентификатор << ", спрайт уже использует этот идентификатор. " << endl; } else { // Извлечение параметра таблицы вручную. luaL_checktype (ls, _stackpos, LUA_TTABLE); векторные <string> текстуры; textures.reserve (lua_objlen (ls, _stackpos)); lua_pushnil (LS); while (lua_next (ls, _stackpos)) { // ключ имеет значение -2, val имеет значение -1 textures.push_back (lua_tostring (ls, - 1 )); lua_pop (ls, 1 ); } auto_ptr <Sprite>



















  for (vector <string> :: iterator i = textures.begin (); i! = textures.end (); ++ i) {
 sprite-> addFrame (* i); }
if ( self -> insertSprite (идент. sprite.get ())) sprite.release (); }
Lret0 Lmeth (Entity, set_sprite) Lparm (Lstring, идент) self -> activSprite (идент ); Lret0 // Определяем интерфейс для Entity Linterface_start (Entity) Linterface (Entity, __gc) Linterface (Entity, move) Linterface (Entity, get_location) Linterface (Entity, load_sprite) Linterface (Entity, set_sprite) Linterface_end void LuaExtate l ( ls) {


   }int main() {

    lua_State *L = luaL_newstate();
    luaL_openlibs(L);

    /* chunk A */
    luaL_dostring(L, "local vec2 = {x=3, y=4}\n"
        "function setup()\n"
        "return vec2\n"
        "end\n");
    /* chunk B */
    luaL_dostring(L, "function test(p)\n"
        "print(p.x)\n"
        "end\n");

    /* call setup function */
    int top = lua_gettop(L);
    lua_getglobal(L, "setup");

    if (lua_pcall(L, 0, LUA_MULTRET, 0))
    {
        std::cout << lua_tostring(L, -1) << '\n';
        lua_pop(L, 1);

        exit(EXIT_FAILURE); // simpy fail for demo
    }

    /* check the return value */
    if (lua_gettop(L) - top)
    {
        // the top now contains the value returned from setup()

        /* call test function */
        lua_getglobal(L, "test");

        // copy the original value as argument
        lua_pushvalue(L, -2);

        if (lua_pcall(L, 1, 0, 0))
        {
            std::cout << lua_tostring(L, -1) << '\n';
            lua_pop(L, 1);
            exit(EXIT_FAILURE);
        }

        // drop the original value
        lua_pop(L, 1);

    }
    else
    {
        // nothing is returned, nothing to do
    }
    lua_close(L);// закрыть состояние
    cin.get();//ожидает ввода символа программа завершается.

    return 0;
}


class Foo
{
public:
    Foo(const std::string & name) : name(name)
    {
        std::cout << "Foo is born" << std::endl;
    }

//  std::string Add(int a, int b)
    //{
        //std::stringstream ss;
        //.ss << name << ": " << a << " + " << b << " = " << (a + b);
        //return ss.str();
//  }

    ~Foo()
    {
        std::cout << "Foo is gone" << std::endl;
    }

private:
    std::string name;
};

// The general pattern to binding C++ class to Lua is to write a Lua
// thunk for every method for the class, so here we go:

int l_Foo_constructor(lua_State * L)
{
    const char * name = luaL_checkstring(L, 1);

    // We could actually allocate Foo itself as a user data but
    // since user data can be GC'ed and we gain unity by using CRT's heap
    // all along.
    Foo ** udata = (Foo **)lua_newuserdata(L, sizeof(Foo *));
    *udata = new Foo(name);

    // Usually, we'll just use "Foo" as the second parameter, but I
    // say luaL_Foo here to distinguish the difference:
    //
    // This 2nd parameter here is an _internal label_ for luaL, it is
    // _not_ exposed to Lua by default.
    //
    // Effectively, this metatable is not accessible by Lua by default.
    luaL_getmetatable(L, "luaL_Foo");

    // The Lua stack at this point looks like this:
    //
    //     3| metatable "luaL_foo"   |-1
    //     2| userdata               |-2
    //     1| string parameter       |-3
    //
    // So the following line sets the metatable for the user data to the luaL_Foo
    // metatable
    //
    // We must set the metatable here because Lua prohibits setting
    // the metatable of a userdata in Lua. The only way to set a metatable
    // of a userdata is to do it in C.
    lua_setmetatable(L, -2);

    // The Lua stack at this point looks like this:
    //
    //     2| userdata               |-1
    //     1| string parameter       |-2
    //
    // We return 1 so Lua callsite will get the user data and
    // Lua will clean the stack after that.

    return 1;
}

Foo * l_CheckFoo(lua_State * L, int n)
{
    // This checks that the argument is a userdata
    // with the metatable "luaL_Foo"
    return *(Foo **)luaL_checkudata(L, n, "luaL_Foo");
}

int l_Foo_add(lua_State * L)
{
    Foo * foo = l_CheckFoo(L, 1);
    int a = (int)luaL_checknumber(L, 2);
    int b = (int)luaL_checknumber(L, 3);

    //std::string s = foo->Add(a, b);
    //lua_pushstring(L, s.c_str());

    // The Lua stack at this point looks like this:
    //
    //     4| result string          |-1
    //     3| metatable "luaL_foo"   |-2
    //     2| userdata               |-3
    //     1| string parameter       |-4
    //
    // Return 1 to return the result string to Lua callsite.

    return 1;
}

int l_Foo_destructor(lua_State * L)
{
    Foo * foo = l_CheckFoo(L, 1);
    delete foo;

    return 0;
}

void RegisterFoo(lua_State * L)
{
    luaL_Reg sFooRegs[] =
    {
        { "new", l_Foo_constructor },
        { "add", l_Foo_add },
        { "__gc", l_Foo_destructor },
        { NULL, NULL }
    };

    // Create a luaL metatable. This metatable is not
    // exposed to Lua. The "luaL_Foo" label is used by luaL
    // internally to identity things.
    luaL_newmetatable(L, "luaL_Foo");

    // Register the C functions _into_ the metatable we just created.
    luaL_setfuncs(L, sFooRegs, 0);

    // The Lua stack at this point looks like this:
    //
    //     1| metatable "luaL_Foo"   |-1
    lua_pushvalue(L, -1);

    // The Lua stack at this point looks like this:
    //
    //     2| metatable "luaL_Foo"   |-1
    //     1| metatable "luaL_Foo"   |-2

    // Set the "__index" field of the metatable to point to itself
    // This pops the stack
    lua_setfield(L, -1, "__index");

    // The Lua stack at this point looks like this:
    //
    //     1| metatable "luaL_Foo"   |-1

    // The luaL_Foo metatable now has the following fields
    //     - __gc
    //     - __index
    //     - add
    //     - new

    // Now we use setglobal to officially expose the luaL_Foo metatable
    // to Lua. And we use the name "Foo".
    //
    // This allows Lua scripts to _override_ the metatable of Foo.
    // For high security code this may not be called for but
    // we'll do this to get greater flexibility.
    lua_setglobal(L, "Foo");
}
int main(int argc, char *argv[]) {
    const char* LUA = R"(
-- to Foo
function Foo:speak()
    print("Hello, I am a Foo")
end

local foo = Foo.new("fred")
--local m = foo:add(3, 4)

-- "fred: 3 + 4 = 7"
print(m)

-- "Hello, I am a Foo"
foo:speak()

-- Let's rig the original metatable
Foo.add_ = Foo.add
--//function Foo:add(a, b)
  --  return "here comes the magic: " .. self:add_(a, b)
--end

--m = foo:add(9, 8)

-- "here comes the magic: fred: 9 + 8 = 17"
--print(m)
   )";

    lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    RegisterFoo(L);
    checkerror(L, LUA);

    lua_pcall(L, 0, 0, 0);// вызвать функцию.

    lua_close(L);

    cin.get();//ожидает ввода символа программа завершается.
    return 0;
}


class Foo
{
public:
    Foo(const std::string & name) : name(name)  {
        std::cout << "Foo create" << std::endl;
    }

    ~Foo(){
        std::cout << "Foo destory" << std::endl;
    }

private:
    std::string name;
};

int l_Foo_constructor(lua_State * L){
    const char * name = luaL_checkstring(L, 1);
    Foo ** udata = (Foo **)lua_newuserdata(L, sizeof(Foo *));
    *udata = new Foo(name);
    luaL_getmetatable(L, "luaL_Foo");
    lua_setmetatable(L, -2);
    return 1;
}

Foo * l_CheckFoo(lua_State * L, int n){
    return *(Foo **)luaL_checkudata(L, n, "luaL_Foo");
}

int l_Foo_add(lua_State * L){
    Foo * foo = l_CheckFoo(L, 1);
    int a = (int)luaL_checknumber(L, 2);
    int b = (int)luaL_checknumber(L, 3);
    return 1;
}

int l_Foo_destructor(lua_State * L){
    Foo * foo = l_CheckFoo(L, 1);
    delete foo;
    return 0;
}

void RegisterFoo(lua_State * L){
    luaL_Reg sFooRegs[] =
    {
        { "new", l_Foo_constructor },
        { "add", l_Foo_add },
        { "__gc", l_Foo_destructor },
        { NULL, NULL }
    };

    luaL_newmetatable(L, "luaL_Foo");

    // Register the C functions _into_ the metatable we just created.
    luaL_setfuncs(L, sFooRegs, 0);/*    void luaL_setfuncs(lua_State * L, const luaL_Reg * l, int nup);
    Регистрирует все функции в массиве l(см.luaL_Reg) В таблице на вершине стека(ниже необязательных
    значений повышений).Когда nupне ноль, все функции создаются с nup общими значениями повышения, которые
    должны быть предварительно помещены в стек поверх таблицы библиотеки. Эти значения выталкиваются
    из стека после регистрации.*/

    lua_pushvalue(L, -1);
    lua_setfield(L, -1, "__index");

    lua_setglobal(L, "Foo");
}
int main(int argc, char *argv[]) {
    const char* LUA = R"(
function Foo:speak()
    print("Hello, I am a Foo")
end

local foo = Foo.new("fred")
foo:speak()
   )";

    lua_State *L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);
    RegisterFoo(L);
    checkerror(L, LUA);

    lua_pcall(L, 0, 0, 0);// вызвать функцию.

    lua_close(L);

    cin.get();//ожидает ввода символа программа завершается.
    return 0;
}



void search(string res, vector<lua_State*>&luastate) {
    lua_State* L = luaL_newstate();/*Функция создает новое Lua состояние. Она вызывает lua_newstate с функцией-*/
    luaL_openlibs(L);

    cout << "adres " << L << endl; //||!!!тут вы брали адрес указателя, поэтому он был всегда одинаковым
    luastate.push_back(L);// !!! вот так
    int status = luaL_loadfile(L, res.c_str());// проверка есть ли ошибки.
    if (status == 0) {// если нет ошибки в файле.
        //luaL_dofile(L, res.c_str());// запуск файла.
        lua_pcall(L, 0, 0, 0);
        lua_getglobal(L, "main");// получаем из lua функцию pri.
        lua_pcall(L, 0, 0, 0);
        string load = "loaded ";
        string er0 = load + res;
        writelog(er0.c_str());
    }//.
    else {
        string er1 = lua_tostring(L, -1);
        string er = "could not load ";
        string er0 = er + er1;
        writelog(er0.c_str()); //!!! writelog должен быть объявлен принимающим const char * (если вдруг он у вас просто char *)
    }
};
int main(int argc, char* argv[]) {

 vector<lua_State*>luastate;
  vector<thread>t;
    for (auto const& de : fs::recursive_directory_iterator{ fs::current_path() / "lualoader" }) { // папка для поиска

        if (de.path().extension() == ".lua" || de.path().extension() == ".LUA") {
            string res = de.path().string();// имя в файла в строку
            t.push_back(move((std::thread(search, res, std::ref(luastate)))));
        }
    };
    for (auto& i : t)
    {
        i.detach();

    };
    cin.get();
for (auto L : luastate) {
        cout << &L << endl;
lua_close(L);
    }
    return 0;


};


Записать элемента стек в файл.

void showstack1(lua_State* L) {
    int i = lua_gettop(L);/* получаем количество элементов в стеке.*/
    string path = "stack.txt";
    fstream f1; {f1.open(path, fstream::in | fstream::out | fstream::app);
    int j = (i) * -1 - 1;
    i = -1;
    for (i; i > j; i--) {
        int t = lua_type(L, i);
        if (LUA_TSTRING == t) {
            f1 << "str ";
             f1 << i; f1 << "\n";
        }
        if (LUA_TNUMBER == t) {
            f1 << "number ";
            f1 << i; f1 << "\n";        }

        if (LUA_TBOOLEAN == t) {
            f1 << "LUA_TBOOLEAN ";
            f1 << i; f1 << "\n";    }
        if (LUA_TLIGHTUSERDATA == t) {
            f1 << "LIGHTUSERDATA ";
            f1 << i; f1 << "\n";
        }
        if (LUA_TTABLE == t) {
        f1 << "LUA_TTABLE ";
        f1 << i; f1 << "\n";
        }
        if (LUA_TFUNCTION == t) {

            f1 << "funs ";
            f1 << i; f1 << "\n";
        }
        if (LUA_TUSERDATA == t) {
            f1 << "user ";
            f1 << i; f1 << "\n";
        }
        if (LUA_TTHREAD == t) {
            cout << "LUA_TTHREAD " << endl;
        }
        if (LUA_TNIL == t) {
            cout << "LUA_TNIL " << endl;
        }
    }
    f1.close(); }
};