#include <windows.h>
#include <string>

#include <lua.hpp>


BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved) {
    return TRUE;
}

std::string CheckStack(lua_State* L, std::string message = "") {
    std::string str = "";
    int top = lua_gettop(L);

    for (int i = -1; i >= 0 - top; i--) {
        std::string type_name = luaL_typename(L, i);
        std::string s = "", ls = "", t = "";

        switch (lua_type(L, i)) {
        case LUA_TNONE: t = "LUA_TNONE"; break;
        case LUA_TNIL: t = "LUA_TNIL "; break;
        case LUA_TBOOLEAN:
            s = lua_toboolean(L, i) ? "true" : "false";
            t = "LUA_TBOOLEAN ";
            break;
        case LUA_TLIGHTUSERDATA: t = "LUA_TLIGHTUSERDATA "; break;
        case LUA_TNUMBER:
            s = std::to_string(lua_tonumber(L, i));
            t = "LUA_TNUMBER ";
            break;
        case LUA_TSTRING:
            ls = lua_tostring(L, i);
            s = "\"" + ls + "\"";
            t = "LUA_TSTRING ";
            break;
        case LUA_TTABLE: t = "LUA_TTABLE "; break;
        case LUA_TFUNCTION: t = "LUA_TFUNCTION "; break;
        case LUA_TUSERDATA: t = "LUA_TUSERDATA "; break;
        case LUA_TTHREAD: t = "LUA_TTHREAD "; break;
        }

        str += "|" + std::to_string(i) + "; " + std::to_string(top + i + 1) + "| "
            + t + type_name + " " + s + "\n";
    }

#ifdef UNICODE
    MessageBoxW(NULL, str.c_str(), message.c_str(), MB_OK);
#else
    MessageBoxA(NULL, str.c_str(), message.c_str(), MB_OK);
#endif
    return str;
}

void F() {
    lua_State* L1 = luaL_newstate();
    lua_State* L2 = luaL_newstate();
    lua_newtable(L1);
    lua_newtable(L2);
    // заполняем таблицу:
    lua_pushstring(L1, "QW");
        CheckStack(L1, "1 L1");
    lua_pushnumber(L1, 11);
        CheckStack(L1, "2 L1");
    lua_settable(L1, -3);
        CheckStack(L1, "3 L1");
    // возвращаем из таблицы значение:
    lua_pushstring(L1, "QW");
        CheckStack(L1, "4 L1");
    lua_gettable(L1, -2);
        CheckStack(L1, "5 L1");
    // вводим ключ:
    lua_pushstring(L1, "QW");
        CheckStack(L1, "6 L1");
    // меняем ключ изначение местами:
    lua_insert(L1, -2);
        CheckStack(L1, "7 L1");
    // переносим ключ и значение из L1 в L2:
    lua_xmove(L1, L2, 2);
        CheckStack(L1, "8 L1");
        // на стеке L2 ключ и значение в нужном порядке!
        CheckStack(L2, "1 L2");
    // вводим ключ и значение в таблицу в L2:
    lua_settable(L2, -3);
        CheckStack(L2, "2 L2");
    // вводим ключ:
    lua_pushstring(L2, "QW");
        CheckStack(L2, "3 L2");
    // возвращаем значение:
    lua_gettable(L2, -2);
    // и - ничего не получили!
        CheckStack(L2, "4 L2");

    lua_close(L1);
    lua_close(L2);
    //==================================================
     
    // А этод код работает!
    lua_State* L3 = luaL_newstate();
    lua_State* L4 = luaL_newstate();
    lua_newtable(L3);
    lua_newtable(L4);
    // заполняем таблицу:
    lua_pushstring(L3, "QW");
    lua_pushnumber(L3, 11);
    lua_settable(L3, -3);
    // возвращаем из таблицы значение:
    lua_pushstring(L3, "QW"); 
        CheckStack(L3, "1 L3");
    // возвращаем из таблицы значение:
    lua_gettable(L3, -2);
        CheckStack(L3, "2 L3");

    // вводим ключ в L4:
    lua_pushstring(L4, "QW");
        CheckStack(L4, "1 L4");
    // переносим значение из L3 в L4:
    lua_xmove(L3, L4, 1);
        CheckStack(L4, "2 L4");
    // заполняем таблицу:
    lua_settable(L4, -3);
        CheckStack(L4, "3 L4");
    // вводим ключ:
    lua_pushstring(L4, "QW");
        CheckStack(L4, "4 L4");
    // возвращаем значение:
    lua_gettable(L4, -2);
    // всё в порядке!
        CheckStack(L4, "5 L4");

    lua_close(L3);
    lua_close(L4);
}

