From ae82225d076974c8b31ea79514a77d69d05dc101 Mon Sep 17 00:00:00 2001 From: zcy <290198252@qq.com> Date: Fri, 19 Nov 2021 00:37:35 +0800 Subject: [PATCH] add lua --- examples/proto_debuger/base_form.cpp | 6 +- examples/proto_debuger/base_form.h | 3 - examples/proto_debuger/lua_wraper.cpp | 177 ++++ examples/proto_debuger/lua_wraper.h | 61 ++ examples/proto_debuger/msgdef.h | 8 + examples/proto_debuger/proto_debuger.vcxproj | 9 +- .../proto_debuger.vcxproj.filters | 9 + examples/proto_debuger/serial_port.h | 2 - examples/proto_debuger/tcp_client_form.h | 1 + .../proto_debuger/tcp_server_libevent.cpp | 358 ++++++++ examples/proto_debuger/tcp_server_libevent.h | 137 +++ .../proto_debuger/third/include/lua/lapi.h | 47 ++ .../proto_debuger/third/include/lua/lauxlib.h | 276 ++++++ .../proto_debuger/third/include/lua/lcode.h | 104 +++ .../proto_debuger/third/include/lua/lctype.h | 101 +++ .../proto_debuger/third/include/lua/ldebug.h | 52 ++ .../proto_debuger/third/include/lua/ldo.h | 78 ++ .../proto_debuger/third/include/lua/lfunc.h | 69 ++ .../proto_debuger/third/include/lua/lgc.h | 189 +++++ .../third/include/lua/ljumptab.h | 112 +++ .../proto_debuger/third/include/lua/llex.h | 91 ++ .../proto_debuger/third/include/lua/llimits.h | 369 ++++++++ .../proto_debuger/third/include/lua/lmem.h | 93 +++ .../proto_debuger/third/include/lua/lobject.h | 790 ++++++++++++++++++ .../third/include/lua/lopcodes.h | 392 +++++++++ .../third/include/lua/lopnames.h | 103 +++ .../proto_debuger/third/include/lua/lparser.h | 171 ++++ .../proto_debuger/third/include/lua/lprefix.h | 45 + .../proto_debuger/third/include/lua/lstate.h | 365 ++++++++ .../proto_debuger/third/include/lua/lstring.h | 57 ++ .../proto_debuger/third/include/lua/ltable.h | 62 ++ .../proto_debuger/third/include/lua/ltm.h | 103 +++ .../proto_debuger/third/include/lua/lua.h | 517 ++++++++++++ .../proto_debuger/third/include/lua/luaconf.h | 761 +++++++++++++++++ .../proto_debuger/third/include/lua/lualib.h | 58 ++ .../proto_debuger/third/include/lua/lundump.h | 36 + .../proto_debuger/third/include/lua/lvm.h | 134 +++ .../proto_debuger/third/include/lua/lzio.h | 66 ++ examples/proto_debuger/third/lib/lua53.dll | Bin 0 -> 586752 bytes examples/proto_debuger/third/lib/lua53.lib | Bin 0 -> 30090 bytes examples/proto_debuger/uart_process.cpp | 6 +- 41 files changed, 6005 insertions(+), 13 deletions(-) create mode 100644 examples/proto_debuger/lua_wraper.cpp create mode 100644 examples/proto_debuger/lua_wraper.h create mode 100644 examples/proto_debuger/msgdef.h create mode 100644 examples/proto_debuger/tcp_server_libevent.cpp create mode 100644 examples/proto_debuger/tcp_server_libevent.h create mode 100644 examples/proto_debuger/third/include/lua/lapi.h create mode 100644 examples/proto_debuger/third/include/lua/lauxlib.h create mode 100644 examples/proto_debuger/third/include/lua/lcode.h create mode 100644 examples/proto_debuger/third/include/lua/lctype.h create mode 100644 examples/proto_debuger/third/include/lua/ldebug.h create mode 100644 examples/proto_debuger/third/include/lua/ldo.h create mode 100644 examples/proto_debuger/third/include/lua/lfunc.h create mode 100644 examples/proto_debuger/third/include/lua/lgc.h create mode 100644 examples/proto_debuger/third/include/lua/ljumptab.h create mode 100644 examples/proto_debuger/third/include/lua/llex.h create mode 100644 examples/proto_debuger/third/include/lua/llimits.h create mode 100644 examples/proto_debuger/third/include/lua/lmem.h create mode 100644 examples/proto_debuger/third/include/lua/lobject.h create mode 100644 examples/proto_debuger/third/include/lua/lopcodes.h create mode 100644 examples/proto_debuger/third/include/lua/lopnames.h create mode 100644 examples/proto_debuger/third/include/lua/lparser.h create mode 100644 examples/proto_debuger/third/include/lua/lprefix.h create mode 100644 examples/proto_debuger/third/include/lua/lstate.h create mode 100644 examples/proto_debuger/third/include/lua/lstring.h create mode 100644 examples/proto_debuger/third/include/lua/ltable.h create mode 100644 examples/proto_debuger/third/include/lua/ltm.h create mode 100644 examples/proto_debuger/third/include/lua/lua.h create mode 100644 examples/proto_debuger/third/include/lua/luaconf.h create mode 100644 examples/proto_debuger/third/include/lua/lualib.h create mode 100644 examples/proto_debuger/third/include/lua/lundump.h create mode 100644 examples/proto_debuger/third/include/lua/lvm.h create mode 100644 examples/proto_debuger/third/include/lua/lzio.h create mode 100644 examples/proto_debuger/third/lib/lua53.dll create mode 100644 examples/proto_debuger/third/lib/lua53.lib diff --git a/examples/proto_debuger/base_form.cpp b/examples/proto_debuger/base_form.cpp index 0764c3f2..afbb63ce 100644 --- a/examples/proto_debuger/base_form.cpp +++ b/examples/proto_debuger/base_form.cpp @@ -41,7 +41,8 @@ LRESULT BasicForm::HandleMessage(UINT uMsg, WPARAM wParam, LPARAM lParam) int cnt = mMonitor->GetRootNode()->GetChildNode(0)->GetChildNodeCount(); ui::TreeNode* p = nullptr; for (int i = 0; i < cnt; i++) { - if (mMonitor->GetRootNode()->GetChildNode(0)->GetChildNode(i)->GetText() == *(wstring*)(wParam)) { + if (mMonitor->GetRootNode()->GetChildNode(0)->GetChildNode(i)->GetText() + == *(wstring*)(wParam)) { p = mMonitor->GetRootNode()->GetChildNode(0)->GetChildNode(i); break; } @@ -169,8 +170,7 @@ LRESULT BasicForm::HandleMessage(UINT uMsg, WPARAM wParam, LPARAM lParam) return WindowImplBase::HandleMessage(uMsg, wParam, lParam); } -void BasicForm::InitWindow() -{ +void BasicForm::InitWindow(){ /* Show settings menu */ ui::Button* btn_add_new = dynamic_cast(FindControl(L"add_new")); btn_add_new->SetText(L"½"); diff --git a/examples/proto_debuger/base_form.h b/examples/proto_debuger/base_form.h index 5b58957c..4142260f 100644 --- a/examples/proto_debuger/base_form.h +++ b/examples/proto_debuger/base_form.h @@ -20,9 +20,6 @@ #include #include -#define WM_USER_POS_CHANGED (WM_USER + 2) -#define WM_ADD_UART_MONITOR (WM_USER + 3) -#define WM_ADD_TCPCLIENT_MONITOR (WM_USER + 4) class BasicForm : public ui::WindowImplBase diff --git a/examples/proto_debuger/lua_wraper.cpp b/examples/proto_debuger/lua_wraper.cpp new file mode 100644 index 00000000..0fbb0cb5 --- /dev/null +++ b/examples/proto_debuger/lua_wraper.cpp @@ -0,0 +1,177 @@ +#include "lua_wraper.h" + +void LuaDelegate::Stop() +{ + +} + +int LuaDelegate::DoString(std::string scr) +{ + if (mVM != nullptr){ + int ret = luaL_dostring(mVM,scr.c_str()); + if (ret > 0){ + printf("lua error"); + PrintError(mVM); + return -1; + } + } + return 0; +} + +int LuaDelegate::UpdateScript(std::string scr) +{ + if(nullptr != mVM){ + lua_close(mVM); + } + free(mVM); + mVM = luaL_newstate(); //打开lua + if(nullptr != mVM){ + printf("shit is nullptr"); + } + for (auto x : mFunc) { + lua_register(mVM, x.first.c_str(), x.second); + } + if (mVM != nullptr){ + int ret = luaL_dostring(mVM,scr.c_str()); + if (ret > 0){ + printf("lua error"); + PrintError(mVM); + return -1; + } + } + return 0; +} + +void LuaDelegate::PrintError(lua_State *L) +{ + std::cout<<"\nFATAL ERROR:%s\n\n"<< lua_tostring(L, -1); +} + +void LuaDelegate::OnSerialData(std::string data){ + int i = lua_getglobal(mVM,"OnDataReady"); + if(i == 0) + return; + lua_pushstring(mVM,data.data()); + lua_call(mVM,1,0); +} + +/// +// 这部分代码可以写成一个统一的c++ 调用lua的接口,核心在于 +// lua_getglobal这个函数调用，其他的参数可以通过回调函数传入,不排除RTTI等技术使用 +// +// +// +// +void LuaDelegate::OnNetworkData(char *addr, char *data, uint32_t port) +{ + std::cout<<"call lua network callback"; + int ret = lua_getglobal(mVM,"OnNetworkData"); + if(ret == 0) + return; + std::cout< 0; --i) + { + int t = lua_type(mVM, i); + switch (t) + { + case LUA_TSTRING: + std::cout<<("%s\n", lua_tostring(mVM, i)); + break; + case LUA_TBOOLEAN: + std::cout<<(lua_toboolean(mVM, i) ? "true\n" : "false\n"); + break; + case LUA_TNUMBER: + std::cout<<("%g\n", lua_tonumber(mVM, i)); + break; + default: + std::cout<<("%s\n", lua_typename(mVM, t)); + break; + } + } + ++count; +} + + +LuaDelegate::~LuaDelegate() +{ + if(nullptr != mVM){ + lua_close(mVM); + } +} + +LuaDelegate::LuaDelegate(): + mVM(nullptr) +{ + mVM = luaL_newstate(); //打开lua + if(nullptr != mVM){ + printf("shit is nullptr"); + } + luaL_openlibs(mVM); //打开标准库 + +} + +LuaDelegate::LuaDelegate(std::map maps) : + mVM(nullptr) +{ + mVM = luaL_newstate(); //打开lua + if (nullptr != mVM) { + printf("shit is nullptr"); + } + luaL_openlibs(mVM); //打开标准库 + + for (auto x : maps) { + lua_register(mVM, x.first.c_str(), x.second); + } + mFunc = maps; +} + +int LuaDelegate::DoFile(std::string path) +{ + if(mVM != nullptr){ + int ret = luaL_dofile(mVM, path.c_str()); + if (ret > 0){ + printf("lua error"); + return -1; + } + } + return 0; +} + diff --git a/examples/proto_debuger/lua_wraper.h b/examples/proto_debuger/lua_wraper.h new file mode 100644 index 00000000..b6409d4d --- /dev/null +++ b/examples/proto_debuger/lua_wraper.h @@ -0,0 +1,61 @@ +#ifndef LUA_WRAPER_H +#define LUA_WRAPER_H + + +#include +#include +#include +#include +#include + + +extern "C" { +#include "lua.h" +#include "lauxlib.h" +#include "lualib.h" +} + + +class LuaDelegate{ +public: + LuaDelegate(); + LuaDelegate(std::map); + + int DoFile(std::string); + void Stop(); + int DoString(std::string); + int UpdateScript(std::string); + + template + void pushstack(T arg1,Types... rest) { + const std::type_info &t1 = typeid(arg1); + pushstack(rest...); + } + template + void CallFuntion(std::string name,T... para){ + int i = lua_getglobal(mVM,name.c_str()); + if(i < 0){ + return ; + } + pushstack(para...); + } + void PrintError(lua_State *L); + + void OnSerialData(std::string); + void OnNetworkData(char*,char*,uint32_t port); + void OnNewTcpClient(std::string ip,uint32_t port,uint32_t sockptr); + void OnClientLeave(std::string ip,uint32_t port,uint32_t sockptr); + + void DumpStack(); + + ~LuaDelegate(); +private: + lua_State *mVM; + std::string mFile; + std::map mFunc; +}; + + + +#endif + diff --git a/examples/proto_debuger/msgdef.h b/examples/proto_debuger/msgdef.h new file mode 100644 index 00000000..ec5a5f38 --- /dev/null +++ b/examples/proto_debuger/msgdef.h @@ -0,0 +1,8 @@ +#pragma once + +#define WM_USER_POS_CHANGED (WM_USER + 2) +#define WM_ADD_UART_MONITOR (WM_USER + 3) +#define WM_ADD_TCPCLIENT_MONITOR (WM_USER + 4) + +#define WM_ADD_UART_RECVDATA (WM_USER + 5) +#define WM_ADD_UART_CLOSE (WM_USER + 6) \ No newline at end of file diff --git a/examples/proto_debuger/proto_debuger.vcxproj b/examples/proto_debuger/proto_debuger.vcxproj index d3796941..ffdb4663 100644 --- a/examples/proto_debuger/proto_debuger.vcxproj +++ b/examples/proto_debuger/proto_debuger.vcxproj @@ -1,4 +1,4 @@ - + @@ -81,7 +81,7 @@ true - $(VC_IncludePath);$(WindowsSDK_IncludePath);..\..\;$(ProjectDir)third\include\libevent\include;$(ProjectDir) + $(VC_IncludePath);$(WindowsSDK_IncludePath);..\..\;$(ProjectDir)third\include\libevent\include;$(ProjectDir);$(ProjectDir)third\include\lua $(ReferencePath) $(VC_LibraryPath_x64);$(WindowsSDK_LibraryPath_x64);$(ProjectDir)third\lib @@ -131,7 +131,7 @@ Windows true - ws2_32.lib;event_extra.lib;event_core.lib;event.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies) + ws2_32.lib;event_extra.lib;event_core.lib;event.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;lua53.lib;%(AdditionalDependencies) @@ -163,17 +163,20 @@ + + + diff --git a/examples/proto_debuger/proto_debuger.vcxproj.filters b/examples/proto_debuger/proto_debuger.vcxproj.filters index 83339ca8..3a0379ef 100644 --- a/examples/proto_debuger/proto_debuger.vcxproj.filters +++ b/examples/proto_debuger/proto_debuger.vcxproj.filters @@ -39,6 +39,12 @@ 源文件 + + 源文件 + + + 源文件 + @@ -65,6 +71,9 @@ 头文件 + + 头文件 + diff --git a/examples/proto_debuger/serial_port.h b/examples/proto_debuger/serial_port.h index 91b8019c..88244eac 100644 --- a/examples/proto_debuger/serial_port.h +++ b/examples/proto_debuger/serial_port.h @@ -5,8 +5,6 @@ using namespace std; -#define WM_ADD_UART_RECVDATA (WM_USER + 4) -#define WM_ADD_UART_CLOSE (WM_USER + 5) typedef struct{ wstring name; diff --git a/examples/proto_debuger/tcp_client_form.h b/examples/proto_debuger/tcp_client_form.h index 6b729261..7898ac25 100644 --- a/examples/proto_debuger/tcp_client_form.h +++ b/examples/proto_debuger/tcp_client_form.h @@ -1,4 +1,5 @@ #include +#include "msgdef.h" // C runtime header #include diff --git a/examples/proto_debuger/tcp_server_libevent.cpp b/examples/proto_debuger/tcp_server_libevent.cpp new file mode 100644 index 00000000..c2eaf603 --- /dev/null +++ b/examples/proto_debuger/tcp_server_libevent.cpp @@ -0,0 +1,358 @@ +#define _WSPIAPI_H_ +#define _WINSOCKAPI_ +#include "tcp_server_libevent.h" +#include + +/** + * @description: + * @param {*} + * @return {*} + */ +ConnectionLibevent::ConnectionLibevent(TcpServerLibevent *p,struct bufferevent *ev,uint32_t fd,struct sockaddr_in *p1): +m_parent_server(nullptr), +m_event(nullptr), +m_fd(-1), +m_addr(nullptr) +{ + m_parent_server = p; + m_event = ev; + m_fd = fd; + m_addr = p1; +} +/** + * @description: + * @param {*} + * @return {*} + */ +ConnectionLibevent::ConnectionLibevent(struct bufferevent *ev,uint32_t fd,struct sockaddr_in *p1): +m_parent_server(nullptr), +m_event(nullptr), +m_fd(-1), +m_addr(nullptr) +{ + m_event = ev; + m_fd = fd; + m_addr = p1; +} +/** + * @description: + * @param {*} + * @return {*} + */ +ConnectionLibevent* defaultConnAccept(struct bufferevent *ev,uint32_t fd,struct sockaddr_in *p1){ + return new ConnectionLibevent(ev,fd,p1); +} +/** + * @description: + * @param {*} + * @return {*} + */ +int ConnectionLibevent::OnRecv(char *p,uint32_t len){ + std::cout<<"OnRecv "<m_fd << " "<IpAddress()<m_event,p,len); +} + +uint32_t ConnectionLibevent::SocketFd(){ + return m_fd; +} +/** + * @description: + * @param {*} + * @return {*} + */ +int ConnectionLibevent::SetServer(TcpServerLibevent *p){ + if(nullptr != p){ + this->m_parent_server = p; + return 0; + } + return -1; +} + +string ConnectionLibevent::IpAddress(){ + if(nullptr != m_addr){ + return string(inet_ntoa(m_addr->sin_addr)); + } + return ""; +} +TcpServerLibevent *ConnectionLibevent::Server(){ + return m_parent_server; +} + +void read_cb(struct bufferevent *bev, void *arg) +{ + char buf[1024] = {0}; + ConnectionLibevent* conn = (ConnectionLibevent*)arg; + bufferevent_read(bev, buf, sizeof(buf)); + auto server = conn->Server(); + cout << "client " << conn->IpAddress() << " say:" << buf << endl; + conn->OnRecv(buf,sizeof(buf)); +} + +void write_cb(struct bufferevent *bev, void *arg) +{ + ConnectionLibevent* conn = (ConnectionLibevent*)arg; + std::cout<<"connection "<IpAddress()<<" sended data success"<< std::endl; +} +/** + * @description: + * @param {*} + * @return {*} + */ +void event_cb(struct bufferevent *bev, short events, void *arg) +{ + ConnectionLibevent *conn = (ConnectionLibevent*)(arg); + TcpServerLibevent *server = conn->Server(); + if (events & BEV_EVENT_EOF) + { + cout << "connection closed: " << conn->IpAddress() << " " << conn->SocketFd() << endl; + conn->OnClose(); + bufferevent_free(bev); + server->RemoveConnection(conn->SocketFd()); + } + else if (events & BEV_EVENT_ERROR) + { + conn->OnClose(); + bufferevent_free(bev); + server->RemoveConnection(conn->SocketFd()); + + cout << "some other error !" << endl; + } + delete conn; +} + +/** + * @description: + * @param {*} + * @return {*} + */ +void cb_listener(struct evconnlistener *listener, evutil_socket_t fd, struct sockaddr *addr, int len, void *ptr) { + struct sockaddr_in* client = (sockaddr_in*)addr ; + cout << "connect new client: " << inet_ntoa(client->sin_addr) << " " << fd << " ::"<< ntohs(client->sin_port)<< endl; + TcpServerLibevent *server = (TcpServerLibevent*)ptr; + if(server != nullptr){ + struct bufferevent *bev; + bev = bufferevent_socket_new(server->m_event_base, fd, BEV_OPT_CLOSE_ON_FREE); + ConnectionLibevent *conn = server->m_handle_accept(bev,ntohs(client->sin_port),client); + conn->SetServer(server); + server->AddConnection(ntohs(client->sin_port),conn); + bufferevent_setcb(bev, read_cb, write_cb, event_cb, conn); + bufferevent_enable(bev, EV_READ); + + } +} + +/** + * @description: + * @param {*} + * @return {*} + */ +void server_run(TcpServerLibevent *p){ + if(nullptr != p){ + while(p->m_status == TcpServerLibevent::RUNNING){ + int ret =event_base_loop(p->m_event_base,EVLOOP_NONBLOCK); + if(ret < 0){ + p->m_status = TcpServerLibevent::FAIL; + break; + } + } + } +} +/** + * @description: + * @param {*} + * @return {*} + */ +TcpServerLibevent::SERVER_STATUS TcpServerLibevent::Status(){ + return m_status; +} +/** + * @description: + * @param {*} + * @return {*} + */ +int TcpServerLibevent::AddConnection(uint32_t fd,ConnectionLibevent *p){ + if( m_map_client.find(fd) == m_map_client.end()){ + if(nullptr != p) + m_map_client[fd] = p; + else + return -1; + } + return 0; +} +/** + * @description: + * @param {*} + * @return {*} + */ +int TcpServerLibevent::RemoveConnection(uint32_t fd){ +if( m_map_client.find(fd) != m_map_client.end()){ + + m_map_client.erase(fd); + return 0; + }else{ + return -1; + } +} +/** + * @description: + * @param {*} + * @return {*} + */ +int TcpServerLibevent::SetNewConnectionHandle(OnAccept p){ + m_handle_accept = p; + return 0; +} +/** + * @description: + * @param {int} ports + * @param {string} bindip + * @return {*} + */ +TcpServerLibevent::TcpServerLibevent(int port,string bindip) : + m_thread(nullptr), + m_event_base(nullptr), + m_event_listener(nullptr) +{ + m_handle_accept = defaultConnAccept; + m_backlog = 10000; + this->m_bind_ip = bindip; + this->m_port = port; + + memset(&m_server_addr, 0, sizeof(m_server_addr)); + m_server_addr.sin_family = AF_INET; + m_server_addr.sin_port = htons(port); + m_server_addr.sin_addr.s_addr = htonl(INADDR_ANY); + + // 创建 event_base + m_event_base = event_base_new(); + if(NULL == m_event_base){ + return; + } + + m_event_listener = evconnlistener_new_bind(m_event_base, + cb_listener, + this, + LEV_OPT_CLOSE_ON_FREE|LEV_OPT_REUSEABLE|LEV_OPT_THREADSAFE, + m_backlog, + (struct sockaddr*)&m_server_addr, + sizeof(m_server_addr)); + if(NULL == m_event_listener) + { + m_status = FAIL; + } + m_status = STOP; +} +/** + * @description: start server synchronous + * @param {*} + * @return {*} + */ +int TcpServerLibevent::StartServerSync(){ + if(m_status == STOP){ + m_status = RUNNING; + if(-1 == event_base_dispatch(m_event_base)){ + } + event_base_free(m_event_base); + return 0; + } + return -1; +} +/** + * @description: start server asynchronous + * @param {*} + * @return {*} + */ +int TcpServerLibevent::StartServerAsync(){ + if(m_status == STOP){ +#ifdef WIN32 + evthread_use_windows_threads(); +#endif +#ifdef linux + evthread_use_pthreads(); +#endif + m_status = RUNNING; + + m_thread = new std::thread(server_run,this); + m_thread->detach(); + return 0; + } + return -1; +} + +int TcpServerLibevent::StopServer() +{ + struct timeval v; + v.tv_usec = 1000; + v.tv_sec = 0; + + if(m_status == RUNNING){ + int ret = event_base_loopexit(m_event_base,&v); + if (ret < 0){ + // todo write log + + } + evconnlistener_free(this->m_event_listener); + if(ret < 0){ + // todo write log + + } + m_status = STOP; + return ret; + } + return -1; +} +/** + * @description: start server asynchronous + * @param {*} + * @return {*} + */ +TcpServerLibevent::~TcpServerLibevent(){ + if(this->m_status == RUNNING){ + m_thread->detach(); + struct timeval v; + v.tv_usec = 1000; + v.tv_sec = 1; + + int ret = event_base_loopexit(m_event_base,&v); + this->m_status = STOP; + } + if(nullptr != m_event_base){ + event_base_free(m_event_base); + delete m_event_base; + m_event_base = nullptr; + } + if(nullptr != m_event_listener){ + delete m_event_listener; + m_event_listener = nullptr; + } +} diff --git a/examples/proto_debuger/tcp_server_libevent.h b/examples/proto_debuger/tcp_server_libevent.h new file mode 100644 index 00000000..d62d0624 --- /dev/null +++ b/examples/proto_debuger/tcp_server_libevent.h @@ -0,0 +1,137 @@ + +/* + * @Author: your name + * @Date: 2021-06-30 16:23:10 + * @LastEditTime: 2021-07-15 22:29:01 + * @LastEditors: Please set LastEditors + * @Description: In User Settings Edit + * @FilePath: \server\tcp_server_libevent.h + */ + +#ifndef GENERAL_TCPSERVER_H +#define GENERAL_TCPSERVER_H + +#ifndef _WIN32_WINNT +#define _WIN32_WINNT 0x0500 +#endif +#ifdef linux +#include +#include +#include +#define EVENT__HAVE_PTHREADS +#endif + +extern "C"{ + #include "event2/bufferevent.h" + #include "event2/buffer.h" + #include "event2/listener.h" + #include "event2/util.h" + #include "event2/event.h" + #include "event2/thread.h" + #include +}; + +#include +#include +#include +#include + + + + +#ifdef Qt_Support +#include +#include + +#endif +using namespace std; + +class TcpServerLibevent; +// tcp 连接 + +#ifdef Qt_Support +class ConnectionLibevent : public QObject { + Q_OBJECT +#else +class ConnectionLibevent{ +#endif +public: + ConnectionLibevent(TcpServerLibevent *p, + struct bufferevent*v, + uint32_t fd, + struct sockaddr_in *p1); + ConnectionLibevent(struct bufferevent*v, + uint32_t fd, + struct sockaddr_in *p1); + virtual int OnRecv(char *p,uint32_t len); // 接收到 + virtual int OnClose(); // 接收到 + virtual int OnWrite(); + int WriteData(const char *p,uint16_t len); + int SetServer(TcpServerLibevent *); + TcpServerLibevent *Server(); + string IpAddress(); + uint32_t SocketFd(); +private: + int m_bytes_send; + int m_bytes_recv; + TcpServerLibevent *m_parent_server; + struct bufferevent *m_event; + struct sockaddr_in *m_addr; + uint32_t m_fd; + +}; + +// 管理服务端 +#ifdef Qt_Support +class TcpServerLibevent : public QObject{ + Q_OBJECT +#else +class TcpServerLibevent { +#endif + +typedef enum{ + RUNNING, + STOP, + FAIL +}SERVER_STATUS; +public: + typedef ConnectionLibevent* (*OnAccept)(struct bufferevent *ev,uint32_t fd,struct sockaddr_in *p1); + TcpServerLibevent(int port,string bindip); + SERVER_STATUS Status(); + ~TcpServerLibevent(); + int StartServerSync(); // 同步启动服务器 + int StartServerAsync(); // 异步启动服务 + int StopServer(); + int RemoveConnection(uint32_t ); + int SetNewConnectionHandle(OnAccept ); + friend void cb_listener(struct evconnlistener *listener, evutil_socket_t fd, struct sockaddr *addr, int len, void *ptr); + friend void read_cb(struct bufferevent *bev, void *arg); + friend void event_cb(struct bufferevent *bev, short events, void *arg); + friend void write_cb(struct bufferevent *bev, void *arg); + friend void server_run(TcpServerLibevent *p); + +#ifdef Qt_Support +signals: + int on_onnected(string ip,uint sock); + int on_disconected(string ip,uint sock); + int on_conn_read(string ip); + +#endif +private: + uint32_t m_port; // 监听端口号 + string m_bind_ip; // 绑定端口号 + int m_current_conection; // 当前连接数目 + uint16_t m_backlog; + struct sockaddr_in m_server_addr; // 服务器地址 + struct event_base * m_event_base; + struct evconnlistener* m_event_listener; + SERVER_STATUS m_status; + std::thread *m_thread; + map m_map_client; + OnAccept m_handle_accept; + int AddConnection(uint32_t fd,ConnectionLibevent *p); + +}; + + +#endif diff --git a/examples/proto_debuger/third/include/lua/lapi.h b/examples/proto_debuger/third/include/lua/lapi.h new file mode 100644 index 00000000..41216b27 --- /dev/null +++ b/examples/proto_debuger/third/include/lua/lapi.h @@ -0,0 +1,47 @@ +/* +** $Id: lapi.h $ +** Auxiliary functions from Lua API +** See Copyright Notice in lua.h +*/ + +#ifndef lapi_h +#define lapi_h + + +#include "llimits.h" +#include "lstate.h" + + +/* Increments 'L->top', checking for stack overflows */ +#define api_incr_top(L) {L->top++; api_check(L, L->top <= L->ci->top, \ + "stack overflow");} + + +/* +** If a call returns too many multiple returns, the callee may not have +** stack space to accommodate all results. In this case, this macro +** increases its stack space ('L->ci->top'). +*/ +#define adjustresults(L,nres) \ + { if ((nres) <= LUA_MULTRET && L->ci->top < L->top) L->ci->top = L->top; } + + +/* Ensure the stack has at least 'n' elements */ +#define api_checknelems(L,n) api_check(L, (n) < (L->top - L->ci->func), \ + "not enough elements in the stack") + + +/* +** To reduce the overhead of returning from C functions, the presence of +** to-be-closed variables in these functions is coded in the CallInfo's +** field 'nresults', in a way that functions with no to-be-closed variables +** with zero, one, or "all" wanted results have no overhead. Functions +** with other number of wanted results, as well as functions with +** variables to be closed, have an extra check. +*/ + +#define hastocloseCfunc(n) ((n) < LUA_MULTRET) + +#define codeNresults(n) (-(n) - 3) + +#endif diff --git a/examples/proto_debuger/third/include/lua/lauxlib.h b/examples/proto_debuger/third/include/lua/lauxlib.h new file mode 100644 index 00000000..59fef6af --- /dev/null +++ b/examples/proto_debuger/third/include/lua/lauxlib.h @@ -0,0 +1,276 @@ +/* +** $Id: lauxlib.h $ +** Auxiliary functions for building Lua libraries +** See Copyright Notice in lua.h +*/ + + +#ifndef lauxlib_h +#define lauxlib_h + + +#include +#include + +#include "lua.h" + + +/* global table */ +#define LUA_GNAME "_G" + + +typedef struct luaL_Buffer luaL_Buffer; + + +/* extra error code for 'luaL_loadfilex' */ +#define LUA_ERRFILE (LUA_ERRERR+1) + + +/* key, in the registry, for table of loaded modules */ +#define LUA_LOADED_TABLE "_LOADED" + + +/* key, in the registry, for table of preloaded loaders */ +#define LUA_PRELOAD_TABLE "_PRELOAD" + + +typedef struct luaL_Reg { + const char *name; + lua_CFunction func; +} luaL_Reg; + + +#define LUAL_NUMSIZES (sizeof(lua_Integer)*16 + sizeof(lua_Number)) + +LUALIB_API void (luaL_checkversion_) (lua_State *L, lua_Number ver, size_t sz); +#define luaL_checkversion(L) \ + luaL_checkversion_(L, LUA_VERSION_NUM, LUAL_NUMSIZES) + +LUALIB_API int (luaL_getmetafield) (lua_State *L, int obj, const char *e); +LUALIB_API int (luaL_callmeta) (lua_State *L, int obj, const char *e); +LUALIB_API const char *(luaL_tolstring) (lua_State *L, int idx, size_t *len); +LUALIB_API int (luaL_argerror) (lua_State *L, int arg, const char *extramsg); +LUALIB_API int (luaL_typeerror) (lua_State *L, int arg, const char *tname); +LUALIB_API const char *(luaL_checklstring) (lua_State *L, int arg, + size_t *l); +LUALIB_API const char *(luaL_optlstring) (lua_State *L, int arg, + const char *def, size_t *l); +LUALIB_API lua_Number (luaL_checknumber) (lua_State *L, int arg); +LUALIB_API lua_Number (luaL_optnumber) (lua_State *L, int arg, lua_Number def); + +LUALIB_API lua_Integer (luaL_checkinteger) (lua_State *L, int arg); +LUALIB_API lua_Integer (luaL_optinteger) (lua_State *L, int arg, + lua_Integer def); + +LUALIB_API void (luaL_checkstack) (lua_State *L, int sz, const char *msg); +LUALIB_API void (luaL_checktype) (lua_State *L, int arg, int t); +LUALIB_API void (luaL_checkany) (lua_State *L, int arg); + +LUALIB_API int (luaL_newmetatable) (lua_State *L, const char *tname); +LUALIB_API void (luaL_setmetatable) (lua_State *L, const char *tname); +LUALIB_API void *(luaL_testudata) (lua_State *L, int ud, const char *tname); +LUALIB_API void *(luaL_checkudata) (lua_State *L, int ud, const char *tname); + +LUALIB_API void (luaL_where) (lua_State *L, int lvl); +LUALIB_API int (luaL_error) (lua_State *L, const char *fmt, ...); + +LUALIB_API int (luaL_checkoption) (lua_State *L, int arg, const char *def, + const char *const lst[]); + +LUALIB_API int (luaL_fileresult) (lua_State *L, int stat, const char *fname); +LUALIB_API int (luaL_execresult) (lua_State *L, int stat); + + +/* predefined references */ +#define LUA_NOREF (-2) +#define LUA_REFNIL (-1) + +LUALIB_API int (luaL_ref) (lua_State *L, int t); +LUALIB_API void (luaL_unref) (lua_State *L, int t, int ref); + +LUALIB_API int (luaL_loadfilex) (lua_State *L, const char *filename, + const char *mode); + +#define luaL_loadfile(L,f) luaL_loadfilex(L,f,NULL) + +LUALIB_API int (luaL_loadbufferx) (lua_State *L, const char *buff, size_t sz, + const char *name, const char *mode); +LUALIB_API int (luaL_loadstring) (lua_State *L, const char *s); + +LUALIB_API lua_State *(luaL_newstate) (void); + +LUALIB_API lua_Integer (luaL_len) (lua_State *L, int idx); + +LUALIB_API void luaL_addgsub (luaL_Buffer *b, const char *s, + const char *p, const char *r); +LUALIB_API const char *(luaL_gsub) (lua_State *L, const char *s, + const char *p, const char *r); + +LUALIB_API void (luaL_setfuncs) (lua_State *L, const luaL_Reg *l, int nup); + +LUALIB_API int (luaL_getsubtable) (lua_State *L, int idx, const char *fname); + +LUALIB_API void (luaL_traceback) (lua_State *L, lua_State *L1, + const char *msg, int level); + +LUALIB_API void (luaL_requiref) (lua_State *L, const char *modname, + lua_CFunction openf, int glb); + +/* +** =============================================================== +** some useful macros +** =============================================================== +*/ + + +#define luaL_newlibtable(L,l) \ + lua_createtable(L, 0, sizeof(l)/sizeof((l)[0]) - 1) + +#define luaL_newlib(L,l) \ + (luaL_checkversion(L), luaL_newlibtable(L,l), luaL_setfuncs(L,l,0)) + +#define luaL_argcheck(L, cond,arg,extramsg) \ + ((void)((cond) || luaL_argerror(L, (arg), (extramsg)))) + +#define luaL_argexpected(L,cond,arg,tname) \ + ((void)((cond) || luaL_typeerror(L, (arg), (tname)))) + +#define luaL_checkstring(L,n) (luaL_checklstring(L, (n), NULL)) +#define luaL_optstring(L,n,d) (luaL_optlstring(L, (n), (d), NULL)) + +#define luaL_typename(L,i) lua_typename(L, lua_type(L,(i))) + +#define luaL_dofile(L, fn) \ + (luaL_loadfile(L, fn) || lua_pcall(L, 0, LUA_MULTRET, 0)) + +#define luaL_dostring(L, s) \ + (luaL_loadstring(L, s) || lua_pcall(L, 0, LUA_MULTRET, 0)) + +#define luaL_getmetatable(L,n) (lua_getfield(L, LUA_REGISTRYINDEX, (n))) + +#define luaL_opt(L,f,n,d) (lua_isnoneornil(L,(n)) ? (d) : f(L,(n))) + +#define luaL_loadbuffer(L,s,sz,n) luaL_loadbufferx(L,s,sz,n,NULL) + + +/* push the value used to represent failure/error */ +#define luaL_pushfail(L) lua_pushnil(L) + + +/* +** {====================================================== +** Generic Buffer manipulation +** ======================================================= +*/ + +struct luaL_Buffer { + char *b; /* buffer address */ + size_t size; /* buffer size */ + size_t n; /* number of characters in buffer */ + lua_State *L; + union { + LUAI_MAXALIGN; /* ensure maximum alignment for buffer */ + char b[LUAL_BUFFERSIZE]; /* initial buffer */ + } init; +}; + + +#define luaL_bufflen(bf) ((bf)->n) +#define luaL_buffaddr(bf) ((bf)->b) + + +#define luaL_addchar(B,c) \ + ((void)((B)->n < (B)->size || luaL_prepbuffsize((B), 1)), \ + ((B)->b[(B)->n++] = (c))) + +#define luaL_addsize(B,s) ((B)->n += (s)) + +#define luaL_buffsub(B,s) ((B)->n -= (s)) + +LUALIB_API void (luaL_buffinit) (lua_State *L, luaL_Buffer *B); +LUALIB_API char *(luaL_prepbuffsize) (luaL_Buffer *B, size_t sz); +LUALIB_API void (luaL_addlstring) (luaL_Buffer *B, const char *s, size_t l); +LUALIB_API void (luaL_addstring) (luaL_Buffer *B, const char *s); +LUALIB_API void (luaL_addvalue) (luaL_Buffer *B); +LUALIB_API void (luaL_pushresult) (luaL_Buffer *B); +LUALIB_API void (luaL_pushresultsize) (luaL_Buffer *B, size_t sz); +LUALIB_API char *(luaL_buffinitsize) (lua_State *L, luaL_Buffer *B, size_t sz); + +#define luaL_prepbuffer(B) luaL_prepbuffsize(B, LUAL_BUFFERSIZE) + +/* }====================================================== */ + + + +/* +** {====================================================== +** File handles for IO library +** ======================================================= +*/ + +/* +** A file handle is a userdata with metatable 'LUA_FILEHANDLE' and +** initial structure 'luaL_Stream' (it may contain other fields +** after that initial structure). +*/ + +#define LUA_FILEHANDLE "FILE*" + + +typedef struct luaL_Stream { + FILE *f; /* stream (NULL for incompletely created streams) */ + lua_CFunction closef; /* to close stream (NULL for closed streams) */ +} luaL_Stream; + +/* }====================================================== */ + +/* +** {================================================================== +** "Abstraction Layer" for basic report of messages and errors +** =================================================================== +*/ + +/* print a string */ +#if !defined(lua_writestring) +#define lua_writestring(s,l) fwrite((s), sizeof(char), (l), stdout) +#endif + +/* print a newline and flush the output */ +#if !defined(lua_writeline) +#define lua_writeline() (lua_writestring("\n", 1), fflush(stdout)) +#endif + +/* print an error message */ +#if !defined(lua_writestringerror) +#define lua_writestringerror(s,p) \ + (fprintf(stderr, (s), (p)), fflush(stderr)) +#endif + +/* }================================================================== */ + + +/* +** {============================================================ +** Compatibility with deprecated conversions +** ============================================================= +*/ +#if defined(LUA_COMPAT_APIINTCASTS) + +#define luaL_checkunsigned(L,a) ((lua_Unsigned)luaL_checkinteger(L,a)) +#define luaL_optunsigned(L,a,d) \ + ((lua_Unsigned)luaL_optinteger(L,a,(lua_Integer)(d))) + +#define luaL_checkint(L,n) ((int)luaL_checkinteger(L, (n))) +#define luaL_optint(L,n,d) ((int)luaL_optinteger(L, (n), (d))) + +#define luaL_checklong(L,n) ((long)luaL_checkinteger(L, (n))) +#define luaL_optlong(L,n,d) ((long)luaL_optinteger(L, (n), (d))) + +#endif +/* }============================================================ */ + + + +#endif + + diff --git a/examples/proto_debuger/third/include/lua/lcode.h b/examples/proto_debuger/third/include/lua/lcode.h new file mode 100644 index 00000000..32658244 --- /dev/null +++ b/examples/proto_debuger/third/include/lua/lcode.h @@ -0,0 +1,104 @@ +/* +** $Id: lcode.h $ +** Code generator for Lua +** See Copyright Notice in lua.h +*/ + +#ifndef lcode_h +#define lcode_h + +#include "llex.h" +#include "lobject.h" +#include "lopcodes.h" +#include "lparser.h" + + +/* +** Marks the end of a patch list. It is an invalid value both as an absolute +** address, and as a list link (would link an element to itself). +*/ +#define NO_JUMP (-1) + + +/* +** grep "ORDER OPR" if you change these enums (ORDER OP) +*/ +typedef enum BinOpr { + /* arithmetic operators */ + OPR_ADD, OPR_SUB, OPR_MUL, OPR_MOD, OPR_POW, + OPR_DIV, OPR_IDIV, + /* bitwise operators */ + OPR_BAND, OPR_BOR, OPR_BXOR, + OPR_SHL, OPR_SHR, + /* string operator */ + OPR_CONCAT, + /* comparison operators */ + OPR_EQ, OPR_LT, OPR_LE, + OPR_NE, OPR_GT, OPR_GE, + /* logical operators */ + OPR_AND, OPR_OR, + OPR_NOBINOPR +} BinOpr; + + +/* true if operation is foldable (that is, it is arithmetic or bitwise) */ +#define foldbinop(op) ((op) <= OPR_SHR) + + +#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) + + +typedef enum UnOpr { OPR_MINUS, OPR_BNOT, OPR_NOT, OPR_LEN, OPR_NOUNOPR } UnOpr; + + +/* get (pointer to) instruction of given 'expdesc' */ +#define getinstruction(fs,e) ((fs)->f->code[(e)->u.info]) + + +#define luaK_setmultret(fs,e) luaK_setreturns(fs, e, LUA_MULTRET) + +#define luaK_jumpto(fs,t) luaK_patchlist(fs, luaK_jump(fs), t) + +LUAI_FUNC int luaK_code (FuncState *fs, Instruction i); +LUAI_FUNC int luaK_codeABx (FuncState *fs, OpCode o, int A, unsigned int Bx); +LUAI_FUNC int luaK_codeAsBx (FuncState *fs, OpCode o, int A, int Bx); +LUAI_FUNC int luaK_codeABCk (FuncState *fs, OpCode o, int A, + int B, int C, int k); +LUAI_FUNC int luaK_isKint (expdesc *e); +LUAI_FUNC int luaK_exp2const (FuncState *fs, const expdesc *e, TValue *v); +LUAI_FUNC void luaK_fixline (FuncState *fs, int line); +LUAI_FUNC void luaK_nil (FuncState *fs, int from, int n); +LUAI_FUNC void luaK_reserveregs (FuncState *fs, int n); +LUAI_FUNC void luaK_checkstack (FuncState *fs, int n); +LUAI_FUNC void luaK_int (FuncState *fs, int reg, lua_Integer n); +LUAI_FUNC void luaK_dischargevars (FuncState *fs, expdesc *e); +LUAI_FUNC int luaK_exp2anyreg (FuncState *fs, expdesc *e); +LUAI_FUNC void luaK_exp2anyregup (FuncState *fs, expdesc *e); +LUAI_FUNC void luaK_exp2nextreg (FuncState *fs, expdesc *e); +LUAI_FUNC void luaK_exp2val (FuncState *fs, expdesc *e); +LUAI_FUNC int luaK_exp2RK (FuncState *fs, expdesc *e); +LUAI_FUNC void luaK_self (FuncState *fs, expdesc *e, expdesc *key); +LUAI_FUNC void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k); +LUAI_FUNC void luaK_goiftrue (FuncState *fs, expdesc *e); +LUAI_FUNC void luaK_goiffalse (FuncState *fs, expdesc *e); +LUAI_FUNC void luaK_storevar (FuncState *fs, expdesc *var, expdesc *e); +LUAI_FUNC void luaK_setreturns (FuncState *fs, expdesc *e, int nresults); +LUAI_FUNC void luaK_setoneret (FuncState *fs, expdesc *e); +LUAI_FUNC int luaK_jump (FuncState *fs); +LUAI_FUNC void luaK_ret (FuncState *fs, int first, int nret); +LUAI_FUNC void luaK_patchlist (FuncState *fs, int list, int target); +LUAI_FUNC void luaK_patchtohere (FuncState *fs, int list); +LUAI_FUNC void luaK_concat (FuncState *fs, int *l1, int l2); +LUAI_FUNC int luaK_getlabel (FuncState *fs); +LUAI_FUNC void luaK_prefix (FuncState *fs, UnOpr op, expdesc *v, int line); +LUAI_FUNC void luaK_infix (FuncState *fs, BinOpr op, expdesc *v); +LUAI_FUNC void luaK_posfix (FuncState *fs, BinOpr op, expdesc *v1, + expdesc *v2, int line); +LUAI_FUNC void luaK_settablesize (FuncState *fs, int pc, + int ra, int asize, int hsize); +LUAI_FUNC void luaK_setlist (FuncState *fs, int base, int nelems, int tostore); +LUAI_FUNC void luaK_finish (FuncState *fs); +LUAI_FUNC l_noret luaK_semerror (LexState *ls, const char *msg); + + +#endif diff --git a/examples/proto_debuger/third/include/lua/lctype.h b/examples/proto_debuger/third/include/lua/lctype.h new file mode 100644 index 00000000..864e1901 --- /dev/null +++ b/examples/proto_debuger/third/include/lua/lctype.h @@ -0,0 +1,101 @@ +/* +** $Id: lctype.h $ +** 'ctype' functions for Lua +** See Copyright Notice in lua.h +*/ + +#ifndef lctype_h +#define lctype_h + +#include "lua.h" + + +/* +** WARNING: the functions defined here do not necessarily correspond +** to the similar functions in the standard C ctype.h. They are +** optimized for the specific needs of Lua. +*/ + +#if !defined(LUA_USE_CTYPE) + +#if 'A' == 65 && '0' == 48 +/* ASCII case: can use its own tables; faster and fixed */ +#define LUA_USE_CTYPE 0 +#else +/* must use standard C ctype */ +#define LUA_USE_CTYPE 1 +#endif + +#endif + + +#if !LUA_USE_CTYPE /* { */ + +#include + +#include "llimits.h" + + +#define ALPHABIT 0 +#define DIGITBIT 1 +#define PRINTBIT 2 +#define SPACEBIT 3 +#define XDIGITBIT 4 + + +#define MASK(B) (1 << (B)) + + +/* +** add 1 to char to allow index -1 (EOZ) +*/ +#define testprop(c,p) (luai_ctype_[(c)+1] & (p)) + +/* +** 'lalpha' (Lua alphabetic) and 'lalnum' (Lua alphanumeric) both include '_' +*/ +#define lislalpha(c) testprop(c, MASK(ALPHABIT)) +#define lislalnum(c) testprop(c, (MASK(ALPHABIT) | MASK(DIGITBIT))) +#define lisdigit(c) testprop(c, MASK(DIGITBIT)) +#define lisspace(c) testprop(c, MASK(SPACEBIT)) +#define lisprint(c) testprop(c, MASK(PRINTBIT)) +#define lisxdigit(c) testprop(c, MASK(XDIGITBIT)) + + +/* +** In ASCII, this 'ltolower' is correct for alphabetic characters and +** for '.'. That is enough for Lua needs. ('check_exp' ensures that +** the character either is an upper-case letter or is unchanged by +** the transformation, which holds for lower-case letters and '.'.) +*/ +#define ltolower(c) \ + check_exp(('A' <= (c) && (c) <= 'Z') || (c) == ((c) | ('A' ^ 'a')), \ + (c) | ('A' ^ 'a')) + + +/* one entry for each character and for -1 (EOZ) */ +LUAI_DDEC(const lu_byte luai_ctype_[UCHAR_MAX + 2];) + + +#else /* }{ */ + +/* +** use standard C ctypes +*/ + +#include + + +#define lislalpha(c) (isalpha(c) || (c) == '_') +#define lislalnum(c) (isalnum(c) || (c) == '_') +#define lisdigit(c) (isdigit(c)) +#define lisspace(c) (isspace(c)) +#define lisprint(c) (isprint(c)) +#define lisxdigit(c) (isxdigit(c)) + +#define ltolower(c) (tolower(c)) + +#endif /* } */ + +#endif + diff --git a/examples/proto_debuger/third/include/lua/ldebug.h b/examples/proto_debuger/third/include/lua/ldebug.h new file mode 100644 index 00000000..a0a58486 --- /dev/null +++ b/examples/proto_debuger/third/include/lua/ldebug.h @@ -0,0 +1,52 @@ +/* +** $Id: ldebug.h $ +** Auxiliary functions from Debug Interface module +** See Copyright Notice in lua.h +*/ + +#ifndef ldebug_h +#define ldebug_h + + +#include "lstate.h" + + +#define pcRel(pc, p) (cast_int((pc) - (p)->code) - 1) + + +/* Active Lua function (given call info) */ +#define ci_func(ci) (clLvalue(s2v((ci)->func))) + + +#define resethookcount(L) (L->hookcount = L->basehookcount) + +/* +** mark for entries in 'lineinfo' array that has absolute information in +** 'abslineinfo' array +*/ +#define ABSLINEINFO (-0x80) + +LUAI_FUNC int luaG_getfuncline (const Proto *f, int pc); +LUAI_FUNC const char *luaG_findlocal (lua_State *L, CallInfo *ci, int n, + StkId *pos); +LUAI_FUNC l_noret luaG_typeerror (lua_State *L, const TValue *o, + const char *opname); +LUAI_FUNC l_noret luaG_forerror (lua_State *L, const TValue *o, + const char *what); +LUAI_FUNC l_noret luaG_concaterror (lua_State *L, const TValue *p1, + const TValue *p2); +LUAI_FUNC l_noret luaG_opinterror (lua_State *L, const TValue *p1, + const TValue *p2, + const char *msg); +LUAI_FUNC l_noret luaG_tointerror (lua_State *L, const TValue *p1, + const TValue *p2); +LUAI_FUNC l_noret luaG_ordererror (lua_State *L, const TValue *p1, + const TValue *p2); +LUAI_FUNC l_noret luaG_runerror (lua_State *L, const char *fmt, ...); +LUAI_FUNC const char *luaG_addinfo (lua_State *L, const char *msg, + TString *src, int line); +LUAI_FUNC l_noret luaG_errormsg (lua_State *L); +LUAI_FUNC int luaG_traceexec (lua_State *L, const Instruction *pc); + + +#endif diff --git a/examples/proto_debuger/third/include/lua/ldo.h b/examples/proto_debuger/third/include/lua/ldo.h new file mode 100644 index 00000000..4d30d072 --- /dev/null +++ b/examples/proto_debuger/third/include/lua/ldo.h @@ -0,0 +1,78 @@ +/* +** $Id: ldo.h $ +** Stack and Call structure of Lua +** See Copyright Notice in lua.h +*/ + +#ifndef ldo_h +#define ldo_h + + +#include "lobject.h" +#include "lstate.h" +#include "lzio.h" + + +/* +** Macro to check stack size and grow stack if needed. Parameters +** 'pre'/'pos' allow the macro to preserve a pointer into the +** stack across reallocations, doing the work only when needed. +** It also allows the running of one GC step when the stack is +** reallocated. +** 'condmovestack' is used in heavy tests to force a stack reallocation +** at every check. +*/ +#define luaD_checkstackaux(L,n,pre,pos) \ + if (L->stack_last - L->top <= (n)) \ + { pre; luaD_growstack(L, n, 1); pos; } \ + else { condmovestack(L,pre,pos); } + +/* In general, 'pre'/'pos' are empty (nothing to save) */ +#define luaD_checkstack(L,n) luaD_checkstackaux(L,n,(void)0,(void)0) + + + +#define savestack(L,p) ((char *)(p) - (char *)L->stack) +#define restorestack(L,n) ((StkId)((char *)L->stack + (n))) + + +/* macro to check stack size, preserving 'p' */ +#define checkstackGCp(L,n,p) \ + luaD_checkstackaux(L, n, \ + ptrdiff_t t__ = savestack(L, p); /* save 'p' */ \ + luaC_checkGC(L), /* stack grow uses memory */ \ + p = restorestack(L, t__)) /* 'pos' part: restore 'p' */ + + +/* macro to check stack size and GC */ +#define checkstackGC(L,fsize) \ + luaD_checkstackaux(L, (fsize), luaC_checkGC(L), (void)0) + + +/* type of protected functions, to be ran by 'runprotected' */ +typedef void (*Pfunc) (lua_State *L, void *ud); + +LUAI_FUNC void luaD_seterrorobj (lua_State *L, int errcode, StkId oldtop); +LUAI_FUNC int luaD_protectedparser (lua_State *L, ZIO *z, const char *name, + const char *mode); +LUAI_FUNC void luaD_hook (lua_State *L, int event, int line, + int fTransfer, int nTransfer); +LUAI_FUNC void luaD_hookcall (lua_State *L, CallInfo *ci); +LUAI_FUNC void luaD_pretailcall (lua_State *L, CallInfo *ci, StkId func, int n); +LUAI_FUNC CallInfo *luaD_precall (lua_State *L, StkId func, int nResults); +LUAI_FUNC void luaD_call (lua_State *L, StkId func, int nResults); +LUAI_FUNC void luaD_callnoyield (lua_State *L, StkId func, int nResults); +LUAI_FUNC void luaD_tryfuncTM (lua_State *L, StkId func); +LUAI_FUNC int luaD_pcall (lua_State *L, Pfunc func, void *u, + ptrdiff_t oldtop, ptrdiff_t ef); +LUAI_FUNC void luaD_poscall (lua_State *L, CallInfo *ci, int nres); +LUAI_FUNC int luaD_reallocstack (lua_State *L, int newsize, int raiseerror); +LUAI_FUNC int luaD_growstack (lua_State *L, int n, int raiseerror); +LUAI_FUNC void luaD_shrinkstack (lua_State *L); +LUAI_FUNC void luaD_inctop (lua_State *L); + +LUAI_FUNC l_noret luaD_throw (lua_State *L, int errcode); +LUAI_FUNC int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud); + +#endif + diff --git a/examples/proto_debuger/third/include/lua/lfunc.h b/examples/proto_debuger/third/include/lua/lfunc.h new file mode 100644 index 00000000..8d6f965c --- /dev/null +++ b/examples/proto_debuger/third/include/lua/lfunc.h @@ -0,0 +1,69 @@ +/* +** $Id: lfunc.h $ +** Auxiliary functions to manipulate prototypes and closures +** See Copyright Notice in lua.h +*/ + +#ifndef lfunc_h +#define lfunc_h + + +#include "lobject.h" + + +#define sizeCclosure(n) (cast_int(offsetof(CClosure, upvalue)) + \ + cast_int(sizeof(TValue)) * (n)) + +#define sizeLclosure(n) (cast_int(offsetof(LClosure, upvals)) + \ + cast_int(sizeof(TValue *)) * (n)) + + +/* test whether thread is in 'twups' list */ +#define isintwups(L) (L->twups != L) + + +/* +** maximum number of upvalues in a closure (both C and Lua). (Value +** must fit in a VM register.) +*/ +#define MAXUPVAL 255 + + +#define upisopen(up) ((up)->v != &(up)->u.value) + + +#define uplevel(up) check_exp(upisopen(up), cast(StkId, (up)->v)) + + +/* +** maximum number of misses before giving up the cache of closures +** in prototypes +*/ +#define MAXMISS 10 + + +/* +** Special "status" for 'luaF_close' +*/ + +/* close upvalues without running their closing methods */ +#define NOCLOSINGMETH (-1) + +/* close upvalues running all closing methods in protected mode */ +#define CLOSEPROTECT (-2) + + +LUAI_FUNC Proto *luaF_newproto (lua_State *L); +LUAI_FUNC CClosure *luaF_newCclosure (lua_State *L, int nupvals); +LUAI_FUNC LClosure *luaF_newLclosure (lua_State *L, int nupvals); +LUAI_FUNC void luaF_initupvals (lua_State *L, LClosure *cl); +LUAI_FUNC UpVal *luaF_findupval (lua_State *L, StkId level); +LUAI_FUNC void luaF_newtbcupval (lua_State *L, StkId level); +LUAI_FUNC int luaF_close (lua_State *L, StkId level, int status); +LUAI_FUNC void luaF_unlinkupval (UpVal *uv); +LUAI_FUNC void luaF_freeproto (lua_State *L, Proto *f); +LUAI_FUNC const char *luaF_getlocalname (const Proto *func, int local_number, + int pc); + + +#endif diff --git a/examples/proto_debuger/third/include/lua/lgc.h b/examples/proto_debuger/third/include/lua/lgc.h new file mode 100644 index 00000000..073e2a40 --- /dev/null +++ b/examples/proto_debuger/third/include/lua/lgc.h @@ -0,0 +1,189 @@ +/* +** $Id: lgc.h $ +** Garbage Collector +** See Copyright Notice in lua.h +*/ + +#ifndef lgc_h +#define lgc_h + + +#include "lobject.h" +#include "lstate.h" + +/* +** Collectable objects may have one of three colors: white, which means +** the object is not marked; gray, which means the object is marked, but +** its references may be not marked; and black, which means that the +** object and all its references are marked. The main invariant of the +** garbage collector, while marking objects, is that a black object can +** never point to a white one. Moreover, any gray object must be in a +** "gray list" (gray, grayagain, weak, allweak, ephemeron) so that it +** can be visited again before finishing the collection cycle. (Open +** upvalues are an exception to this rule.) These lists have no meaning +** when the invariant is not being enforced (e.g., sweep phase). +*/ + + +/* +** Possible states of the Garbage Collector +*/ +#define GCSpropagate 0 +#define GCSenteratomic 1 +#define GCSatomic 2 +#define GCSswpallgc 3 +#define GCSswpfinobj 4 +#define GCSswptobefnz 5 +#define GCSswpend 6 +#define GCScallfin 7 +#define GCSpause 8 + + +#define issweepphase(g) \ + (GCSswpallgc <= (g)->gcstate && (g)->gcstate <= GCSswpend) + + +/* +** macro to tell when main invariant (white objects cannot point to black +** ones) must be kept. During a collection, the sweep +** phase may break the invariant, as objects turned white may point to +** still-black objects. The invariant is restored when sweep ends and +** all objects are white again. +*/ + +#define keepinvariant(g) ((g)->gcstate <= GCSatomic) + + +/* +** some useful bit tricks +*/ +#define resetbits(x,m) ((x) &= cast_byte(~(m))) +#define setbits(x,m) ((x) |= (m)) +#define testbits(x,m) ((x) & (m)) +#define bitmask(b) (1<<(b)) +#define bit2mask(b1,b2) (bitmask(b1) | bitmask(b2)) +#define l_setbit(x,b) setbits(x, bitmask(b)) +#define resetbit(x,b) resetbits(x, bitmask(b)) +#define testbit(x,b) testbits(x, bitmask(b)) + + +/* +** Layout for bit use in 'marked' field. First three bits are +** used for object "age" in generational mode. Last bit is used +** by tests. +*/ +#define WHITE0BIT 3 /* object is white (type 0) */ +#define WHITE1BIT 4 /* object is white (type 1) */ +#define BLACKBIT 5 /* object is black */ +#define FINALIZEDBIT 6 /* object has been marked for finalization */ + +#define TESTBIT 7 + + + +#define WHITEBITS bit2mask(WHITE0BIT, WHITE1BIT) + + +#define iswhite(x) testbits((x)->marked, WHITEBITS) +#define isblack(x) testbit((x)->marked, BLACKBIT) +#define isgray(x) /* neither white nor black */ \ + (!testbits((x)->marked, WHITEBITS | bitmask(BLACKBIT))) + +#define tofinalize(x) testbit((x)->marked, FINALIZEDBIT) + +#define otherwhite(g) ((g)->currentwhite ^ WHITEBITS) +#define isdeadm(ow,m) ((m) & (ow)) +#define isdead(g,v) isdeadm(otherwhite(g), (v)->marked) + +#define changewhite(x) ((x)->marked ^= WHITEBITS) +#define nw2black(x) \ + check_exp(!iswhite(x), l_setbit((x)->marked, BLACKBIT)) + +#define luaC_white(g) cast_byte((g)->currentwhite & WHITEBITS) + + +/* object age in generational mode */ +#define G_NEW 0 /* created in current cycle */ +#define G_SURVIVAL 1 /* created in previous cycle */ +#define G_OLD0 2 /* marked old by frw. barrier in this cycle */ +#define G_OLD1 3 /* first full cycle as old */ +#define G_OLD 4 /* really old object (not to be visited) */ +#define G_TOUCHED1 5 /* old object touched this cycle */ +#define G_TOUCHED2 6 /* old object touched in previous cycle */ + +#define AGEBITS 7 /* all age bits (111) */ + +#define getage(o) ((o)->marked & AGEBITS) +#define setage(o,a) ((o)->marked = cast_byte(((o)->marked & (~AGEBITS)) | a)) +#define isold(o) (getage(o) > G_SURVIVAL) + +#define changeage(o,f,t) \ + check_exp(getage(o) == (f), (o)->marked ^= ((f)^(t))) + + +/* Default Values for GC parameters */ +#define LUAI_GENMAJORMUL 100 +#define LUAI_GENMINORMUL 20 + +/* wait memory to double before starting new cycle */ +#define LUAI_GCPAUSE 200 + +/* +** some gc parameters are stored divided by 4 to allow a maximum value +** up to 1023 in a 'lu_byte'. +*/ +#define getgcparam(p) ((p) * 4) +#define setgcparam(p,v) ((p) = (v) / 4) + +#define LUAI_GCMUL 100 + +/* how much to allocate before next GC step (log2) */ +#define LUAI_GCSTEPSIZE 13 /* 8 KB */ + + +/* +** Check whether the declared GC mode is generational. While in +** generational mode, the collector can go temporarily to incremental +** mode to improve performance. This is signaled by 'g->lastatomic != 0'. +*/ +#define isdecGCmodegen(g) (g->gckind == KGC_GEN || g->lastatomic != 0) + +/* +** Does one step of collection when debt becomes positive. 'pre'/'pos' +** allows some adjustments to be done only when needed. macro +** 'condchangemem' is used only for heavy tests (forcing a full +** GC cycle on every opportunity) +*/ +#define luaC_condGC(L,pre,pos) \ + { if (G(L)->GCdebt > 0) { pre; luaC_step(L); pos;}; \ + condchangemem(L,pre,pos); } + +/* more often than not, 'pre'/'pos' are empty */ +#define luaC_checkGC(L) luaC_condGC(L,(void)0,(void)0) + + +#define luaC_barrier(L,p,v) ( \ + (iscollectable(v) && isblack(p) && iswhite(gcvalue(v))) ? \ + luaC_barrier_(L,obj2gco(p),gcvalue(v)) : cast_void(0)) + +#define luaC_barrierback(L,p,v) ( \ + (iscollectable(v) && isblack(p) && iswhite(gcvalue(v))) ? \ + luaC_barrierback_(L,p) : cast_void(0)) + +#define luaC_objbarrier(L,p,o) ( \ + (isblack(p) && iswhite(o)) ? \ + luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) + +LUAI_FUNC void luaC_fix (lua_State *L, GCObject *o); +LUAI_FUNC void luaC_freeallobjects (lua_State *L); +LUAI_FUNC void luaC_step (lua_State *L); +LUAI_FUNC void luaC_runtilstate (lua_State *L, int statesmask); +LUAI_FUNC void luaC_fullgc (lua_State *L, int isemergency); +LUAI_FUNC GCObject *luaC_newobj (lua_State *L, int tt, size_t sz); +LUAI_FUNC void luaC_barrier_ (lua_State *L, GCObject *o, GCObject *v); +LUAI_FUNC void luaC_barrierback_ (lua_State *L, GCObject *o); +LUAI_FUNC void luaC_checkfinalizer (lua_State *L, GCObject *o, Table *mt); +LUAI_FUNC void luaC_changemode (lua_State *L, int newmode); + + +#endif diff --git a/examples/proto_debuger/third/include/lua/ljumptab.h b/examples/proto_debuger/third/include/lua/ljumptab.h new file mode 100644 index 00000000..8306f250 --- /dev/null +++ b/examples/proto_debuger/third/include/lua/ljumptab.h @@ -0,0 +1,112 @@ +/* +** $Id: ljumptab.h $ +** Jump Table for the Lua interpreter +** See Copyright Notice in lua.h +*/ + + +#undef vmdispatch +#undef vmcase +#undef vmbreak + +#define vmdispatch(x) goto *disptab[x]; + +#define vmcase(l) L_##l: + +#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); + + +static const void *const disptab[NUM_OPCODES] = { + +#if 0 +** you can update the following list with this command: +** +** sed -n '/^OP_/\!d; s/OP_/\&\&L_OP_/ ; s/,.*/,/ ; s/\/.*// ; p' lopcodes.h +** +#endif + +&&L_OP_MOVE, +&&L_OP_LOADI, +&&L_OP_LOADF, +&&L_OP_LOADK, +&&L_OP_LOADKX, +&&L_OP_LOADFALSE, +&&L_OP_LFALSESKIP, +&&L_OP_LOADTRUE, +&&L_OP_LOADNIL, +&&L_OP_GETUPVAL, +&&L_OP_SETUPVAL, +&&L_OP_GETTABUP, +&&L_OP_GETTABLE, +&&L_OP_GETI, +&&L_OP_GETFIELD, +&&L_OP_SETTABUP, +&&L_OP_SETTABLE, +&&L_OP_SETI, +&&L_OP_SETFIELD, +&&L_OP_NEWTABLE, +&&L_OP_SELF, +&&L_OP_ADDI, +&&L_OP_ADDK, +&&L_OP_SUBK, +&&L_OP_MULK, +&&L_OP_MODK, +&&L_OP_POWK, +&&L_OP_DIVK, +&&L_OP_IDIVK, +&&L_OP_BANDK, +&&L_OP_BORK, +&&L_OP_BXORK, +&&L_OP_SHRI, +&&L_OP_SHLI, +&&L_OP_ADD, +&&L_OP_SUB, +&&L_OP_MUL, +&&L_OP_MOD, +&&L_OP_POW, +&&L_OP_DIV, +&&L_OP_IDIV, +&&L_OP_BAND, +&&L_OP_BOR, +&&L_OP_BXOR, +&&L_OP_SHL, +&&L_OP_SHR, +&&L_OP_MMBIN, +&&L_OP_MMBINI, +&&L_OP_MMBINK, +&&L_OP_UNM, +&&L_OP_BNOT, +&&L_OP_NOT, +&&L_OP_LEN, +&&L_OP_CONCAT, +&&L_OP_CLOSE, +&&L_OP_TBC, +&&L_OP_JMP, +&&L_OP_EQ, +&&L_OP_LT, +&&L_OP_LE, +&&L_OP_EQK, +&&L_OP_EQI, +&&L_OP_LTI, +&&L_OP_LEI, +&&L_OP_GTI, +&&L_OP_GEI, +&&L_OP_TEST, +&&L_OP_TESTSET, +&&L_OP_CALL, +&&L_OP_TAILCALL, +&&L_OP_RETURN, +&&L_OP_RETURN0, +&&L_OP_RETURN1, +&&L_OP_FORLOOP, +&&L_OP_FORPREP, +&&L_OP_TFORPREP, +&&L_OP_TFORCALL, +&&L_OP_TFORLOOP, +&&L_OP_SETLIST, +&&L_OP_CLOSURE, +&&L_OP_VARARG, +&&L_OP_VARARGPREP, +&&L_OP_EXTRAARG + +}; diff --git a/examples/proto_debuger/third/include/lua/llex.h b/examples/proto_debuger/third/include/lua/llex.h new file mode 100644 index 00000000..389d2f86 --- /dev/null +++ b/examples/proto_debuger/third/include/lua/llex.h @@ -0,0 +1,91 @@ +/* +** $Id: llex.h $ +** Lexical Analyzer +** See Copyright Notice in lua.h +*/ + +#ifndef llex_h +#define llex_h + +#include + +#include "lobject.h" +#include "lzio.h" + + +/* +** Single-char tokens (terminal symbols) are represented by their own +** numeric code. Other tokens start at the following value. +*/ +#define FIRST_RESERVED (UCHAR_MAX + 1) + + +#if !defined(LUA_ENV) +#define LUA_ENV "_ENV" +#endif + + +/* +* WARNING: if you change the order of this enumeration, +* grep "ORDER RESERVED" +*/ +enum RESERVED { + /* terminal symbols denoted by reserved words */ + TK_AND = FIRST_RESERVED, TK_BREAK, + TK_DO, TK_ELSE, TK_ELSEIF, TK_END, TK_FALSE, TK_FOR, TK_FUNCTION, + TK_GOTO, TK_IF, TK_IN, TK_LOCAL, TK_NIL, TK_NOT, TK_OR, TK_REPEAT, + TK_RETURN, TK_THEN, TK_TRUE, TK_UNTIL, TK_WHILE, + /* other terminal symbols */ + TK_IDIV, TK_CONCAT, TK_DOTS, TK_EQ, TK_GE, TK_LE, TK_NE, + TK_SHL, TK_SHR, + TK_DBCOLON, TK_EOS, + TK_FLT, TK_INT, TK_NAME, TK_STRING +}; + +/* number of reserved words */ +#define NUM_RESERVED (cast_int(TK_WHILE-FIRST_RESERVED + 1)) + + +typedef union { + lua_Number r; + lua_Integer i; + TString *ts; +} SemInfo; /* semantics information */ + + +typedef struct Token { + int token; + SemInfo seminfo; +} Token; + + +/* state of the lexer plus state of the parser when shared by all + functions */ +typedef struct LexState { + int current; /* current character (charint) */ + int linenumber; /* input line counter */ + int lastline; /* line of last token 'consumed' */ + Token t; /* current token */ + Token lookahead; /* look ahead token */ + struct FuncState *fs; /* current function (parser) */ + struct lua_State *L; + ZIO *z; /* input stream */ + Mbuffer *buff; /* buffer for tokens */ + Table *h; /* to avoid collection/reuse strings */ + struct Dyndata *dyd; /* dynamic structures used by the parser */ + TString *source; /* current source name */ + TString *envn; /* environment variable name */ +} LexState; + + +LUAI_FUNC void luaX_init (lua_State *L); +LUAI_FUNC void luaX_setinput (lua_State *L, LexState *ls, ZIO *z, + TString *source, int firstchar); +LUAI_FUNC TString *luaX_newstring (LexState *ls, const char *str, size_t l); +LUAI_FUNC void luaX_next (LexState *ls); +LUAI_FUNC int luaX_lookahead (LexState *ls); +LUAI_FUNC l_noret luaX_syntaxerror (LexState *ls, const char *s); +LUAI_FUNC const char *luaX_token2str (LexState *ls, int token); + + +#endif diff --git a/examples/proto_debuger/third/include/lua/llimits.h b/examples/proto_debuger/third/include/lua/llimits.h new file mode 100644 index 00000000..d0394831 --- /dev/null +++ b/examples/proto_debuger/third/include/lua/llimits.h @@ -0,0 +1,369 @@ +/* +** $Id: llimits.h $ +** Limits, basic types, and some other 'installation-dependent' definitions +** See Copyright Notice in lua.h +*/ + +#ifndef llimits_h +#define llimits_h + + +#include +#include + + +#include "lua.h" + + +/* +** 'lu_mem' and 'l_mem' are unsigned/signed integers big enough to count +** the total memory used by Lua (in bytes). Usually, 'size_t' and +** 'ptrdiff_t' should work, but we use 'long' for 16-bit machines. +*/ +#if defined(LUAI_MEM) /* { external definitions? */ +typedef LUAI_UMEM lu_mem; +typedef LUAI_MEM l_mem; +#elif LUAI_IS32INT /* }{ */ +typedef size_t lu_mem; +typedef ptrdiff_t l_mem; +#else /* 16-bit ints */ /* }{ */ +typedef unsigned long lu_mem; +typedef long l_mem; +#endif /* } */ + + +/* chars used as small naturals (so that 'char' is reserved for characters) */ +typedef unsigned char lu_byte; +typedef signed char ls_byte; + + +/* maximum value for size_t */ +#define MAX_SIZET ((size_t)(~(size_t)0)) + +/* maximum size visible for Lua (must be representable in a lua_Integer) */ +#define MAX_SIZE (sizeof(size_t) < sizeof(lua_Integer) ? MAX_SIZET \ + : (size_t)(LUA_MAXINTEGER)) + + +#define MAX_LUMEM ((lu_mem)(~(lu_mem)0)) + +#define MAX_LMEM ((l_mem)(MAX_LUMEM >> 1)) + + +#define MAX_INT INT_MAX /* maximum value of an int */ + + +/* +** floor of the log2 of the maximum signed value for integral type 't'. +** (That is, maximum 'n' such that '2^n' fits in the given signed type.) +*/ +#define log2maxs(t) (sizeof(t) * 8 - 2) + + +/* +** test whether an unsigned value is a power of 2 (or zero) +*/ +#define ispow2(x) (((x) & ((x) - 1)) == 0) + + +/* number of chars of a literal string without the ending \0 */ +#define LL(x) (sizeof(x)/sizeof(char) - 1) + + +/* +** conversion of pointer to unsigned integer: +** this is for hashing only; there is no problem if the integer +** cannot hold the whole pointer value +*/ +#define point2uint(p) ((unsigned int)((size_t)(p) & UINT_MAX)) + + + +/* types of 'usual argument conversions' for lua_Number and lua_Integer */ +typedef LUAI_UACNUMBER l_uacNumber; +typedef LUAI_UACINT l_uacInt; + + +/* +** Internal assertions for in-house debugging +*/ +#if defined LUAI_ASSERT +#undef NDEBUG +#include +#define lua_assert(c) assert(c) +#endif + +#if defined(lua_assert) +#define check_exp(c,e) (lua_assert(c), (e)) +/* to avoid problems with conditions too long */ +#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0)) +#else +#define lua_assert(c) ((void)0) +#define check_exp(c,e) (e) +#define lua_longassert(c) ((void)0) +#endif + +/* +** assertion for checking API calls +*/ +#if !defined(luai_apicheck) +#define luai_apicheck(l,e) ((void)l, lua_assert(e)) +#endif + +#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) + + +/* macro to avoid warnings about unused variables */ +#if !defined(UNUSED) +#define UNUSED(x) ((void)(x)) +#endif + + +/* type casts (a macro highlights casts in the code) */ +#define cast(t, exp) ((t)(exp)) + +#define cast_void(i) cast(void, (i)) +#define cast_voidp(i) cast(void *, (i)) +#define cast_num(i) cast(lua_Number, (i)) +#define cast_int(i) cast(int, (i)) +#define cast_uint(i) cast(unsigned int, (i)) +#define cast_byte(i) cast(lu_byte, (i)) +#define cast_uchar(i) cast(unsigned char, (i)) +#define cast_char(i) cast(char, (i)) +#define cast_charp(i) cast(char *, (i)) +#define cast_sizet(i) cast(size_t, (i)) + + +/* cast a signed lua_Integer to lua_Unsigned */ +#if !defined(l_castS2U) +#define l_castS2U(i) ((lua_Unsigned)(i)) +#endif + +/* +** cast a lua_Unsigned to a signed lua_Integer; this cast is +** not strict ISO C, but two-complement architectures should +** work fine. +*/ +#if !defined(l_castU2S) +#define l_castU2S(i) ((lua_Integer)(i)) +#endif + + +/* +** macros to improve jump prediction (used mainly for error handling) +*/ +#if !defined(likely) + +#if defined(__GNUC__) +#define likely(x) (__builtin_expect(((x) != 0), 1)) +#define unlikely(x) (__builtin_expect(((x) != 0), 0)) +#else +#define likely(x) (x) +#define unlikely(x) (x) +#endif + +#endif + + +/* +** non-return type +*/ +#if !defined(l_noret) + +#if defined(__GNUC__) +#define l_noret void __attribute__((noreturn)) +#elif defined(_MSC_VER) && _MSC_VER >= 1200 +#define l_noret void __declspec(noreturn) +#else +#define l_noret void +#endif + +#endif + + +/* +** type for virtual-machine instructions; +** must be an unsigned with (at least) 4 bytes (see details in lopcodes.h) +*/ +#if LUAI_IS32INT +typedef unsigned int l_uint32; +#else +typedef unsigned long l_uint32; +#endif + +typedef l_uint32 Instruction; + + + +/* +** Maximum length for short strings, that is, strings that are +** internalized. (Cannot be smaller than reserved words or tags for +** metamethods, as these strings must be internalized; +** #("function") = 8, #("__newindex") = 10.) +*/ +#if !defined(LUAI_MAXSHORTLEN) +#define LUAI_MAXSHORTLEN 40 +#endif + + +/* +** Initial size for the string table (must be power of 2). +** The Lua core alone registers ~50 strings (reserved words + +** metaevent keys + a few others). Libraries would typically add +** a few dozens more. +*/ +#if !defined(MINSTRTABSIZE) +#define MINSTRTABSIZE 128 +#endif + + +/* +** Size of cache for strings in the API. 'N' is the number of +** sets (better be a prime) and "M" is the size of each set (M == 1 +** makes a direct cache.) +*/ +#if !defined(STRCACHE_N) +#define STRCACHE_N 53 +#define STRCACHE_M 2 +#endif + + +/* minimum size for string buffer */ +#if !defined(LUA_MINBUFFER) +#define LUA_MINBUFFER 32 +#endif + + +/* +** Maximum depth for nested C calls, syntactical nested non-terminals, +** and other features implemented through recursion in C. (Value must +** fit in a 16-bit unsigned integer. It must also be compatible with +** the size of the C stack.) +*/ +#if !defined(LUAI_MAXCCALLS) +#define LUAI_MAXCCALLS 200 +#endif + + +/* +** macros that are executed whenever program enters the Lua core +** ('lua_lock') and leaves the core ('lua_unlock') +*/ +#if !defined(lua_lock) +#define lua_lock(L) ((void) 0) +#define lua_unlock(L) ((void) 0) +#endif + +/* +** macro executed during Lua functions at points where the +** function can yield. +*/ +#if !defined(luai_threadyield) +#define luai_threadyield(L) {lua_unlock(L); lua_lock(L);} +#endif + + +/* +** these macros allow user-specific actions when a thread is +** created/deleted/resumed/yielded. +*/ +#if !defined(luai_userstateopen) +#define luai_userstateopen(L) ((void)L) +#endif + +#if !defined(luai_userstateclose) +#define luai_userstateclose(L) ((void)L) +#endif + +#if !defined(luai_userstatethread) +#define luai_userstatethread(L,L1) ((void)L) +#endif + +#if !defined(luai_userstatefree) +#define luai_userstatefree(L,L1) ((void)L) +#endif + +#if !defined(luai_userstateresume) +#define luai_userstateresume(L,n) ((void)L) +#endif + +#if !defined(luai_userstateyield) +#define luai_userstateyield(L,n) ((void)L) +#endif + + + +/* +** The luai_num* macros define the primitive operations over numbers. +*/ + +/* floor division (defined as 'floor(a/b)') */ +#if !defined(luai_numidiv) +#define luai_numidiv(L,a,b) ((void)L, l_floor(luai_numdiv(L,a,b))) +#endif + +/* float division */ +#if !defined(luai_numdiv) +#define luai_numdiv(L,a,b) ((a)/(b)) +#endif + +/* +** modulo: defined as 'a - floor(a/b)*b'; the direct computation +** using this definition has several problems with rounding errors, +** so it is better to use 'fmod'. 'fmod' gives the result of +** 'a - trunc(a/b)*b', and therefore must be corrected when +** 'trunc(a/b) ~= floor(a/b)'. That happens when the division has a +** non-integer negative result: non-integer result is equivalent to +** a non-zero remainder 'm'; negative result is equivalent to 'a' and +** 'b' with different signs, or 'm' and 'b' with different signs +** (as the result 'm' of 'fmod' has the same sign of 'a'). +*/ +#if !defined(luai_nummod) +#define luai_nummod(L,a,b,m) \ + { (void)L; (m) = l_mathop(fmod)(a,b); \ + if (((m) > 0) ? (b) < 0 : ((m) < 0 && (b) > 0)) (m) += (b); } +#endif + +/* exponentiation */ +#if !defined(luai_numpow) +#define luai_numpow(L,a,b) \ + ((void)L, (b == 2) ? (a)*(a) : l_mathop(pow)(a,b)) +#endif + +/* the others are quite standard operations */ +#if !defined(luai_numadd) +#define luai_numadd(L,a,b) ((a)+(b)) +#define luai_numsub(L,a,b) ((a)-(b)) +#define luai_nummul(L,a,b) ((a)*(b)) +#define luai_numunm(L,a) (-(a)) +#define luai_numeq(a,b) ((a)==(b)) +#define luai_numlt(a,b) ((a)<(b)) +#define luai_numle(a,b) ((a)<=(b)) +#define luai_numgt(a,b) ((a)>(b)) +#define luai_numge(a,b) ((a)>=(b)) +#define luai_numisnan(a) (!luai_numeq((a), (a))) +#endif + + + + + +/* +** macro to control inclusion of some hard tests on stack reallocation +*/ +#if !defined(HARDSTACKTESTS) +#define condmovestack(L,pre,pos) ((void)0) +#else +/* realloc stack keeping its size */ +#define condmovestack(L,pre,pos) \ + { int sz_ = stacksize(L); pre; luaD_reallocstack((L), sz_, 0); pos; } +#endif + +#if !defined(HARDMEMTESTS) +#define condchangemem(L,pre,pos) ((void)0) +#else +#define condchangemem(L,pre,pos) \ + { if (G(L)->gcrunning) { pre; luaC_fullgc(L, 0); pos; } } +#endif + +#endif diff --git a/examples/proto_debuger/third/include/lua/lmem.h b/examples/proto_debuger/third/include/lua/lmem.h new file mode 100644 index 00000000..8c75a44b --- /dev/null +++ b/examples/proto_debuger/third/include/lua/lmem.h @@ -0,0 +1,93 @@ +/* +** $Id: lmem.h $ +** Interface to Memory Manager +** See Copyright Notice in lua.h +*/ + +#ifndef lmem_h +#define lmem_h + + +#include + +#include "llimits.h" +#include "lua.h" + + +#define luaM_error(L) luaD_throw(L, LUA_ERRMEM) + + +/* +** This macro tests whether it is safe to multiply 'n' by the size of +** type 't' without overflows. Because 'e' is always constant, it avoids +** the runtime division MAX_SIZET/(e). +** (The macro is somewhat complex to avoid warnings: The 'sizeof' +** comparison avoids a runtime comparison when overflow cannot occur. +** The compiler should be able to optimize the real test by itself, but +** when it does it, it may give a warning about "comparison is always +** false due to limited range of data type"; the +1 tricks the compiler, +** avoiding this warning but also this optimization.) +*/ +#define luaM_testsize(n,e) \ + (sizeof(n) >= sizeof(size_t) && cast_sizet((n)) + 1 > MAX_SIZET/(e)) + +#define luaM_checksize(L,n,e) \ + (luaM_testsize(n,e) ? luaM_toobig(L) : cast_void(0)) + + +/* +** Computes the minimum between 'n' and 'MAX_SIZET/sizeof(t)', so that +** the result is not larger than 'n' and cannot overflow a 'size_t' +** when multiplied by the size of type 't'. (Assumes that 'n' is an +** 'int' or 'unsigned int' and that 'int' is not larger than 'size_t'.) +*/ +#define luaM_limitN(n,t) \ + ((cast_sizet(n) <= MAX_SIZET/sizeof(t)) ? (n) : \ + cast_uint((MAX_SIZET/sizeof(t)))) + + +/* +** Arrays of chars do not need any test +*/ +#define luaM_reallocvchar(L,b,on,n) \ + cast_charp(luaM_saferealloc_(L, (b), (on)*sizeof(char), (n)*sizeof(char))) + +#define luaM_freemem(L, b, s) luaM_free_(L, (b), (s)) +#define luaM_free(L, b) luaM_free_(L, (b), sizeof(*(b))) +#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) + +#define luaM_new(L,t) cast(t*, luaM_malloc_(L, sizeof(t), 0)) +#define luaM_newvector(L,n,t) cast(t*, luaM_malloc_(L, (n)*sizeof(t), 0)) +#define luaM_newvectorchecked(L,n,t) \ + (luaM_checksize(L,n,sizeof(t)), luaM_newvector(L,n,t)) + +#define luaM_newobject(L,tag,s) luaM_malloc_(L, (s), tag) + +#define luaM_growvector(L,v,nelems,size,t,limit,e) \ + ((v)=cast(t *, luaM_growaux_(L,v,nelems,&(size),sizeof(t), \ + luaM_limitN(limit,t),e))) + +#define luaM_reallocvector(L, v,oldn,n,t) \ + (cast(t *, luaM_realloc_(L, v, cast_sizet(oldn) * sizeof(t), \ + cast_sizet(n) * sizeof(t)))) + +#define luaM_shrinkvector(L,v,size,fs,t) \ + ((v)=cast(t *, luaM_shrinkvector_(L, v, &(size), fs, sizeof(t)))) + +LUAI_FUNC l_noret luaM_toobig (lua_State *L); + +/* not to be called directly */ +LUAI_FUNC void *luaM_realloc_ (lua_State *L, void *block, size_t oldsize, + size_t size); +LUAI_FUNC void *luaM_saferealloc_ (lua_State *L, void *block, size_t oldsize, + size_t size); +LUAI_FUNC void luaM_free_ (lua_State *L, void *block, size_t osize); +LUAI_FUNC void *luaM_growaux_ (lua_State *L, void *block, int nelems, + int *size, int size_elem, int limit, + const char *what); +LUAI_FUNC void *luaM_shrinkvector_ (lua_State *L, void *block, int *nelem, + int final_n, int size_elem); +LUAI_FUNC void *luaM_malloc_ (lua_State *L, size_t size, int tag); + +#endif + diff --git a/examples/proto_debuger/third/include/lua/lobject.h b/examples/proto_debuger/third/include/lua/lobject.h new file mode 100644 index 00000000..1cc8e757 --- /dev/null +++ b/examples/proto_debuger/third/include/lua/lobject.h @@ -0,0 +1,790 @@ +/* +** $Id: lobject.h $ +** Type definitions for Lua objects +** See Copyright Notice in lua.h +*/ + + +#ifndef lobject_h +#define lobject_h + + +#include + + +#include "llimits.h" +#include "lua.h" + + +/* +** Extra types for collectable non-values +*/ +#define LUA_TUPVAL LUA_NUMTYPES /* upvalues */ +#define LUA_TPROTO (LUA_NUMTYPES+1) /* function prototypes */ +#define LUA_TDEADKEY (LUA_NUMTYPES+2) /* removed keys in tables */ + + + +/* +** number of all possible types (including LUA_TNONE but excluding DEADKEY) +*/ +#define LUA_TOTALTYPES (LUA_TPROTO + 2) + + +/* +** tags for Tagged Values have the following use of bits: +** bits 0-3: actual tag (a LUA_T* constant) +** bits 4-5: variant bits +** bit 6: whether value is collectable +*/ + +/* add variant bits to a type */ +#define makevariant(t,v) ((t) | ((v) << 4)) + + + +/* +** Union of all Lua values +*/ +typedef union Value { + struct GCObject *gc; /* collectable objects */ + void *p; /* light userdata */ + lua_CFunction f; /* light C functions */ + lua_Integer i; /* integer numbers */ + lua_Number n; /* float numbers */ +} Value; + + +/* +** Tagged Values. This is the basic representation of values in Lua: +** an actual value plus a tag with its type. +*/ + +#define TValuefields Value value_; lu_byte tt_ + +typedef struct TValue { + TValuefields; +} TValue; + + +#define val_(o) ((o)->value_) +#define valraw(o) (&val_(o)) + + +/* raw type tag of a TValue */ +#define rawtt(o) ((o)->tt_) + +/* tag with no variants (bits 0-3) */ +#define novariant(t) ((t) & 0x0F) + +/* type tag of a TValue (bits 0-3 for tags + variant bits 4-5) */ +#define withvariant(t) ((t) & 0x3F) +#define ttypetag(o) withvariant(rawtt(o)) + +/* type of a TValue */ +#define ttype(o) (novariant(rawtt(o))) + + +/* Macros to test type */ +#define checktag(o,t) (rawtt(o) == (t)) +#define checktype(o,t) (ttype(o) == (t)) + + +/* Macros for internal tests */ + +/* collectable object has the same tag as the original value */ +#define righttt(obj) (ttypetag(obj) == gcvalue(obj)->tt) + +/* +** Any value being manipulated by the program either is non +** collectable, or the collectable object has the right tag +** and it is not dead. The option 'L == NULL' allows other +** macros using this one to be used where L is not available. +*/ +#define checkliveness(L,obj) \ + ((void)L, lua_longassert(!iscollectable(obj) || \ + (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) + + +/* Macros to set values */ + +/* set a value's tag */ +#define settt_(o,t) ((o)->tt_=(t)) + + +/* main macro to copy values (from 'obj1' to 'obj2') */ +#define setobj(L,obj1,obj2) \ + { TValue *io1=(obj1); const TValue *io2=(obj2); \ + io1->value_ = io2->value_; settt_(io1, io2->tt_); \ + checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } + +/* +** Different types of assignments, according to source and destination. +** (They are mostly equal now, but may be different in the future.) +*/ + +/* from stack to stack */ +#define setobjs2s(L,o1,o2) setobj(L,s2v(o1),s2v(o2)) +/* to stack (not from same stack) */ +#define setobj2s(L,o1,o2) setobj(L,s2v(o1),o2) +/* from table to same table */ +#define setobjt2t setobj +/* to new object */ +#define setobj2n setobj +/* to table */ +#define setobj2t setobj + + +/* +** Entries in the Lua stack +*/ +typedef union StackValue { + TValue val; +} StackValue; + + +/* index to stack elements */ +typedef StackValue *StkId; + +/* convert a 'StackValue' to a 'TValue' */ +#define s2v(o) (&(o)->val) + + + +/* +** {================================================================== +** Nil +** =================================================================== +*/ + +/* Standard nil */ +#define LUA_VNIL makevariant(LUA_TNIL, 0) + +/* Empty slot (which might be different from a slot containing nil) */ +#define LUA_VEMPTY makevariant(LUA_TNIL, 1) + +/* Value returned for a key not found in a table (absent key) */ +#define LUA_VABSTKEY makevariant(LUA_TNIL, 2) + + +/* macro to test for (any kind of) nil */ +#define ttisnil(v) checktype((v), LUA_TNIL) + + +/* macro to test for a standard nil */ +#define ttisstrictnil(o) checktag((o), LUA_VNIL) + + +#define setnilvalue(obj) settt_(obj, LUA_VNIL) + + +#define isabstkey(v) checktag((v), LUA_VABSTKEY) + + +/* +** macro to detect non-standard nils (used only in assertions) +*/ +#define isnonstrictnil(v) (ttisnil(v) && !ttisstrictnil(v)) + + +/* +** By default, entries with any kind of nil are considered empty. +** (In any definition, values associated with absent keys must also +** be accepted as empty.) +*/ +#define isempty(v) ttisnil(v) + + +/* macro defining a value corresponding to an absent key */ +#define ABSTKEYCONSTANT {NULL}, LUA_VABSTKEY + + +/* mark an entry as empty */ +#define setempty(v) settt_(v, LUA_VEMPTY) + + + +/* }================================================================== */ + + +/* +** {================================================================== +** Booleans +** =================================================================== +*/ + + +#define LUA_VFALSE makevariant(LUA_TBOOLEAN, 0) +#define LUA_VTRUE makevariant(LUA_TBOOLEAN, 1) + +#define ttisboolean(o) checktype((o), LUA_TBOOLEAN) +#define ttisfalse(o) checktag((o), LUA_VFALSE) +#define ttistrue(o) checktag((o), LUA_VTRUE) + + +#define l_isfalse(o) (ttisfalse(o) || ttisnil(o)) + + +#define setbfvalue(obj) settt_(obj, LUA_VFALSE) +#define setbtvalue(obj) settt_(obj, LUA_VTRUE) + +/* }================================================================== */ + + +/* +** {================================================================== +** Threads +** =================================================================== +*/ + +#define LUA_VTHREAD makevariant(LUA_TTHREAD, 0) + +#define ttisthread(o) checktag((o), ctb(LUA_VTHREAD)) + +#define thvalue(o) check_exp(ttisthread(o), gco2th(val_(o).gc)) + +#define setthvalue(L,obj,x) \ + { TValue *io = (obj); lua_State *x_ = (x); \ + val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTHREAD)); \ + checkliveness(L,io); } + +#define setthvalue2s(L,o,t) setthvalue(L,s2v(o),t) + +/* }================================================================== */ + + +/* +** {================================================================== +** Collectable Objects +** =================================================================== +*/ + +/* +** Common Header for all collectable objects (in macro form, to be +** included in other objects) +*/ +#define CommonHeader struct GCObject *next; lu_byte tt; lu_byte marked + + +/* Common type for all collectable objects */ +typedef struct GCObject { + CommonHeader; +} GCObject; + + +/* Bit mark for collectable types */ +#define BIT_ISCOLLECTABLE (1 << 6) + +#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) + +/* mark a tag as collectable */ +#define ctb(t) ((t) | BIT_ISCOLLECTABLE) + +#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) + +#define gcvalueraw(v) ((v).gc) + +#define setgcovalue(L,obj,x) \ + { TValue *io = (obj); GCObject *i_g=(x); \ + val_(io).gc = i_g; settt_(io, ctb(i_g->tt)); } + +/* }================================================================== */ + + +/* +** {================================================================== +** Numbers +** =================================================================== +*/ + +/* Variant tags for numbers */ +#define LUA_VNUMINT makevariant(LUA_TNUMBER, 0) /* integer numbers */ +#define LUA_VNUMFLT makevariant(LUA_TNUMBER, 1) /* float numbers */ + +#define ttisnumber(o) checktype((o), LUA_TNUMBER) +#define ttisfloat(o) checktag((o), LUA_VNUMFLT) +#define ttisinteger(o) checktag((o), LUA_VNUMINT) + +#define nvalue(o) check_exp(ttisnumber(o), \ + (ttisinteger(o) ? cast_num(ivalue(o)) : fltvalue(o))) +#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) +#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) + +#define fltvalueraw(v) ((v).n) +#define ivalueraw(v) ((v).i) + +#define setfltvalue(obj,x) \ + { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } + +#define chgfltvalue(obj,x) \ + { TValue *io=(obj); lua_assert(ttisfloat(io)); val_(io).n=(x); } + +#define setivalue(obj,x) \ + { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } + +#define chgivalue(obj,x) \ + { TValue *io=(obj); lua_assert(ttisinteger(io)); val_(io).i=(x); } + +/* }================================================================== */ + + +/* +** {================================================================== +** Strings +** =================================================================== +*/ + +/* Variant tags for strings */ +#define LUA_VSHRSTR makevariant(LUA_TSTRING, 0) /* short strings */ +#define LUA_VLNGSTR makevariant(LUA_TSTRING, 1) /* long strings */ + +#define ttisstring(o) checktype((o), LUA_TSTRING) +#define ttisshrstring(o) checktag((o), ctb(LUA_VSHRSTR)) +#define ttislngstring(o) checktag((o), ctb(LUA_VLNGSTR)) + +#define tsvalueraw(v) (gco2ts((v).gc)) + +#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) + +#define setsvalue(L,obj,x) \ + { TValue *io = (obj); TString *x_ = (x); \ + val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ + checkliveness(L,io); } + +/* set a string to the stack */ +#define setsvalue2s(L,o,s) setsvalue(L,s2v(o),s) + +/* set a string to a new object */ +#define setsvalue2n setsvalue + + +/* +** Header for a string value. +*/ +typedef struct TString { + CommonHeader; + lu_byte extra; /* reserved words for short strings; "has hash" for longs */ + lu_byte shrlen; /* length for short strings */ + unsigned int hash; + union { + size_t lnglen; /* length for long strings */ + struct TString *hnext; /* linked list for hash table */ + } u; + char contents[1]; +} TString; + + + +/* +** Get the actual string (array of bytes) from a 'TString'. +*/ +#define getstr(ts) ((ts)->contents) + + +/* get the actual string (array of bytes) from a Lua value */ +#define svalue(o) getstr(tsvalue(o)) + +/* get string length from 'TString *s' */ +#define tsslen(s) ((s)->tt == LUA_VSHRSTR ? (s)->shrlen : (s)->u.lnglen) + +/* get string length from 'TValue *o' */ +#define vslen(o) tsslen(tsvalue(o)) + +/* }================================================================== */ + + +/* +** {================================================================== +** Userdata +** =================================================================== +*/ + + +/* +** Light userdata should be a variant of userdata, but for compatibility +** reasons they are also different types. +*/ +#define LUA_VLIGHTUSERDATA makevariant(LUA_TLIGHTUSERDATA, 0) + +#define LUA_VUSERDATA makevariant(LUA_TUSERDATA, 0) + +#define ttislightuserdata(o) checktag((o), LUA_VLIGHTUSERDATA) +#define ttisfulluserdata(o) checktag((o), ctb(LUA_VUSERDATA)) + +#define pvalue(o) check_exp(ttislightuserdata(o), val_(o).p) +#define uvalue(o) check_exp(ttisfulluserdata(o), gco2u(val_(o).gc)) + +#define pvalueraw(v) ((v).p) + +#define setpvalue(obj,x) \ + { TValue *io=(obj); val_(io).p=(x); settt_(io, LUA_VLIGHTUSERDATA); } + +#define setuvalue(L,obj,x) \ + { TValue *io = (obj); Udata *x_ = (x); \ + val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VUSERDATA)); \ + checkliveness(L,io); } + + +/* Ensures that addresses after this type are always fully aligned. */ +typedef union UValue { + TValue uv; + LUAI_MAXALIGN; /* ensures maximum alignment for udata bytes */ +} UValue; + + +/* +** Header for userdata with user values; +** memory area follows the end of this structure. +*/ +typedef struct Udata { + CommonHeader; + unsigned short nuvalue; /* number of user values */ + size_t len; /* number of bytes */ + struct Table *metatable; + GCObject *gclist; + UValue uv[1]; /* user values */ +} Udata; + + +/* +** Header for userdata with no user values. These userdata do not need +** to be gray during GC, and therefore do not need a 'gclist' field. +** To simplify, the code always use 'Udata' for both kinds of userdata, +** making sure it never accesses 'gclist' on userdata with no user values. +** This structure here is used only to compute the correct size for +** this representation. (The 'bindata' field in its end ensures correct +** alignment for binary data following this header.) +*/ +typedef struct Udata0 { + CommonHeader; + unsigned short nuvalue; /* number of user values */ + size_t len; /* number of bytes */ + struct Table *metatable; + union {LUAI_MAXALIGN;} bindata; +} Udata0; + + +/* compute the offset of the memory area of a userdata */ +#define udatamemoffset(nuv) \ + ((nuv) == 0 ? offsetof(Udata0, bindata) \ + : offsetof(Udata, uv) + (sizeof(UValue) * (nuv))) + +/* get the address of the memory block inside 'Udata' */ +#define getudatamem(u) (cast_charp(u) + udatamemoffset((u)->nuvalue)) + +/* compute the size of a userdata */ +#define sizeudata(nuv,nb) (udatamemoffset(nuv) + (nb)) + +/* }================================================================== */ + + +/* +** {================================================================== +** Prototypes +** =================================================================== +*/ + +#define LUA_VPROTO makevariant(LUA_TPROTO, 0) + + +/* +** Description of an upvalue for function prototypes +*/ +typedef struct Upvaldesc { + TString *name; /* upvalue name (for debug information) */ + lu_byte instack; /* whether it is in stack (register) */ + lu_byte idx; /* index of upvalue (in stack or in outer function's list) */ + lu_byte kind; /* kind of corresponding variable */ +} Upvaldesc; + + +/* +** Description of a local variable for function prototypes +** (used for debug information) +*/ +typedef struct LocVar { + TString *varname; + int startpc; /* first point where variable is active */ + int endpc; /* first point where variable is dead */ +} LocVar; + + +/* +** Associates the absolute line source for a given instruction ('pc'). +** The array 'lineinfo' gives, for each instruction, the difference in +** lines from the previous instruction. When that difference does not +** fit into a byte, Lua saves the absolute line for that instruction. +** (Lua also saves the absolute line periodically, to speed up the +** computation of a line number: we can use binary search in the +** absolute-line array, but we must traverse the 'lineinfo' array +** linearly to compute a line.) +*/ +typedef struct AbsLineInfo { + int pc; + int line; +} AbsLineInfo; + +/* +** Function Prototypes +*/ +typedef struct Proto { + CommonHeader; + lu_byte numparams; /* number of fixed (named) parameters */ + lu_byte is_vararg; + lu_byte maxstacksize; /* number of registers needed by this function */ + int sizeupvalues; /* size of 'upvalues' */ + int sizek; /* size of 'k' */ + int sizecode; + int sizelineinfo; + int sizep; /* size of 'p' */ + int sizelocvars; + int sizeabslineinfo; /* size of 'abslineinfo' */ + int linedefined; /* debug information */ + int lastlinedefined; /* debug information */ + TValue *k; /* constants used by the function */ + Instruction *code; /* opcodes */ + struct Proto **p; /* functions defined inside the function */ + Upvaldesc *upvalues; /* upvalue information */ + ls_byte *lineinfo; /* information about source lines (debug information) */ + AbsLineInfo *abslineinfo; /* idem */ + LocVar *locvars; /* information about local variables (debug information) */ + TString *source; /* used for debug information */ + GCObject *gclist; +} Proto; + +/* }================================================================== */ + + +/* +** {================================================================== +** Functions +** =================================================================== +*/ + +#define LUA_VUPVAL makevariant(LUA_TUPVAL, 0) + + +/* Variant tags for functions */ +#define LUA_VLCL makevariant(LUA_TFUNCTION, 0) /* Lua closure */ +#define LUA_VLCF makevariant(LUA_TFUNCTION, 1) /* light C function */ +#define LUA_VCCL makevariant(LUA_TFUNCTION, 2) /* C closure */ + +#define ttisfunction(o) checktype(o, LUA_TFUNCTION) +#define ttisclosure(o) ((rawtt(o) & 0x1F) == LUA_VLCL) +#define ttisLclosure(o) checktag((o), ctb(LUA_VLCL)) +#define ttislcf(o) checktag((o), LUA_VLCF) +#define ttisCclosure(o) checktag((o), ctb(LUA_VCCL)) + +#define isLfunction(o) ttisLclosure(o) + +#define clvalue(o) check_exp(ttisclosure(o), gco2cl(val_(o).gc)) +#define clLvalue(o) check_exp(ttisLclosure(o), gco2lcl(val_(o).gc)) +#define fvalue(o) check_exp(ttislcf(o), val_(o).f) +#define clCvalue(o) check_exp(ttisCclosure(o), gco2ccl(val_(o).gc)) + +#define fvalueraw(v) ((v).f) + +#define setclLvalue(L,obj,x) \ + { TValue *io = (obj); LClosure *x_ = (x); \ + val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VLCL)); \ + checkliveness(L,io); } + +#define setclLvalue2s(L,o,cl) setclLvalue(L,s2v(o),cl) + +#define setfvalue(obj,x) \ + { TValue *io=(obj); val_(io).f=(x); settt_(io, LUA_VLCF); } + +#define setclCvalue(L,obj,x) \ + { TValue *io = (obj); CClosure *x_ = (x); \ + val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VCCL)); \ + checkliveness(L,io); } + + +/* +** Upvalues for Lua closures +*/ +typedef struct UpVal { + CommonHeader; + lu_byte tbc; /* true if it represents a to-be-closed variable */ + TValue *v; /* points to stack or to its own value */ + union { + struct { /* (when open) */ + struct UpVal *next; /* linked list */ + struct UpVal **previous; + } open; + TValue value; /* the value (when closed) */ + } u; +} UpVal; + + + +#define ClosureHeader \ + CommonHeader; lu_byte nupvalues; GCObject *gclist + +typedef struct CClosure { + ClosureHeader; + lua_CFunction f; + TValue upvalue[1]; /* list of upvalues */ +} CClosure; + + +typedef struct LClosure { + ClosureHeader; + struct Proto *p; + UpVal *upvals[1]; /* list of upvalues */ +} LClosure; + + +typedef union Closure { + CClosure c; + LClosure l; +} Closure; + + +#define getproto(o) (clLvalue(o)->p) + +/* }================================================================== */ + + +/* +** {================================================================== +** Tables +** =================================================================== +*/ + +#define LUA_VTABLE makevariant(LUA_TTABLE, 0) + +#define ttistable(o) checktag((o), ctb(LUA_VTABLE)) + +#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) + +#define sethvalue(L,obj,x) \ + { TValue *io = (obj); Table *x_ = (x); \ + val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ + checkliveness(L,io); } + +#define sethvalue2s(L,o,h) sethvalue(L,s2v(o),h) + + +/* +** Nodes for Hash tables: A pack of two TValue's (key-value pairs) +** plus a 'next' field to link colliding entries. The distribution +** of the key's fields ('key_tt' and 'key_val') not forming a proper +** 'TValue' allows for a smaller size for 'Node' both in 4-byte +** and 8-byte alignments. +*/ +typedef union Node { + struct NodeKey { + TValuefields; /* fields for value */ + lu_byte key_tt; /* key type */ + int next; /* for chaining */ + Value key_val; /* key value */ + } u; + TValue i_val; /* direct access to node's value as a proper 'TValue' */ +} Node; + + +/* copy a value into a key */ +#define setnodekey(L,node,obj) \ + { Node *n_=(node); const TValue *io_=(obj); \ + n_->u.key_val = io_->value_; n_->u.key_tt = io_->tt_; \ + checkliveness(L,io_); } + + +/* copy a value from a key */ +#define getnodekey(L,obj,node) \ + { TValue *io_=(obj); const Node *n_=(node); \ + io_->value_ = n_->u.key_val; io_->tt_ = n_->u.key_tt; \ + checkliveness(L,io_); } + + +/* +** About 'alimit': if 'isrealasize(t)' is true, then 'alimit' is the +** real size of 'array'. Otherwise, the real size of 'array' is the +** smallest power of two not smaller than 'alimit' (or zero iff 'alimit' +** is zero); 'alimit' is then used as a hint for #t. +*/ + +#define BITRAS (1 << 7) +#define isrealasize(t) (!((t)->flags & BITRAS)) +#define setrealasize(t) ((t)->flags &= cast_byte(~BITRAS)) +#define setnorealasize(t) ((t)->flags |= BITRAS) + + +typedef struct Table { + CommonHeader; + lu_byte flags; /* 1<

u.key_tt) +#define keyval(node) ((node)->u.key_val) + +#define keyisnil(node) (keytt(node) == LUA_TNIL) +#define keyisinteger(node) (keytt(node) == LUA_VNUMINT) +#define keyival(node) (keyval(node).i) +#define keyisshrstr(node) (keytt(node) == ctb(LUA_VSHRSTR)) +#define keystrval(node) (gco2ts(keyval(node).gc)) + +#define setnilkey(node) (keytt(node) = LUA_TNIL) + +#define keyiscollectable(n) (keytt(n) & BIT_ISCOLLECTABLE) + +#define gckey(n) (keyval(n).gc) +#define gckeyN(n) (keyiscollectable(n) ? gckey(n) : NULL) + + +/* +** Dead keys in tables have the tag DEADKEY but keep their original +** gcvalue. This distinguishes them from regular keys but allows them to +** be found when searched in a special way. ('next' needs that to find +** keys removed from a table during a traversal.) +*/ +#define setdeadkey(node) (keytt(node) = LUA_TDEADKEY) +#define keyisdead(node) (keytt(node) == LUA_TDEADKEY) + +/* }================================================================== */ + + + +/* +** 'module' operation for hashing (size is always a power of 2) +*/ +#define lmod(s,size) \ + (check_exp((size&(size-1))==0, (cast_int((s) & ((size)-1))))) + + +#define twoto(x) (1<<(x)) +#define sizenode(t) (twoto((t)->lsizenode)) + + +/* size of buffer for 'luaO_utf8esc' function */ +#define UTF8BUFFSZ 8 + +LUAI_FUNC int luaO_utf8esc (char *buff, unsigned long x); +LUAI_FUNC int luaO_ceillog2 (unsigned int x); +LUAI_FUNC int luaO_rawarith (lua_State *L, int op, const TValue *p1, + const TValue *p2, TValue *res); +LUAI_FUNC void luaO_arith (lua_State *L, int op, const TValue *p1, + const TValue *p2, StkId res); +LUAI_FUNC size_t luaO_str2num (const char *s, TValue *o); +LUAI_FUNC int luaO_hexavalue (int c); +LUAI_FUNC void luaO_tostring (lua_State *L, TValue *obj); +LUAI_FUNC const char *luaO_pushvfstring (lua_State *L, const char *fmt, + va_list argp); +LUAI_FUNC const char *luaO_pushfstring (lua_State *L, const char *fmt, ...); +LUAI_FUNC void luaO_chunkid (char *out, const char *source, size_t srclen); + + +#endif + diff --git a/examples/proto_debuger/third/include/lua/lopcodes.h b/examples/proto_debuger/third/include/lua/lopcodes.h new file mode 100644 index 00000000..120cdd94 --- /dev/null +++ b/examples/proto_debuger/third/include/lua/lopcodes.h @@ -0,0 +1,392 @@ +/* +** $Id: lopcodes.h $ +** Opcodes for Lua virtual machine +** See Copyright Notice in lua.h +*/ + +#ifndef lopcodes_h +#define lopcodes_h + +#include "llimits.h" + + +/*=========================================================================== + We assume that instructions are unsigned 32-bit integers. + All instructions have an opcode in the first 7 bits. + Instructions can have the following formats: + + 3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 + 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 +iABC C(8) | B(8) |k| A(8) | Op(7) | +iABx Bx(17) | A(8) | Op(7) | +iAsBx sBx (signed)(17) | A(8) | Op(7) | +iAx Ax(25) | Op(7) | +isJ sJ(25) | Op(7) | + + A signed argument is represented in excess K: the represented value is + the written unsigned value minus K, where K is half the maximum for the + corresponding unsigned argument. +===========================================================================*/ + + +enum OpMode {iABC, iABx, iAsBx, iAx, isJ}; /* basic instruction formats */ + + +/* +** size and position of opcode arguments. +*/ +#define SIZE_C 8 +#define SIZE_B 8 +#define SIZE_Bx (SIZE_C + SIZE_B + 1) +#define SIZE_A 8 +#define SIZE_Ax (SIZE_Bx + SIZE_A) +#define SIZE_sJ (SIZE_Bx + SIZE_A) + +#define SIZE_OP 7 + +#define POS_OP 0 + +#define POS_A (POS_OP + SIZE_OP) +#define POS_k (POS_A + SIZE_A) +#define POS_B (POS_k + 1) +#define POS_C (POS_B + SIZE_B) + +#define POS_Bx POS_k + +#define POS_Ax POS_A + +#define POS_sJ POS_A + + +/* +** limits for opcode arguments. +** we use (signed) 'int' to manipulate most arguments, +** so they must fit in ints. +*/ + +/* Check whether type 'int' has at least 'b' bits ('b' < 32) */ +#define L_INTHASBITS(b) ((UINT_MAX >> ((b) - 1)) >= 1) + + +#if L_INTHASBITS(SIZE_Bx) +#define MAXARG_Bx ((1<>1) /* 'sBx' is signed */ + + +#if L_INTHASBITS(SIZE_Ax) +#define MAXARG_Ax ((1<> 1) + + +#define MAXARG_A ((1<> 1) + +#define int2sC(i) ((i) + OFFSET_sC) +#define sC2int(i) ((i) - OFFSET_sC) + + +/* creates a mask with 'n' 1 bits at position 'p' */ +#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) + +/* creates a mask with 'n' 0 bits at position 'p' */ +#define MASK0(n,p) (~MASK1(n,p)) + +/* +** the following macros help to manipulate instructions +*/ + +#define GET_OPCODE(i) (cast(OpCode, ((i)>>POS_OP) & MASK1(SIZE_OP,0))) +#define SET_OPCODE(i,o) ((i) = (((i)&MASK0(SIZE_OP,POS_OP)) | \ + ((cast(Instruction, o)<>(pos)) & MASK1(size,0))) +#define setarg(i,v,pos,size) ((i) = (((i)&MASK0(size,pos)) | \ + ((cast(Instruction, v)<> sC */ +OP_SHLI,/* A B sC R[A] := sC << R[B] */ + +OP_ADD,/* A B C R[A] := R[B] + R[C] */ +OP_SUB,/* A B C R[A] := R[B] - R[C] */ +OP_MUL,/* A B C R[A] := R[B] * R[C] */ +OP_MOD,/* A B C R[A] := R[B] % R[C] */ +OP_POW,/* A B C R[A] := R[B] ^ R[C] */ +OP_DIV,/* A B C R[A] := R[B] / R[C] */ +OP_IDIV,/* A B C R[A] := R[B] // R[C] */ + +OP_BAND,/* A B C R[A] := R[B] & R[C] */ +OP_BOR,/* A B C R[A] := R[B] | R[C] */ +OP_BXOR,/* A B C R[A] := R[B] ~ R[C] */ +OP_SHL,/* A B C R[A] := R[B] << R[C] */ +OP_SHR,/* A B C R[A] := R[B] >> R[C] */ + +OP_MMBIN,/* A B C call C metamethod over R[A] and R[B] */ +OP_MMBINI,/* A sB C k call C metamethod over R[A] and sB */ +OP_MMBINK,/* A B C k call C metamethod over R[A] and K[B] */ + +OP_UNM,/* A B R[A] := -R[B] */ +OP_BNOT,/* A B R[A] := ~R[B] */ +OP_NOT,/* A B R[A] := not R[B] */ +OP_LEN,/* A B R[A] := #R[B] (length operator) */ + +OP_CONCAT,/* A B R[A] := R[A].. ... ..R[A + B - 1] */ + +OP_CLOSE,/* A close all upvalues >= R[A] */ +OP_TBC,/* A mark variable A "to be closed" */ +OP_JMP,/* sJ pc += sJ */ +OP_EQ,/* A B k if ((R[A] == R[B]) ~= k) then pc++ */ +OP_LT,/* A B k if ((R[A] < R[B]) ~= k) then pc++ */ +OP_LE,/* A B k if ((R[A] <= R[B]) ~= k) then pc++ */ + +OP_EQK,/* A B k if ((R[A] == K[B]) ~= k) then pc++ */ +OP_EQI,/* A sB k if ((R[A] == sB) ~= k) then pc++ */ +OP_LTI,/* A sB k if ((R[A] < sB) ~= k) then pc++ */ +OP_LEI,/* A sB k if ((R[A] <= sB) ~= k) then pc++ */ +OP_GTI,/* A sB k if ((R[A] > sB) ~= k) then pc++ */ +OP_GEI,/* A sB k if ((R[A] >= sB) ~= k) then pc++ */ + +OP_TEST,/* A k if (not R[A] == k) then pc++ */ +OP_TESTSET,/* A B k if (not R[B] == k) then pc++ else R[A] := R[B] */ + +OP_CALL,/* A B C R[A], ... ,R[A+C-2] := R[A](R[A+1], ... ,R[A+B-1]) */ +OP_TAILCALL,/* A B C k return R[A](R[A+1], ... ,R[A+B-1]) */ + +OP_RETURN,/* A B C k return R[A], ... ,R[A+B-2] (see note) */ +OP_RETURN0,/* return */ +OP_RETURN1,/* A return R[A] */ + +OP_FORLOOP,/* A Bx update counters; if loop continues then pc-=Bx; */ +OP_FORPREP,/* A Bx ; + if not to run then pc+=Bx+1; */ + +OP_TFORPREP,/* A Bx create upvalue for R[A + 3]; pc+=Bx */ +OP_TFORCALL,/* A C R[A+4], ... ,R[A+3+C] := R[A](R[A+1], R[A+2]); */ +OP_TFORLOOP,/* A Bx if R[A+2] ~= nil then { R[A]=R[A+2]; pc -= Bx } */ + +OP_SETLIST,/* A B C k R[A][C+i] := R[A+i], 1 <= i <= B */ + +OP_CLOSURE,/* A Bx R[A] := closure(KPROTO[Bx]) */ + +OP_VARARG,/* A C R[A], R[A+1], ..., R[A+C-2] = vararg */ + +OP_VARARGPREP,/*A (adjust vararg parameters) */ + +OP_EXTRAARG/* Ax extra (larger) argument for previous opcode */ +} OpCode; + + +#define NUM_OPCODES ((int)(OP_EXTRAARG) + 1) + + + +/*=========================================================================== + Notes: + (*) In OP_CALL, if (B == 0) then B = top - A. If (C == 0), then + 'top' is set to last_result+1, so next open instruction (OP_CALL, + OP_RETURN*, OP_SETLIST) may use 'top'. + + (*) In OP_VARARG, if (C == 0) then use actual number of varargs and + set top (like in OP_CALL with C == 0). + + (*) In OP_RETURN, if (B == 0) then return up to 'top'. + + (*) In OP_LOADKX and OP_NEWTABLE, the next instruction is always + OP_EXTRAARG. + + (*) In OP_SETLIST, if (B == 0) then real B = 'top'; if k, then + real C = EXTRAARG _ C (the bits of EXTRAARG concatenated with the + bits of C). + + (*) In OP_NEWTABLE, B is log2 of the hash size (which is always a + power of 2) plus 1, or zero for size zero. If not k, the array size + is C. Otherwise, the array size is EXTRAARG _ C. + + (*) For comparisons, k specifies what condition the test should accept + (true or false). + + (*) In OP_MMBINI/OP_MMBINK, k means the arguments were flipped + (the constant is the first operand). + + (*) All 'skips' (pc++) assume that next instruction is a jump. + + (*) In instructions OP_RETURN/OP_TAILCALL, 'k' specifies that the + function builds upvalues, which may need to be closed. C > 0 means + the function is vararg, so that its 'func' must be corrected before + returning; in this case, (C - 1) is its number of fixed parameters. + + (*) In comparisons with an immediate operand, C signals whether the + original operand was a float. (It must be corrected in case of + metamethods.) + +===========================================================================*/ + + +/* +** masks for instruction properties. The format is: +** bits 0-2: op mode +** bit 3: instruction set register A +** bit 4: operator is a test (next instruction must be a jump) +** bit 5: instruction uses 'L->top' set by previous instruction (when B == 0) +** bit 6: instruction sets 'L->top' for next instruction (when C == 0) +** bit 7: instruction is an MM instruction (call a metamethod) +*/ + +LUAI_DDEC(const lu_byte luaP_opmodes[NUM_OPCODES];) + +#define getOpMode(m) (cast(enum OpMode, luaP_opmodes[m] & 7)) +#define testAMode(m) (luaP_opmodes[m] & (1 << 3)) +#define testTMode(m) (luaP_opmodes[m] & (1 << 4)) +#define testITMode(m) (luaP_opmodes[m] & (1 << 5)) +#define testOTMode(m) (luaP_opmodes[m] & (1 << 6)) +#define testMMMode(m) (luaP_opmodes[m] & (1 << 7)) + +/* "out top" (set top for next instruction) */ +#define isOT(i) \ + ((testOTMode(GET_OPCODE(i)) && GETARG_C(i) == 0) || \ + GET_OPCODE(i) == OP_TAILCALL) + +/* "in top" (uses top from previous instruction) */ +#define isIT(i) (testITMode(GET_OPCODE(i)) && GETARG_B(i) == 0) + +#define opmode(mm,ot,it,t,a,m) \ + (((mm) << 7) | ((ot) << 6) | ((it) << 5) | ((t) << 4) | ((a) << 3) | (m)) + + +/* number of list items to accumulate before a SETLIST instruction */ +#define LFIELDS_PER_FLUSH 50 + +#endif diff --git a/examples/proto_debuger/third/include/lua/lopnames.h b/examples/proto_debuger/third/include/lua/lopnames.h new file mode 100644 index 00000000..965cec9b --- /dev/null +++ b/examples/proto_debuger/third/include/lua/lopnames.h @@ -0,0 +1,103 @@ +/* +** $Id: lopnames.h $ +** Opcode names +** See Copyright Notice in lua.h +*/ + +#if !defined(lopnames_h) +#define lopnames_h + +#include + + +/* ORDER OP */ + +static const char *const opnames[] = { + "MOVE", + "LOADI", + "LOADF", + "LOADK", + "LOADKX", + "LOADFALSE", + "LFALSESKIP", + "LOADTRUE", + "LOADNIL", + "GETUPVAL", + "SETUPVAL", + "GETTABUP", + "GETTABLE", + "GETI", + "GETFIELD", + "SETTABUP", + "SETTABLE", + "SETI", + "SETFIELD", + "NEWTABLE", + "SELF", + "ADDI", + "ADDK", + "SUBK", + "MULK", + "MODK", + "POWK", + "DIVK", + "IDIVK", + "BANDK", + "BORK", + "BXORK", + "SHRI", + "SHLI", + "ADD", + "SUB", + "MUL", + "MOD", + "POW", + "DIV", + "IDIV", + "BAND", + "BOR", + "BXOR", + "SHL", + "SHR", + "MMBIN", + "MMBINI", + "MMBINK", + "UNM", + "BNOT", + "NOT", + "LEN", + "CONCAT", + "CLOSE", + "TBC", + "JMP", + "EQ", + "LT", + "LE", + "EQK", + "EQI", + "LTI", + "LEI", + "GTI", + "GEI", + "TEST", + "TESTSET", + "CALL", + "TAILCALL", + "RETURN", + "RETURN0", + "RETURN1", + "FORLOOP", + "FORPREP", + "TFORPREP", + "TFORCALL", + "TFORLOOP", + "SETLIST", + "CLOSURE", + "VARARG", + "VARARGPREP", + "EXTRAARG", + NULL +}; + +#endif + diff --git a/examples/proto_debuger/third/include/lua/lparser.h b/examples/proto_debuger/third/include/lua/lparser.h new file mode 100644 index 00000000..2e6dae72 --- /dev/null +++ b/examples/proto_debuger/third/include/lua/lparser.h @@ -0,0 +1,171 @@ +/* +** $Id: lparser.h $ +** Lua Parser +** See Copyright Notice in lua.h +*/ + +#ifndef lparser_h +#define lparser_h + +#include "llimits.h" +#include "lobject.h" +#include "lzio.h" + + +/* +** Expression and variable descriptor. +** Code generation for variables and expressions can be delayed to allow +** optimizations; An 'expdesc' structure describes a potentially-delayed +** variable/expression. It has a description of its "main" value plus a +** list of conditional jumps that can also produce its value (generated +** by short-circuit operators 'and'/'or'). +*/ + +/* kinds of variables/expressions */ +typedef enum { + VVOID, /* when 'expdesc' describes the last expression of a list, + this kind means an empty list (so, no expression) */ + VNIL, /* constant nil */ + VTRUE, /* constant true */ + VFALSE, /* constant false */ + VK, /* constant in 'k'; info = index of constant in 'k' */ + VKFLT, /* floating constant; nval = numerical float value */ + VKINT, /* integer constant; ival = numerical integer value */ + VKSTR, /* string constant; strval = TString address; + (string is fixed by the lexer) */ + VNONRELOC, /* expression has its value in a fixed register; + info = result register */ + VLOCAL, /* local variable; var.sidx = stack index (local register); + var.vidx = relative index in 'actvar.arr' */ + VUPVAL, /* upvalue variable; info = index of upvalue in 'upvalues' */ + VCONST, /* compile-time variable; + info = absolute index in 'actvar.arr' */ + VINDEXED, /* indexed variable; + ind.t = table register; + ind.idx = key's R index */ + VINDEXUP, /* indexed upvalue; + ind.t = table upvalue; + ind.idx = key's K index */ + VINDEXI, /* indexed variable with constant integer; + ind.t = table register; + ind.idx = key's value */ + VINDEXSTR, /* indexed variable with literal string; + ind.t = table register; + ind.idx = key's K index */ + VJMP, /* expression is a test/comparison; + info = pc of corresponding jump instruction */ + VRELOC, /* expression can put result in any register; + info = instruction pc */ + VCALL, /* expression is a function call; info = instruction pc */ + VVARARG /* vararg expression; info = instruction pc */ +} expkind; + + +#define vkisvar(k) (VLOCAL <= (k) && (k) <= VINDEXSTR) +#define vkisindexed(k) (VINDEXED <= (k) && (k) <= VINDEXSTR) + + +typedef struct expdesc { + expkind k; + union { + lua_Integer ival; /* for VKINT */ + lua_Number nval; /* for VKFLT */ + TString *strval; /* for VKSTR */ + int info; /* for generic use */ + struct { /* for indexed variables */ + short idx; /* index (R or "long" K) */ + lu_byte t; /* table (register or upvalue) */ + } ind; + struct { /* for local variables */ + lu_byte sidx; /* index in the stack */ + unsigned short vidx; /* compiler index (in 'actvar.arr') */ + } var; + } u; + int t; /* patch list of 'exit when true' */ + int f; /* patch list of 'exit when false' */ +} expdesc; + + +/* kinds of variables */ +#define VDKREG 0 /* regular */ +#define RDKCONST 1 /* constant */ +#define RDKTOCLOSE 2 /* to-be-closed */ +#define RDKCTC 3 /* compile-time constant */ + +/* description of an active local variable */ +typedef union Vardesc { + struct { + TValuefields; /* constant value (if it is a compile-time constant) */ + lu_byte kind; + lu_byte sidx; /* index of the variable in the stack */ + short pidx; /* index of the variable in the Proto's 'locvars' array */ + TString *name; /* variable name */ + } vd; + TValue k; /* constant value (if any) */ +} Vardesc; + + + +/* description of pending goto statements and label statements */ +typedef struct Labeldesc { + TString *name; /* label identifier */ + int pc; /* position in code */ + int line; /* line where it appeared */ + lu_byte nactvar; /* number of active variables in that position */ + lu_byte close; /* goto that escapes upvalues */ +} Labeldesc; + + +/* list of labels or gotos */ +typedef struct Labellist { + Labeldesc *arr; /* array */ + int n; /* number of entries in use */ + int size; /* array size */ +} Labellist; + + +/* dynamic structures used by the parser */ +typedef struct Dyndata { + struct { /* list of all active local variables */ + Vardesc *arr; + int n; + int size; + } actvar; + Labellist gt; /* list of pending gotos */ + Labellist label; /* list of active labels */ +} Dyndata; + + +/* control of blocks */ +struct BlockCnt; /* defined in lparser.c */ + + +/* state needed to generate code for a given function */ +typedef struct FuncState { + Proto *f; /* current function header */ + struct FuncState *prev; /* enclosing function */ + struct LexState *ls; /* lexical state */ + struct BlockCnt *bl; /* chain of current blocks */ + int pc; /* next position to code (equivalent to 'ncode') */ + int lasttarget; /* 'label' of last 'jump label' */ + int previousline; /* last line that was saved in 'lineinfo' */ + int nk; /* number of elements in 'k' */ + int np; /* number of elements in 'p' */ + int nabslineinfo; /* number of elements in 'abslineinfo' */ + int firstlocal; /* index of first local var (in Dyndata array) */ + int firstlabel; /* index of first label (in 'dyd->label->arr') */ + short ndebugvars; /* number of elements in 'f->locvars' */ + lu_byte nactvar; /* number of active local variables */ + lu_byte nups; /* number of upvalues */ + lu_byte freereg; /* first free register */ + lu_byte iwthabs; /* instructions issued since last absolute line info */ + lu_byte needclose; /* function needs to close upvalues when returning */ +} FuncState; + + +LUAI_FUNC int luaY_nvarstack (FuncState *fs); +LUAI_FUNC LClosure *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff, + Dyndata *dyd, const char *name, int firstchar); + + +#endif diff --git a/examples/proto_debuger/third/include/lua/lprefix.h b/examples/proto_debuger/third/include/lua/lprefix.h new file mode 100644 index 00000000..484f2ad6 --- /dev/null +++ b/examples/proto_debuger/third/include/lua/lprefix.h @@ -0,0 +1,45 @@ +/* +** $Id: lprefix.h $ +** Definitions for Lua code that must come before any other header file +** See Copyright Notice in lua.h +*/ + +#ifndef lprefix_h +#define lprefix_h + + +/* +** Allows POSIX/XSI stuff +*/ +#if !defined(LUA_USE_C89) /* { */ + +#if !defined(_XOPEN_SOURCE) +#define _XOPEN_SOURCE 600 +#elif _XOPEN_SOURCE == 0 +#undef _XOPEN_SOURCE /* use -D_XOPEN_SOURCE=0 to undefine it */ +#endif + +/* +** Allows manipulation of large files in gcc and some other compilers +*/ +#if !defined(LUA_32BITS) && !defined(_FILE_OFFSET_BITS) +#define _LARGEFILE_SOURCE 1 +#define _FILE_OFFSET_BITS 64 +#endif + +#endif /* } */ + + +/* +** Windows stuff +*/ +#if defined(_WIN32) /* { */ + +#if !defined(_CRT_SECURE_NO_WARNINGS) +#define _CRT_SECURE_NO_WARNINGS /* avoid warnings about ISO C functions */ +#endif + +#endif /* } */ + +#endif + diff --git a/examples/proto_debuger/third/include/lua/lstate.h b/examples/proto_debuger/third/include/lua/lstate.h new file mode 100644 index 00000000..cbcf07e2 --- /dev/null +++ b/examples/proto_debuger/third/include/lua/lstate.h @@ -0,0 +1,365 @@ +/* +** $Id: lstate.h $ +** Global State +** See Copyright Notice in lua.h +*/ + +#ifndef lstate_h +#define lstate_h + +#include "lua.h" + +#include "lobject.h" +#include "ltm.h" +#include "lzio.h" + + +/* +** Some notes about garbage-collected objects: All objects in Lua must +** be kept somehow accessible until being freed, so all objects always +** belong to one (and only one) of these lists, using field 'next' of +** the 'CommonHeader' for the link: +** +** 'allgc': all objects not marked for finalization; +** 'finobj': all objects marked for finalization; +** 'tobefnz': all objects ready to be finalized; +** 'fixedgc': all objects that are not to be collected (currently +** only small strings, such as reserved words). +** +** For the generational collector, some of these lists have marks for +** generations. Each mark points to the first element in the list for +** that particular generation; that generation goes until the next mark. +** +** 'allgc' -> 'survival': new objects; +** 'survival' -> 'old': objects that survived one collection; +** 'old1' -> 'reallyold': objects that became old in last collection; +** 'reallyold' -> NULL: objects old for more than one cycle. +** +** 'finobj' -> 'finobjsur': new objects marked for finalization; +** 'finobjsur' -> 'finobjold1': survived """"; +** 'finobjold1' -> 'finobjrold': just old """"; +** 'finobjrold' -> NULL: really old """". +** +** All lists can contain elements older than their main ages, due +** to 'luaC_checkfinalizer' and 'udata2finalize', which move +** objects between the normal lists and the "marked for finalization" +** lists. Moreover, barriers can age young objects in young lists as +** OLD0, which then become OLD1. However, a list never contains +** elements younger than their main ages. +** +** The generational collector also uses a pointer 'firstold1', which +** points to the first OLD1 object in the list. It is used to optimize +** 'markold'. (Potentially OLD1 objects can be anywhere between 'allgc' +** and 'reallyold', but often the list has no OLD1 objects or they are +** after 'old1'.) Note the difference between it and 'old1': +** 'firstold1': no OLD1 objects before this point; there can be all +** ages after it. +** 'old1': no objects younger than OLD1 after this point. +*/ + +/* +** Moreover, there is another set of lists that control gray objects. +** These lists are linked by fields 'gclist'. (All objects that +** can become gray have such a field. The field is not the same +** in all objects, but it always has this name.) Any gray object +** must belong to one of these lists, and all objects in these lists +** must be gray (with two exceptions explained below): +** +** 'gray': regular gray objects, still waiting to be visited. +** 'grayagain': objects that must be revisited at the atomic phase. +** That includes +** - black objects got in a write barrier; +** - all kinds of weak tables during propagation phase; +** - all threads. +** 'weak': tables with weak values to be cleared; +** 'ephemeron': ephemeron tables with white->white entries; +** 'allweak': tables with weak keys and/or weak values to be cleared. +** +** The exceptions to that "gray rule" are: +** - TOUCHED2 objects in generational mode stay in a gray list (because +** they must be visited again at the end of the cycle), but they are +** marked black because assignments to them must activate barriers (to +** move them back to TOUCHED1). +** - Open upvales are kept gray to avoid barriers, but they stay out +** of gray lists. (They don't even have a 'gclist' field.) +*/ + + + +/* +** About 'nCcalls': This count has two parts: the lower 16 bits counts +** the number of recursive invocations in the C stack; the higher +** 16 bits counts the number of non-yieldable calls in the stack. +** (They are together so that we can change and save both with one +** instruction.) +*/ + + +/* true if this thread does not have non-yieldable calls in the stack */ +#define yieldable(L) (((L)->nCcalls & 0xffff0000) == 0) + +/* real number of C calls */ +#define getCcalls(L) ((L)->nCcalls & 0xffff) + + +/* Increment the number of non-yieldable calls */ +#define incnny(L) ((L)->nCcalls += 0x10000) + +/* Decrement the number of non-yieldable calls */ +#define decnny(L) ((L)->nCcalls -= 0x10000) + +/* Non-yieldable call increment */ +#define nyci (0x10000 | 1) + + + + +struct lua_longjmp; /* defined in ldo.c */ + + +/* +** Atomic type (relative to signals) to better ensure that 'lua_sethook' +** is thread safe +*/ +#if !defined(l_signalT) +#include +#define l_signalT sig_atomic_t +#endif + + +/* +** Extra stack space to handle TM calls and some other extras. This +** space is not included in 'stack_last'. It is used only to avoid stack +** checks, either because the element will be promptly popped or because +** there will be a stack check soon after the push. Function frames +** never use this extra space, so it does not need to be kept clean. +*/ +#define EXTRA_STACK 5 + + +#define BASIC_STACK_SIZE (2*LUA_MINSTACK) + +#define stacksize(th) cast_int((th)->stack_last - (th)->stack) + + +/* kinds of Garbage Collection */ +#define KGC_INC 0 /* incremental gc */ +#define KGC_GEN 1 /* generational gc */ + + +typedef struct stringtable { + TString **hash; + int nuse; /* number of elements */ + int size; +} stringtable; + + +/* +** Information about a call. +*/ +typedef struct CallInfo { + StkId func; /* function index in the stack */ + StkId top; /* top for this function */ + struct CallInfo *previous, *next; /* dynamic call link */ + union { + struct { /* only for Lua functions */ + const Instruction *savedpc; + volatile l_signalT trap; + int nextraargs; /* # of extra arguments in vararg functions */ + } l; + struct { /* only for C functions */ + lua_KFunction k; /* continuation in case of yields */ + ptrdiff_t old_errfunc; + lua_KContext ctx; /* context info. in case of yields */ + } c; + } u; + union { + int funcidx; /* called-function index */ + int nyield; /* number of values yielded */ + struct { /* info about transferred values (for call/return hooks) */ + unsigned short ftransfer; /* offset of first value transferred */ + unsigned short ntransfer; /* number of values transferred */ + } transferinfo; + } u2; + short nresults; /* expected number of results from this function */ + unsigned short callstatus; +} CallInfo; + + +/* +** Bits in CallInfo status +*/ +#define CIST_OAH (1<<0) /* original value of 'allowhook' */ +#define CIST_C (1<<1) /* call is running a C function */ +#define CIST_FRESH (1<<2) /* call is on a fresh "luaV_execute" frame */ +#define CIST_HOOKED (1<<3) /* call is running a debug hook */ +#define CIST_YPCALL (1<<4) /* call is a yieldable protected call */ +#define CIST_TAIL (1<<5) /* call was tail called */ +#define CIST_HOOKYIELD (1<<6) /* last hook called yielded */ +#define CIST_FIN (1<<7) /* call is running a finalizer */ +#define CIST_TRAN (1<<8) /* 'ci' has transfer information */ +#if defined(LUA_COMPAT_LT_LE) +#define CIST_LEQ (1<<9) /* using __lt for __le */ +#endif + +/* active function is a Lua function */ +#define isLua(ci) (!((ci)->callstatus & CIST_C)) + +/* call is running Lua code (not a hook) */ +#define isLuacode(ci) (!((ci)->callstatus & (CIST_C | CIST_HOOKED))) + +/* assume that CIST_OAH has offset 0 and that 'v' is strictly 0/1 */ +#define setoah(st,v) ((st) = ((st) & ~CIST_OAH) | (v)) +#define getoah(st) ((st) & CIST_OAH) + + +/* +** 'global state', shared by all threads of this state +*/ +typedef struct global_State { + lua_Alloc frealloc; /* function to reallocate memory */ + void *ud; /* auxiliary data to 'frealloc' */ + l_mem totalbytes; /* number of bytes currently allocated - GCdebt */ + l_mem GCdebt; /* bytes allocated not yet compensated by the collector */ + lu_mem GCestimate; /* an estimate of the non-garbage memory in use */ + lu_mem lastatomic; /* see function 'genstep' in file 'lgc.c' */ + stringtable strt; /* hash table for strings */ + TValue l_registry; + TValue nilvalue; /* a nil value */ + unsigned int seed; /* randomized seed for hashes */ + lu_byte currentwhite; + lu_byte gcstate; /* state of garbage collector */ + lu_byte gckind; /* kind of GC running */ + lu_byte genminormul; /* control for minor generational collections */ + lu_byte genmajormul; /* control for major generational collections */ + lu_byte gcrunning; /* true if GC is running */ + lu_byte gcemergency; /* true if this is an emergency collection */ + lu_byte gcpause; /* size of pause between successive GCs */ + lu_byte gcstepmul; /* GC "speed" */ + lu_byte gcstepsize; /* (log2 of) GC granularity */ + GCObject *allgc; /* list of all collectable objects */ + GCObject **sweepgc; /* current position of sweep in list */ + GCObject *finobj; /* list of collectable objects with finalizers */ + GCObject *gray; /* list of gray objects */ + GCObject *grayagain; /* list of objects to be traversed atomically */ + GCObject *weak; /* list of tables with weak values */ + GCObject *ephemeron; /* list of ephemeron tables (weak keys) */ + GCObject *allweak; /* list of all-weak tables */ + GCObject *tobefnz; /* list of userdata to be GC */ + GCObject *fixedgc; /* list of objects not to be collected */ + /* fields for generational collector */ + GCObject *survival; /* start of objects that survived one GC cycle */ + GCObject *old1; /* start of old1 objects */ + GCObject *reallyold; /* objects more than one cycle old ("really old") */ + GCObject *firstold1; /* first OLD1 object in the list (if any) */ + GCObject *finobjsur; /* list of survival objects with finalizers */ + GCObject *finobjold1; /* list of old1 objects with finalizers */ + GCObject *finobjrold; /* list of really old objects with finalizers */ + struct lua_State *twups; /* list of threads with open upvalues */ + lua_CFunction panic; /* to be called in unprotected errors */ + struct lua_State *mainthread; + TString *memerrmsg; /* message for memory-allocation errors */ + TString *tmname[TM_N]; /* array with tag-method names */ + struct Table *mt[LUA_NUMTAGS]; /* metatables for basic types */ + TString *strcache[STRCACHE_N][STRCACHE_M]; /* cache for strings in API */ + lua_WarnFunction warnf; /* warning function */ + void *ud_warn; /* auxiliary data to 'warnf' */ +} global_State; + + +/* +** 'per thread' state +*/ +struct lua_State { + CommonHeader; + lu_byte status; + lu_byte allowhook; + unsigned short nci; /* number of items in 'ci' list */ + StkId top; /* first free slot in the stack */ + global_State *l_G; + CallInfo *ci; /* call info for current function */ + StkId stack_last; /* end of stack (last element + 1) */ + StkId stack; /* stack base */ + UpVal *openupval; /* list of open upvalues in this stack */ + GCObject *gclist; + struct lua_State *twups; /* list of threads with open upvalues */ + struct lua_longjmp *errorJmp; /* current error recover point */ + CallInfo base_ci; /* CallInfo for first level (C calling Lua) */ + volatile lua_Hook hook; + ptrdiff_t errfunc; /* current error handling function (stack index) */ + l_uint32 nCcalls; /* number of nested (non-yieldable | C) calls */ + int oldpc; /* last pc traced */ + int basehookcount; + int hookcount; + volatile l_signalT hookmask; +}; + + +#define G(L) (L->l_G) + + +/* +** Union of all collectable objects (only for conversions) +** ISO C99, 6.5.2.3 p.5: +** "if a union contains several structures that share a common initial +** sequence [...], and if the union object currently contains one +** of these structures, it is permitted to inspect the common initial +** part of any of them anywhere that a declaration of the complete type +** of the union is visible." +*/ +union GCUnion { + GCObject gc; /* common header */ + struct TString ts; + struct Udata u; + union Closure cl; + struct Table h; + struct Proto p; + struct lua_State th; /* thread */ + struct UpVal upv; +}; + + +/* +** ISO C99, 6.7.2.1 p.14: +** "A pointer to a union object, suitably converted, points to each of +** its members [...], and vice versa." +*/ +#define cast_u(o) cast(union GCUnion *, (o)) + +/* macros to convert a GCObject into a specific value */ +#define gco2ts(o) \ + check_exp(novariant((o)->tt) == LUA_TSTRING, &((cast_u(o))->ts)) +#define gco2u(o) check_exp((o)->tt == LUA_VUSERDATA, &((cast_u(o))->u)) +#define gco2lcl(o) check_exp((o)->tt == LUA_VLCL, &((cast_u(o))->cl.l)) +#define gco2ccl(o) check_exp((o)->tt == LUA_VCCL, &((cast_u(o))->cl.c)) +#define gco2cl(o) \ + check_exp(novariant((o)->tt) == LUA_TFUNCTION, &((cast_u(o))->cl)) +#define gco2t(o) check_exp((o)->tt == LUA_VTABLE, &((cast_u(o))->h)) +#define gco2p(o) check_exp((o)->tt == LUA_VPROTO, &((cast_u(o))->p)) +#define gco2th(o) check_exp((o)->tt == LUA_VTHREAD, &((cast_u(o))->th)) +#define gco2upv(o) check_exp((o)->tt == LUA_VUPVAL, &((cast_u(o))->upv)) + + +/* +** macro to convert a Lua object into a GCObject +** (The access to 'tt' tries to ensure that 'v' is actually a Lua object.) +*/ +#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) + + +/* actual number of total bytes allocated */ +#define gettotalbytes(g) cast(lu_mem, (g)->totalbytes + (g)->GCdebt) + +LUAI_FUNC void luaE_setdebt (global_State *g, l_mem debt); +LUAI_FUNC void luaE_freethread (lua_State *L, lua_State *L1); +LUAI_FUNC CallInfo *luaE_extendCI (lua_State *L); +LUAI_FUNC void luaE_freeCI (lua_State *L); +LUAI_FUNC void luaE_shrinkCI (lua_State *L); +LUAI_FUNC void luaE_checkcstack (lua_State *L); +LUAI_FUNC void luaE_incCstack (lua_State *L); +LUAI_FUNC void luaE_warning (lua_State *L, const char *msg, int tocont); +LUAI_FUNC void luaE_warnerror (lua_State *L, const char *where); + + +#endif + diff --git a/examples/proto_debuger/third/include/lua/lstring.h b/examples/proto_debuger/third/include/lua/lstring.h new file mode 100644 index 00000000..450c2390 --- /dev/null +++ b/examples/proto_debuger/third/include/lua/lstring.h @@ -0,0 +1,57 @@ +/* +** $Id: lstring.h $ +** String table (keep all strings handled by Lua) +** See Copyright Notice in lua.h +*/ + +#ifndef lstring_h +#define lstring_h + +#include "lgc.h" +#include "lobject.h" +#include "lstate.h" + + +/* +** Memory-allocation error message must be preallocated (it cannot +** be created after memory is exhausted) +*/ +#define MEMERRMSG "not enough memory" + + +/* +** Size of a TString: Size of the header plus space for the string +** itself (including final '\0'). +*/ +#define sizelstring(l) (offsetof(TString, contents) + ((l) + 1) * sizeof(char)) + +#define luaS_newliteral(L, s) (luaS_newlstr(L, "" s, \ + (sizeof(s)/sizeof(char))-1)) + + +/* +** test whether a string is a reserved word +*/ +#define isreserved(s) ((s)->tt == LUA_VSHRSTR && (s)->extra > 0) + + +/* +** equality for short strings, which are always internalized +*/ +#define eqshrstr(a,b) check_exp((a)->tt == LUA_VSHRSTR, (a) == (b)) + + +LUAI_FUNC unsigned int luaS_hash (const char *str, size_t l, unsigned int seed); +LUAI_FUNC unsigned int luaS_hashlongstr (TString *ts); +LUAI_FUNC int luaS_eqlngstr (TString *a, TString *b); +LUAI_FUNC void luaS_resize (lua_State *L, int newsize); +LUAI_FUNC void luaS_clearcache (global_State *g); +LUAI_FUNC void luaS_init (lua_State *L); +LUAI_FUNC void luaS_remove (lua_State *L, TString *ts); +LUAI_FUNC Udata *luaS_newudata (lua_State *L, size_t s, int nuvalue); +LUAI_FUNC TString *luaS_newlstr (lua_State *L, const char *str, size_t l); +LUAI_FUNC TString *luaS_new (lua_State *L, const char *str); +LUAI_FUNC TString *luaS_createlngstrobj (lua_State *L, size_t l); + + +#endif diff --git a/examples/proto_debuger/third/include/lua/ltable.h b/examples/proto_debuger/third/include/lua/ltable.h new file mode 100644 index 00000000..c0060f4b --- /dev/null +++ b/examples/proto_debuger/third/include/lua/ltable.h @@ -0,0 +1,62 @@ +/* +** $Id: ltable.h $ +** Lua tables (hash) +** See Copyright Notice in lua.h +*/ + +#ifndef ltable_h +#define ltable_h + +#include "lobject.h" + + +#define gnode(t,i) (&(t)->node[i]) +#define gval(n) (&(n)->i_val) +#define gnext(n) ((n)->u.next) + + +/* +** Clear all bits of fast-access metamethods, which means that the table +** may have any of these metamethods. (First access that fails after the +** clearing will set the bit again.) +*/ +#define invalidateTMcache(t) ((t)->flags &= ~maskflags) + + +/* true when 't' is using 'dummynode' as its hash part */ +#define isdummy(t) ((t)->lastfree == NULL) + + +/* allocated size for hash nodes */ +#define allocsizenode(t) (isdummy(t) ? 0 : sizenode(t)) + + +/* returns the Node, given the value of a table entry */ +#define nodefromval(v) cast(Node *, (v)) + + +LUAI_FUNC const TValue *luaH_getint (Table *t, lua_Integer key); +LUAI_FUNC void luaH_setint (lua_State *L, Table *t, lua_Integer key, + TValue *value); +LUAI_FUNC const TValue *luaH_getshortstr (Table *t, TString *key); +LUAI_FUNC const TValue *luaH_getstr (Table *t, TString *key); +LUAI_FUNC const TValue *luaH_get (Table *t, const TValue *key); +LUAI_FUNC TValue *luaH_newkey (lua_State *L, Table *t, const TValue *key); +LUAI_FUNC TValue *luaH_set (lua_State *L, Table *t, const TValue *key); +LUAI_FUNC Table *luaH_new (lua_State *L); +LUAI_FUNC void luaH_resize (lua_State *L, Table *t, unsigned int nasize, + unsigned int nhsize); +LUAI_FUNC void luaH_resizearray (lua_State *L, Table *t, unsigned int nasize); +LUAI_FUNC void luaH_free (lua_State *L, Table *t); +LUAI_FUNC int luaH_next (lua_State *L, Table *t, StkId key); +LUAI_FUNC lua_Unsigned luaH_getn (Table *t); +LUAI_FUNC unsigned int luaH_realasize (const Table *t); + + +#if defined(LUA_DEBUG) +LUAI_FUNC Node *luaH_mainposition (const Table *t, const TValue *key); +LUAI_FUNC int luaH_isdummy (const Table *t); +#endif + + +#endif diff --git a/examples/proto_debuger/third/include/lua/ltm.h b/examples/proto_debuger/third/include/lua/ltm.h new file mode 100644 index 00000000..73b833c6 --- /dev/null +++ b/examples/proto_debuger/third/include/lua/ltm.h @@ -0,0 +1,103 @@ +/* +** $Id: ltm.h $ +** Tag methods +** See Copyright Notice in lua.h +*/ + +#ifndef ltm_h +#define ltm_h + + +#include "lobject.h" + + +/* +* WARNING: if you change the order of this enumeration, +* grep "ORDER TM" and "ORDER OP" +*/ +typedef enum { + TM_INDEX, + TM_NEWINDEX, + TM_GC, + TM_MODE, + TM_LEN, + TM_EQ, /* last tag method with fast access */ + TM_ADD, + TM_SUB, + TM_MUL, + TM_MOD, + TM_POW, + TM_DIV, + TM_IDIV, + TM_BAND, + TM_BOR, + TM_BXOR, + TM_SHL, + TM_SHR, + TM_UNM, + TM_BNOT, + TM_LT, + TM_LE, + TM_CONCAT, + TM_CALL, + TM_CLOSE, + TM_N /* number of elements in the enum */ +} TMS; + + +/* +** Mask with 1 in all fast-access methods. A 1 in any of these bits +** in the flag of a (meta)table means the metatable does not have the +** corresponding metamethod field. (Bit 7 of the flag is used for +** 'isrealasize'.) +*/ +#define maskflags (~(~0u << (TM_EQ + 1))) + + +/* +** Test whether there is no tagmethod. +** (Because tagmethods use raw accesses, the result may be an "empty" nil.) +*/ +#define notm(tm) ttisnil(tm) + + +#define gfasttm(g,et,e) ((et) == NULL ? NULL : \ + ((et)->flags & (1u<<(e))) ? NULL : luaT_gettm(et, e, (g)->tmname[e])) + +#define fasttm(l,et,e) gfasttm(G(l), et, e) + +#define ttypename(x) luaT_typenames_[(x) + 1] + +LUAI_DDEC(const char *const luaT_typenames_[LUA_TOTALTYPES];) + + +LUAI_FUNC const char *luaT_objtypename (lua_State *L, const TValue *o); + +LUAI_FUNC const TValue *luaT_gettm (Table *events, TMS event, TString *ename); +LUAI_FUNC const TValue *luaT_gettmbyobj (lua_State *L, const TValue *o, + TMS event); +LUAI_FUNC void luaT_init (lua_State *L); + +LUAI_FUNC void luaT_callTM (lua_State *L, const TValue *f, const TValue *p1, + const TValue *p2, const TValue *p3); +LUAI_FUNC void luaT_callTMres (lua_State *L, const TValue *f, + const TValue *p1, const TValue *p2, StkId p3); +LUAI_FUNC void luaT_trybinTM (lua_State *L, const TValue *p1, const TValue *p2, + StkId res, TMS event); +LUAI_FUNC void luaT_tryconcatTM (lua_State *L); +LUAI_FUNC void luaT_trybinassocTM (lua_State *L, const TValue *p1, + const TValue *p2, int inv, StkId res, TMS event); +LUAI_FUNC void luaT_trybiniTM (lua_State *L, const TValue *p1, lua_Integer i2, + int inv, StkId res, TMS event); +LUAI_FUNC int luaT_callorderTM (lua_State *L, const TValue *p1, + const TValue *p2, TMS event); +LUAI_FUNC int luaT_callorderiTM (lua_State *L, const TValue *p1, int v2, + int inv, int isfloat, TMS event); + +LUAI_FUNC void luaT_adjustvarargs (lua_State *L, int nfixparams, + struct CallInfo *ci, const Proto *p); +LUAI_FUNC void luaT_getvarargs (lua_State *L, struct CallInfo *ci, + StkId where, int wanted); + + +#endif diff --git a/examples/proto_debuger/third/include/lua/lua.h b/examples/proto_debuger/third/include/lua/lua.h new file mode 100644 index 00000000..c9d64d7f --- /dev/null +++ b/examples/proto_debuger/third/include/lua/lua.h @@ -0,0 +1,517 @@ +/* +** $Id: lua.h $ +** Lua - A Scripting Language +** Lua.org, PUC-Rio, Brazil (http://www.lua.org) +** See Copyright Notice at the end of this file +*/ + + +#ifndef lua_h +#define lua_h + +#include +#include + + +#include "luaconf.h" + + +#define LUA_VERSION_MAJOR "5" +#define LUA_VERSION_MINOR "4" +#define LUA_VERSION_RELEASE "2" + +#define LUA_VERSION_NUM 504 +#define LUA_VERSION_RELEASE_NUM (LUA_VERSION_NUM * 100 + 0) + +#define LUA_VERSION "Lua " LUA_VERSION_MAJOR "." LUA_VERSION_MINOR +#define LUA_RELEASE LUA_VERSION "." LUA_VERSION_RELEASE +#define LUA_COPYRIGHT LUA_RELEASE " Copyright (C) 1994-2020 Lua.org, PUC-Rio" +#define LUA_AUTHORS "R. Ierusalimschy, L. H. de Figueiredo, W. Celes" + + +/* mark for precompiled code ('Lua') */ +#define LUA_SIGNATURE "\x1bLua" + +/* option for multiple returns in 'lua_pcall' and 'lua_call' */ +#define LUA_MULTRET (-1) + + +/* +** Pseudo-indices +** (-LUAI_MAXSTACK is the minimum valid index; we keep some free empty +** space after that to help overflow detection) +*/ +#define LUA_REGISTRYINDEX (-LUAI_MAXSTACK - 1000) +#define lua_upvalueindex(i) (LUA_REGISTRYINDEX - (i)) + + +/* thread status */ +#define LUA_OK 0 +#define LUA_YIELD 1 +#define LUA_ERRRUN 2 +#define LUA_ERRSYNTAX 3 +#define LUA_ERRMEM 4 +#define LUA_ERRERR 5 + + +typedef struct lua_State lua_State; + + +/* +** basic types +*/ +#define LUA_TNONE (-1) + +#define LUA_TNIL 0 +#define LUA_TBOOLEAN 1 +#define LUA_TLIGHTUSERDATA 2 +#define LUA_TNUMBER 3 +#define LUA_TSTRING 4 +#define LUA_TTABLE 5 +#define LUA_TFUNCTION 6 +#define LUA_TUSERDATA 7 +#define LUA_TTHREAD 8 + +#define LUA_NUMTYPES 9 + + + +/* minimum Lua stack available to a C function */ +#define LUA_MINSTACK 20 + + +/* predefined values in the registry */ +#define LUA_RIDX_MAINTHREAD 1 +#define LUA_RIDX_GLOBALS 2 +#define LUA_RIDX_LAST LUA_RIDX_GLOBALS + + +/* type of numbers in Lua */ +typedef LUA_NUMBER lua_Number; + + +/* type for integer functions */ +typedef LUA_INTEGER lua_Integer; + +/* unsigned integer type */ +typedef LUA_UNSIGNED lua_Unsigned; + +/* type for continuation-function contexts */ +typedef LUA_KCONTEXT lua_KContext; + + +/* +** Type for C functions registered with Lua +*/ +typedef int (*lua_CFunction) (lua_State *L); + +/* +** Type for continuation functions +*/ +typedef int (*lua_KFunction) (lua_State *L, int status, lua_KContext ctx); + + +/* +** Type for functions that read/write blocks when loading/dumping Lua chunks +*/ +typedef const char * (*lua_Reader) (lua_State *L, void *ud, size_t *sz); + +typedef int (*lua_Writer) (lua_State *L, const void *p, size_t sz, void *ud); + + +/* +** Type for memory-allocation functions +*/ +typedef void * (*lua_Alloc) (void *ud, void *ptr, size_t osize, size_t nsize); + + +/* +** Type for warning functions +*/ +typedef void (*lua_WarnFunction) (void *ud, const char *msg, int tocont); + + + + +/* +** generic extra include file +*/ +#if defined(LUA_USER_H) +#include LUA_USER_H +#endif + + +/* +** RCS ident string +*/ +extern const char lua_ident[]; + + +/* +** state manipulation +*/ +LUA_API lua_State *(lua_newstate) (lua_Alloc f, void *ud); +LUA_API void (lua_close) (lua_State *L); +LUA_API lua_State *(lua_newthread) (lua_State *L); +LUA_API int (lua_resetthread) (lua_State *L); + +LUA_API lua_CFunction (lua_atpanic) (lua_State *L, lua_CFunction panicf); + + +LUA_API lua_Number (lua_version) (lua_State *L); + + +/* +** basic stack manipulation +*/ +LUA_API int (lua_absindex) (lua_State *L, int idx); +LUA_API int (lua_gettop) (lua_State *L); +LUA_API void (lua_settop) (lua_State *L, int idx); +LUA_API void (lua_pushvalue) (lua_State *L, int idx); +LUA_API void (lua_rotate) (lua_State *L, int idx, int n); +LUA_API void (lua_copy) (lua_State *L, int fromidx, int toidx); +LUA_API int (lua_checkstack) (lua_State *L, int n); + +LUA_API void (lua_xmove) (lua_State *from, lua_State *to, int n); + + +/* +** access functions (stack -> C) +*/ + +LUA_API int (lua_isnumber) (lua_State *L, int idx); +LUA_API int (lua_isstring) (lua_State *L, int idx); +LUA_API int (lua_iscfunction) (lua_State *L, int idx); +LUA_API int (lua_isinteger) (lua_State *L, int idx); +LUA_API int (lua_isuserdata) (lua_State *L, int idx); +LUA_API int (lua_type) (lua_State *L, int idx); +LUA_API const char *(lua_typename) (lua_State *L, int tp); + +LUA_API lua_Number (lua_tonumberx) (lua_State *L, int idx, int *isnum); +LUA_API lua_Integer (lua_tointegerx) (lua_State *L, int idx, int *isnum); +LUA_API int (lua_toboolean) (lua_State *L, int idx); +LUA_API const char *(lua_tolstring) (lua_State *L, int idx, size_t *len); +LUA_API lua_Unsigned (lua_rawlen) (lua_State *L, int idx); +LUA_API lua_CFunction (lua_tocfunction) (lua_State *L, int idx); +LUA_API void *(lua_touserdata) (lua_State *L, int idx); +LUA_API lua_State *(lua_tothread) (lua_State *L, int idx); +LUA_API const void *(lua_topointer) (lua_State *L, int idx); + + +/* +** Comparison and arithmetic functions +*/ + +#define LUA_OPADD 0 /* ORDER TM, ORDER OP */ +#define LUA_OPSUB 1 +#define LUA_OPMUL 2 +#define LUA_OPMOD 3 +#define LUA_OPPOW 4 +#define LUA_OPDIV 5 +#define LUA_OPIDIV 6 +#define LUA_OPBAND 7 +#define LUA_OPBOR 8 +#define LUA_OPBXOR 9 +#define LUA_OPSHL 10 +#define LUA_OPSHR 11 +#define LUA_OPUNM 12 +#define LUA_OPBNOT 13 + +LUA_API void (lua_arith) (lua_State *L, int op); + +#define LUA_OPEQ 0 +#define LUA_OPLT 1 +#define LUA_OPLE 2 + +LUA_API int (lua_rawequal) (lua_State *L, int idx1, int idx2); +LUA_API int (lua_compare) (lua_State *L, int idx1, int idx2, int op); + + +/* +** push functions (C -> stack) +*/ +LUA_API void (lua_pushnil) (lua_State *L); +LUA_API void (lua_pushnumber) (lua_State *L, lua_Number n); +LUA_API void (lua_pushinteger) (lua_State *L, lua_Integer n); +LUA_API const char *(lua_pushlstring) (lua_State *L, const char *s, size_t len); +LUA_API const char *(lua_pushstring) (lua_State *L, const char *s); +LUA_API const char *(lua_pushvfstring) (lua_State *L, const char *fmt, + va_list argp); +LUA_API const char *(lua_pushfstring) (lua_State *L, const char *fmt, ...); +LUA_API void (lua_pushcclosure) (lua_State *L, lua_CFunction fn, int n); +LUA_API void (lua_pushboolean) (lua_State *L, int b); +LUA_API void (lua_pushlightuserdata) (lua_State *L, void *p); +LUA_API int (lua_pushthread) (lua_State *L); + + +/* +** get functions (Lua -> stack) +*/ +LUA_API int (lua_getglobal) (lua_State *L, const char *name); +LUA_API int (lua_gettable) (lua_State *L, int idx); +LUA_API int (lua_getfield) (lua_State *L, int idx, const char *k); +LUA_API int (lua_geti) (lua_State *L, int idx, lua_Integer n); +LUA_API int (lua_rawget) (lua_State *L, int idx); +LUA_API int (lua_rawgeti) (lua_State *L, int idx, lua_Integer n); +LUA_API int (lua_rawgetp) (lua_State *L, int idx, const void *p); + +LUA_API void (lua_createtable) (lua_State *L, int narr, int nrec); +LUA_API void *(lua_newuserdatauv) (lua_State *L, size_t sz, int nuvalue); +LUA_API int (lua_getmetatable) (lua_State *L, int objindex); +LUA_API int (lua_getiuservalue) (lua_State *L, int idx, int n); + + +/* +** set functions (stack -> Lua) +*/ +LUA_API void (lua_setglobal) (lua_State *L, const char *name); +LUA_API void (lua_settable) (lua_State *L, int idx); +LUA_API void (lua_setfield) (lua_State *L, int idx, const char *k); +LUA_API void (lua_seti) (lua_State *L, int idx, lua_Integer n); +LUA_API void (lua_rawset) (lua_State *L, int idx); +LUA_API void (lua_rawseti) (lua_State *L, int idx, lua_Integer n); +LUA_API void (lua_rawsetp) (lua_State *L, int idx, const void *p); +LUA_API int (lua_setmetatable) (lua_State *L, int objindex); +LUA_API int (lua_setiuservalue) (lua_State *L, int idx, int n); + + +/* +** 'load' and 'call' functions (load and run Lua code) +*/ +LUA_API void (lua_callk) (lua_State *L, int nargs, int nresults, + lua_KContext ctx, lua_KFunction k); +#define lua_call(L,n,r) lua_callk(L, (n), (r), 0, NULL) + +LUA_API int (lua_pcallk) (lua_State *L, int nargs, int nresults, int errfunc, + lua_KContext ctx, lua_KFunction k); +#define lua_pcall(L,n,r,f) lua_pcallk(L, (n), (r), (f), 0, NULL) + +LUA_API int (lua_load) (lua_State *L, lua_Reader reader, void *dt, + const char *chunkname, const char *mode); + +LUA_API int (lua_dump) (lua_State *L, lua_Writer writer, void *data, int strip); + + +/* +** coroutine functions +*/ +LUA_API int (lua_yieldk) (lua_State *L, int nresults, lua_KContext ctx, + lua_KFunction k); +LUA_API int (lua_resume) (lua_State *L, lua_State *from, int narg, + int *nres); +LUA_API int (lua_status) (lua_State *L); +LUA_API int (lua_isyieldable) (lua_State *L); + +#define lua_yield(L,n) lua_yieldk(L, (n), 0, NULL) + + +/* +** Warning-related functions +*/ +LUA_API void (lua_setwarnf) (lua_State *L, lua_WarnFunction f, void *ud); +LUA_API void (lua_warning) (lua_State *L, const char *msg, int tocont); + + +/* +** garbage-collection function and options +*/ + +#define LUA_GCSTOP 0 +#define LUA_GCRESTART 1 +#define LUA_GCCOLLECT 2 +#define LUA_GCCOUNT 3 +#define LUA_GCCOUNTB 4 +#define LUA_GCSTEP 5 +#define LUA_GCSETPAUSE 6 +#define LUA_GCSETSTEPMUL 7 +#define LUA_GCISRUNNING 9 +#define LUA_GCGEN 10 +#define LUA_GCINC 11 + +LUA_API int (lua_gc) (lua_State *L, int what, ...); + + +/* +** miscellaneous functions +*/ + +LUA_API int (lua_error) (lua_State *L); + +LUA_API int (lua_next) (lua_State *L, int idx); + +LUA_API void (lua_concat) (lua_State *L, int n); +LUA_API void (lua_len) (lua_State *L, int idx); + +LUA_API size_t (lua_stringtonumber) (lua_State *L, const char *s); + +LUA_API lua_Alloc (lua_getallocf) (lua_State *L, void **ud); +LUA_API void (lua_setallocf) (lua_State *L, lua_Alloc f, void *ud); + +LUA_API void (lua_toclose) (lua_State *L, int idx); + + +/* +** {============================================================== +** some useful macros +** =============================================================== +*/ + +#define lua_getextraspace(L) ((void *)((char *)(L) - LUA_EXTRASPACE)) + +#define lua_tonumber(L,i) lua_tonumberx(L,(i),NULL) +#define lua_tointeger(L,i) lua_tointegerx(L,(i),NULL) + +#define lua_pop(L,n) lua_settop(L, -(n)-1) + +#define lua_newtable(L) lua_createtable(L, 0, 0) + +#define lua_register(L,n,f) (lua_pushcfunction(L, (f)), lua_setglobal(L, (n))) + +#define lua_pushcfunction(L,f) lua_pushcclosure(L, (f), 0) + +#define lua_isfunction(L,n) (lua_type(L, (n)) == LUA_TFUNCTION) +#define lua_istable(L,n) (lua_type(L, (n)) == LUA_TTABLE) +#define lua_islightuserdata(L,n) (lua_type(L, (n)) == LUA_TLIGHTUSERDATA) +#define lua_isnil(L,n) (lua_type(L, (n)) == LUA_TNIL) +#define lua_isboolean(L,n) (lua_type(L, (n)) == LUA_TBOOLEAN) +#define lua_isthread(L,n) (lua_type(L, (n)) == LUA_TTHREAD) +#define lua_isnone(L,n) (lua_type(L, (n)) == LUA_TNONE) +#define lua_isnoneornil(L, n) (lua_type(L, (n)) <= 0) + +#define lua_pushliteral(L, s) lua_pushstring(L, "" s) + +#define lua_pushglobaltable(L) \ + ((void)lua_rawgeti(L, LUA_REGISTRYINDEX, LUA_RIDX_GLOBALS)) + +#define lua_tostring(L,i) lua_tolstring(L, (i), NULL) + + +#define lua_insert(L,idx) lua_rotate(L, (idx), 1) + +#define lua_remove(L,idx) (lua_rotate(L, (idx), -1), lua_pop(L, 1)) + +#define lua_replace(L,idx) (lua_copy(L, -1, (idx)), lua_pop(L, 1)) + +/* }============================================================== */ + + +/* +** {============================================================== +** compatibility macros +** =============================================================== +*/ +#if defined(LUA_COMPAT_APIINTCASTS) + +#define lua_pushunsigned(L,n) lua_pushinteger(L, (lua_Integer)(n)) +#define lua_tounsignedx(L,i,is) ((lua_Unsigned)lua_tointegerx(L,i,is)) +#define lua_tounsigned(L,i) lua_tounsignedx(L,(i),NULL) + +#endif + +#define lua_newuserdata(L,s) lua_newuserdatauv(L,s,1) +#define lua_getuservalue(L,idx) lua_getiuservalue(L,idx,1) +#define lua_setuservalue(L,idx) lua_setiuservalue(L,idx,1) + +#define LUA_NUMTAGS LUA_NUMTYPES + +/* }============================================================== */ + +/* +** {====================================================================== +** Debug API +** ======================================================================= +*/ + + +/* +** Event codes +*/ +#define LUA_HOOKCALL 0 +#define LUA_HOOKRET 1 +#define LUA_HOOKLINE 2 +#define LUA_HOOKCOUNT 3 +#define LUA_HOOKTAILCALL 4 + + +/* +** Event masks +*/ +#define LUA_MASKCALL (1 << LUA_HOOKCALL) +#define LUA_MASKRET (1 << LUA_HOOKRET) +#define LUA_MASKLINE (1 << LUA_HOOKLINE) +#define LUA_MASKCOUNT (1 << LUA_HOOKCOUNT) + +typedef struct lua_Debug lua_Debug; /* activation record */ + + +/* Functions to be called by the debugger in specific events */ +typedef void (*lua_Hook) (lua_State *L, lua_Debug *ar); + + +LUA_API int (lua_getstack) (lua_State *L, int level, lua_Debug *ar); +LUA_API int (lua_getinfo) (lua_State *L, const char *what, lua_Debug *ar); +LUA_API const char *(lua_getlocal) (lua_State *L, const lua_Debug *ar, int n); +LUA_API const char *(lua_setlocal) (lua_State *L, const lua_Debug *ar, int n); +LUA_API const char *(lua_getupvalue) (lua_State *L, int funcindex, int n); +LUA_API const char *(lua_setupvalue) (lua_State *L, int funcindex, int n); + +LUA_API void *(lua_upvalueid) (lua_State *L, int fidx, int n); +LUA_API void (lua_upvaluejoin) (lua_State *L, int fidx1, int n1, + int fidx2, int n2); + +LUA_API void (lua_sethook) (lua_State *L, lua_Hook func, int mask, int count); +LUA_API lua_Hook (lua_gethook) (lua_State *L); +LUA_API int (lua_gethookmask) (lua_State *L); +LUA_API int (lua_gethookcount) (lua_State *L); + +LUA_API int (lua_setcstacklimit) (lua_State *L, unsigned int limit); + +struct lua_Debug { + int event; + const char *name; /* (n) */ + const char *namewhat; /* (n) 'global', 'local', 'field', 'method' */ + const char *what; /* (S) 'Lua', 'C', 'main', 'tail' */ + const char *source; /* (S) */ + size_t srclen; /* (S) */ + int currentline; /* (l) */ + int linedefined; /* (S) */ + int lastlinedefined; /* (S) */ + unsigned char nups; /* (u) number of upvalues */ + unsigned char nparams;/* (u) number of parameters */ + char isvararg; /* (u) */ + char istailcall; /* (t) */ + unsigned short ftransfer; /* (r) index of first value transferred */ + unsigned short ntransfer; /* (r) number of transferred values */ + char short_src[LUA_IDSIZE]; /* (S) */ + /* private part */ + struct CallInfo *i_ci; /* active function */ +}; + +/* }====================================================================== */ + + +/****************************************************************************** +* Copyright (C) 1994-2020 Lua.org, PUC-Rio. +* +* Permission is hereby granted, free of charge, to any person obtaining +* a copy of this software and associated documentation files (the +* "Software"), to deal in the Software without restriction, including +* without limitation the rights to use, copy, modify, merge, publish, +* distribute, sublicense, and/or sell copies of the Software, and to +* permit persons to whom the Software is furnished to do so, subject to +* the following conditions: +* +* The above copyright notice and this permission notice shall be +* included in all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +******************************************************************************/ + + +#endif diff --git a/examples/proto_debuger/third/include/lua/luaconf.h b/examples/proto_debuger/third/include/lua/luaconf.h new file mode 100644 index 00000000..d9cf18ca --- /dev/null +++ b/examples/proto_debuger/third/include/lua/luaconf.h @@ -0,0 +1,761 @@ +/* +** $Id: luaconf.h $ +** Configuration file for Lua +** See Copyright Notice in lua.h +*/ + + +#ifndef luaconf_h +#define luaconf_h + +#include +#include + + +/* +** =================================================================== +** General Configuration File for Lua +** +** Some definitions here can be changed externally, through the +** compiler (e.g., with '-D' options). Those are protected by +** '#if !defined' guards. However, several other definitions should +** be changed directly here, either because they affect the Lua +** ABI (by making the changes here, you ensure that all software +** connected to Lua, such as C libraries, will be compiled with the +** same configuration); or because they are seldom changed. +** +** Search for "@@" to find all configurable definitions. +** =================================================================== +*/ + + +/* +** {==================================================================== +** System Configuration: macros to adapt (if needed) Lua to some +** particular platform, for instance restricting it to C89. +** ===================================================================== +*/ + +/* +@@ LUA_USE_C89 controls the use of non-ISO-C89 features. +** Define it if you want Lua to avoid the use of a few C99 features +** or Windows-specific features on Windows. +*/ +/* #define LUA_USE_C89 */ + + +/* +** By default, Lua on Windows use (some) specific Windows features +*/ +#if !defined(LUA_USE_C89) && defined(_WIN32) && !defined(_WIN32_WCE) +#define LUA_USE_WINDOWS /* enable goodies for regular Windows */ +#endif + + +#if defined(LUA_USE_WINDOWS) +#define LUA_DL_DLL /* enable support for DLL */ +#define LUA_USE_C89 /* broadly, Windows is C89 */ +#endif + + +#if defined(LUA_USE_LINUX) +#define LUA_USE_POSIX +#define LUA_USE_DLOPEN /* needs an extra library: -ldl */ +#endif + + +#if defined(LUA_USE_MACOSX) +#define LUA_USE_POSIX +#define LUA_USE_DLOPEN /* MacOS does not need -ldl */ +#endif + + +/* +@@ LUAI_IS32INT is true iff 'int' has (at least) 32 bits. +*/ +#define LUAI_IS32INT ((UINT_MAX >> 30) >= 3) + +/* }================================================================== */ + + + +/* +** {================================================================== +** Configuration for Number types. +** =================================================================== +*/ + +/* +@@ LUA_32BITS enables Lua with 32-bit integers and 32-bit floats. +*/ +/* #define LUA_32BITS */ + + +/* +@@ LUA_C89_NUMBERS ensures that Lua uses the largest types available for +** C89 ('long' and 'double'); Windows always has '__int64', so it does +** not need to use this case. +*/ +#if defined(LUA_USE_C89) && !defined(LUA_USE_WINDOWS) +#define LUA_C89_NUMBERS +#endif + + +/* +@@ LUA_INT_TYPE defines the type for Lua integers. +@@ LUA_FLOAT_TYPE defines the type for Lua floats. +** Lua should work fine with any mix of these options supported +** by your C compiler. The usual configurations are 64-bit integers +** and 'double' (the default), 32-bit integers and 'float' (for +** restricted platforms), and 'long'/'double' (for C compilers not +** compliant with C99, which may not have support for 'long long'). +*/ + +/* predefined options for LUA_INT_TYPE */ +#define LUA_INT_INT 1 +#define LUA_INT_LONG 2 +#define LUA_INT_LONGLONG 3 + +/* predefined options for LUA_FLOAT_TYPE */ +#define LUA_FLOAT_FLOAT 1 +#define LUA_FLOAT_DOUBLE 2 +#define LUA_FLOAT_LONGDOUBLE 3 + +#if defined(LUA_32BITS) /* { */ +/* +** 32-bit integers and 'float' +*/ +#if LUAI_IS32INT /* use 'int' if big enough */ +#define LUA_INT_TYPE LUA_INT_INT +#else /* otherwise use 'long' */ +#define LUA_INT_TYPE LUA_INT_LONG +#endif +#define LUA_FLOAT_TYPE LUA_FLOAT_FLOAT + +#elif defined(LUA_C89_NUMBERS) /* }{ */ +/* +** largest types available for C89 ('long' and 'double') +*/ +#define LUA_INT_TYPE LUA_INT_LONG +#define LUA_FLOAT_TYPE LUA_FLOAT_DOUBLE + +#endif /* } */ + + +/* +** default configuration for 64-bit Lua ('long long' and 'double') +*/ +#if !defined(LUA_INT_TYPE) +#define LUA_INT_TYPE LUA_INT_LONGLONG +#endif + +#if !defined(LUA_FLOAT_TYPE) +#define LUA_FLOAT_TYPE LUA_FLOAT_DOUBLE +#endif + +/* }================================================================== */ + + + +/* +** {================================================================== +** Configuration for Paths. +** =================================================================== +*/ + +/* +** LUA_PATH_SEP is the character that separates templates in a path. +** LUA_PATH_MARK is the string that marks the substitution points in a +** template. +** LUA_EXEC_DIR in a Windows path is replaced by the executable's +** directory. +*/ +#define LUA_PATH_SEP ";" +#define LUA_PATH_MARK "?" +#define LUA_EXEC_DIR "!" + + +/* +@@ LUA_PATH_DEFAULT is the default path that Lua uses to look for +** Lua libraries. +@@ LUA_CPATH_DEFAULT is the default path that Lua uses to look for +** C libraries. +** CHANGE them if your machine has a non-conventional directory +** hierarchy or if you want to install your libraries in +** non-conventional directories. +*/ + +#define LUA_VDIR LUA_VERSION_MAJOR "." LUA_VERSION_MINOR +#if defined(_WIN32) /* { */ +/* +** In Windows, any exclamation mark ('!') in the path is replaced by the +** path of the directory of the executable file of the current process. +*/ +#define LUA_LDIR "!\\lua\\" +#define LUA_CDIR "!\\" +#define LUA_SHRDIR "!\\..\\share\\lua\\" LUA_VDIR "\\" + +#if !defined(LUA_PATH_DEFAULT) +#define LUA_PATH_DEFAULT \ + LUA_LDIR"?.lua;" LUA_LDIR"?\\init.lua;" \ + LUA_CDIR"?.lua;" LUA_CDIR"?\\init.lua;" \ + LUA_SHRDIR"?.lua;" LUA_SHRDIR"?\\init.lua;" \ + ".\\?.lua;" ".\\?\\init.lua" +#endif + +#if !defined(LUA_CPATH_DEFAULT) +#define LUA_CPATH_DEFAULT \ + LUA_CDIR"?.dll;" \ + LUA_CDIR"..\\lib\\lua\\" LUA_VDIR "\\?.dll;" \ + LUA_CDIR"loadall.dll;" ".\\?.dll" +#endif + +#else /* }{ */ + +#define LUA_ROOT "/usr/local/" +#define LUA_LDIR LUA_ROOT "share/lua/" LUA_VDIR "/" +#define LUA_CDIR LUA_ROOT "lib/lua/" LUA_VDIR "/" + +#if !defined(LUA_PATH_DEFAULT) +#define LUA_PATH_DEFAULT \ + LUA_LDIR"?.lua;" LUA_LDIR"?/init.lua;" \ + LUA_CDIR"?.lua;" LUA_CDIR"?/init.lua;" \ + "./?.lua;" "./?/init.lua" +#endif + +#if !defined(LUA_CPATH_DEFAULT) +#define LUA_CPATH_DEFAULT \ + LUA_CDIR"?.so;" LUA_CDIR"loadall.so;" "./?.so" +#endif + +#endif /* } */ + + +/* +@@ LUA_DIRSEP is the directory separator (for submodules). +** CHANGE it if your machine does not use "/" as the directory separator +** and is not Windows. (On Windows Lua automatically uses "\".) +*/ +#if !defined(LUA_DIRSEP) + +#if defined(_WIN32) +#define LUA_DIRSEP "\\" +#else +#define LUA_DIRSEP "/" +#endif + +#endif + +/* }================================================================== */ + + +/* +** {================================================================== +** Marks for exported symbols in the C code +** =================================================================== +*/ + +/* +@@ LUA_API is a mark for all core API functions. +@@ LUALIB_API is a mark for all auxiliary library functions. +@@ LUAMOD_API is a mark for all standard library opening functions. +** CHANGE them if you need to define those functions in some special way. +** For instance, if you want to create one Windows DLL with the core and +** the libraries, you may want to use the following definition (define +** LUA_BUILD_AS_DLL to get it). +*/ +#if defined(LUA_BUILD_AS_DLL) /* { */ + +#if defined(LUA_CORE) || defined(LUA_LIB) /* { */ +#define LUA_API __declspec(dllexport) +#else /* }{ */ +#define LUA_API __declspec(dllimport) +#endif /* } */ + +#else /* }{ */ + +#define LUA_API extern + +#endif /* } */ + + +/* +** More often than not the libs go together with the core. +*/ +#define LUALIB_API LUA_API +#define LUAMOD_API LUA_API + + +/* +@@ LUAI_FUNC is a mark for all extern functions that are not to be +** exported to outside modules. +@@ LUAI_DDEF and LUAI_DDEC are marks for all extern (const) variables, +** none of which to be exported to outside modules (LUAI_DDEF for +** definitions and LUAI_DDEC for declarations). +** CHANGE them if you need to mark them in some special way. Elf/gcc +** (versions 3.2 and later) mark them as "hidden" to optimize access +** when Lua is compiled as a shared library. Not all elf targets support +** this attribute. Unfortunately, gcc does not offer a way to check +** whether the target offers that support, and those without support +** give a warning about it. To avoid these warnings, change to the +** default definition. +*/ +#if defined(__GNUC__) && ((__GNUC__*100 + __GNUC_MINOR__) >= 302) && \ + defined(__ELF__) /* { */ +#define LUAI_FUNC __attribute__((visibility("internal"))) extern +#else /* }{ */ +#define LUAI_FUNC extern +#endif /* } */ + +#define LUAI_DDEC(dec) LUAI_FUNC dec +#define LUAI_DDEF /* empty */ + +/* }================================================================== */ + + +/* +** {================================================================== +** Compatibility with previous versions +** =================================================================== +*/ + +/* +@@ LUA_COMPAT_5_3 controls other macros for compatibility with Lua 5.3. +** You can define it to get all options, or change specific options +** to fit your specific needs. +*/ +#if defined(LUA_COMPAT_5_3) /* { */ + +/* +@@ LUA_COMPAT_MATHLIB controls the presence of several deprecated +** functions in the mathematical library. +** (These functions were already officially removed in 5.3; +** nevertheless they are still available here.) +*/ +#define LUA_COMPAT_MATHLIB + +/* +@@ LUA_COMPAT_APIINTCASTS controls the presence of macros for +** manipulating other integer types (lua_pushunsigned, lua_tounsigned, +** luaL_checkint, luaL_checklong, etc.) +** (These macros were also officially removed in 5.3, but they are still +** available here.) +*/ +#define LUA_COMPAT_APIINTCASTS + + +/* +@@ LUA_COMPAT_LT_LE controls the emulation of the '__le' metamethod +** using '__lt'. +*/ +#define LUA_COMPAT_LT_LE + + +/* +@@ The following macros supply trivial compatibility for some +** changes in the API. The macros themselves document how to +** change your code to avoid using them. +** (Once more, these macros were officially removed in 5.3, but they are +** still available here.) +*/ +#define lua_strlen(L,i) lua_rawlen(L, (i)) + +#define lua_objlen(L,i) lua_rawlen(L, (i)) + +#define lua_equal(L,idx1,idx2) lua_compare(L,(idx1),(idx2),LUA_OPEQ) +#define lua_lessthan(L,idx1,idx2) lua_compare(L,(idx1),(idx2),LUA_OPLT) + +#endif /* } */ + +/* }================================================================== */ + + + +/* +** {================================================================== +** Configuration for Numbers. +** Change these definitions if no predefined LUA_FLOAT_* / LUA_INT_* +** satisfy your needs. +** =================================================================== +*/ + +/* +@@ LUA_NUMBER is the floating-point type used by Lua. +@@ LUAI_UACNUMBER is the result of a 'default argument promotion' +@@ over a floating number. +@@ l_floatatt(x) corrects float attribute 'x' to the proper float type +** by prefixing it with one of FLT/DBL/LDBL. +@@ LUA_NUMBER_FRMLEN is the length modifier for writing floats. +@@ LUA_NUMBER_FMT is the format for writing floats. +@@ lua_number2str converts a float to a string. +@@ l_mathop allows the addition of an 'l' or 'f' to all math operations. +@@ l_floor takes the floor of a float. +@@ lua_str2number converts a decimal numeral to a number. +*/ + + +/* The following definitions are good for most cases here */ + +#define l_floor(x) (l_mathop(floor)(x)) + +#define lua_number2str(s,sz,n) \ + l_sprintf((s), sz, LUA_NUMBER_FMT, (LUAI_UACNUMBER)(n)) + +/* +@@ lua_numbertointeger converts a float number with an integral value +** to an integer, or returns 0 if float is not within the range of +** a lua_Integer. (The range comparisons are tricky because of +** rounding. The tests here assume a two-complement representation, +** where MININTEGER always has an exact representation as a float; +** MAXINTEGER may not have one, and therefore its conversion to float +** may have an ill-defined value.) +*/ +#define lua_numbertointeger(n,p) \ + ((n) >= (LUA_NUMBER)(LUA_MININTEGER) && \ + (n) < -(LUA_NUMBER)(LUA_MININTEGER) && \ + (*(p) = (LUA_INTEGER)(n), 1)) + + +/* now the variable definitions */ + +#if LUA_FLOAT_TYPE == LUA_FLOAT_FLOAT /* { single float */ + +#define LUA_NUMBER float + +#define l_floatatt(n) (FLT_##n) + +#define LUAI_UACNUMBER double + +#define LUA_NUMBER_FRMLEN "" +#define LUA_NUMBER_FMT "%.7g" + +#define l_mathop(op) op##f + +#define lua_str2number(s,p) strtof((s), (p)) + + +#elif LUA_FLOAT_TYPE == LUA_FLOAT_LONGDOUBLE /* }{ long double */ + +#define LUA_NUMBER long double + +#define l_floatatt(n) (LDBL_##n) + +#define LUAI_UACNUMBER long double + +#define LUA_NUMBER_FRMLEN "L" +#define LUA_NUMBER_FMT "%.19Lg" + +#define l_mathop(op) op##l + +#define lua_str2number(s,p) strtold((s), (p)) + +#elif LUA_FLOAT_TYPE == LUA_FLOAT_DOUBLE /* }{ double */ + +#define LUA_NUMBER double + +#define l_floatatt(n) (DBL_##n) + +#define LUAI_UACNUMBER double + +#define LUA_NUMBER_FRMLEN "" +#define LUA_NUMBER_FMT "%.14g" + +#define l_mathop(op) op + +#define lua_str2number(s,p) strtod((s), (p)) + +#else /* }{ */ + +#error "numeric float type not defined" + +#endif /* } */ + + + +/* +@@ LUA_INTEGER is the integer type used by Lua. +** +@@ LUA_UNSIGNED is the unsigned version of LUA_INTEGER. +** +@@ LUAI_UACINT is the result of a 'default argument promotion' +@@ over a LUA_INTEGER. +@@ LUA_INTEGER_FRMLEN is the length modifier for reading/writing integers. +@@ LUA_INTEGER_FMT is the format for writing integers. +@@ LUA_MAXINTEGER is the maximum value for a LUA_INTEGER. +@@ LUA_MININTEGER is the minimum value for a LUA_INTEGER. +@@ LUA_MAXUNSIGNED is the maximum value for a LUA_UNSIGNED. +@@ LUA_UNSIGNEDBITS is the number of bits in a LUA_UNSIGNED. +@@ lua_integer2str converts an integer to a string. +*/ + + +/* The following definitions are good for most cases here */ + +#define LUA_INTEGER_FMT "%" LUA_INTEGER_FRMLEN "d" + +#define LUAI_UACINT LUA_INTEGER + +#define lua_integer2str(s,sz,n) \ + l_sprintf((s), sz, LUA_INTEGER_FMT, (LUAI_UACINT)(n)) + +/* +** use LUAI_UACINT here to avoid problems with promotions (which +** can turn a comparison between unsigneds into a signed comparison) +*/ +#define LUA_UNSIGNED unsigned LUAI_UACINT + + +#define LUA_UNSIGNEDBITS (sizeof(LUA_UNSIGNED) * CHAR_BIT) + + +/* now the variable definitions */ + +#if LUA_INT_TYPE == LUA_INT_INT /* { int */ + +#define LUA_INTEGER int +#define LUA_INTEGER_FRMLEN "" + +#define LUA_MAXINTEGER INT_MAX +#define LUA_MININTEGER INT_MIN + +#define LUA_MAXUNSIGNED UINT_MAX + +#elif LUA_INT_TYPE == LUA_INT_LONG /* }{ long */ + +#define LUA_INTEGER long +#define LUA_INTEGER_FRMLEN "l" + +#define LUA_MAXINTEGER LONG_MAX +#define LUA_MININTEGER LONG_MIN + +#define LUA_MAXUNSIGNED ULONG_MAX + +#elif LUA_INT_TYPE == LUA_INT_LONGLONG /* }{ long long */ + +/* use presence of macro LLONG_MAX as proxy for C99 compliance */ +#if defined(LLONG_MAX) /* { */ +/* use ISO C99 stuff */ + +#define LUA_INTEGER long long +#define LUA_INTEGER_FRMLEN "ll" + +#define LUA_MAXINTEGER LLONG_MAX +#define LUA_MININTEGER LLONG_MIN + +#define LUA_MAXUNSIGNED ULLONG_MAX + +#elif defined(LUA_USE_WINDOWS) /* }{ */ +/* in Windows, can use specific Windows types */ + +#define LUA_INTEGER __int64 +#define LUA_INTEGER_FRMLEN "I64" + +#define LUA_MAXINTEGER _I64_MAX +#define LUA_MININTEGER _I64_MIN + +#define LUA_MAXUNSIGNED _UI64_MAX + +#else /* }{ */ + +#error "Compiler does not support 'long long'. Use option '-DLUA_32BITS' \ + or '-DLUA_C89_NUMBERS' (see file 'luaconf.h' for details)" + +#endif /* } */ + +#else /* }{ */ + +#error "numeric integer type not defined" + +#endif /* } */ + +/* }================================================================== */ + + +/* +** {================================================================== +** Dependencies with C99 and other C details +** =================================================================== +*/ + +/* +@@ l_sprintf is equivalent to 'snprintf' or 'sprintf' in C89. +** (All uses in Lua have only one format item.) +*/ +#if !defined(LUA_USE_C89) +#define l_sprintf(s,sz,f,i) snprintf(s,sz,f,i) +#else +#define l_sprintf(s,sz,f,i) ((void)(sz), sprintf(s,f,i)) +#endif + + +/* +@@ lua_strx2number converts a hexadecimal numeral to a number. +** In C99, 'strtod' does that conversion. Otherwise, you can +** leave 'lua_strx2number' undefined and Lua will provide its own +** implementation. +*/ +#if !defined(LUA_USE_C89) +#define lua_strx2number(s,p) lua_str2number(s,p) +#endif + + +/* +@@ lua_pointer2str converts a pointer to a readable string in a +** non-specified way. +*/ +#define lua_pointer2str(buff,sz,p) l_sprintf(buff,sz,"%p",p) + + +/* +@@ lua_number2strx converts a float to a hexadecimal numeral. +** In C99, 'sprintf' (with format specifiers '%a'/'%A') does that. +** Otherwise, you can leave 'lua_number2strx' undefined and Lua will +** provide its own implementation. +*/ +#if !defined(LUA_USE_C89) +#define lua_number2strx(L,b,sz,f,n) \ + ((void)L, l_sprintf(b,sz,f,(LUAI_UACNUMBER)(n))) +#endif + + +/* +** 'strtof' and 'opf' variants for math functions are not valid in +** C89. Otherwise, the macro 'HUGE_VALF' is a good proxy for testing the +** availability of these variants. ('math.h' is already included in +** all files that use these macros.) +*/ +#if defined(LUA_USE_C89) || (defined(HUGE_VAL) && !defined(HUGE_VALF)) +#undef l_mathop /* variants not available */ +#undef lua_str2number +#define l_mathop(op) (lua_Number)op /* no variant */ +#define lua_str2number(s,p) ((lua_Number)strtod((s), (p))) +#endif + + +/* +@@ LUA_KCONTEXT is the type of the context ('ctx') for continuation +** functions. It must be a numerical type; Lua will use 'intptr_t' if +** available, otherwise it will use 'ptrdiff_t' (the nearest thing to +** 'intptr_t' in C89) +*/ +#define LUA_KCONTEXT ptrdiff_t + +#if !defined(LUA_USE_C89) && defined(__STDC_VERSION__) && \ + __STDC_VERSION__ >= 199901L +#include +#if defined(INTPTR_MAX) /* even in C99 this type is optional */ +#undef LUA_KCONTEXT +#define LUA_KCONTEXT intptr_t +#endif +#endif + + +/* +@@ lua_getlocaledecpoint gets the locale "radix character" (decimal point). +** Change that if you do not want to use C locales. (Code using this +** macro must include the header 'locale.h'.) +*/ +#if !defined(lua_getlocaledecpoint) +#define lua_getlocaledecpoint() (localeconv()->decimal_point[0]) +#endif + +/* }================================================================== */ + + +/* +** {================================================================== +** Language Variations +** ===================================================================== +*/ + +/* +@@ LUA_NOCVTN2S/LUA_NOCVTS2N control how Lua performs some +** coercions. Define LUA_NOCVTN2S to turn off automatic coercion from +** numbers to strings. Define LUA_NOCVTS2N to turn off automatic +** coercion from strings to numbers. +*/ +/* #define LUA_NOCVTN2S */ +/* #define LUA_NOCVTS2N */ + + +/* +@@ LUA_USE_APICHECK turns on several consistency checks on the C API. +** Define it as a help when debugging C code. +*/ +#if defined(LUA_USE_APICHECK) +#include +#define luai_apicheck(l,e) assert(e) +#endif + +/* }================================================================== */ + + +/* +** {================================================================== +** Macros that affect the API and must be stable (that is, must be the +** same when you compile Lua and when you compile code that links to +** Lua). +** ===================================================================== +*/ + +/* +@@ LUAI_MAXSTACK limits the size of the Lua stack. +** CHANGE it if you need a different limit. This limit is arbitrary; +** its only purpose is to stop Lua from consuming unlimited stack +** space (and to reserve some numbers for pseudo-indices). +** (It must fit into max(size_t)/32.) +*/ +#if LUAI_IS32INT +#define LUAI_MAXSTACK 1000000 +#else +#define LUAI_MAXSTACK 15000 +#endif + + +/* +@@ LUA_EXTRASPACE defines the size of a raw memory area associated with +** a Lua state with very fast access. +** CHANGE it if you need a different size. +*/ +#define LUA_EXTRASPACE (sizeof(void *)) + + +/* +@@ LUA_IDSIZE gives the maximum size for the description of the source +@@ of a function in debug information. +** CHANGE it if you want a different size. +*/ +#define LUA_IDSIZE 60 + + +/* +@@ LUAL_BUFFERSIZE is the buffer size used by the lauxlib buffer system. +*/ +#define LUAL_BUFFERSIZE ((int)(16 * sizeof(void*) * sizeof(lua_Number))) + + +/* +@@ LUAI_MAXALIGN defines fields that, when used in a union, ensure +** maximum alignment for the other items in that union. +*/ +#define LUAI_MAXALIGN lua_Number n; double u; void *s; lua_Integer i; long l + +/* }================================================================== */ + + + + + +/* =================================================================== */ + +/* +** Local configuration. You can use this space to add your redefinitions +** without modifying the main part of the file. +*/ + + + + + +#endif + diff --git a/examples/proto_debuger/third/include/lua/lualib.h b/examples/proto_debuger/third/include/lua/lualib.h new file mode 100644 index 00000000..eb08b530 --- /dev/null +++ b/examples/proto_debuger/third/include/lua/lualib.h @@ -0,0 +1,58 @@ +/* +** $Id: lualib.h $ +** Lua standard libraries +** See Copyright Notice in lua.h +*/ + + +#ifndef lualib_h +#define lualib_h + +#include "lua.h" + + +/* version suffix for environment variable names */ +#define LUA_VERSUFFIX "_" LUA_VERSION_MAJOR "_" LUA_VERSION_MINOR + + +LUAMOD_API int (luaopen_base) (lua_State *L); + +#define LUA_COLIBNAME "coroutine" +LUAMOD_API int (luaopen_coroutine) (lua_State *L); + +#define LUA_TABLIBNAME "table" +LUAMOD_API int (luaopen_table) (lua_State *L); + +#define LUA_IOLIBNAME "io" +LUAMOD_API int (luaopen_io) (lua_State *L); + +#define LUA_OSLIBNAME "os" +LUAMOD_API int (luaopen_os) (lua_State *L); + +#define LUA_STRLIBNAME "string" +LUAMOD_API int (luaopen_string) (lua_State *L); + +#define LUA_UTF8LIBNAME "utf8" +LUAMOD_API int (luaopen_utf8) (lua_State *L); + +#define LUA_MATHLIBNAME "math" +LUAMOD_API int (luaopen_math) (lua_State *L); + +#define LUA_DBLIBNAME "debug" +LUAMOD_API int (luaopen_debug) (lua_State *L); + +#define LUA_LOADLIBNAME "package" +LUAMOD_API int (luaopen_package) (lua_State *L); + + +/* open all previous libraries */ +LUALIB_API void (luaL_openlibs) (lua_State *L); + + + +#if !defined(lua_assert) +#define lua_assert(x) ((void)0) +#endif + + +#endif diff --git a/examples/proto_debuger/third/include/lua/lundump.h b/examples/proto_debuger/third/include/lua/lundump.h new file mode 100644 index 00000000..f3748a99 --- /dev/null +++ b/examples/proto_debuger/third/include/lua/lundump.h @@ -0,0 +1,36 @@ +/* +** $Id: lundump.h $ +** load precompiled Lua chunks +** See Copyright Notice in lua.h +*/ + +#ifndef lundump_h +#define lundump_h + +#include "llimits.h" +#include "lobject.h" +#include "lzio.h" + + +/* data to catch conversion errors */ +#define LUAC_DATA "\x19\x93\r\n\x1a\n" + +#define LUAC_INT 0x5678 +#define LUAC_NUM cast_num(370.5) + +/* +** Encode major-minor version in one byte, one nibble for each +*/ +#define MYINT(s) (s[0]-'0') /* assume one-digit numerals */ +#define LUAC_VERSION (MYINT(LUA_VERSION_MAJOR)*16+MYINT(LUA_VERSION_MINOR)) + +#define LUAC_FORMAT 0 /* this is the official format */ + +/* load one chunk; from lundump.c */ +LUAI_FUNC LClosure* luaU_undump (lua_State* L, ZIO* Z, const char* name); + +/* dump one chunk; from ldump.c */ +LUAI_FUNC int luaU_dump (lua_State* L, const Proto* f, lua_Writer w, + void* data, int strip); + +#endif diff --git a/examples/proto_debuger/third/include/lua/lvm.h b/examples/proto_debuger/third/include/lua/lvm.h new file mode 100644 index 00000000..2d4ac160 --- /dev/null +++ b/examples/proto_debuger/third/include/lua/lvm.h @@ -0,0 +1,134 @@ +/* +** $Id: lvm.h $ +** Lua virtual machine +** See Copyright Notice in lua.h +*/ + +#ifndef lvm_h +#define lvm_h + + +#include "ldo.h" +#include "lobject.h" +#include "ltm.h" + + +#if !defined(LUA_NOCVTN2S) +#define cvt2str(o) ttisnumber(o) +#else +#define cvt2str(o) 0 /* no conversion from numbers to strings */ +#endif + + +#if !defined(LUA_NOCVTS2N) +#define cvt2num(o) ttisstring(o) +#else +#define cvt2num(o) 0 /* no conversion from strings to numbers */ +#endif + + +/* +** You can define LUA_FLOORN2I if you want to convert floats to integers +** by flooring them (instead of raising an error if they are not +** integral values) +*/ +#if !defined(LUA_FLOORN2I) +#define LUA_FLOORN2I F2Ieq +#endif + + +/* +** Rounding modes for float->integer coercion + */ +typedef enum { + F2Ieq, /* no rounding; accepts only integral values */ + F2Ifloor, /* takes the floor of the number */ + F2Iceil /* takes the ceil of the number */ +} F2Imod; + + +/* convert an object to a float (including string coercion) */ +#define tonumber(o,n) \ + (ttisfloat(o) ? (*(n) = fltvalue(o), 1) : luaV_tonumber_(o,n)) + + +/* convert an object to a float (without string coercion) */ +#define tonumberns(o,n) \ + (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ + (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) + + +/* convert an object to an integer (including string coercion) */ +#define tointeger(o,i) \ + (ttisinteger(o) ? (*(i) = ivalue(o), 1) : luaV_tointeger(o,i,LUA_FLOORN2I)) + + +/* convert an object to an integer (without string coercion) */ +#define tointegerns(o,i) \ + (ttisinteger(o) ? (*(i) = ivalue(o), 1) : luaV_tointegerns(o,i,LUA_FLOORN2I)) + + +#define intop(op,v1,v2) l_castU2S(l_castS2U(v1) op l_castS2U(v2)) + +#define luaV_rawequalobj(t1,t2) luaV_equalobj(NULL,t1,t2) + + +/* +** fast track for 'gettable': if 't' is a table and 't[k]' is present, +** return 1 with 'slot' pointing to 't[k]' (position of final result). +** Otherwise, return 0 (meaning it will have to check metamethod) +** with 'slot' pointing to an empty 't[k]' (if 't' is a table) or NULL +** (otherwise). 'f' is the raw get function to use. +*/ +#define luaV_fastget(L,t,k,slot,f) \ + (!ttistable(t) \ + ? (slot = NULL, 0) /* not a table; 'slot' is NULL and result is 0 */ \ + : (slot = f(hvalue(t), k), /* else, do raw access */ \ + !isempty(slot))) /* result not empty? */ + + +/* +** Special case of 'luaV_fastget' for integers, inlining the fast case +** of 'luaH_getint'. +*/ +#define luaV_fastgeti(L,t,k,slot) \ + (!ttistable(t) \ + ? (slot = NULL, 0) /* not a table; 'slot' is NULL and result is 0 */ \ + : (slot = (l_castS2U(k) - 1u < hvalue(t)->alimit) \ + ? &hvalue(t)->array[k - 1] : luaH_getint(hvalue(t), k), \ + !isempty(slot))) /* result not empty? */ + + +/* +** Finish a fast set operation (when fast get succeeds). In that case, +** 'slot' points to the place to put the value. +*/ +#define luaV_finishfastset(L,t,slot,v) \ + { setobj2t(L, cast(TValue *,slot), v); \ + luaC_barrierback(L, gcvalue(t), v); } + + + + +LUAI_FUNC int luaV_equalobj (lua_State *L, const TValue *t1, const TValue *t2); +LUAI_FUNC int luaV_lessthan (lua_State *L, const TValue *l, const TValue *r); +LUAI_FUNC int luaV_lessequal (lua_State *L, const TValue *l, const TValue *r); +LUAI_FUNC int luaV_tonumber_ (const TValue *obj, lua_Number *n); +LUAI_FUNC int luaV_tointeger (const TValue *obj, lua_Integer *p, F2Imod mode); +LUAI_FUNC int luaV_tointegerns (const TValue *obj, lua_Integer *p, + F2Imod mode); +LUAI_FUNC int luaV_flttointeger (lua_Number n, lua_Integer *p, F2Imod mode); +LUAI_FUNC void luaV_finishget (lua_State *L, const TValue *t, TValue *key, + StkId val, const TValue *slot); +LUAI_FUNC void luaV_finishset (lua_State *L, const TValue *t, TValue *key, + TValue *val, const TValue *slot); +LUAI_FUNC void luaV_finishOp (lua_State *L); +LUAI_FUNC void luaV_execute (lua_State *L, CallInfo *ci); +LUAI_FUNC void luaV_concat (lua_State *L, int total); +LUAI_FUNC lua_Integer luaV_idiv (lua_State *L, lua_Integer x, lua_Integer y); +LUAI_FUNC lua_Integer luaV_mod (lua_State *L, lua_Integer x, lua_Integer y); +LUAI_FUNC lua_Number luaV_modf (lua_State *L, lua_Number x, lua_Number y); +LUAI_FUNC lua_Integer luaV_shiftl (lua_Integer x, lua_Integer y); +LUAI_FUNC void luaV_objlen (lua_State *L, StkId ra, const TValue *rb); + +#endif diff --git a/examples/proto_debuger/third/include/lua/lzio.h b/examples/proto_debuger/third/include/lua/lzio.h new file mode 100644 index 00000000..38f397fd --- /dev/null +++ b/examples/proto_debuger/third/include/lua/lzio.h @@ -0,0 +1,66 @@ +/* +** $Id: lzio.h $ +** Buffered streams +** See Copyright Notice in lua.h +*/ + + +#ifndef lzio_h +#define lzio_h + +#include "lua.h" + +#include "lmem.h" + + +#define EOZ (-1) /* end of stream */ + +typedef struct Zio ZIO; + +#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) + + +typedef struct Mbuffer { + char *buffer; + size_t n; + size_t buffsize; +} Mbuffer; + +#define luaZ_initbuffer(L, buff) ((buff)->buffer = NULL, (buff)->buffsize = 0) + +#define luaZ_buffer(buff) ((buff)->buffer) +#define luaZ_sizebuffer(buff) ((buff)->buffsize) +#define luaZ_bufflen(buff) ((buff)->n) + +#define luaZ_buffremove(buff,i) ((buff)->n -= (i)) +#define luaZ_resetbuffer(buff) ((buff)->n = 0) + + +#define luaZ_resizebuffer(L, buff, size) \ + ((buff)->buffer = luaM_reallocvchar(L, (buff)->buffer, \ + (buff)->buffsize, size), \ + (buff)->buffsize = size) + +#define luaZ_freebuffer(L, buff) luaZ_resizebuffer(L, buff, 0) + + +LUAI_FUNC void luaZ_init (lua_State *L, ZIO *z, lua_Reader reader, + void *data); +LUAI_FUNC size_t luaZ_read (ZIO* z, void *b, size_t n); /* read next n bytes */ + + + +/* --------- Private Part ------------------ */ + +struct Zio { + size_t n; /* bytes still unread */ + const char *p; /* current position in buffer */ + lua_Reader reader; /* reader function */ + void *data; /* additional data */ + lua_State *L; /* Lua state (for reader) */ +}; + + +LUAI_FUNC int luaZ_fill (ZIO *z); + +#endif diff --git a/examples/proto_debuger/third/lib/lua53.dll b/examples/proto_debuger/third/lib/lua53.dll new file mode 100644 index 0000000000000000000000000000000000000000..4739ec5bb54bbbc982c706637c4211cd095d6a52 GIT binary patch literal 586752 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

8vQEKG@?-o4P;OV7Q=ifW^`b$07? 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

{fp(V=be{m6X#6<`U3%NbT1=za0C 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⋙FfXSrF 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 z_qAttachClick([this](ui::EventArgs*) { wstring* name = new wstring(this->GetName()); - ::PostMessage(this->GetWindow()->GetHWND(), WM_ADD_UART_CLOSE, (WPARAM)name, 0); + ::PostMessage(this->GetWindow()->GetHWND(), + WM_ADD_UART_CLOSE, (WPARAM)name, 0); return true; - }); + }); } }