int Start(lua_State* L) { F(); return 0; }

static struct luaL_Reg ls_lib[] = {{ "Start", Start },{NULL, NULL}};

extern "C" __declspec(dllexport) int luaopen_LuaSt(lua_State* L) {
    luaL_newlib(L, ls_lib);
    return 1;
}

lua_State* L_global;
int static nummer_table_from_stack;

void SetUpdateCallcak_wrapper(lua_State* L)
{

    L_global = L;
    std::cout << "L_global_adress:" << &L_global << std::endl;


    //-----------------------------------------------------------------1-Вызовем функцию CreateDataSource:Начало--------------------------------------------
    lua_getglobal(L, "CreateDataSource");                 

    lua_pushstring(L, "TQBR");       //Добавим первый параметр функции CreateDataSource на вершину стека
    lua_pushstring(L, "SBER");          //Добавим второй параметр функции CreateDataSource на вершину стека
    lua_pushnumber(L, 1);            //Добавим третий параметр функции CreateDataSource на вершину стека

    int status_lua_pcall = lua_pcall(L, 3, 2, 0);    //Так как все необходимые параметры добавлены в стек, то вызываем функцию lua_pcall - которая использя доабвенные параметры в правильном порядке - реализует вызов функции CreateDataSource: 2-ой параметр - это число аргументов, которые мы добаили в стек и которая принимает функция CreateDataSource; 2-ой: параметр - это число параметров, которое возвращает функция CreateDataSource. После успешного выполнения lua_pcall удаляет и значение функции и переданные аргменты со стека в кол-во указанном во втором параметре(не велючая функцию) и доабвляеи результат на стек в кол-во указанном во втором параметре.
    //-----------------------------------------------------------------1-Вызовем функцию CreateDataSource:Конец--------------------------------------------



    //-------------------------------------------------------------------5-Проверка на ошибку lua_pcall:Начало---------------------------------------------------------------------
    if (status_lua_pcall != 0)
    {
        //Ошибка произошла при вызове функции lua_pcall при вызове CreateDataSource:
        std::cout << "ERROR CreateDataSource" << std::endl;
        return;
    }
    //-------------------------------------------------------------------5-Проверка на ошибку lua_pcall:Конец---------------------------------------------------------------------
    else
    {

         nummer_table_from_stack = lua_gettop(L) - 1;   //Это номер элемента в стеке L - в котором теперь размещается полученная от CreateDataSource таблица. "-1" - потому что CreateDataSource поместила на вершину стека две перменные: таблицу и переменную об ошибке. То есть таблица находить на предпоследнем месте с вершины стека.

         my_call_SetUpdateCallback(L);     //Вызываем SetUpdateCallback wrapper
    }

}

l
static void ckeck_Lua_Stack(lua_State* L)
{

    std::cout << "----------------------------------------" << std::endl;

    int top = lua_gettop(L);
    std::cout << "Total element is stack:"<< top << std::endl;

    for (int i = 1; i <= top; i++) 
    {
        int type = lua_type(L, i);

        const char* type_name = lua_typename(L, type);

        std::cout << "type:" << type_name << ":";


        if (type == LUA_TSTRING || type == LUA_TNUMBER) 
        {
            std::cout << lua_tostring(L, i) << std::endl;
        }
        else
        {
            std::cout << std::endl;
        }
    }
    std::cout << "----------------------------------------" << std::endl << std::endl;


    //std::this_thread::sleep_for(std::chrono::milliseconds(100000));

}

static int my_callback__for__SetUpdateCallback(lua_State* L)
{

//Значит произошла сделка!

    std::cout << "Number_candle:"<< lua_tonumber(L, -1) << std::endl;

    ckeck_Lua_Stack(L_global);         //Проверяем стек Lua!!! И теперь в нем находится сдедующее:

----------------------------------------
Total element is stack:1                          //Куда черт возьми делать моя ранее заказанная таблица CreateDataSource ?????
type:number:1
----------------------------------------


    return 0;

}

static void my_call_SetUpdateCallback(lua_State* L)
{

    
    //--------------------------------------------------------
    lua_getfield(L_global, nummer_table_from_stack, "SetUpdateCallback");                       //"Извлекаем" из "таблицы" функцию SetUpdateCallback.
     
    lua_pushvalue(L_global, nummer_table_from_stack);                                                       //Помещаем копию обьекта таблицы CreateDataSource на вершину стека.
    //--------------------------------------------------------


    lua_pushnumber(L_global, 555);  //Просто для примера связываю какое то любое значение для передачи в колбек. 

    lua_pushcclosure(L_global, my_callback__for__SetUpdateCallback, 1);       //Захватываем.


    //--------------------------------------------------------
    int status_lua_pcall = lua_pcall(L_global, 2, 0, 0);                  //Реализауем вызов функции SetUpdateCallback с аргументом таблицы, которую поместили на вершину стека 
    //--------------------------------------------------------
    

    if (status_lua_pcall != 0)
    {
        std::cout << "lua_pcall__ERROR" << std::endl;
        return; 
    }
    else
    {
        std::cout << "SetUpdateCallback Success Call" << std::endl;
        
        ckeck_Lua_Stack(L_global);       //Проверяю что находится на данный момент в стеке Lua.

       //Находится следующее:

 ----------------------------------------
Total element is stack:3
type:string:1     //Таблица глобьальный функций
type:table:        //Это как раз запрошенная таблица CreateDataSource
type:nil:            //Ошибка при запросе таблицы CreateDataSource - то есть nil - ошибки нет.
----------------------------------------

        return;
    }


}

lua_getglobal(L, "OnAllTrade ");

       //index - номер таблицы в стеке Lua

    lua_getfield(L, index, "Size");            //"Извлекаем" из "таблицы" функцию отвечающую за возвращения размера этой таблицы.
    lua_pushvalue(L, index);                //Помещаем копию обьекта таблицы на вершину стека.

    int status_lua_pcall = lua_pcall(L, 1, 1, 0);      //Вызываем функцию Size 

    lua_getfield(L, index, "bid_count");            //"Извлекаем" из "таблицы" функцию отвечающую за возвращения размера этой таблицы.
    lua_pushvalue(L, index);                //Помещаем копию обьекта таблицы на вершину стека.

    int status_lua_pcall = lua_pcall(L, 1, 1, 0);      //Вызываем функцию Size 

global_cntr=0;



function my_callback_CreateDataSource_(my_table_data_candle_, code_class_, code_paper_, interval_, idx)


message(code_paper_ ..":" .. interval_string_..":" ..tostring(my_table_data_history_candle_:C(idx))  )




if global_cntr == 13 then

my_table_data_history_candle_:Close()     --отписываемся
message("CLOSE")

end
global_cntr=global_cntr+1


end








function main()

message("start")

local code_class_1= "TQBR"          
local code_paper_1= "SBER"
local intervakla_1= INTERVAL_M1



local my_table_1, error_desc_1 = CreateDataSource(code_class_1, code_paper_1, intervakla_1)  


------------------------Проверка на ошибки:-------------------
if error_desc_1 ~= nil then 
message("1:" .. error_desc_1)
end
--------------------------------------------------------------

status = my_table_1:SetUpdateCallback(function(idx)my_callback_CreateDataSource_(my_table_1, code_class_1, code_paper_1, intervakla_1, idx) end)









while not stopped do 

sleep(1)

if global_cntr == 14 then

message("START_2")

local code_class_1= "TQBR"          
local code_paper_1= "SBER"
local intervakla_1= INTERVAL_M1



local my_table_2, error_desc_2 = CreateDataSource(code_class_1, code_paper_1, intervakla_1)  


------------------------Проверка на ошибки:-------------------
if error_desc_2 ~= nil then 
message("1:" .. error_desc_2)
end
--------------------------------------------------------------

status = my_table_2:SetUpdateCallback(function(idx)my_callback_CreateDataSource_(my_table_2, code_class_1, code_paper_1, intervakla_1, idx) end)

message(tostring(status))

global_cntr = global_cntr + 1

message("END")
break

end


end








-------------------------
while not stopped do 
sleep(1)
end 
-------------------------



end -- end main()

#include <windows.h>
#include <process.h>

// необходимые для Lua константы
#define LUA_LIB
#define LUA_BUILD_AS_DLL

// заголовочные файлы LUA
extern "C" {
#include "Lua\lauxlib.h"
#include "Lua\lua.h"
}

TCHAR CommandMemory[] = TEXT("Memory4CommandGetCandles");
TCHAR CandlesMemory[] = TEXT("Memory4GetCandles");

HANDLE CommandFileMap = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, 64, CommandMemory);
HANDLE CandlesFileMap = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, 128, CandlesMemory);

// точка входа DLL
BOOL APIENTRY DllMain(HANDLE hModule, DWORD  ul_reason_for_call, LPVOID lpReserved)
{
    return TRUE;
}

// функция отправки команд из программы в Lua скрипт
static int forLua_GetCommand(lua_State* L)
{
    if (CommandFileMap) // если память существует
    {
        // считываем данные из памяти и переводим в набор байтов
        PBYTE pb = (PBYTE)(MapViewOfFile(CommandFileMap, FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, 64));
        if (pb != NULL) // если есть данные
        {
            if (pb[0] == 0) // если первый байт нулевой
            {
                lua_pushstring(L, ""); // отправляем пустую строку в Lua скрипт
            }
            else
            {
                lua_pushstring(L, (char*)(pb));//иначе отправляем набор байтов в Lua скрипт
            }


            UnmapViewOfFile(pb); // закрываем доступ к данным
        }
        else
        {
            lua_pushstring(L, ""); // иначе отправляем пустую строку в Lua скрипт
        }
    }
    else
    {
        lua_pushstring(L, ""); // иначе отправляем пустую строку в Lua скрипт
    }

    return(1);
}

// функция очистки памяти для отправки команд
static int forLua_ClearCommand(lua_State* L)
{
    if (CommandFileMap)//если память существует
    {
        // считываем данные из памяти и переводим в набор байтов
        PBYTE pb = (PBYTE)(MapViewOfFile(CommandFileMap, FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, 64));

        if (pb != NULL) // если есть данные
        {
            // заполняем нулевыми байтами
            for (int i = 0; i < 64; i++)
            {
                pb[i] = '\0';
            }

            UnmapViewOfFile(pb); // закрываем доступ
        }
    }

    return(0);
}

// функция отправки свечек из lua в программу
static int forLua_SendCandle(lua_State* L)
{
    if (CandlesFileMap) // если память существует
    {
        // считываем данные из памяти и переводим в набор байтов
        PBYTE pb = (PBYTE)(MapViewOfFile(CandlesFileMap, FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, 128));
        if (pb != NULL) // если есть данные
        {
            const char* Candle = lua_tostring(L, 1); // переменная для хранения данных
            int Size = 0;

            for (int i = 0; i < 128; i++)
            {
                if (Candle[i] == 0)
                {
                    break;
                }
                else
                {
                    Size++;
                }
            }

            memcpy(pb + 1, Candle, Size); // копируем 
            memcpy(pb, "1", 1);
            UnmapViewOfFile(pb); // закрываем доступ
        }
    }

    return(0);
}

// регистрация реализованных в dll функций, чтобы они стали "видимы" для Lua
static const struct luaL_Reg ls_lib[] = {
    { "GetCommand", forLua_GetCommand },
    { "ClearCommand", forLua_ClearCommand },
    { "SendCandle", forLua_SendCandle },
    { NULL, NULL }
};

// регистрация названия библиотеки, видимого в скрипте Lua
extern "C" LUALIB_API int luaopen_GetCandlesDll(lua_State * L) {
    lua_newtable(L);
    luaL_setfuncs(L, ls_lib, 0);
    lua_setglobal(L, "GetCandlesDll");
    return 1;
}

require("GetCandlesDll");

local Candle = "";
local LastQty = 1;
local CurrentQty = 1;
local DataSet;
local IsOnline = false;
local IsRun = true;

local Minute = "";
local Hour = "";

local Day = "";
local Month = "";
local Year = "";

local High = "";
local Low = "";
local Open = "";
local Close = "";

local ClassName = "TQBR";
local ToolName = "YNDX";

function OnInit()
    DataSet = CreateDataSource(ClassName, ToolName, INTERVAL_M1);
end;

function OnStop()
    IsRun = false;
end;

function main()
    while IsRun do
        if tostring(GetCandlesDll.GetCommand()) == "run" then
            IsOnline = true;
            DataSet = CreateDataSource(ClassName, ToolName, INTERVAL_M1);
            GetCandlesDll.ClearCommand();
        end;
        
        if tostring(GetCandlesDll.GetCommand()) == "stop" then
            StopScript();
        end;

        if IsOnline == true then
            CurrentQty = DataSet:Size() - 1;

            if CurrentQty ~= nil and CurrentQty > LastQty then
                for i = LastQty, CurrentQty do
                    if (i == CurrentQty) then
                        LastQty = CurrentQty;
                    end;

                    if tostring(GetCandlesDll.GetCommand()) == "stop" then
                        StopScript();

                        break;
                    end;

                    Minute = tonumber(DataSet:T(i).min) < 10 and "0"..tostring(DataSet:T(i).min) : tostring(DataSet:T(i).min);
                    Hour = tonumber(DataSet:T(i).hour) < 10 and "0"..tostring(DataSetDataSetT(i).hour) : tostring(DataSet:T(i).hour);

                    Day = tonumber(DataSet:T(i).day) < 10 and "0"..tostring(DataSet:T(i).day) : tostring(DataSet:T(i).day);
                    Month = tonumber(DataSet:T(i).month) < 10 and "0"..tostring(DataSet:T(i).month) : tostring(DataSet:T(i).month);
                    Year = tostring(DataSet:T(i).year);
                    
                    High = tostring(DataSet:H(i));
                    Low = tostring(DataSet:L(i));
                    Open = tostring(DataSet:O(i));
                    Close = tostring(DataSet:C(i));
                    
                    Candle = Day.."."..Month.."."..Year.." "..Hour..":"..Minute..":".."00"..";"..High..";"..Low..";"..Open..";"..Close..";";

                    sleep(1);
                end;
            end;
        end;

        sleep(1000);
    end;
end;

function StopScript()
    GetCandlesDll.ClearCommand()
    IsOnline = false;
    LastQty = 1;
    Candle = "";

    if DataSet:Size() ~= nil then 
        DataSet:Close(); 
    end;
end;

int my_callback(lua_State* L)
{
//Доп.пераметры извелкаем через lua_upvalueindex.

std::cout<<"interval_int:" <<interval_int <<std::endl;
}



void my_call_CreateDataSource(lua_State* L_, name_class_insrument, name_code_paper, interval_int)
{
lua_getglobal(L, "CreateDataSource");          

lua_pushstring(L,_ name_class_insrument);    
lua_pushstring(L_, name_code_paper);        
lua_pushnumber(L_, interval_int);                

int status_lua_pcall = lua_pcall(L, 3, 2, 0); 



my_call_SetUpdateCallback(L_, my_callback, name_class_insrument, name_code_paper, interval_int);    //Вызываем SetUpdateCallback и передаем в нее функцкиб обратного вызова и доп.параметры.
}


int ruc_cpp(lua_State* L_main)
{



lua_State* L_1 = lua_newthread(L_main);       //Создаю "поток" связанный с главным стеком.
lua_State* L_2 = lua_newthread(L_main);


my_call_CreateDataSource(L_1 , "TQBR", "GAZP", "INTERVAL_H2");
my_call_CreateDataSource(L_2 , "TQBR", "GAZP", "INTERVAL_H4");






    //-----------------------------------------------
    for (int i = 0; i < 1000000; i++)
    {
        std::this_thread::sleep_for(std::chrono::milliseconds(100)); 
    }
    //-----------------------------------------------
}

function my_callback_CreateDataSource_HISTORY(my_table_data_history_candle_, code_class, code_paper, interval)

message("SIZE_TABLE:" ..tostring(my_table_data_history_candle_:Size()) )

my_table_data_history_candle_:Close()     --отписываемся от callback`а. Нужен только первый вызов.

end


function my_callback_CreateDataSource_HISTORY_1(my_table_data_history_candle_, code_class, code_paper, interval)

message("SIZE_TABLE:" ..tostring(my_table_data_history_candle_:Size()) )

--Этот колбек уже не вызывается.

end






function main()

local code_class_= "TQBR"          
local code_paper_= "ZVEZ"           
local interval_= INTERVAL_W1

my_table_, error_desc = CreateDataSource(code_class_, code_paper_, interval_)  

------------------------Проверка на ошибки:-------------------
if error_desc ~= nil then 
message(error_desc)
end
--------------------------------------------------------------

my_table_:SetUpdateCallback(function(idx)my_callback_CreateDataSource_HISTORY(my_table_, code_class_, code_paper_, intervakla_) end)




code_class_= "TQBR"          
code_paper_= "ZVEZ"           
interval_= INTERVAL_M15   


my_table_1, error_desc_1 = CreateDataSource(code_class_, code_paper_, interval_) 

------------------------Проверка на ошибки:-------------------
if error_desc_1 ~= nil then 
message(error_desc_1)
end
--------------------------------------------------------------

my_table_1:SetUpdateCallback(function(idx)my_callback_CreateDataSource_HISTORY_1(my_table_1, code_class_, code_paper_, intervakla_) end)



-------------------------
while not stopped do 
sleep(1)
end 
-------------------------


end -- end main()

static int my_pushcclosure_func(lua_State* L)
{
    std::cout << "Size_L:" <<gettop(L) << std::endl;    //Размер равен нулю.

    std::cout << "PARAM1:" << lua_tostring(L, lua_upvalueindex(1)) << std::endl;    //Тут будет param1
    std::cout << "PARAM2:" << lua_tostring(L, lua_upvalueindex(2)) << std::endl;    //Тут будет param2
}



    lua_pushstring(L, "param1");
    lua_pushstring(L, "param2");
    lua_pushcclosure(L, my_pushcclosure_func, 2);

    int status_lua_pcall = lua_pcall(L, 0, 0, 0);  

function main()

Quik_Lua_connector= require("Quik_Lua_connector")    

Quik_Lua_connector.run_Cpp() 

-------------------------
while not stopped do 
sleep(1)
end 
-------------------------
end

static int run_Cpp(lua_State* Lua_main) 
{

lua_State* L = lua_newthread(Lua_main);

std::cout << "SIZE_MAIN_STACK:" << lua_gettop(Lua_main) << std::endl;
lua_close(L);            //Квик тупо ЗАКРЫВАЕТСЯ
std::cout << "SIZE_MAIN_STACK:" << lua_gettop(Lua_main) << std::endl;
}

function main()

Quik_Lua_connector= require("Quil_Lua_connector_work_TEST")    

Quik_Lua_connector.TestFunc_run_WinConsole_for_dll()

Quik_Lua_connector.run_Cpp() 

-------------------------
while not stopped do 
sleep(1)
end 
-------------------------
end

static int run_Cpp(lua_State* Lua_stek)
{

    lua_State* L = luaL_newstate();

    if (L == NULL)
    {
        std::cout << "L == NULL" << std::endl;    //Ошибки нет.
    }

lua_getglobal(L, "CreateDataSource");           

lua_pushstring(L, "TQBR");    
lua_pushstring(L, "GAZP");         
lua_pushnumber(L, "INTERVAL_MN1");                

std::cout << "Size_stack:" << lua_gettop(L) << std::endl;   //Размер 4 - как и должно быть

int status_lua_pcall = lua_pcall(L, 3, 2, 0);   
    
if(status_lua_pcall  != 0)
{
std::cout<<"Error"<<std::endl;   //attempt to call a nil value
}

}

function my_callback_(index)

--index - индекс свечи в таблице my_table, НО сама таблица по умолчанию не приходит, что просто дикость.

end


local my_table = CreateDataSource(code_class, code_paper_ interval)

my_table :SetUpdateCallback(my_callback_)

function my_callback_(my_table_, param1, param2, index)

--Теперь тут доступны переданные дополнительные параметры...my_table_, param1, param2 - помимо стандартного index

end


local my_table = CreateDataSource(code_class, code_paper_ interval)

parametr_1 = "1"
parametr_2 = "2"

my_table :SetUpdateCallback(function(idx)my_callback_(my_table,parametr_1, parametr_2, idx) end)

        lua_getfield(L, index, "SetUpdateCallback");                    //"Извлекаем" из "таблицы" функцию SetUpdateCallback.

    lua_pushvalue(L, index);                                        //Помещаем копию обьекта таблицы на вершину стека.

    lua_pushcfunction(L, my_callback_);                       //Помещаем имя Сишой callback функции таблицы на вершину стека.

    int status_lua_pcall = lua_pcall(L, 2, 0, 0);              //Реализую вызов метода SetUpdateCallback

static int my_callback_(lua_State* L)
{
    std::cout << "my_callback_:" << lua_gettop(L) << std::endl;

    status = lua_isstring(L, 1);
    if (status == 1)
    {
          std::cout<< "lua_isstring:"<< lua_tostring(L,1) << std::endl ;
    }
    return 0;
}

1
2
3
4
5
6
...
итд