diff --git a/src/pre_generated-zmq.nobj.c b/src/pre_generated-zmq.nobj.c index eaf0395..f639e1a 100644 --- a/src/pre_generated-zmq.nobj.c +++ b/src/pre_generated-zmq.nobj.c @@ -207,6 +207,24 @@ typedef struct ffi_export_symbol { } ffi_export_symbol; #endif +#ifndef ZMQ_DONTWAIT +# define ZMQ_DONTWAIT ZMQ_NOBLOCK +#endif +#if ZMQ_VERSION_MAJOR == 2 +# define ZMQ_POLL_MSEC 1000 // zmq_poll is usec +#elif ZMQ_VERSION_MAJOR == 3 +# define ZMQ_POLL_MSEC 1 // zmq_poll is msec +# ifndef ZMQ_HWM +# define ZMQ_HWM 1 // backwards compatibility +# endif +#endif +#ifndef ZMQ_DEALER +# define ZMQ_DEALER ZMQ_XREQ +#endif +#ifndef ZMQ_ROUTER +# define ZMQ_ROUTER ZMQ_XREP +#endif + typedef int ZMQ_Error; @@ -1062,6 +1080,10 @@ static const char zmq_ffi_lua_code[] = "local ffi=require\"ffi\"\n" "int zmq_msg_init_size (zmq_msg_t *msg, size_t size);\n" "\n" "\n" +"ZMQ_Error zmq_msg_init(zmq_msg_t *);\n" +"\n" +"ZMQ_Error zmq_msg_init_size(zmq_msg_t *, size_t);\n" +"\n" "ZMQ_Error zmq_msg_close(zmq_msg_t *);\n" "\n" "ZMQ_Error zmq_msg_move(zmq_msg_t *, zmq_msg_t *);\n" @@ -1081,11 +1103,111 @@ static const char zmq_ffi_lua_code[] = "local ffi=require\"ffi\"\n" "int zmq_setsockopt (void *s, int option, const void *optval, size_t optvallen);\n" "int zmq_getsockopt (void *s, int option, void *optval, size_t *optvallen);\n" "\n" -"ZMQ_Error zmq_send(ZMQ_Socket *, zmq_msg_t *, int);\n" +"ZMQ_Error zmq_sendmsg(ZMQ_Socket *, zmq_msg_t *, int);\n" "\n" "ZMQ_Error simple_zmq_send(ZMQ_Socket *, const char *, size_t, int);\n" "\n" -"ZMQ_Error zmq_recv(ZMQ_Socket *, zmq_msg_t *, int);\n" +"ZMQ_Error zmq_recvmsg(ZMQ_Socket *, zmq_msg_t *, int);\n" +"\n" +"ZMQ_Error lzmq_socket_hwm(ZMQ_Socket *, int*);\n" +"\n" +"ZMQ_Error lzmq_socket_set_hwm(ZMQ_Socket *, int);\n" +"\n" +"ZMQ_Error lzmq_socket_swap(ZMQ_Socket *, int*);\n" +"\n" +"ZMQ_Error lzmq_socket_set_swap(ZMQ_Socket *, int);\n" +"\n" +"ZMQ_Error lzmq_socket_affinity(ZMQ_Socket *, uint64_t*);\n" +"\n" +"ZMQ_Error lzmq_socket_set_affinity(ZMQ_Socket *, uint64_t);\n" +"\n" +"ZMQ_Error lzmq_socket_identity(ZMQ_Socket *, char *, size_t*);\n" +"\n" +"ZMQ_Error lzmq_socket_set_identity(ZMQ_Socket *, const char *, size_t);\n" +"\n" +"ZMQ_Error lzmq_socket_subscribe(ZMQ_Socket *, const char *, size_t);\n" +"\n" +"ZMQ_Error lzmq_socket_unsubscribe(ZMQ_Socket *, const char *, size_t);\n" +"\n" +"ZMQ_Error lzmq_socket_rate(ZMQ_Socket *, int*);\n" +"\n" +"ZMQ_Error lzmq_socket_set_rate(ZMQ_Socket *, int);\n" +"\n" +"ZMQ_Error lzmq_socket_recovery_ivl(ZMQ_Socket *, int*);\n" +"\n" +"ZMQ_Error lzmq_socket_set_recovery_ivl(ZMQ_Socket *, int);\n" +"\n" +"ZMQ_Error lzmq_socket_mcast_loop(ZMQ_Socket *, int*);\n" +"\n" +"ZMQ_Error lzmq_socket_set_mcast_loop(ZMQ_Socket *, int);\n" +"\n" +"ZMQ_Error lzmq_socket_sndbuf(ZMQ_Socket *, int*);\n" +"\n" +"ZMQ_Error lzmq_socket_set_sndbuf(ZMQ_Socket *, int);\n" +"\n" +"ZMQ_Error lzmq_socket_rcvbuf(ZMQ_Socket *, int*);\n" +"\n" +"ZMQ_Error lzmq_socket_set_rcvbuf(ZMQ_Socket *, int);\n" +"\n" +"ZMQ_Error lzmq_socket_rcvmore(ZMQ_Socket *, int*);\n" +"\n" +"ZMQ_Error lzmq_socket_fd(ZMQ_Socket *, int*);\n" +"\n" +"ZMQ_Error lzmq_socket_events(ZMQ_Socket *, int*);\n" +"\n" +"ZMQ_Error lzmq_socket_type(ZMQ_Socket *, int*);\n" +"\n" +"ZMQ_Error lzmq_socket_linger(ZMQ_Socket *, int*);\n" +"\n" +"ZMQ_Error lzmq_socket_set_linger(ZMQ_Socket *, int);\n" +"\n" +"ZMQ_Error lzmq_socket_reconnect_ivl(ZMQ_Socket *, int*);\n" +"\n" +"ZMQ_Error lzmq_socket_set_reconnect_ivl(ZMQ_Socket *, int);\n" +"\n" +"ZMQ_Error lzmq_socket_backlog(ZMQ_Socket *, int*);\n" +"\n" +"ZMQ_Error lzmq_socket_set_backlog(ZMQ_Socket *, int);\n" +"\n" +"ZMQ_Error lzmq_socket_recovery_ivl_msec(ZMQ_Socket *, int64_t*);\n" +"\n" +"ZMQ_Error lzmq_socket_set_recovery_ivl_msec(ZMQ_Socket *, int64_t);\n" +"\n" +"ZMQ_Error lzmq_socket_reconnect_ivl_max(ZMQ_Socket *, int*);\n" +"\n" +"ZMQ_Error lzmq_socket_set_reconnect_ivl_max(ZMQ_Socket *, int);\n" +"\n" +"ZMQ_Error lzmq_socket_maxmsgsize(ZMQ_Socket *, int64_t*);\n" +"\n" +"ZMQ_Error lzmq_socket_set_maxmsgsize(ZMQ_Socket *, int64_t);\n" +"\n" +"ZMQ_Error lzmq_socket_sndhwm(ZMQ_Socket *, int*);\n" +"\n" +"ZMQ_Error lzmq_socket_set_sndhwm(ZMQ_Socket *, int);\n" +"\n" +"ZMQ_Error lzmq_socket_rcvhwm(ZMQ_Socket *, int*);\n" +"\n" +"ZMQ_Error lzmq_socket_set_rcvhwm(ZMQ_Socket *, int);\n" +"\n" +"ZMQ_Error lzmq_socket_multicast_hops(ZMQ_Socket *, int*);\n" +"\n" +"ZMQ_Error lzmq_socket_set_multicast_hops(ZMQ_Socket *, int);\n" +"\n" +"ZMQ_Error lzmq_socket_rcvtimeo(ZMQ_Socket *, int*);\n" +"\n" +"ZMQ_Error lzmq_socket_set_rcvtimeo(ZMQ_Socket *, int);\n" +"\n" +"ZMQ_Error lzmq_socket_sndtimeo(ZMQ_Socket *, int*);\n" +"\n" +"ZMQ_Error lzmq_socket_set_sndtimeo(ZMQ_Socket *, int);\n" +"\n" +"ZMQ_Error lzmq_socket_rcvlabel(ZMQ_Socket *, int*);\n" +"\n" +"ZMQ_Error lzmq_socket_set_rcvlabel(ZMQ_Socket *, int);\n" +"\n" +"typedef ZMQ_Error (*zmq_sendmsg_func)(ZMQ_Socket * this, zmq_msg_t * msg, int flags);\n" +"\n" +"typedef ZMQ_Error (*zmq_recvmsg_func)(ZMQ_Socket * this, zmq_msg_t * msg, int flags);\n" "\n" "typedef int socket_t;\n" "typedef struct zmq_pollitem_t {\n" @@ -1148,6 +1270,7 @@ static const char zmq_ffi_lua_code[] = "local ffi=require\"ffi\"\n" " new_pub[k] = v\n" " end\n" " pub = new_pub\n" +" _M[obj_name] = pub\n" " end\n" " _pub[obj_name] = pub\n" "end\n" @@ -1376,6 +1499,10 @@ static const char zmq_ffi_lua_code[] = "local ffi=require\"ffi\"\n" "end\n" "\n" "\n" +"local zmq_sendmsg = ffi.new(\"zmq_sendmsg_func\", _priv[\"zmq_sendmsg\"])\n" +"\n" +"local zmq_recvmsg = ffi.new(\"zmq_recvmsg_func\", _priv[\"zmq_recvmsg\"])\n" +"\n" "\n" "-- Start \"ZErrors\" FFI interface\n" "-- End \"ZErrors\" FFI interface\n" @@ -1398,78 +1525,96 @@ static const char zmq_ffi_lua_code[] = "local ffi=require\"ffi\"\n" "\n" "\n" "-- Start \"zmq_msg_t\" FFI interface\n" +"-- method: init\n" +"function _pub.zmq_msg_t.init()\n" +" local self = ffi.new(\"zmq_msg_t\")\n" +" local rc_zmq_msg_init2 = 0\n" +" rc_zmq_msg_init2 = C.zmq_msg_init(self)\n" +" if (-1 == rc_zmq_msg_init2) then\n" +" return nil,error_code__ZMQ_Error__push(rc_zmq_msg_init2)\n" +" end\n" +" return obj_type_zmq_msg_t_push(self)\n" +"end\n" +"register_default_constructor(_pub,\"zmq_msg_t\",_pub.zmq_msg_t.init)\n" +"-- method: init_size\n" +"function _pub.zmq_msg_t.init_size(size1)\n" +" \n" +" local self = ffi.new(\"zmq_msg_t\")\n" +" local rc_zmq_msg_init_size2 = 0\n" +" rc_zmq_msg_init_size2 = C.zmq_msg_init_size(self, size1)\n" +" if (-1 == rc_zmq_msg_init_size2) then\n" +" return nil,error_code__ZMQ_Error__push(rc_zmq_msg_init_size2)\n" +" end\n" +" return obj_type_zmq_msg_t_push(self)\n" +"end\n" +"-- method: init_data\n" +"function _pub.zmq_msg_t.init_data(data1)\n" +" local data_len1 = #data1\n" +" local self = ffi.new(\"zmq_msg_t\")\n" +" local err2 = 0\n" +" err2 = C.zmq_msg_init_size(self, data_len1)\n" +" if(0 == err2) then\n" +" -- fill message\n" +" ffi.copy(C.zmq_msg_data(self), data1, data_len1)\n" +" end\n" +"\n" +" if (-1 == err2) then\n" +" return nil,error_code__ZMQ_Error__push(err2)\n" +" end\n" +" return obj_type_zmq_msg_t_push(self)\n" +"end\n" "-- method: __gc\n" "function _priv.zmq_msg_t.__gc(self)\n" " local self = obj_type_zmq_msg_t_delete(self)\n" " if not self then return end\n" -" local rc_zmq_msg_close1\n" +" local rc_zmq_msg_close1 = 0\n" " rc_zmq_msg_close1 = C.zmq_msg_close(self)\n" " -- check for error.\n" -" local rc_zmq_msg_close1_err\n" " if (-1 == rc_zmq_msg_close1) then\n" -" rc_zmq_msg_close1_err = error_code__ZMQ_Error__push(rc_zmq_msg_close1)\n" -" rc_zmq_msg_close1 = nil\n" -" else\n" -" rc_zmq_msg_close1 = true\n" +" return nil, error_code__ZMQ_Error__push(rc_zmq_msg_close1)\n" " end\n" -" return rc_zmq_msg_close1, rc_zmq_msg_close1_err\n" +" return true\n" "end\n" -"\n" "-- method: close\n" "function _meth.zmq_msg_t.close(self)\n" " \n" -" local rc_zmq_msg_close1\n" +" local rc_zmq_msg_close1 = 0\n" " rc_zmq_msg_close1 = C.zmq_msg_close(self)\n" " -- check for error.\n" -" local rc_zmq_msg_close1_err\n" " if (-1 == rc_zmq_msg_close1) then\n" -" rc_zmq_msg_close1_err = error_code__ZMQ_Error__push(rc_zmq_msg_close1)\n" -" rc_zmq_msg_close1 = nil\n" -" else\n" -" rc_zmq_msg_close1 = true\n" +" return nil, error_code__ZMQ_Error__push(rc_zmq_msg_close1)\n" " end\n" -" return rc_zmq_msg_close1, rc_zmq_msg_close1_err\n" +" return true\n" "end\n" -"\n" "-- method: move\n" "function _meth.zmq_msg_t.move(self, src2)\n" " \n" " \n" -" local rc_zmq_msg_move1\n" +" local rc_zmq_msg_move1 = 0\n" " rc_zmq_msg_move1 = C.zmq_msg_move(self, src2)\n" " -- check for error.\n" -" local rc_zmq_msg_move1_err\n" " if (-1 == rc_zmq_msg_move1) then\n" -" rc_zmq_msg_move1_err = error_code__ZMQ_Error__push(rc_zmq_msg_move1)\n" -" rc_zmq_msg_move1 = nil\n" -" else\n" -" rc_zmq_msg_move1 = true\n" +" return nil, error_code__ZMQ_Error__push(rc_zmq_msg_move1)\n" " end\n" -" return rc_zmq_msg_move1, rc_zmq_msg_move1_err\n" +" return true\n" "end\n" -"\n" "-- method: copy\n" "function _meth.zmq_msg_t.copy(self, src2)\n" " \n" " \n" -" local rc_zmq_msg_copy1\n" +" local rc_zmq_msg_copy1 = 0\n" " rc_zmq_msg_copy1 = C.zmq_msg_copy(self, src2)\n" " -- check for error.\n" -" local rc_zmq_msg_copy1_err\n" " if (-1 == rc_zmq_msg_copy1) then\n" -" rc_zmq_msg_copy1_err = error_code__ZMQ_Error__push(rc_zmq_msg_copy1)\n" -" rc_zmq_msg_copy1 = nil\n" -" else\n" -" rc_zmq_msg_copy1 = true\n" +" return nil, error_code__ZMQ_Error__push(rc_zmq_msg_copy1)\n" " end\n" -" return rc_zmq_msg_copy1, rc_zmq_msg_copy1_err\n" +" return true\n" "end\n" -"\n" "-- method: set_data\n" "function _meth.zmq_msg_t.set_data(self, data2)\n" " \n" " local data_len2 = #data2\n" -" local err1\n" +" local err1 = 0\n" " -- check message data size.\n" " if (C.zmq_msg_size(self) ~= data_len2) then\n" " -- need to resize message.\n" @@ -1483,30 +1628,23 @@ static const char zmq_ffi_lua_code[] = "local ffi=require\"ffi\"\n" " ffi.copy(C.zmq_msg_data(self), data2, data_len2);\n" "\n" " -- check for error.\n" -" local err1_err\n" " if (-1 == err1) then\n" -" err1_err = error_code__ZMQ_Error__push(err1)\n" -" err1 = nil\n" -" else\n" -" err1 = true\n" +" return nil, error_code__ZMQ_Error__push(err1)\n" " end\n" -" return err1, err1_err\n" +" return true\n" "end\n" -"\n" "-- method: data\n" "function _meth.zmq_msg_t.data(self)\n" " \n" -" local rc_zmq_msg_data1\n" +" local rc_zmq_msg_data1 = NULL\n" " rc_zmq_msg_data1 = C.zmq_msg_data(self)\n" -" rc_zmq_msg_data1 = rc_zmq_msg_data1\n" " return rc_zmq_msg_data1\n" "end\n" -"\n" "-- method: set_size\n" "function _meth.zmq_msg_t.set_size(self, size2)\n" " \n" " \n" -" local err1\n" +" local err1 = 0\n" " -- check message data size.\n" " if (C.zmq_msg_size(self) ~= size2) then\n" " -- need to resize message.\n" @@ -1518,121 +1656,131 @@ static const char zmq_ffi_lua_code[] = "local ffi=require\"ffi\"\n" " end\n" "\n" " -- check for error.\n" -" local err1_err\n" " if (-1 == err1) then\n" -" err1_err = error_code__ZMQ_Error__push(err1)\n" -" err1 = nil\n" -" else\n" -" err1 = true\n" +" return nil, error_code__ZMQ_Error__push(err1)\n" " end\n" -" return err1, err1_err\n" +" return true\n" "end\n" -"\n" "-- method: size\n" "function _meth.zmq_msg_t.size(self)\n" " \n" -" local rc_zmq_msg_size1\n" +" local rc_zmq_msg_size1 = 0\n" " rc_zmq_msg_size1 = C.zmq_msg_size(self)\n" -" rc_zmq_msg_size1 = rc_zmq_msg_size1\n" " return rc_zmq_msg_size1\n" "end\n" -"\n" "-- method: __tostring\n" "function _priv.zmq_msg_t.__tostring(self)\n" " \n" " local data_len1 = 0\n" -" local data1\n" +" local data1 = NULL\n" " data1 = C.zmq_msg_data(self);\n" " data_len1 = C.zmq_msg_size(self);\n" "\n" -" data1 = ((nil ~= data1) and ffi.string(data1,data_len1))\n" -" return data1\n" +" return ((nil ~= data1) and ffi.string(data1,data_len1))\n" "end\n" -"\n" "ffi.metatype(\"zmq_msg_t\", _priv.zmq_msg_t)\n" "-- End \"zmq_msg_t\" FFI interface\n" "\n" "\n" "-- Start \"ZMQ_Socket\" FFI interface\n" +"-- detect zmq version\n" +"local VERSION_2_0 = true\n" +"local VERSION_2_1 = false\n" +"local VERSION_3_0 = false\n" +"local zver = _M.version()\n" +"if zver[1] == 3 then\n" +" VERSION_2_0 = false\n" +" VERSION_3_0 = true\n" +"elseif zver[1] == 2 and zver[2] == 1 then\n" +" VERSION_2_1 = true\n" +"end\n" +"\n" "-- method: close\n" "function _meth.ZMQ_Socket.close(self)\n" " local self,this_flags1 = obj_type_ZMQ_Socket_delete(self)\n" " if not self then return end\n" -" local rc_zmq_close1\n" +" local rc_zmq_close1 = 0\n" " rc_zmq_close1 = C.zmq_close(self)\n" " -- check for error.\n" -" local rc_zmq_close1_err\n" " if (-1 == rc_zmq_close1) then\n" -" rc_zmq_close1_err = error_code__ZMQ_Error__push(rc_zmq_close1)\n" -" rc_zmq_close1 = nil\n" -" else\n" -" rc_zmq_close1 = true\n" +" return nil, error_code__ZMQ_Error__push(rc_zmq_close1)\n" " end\n" -" return rc_zmq_close1, rc_zmq_close1_err\n" +" return true\n" "end\n" -"\n" "_priv.ZMQ_Socket.__gc = _meth.ZMQ_Socket.close\n" "-- method: bind\n" "function _meth.ZMQ_Socket.bind(self, addr2)\n" " \n" " local addr_len2 = #addr2\n" -" local rc_zmq_bind1\n" +" local rc_zmq_bind1 = 0\n" " rc_zmq_bind1 = C.zmq_bind(self, addr2)\n" " -- check for error.\n" -" local rc_zmq_bind1_err\n" " if (-1 == rc_zmq_bind1) then\n" -" rc_zmq_bind1_err = error_code__ZMQ_Error__push(rc_zmq_bind1)\n" -" rc_zmq_bind1 = nil\n" -" else\n" -" rc_zmq_bind1 = true\n" +" return nil, error_code__ZMQ_Error__push(rc_zmq_bind1)\n" " end\n" -" return rc_zmq_bind1, rc_zmq_bind1_err\n" +" return true\n" "end\n" -"\n" "-- method: connect\n" "function _meth.ZMQ_Socket.connect(self, addr2)\n" " \n" " local addr_len2 = #addr2\n" -" local rc_zmq_connect1\n" +" local rc_zmq_connect1 = 0\n" " rc_zmq_connect1 = C.zmq_connect(self, addr2)\n" " -- check for error.\n" -" local rc_zmq_connect1_err\n" " if (-1 == rc_zmq_connect1) then\n" -" rc_zmq_connect1_err = error_code__ZMQ_Error__push(rc_zmq_connect1)\n" -" rc_zmq_connect1 = nil\n" -" else\n" -" rc_zmq_connect1 = true\n" +" return nil, error_code__ZMQ_Error__push(rc_zmq_connect1)\n" " end\n" -" return rc_zmq_connect1, rc_zmq_connect1_err\n" -"end\n" -"\n" -"local option_types = {\n" -"[zmq.HWM] = 'uint64_t[1]',\n" -"[zmq.SWAP] = 'int64_t[1]',\n" -"[zmq.AFFINITY] = 'uint64_t[1]',\n" -"[zmq.IDENTITY] = 'string',\n" -"[zmq.SUBSCRIBE] = 'string',\n" -"[zmq.UNSUBSCRIBE] = 'string',\n" -"[zmq.RATE] = 'int64_t[1]',\n" -"[zmq.RECOVERY_IVL] = 'int64_t[1]',\n" -"[zmq.MCAST_LOOP] = 'int64_t[1]',\n" -"[zmq.SNDBUF] = 'uint64_t[1]',\n" -"[zmq.RCVBUF] = 'uint64_t[1]',\n" -"[zmq.RCVMORE] = 'int64_t[1]',\n" -"[zmq.FD] = 'int[1]',\n" -"[zmq.EVENTS] = 'uint32_t[1]',\n" -"[zmq.TYPE] = 'int[1]',\n" -"[zmq.LINGER] = 'int[1]',\n" -"[zmq.RECONNECT_IVL] = 'int[1]',\n" -"[zmq.BACKLOG] = 'int[1]',\n" +" return true\n" +"end\n" +"local option_gets = {}\n" +"local option_sets = {}\n" +"\n" +"do\n" +" local opt_name\n" +" local methods = _meth.ZMQ_Socket\n" +" setmetatable(option_gets,{__index = function(tab,opt)\n" +" local opt_name = opt_name[opt]\n" +" if not opt_name then return nil end\n" +" local method = methods[opt_name]\n" +" rawset(tab, opt, method)\n" +" return method\n" +" end})\n" +" setmetatable(option_sets,{__index = function(tab,opt)\n" +" local opt_name = opt_name[opt]\n" +" if not opt_name then return nil end\n" +" local method = methods[opt_name] or methods['set_' .. opt_name]\n" +" rawset(tab, opt, method)\n" +" return method\n" +" end})\n" +" opt_name = {\n" +" [1] = 'hwm',\n" +" [3] = 'swap',\n" +" [4] = 'affinity',\n" +" [5] = 'identity',\n" +" [6] = 'subscribe',\n" +" [7] = 'unsubscribe',\n" +" [8] = 'rate',\n" +" [9] = 'recovery_ivl',\n" +" [10] = 'mcast_loop',\n" +" [11] = 'sndbuf',\n" +" [12] = 'rcvbuf',\n" +" [13] = 'rcvmore',\n" +" [14] = 'fd',\n" +" [15] = 'events',\n" +" [16] = 'type',\n" +" [17] = 'linger',\n" +" [18] = 'reconnect_ivl',\n" +" [19] = 'backlog',\n" +" [20] = 'recovery_ivl_msec',\n" +" [21] = 'reconnect_ivl_max',\n" +" [22] = 'maxmsgsize',\n" +" [23] = 'sndhwm',\n" +" [24] = 'rcvhwm',\n" +" [25] = 'multicast_hops',\n" +" [27] = 'rcvtimeo',\n" +" [28] = 'sndtimeo',\n" +" [29] = 'rcvlabel',\n" "}\n" -"local option_len = {}\n" -"local option_tmps = {}\n" -"for k,v in pairs(option_types) do\n" -" if v ~= 'string' then\n" -" option_len[k] = ffi.sizeof(v)\n" -" option_tmps[k] = ffi.new(v, 0)\n" -" end\n" "end\n" "\n" "\n" @@ -1640,31 +1788,20 @@ static const char zmq_ffi_lua_code[] = "local ffi=require\"ffi\"\n" "function _meth.ZMQ_Socket.setopt(self, opt2, val3)\n" " \n" " \n" -" local err1\n" -" local ctype = option_types[opt2]\n" -" local tval\n" -" local tval_len = 0\n" -" if ctype == 'string' then\n" -" tval = tostring(val3)\n" -" tval_len = #val3\n" +" local err1 = 0\n" +" local set = option_sets[opt2]\n" +" if set then\n" +" return set(self,val3)\n" " else\n" -" tval = option_tmps[opt2]\n" -" tval[0] = val3\n" -" tval_len = option_len[opt2]\n" +" error(\"Invalid socket option.\")\n" " end\n" -" err1 = C.zmq_setsockopt(self, opt2, tval, tval_len)\n" "\n" " -- check for error.\n" -" local err1_err\n" " if (-1 == err1) then\n" -" err1_err = error_code__ZMQ_Error__push(err1)\n" -" err1 = nil\n" -" else\n" -" err1 = true\n" +" return nil, error_code__ZMQ_Error__push(err1)\n" " end\n" -" return err1, err1_err\n" +" return true\n" "end\n" -"\n" "local tmp_val_len = ffi.new('size_t[1]', 4)\n" "\n" "-- method: getopt\n" @@ -1672,111 +1809,55 @@ static const char zmq_ffi_lua_code[] = "local ffi=require\"ffi\"\n" " \n" " \n" " local val1\n" -" local err2\n" -" local ctype = option_types[opt2]\n" -" local val\n" -" local val_len = tmp_val_len\n" -" if ctype == 'string' then\n" -" val_len[0] = 255\n" -" val = ffi.new('uint8_t[?]', val_len[0])\n" -" ffi.fill(val, val_len[0])\n" +" local err2 = 0\n" +" local get = option_gets[opt2]\n" +" if get then\n" +" return get(self)\n" " else\n" -" val = option_tmps[opt2]\n" -" val[0] = 0\n" -" val_len[0] = option_len[opt2]\n" -" end\n" -" err2 = C.zmq_getsockopt(self, opt2, val, val_len)\n" -" if err2 == 0 then\n" -" if ctype == 'string' then\n" -" val_len = val_len[0]\n" -" return ffi.string(val, val_len)\n" -" else\n" -" return tonumber(val[0])\n" -" end\n" +" error(\"Invalid socket option.\")\n" " end\n" "\n" -" err2 = error_code__ZMQ_Error__push(err2)\n" -" return val1, err2\n" -"end\n" -"\n" -"-- temp. values for 'events' function.\n" -"local events_tmp = ffi.new('uint32_t[1]', 0)\n" -"local events_tmp_size = ffi.sizeof('uint32_t')\n" -"local events_tmp_len = ffi.new('size_t[1]', events_tmp_size)\n" -"local ZMQ_EVENTS = _M.EVENTS\n" -"\n" -"-- method: events\n" -"function _meth.ZMQ_Socket.events(self)\n" -" \n" -" local events1\n" -" local err2\n" -" events_tmp_len[0] = events_tmp_size\n" -" err2 = C.zmq_getsockopt(self, ZMQ_EVENTS, events_tmp, events_tmp_len);\n" -" events1 = events_tmp[0]\n" -"\n" -" if not (-1 == err2) then\n" -" events1 = events1\n" -" else\n" -" events1 = nil\n" -" end\n" -" err2 = error_code__ZMQ_Error__push(err2)\n" -" return events1, err2\n" +" return val1\n" "end\n" -"\n" "-- method: send_msg\n" "function _meth.ZMQ_Socket.send_msg(self, msg2, flags3)\n" " \n" " \n" " flags3 = flags3 or 0\n" -" local rc_zmq_send1\n" -" rc_zmq_send1 = C.zmq_send(self, msg2, flags3)\n" +" local rc_zmq_sendmsg1 = 0\n" +" rc_zmq_sendmsg1 = zmq_sendmsg(self, msg2, flags3)\n" " -- check for error.\n" -" local rc_zmq_send1_err\n" -" if (-1 == rc_zmq_send1) then\n" -" rc_zmq_send1_err = error_code__ZMQ_Error__push(rc_zmq_send1)\n" -" rc_zmq_send1 = nil\n" -" else\n" -" rc_zmq_send1 = true\n" +" if (-1 == rc_zmq_sendmsg1) then\n" +" return nil, error_code__ZMQ_Error__push(rc_zmq_sendmsg1)\n" " end\n" -" return rc_zmq_send1, rc_zmq_send1_err\n" +" return true\n" "end\n" -"\n" "-- method: send\n" "function _meth.ZMQ_Socket.send(self, data2, flags3)\n" " \n" " local data_len2 = #data2\n" " flags3 = flags3 or 0\n" -" local rc_simple_zmq_send1\n" +" local rc_simple_zmq_send1 = 0\n" " rc_simple_zmq_send1 = C.simple_zmq_send(self, data2, data_len2, flags3)\n" " -- check for error.\n" -" local rc_simple_zmq_send1_err\n" " if (-1 == rc_simple_zmq_send1) then\n" -" rc_simple_zmq_send1_err = error_code__ZMQ_Error__push(rc_simple_zmq_send1)\n" -" rc_simple_zmq_send1 = nil\n" -" else\n" -" rc_simple_zmq_send1 = true\n" +" return nil, error_code__ZMQ_Error__push(rc_simple_zmq_send1)\n" " end\n" -" return rc_simple_zmq_send1, rc_simple_zmq_send1_err\n" +" return true\n" "end\n" -"\n" "-- method: recv_msg\n" "function _meth.ZMQ_Socket.recv_msg(self, msg2, flags3)\n" " \n" " \n" " flags3 = flags3 or 0\n" -" local rc_zmq_recv1\n" -" rc_zmq_recv1 = C.zmq_recv(self, msg2, flags3)\n" +" local rc_zmq_recvmsg1 = 0\n" +" rc_zmq_recvmsg1 = zmq_recvmsg(self, msg2, flags3)\n" " -- check for error.\n" -" local rc_zmq_recv1_err\n" -" if (-1 == rc_zmq_recv1) then\n" -" rc_zmq_recv1_err = error_code__ZMQ_Error__push(rc_zmq_recv1)\n" -" rc_zmq_recv1 = nil\n" -" else\n" -" rc_zmq_recv1 = true\n" +" if (-1 == rc_zmq_recvmsg1) then\n" +" return nil, error_code__ZMQ_Error__push(rc_zmq_recvmsg1)\n" " end\n" -" return rc_zmq_recv1, rc_zmq_recv1_err\n" +" return true\n" "end\n" -"\n" "local tmp_msg = ffi.new('zmq_msg_t')\n" "\n" "-- method: recv\n" @@ -1784,8 +1865,8 @@ static const char zmq_ffi_lua_code[] = "local ffi=require\"ffi\"\n" " \n" " flags2 = flags2 or 0\n" " local data_len1 = 0\n" -" local data1\n" -" local err2\n" +" local data1 = NULL\n" +" local err2 = 0\n" " local msg = tmp_msg\n" " -- initialize blank message.\n" " if C.zmq_msg_init(msg) < 0 then\n" @@ -1793,7 +1874,7 @@ static const char zmq_ffi_lua_code[] = "local ffi=require\"ffi\"\n" " end\n" "\n" " -- receive message\n" -" err2 = C.zmq_recv(self, msg, flags2)\n" +" err2 = zmq_recvmsg(self, msg, flags2)\n" " if 0 == err2 then\n" " local data = ffi.string(C.zmq_msg_data(msg), C.zmq_msg_size(msg))\n" " -- close message\n" @@ -1801,1262 +1882,3189 @@ static const char zmq_ffi_lua_code[] = "local ffi=require\"ffi\"\n" " return data\n" " end\n" "\n" -" if not (-1 == err2) then\n" -" data1 = ((nil ~= data1) and ffi.string(data1,data_len1))\n" -" else\n" -" data1 = nil\n" +" if (-1 == err2) then\n" +" return nil,error_code__ZMQ_Error__push(err2)\n" " end\n" -" err2 = error_code__ZMQ_Error__push(err2)\n" " -- close message\n" " C.zmq_msg_close(msg)\n" "\n" -" return data1, err2\n" +" return ((nil ~= data1) and ffi.string(data1,data_len1))\n" "end\n" -"\n" -"ffi.metatype(\"ZMQ_Socket\", _priv.ZMQ_Socket)\n" -"-- End \"ZMQ_Socket\" FFI interface\n" -"\n" -"\n" -"-- Start \"ZMQ_Poller\" FFI interface\n" -"-- method: new\n" -"function _pub.ZMQ_Poller.new(length1)\n" -" length1 = length1 or 10\n" -" local self\n" -" self = ffi.new(\"ZMQ_Poller\")\n" -"\n" -" C.poller_init(self, length1)\n" -" self = obj_type_ZMQ_Poller_push(self)\n" -" return self\n" +" local hwm_value_tmp = ffi.new(\"int[1]\")\n" +"-- method: hwm\n" +"if (VERSION_2_0 or VERSION_3_0) then\n" +"function _meth.ZMQ_Socket.hwm(self)\n" +" \n" +" local value1 = hwm_value_tmp\n" +" local rc_lzmq_socket_hwm2 = 0\n" +" rc_lzmq_socket_hwm2 = C.lzmq_socket_hwm(self, value1)\n" +" if (-1 == rc_lzmq_socket_hwm2) then\n" +" return nil,error_code__ZMQ_Error__push(rc_lzmq_socket_hwm2)\n" +" end\n" +" return value1[0]\n" "end\n" -"\n" -"register_default_constructor(_pub,\"ZMQ_Poller\",_pub.ZMQ_Poller.new)\n" -"-- method: close\n" -"function _meth.ZMQ_Poller.close(self)\n" -" local self = obj_type_ZMQ_Poller_delete(self)\n" -" if not self then return end\n" -" C.poller_cleanup(self)\n" -" return \n" "end\n" -"\n" -"_priv.ZMQ_Poller.__gc = _meth.ZMQ_Poller.close\n" -"-- method: add\n" -"function _meth.ZMQ_Poller.add(self, sock2, events3)\n" +"-- method: set_hwm\n" +"if (VERSION_2_0 or VERSION_3_0) then\n" +"function _meth.ZMQ_Socket.set_hwm(self, value2)\n" " \n" " \n" -" local idx1\n" -" local fd = 0\n" -" local sock_type = type(sock2)\n" -" if sock_type == 'cdata' then\n" -" sock = obj_type_ZMQ_Socket_check(sock2)\n" -" elseif sock_type == 'number' then\n" -" fd = sock2\n" -" else\n" -" error(\"expected number or ZMQ_Socket\")\n" -" end\n" -" idx1 = C.poller_get_free_item(self)\n" -" local item = self.items[idx1]\n" -" item.socket = sock\n" -" item.fd = fd\n" -" item.events = events3\n" -"\n" -" idx1 = idx1\n" -" return idx1\n" +" local rc_lzmq_socket_set_hwm1 = 0\n" +" rc_lzmq_socket_set_hwm1 = C.lzmq_socket_set_hwm(self, value2)\n" +" -- check for error.\n" +" if (-1 == rc_lzmq_socket_set_hwm1) then\n" +" return nil, error_code__ZMQ_Error__push(rc_lzmq_socket_set_hwm1)\n" +" end\n" +" return true\n" "end\n" -"\n" -"-- method: modify\n" -"function _meth.ZMQ_Poller.modify(self, sock2, events3)\n" +"end\n" +" local swap_value_tmp = ffi.new(\"int[1]\")\n" +"-- method: swap\n" +"if (VERSION_2_0) then\n" +"function _meth.ZMQ_Socket.swap(self)\n" " \n" +" local value1 = swap_value_tmp\n" +" local rc_lzmq_socket_swap2 = 0\n" +" rc_lzmq_socket_swap2 = C.lzmq_socket_swap(self, value1)\n" +" if (-1 == rc_lzmq_socket_swap2) then\n" +" return nil,error_code__ZMQ_Error__push(rc_lzmq_socket_swap2)\n" +" end\n" +" return value1[0]\n" +"end\n" +"end\n" +"-- method: set_swap\n" +"if (VERSION_2_0) then\n" +"function _meth.ZMQ_Socket.set_swap(self, value2)\n" " \n" -" local idx1\n" -" local fd = 0\n" -" local sock_type = type(sock2)\n" -" if sock_type == 'cdata' then\n" -" sock = obj_type_ZMQ_Socket_check(sock2)\n" -" -- find sock in items list.\n" -" idx1 = C.poller_find_sock_item(self, sock)\n" -" elseif sock_type == 'number' then\n" -" fd = sock2\n" -" -- find fd in items list.\n" -" idx1 = C.poller_find_fd_item(self, fd);\n" -" else\n" -" error(\"expected number or ZMQ_Socket\")\n" -" end\n" -" if events3 ~= 0 then\n" -" local item = self.items[idx1]\n" -" item.socket = sock\n" -" item.fd = fd\n" -" item.events = events3\n" -" else\n" -" C.poller_remove_item(self, idx1)\n" -" end\n" -"\n" -" idx1 = idx1\n" -" return idx1\n" +" \n" +" local rc_lzmq_socket_set_swap1 = 0\n" +" rc_lzmq_socket_set_swap1 = C.lzmq_socket_set_swap(self, value2)\n" +" -- check for error.\n" +" if (-1 == rc_lzmq_socket_set_swap1) then\n" +" return nil, error_code__ZMQ_Error__push(rc_lzmq_socket_set_swap1)\n" +" end\n" +" return true\n" "end\n" -"\n" -"-- method: remove\n" -"function _meth.ZMQ_Poller.remove(self, sock2)\n" +"end\n" +" local affinity_value_tmp = ffi.new(\"uint64_t[1]\")\n" +"-- method: affinity\n" +"if (VERSION_2_0 or VERSION_3_0) then\n" +"function _meth.ZMQ_Socket.affinity(self)\n" " \n" -" local idx1\n" -" local fd = 0\n" -" local sock_type = type(sock2)\n" -" if sock_type == 'cdata' then\n" -" sock = obj_type_ZMQ_Socket_check(sock2)\n" -" -- find sock in items list.\n" -" idx1 = C.poller_find_sock_item(self, sock)\n" -" elseif sock_type == 'number' then\n" -" fd = sock2\n" -" -- find fd in items list.\n" -" idx1 = C.poller_find_fd_item(self, fd);\n" -" else\n" -" error(\"expected number or ZMQ_Socket\")\n" -" end\n" -" if idx1 >= 0 then\n" -" C.poller_remove_item(self, idx1)\n" -" end\n" -"\n" -" idx1 = idx1\n" -" return idx1\n" +" local value1 = affinity_value_tmp\n" +" local rc_lzmq_socket_affinity2 = 0\n" +" rc_lzmq_socket_affinity2 = C.lzmq_socket_affinity(self, value1)\n" +" if (-1 == rc_lzmq_socket_affinity2) then\n" +" return nil,error_code__ZMQ_Error__push(rc_lzmq_socket_affinity2)\n" +" end\n" +" return value1[0]\n" "end\n" -"\n" -"-- method: poll\n" -"function _meth.ZMQ_Poller.poll(self, timeout2)\n" +"end\n" +"-- method: set_affinity\n" +"if (VERSION_2_0 or VERSION_3_0) then\n" +"function _meth.ZMQ_Socket.set_affinity(self, value2)\n" " \n" " \n" -" local count1\n" -" local err2\n" -" -- poll for events\n" -" err2 = C.poller_poll(self, timeout2)\n" -" if(err2 > 0) then\n" -" self.next = 0\n" -" count1 = err2\n" -" else\n" -" self.next = -1\n" -" count1 = 0\n" -" end\n" -"\n" -" if not (-1 == err2) then\n" -" count1 = count1\n" -" else\n" -" count1 = nil\n" +" local rc_lzmq_socket_set_affinity1 = 0\n" +" rc_lzmq_socket_set_affinity1 = C.lzmq_socket_set_affinity(self, value2)\n" +" -- check for error.\n" +" if (-1 == rc_lzmq_socket_set_affinity1) then\n" +" return nil, error_code__ZMQ_Error__push(rc_lzmq_socket_set_affinity1)\n" " end\n" -" err2 = error_code__ZMQ_Error__push(err2)\n" -" return count1, err2\n" +" return true\n" "end\n" -"\n" -" local next_revents_idx_revents_tmp = ffi.new(\"int[1]\")\n" -"-- method: next_revents_idx\n" -"function _meth.ZMQ_Poller.next_revents_idx(self)\n" -" \n" -" local idx1\n" -" local revents2 = next_revents_idx_revents_tmp\n" -" idx1 = C.poller_next_revents(self, revents2)\n" -" idx1 = idx1\n" -" revents2 = revents2\n" -"[0] return idx1, revents2\n" "end\n" -"\n" -"-- method: count\n" -"function _meth.ZMQ_Poller.count(self)\n" +"-- method: identity\n" +"if (VERSION_2_0 or VERSION_3_0) then\n" +"function _meth.ZMQ_Socket.identity(self)\n" " \n" -" local count1\n" -" count1 = self.count;\n" -"\n" -" count1 = count1\n" -" return count1\n" +" local value_len1 = 0\n" +" local value1 = NULL\n" +" local rc_lzmq_socket_identity2 = 0\n" +" rc_lzmq_socket_identity2 = C.lzmq_socket_identity(self, value1, value_len1)\n" +" if (-1 == rc_lzmq_socket_identity2) then\n" +" return nil,error_code__ZMQ_Error__push(rc_lzmq_socket_identity2)\n" +" end\n" +" return ((nil ~= value1) and ffi.string(value1,value_len1))\n" "end\n" -"\n" -"ffi.metatype(\"ZMQ_Poller\", _priv.ZMQ_Poller)\n" -"-- End \"ZMQ_Poller\" FFI interface\n" -"\n" -"\n" -"-- Start \"ZMQ_Ctx\" FFI interface\n" -"-- method: term\n" -"function _meth.ZMQ_Ctx.term(self)\n" -" local self,this_flags1 = obj_type_ZMQ_Ctx_delete(self)\n" -" if not self then return end\n" -" local rc_zmq_term1\n" -" rc_zmq_term1 = C.zmq_term(self)\n" +"end\n" +"-- method: set_identity\n" +"if (VERSION_2_0 or VERSION_3_0) then\n" +"function _meth.ZMQ_Socket.set_identity(self, value2)\n" +" \n" +" local value_len2 = #value2\n" +" local rc_lzmq_socket_set_identity1 = 0\n" +" rc_lzmq_socket_set_identity1 = C.lzmq_socket_set_identity(self, value2, value_len2)\n" " -- check for error.\n" -" local rc_zmq_term1_err\n" -" if (-1 == rc_zmq_term1) then\n" -" rc_zmq_term1_err = error_code__ZMQ_Error__push(rc_zmq_term1)\n" -" rc_zmq_term1 = nil\n" -" else\n" -" rc_zmq_term1 = true\n" +" if (-1 == rc_lzmq_socket_set_identity1) then\n" +" return nil, error_code__ZMQ_Error__push(rc_lzmq_socket_set_identity1)\n" " end\n" -" return rc_zmq_term1, rc_zmq_term1_err\n" +" return true\n" "end\n" -"\n" -"_priv.ZMQ_Ctx.__gc = _meth.ZMQ_Ctx.term\n" -"-- method: socket\n" -"function _meth.ZMQ_Ctx.socket(self, type2)\n" -" \n" +"end\n" +"-- method: subscribe\n" +"if (VERSION_2_0 or VERSION_3_0) then\n" +"function _meth.ZMQ_Socket.subscribe(self, value2)\n" " \n" -" local rc_zmq_socket_flags1 = OBJ_UDATA_FLAG_OWN\n" -" local rc_zmq_socket1\n" -" rc_zmq_socket1 = C.zmq_socket(self, type2)\n" -" local rc_zmq_socket1_err\n" -" if (nil == rc_zmq_socket1) then\n" -" rc_zmq_socket1_err = get_zmq_strerror()\n" -" else\n" -" rc_zmq_socket1 = obj_type_ZMQ_Socket_push(rc_zmq_socket1, rc_zmq_socket_flags1)\n" +" local value_len2 = #value2\n" +" local rc_lzmq_socket_subscribe1 = 0\n" +" rc_lzmq_socket_subscribe1 = C.lzmq_socket_subscribe(self, value2, value_len2)\n" +" -- check for error.\n" +" if (-1 == rc_lzmq_socket_subscribe1) then\n" +" return nil, error_code__ZMQ_Error__push(rc_lzmq_socket_subscribe1)\n" " end\n" -" return rc_zmq_socket1, rc_zmq_socket1_err\n" +" return true\n" "end\n" -"\n" -"ffi.metatype(\"ZMQ_Ctx\", _priv.ZMQ_Ctx)\n" -"-- End \"ZMQ_Ctx\" FFI interface\n" -"\n" -"\n" -"-- Start \"ZMQ_StopWatch\" FFI interface\n" -"-- method: start\n" -"function _pub.ZMQ_StopWatch.start()\n" -" local this_flags1 = OBJ_UDATA_FLAG_OWN\n" -" local self\n" -" self = C.zmq_stopwatch_start()\n" -" self = obj_type_ZMQ_StopWatch_push(self, this_flags1)\n" -" return self\n" "end\n" -"\n" -"register_default_constructor(_pub,\"ZMQ_StopWatch\",_pub.ZMQ_StopWatch.start)\n" -"-- method: stop\n" -"function _meth.ZMQ_StopWatch.stop(self)\n" -" local self,this_flags1 = obj_type_ZMQ_StopWatch_delete(self)\n" -" if not self then return end\n" -" local usecs1\n" -" usecs1 = C.zmq_stopwatch_stop(self)\n" -" usecs1 = tonumber(usecs1)\n" -" return usecs1\n" +"-- method: unsubscribe\n" +"if (VERSION_2_0 or VERSION_3_0) then\n" +"function _meth.ZMQ_Socket.unsubscribe(self, value2)\n" +" \n" +" local value_len2 = #value2\n" +" local rc_lzmq_socket_unsubscribe1 = 0\n" +" rc_lzmq_socket_unsubscribe1 = C.lzmq_socket_unsubscribe(self, value2, value_len2)\n" +" -- check for error.\n" +" if (-1 == rc_lzmq_socket_unsubscribe1) then\n" +" return nil, error_code__ZMQ_Error__push(rc_lzmq_socket_unsubscribe1)\n" +" end\n" +" return true\n" "end\n" -"\n" -"_priv.ZMQ_StopWatch.__gc = _meth.ZMQ_StopWatch.stop\n" -"ffi.metatype(\"ZMQ_StopWatch\", _priv.ZMQ_StopWatch)\n" -"-- End \"ZMQ_StopWatch\" FFI interface\n" -"\n" -"-- method: init\n" -"function _pub.zmq.init(io_threads1)\n" +"end\n" +" local rate_value_tmp = ffi.new(\"int[1]\")\n" +"-- method: rate\n" +"if (VERSION_2_0 or VERSION_3_0) then\n" +"function _meth.ZMQ_Socket.rate(self)\n" " \n" -" local rc_zmq_init_flags1 = OBJ_UDATA_FLAG_OWN\n" -" local rc_zmq_init1\n" -" rc_zmq_init1 = C.zmq_init(io_threads1)\n" -" local rc_zmq_init1_err\n" -" if (nil == rc_zmq_init1) then\n" -" rc_zmq_init1_err = get_zmq_strerror()\n" -" else\n" -" rc_zmq_init1 = obj_type_ZMQ_Ctx_push(rc_zmq_init1, rc_zmq_init_flags1)\n" +" local value1 = rate_value_tmp\n" +" local rc_lzmq_socket_rate2 = 0\n" +" rc_lzmq_socket_rate2 = C.lzmq_socket_rate(self, value1)\n" +" if (-1 == rc_lzmq_socket_rate2) then\n" +" return nil,error_code__ZMQ_Error__push(rc_lzmq_socket_rate2)\n" " end\n" -" return rc_zmq_init1, rc_zmq_init1_err\n" +" return value1[0]\n" "end\n" -"\n" -"-- method: init_ctx\n" -"function _pub.zmq.init_ctx(ptr1)\n" -" local ctx1\n" -" local p_type = type(ptr1)\n" -" if p_type == 'userdata' then\n" -" ctx1 = ffi.cast('ZMQ_Ctx *', ptr1);\n" -" elseif p_type == 'cdata' and ffi.istype('void *', ptr1) then\n" -" ctx1 = ffi.cast('ZMQ_Ctx *', ptr1);\n" -" else\n" -" return error(\"expected lightuserdata/cdata\");\n" -" end\n" -"\n" -" local ctx1_err\n" -" if (nil == ctx1) then\n" -" ctx1_err = get_zmq_strerror()\n" -" else\n" -" ctx1 = obj_type_ZMQ_Ctx_push(ctx1, 0)\n" +"end\n" +"-- method: set_rate\n" +"if (VERSION_2_0 or VERSION_3_0) then\n" +"function _meth.ZMQ_Socket.set_rate(self, value2)\n" +" \n" +" \n" +" local rc_lzmq_socket_set_rate1 = 0\n" +" rc_lzmq_socket_set_rate1 = C.lzmq_socket_set_rate(self, value2)\n" +" -- check for error.\n" +" if (-1 == rc_lzmq_socket_set_rate1) then\n" +" return nil, error_code__ZMQ_Error__push(rc_lzmq_socket_set_rate1)\n" " end\n" -" return ctx1, ctx1_err\n" +" return true\n" "end\n" -"\n" -"-- method: device\n" -"function _pub.zmq.device(device1, insock2, outsock3)\n" +"end\n" +" local recovery_ivl_value_tmp = ffi.new(\"int[1]\")\n" +"-- method: recovery_ivl\n" +"if (VERSION_2_0 or VERSION_3_0) then\n" +"function _meth.ZMQ_Socket.recovery_ivl(self)\n" " \n" +" local value1 = recovery_ivl_value_tmp\n" +" local rc_lzmq_socket_recovery_ivl2 = 0\n" +" rc_lzmq_socket_recovery_ivl2 = C.lzmq_socket_recovery_ivl(self, value1)\n" +" if (-1 == rc_lzmq_socket_recovery_ivl2) then\n" +" return nil,error_code__ZMQ_Error__push(rc_lzmq_socket_recovery_ivl2)\n" +" end\n" +" return value1[0]\n" +"end\n" +"end\n" +"-- method: set_recovery_ivl\n" +"if (VERSION_2_0 or VERSION_3_0) then\n" +"function _meth.ZMQ_Socket.set_recovery_ivl(self, value2)\n" " \n" " \n" -" local rc_zmq_device1\n" -" rc_zmq_device1 = C.zmq_device(device1, insock2, outsock3)\n" +" local rc_lzmq_socket_set_recovery_ivl1 = 0\n" +" rc_lzmq_socket_set_recovery_ivl1 = C.lzmq_socket_set_recovery_ivl(self, value2)\n" " -- check for error.\n" -" local rc_zmq_device1_err\n" -" if (-1 == rc_zmq_device1) then\n" -" rc_zmq_device1_err = error_code__ZMQ_Error__push(rc_zmq_device1)\n" -" rc_zmq_device1 = nil\n" -" else\n" -" rc_zmq_device1 = true\n" +" if (-1 == rc_lzmq_socket_set_recovery_ivl1) then\n" +" return nil, error_code__ZMQ_Error__push(rc_lzmq_socket_set_recovery_ivl1)\n" " end\n" -" return rc_zmq_device1, rc_zmq_device1_err\n" +" return true\n" "end\n" -"\n" -"-- method: stopwatch_start\n" -"function _pub.zmq.stopwatch_start()\n" -" local rc_zmq_stopwatch_start_flags1 = OBJ_UDATA_FLAG_OWN\n" -" local rc_zmq_stopwatch_start1\n" -" rc_zmq_stopwatch_start1 = C.zmq_stopwatch_start()\n" -" rc_zmq_stopwatch_start1 = obj_type_ZMQ_StopWatch_push(rc_zmq_stopwatch_start1, rc_zmq_stopwatch_start_flags1)\n" -" return rc_zmq_stopwatch_start1\n" "end\n" -"\n" -"-- method: sleep\n" -"function _pub.zmq.sleep(seconds_1)\n" +" local mcast_loop_value_tmp = ffi.new(\"int[1]\")\n" +"-- method: mcast_loop\n" +"if (VERSION_2_0 or VERSION_3_0) then\n" +"function _meth.ZMQ_Socket.mcast_loop(self)\n" " \n" -" C.zmq_sleep(seconds_1)\n" -" return \n" +" local value1 = mcast_loop_value_tmp\n" +" local rc_lzmq_socket_mcast_loop2 = 0\n" +" rc_lzmq_socket_mcast_loop2 = C.lzmq_socket_mcast_loop(self, value1)\n" +" if (-1 == rc_lzmq_socket_mcast_loop2) then\n" +" return nil,error_code__ZMQ_Error__push(rc_lzmq_socket_mcast_loop2)\n" +" end\n" +" return value1[0]\n" +"end\n" +"end\n" +"-- method: set_mcast_loop\n" +"if (VERSION_2_0 or VERSION_3_0) then\n" +"function _meth.ZMQ_Socket.set_mcast_loop(self, value2)\n" +" \n" +" \n" +" local rc_lzmq_socket_set_mcast_loop1 = 0\n" +" rc_lzmq_socket_set_mcast_loop1 = C.lzmq_socket_set_mcast_loop(self, value2)\n" +" -- check for error.\n" +" if (-1 == rc_lzmq_socket_set_mcast_loop1) then\n" +" return nil, error_code__ZMQ_Error__push(rc_lzmq_socket_set_mcast_loop1)\n" +" end\n" +" return true\n" +"end\n" +"end\n" +" local sndbuf_value_tmp = ffi.new(\"int[1]\")\n" +"-- method: sndbuf\n" +"if (VERSION_2_0 or VERSION_3_0) then\n" +"function _meth.ZMQ_Socket.sndbuf(self)\n" +" \n" +" local value1 = sndbuf_value_tmp\n" +" local rc_lzmq_socket_sndbuf2 = 0\n" +" rc_lzmq_socket_sndbuf2 = C.lzmq_socket_sndbuf(self, value1)\n" +" if (-1 == rc_lzmq_socket_sndbuf2) then\n" +" return nil,error_code__ZMQ_Error__push(rc_lzmq_socket_sndbuf2)\n" +" end\n" +" return value1[0]\n" +"end\n" +"end\n" +"-- method: set_sndbuf\n" +"if (VERSION_2_0 or VERSION_3_0) then\n" +"function _meth.ZMQ_Socket.set_sndbuf(self, value2)\n" +" \n" +" \n" +" local rc_lzmq_socket_set_sndbuf1 = 0\n" +" rc_lzmq_socket_set_sndbuf1 = C.lzmq_socket_set_sndbuf(self, value2)\n" +" -- check for error.\n" +" if (-1 == rc_lzmq_socket_set_sndbuf1) then\n" +" return nil, error_code__ZMQ_Error__push(rc_lzmq_socket_set_sndbuf1)\n" +" end\n" +" return true\n" +"end\n" +"end\n" +" local rcvbuf_value_tmp = ffi.new(\"int[1]\")\n" +"-- method: rcvbuf\n" +"if (VERSION_2_0 or VERSION_3_0) then\n" +"function _meth.ZMQ_Socket.rcvbuf(self)\n" +" \n" +" local value1 = rcvbuf_value_tmp\n" +" local rc_lzmq_socket_rcvbuf2 = 0\n" +" rc_lzmq_socket_rcvbuf2 = C.lzmq_socket_rcvbuf(self, value1)\n" +" if (-1 == rc_lzmq_socket_rcvbuf2) then\n" +" return nil,error_code__ZMQ_Error__push(rc_lzmq_socket_rcvbuf2)\n" +" end\n" +" return value1[0]\n" +"end\n" +"end\n" +"-- method: set_rcvbuf\n" +"if (VERSION_2_0 or VERSION_3_0) then\n" +"function _meth.ZMQ_Socket.set_rcvbuf(self, value2)\n" +" \n" +" \n" +" local rc_lzmq_socket_set_rcvbuf1 = 0\n" +" rc_lzmq_socket_set_rcvbuf1 = C.lzmq_socket_set_rcvbuf(self, value2)\n" +" -- check for error.\n" +" if (-1 == rc_lzmq_socket_set_rcvbuf1) then\n" +" return nil, error_code__ZMQ_Error__push(rc_lzmq_socket_set_rcvbuf1)\n" +" end\n" +" return true\n" +"end\n" +"end\n" +" local rcvmore_value_tmp = ffi.new(\"int[1]\")\n" +"-- method: rcvmore\n" +"if (VERSION_2_0 or VERSION_3_0) then\n" +"function _meth.ZMQ_Socket.rcvmore(self)\n" +" \n" +" local value1 = rcvmore_value_tmp\n" +" local rc_lzmq_socket_rcvmore2 = 0\n" +" rc_lzmq_socket_rcvmore2 = C.lzmq_socket_rcvmore(self, value1)\n" +" if (-1 == rc_lzmq_socket_rcvmore2) then\n" +" return nil,error_code__ZMQ_Error__push(rc_lzmq_socket_rcvmore2)\n" +" end\n" +" return value1[0]\n" +"end\n" +"end\n" +" local fd_value_tmp = ffi.new(\"int[1]\")\n" +"-- method: fd\n" +"if (VERSION_2_1 or VERSION_3_0) then\n" +"function _meth.ZMQ_Socket.fd(self)\n" +" \n" +" local value1 = fd_value_tmp\n" +" local rc_lzmq_socket_fd2 = 0\n" +" rc_lzmq_socket_fd2 = C.lzmq_socket_fd(self, value1)\n" +" if (-1 == rc_lzmq_socket_fd2) then\n" +" return nil,error_code__ZMQ_Error__push(rc_lzmq_socket_fd2)\n" +" end\n" +" return value1[0]\n" +"end\n" +"end\n" +" local events_value_tmp = ffi.new(\"int[1]\")\n" +"-- method: events\n" +"if (VERSION_2_1 or VERSION_3_0) then\n" +"function _meth.ZMQ_Socket.events(self)\n" +" \n" +" local value1 = events_value_tmp\n" +" local rc_lzmq_socket_events2 = 0\n" +" rc_lzmq_socket_events2 = C.lzmq_socket_events(self, value1)\n" +" if (-1 == rc_lzmq_socket_events2) then\n" +" return nil,error_code__ZMQ_Error__push(rc_lzmq_socket_events2)\n" +" end\n" +" return value1[0]\n" +"end\n" +"end\n" +" local type_value_tmp = ffi.new(\"int[1]\")\n" +"-- method: type\n" +"if (VERSION_2_1 or VERSION_3_0) then\n" +"function _meth.ZMQ_Socket.type(self)\n" +" \n" +" local value1 = type_value_tmp\n" +" local rc_lzmq_socket_type2 = 0\n" +" rc_lzmq_socket_type2 = C.lzmq_socket_type(self, value1)\n" +" if (-1 == rc_lzmq_socket_type2) then\n" +" return nil,error_code__ZMQ_Error__push(rc_lzmq_socket_type2)\n" +" end\n" +" return value1[0]\n" +"end\n" +"end\n" +" local linger_value_tmp = ffi.new(\"int[1]\")\n" +"-- method: linger\n" +"if (VERSION_2_1 or VERSION_3_0) then\n" +"function _meth.ZMQ_Socket.linger(self)\n" +" \n" +" local value1 = linger_value_tmp\n" +" local rc_lzmq_socket_linger2 = 0\n" +" rc_lzmq_socket_linger2 = C.lzmq_socket_linger(self, value1)\n" +" if (-1 == rc_lzmq_socket_linger2) then\n" +" return nil,error_code__ZMQ_Error__push(rc_lzmq_socket_linger2)\n" +" end\n" +" return value1[0]\n" +"end\n" +"end\n" +"-- method: set_linger\n" +"if (VERSION_2_1 or VERSION_3_0) then\n" +"function _meth.ZMQ_Socket.set_linger(self, value2)\n" +" \n" +" \n" +" local rc_lzmq_socket_set_linger1 = 0\n" +" rc_lzmq_socket_set_linger1 = C.lzmq_socket_set_linger(self, value2)\n" +" -- check for error.\n" +" if (-1 == rc_lzmq_socket_set_linger1) then\n" +" return nil, error_code__ZMQ_Error__push(rc_lzmq_socket_set_linger1)\n" +" end\n" +" return true\n" +"end\n" +"end\n" +" local reconnect_ivl_value_tmp = ffi.new(\"int[1]\")\n" +"-- method: reconnect_ivl\n" +"if (VERSION_2_1 or VERSION_3_0) then\n" +"function _meth.ZMQ_Socket.reconnect_ivl(self)\n" +" \n" +" local value1 = reconnect_ivl_value_tmp\n" +" local rc_lzmq_socket_reconnect_ivl2 = 0\n" +" rc_lzmq_socket_reconnect_ivl2 = C.lzmq_socket_reconnect_ivl(self, value1)\n" +" if (-1 == rc_lzmq_socket_reconnect_ivl2) then\n" +" return nil,error_code__ZMQ_Error__push(rc_lzmq_socket_reconnect_ivl2)\n" +" end\n" +" return value1[0]\n" "end\n" +"end\n" +"-- method: set_reconnect_ivl\n" +"if (VERSION_2_1 or VERSION_3_0) then\n" +"function _meth.ZMQ_Socket.set_reconnect_ivl(self, value2)\n" +" \n" +" \n" +" local rc_lzmq_socket_set_reconnect_ivl1 = 0\n" +" rc_lzmq_socket_set_reconnect_ivl1 = C.lzmq_socket_set_reconnect_ivl(self, value2)\n" +" -- check for error.\n" +" if (-1 == rc_lzmq_socket_set_reconnect_ivl1) then\n" +" return nil, error_code__ZMQ_Error__push(rc_lzmq_socket_set_reconnect_ivl1)\n" +" end\n" +" return true\n" +"end\n" +"end\n" +" local backlog_value_tmp = ffi.new(\"int[1]\")\n" +"-- method: backlog\n" +"if (VERSION_2_1 or VERSION_3_0) then\n" +"function _meth.ZMQ_Socket.backlog(self)\n" +" \n" +" local value1 = backlog_value_tmp\n" +" local rc_lzmq_socket_backlog2 = 0\n" +" rc_lzmq_socket_backlog2 = C.lzmq_socket_backlog(self, value1)\n" +" if (-1 == rc_lzmq_socket_backlog2) then\n" +" return nil,error_code__ZMQ_Error__push(rc_lzmq_socket_backlog2)\n" +" end\n" +" return value1[0]\n" +"end\n" +"end\n" +"-- method: set_backlog\n" +"if (VERSION_2_1 or VERSION_3_0) then\n" +"function _meth.ZMQ_Socket.set_backlog(self, value2)\n" +" \n" +" \n" +" local rc_lzmq_socket_set_backlog1 = 0\n" +" rc_lzmq_socket_set_backlog1 = C.lzmq_socket_set_backlog(self, value2)\n" +" -- check for error.\n" +" if (-1 == rc_lzmq_socket_set_backlog1) then\n" +" return nil, error_code__ZMQ_Error__push(rc_lzmq_socket_set_backlog1)\n" +" end\n" +" return true\n" +"end\n" +"end\n" +" local recovery_ivl_msec_value_tmp = ffi.new(\"int64_t[1]\")\n" +"-- method: recovery_ivl_msec\n" +"if (VERSION_2_1) then\n" +"function _meth.ZMQ_Socket.recovery_ivl_msec(self)\n" +" \n" +" local value1 = recovery_ivl_msec_value_tmp\n" +" local rc_lzmq_socket_recovery_ivl_msec2 = 0\n" +" rc_lzmq_socket_recovery_ivl_msec2 = C.lzmq_socket_recovery_ivl_msec(self, value1)\n" +" if (-1 == rc_lzmq_socket_recovery_ivl_msec2) then\n" +" return nil,error_code__ZMQ_Error__push(rc_lzmq_socket_recovery_ivl_msec2)\n" +" end\n" +" return value1[0]\n" +"end\n" +"end\n" +"-- method: set_recovery_ivl_msec\n" +"if (VERSION_2_1) then\n" +"function _meth.ZMQ_Socket.set_recovery_ivl_msec(self, value2)\n" +" \n" +" \n" +" local rc_lzmq_socket_set_recovery_ivl_msec1 = 0\n" +" rc_lzmq_socket_set_recovery_ivl_msec1 = C.lzmq_socket_set_recovery_ivl_msec(self, value2)\n" +" -- check for error.\n" +" if (-1 == rc_lzmq_socket_set_recovery_ivl_msec1) then\n" +" return nil, error_code__ZMQ_Error__push(rc_lzmq_socket_set_recovery_ivl_msec1)\n" +" end\n" +" return true\n" +"end\n" +"end\n" +" local reconnect_ivl_max_value_tmp = ffi.new(\"int[1]\")\n" +"-- method: reconnect_ivl_max\n" +"if (VERSION_2_1 or VERSION_3_0) then\n" +"function _meth.ZMQ_Socket.reconnect_ivl_max(self)\n" +" \n" +" local value1 = reconnect_ivl_max_value_tmp\n" +" local rc_lzmq_socket_reconnect_ivl_max2 = 0\n" +" rc_lzmq_socket_reconnect_ivl_max2 = C.lzmq_socket_reconnect_ivl_max(self, value1)\n" +" if (-1 == rc_lzmq_socket_reconnect_ivl_max2) then\n" +" return nil,error_code__ZMQ_Error__push(rc_lzmq_socket_reconnect_ivl_max2)\n" +" end\n" +" return value1[0]\n" +"end\n" +"end\n" +"-- method: set_reconnect_ivl_max\n" +"if (VERSION_2_1 or VERSION_3_0) then\n" +"function _meth.ZMQ_Socket.set_reconnect_ivl_max(self, value2)\n" +" \n" +" \n" +" local rc_lzmq_socket_set_reconnect_ivl_max1 = 0\n" +" rc_lzmq_socket_set_reconnect_ivl_max1 = C.lzmq_socket_set_reconnect_ivl_max(self, value2)\n" +" -- check for error.\n" +" if (-1 == rc_lzmq_socket_set_reconnect_ivl_max1) then\n" +" return nil, error_code__ZMQ_Error__push(rc_lzmq_socket_set_reconnect_ivl_max1)\n" +" end\n" +" return true\n" +"end\n" +"end\n" +" local maxmsgsize_value_tmp = ffi.new(\"int64_t[1]\")\n" +"-- method: maxmsgsize\n" +"if (VERSION_3_0) then\n" +"function _meth.ZMQ_Socket.maxmsgsize(self)\n" +" \n" +" local value1 = maxmsgsize_value_tmp\n" +" local rc_lzmq_socket_maxmsgsize2 = 0\n" +" rc_lzmq_socket_maxmsgsize2 = C.lzmq_socket_maxmsgsize(self, value1)\n" +" if (-1 == rc_lzmq_socket_maxmsgsize2) then\n" +" return nil,error_code__ZMQ_Error__push(rc_lzmq_socket_maxmsgsize2)\n" +" end\n" +" return value1[0]\n" +"end\n" +"end\n" +"-- method: set_maxmsgsize\n" +"if (VERSION_3_0) then\n" +"function _meth.ZMQ_Socket.set_maxmsgsize(self, value2)\n" +" \n" +" \n" +" local rc_lzmq_socket_set_maxmsgsize1 = 0\n" +" rc_lzmq_socket_set_maxmsgsize1 = C.lzmq_socket_set_maxmsgsize(self, value2)\n" +" -- check for error.\n" +" if (-1 == rc_lzmq_socket_set_maxmsgsize1) then\n" +" return nil, error_code__ZMQ_Error__push(rc_lzmq_socket_set_maxmsgsize1)\n" +" end\n" +" return true\n" +"end\n" +"end\n" +" local sndhwm_value_tmp = ffi.new(\"int[1]\")\n" +"-- method: sndhwm\n" +"if (VERSION_3_0) then\n" +"function _meth.ZMQ_Socket.sndhwm(self)\n" +" \n" +" local value1 = sndhwm_value_tmp\n" +" local rc_lzmq_socket_sndhwm2 = 0\n" +" rc_lzmq_socket_sndhwm2 = C.lzmq_socket_sndhwm(self, value1)\n" +" if (-1 == rc_lzmq_socket_sndhwm2) then\n" +" return nil,error_code__ZMQ_Error__push(rc_lzmq_socket_sndhwm2)\n" +" end\n" +" return value1[0]\n" +"end\n" +"end\n" +"-- method: set_sndhwm\n" +"if (VERSION_3_0) then\n" +"function _meth.ZMQ_Socket.set_sndhwm(self, value2)\n" +" \n" +" \n" +" local rc_lzmq_socket_set_sndhwm1 = 0\n" +" rc_lzmq_socket_set_sndhwm1 = C.lzmq_socket_set_sndhwm(self, value2)\n" +" -- check for error.\n" +" if (-1 == rc_lzmq_socket_set_sndhwm1) then\n" +" return nil, error_code__ZMQ_Error__push(rc_lzmq_socket_set_sndhwm1)\n" +" end\n" +" return true\n" +"end\n" +"end\n" +" local rcvhwm_value_tmp = ffi.new(\"int[1]\")\n" +"-- method: rcvhwm\n" +"if (VERSION_3_0) then\n" +"function _meth.ZMQ_Socket.rcvhwm(self)\n" +" \n" +" local value1 = rcvhwm_value_tmp\n" +" local rc_lzmq_socket_rcvhwm2 = 0\n" +" rc_lzmq_socket_rcvhwm2 = C.lzmq_socket_rcvhwm(self, value1)\n" +" if (-1 == rc_lzmq_socket_rcvhwm2) then\n" +" return nil,error_code__ZMQ_Error__push(rc_lzmq_socket_rcvhwm2)\n" +" end\n" +" return value1[0]\n" +"end\n" +"end\n" +"-- method: set_rcvhwm\n" +"if (VERSION_3_0) then\n" +"function _meth.ZMQ_Socket.set_rcvhwm(self, value2)\n" +" \n" +" \n" +" local rc_lzmq_socket_set_rcvhwm1 = 0\n" +" rc_lzmq_socket_set_rcvhwm1 = C.lzmq_socket_set_rcvhwm(self, value2)\n" +" -- check for error.\n" +" if (-1 == rc_lzmq_socket_set_rcvhwm1) then\n" +" return nil, error_code__ZMQ_Error__push(rc_lzmq_socket_set_rcvhwm1)\n" +" end\n" +" return true\n" +"end\n" +"end\n" +" local multicast_hops_value_tmp = ffi.new(\"int[1]\")\n" +"-- method: multicast_hops\n" +"if (VERSION_3_0) then\n" +"function _meth.ZMQ_Socket.multicast_hops(self)\n" +" \n" +" local value1 = multicast_hops_value_tmp\n" +" local rc_lzmq_socket_multicast_hops2 = 0\n" +" rc_lzmq_socket_multicast_hops2 = C.lzmq_socket_multicast_hops(self, value1)\n" +" if (-1 == rc_lzmq_socket_multicast_hops2) then\n" +" return nil,error_code__ZMQ_Error__push(rc_lzmq_socket_multicast_hops2)\n" +" end\n" +" return value1[0]\n" +"end\n" +"end\n" +"-- method: set_multicast_hops\n" +"if (VERSION_3_0) then\n" +"function _meth.ZMQ_Socket.set_multicast_hops(self, value2)\n" +" \n" +" \n" +" local rc_lzmq_socket_set_multicast_hops1 = 0\n" +" rc_lzmq_socket_set_multicast_hops1 = C.lzmq_socket_set_multicast_hops(self, value2)\n" +" -- check for error.\n" +" if (-1 == rc_lzmq_socket_set_multicast_hops1) then\n" +" return nil, error_code__ZMQ_Error__push(rc_lzmq_socket_set_multicast_hops1)\n" +" end\n" +" return true\n" +"end\n" +"end\n" +" local rcvtimeo_value_tmp = ffi.new(\"int[1]\")\n" +"-- method: rcvtimeo\n" +"if (VERSION_3_0) then\n" +"function _meth.ZMQ_Socket.rcvtimeo(self)\n" +" \n" +" local value1 = rcvtimeo_value_tmp\n" +" local rc_lzmq_socket_rcvtimeo2 = 0\n" +" rc_lzmq_socket_rcvtimeo2 = C.lzmq_socket_rcvtimeo(self, value1)\n" +" if (-1 == rc_lzmq_socket_rcvtimeo2) then\n" +" return nil,error_code__ZMQ_Error__push(rc_lzmq_socket_rcvtimeo2)\n" +" end\n" +" return value1[0]\n" +"end\n" +"end\n" +"-- method: set_rcvtimeo\n" +"if (VERSION_3_0) then\n" +"function _meth.ZMQ_Socket.set_rcvtimeo(self, value2)\n" +" \n" +" \n" +" local rc_lzmq_socket_set_rcvtimeo1 = 0\n" +" rc_lzmq_socket_set_rcvtimeo1 = C.lzmq_socket_set_rcvtimeo(self, value2)\n" +" -- check for error.\n" +" if (-1 == rc_lzmq_socket_set_rcvtimeo1) then\n" +" return nil, error_code__ZMQ_Error__push(rc_lzmq_socket_set_rcvtimeo1)\n" +" end\n" +" return true\n" +"end\n" +"end\n" +" local sndtimeo_value_tmp = ffi.new(\"int[1]\")\n" +"-- method: sndtimeo\n" +"if (VERSION_3_0) then\n" +"function _meth.ZMQ_Socket.sndtimeo(self)\n" +" \n" +" local value1 = sndtimeo_value_tmp\n" +" local rc_lzmq_socket_sndtimeo2 = 0\n" +" rc_lzmq_socket_sndtimeo2 = C.lzmq_socket_sndtimeo(self, value1)\n" +" if (-1 == rc_lzmq_socket_sndtimeo2) then\n" +" return nil,error_code__ZMQ_Error__push(rc_lzmq_socket_sndtimeo2)\n" +" end\n" +" return value1[0]\n" +"end\n" +"end\n" +"-- method: set_sndtimeo\n" +"if (VERSION_3_0) then\n" +"function _meth.ZMQ_Socket.set_sndtimeo(self, value2)\n" +" \n" +" \n" +" local rc_lzmq_socket_set_sndtimeo1 = 0\n" +" rc_lzmq_socket_set_sndtimeo1 = C.lzmq_socket_set_sndtimeo(self, value2)\n" +" -- check for error.\n" +" if (-1 == rc_lzmq_socket_set_sndtimeo1) then\n" +" return nil, error_code__ZMQ_Error__push(rc_lzmq_socket_set_sndtimeo1)\n" +" end\n" +" return true\n" +"end\n" +"end\n" +" local rcvlabel_value_tmp = ffi.new(\"int[1]\")\n" +"-- method: rcvlabel\n" +"if (VERSION_3_0) then\n" +"function _meth.ZMQ_Socket.rcvlabel(self)\n" +" \n" +" local value1 = rcvlabel_value_tmp\n" +" local rc_lzmq_socket_rcvlabel2 = 0\n" +" rc_lzmq_socket_rcvlabel2 = C.lzmq_socket_rcvlabel(self, value1)\n" +" if (-1 == rc_lzmq_socket_rcvlabel2) then\n" +" return nil,error_code__ZMQ_Error__push(rc_lzmq_socket_rcvlabel2)\n" +" end\n" +" return value1[0]\n" +"end\n" +"end\n" +"-- method: set_rcvlabel\n" +"if (VERSION_3_0) then\n" +"function _meth.ZMQ_Socket.set_rcvlabel(self, value2)\n" +" \n" +" \n" +" local rc_lzmq_socket_set_rcvlabel1 = 0\n" +" rc_lzmq_socket_set_rcvlabel1 = C.lzmq_socket_set_rcvlabel(self, value2)\n" +" -- check for error.\n" +" if (-1 == rc_lzmq_socket_set_rcvlabel1) then\n" +" return nil, error_code__ZMQ_Error__push(rc_lzmq_socket_set_rcvlabel1)\n" +" end\n" +" return true\n" +"end\n" +"end\n" +"ffi.metatype(\"ZMQ_Socket\", _priv.ZMQ_Socket)\n" +"-- End \"ZMQ_Socket\" FFI interface\n" "\n" -""; -static char *zmq_ZErrors_key = "zmq_ZErrors_key"; -/* - * This wrapper function is to make the EAGAIN/ETERM error messages more like - * what is returned by LuaSocket. - */ -static const char *get_zmq_strerror() { - int err = zmq_errno(); - switch(err) { +"\n" +"-- Start \"ZMQ_Poller\" FFI interface\n" +"-- method: new\n" +"function _pub.ZMQ_Poller.new(length1)\n" +" length1 = length1 or 10\n" +" local self = ffi.new(\"ZMQ_Poller\")\n" +" C.poller_init(self, length1)\n" +" return obj_type_ZMQ_Poller_push(self)\n" +"end\n" +"register_default_constructor(_pub,\"ZMQ_Poller\",_pub.ZMQ_Poller.new)\n" +"-- method: close\n" +"function _meth.ZMQ_Poller.close(self)\n" +" local self = obj_type_ZMQ_Poller_delete(self)\n" +" if not self then return end\n" +" C.poller_cleanup(self)\n" +" return \n" +"end\n" +"_priv.ZMQ_Poller.__gc = _meth.ZMQ_Poller.close\n" +"-- method: add\n" +"function _meth.ZMQ_Poller.add(self, sock2, events3)\n" +" \n" +" \n" +" local idx1 = 0\n" +" local fd = 0\n" +" local sock_type = type(sock2)\n" +" if sock_type == 'cdata' then\n" +" sock = obj_type_ZMQ_Socket_check(sock2)\n" +" elseif sock_type == 'number' then\n" +" fd = sock2\n" +" else\n" +" error(\"expected number or ZMQ_Socket\")\n" +" end\n" +" idx1 = C.poller_get_free_item(self)\n" +" local item = self.items[idx1]\n" +" item.socket = sock\n" +" item.fd = fd\n" +" item.events = events3\n" +"\n" +" return idx1\n" +"end\n" +"-- method: modify\n" +"function _meth.ZMQ_Poller.modify(self, sock2, events3)\n" +" \n" +" \n" +" local idx1 = 0\n" +" local fd = 0\n" +" local sock_type = type(sock2)\n" +" if sock_type == 'cdata' then\n" +" sock = obj_type_ZMQ_Socket_check(sock2)\n" +" -- find sock in items list.\n" +" idx1 = C.poller_find_sock_item(self, sock)\n" +" elseif sock_type == 'number' then\n" +" fd = sock2\n" +" -- find fd in items list.\n" +" idx1 = C.poller_find_fd_item(self, fd);\n" +" else\n" +" error(\"expected number or ZMQ_Socket\")\n" +" end\n" +" if events3 ~= 0 then\n" +" local item = self.items[idx1]\n" +" item.socket = sock\n" +" item.fd = fd\n" +" item.events = events3\n" +" else\n" +" C.poller_remove_item(self, idx1)\n" +" end\n" +"\n" +" return idx1\n" +"end\n" +"-- method: remove\n" +"function _meth.ZMQ_Poller.remove(self, sock2)\n" +" \n" +" local idx1 = 0\n" +" local fd = 0\n" +" local sock_type = type(sock2)\n" +" if sock_type == 'cdata' then\n" +" sock = obj_type_ZMQ_Socket_check(sock2)\n" +" -- find sock in items list.\n" +" idx1 = C.poller_find_sock_item(self, sock)\n" +" elseif sock_type == 'number' then\n" +" fd = sock2\n" +" -- find fd in items list.\n" +" idx1 = C.poller_find_fd_item(self, fd);\n" +" else\n" +" error(\"expected number or ZMQ_Socket\")\n" +" end\n" +" if idx1 >= 0 then\n" +" C.poller_remove_item(self, idx1)\n" +" end\n" +"\n" +" return idx1\n" +"end\n" +"-- method: poll\n" +"function _meth.ZMQ_Poller.poll(self, timeout2)\n" +" \n" +" \n" +" local count1 = 0\n" +" local err2 = 0\n" +" -- poll for events\n" +" err2 = C.poller_poll(self, timeout2)\n" +" if(err2 > 0) then\n" +" self.next = 0\n" +" count1 = err2\n" +" else\n" +" self.next = -1\n" +" count1 = 0\n" +" end\n" +"\n" +" if (-1 == err2) then\n" +" return nil,error_code__ZMQ_Error__push(err2)\n" +" end\n" +" return count1\n" +"end\n" +" local next_revents_idx_revents_tmp = ffi.new(\"int[1]\")\n" +"-- method: next_revents_idx\n" +"function _meth.ZMQ_Poller.next_revents_idx(self)\n" +" \n" +" local idx1 = 0\n" +" local revents2 = next_revents_idx_revents_tmp\n" +" idx1 = C.poller_next_revents(self, revents2)\n" +" return idx1, revents2[0]\n" +"end\n" +"-- method: count\n" +"function _meth.ZMQ_Poller.count(self)\n" +" \n" +" local count1 = 0\n" +" count1 = self.count;\n" +"\n" +" return count1\n" +"end\n" +"ffi.metatype(\"ZMQ_Poller\", _priv.ZMQ_Poller)\n" +"-- End \"ZMQ_Poller\" FFI interface\n" +"\n" +"\n" +"-- Start \"ZMQ_Ctx\" FFI interface\n" +"-- method: term\n" +"function _meth.ZMQ_Ctx.term(self)\n" +" local self,this_flags1 = obj_type_ZMQ_Ctx_delete(self)\n" +" if not self then return end\n" +" local rc_zmq_term1 = 0\n" +" rc_zmq_term1 = C.zmq_term(self)\n" +" -- check for error.\n" +" if (-1 == rc_zmq_term1) then\n" +" return nil, error_code__ZMQ_Error__push(rc_zmq_term1)\n" +" end\n" +" return true\n" +"end\n" +"_priv.ZMQ_Ctx.__gc = _meth.ZMQ_Ctx.term\n" +"-- method: socket\n" +"function _meth.ZMQ_Ctx.socket(self, type2)\n" +" \n" +" \n" +" local rc_zmq_socket_flags1 = OBJ_UDATA_FLAG_OWN\n" +" local rc_zmq_socket1\n" +" rc_zmq_socket1 = C.zmq_socket(self, type2)\n" +" if (nil == rc_zmq_socket1) then\n" +" return nil, get_zmq_strerror()\n" +" end\n" +" return obj_type_ZMQ_Socket_push(rc_zmq_socket1, rc_zmq_socket_flags1)\n" +"end\n" +"ffi.metatype(\"ZMQ_Ctx\", _priv.ZMQ_Ctx)\n" +"-- End \"ZMQ_Ctx\" FFI interface\n" +"\n" +"\n" +"-- Start \"ZMQ_StopWatch\" FFI interface\n" +"-- method: start\n" +"function _pub.ZMQ_StopWatch.start()\n" +" local this_flags1 = OBJ_UDATA_FLAG_OWN\n" +" local self\n" +" self = C.zmq_stopwatch_start()\n" +" return obj_type_ZMQ_StopWatch_push(self, this_flags1)\n" +"end\n" +"register_default_constructor(_pub,\"ZMQ_StopWatch\",_pub.ZMQ_StopWatch.start)\n" +"-- method: stop\n" +"function _meth.ZMQ_StopWatch.stop(self)\n" +" local self,this_flags1 = obj_type_ZMQ_StopWatch_delete(self)\n" +" if not self then return end\n" +" local usecs1 = 0\n" +" usecs1 = C.zmq_stopwatch_stop(self)\n" +" return tonumber(usecs1)\n" +"end\n" +"_priv.ZMQ_StopWatch.__gc = _meth.ZMQ_StopWatch.stop\n" +"ffi.metatype(\"ZMQ_StopWatch\", _priv.ZMQ_StopWatch)\n" +"-- End \"ZMQ_StopWatch\" FFI interface\n" +"\n" +"-- method: init\n" +"function _pub.zmq.init(io_threads1)\n" +" \n" +" local rc_zmq_init_flags1 = OBJ_UDATA_FLAG_OWN\n" +" local rc_zmq_init1\n" +" rc_zmq_init1 = C.zmq_init(io_threads1)\n" +" if (nil == rc_zmq_init1) then\n" +" return nil, get_zmq_strerror()\n" +" end\n" +" return obj_type_ZMQ_Ctx_push(rc_zmq_init1, rc_zmq_init_flags1)\n" +"end\n" +"-- method: init_ctx\n" +"function _pub.zmq.init_ctx(ptr1)\n" +" local ctx1\n" +" local p_type = type(ptr1)\n" +" if p_type == 'userdata' then\n" +" ctx1 = ffi.cast('ZMQ_Ctx *', ptr1);\n" +" elseif p_type == 'cdata' and ffi.istype('void *', ptr1) then\n" +" ctx1 = ffi.cast('ZMQ_Ctx *', ptr1);\n" +" else\n" +" return error(\"expected lightuserdata/cdata\");\n" +" end\n" +"\n" +" if (nil == ctx1) then\n" +" return nil, get_zmq_strerror()\n" +" end\n" +" return obj_type_ZMQ_Ctx_push(ctx1, 0)\n" +"end\n" +"-- method: device\n" +"function _pub.zmq.device(device1, insock2, outsock3)\n" +" \n" +" \n" +" \n" +" local rc_zmq_device1 = 0\n" +" rc_zmq_device1 = C.zmq_device(device1, insock2, outsock3)\n" +" -- check for error.\n" +" if (-1 == rc_zmq_device1) then\n" +" return nil, error_code__ZMQ_Error__push(rc_zmq_device1)\n" +" end\n" +" return true\n" +"end\n" +"-- method: stopwatch_start\n" +"function _pub.zmq.stopwatch_start()\n" +" local rc_zmq_stopwatch_start_flags1 = OBJ_UDATA_FLAG_OWN\n" +" local rc_zmq_stopwatch_start1\n" +" rc_zmq_stopwatch_start1 = C.zmq_stopwatch_start()\n" +" return obj_type_ZMQ_StopWatch_push(rc_zmq_stopwatch_start1, rc_zmq_stopwatch_start_flags1)\n" +"end\n" +"-- method: sleep\n" +"function _pub.zmq.sleep(seconds_1)\n" +" \n" +" C.zmq_sleep(seconds_1)\n" +" return \n" +"end\n" +""; +static char *zmq_ZErrors_key = "zmq_ZErrors_key"; +/* + * This wrapper function is to make the EAGAIN/ETERM error messages more like + * what is returned by LuaSocket. + */ +static const char *get_zmq_strerror() { + int err = zmq_errno(); + switch(err) { + case EAGAIN: + return "timeout"; + break; + case EINTR: + return "interrupted"; + break; +#if defined(ETERM) + case ETERM: + return "closed"; + break; +#endif + default: + break; + } + return zmq_strerror(err); +} + + +/* detect zmq version */ +#define VERSION_2_0 1 +#define VERSION_2_1 0 +#define VERSION_3_0 0 +#if defined(ZMQ_VERSION) +# if (ZMQ_VERSION >= ZMQ_MAKE_VERSION(2,1,0)) +# undef VERSION_2_1 +# define VERSION_2_1 1 +# endif +# if (ZMQ_VERSION >= ZMQ_MAKE_VERSION(3,0,0)) +# undef VERSION_2_0 +# define VERSION_2_0 0 +# undef VERSION_3_0 +# define VERSION_3_0 1 +# endif +#endif + +/* detect really old ZeroMQ 2.0.x series. */ +#if !defined(ZMQ_RCVMORE) +# error "Your version of ZeroMQ is too old. Please upgrade to version 2.1 or to the latest 2.0.x" +#endif + +typedef struct ZMQ_Socket ZMQ_Socket; + +#ifdef _WIN32 +#include +typedef SOCKET socket_t; +#else +typedef int socket_t; +#endif + +#if ZMQ_VERSION_MAJOR == 2 +# define zmq_sendmsg zmq_send +# define zmq_recvmsg zmq_recv +#endif + +/* socket option types. */ +#define OPT_TYPE_NONE 0 +#define OPT_TYPE_INT 1 +#define OPT_TYPE_UINT32 2 +#define OPT_TYPE_UINT64 3 +#define OPT_TYPE_INT64 4 +#define OPT_TYPE_BLOB 5 +#define OPT_TYPE_FD 6 + +static const int opt_types[] = { + OPT_TYPE_NONE, /* 0 unused */ +#if VERSION_2_0 +#define VERSION_2_0_MAX_OPT 13 + OPT_TYPE_UINT64, /* 1 ZMQ_HWM */ + OPT_TYPE_NONE, /* 2 unused */ + OPT_TYPE_INT64, /* 3 ZMQ_SWAP */ + OPT_TYPE_UINT64, /* 4 ZMQ_AFFINITY */ + OPT_TYPE_BLOB, /* 5 ZMQ_IDENTITY */ + OPT_TYPE_BLOB, /* 6 ZMQ_SUBSCRIBE */ + OPT_TYPE_BLOB, /* 7 ZMQ_UNSUBSCRIBE */ + OPT_TYPE_INT64, /* 8 ZMQ_RATE */ + OPT_TYPE_INT64, /* 9 ZMQ_RECOVERY_IVL */ + OPT_TYPE_INT64, /* 10 ZMQ_MCAST_LOOP */ + OPT_TYPE_UINT64, /* 11 ZMQ_SNDBUF */ + OPT_TYPE_UINT64, /* 12 ZMQ_RCVBUF */ + OPT_TYPE_INT64, /* 13 ZMQ_RCVMORE */ +#endif /* #if VERSION_2_0 */ +#if VERSION_2_1 +#define VERSION_2_1_MAX_OPT 21 + OPT_TYPE_FD, /* 14 ZMQ_FD */ + OPT_TYPE_UINT32, /* 15 ZMQ_EVENTS */ + OPT_TYPE_INT, /* 16 ZMQ_TYPE */ + OPT_TYPE_INT, /* 17 ZMQ_LINGER */ + OPT_TYPE_INT, /* 18 ZMQ_RECONNECT_IVL */ + OPT_TYPE_INT, /* 19 ZMQ_BACKLOG */ + OPT_TYPE_INT64, /* 20 ZMQ_RECOVERY_IVL_MSEC */ + OPT_TYPE_INT, /* 21 ZMQ_RECONNECT_IVL_MAX */ +#endif /* #if VERSION_2_1 */ +#if VERSION_3_0 +#define VERSION_3_0_MAX_OPT 29 + OPT_TYPE_INT, /* 1 ZMQ_HWM */ + OPT_TYPE_NONE, /* 2 unused */ + OPT_TYPE_NONE, /* 3 unused */ + OPT_TYPE_UINT64, /* 4 ZMQ_AFFINITY */ + OPT_TYPE_BLOB, /* 5 ZMQ_IDENTITY */ + OPT_TYPE_BLOB, /* 6 ZMQ_SUBSCRIBE */ + OPT_TYPE_BLOB, /* 7 ZMQ_UNSUBSCRIBE */ + OPT_TYPE_INT, /* 8 ZMQ_RATE */ + OPT_TYPE_INT, /* 9 ZMQ_RECOVERY_IVL */ + OPT_TYPE_INT, /* 10 ZMQ_MCAST_LOOP */ + OPT_TYPE_INT, /* 11 ZMQ_SNDBUF */ + OPT_TYPE_INT, /* 12 ZMQ_RCVBUF */ + OPT_TYPE_INT, /* 13 ZMQ_RCVMORE */ + OPT_TYPE_FD, /* 14 ZMQ_FD */ + OPT_TYPE_INT, /* 15 ZMQ_EVENTS */ + OPT_TYPE_INT, /* 16 ZMQ_TYPE */ + OPT_TYPE_INT, /* 17 ZMQ_LINGER */ + OPT_TYPE_INT, /* 18 ZMQ_RECONNECT_IVL */ + OPT_TYPE_INT, /* 19 ZMQ_BACKLOG */ + OPT_TYPE_NONE, /* 20 unused */ + OPT_TYPE_INT, /* 21 ZMQ_RECONNECT_IVL_MAX */ + OPT_TYPE_INT64, /* 22 ZMQ_MAXMSGSIZE */ + OPT_TYPE_INT, /* 23 ZMQ_SNDHWM */ + OPT_TYPE_INT, /* 24 ZMQ_RCVHWM */ + OPT_TYPE_INT, /* 25 ZMQ_MULTICAST_HOPS */ + OPT_TYPE_NONE, /* 26 unused */ + OPT_TYPE_INT, /* 27 ZMQ_RCVTIMEO */ + OPT_TYPE_INT, /* 28 ZMQ_SNDTIMEO */ + OPT_TYPE_INT, /* 29 ZMQ_RCVLABEL */ +#endif /* #if VERSION_3_0 */ +#if VERSION_3_0 +# define MAX_OPTS VERSION_3_0_MAX_OPT +#else +# if VERSION_2_1 +# define MAX_OPTS VERSION_2_1_MAX_OPT +# else +# define MAX_OPTS VERSION_2_0_MAX_OPT +# endif +#endif +}; + +#if VERSION_2_0 +ZMQ_Error lzmq_socket_set_hwm(ZMQ_Socket *sock, int value) { + uint64_t val = (uint64_t)value; + return zmq_setsockopt(sock, ZMQ_HWM, &val, sizeof(val)); +} + +ZMQ_Error lzmq_socket_hwm(ZMQ_Socket *sock, int *value) { + uint64_t val; + size_t val_len = sizeof(val); + int rc = zmq_getsockopt(sock, ZMQ_HWM, &val, &val_len); + *value = (int)val; + return rc; +} + +ZMQ_Error lzmq_socket_set_swap(ZMQ_Socket *sock, int value) { + int64_t val = (int64_t)value; + return zmq_setsockopt(sock, ZMQ_SWAP, &val, sizeof(val)); +} + +ZMQ_Error lzmq_socket_swap(ZMQ_Socket *sock, int *value) { + int64_t val; + size_t val_len = sizeof(val); + int rc = zmq_getsockopt(sock, ZMQ_SWAP, &val, &val_len); + *value = (int)val; + return rc; +} + +ZMQ_Error lzmq_socket_set_affinity(ZMQ_Socket *sock, uint64_t value) { + return zmq_setsockopt(sock, ZMQ_AFFINITY, &value, sizeof(value)); +} + +ZMQ_Error lzmq_socket_affinity(ZMQ_Socket *sock, uint64_t *value) { + size_t val_len = sizeof(uint64_t); + return zmq_getsockopt(sock, ZMQ_AFFINITY, value, &val_len); +} + +ZMQ_Error lzmq_socket_set_identity(ZMQ_Socket *sock, const char *value, size_t str_len) { + return zmq_setsockopt(sock, ZMQ_IDENTITY, value, str_len); +} + +ZMQ_Error lzmq_socket_identity(ZMQ_Socket *sock, char *value, size_t *len) { + return zmq_getsockopt(sock, ZMQ_IDENTITY, value, len); +} + +ZMQ_Error lzmq_socket_subscribe(ZMQ_Socket *sock, const char *value, size_t str_len) { + return zmq_setsockopt(sock, ZMQ_SUBSCRIBE, value, str_len); +} + +ZMQ_Error lzmq_socket_unsubscribe(ZMQ_Socket *sock, const char *value, size_t str_len) { + return zmq_setsockopt(sock, ZMQ_UNSUBSCRIBE, value, str_len); +} + +ZMQ_Error lzmq_socket_set_rate(ZMQ_Socket *sock, int value) { + int64_t val = (int64_t)value; + return zmq_setsockopt(sock, ZMQ_RATE, &val, sizeof(val)); +} + +ZMQ_Error lzmq_socket_rate(ZMQ_Socket *sock, int *value) { + int64_t val; + size_t val_len = sizeof(val); + int rc = zmq_getsockopt(sock, ZMQ_RATE, &val, &val_len); + *value = (int)val; + return rc; +} + +ZMQ_Error lzmq_socket_set_recovery_ivl(ZMQ_Socket *sock, int value) { + int64_t val = (int64_t)value; + return zmq_setsockopt(sock, ZMQ_RECOVERY_IVL, &val, sizeof(val)); +} + +ZMQ_Error lzmq_socket_recovery_ivl(ZMQ_Socket *sock, int *value) { + int64_t val; + size_t val_len = sizeof(val); + int rc = zmq_getsockopt(sock, ZMQ_RECOVERY_IVL, &val, &val_len); + *value = (int)val; + return rc; +} + +ZMQ_Error lzmq_socket_set_mcast_loop(ZMQ_Socket *sock, int value) { + int64_t val = (int64_t)value; + return zmq_setsockopt(sock, ZMQ_MCAST_LOOP, &val, sizeof(val)); +} + +ZMQ_Error lzmq_socket_mcast_loop(ZMQ_Socket *sock, int *value) { + int64_t val; + size_t val_len = sizeof(val); + int rc = zmq_getsockopt(sock, ZMQ_MCAST_LOOP, &val, &val_len); + *value = (int)val; + return rc; +} + +ZMQ_Error lzmq_socket_set_sndbuf(ZMQ_Socket *sock, int value) { + uint64_t val = (uint64_t)value; + return zmq_setsockopt(sock, ZMQ_SNDBUF, &val, sizeof(val)); +} + +ZMQ_Error lzmq_socket_sndbuf(ZMQ_Socket *sock, int *value) { + uint64_t val; + size_t val_len = sizeof(val); + int rc = zmq_getsockopt(sock, ZMQ_SNDBUF, &val, &val_len); + *value = (int)val; + return rc; +} + +ZMQ_Error lzmq_socket_set_rcvbuf(ZMQ_Socket *sock, int value) { + uint64_t val = (uint64_t)value; + return zmq_setsockopt(sock, ZMQ_RCVBUF, &val, sizeof(val)); +} + +ZMQ_Error lzmq_socket_rcvbuf(ZMQ_Socket *sock, int *value) { + uint64_t val; + size_t val_len = sizeof(val); + int rc = zmq_getsockopt(sock, ZMQ_RCVBUF, &val, &val_len); + *value = (int)val; + return rc; +} + +ZMQ_Error lzmq_socket_rcvmore(ZMQ_Socket *sock, int *value) { + int64_t val; + size_t val_len = sizeof(val); + int rc = zmq_getsockopt(sock, ZMQ_RCVMORE, &val, &val_len); + *value = (int)val; + return rc; +} + +#endif /* #if VERSION_2_0 */ +#if VERSION_2_1 +ZMQ_Error lzmq_socket_fd(ZMQ_Socket *sock, int *value) { + size_t val_len = sizeof(int); + return zmq_getsockopt(sock, ZMQ_FD, value, &val_len); +} + +ZMQ_Error lzmq_socket_events(ZMQ_Socket *sock, int *value) { + uint32_t val; + size_t val_len = sizeof(val); + int rc = zmq_getsockopt(sock, ZMQ_EVENTS, &val, &val_len); + *value = (int)val; + return rc; +} + +ZMQ_Error lzmq_socket_type(ZMQ_Socket *sock, int *value) { + size_t val_len = sizeof(int); + return zmq_getsockopt(sock, ZMQ_TYPE, value, &val_len); +} + +ZMQ_Error lzmq_socket_set_linger(ZMQ_Socket *sock, int value) { + return zmq_setsockopt(sock, ZMQ_LINGER, &value, sizeof(value)); +} + +ZMQ_Error lzmq_socket_linger(ZMQ_Socket *sock, int *value) { + size_t val_len = sizeof(int); + return zmq_getsockopt(sock, ZMQ_LINGER, value, &val_len); +} + +ZMQ_Error lzmq_socket_set_reconnect_ivl(ZMQ_Socket *sock, int value) { + return zmq_setsockopt(sock, ZMQ_RECONNECT_IVL, &value, sizeof(value)); +} + +ZMQ_Error lzmq_socket_reconnect_ivl(ZMQ_Socket *sock, int *value) { + size_t val_len = sizeof(int); + return zmq_getsockopt(sock, ZMQ_RECONNECT_IVL, value, &val_len); +} + +ZMQ_Error lzmq_socket_set_backlog(ZMQ_Socket *sock, int value) { + return zmq_setsockopt(sock, ZMQ_BACKLOG, &value, sizeof(value)); +} + +ZMQ_Error lzmq_socket_backlog(ZMQ_Socket *sock, int *value) { + size_t val_len = sizeof(int); + return zmq_getsockopt(sock, ZMQ_BACKLOG, value, &val_len); +} + +ZMQ_Error lzmq_socket_set_recovery_ivl_msec(ZMQ_Socket *sock, int64_t value) { + return zmq_setsockopt(sock, ZMQ_RECOVERY_IVL_MSEC, &value, sizeof(value)); +} + +ZMQ_Error lzmq_socket_recovery_ivl_msec(ZMQ_Socket *sock, int64_t *value) { + size_t val_len = sizeof(int64_t); + return zmq_getsockopt(sock, ZMQ_RECOVERY_IVL_MSEC, value, &val_len); +} + +ZMQ_Error lzmq_socket_set_reconnect_ivl_max(ZMQ_Socket *sock, int value) { + return zmq_setsockopt(sock, ZMQ_RECONNECT_IVL_MAX, &value, sizeof(value)); +} + +ZMQ_Error lzmq_socket_reconnect_ivl_max(ZMQ_Socket *sock, int *value) { + size_t val_len = sizeof(int); + return zmq_getsockopt(sock, ZMQ_RECONNECT_IVL_MAX, value, &val_len); +} + +#endif /* #if VERSION_2_1 */ +#if VERSION_3_0 +ZMQ_Error lzmq_socket_set_hwm(ZMQ_Socket *sock, int value) { + int val; + int rc; + val = (int)value; + rc = zmq_setsockopt(sock, ZMQ_SNDHWM, &value, sizeof(value)); + if(-1 == rc) return rc; + val = (int)value; + return zmq_setsockopt(sock, ZMQ_RCVHWM, &value, sizeof(value)); +} +ZMQ_Error lzmq_socket_hwm(ZMQ_Socket *sock, int *value) { + size_t val_len; + int rc; + val_len = sizeof(value); + rc = zmq_getsockopt(sock, ZMQ_SNDHWM, value, &val_len); + if(-1 == rc) return rc; + val_len = sizeof(value); + return zmq_getsockopt(sock, ZMQ_RCVHWM, value, &val_len); +} + +ZMQ_Error lzmq_socket_set_affinity(ZMQ_Socket *sock, uint64_t value) { + return zmq_setsockopt(sock, ZMQ_AFFINITY, &value, sizeof(value)); +} + +ZMQ_Error lzmq_socket_affinity(ZMQ_Socket *sock, uint64_t *value) { + size_t val_len = sizeof(uint64_t); + return zmq_getsockopt(sock, ZMQ_AFFINITY, value, &val_len); +} + +ZMQ_Error lzmq_socket_set_identity(ZMQ_Socket *sock, const char *value, size_t str_len) { + return zmq_setsockopt(sock, ZMQ_IDENTITY, value, str_len); +} + +ZMQ_Error lzmq_socket_identity(ZMQ_Socket *sock, char *value, size_t *len) { + return zmq_getsockopt(sock, ZMQ_IDENTITY, value, len); +} + +ZMQ_Error lzmq_socket_subscribe(ZMQ_Socket *sock, const char *value, size_t str_len) { + return zmq_setsockopt(sock, ZMQ_SUBSCRIBE, value, str_len); +} + +ZMQ_Error lzmq_socket_unsubscribe(ZMQ_Socket *sock, const char *value, size_t str_len) { + return zmq_setsockopt(sock, ZMQ_UNSUBSCRIBE, value, str_len); +} + +ZMQ_Error lzmq_socket_set_rate(ZMQ_Socket *sock, int value) { + return zmq_setsockopt(sock, ZMQ_RATE, &value, sizeof(value)); +} + +ZMQ_Error lzmq_socket_rate(ZMQ_Socket *sock, int *value) { + size_t val_len = sizeof(int); + return zmq_getsockopt(sock, ZMQ_RATE, value, &val_len); +} + +ZMQ_Error lzmq_socket_set_recovery_ivl(ZMQ_Socket *sock, int value) { + return zmq_setsockopt(sock, ZMQ_RECOVERY_IVL, &value, sizeof(value)); +} + +ZMQ_Error lzmq_socket_recovery_ivl(ZMQ_Socket *sock, int *value) { + size_t val_len = sizeof(int); + return zmq_getsockopt(sock, ZMQ_RECOVERY_IVL, value, &val_len); +} + +ZMQ_Error lzmq_socket_set_mcast_loop(ZMQ_Socket *sock, int value) { + return zmq_setsockopt(sock, ZMQ_MCAST_LOOP, &value, sizeof(value)); +} + +ZMQ_Error lzmq_socket_mcast_loop(ZMQ_Socket *sock, int *value) { + size_t val_len = sizeof(int); + return zmq_getsockopt(sock, ZMQ_MCAST_LOOP, value, &val_len); +} + +ZMQ_Error lzmq_socket_set_sndbuf(ZMQ_Socket *sock, int value) { + return zmq_setsockopt(sock, ZMQ_SNDBUF, &value, sizeof(value)); +} + +ZMQ_Error lzmq_socket_sndbuf(ZMQ_Socket *sock, int *value) { + size_t val_len = sizeof(int); + return zmq_getsockopt(sock, ZMQ_SNDBUF, value, &val_len); +} + +ZMQ_Error lzmq_socket_set_rcvbuf(ZMQ_Socket *sock, int value) { + return zmq_setsockopt(sock, ZMQ_RCVBUF, &value, sizeof(value)); +} + +ZMQ_Error lzmq_socket_rcvbuf(ZMQ_Socket *sock, int *value) { + size_t val_len = sizeof(int); + return zmq_getsockopt(sock, ZMQ_RCVBUF, value, &val_len); +} + +ZMQ_Error lzmq_socket_rcvmore(ZMQ_Socket *sock, int *value) { + size_t val_len = sizeof(int); + return zmq_getsockopt(sock, ZMQ_RCVMORE, value, &val_len); +} + +ZMQ_Error lzmq_socket_fd(ZMQ_Socket *sock, int *value) { + size_t val_len = sizeof(int); + return zmq_getsockopt(sock, ZMQ_FD, value, &val_len); +} + +ZMQ_Error lzmq_socket_events(ZMQ_Socket *sock, int *value) { + size_t val_len = sizeof(int); + return zmq_getsockopt(sock, ZMQ_EVENTS, value, &val_len); +} + +ZMQ_Error lzmq_socket_type(ZMQ_Socket *sock, int *value) { + size_t val_len = sizeof(int); + return zmq_getsockopt(sock, ZMQ_TYPE, value, &val_len); +} + +ZMQ_Error lzmq_socket_set_linger(ZMQ_Socket *sock, int value) { + return zmq_setsockopt(sock, ZMQ_LINGER, &value, sizeof(value)); +} + +ZMQ_Error lzmq_socket_linger(ZMQ_Socket *sock, int *value) { + size_t val_len = sizeof(int); + return zmq_getsockopt(sock, ZMQ_LINGER, value, &val_len); +} + +ZMQ_Error lzmq_socket_set_reconnect_ivl(ZMQ_Socket *sock, int value) { + return zmq_setsockopt(sock, ZMQ_RECONNECT_IVL, &value, sizeof(value)); +} + +ZMQ_Error lzmq_socket_reconnect_ivl(ZMQ_Socket *sock, int *value) { + size_t val_len = sizeof(int); + return zmq_getsockopt(sock, ZMQ_RECONNECT_IVL, value, &val_len); +} + +ZMQ_Error lzmq_socket_set_backlog(ZMQ_Socket *sock, int value) { + return zmq_setsockopt(sock, ZMQ_BACKLOG, &value, sizeof(value)); +} + +ZMQ_Error lzmq_socket_backlog(ZMQ_Socket *sock, int *value) { + size_t val_len = sizeof(int); + return zmq_getsockopt(sock, ZMQ_BACKLOG, value, &val_len); +} + +ZMQ_Error lzmq_socket_set_reconnect_ivl_max(ZMQ_Socket *sock, int value) { + return zmq_setsockopt(sock, ZMQ_RECONNECT_IVL_MAX, &value, sizeof(value)); +} + +ZMQ_Error lzmq_socket_reconnect_ivl_max(ZMQ_Socket *sock, int *value) { + size_t val_len = sizeof(int); + return zmq_getsockopt(sock, ZMQ_RECONNECT_IVL_MAX, value, &val_len); +} + +ZMQ_Error lzmq_socket_set_maxmsgsize(ZMQ_Socket *sock, int64_t value) { + return zmq_setsockopt(sock, ZMQ_MAXMSGSIZE, &value, sizeof(value)); +} + +ZMQ_Error lzmq_socket_maxmsgsize(ZMQ_Socket *sock, int64_t *value) { + size_t val_len = sizeof(int64_t); + return zmq_getsockopt(sock, ZMQ_MAXMSGSIZE, value, &val_len); +} + +ZMQ_Error lzmq_socket_set_sndhwm(ZMQ_Socket *sock, int value) { + return zmq_setsockopt(sock, ZMQ_SNDHWM, &value, sizeof(value)); +} + +ZMQ_Error lzmq_socket_sndhwm(ZMQ_Socket *sock, int *value) { + size_t val_len = sizeof(int); + return zmq_getsockopt(sock, ZMQ_SNDHWM, value, &val_len); +} + +ZMQ_Error lzmq_socket_set_rcvhwm(ZMQ_Socket *sock, int value) { + return zmq_setsockopt(sock, ZMQ_RCVHWM, &value, sizeof(value)); +} + +ZMQ_Error lzmq_socket_rcvhwm(ZMQ_Socket *sock, int *value) { + size_t val_len = sizeof(int); + return zmq_getsockopt(sock, ZMQ_RCVHWM, value, &val_len); +} + +ZMQ_Error lzmq_socket_set_multicast_hops(ZMQ_Socket *sock, int value) { + return zmq_setsockopt(sock, ZMQ_MULTICAST_HOPS, &value, sizeof(value)); +} + +ZMQ_Error lzmq_socket_multicast_hops(ZMQ_Socket *sock, int *value) { + size_t val_len = sizeof(int); + return zmq_getsockopt(sock, ZMQ_MULTICAST_HOPS, value, &val_len); +} + +ZMQ_Error lzmq_socket_set_rcvtimeo(ZMQ_Socket *sock, int value) { + return zmq_setsockopt(sock, ZMQ_RCVTIMEO, &value, sizeof(value)); +} + +ZMQ_Error lzmq_socket_rcvtimeo(ZMQ_Socket *sock, int *value) { + size_t val_len = sizeof(int); + return zmq_getsockopt(sock, ZMQ_RCVTIMEO, value, &val_len); +} + +ZMQ_Error lzmq_socket_set_sndtimeo(ZMQ_Socket *sock, int value) { + return zmq_setsockopt(sock, ZMQ_SNDTIMEO, &value, sizeof(value)); +} + +ZMQ_Error lzmq_socket_sndtimeo(ZMQ_Socket *sock, int *value) { + size_t val_len = sizeof(int); + return zmq_getsockopt(sock, ZMQ_SNDTIMEO, value, &val_len); +} + +ZMQ_Error lzmq_socket_set_rcvlabel(ZMQ_Socket *sock, int value) { + return zmq_setsockopt(sock, ZMQ_RCVLABEL, &value, sizeof(value)); +} + +ZMQ_Error lzmq_socket_rcvlabel(ZMQ_Socket *sock, int *value) { + size_t val_len = sizeof(int); + return zmq_getsockopt(sock, ZMQ_RCVLABEL, value, &val_len); +} + +#endif /* #if VERSION_3_0 */ + +ZMQ_Error simple_zmq_send(ZMQ_Socket *sock, const char *data, size_t data_len, int flags) { + ZMQ_Error err; + zmq_msg_t msg; + /* initialize message */ + err = zmq_msg_init_size(&msg, data_len); + if(0 == err) { + /* fill message */ + memcpy(zmq_msg_data(&msg), data, data_len); + /* send message */ + err = zmq_sendmsg(sock, &msg, flags); + /* close message */ + zmq_msg_close(&msg); + } + return err; +} + +struct ZMQ_Poller { + zmq_pollitem_t *items; + int next; + int count; + int free_list; + int len; +}; + + +typedef struct ZMQ_Poller ZMQ_Poller; + +#define FREE_ITEM_EVENTS_TAG ((short)0xFFFF) + +#define ITEM_TO_INDEX(items, item) (item - (items)) + +static int poller_resize_items(ZMQ_Poller *poller, int len) { + int old_len = poller->len; + + /* make sure new length is atleast as large as items count. */ + len = (poller->count <= len) ? len : poller->count; + + /* if the new length is the same as the old length, then don't try to resize. */ + if(old_len == len) return len; + + poller->items = (zmq_pollitem_t *)realloc(poller->items, len * sizeof(zmq_pollitem_t)); + poller->len = len; + if(len > old_len) { + /* clear new space. */ + memset(&(poller->items[old_len]), 0, (len - old_len) * sizeof(zmq_pollitem_t)); + } + return len; +} + +void poller_init(ZMQ_Poller *poller, int length) { + poller->items = (zmq_pollitem_t *)calloc(length, sizeof(zmq_pollitem_t)); + poller->next = -1; + poller->count = 0; + poller->len = length; + poller->free_list = -1; +} + +void poller_cleanup(ZMQ_Poller *poller) { + free(poller->items); + poller->items = NULL; + poller->next = -1; + poller->count = 0; + poller->len = 0; + poller->free_list = -1; +} + +int poller_find_sock_item(ZMQ_Poller *poller, ZMQ_Socket *sock) { + zmq_pollitem_t *items; + int count; + int n; + + /* find ZMQ_Socket */ + items = poller->items; + count = poller->count; + for(n=0; n < count; n++) { + if(items[n].socket == sock) return n; + } + /* not found. */ + return -1; +} + +int poller_find_fd_item(ZMQ_Poller *poller, socket_t fd) { + zmq_pollitem_t *items; + int count; + int n; + + /* find fd */ + items = poller->items; + count = poller->count; + for(n=0; n < count; n++) { + if(items[n].fd == fd) return n; + } + /* not found. */ + return -1; +} + +void poller_remove_item(ZMQ_Poller *poller, int idx) { + zmq_pollitem_t *items; + int free_list; + int count; + + count = poller->count; + /* no item to remove. */ + if(idx >= count || count == 0) return; + + items = poller->items; + free_list = poller->free_list; + + /* link new free slot to head of free list. */ + if(free_list >= 0 && free_list < count) { + /* use socket pointer for free list's 'next' field. */ + items[idx].socket = &(items[free_list]); + } else { + /* free list is empty mark poller slot as the end. */ + items[idx].socket = NULL; + } + poller->free_list = idx; + /* mark poller slot as a free slot. */ + items[idx].events = FREE_ITEM_EVENTS_TAG; + /* clear old revents. */ + items[idx].revents = 0; +} + +int poller_get_free_item(ZMQ_Poller *poller) { + zmq_pollitem_t *curr; + zmq_pollitem_t *next; + int count; + int idx; + + count = poller->count; + idx = poller->free_list; + /* check for a free slot in the free list. */ + if(idx >= 0 && idx < count) { + /* remove free slot from free list. */ + curr = &(poller->items[idx]); + /* valid free slot. */ + assert(curr->events == FREE_ITEM_EVENTS_TAG); + /* is poller the last free slot? */ + next = ((zmq_pollitem_t *)curr->socket); + if(next != NULL) { + /* set next free slot as head of free list. */ + poller->free_list = ITEM_TO_INDEX(poller->items, next); + } else { + /* free list is empty now. */ + poller->free_list = -1; + } + /* clear slot */ + memset(curr, 0, sizeof(zmq_pollitem_t)); + return idx; + } + + idx = count; + poller->count = ++count; + /* make room for new item. */ + if(count >= poller->len) { + poller_resize_items(poller, poller->len + 10); + } + return idx; +} + +static int poller_compact_items(ZMQ_Poller *poller) { + zmq_pollitem_t *items; + int count; + int old_count; + int next; + + count = poller->count; + /* if no free slot, then return. */ + if(poller->free_list < 0) return count; + old_count = count; + + items = poller->items; + next = 0; + /* find first free slot. */ + while(next < count && items[next].events != FREE_ITEM_EVENTS_TAG) { + ++next; + } + + /* move non-free slots into free slot. */ + count = next; + ++next; + while(next < old_count) { + if(items[next].events != FREE_ITEM_EVENTS_TAG) { + /* found non-free slot, move it to the current free slot. */ + items[count] = items[next]; + ++count; + } + ++next; + } + + /* clear old used-space */ + memset(&(items[count]), 0, ((old_count - count) * sizeof(zmq_pollitem_t))); + poller->count = count; + poller->free_list = -1; /* free list is now empty. */ + + assert(count <= poller->len); + return count; +} + +int poller_poll(ZMQ_Poller *poller, long timeout) { + int count; + /* remove free slots from items list. */ + if(poller->free_list >= 0) { + count = poller_compact_items(poller); + } else { + count = poller->count; + } + /* poll for events. */ + return zmq_poll(poller->items, count, timeout); +} + +int poller_next_revents(ZMQ_Poller *poller, int *revents) { + zmq_pollitem_t *items; + int count; + int idx; + int next; + + idx = poller->next; + /* do we need to poll for more events? */ + if(idx < 0) { + return idx; + } + items = poller->items; + count = poller->count; + /* find next item with pending events. */ + for(;idx < count; ++idx) { + /* did we find a pending event? */ + if(items[idx].revents != 0) { + *revents = items[idx].revents; + poller->next = idx+1; + return idx; + } + } + /* processed all pending events. */ + poller->next = -1; + *revents = 0; + return -1; +} + + +typedef struct ZMQ_Ctx ZMQ_Ctx; + +typedef struct ZMQ_StopWatch ZMQ_StopWatch; + + + +/* method: description */ +static int ZErrors__description__meth(lua_State *L) { + const char * msg1 = NULL; + int err_type; + int err_num = -1; + + err_type = lua_type(L, 2); + if(err_type == LUA_TSTRING) { + lua_pushvalue(L, 2); + lua_rawget(L, 1); + if(lua_isnumber(L, -1)) { + err_num = lua_tointeger(L, -1); + } + lua_pop(L, 1); + } else if(err_type == LUA_TNUMBER) { + err_num = lua_tointeger(L, 2); + } else { + return luaL_argerror(L, 2, "expected string/number"); + } + if(err_num < 0) { + lua_pushnil(L); + lua_pushliteral(L, "UNKNOWN ERROR"); + return 2; + } + msg1 = strerror(err_num); + + lua_pushstring(L, msg1); + return 1; +} + +/* method: __index */ +static int ZErrors____index__meth(lua_State *L) { + int err2 = luaL_checkinteger(L,2); + const char * msg1 = NULL; + switch(err2) { case EAGAIN: - return "timeout"; + msg1 = "timeout"; break; case EINTR: - return "interrupted"; + msg1 = "interrupted"; break; #if defined(ETERM) case ETERM: - return "closed"; + msg1 = "closed"; break; #endif default: + msg1 = zmq_strerror(err2); break; } - return zmq_strerror(err); -} - - -/* detect zmq version >= 2.1.0 */ -#define VERSION_2_1 0 -#if defined(ZMQ_VERSION) -#if (ZMQ_VERSION >= ZMQ_MAKE_VERSION(2,1,0)) -#undef VERSION_2_1 -#define VERSION_2_1 1 -#endif -#endif - -/* detect really old ZeroMQ 2.0.x series. */ -#if !defined(ZMQ_RCVMORE) -#error "Your version of ZeroMQ is too old. Please upgrade to version 2.1 or to the latest 2.0.x" -#endif - -typedef struct ZMQ_Socket ZMQ_Socket; + lua_pushvalue(L, 2); + lua_pushstring(L, msg1); + lua_rawset(L, 1); -#ifdef _WIN32 -#include -typedef SOCKET socket_t; -#else -typedef int socket_t; -#endif + lua_pushstring(L, msg1); + return 1; +} -/* socket option types. */ -#define OPT_TYPE_NONE 0 -#define OPT_TYPE_INT 1 -#define OPT_TYPE_UINT32 2 -#define OPT_TYPE_UINT64 3 -#define OPT_TYPE_INT64 4 -#define OPT_TYPE_STR 5 -#define OPT_TYPE_FD 6 +static void error_code__ZMQ_Error__push(lua_State *L, ZMQ_Error err) { + const char *err_str = NULL; + if(-1 == err) { + /* get ZErrors table. */ + lua_pushlightuserdata(L, zmq_ZErrors_key); + lua_rawget(L, LUA_REGISTRYINDEX); + /* convert zmq_errno to string. */ + lua_rawgeti(L, -1, zmq_errno()); + /* remove ZErrors table. */ + lua_remove(L, -2); + if(!lua_isnil(L, -1)) { + /* found error. */ + return; + } + /* Unknown error. */ + lua_pop(L, 1); + err_str = "UNKNOWN ERROR"; + } -static const int opt_types[] = { - OPT_TYPE_NONE, /* 0 unused */ - OPT_TYPE_UINT64, /* 1 ZMQ_HWM */ - OPT_TYPE_NONE, /* 2 unused */ - OPT_TYPE_INT64, /* 3 ZMQ_SWAP */ - OPT_TYPE_UINT64, /* 4 ZMQ_AFFINITY */ - OPT_TYPE_STR, /* 5 ZMQ_IDENTITY */ - OPT_TYPE_STR, /* 6 ZMQ_SUBSCRIBE */ - OPT_TYPE_STR, /* 7 ZMQ_UNSUBSCRIBE */ - OPT_TYPE_INT64, /* 8 ZMQ_RATE */ - OPT_TYPE_INT64, /* 9 ZMQ_RECOVERY_IVL */ - OPT_TYPE_INT64, /* 10 ZMQ_MCAST_LOOP */ - OPT_TYPE_UINT64, /* 11 ZMQ_SNDBUF */ - OPT_TYPE_UINT64, /* 12 ZMQ_RCVBUF */ - OPT_TYPE_INT64, /* 13 ZMQ_RCVMORE */ + if(err_str) { + lua_pushstring(L, err_str); + } else { + lua_pushnil(L); + } +} -#if VERSION_2_1 - OPT_TYPE_FD, /* 14 ZMQ_FD */ - OPT_TYPE_UINT32, /* 15 ZMQ_EVENTS */ - OPT_TYPE_INT, /* 16 ZMQ_TYPE */ - OPT_TYPE_INT, /* 17 ZMQ_LINGER */ - OPT_TYPE_INT, /* 18 ZMQ_RECONNECT_IVL */ - OPT_TYPE_INT, /* 19 ZMQ_BACKLOG */ -#endif -}; -#if VERSION_2_1 -#define MAX_OPTS ZMQ_BACKLOG -#else -#define MAX_OPTS ZMQ_RCVMORE -#endif +/* method: init */ +static int zmq_msg_t__init__meth(lua_State *L) { + zmq_msg_t this1_store; + zmq_msg_t * this1 = &(this1_store);; + ZMQ_Error rc_zmq_msg_init2 = 0; + rc_zmq_msg_init2 = zmq_msg_init(this1); + if(!(-1 == rc_zmq_msg_init2)) { + obj_type_zmq_msg_t_push(L, this1); + } else { + lua_pushnil(L); + } + error_code__ZMQ_Error__push(L, rc_zmq_msg_init2); + return 2; +} +/* method: init_size */ +static int zmq_msg_t__init_size__meth(lua_State *L) { + size_t size1 = luaL_checkinteger(L,1); + zmq_msg_t this1_store; + zmq_msg_t * this1 = &(this1_store);; + ZMQ_Error rc_zmq_msg_init_size2 = 0; + rc_zmq_msg_init_size2 = zmq_msg_init_size(this1, size1); + if(!(-1 == rc_zmq_msg_init_size2)) { + obj_type_zmq_msg_t_push(L, this1); + } else { + lua_pushnil(L); + } + error_code__ZMQ_Error__push(L, rc_zmq_msg_init_size2); + return 2; +} -ZMQ_Error simple_zmq_send(ZMQ_Socket *sock, const char *data, size_t data_len, int flags) { - ZMQ_Error err; - zmq_msg_t msg; - /* initialize message */ - err = zmq_msg_init_size(&msg, data_len); - if(0 == err) { +/* method: init_data */ +static int zmq_msg_t__init_data__meth(lua_State *L) { + size_t data_len1; + const char * data1 = luaL_checklstring(L,1,&(data_len1)); + zmq_msg_t this1_store; + zmq_msg_t * this1 = &(this1_store);; + ZMQ_Error err2 = 0; + err2 = zmq_msg_init_size(this1, data_len1); + if(0 == err2) { /* fill message */ - memcpy(zmq_msg_data(&msg), data, data_len); - /* send message */ - err = zmq_send(sock, &msg, flags); - /* close message */ - zmq_msg_close(&msg); + memcpy(zmq_msg_data(this1), data1, data_len1); } - return err; -} -struct ZMQ_Poller { - zmq_pollitem_t *items; - int next; - int count; - int free_list; - int len; -}; + if(!(-1 == err2)) { + obj_type_zmq_msg_t_push(L, this1); + } else { + lua_pushnil(L); + } + error_code__ZMQ_Error__push(L, err2); + return 2; +} +/* method: _priv */ +static int zmq_msg_t__delete__meth(lua_State *L) { + zmq_msg_t * this1 = obj_type_zmq_msg_t_delete(L,1); + ZMQ_Error rc_zmq_msg_close1 = 0; + rc_zmq_msg_close1 = zmq_msg_close(this1); + /* check for error. */ + if((-1 == rc_zmq_msg_close1)) { + lua_pushnil(L); + error_code__ZMQ_Error__push(L, rc_zmq_msg_close1); + } else { + lua_pushboolean(L, 1); + lua_pushnil(L); + } + return 2; +} -typedef struct ZMQ_Poller ZMQ_Poller; +/* method: close */ +static int zmq_msg_t__close__meth(lua_State *L) { + zmq_msg_t * this1 = obj_type_zmq_msg_t_check(L,1); + ZMQ_Error rc_zmq_msg_close1 = 0; + rc_zmq_msg_close1 = zmq_msg_close(this1); + /* check for error. */ + if((-1 == rc_zmq_msg_close1)) { + lua_pushnil(L); + error_code__ZMQ_Error__push(L, rc_zmq_msg_close1); + } else { + lua_pushboolean(L, 1); + lua_pushnil(L); + } + return 2; +} -#define FREE_ITEM_EVENTS_TAG ((short)0xFFFF) +/* method: move */ +static int zmq_msg_t__move__meth(lua_State *L) { + zmq_msg_t * this1 = obj_type_zmq_msg_t_check(L,1); + zmq_msg_t * src2 = obj_type_zmq_msg_t_check(L,2); + ZMQ_Error rc_zmq_msg_move1 = 0; + rc_zmq_msg_move1 = zmq_msg_move(this1, src2); + /* check for error. */ + if((-1 == rc_zmq_msg_move1)) { + lua_pushnil(L); + error_code__ZMQ_Error__push(L, rc_zmq_msg_move1); + } else { + lua_pushboolean(L, 1); + lua_pushnil(L); + } + return 2; +} -#define ITEM_TO_INDEX(items, item) (item - (items)) +/* method: copy */ +static int zmq_msg_t__copy__meth(lua_State *L) { + zmq_msg_t * this1 = obj_type_zmq_msg_t_check(L,1); + zmq_msg_t * src2 = obj_type_zmq_msg_t_check(L,2); + ZMQ_Error rc_zmq_msg_copy1 = 0; + rc_zmq_msg_copy1 = zmq_msg_copy(this1, src2); + /* check for error. */ + if((-1 == rc_zmq_msg_copy1)) { + lua_pushnil(L); + error_code__ZMQ_Error__push(L, rc_zmq_msg_copy1); + } else { + lua_pushboolean(L, 1); + lua_pushnil(L); + } + return 2; +} -static int poller_resize_items(ZMQ_Poller *poller, int len) { - int old_len = poller->len; +/* method: set_data */ +static int zmq_msg_t__set_data__meth(lua_State *L) { + zmq_msg_t * this1 = obj_type_zmq_msg_t_check(L,1); + size_t data_len2; + const char * data2 = luaL_checklstring(L,2,&(data_len2)); + ZMQ_Error err1 = 0; + /* check message data size. */ + if(zmq_msg_size(this1) != data_len2) { + /* need to resize message. */ + zmq_msg_close(this1); /* close old message, to free old data. */ + err1 = zmq_msg_init_size(this1, data_len2); /* re-initialize message. */ + if(0 != err1) { + luaL_error(L, "set_data() failed: %s", get_zmq_strerror()); + } + } + /* copy data into message */ + memcpy(zmq_msg_data(this1), data2, data_len2); - /* make sure new length is atleast as large as items count. */ - len = (poller->count <= len) ? len : poller->count; + /* check for error. */ + if((-1 == err1)) { + lua_pushnil(L); + error_code__ZMQ_Error__push(L, err1); + } else { + lua_pushboolean(L, 1); + lua_pushnil(L); + } + return 2; +} - /* if the new length is the same as the old length, then don't try to resize. */ - if(old_len == len) return len; +/* method: data */ +static int zmq_msg_t__data__meth(lua_State *L) { + zmq_msg_t * this1 = obj_type_zmq_msg_t_check(L,1); + void * rc_zmq_msg_data1 = NULL; + rc_zmq_msg_data1 = zmq_msg_data(this1); + lua_pushlightuserdata(L, rc_zmq_msg_data1); + return 1; +} - poller->items = (zmq_pollitem_t *)realloc(poller->items, len * sizeof(zmq_pollitem_t)); - poller->len = len; - if(len > old_len) { - /* clear new space. */ - memset(&(poller->items[old_len]), 0, (len - old_len) * sizeof(zmq_pollitem_t)); +/* method: set_size */ +static int zmq_msg_t__set_size__meth(lua_State *L) { + zmq_msg_t * this1 = obj_type_zmq_msg_t_check(L,1); + size_t size2 = luaL_checkinteger(L,2); + ZMQ_Error err1 = 0; + /* check message data size. */ + if(zmq_msg_size(this1) != size2) { + /* need to resize message. */ + zmq_msg_close(this1); /* close old message, to free old data. */ + err1 = zmq_msg_init_size(this1, size2); /* re-initialize message. */ + if(0 != err1) { + luaL_error(L, "set_size() failed: %s", get_zmq_strerror()); + } } - return len; -} -void poller_init(ZMQ_Poller *poller, int length) { - poller->items = (zmq_pollitem_t *)calloc(length, sizeof(zmq_pollitem_t)); - poller->next = -1; - poller->count = 0; - poller->len = length; - poller->free_list = -1; + /* check for error. */ + if((-1 == err1)) { + lua_pushnil(L); + error_code__ZMQ_Error__push(L, err1); + } else { + lua_pushboolean(L, 1); + lua_pushnil(L); + } + return 2; } -void poller_cleanup(ZMQ_Poller *poller) { - free(poller->items); - poller->items = NULL; - poller->next = -1; - poller->count = 0; - poller->len = 0; - poller->free_list = -1; +/* method: size */ +static int zmq_msg_t__size__meth(lua_State *L) { + zmq_msg_t * this1 = obj_type_zmq_msg_t_check(L,1); + size_t rc_zmq_msg_size1 = 0; + rc_zmq_msg_size1 = zmq_msg_size(this1); + lua_pushinteger(L, rc_zmq_msg_size1); + return 1; } -int poller_find_sock_item(ZMQ_Poller *poller, ZMQ_Socket *sock) { - zmq_pollitem_t *items; - int count; - int n; +/* method: __tostring */ +static int zmq_msg_t____tostring__meth(lua_State *L) { + zmq_msg_t * this1 = obj_type_zmq_msg_t_check(L,1); + size_t data_len1 = 0; + const char * data1 = NULL; + data1 = zmq_msg_data(this1); + data_len1 = zmq_msg_size(this1); - /* find ZMQ_Socket */ - items = poller->items; - count = poller->count; - for(n=0; n < count; n++) { - if(items[n].socket == sock) return n; - } - /* not found. */ - return -1; + if(data1 == NULL) lua_pushnil(L); else lua_pushlstring(L, data1,data_len1); + return 1; } -int poller_find_fd_item(ZMQ_Poller *poller, socket_t fd) { - zmq_pollitem_t *items; - int count; - int n; +/* method: close */ +static int ZMQ_Socket__close__meth(lua_State *L) { + int this_flags1 = 0; + ZMQ_Socket * this1 = obj_type_ZMQ_Socket_delete(L,1,&(this_flags1)); + ZMQ_Error rc_zmq_close1 = 0; + if(!(this_flags1 & OBJ_UDATA_FLAG_OWN)) { return 0; } + rc_zmq_close1 = zmq_close(this1); + /* check for error. */ + if((-1 == rc_zmq_close1)) { + lua_pushnil(L); + error_code__ZMQ_Error__push(L, rc_zmq_close1); + } else { + lua_pushboolean(L, 1); + lua_pushnil(L); + } + return 2; +} - /* find fd */ - items = poller->items; - count = poller->count; - for(n=0; n < count; n++) { - if(items[n].fd == fd) return n; - } - /* not found. */ - return -1; +/* method: bind */ +static int ZMQ_Socket__bind__meth(lua_State *L) { + ZMQ_Socket * this1 = obj_type_ZMQ_Socket_check(L,1); + size_t addr_len2; + const char * addr2 = luaL_checklstring(L,2,&(addr_len2)); + ZMQ_Error rc_zmq_bind1 = 0; + rc_zmq_bind1 = zmq_bind(this1, addr2); + /* check for error. */ + if((-1 == rc_zmq_bind1)) { + lua_pushnil(L); + error_code__ZMQ_Error__push(L, rc_zmq_bind1); + } else { + lua_pushboolean(L, 1); + lua_pushnil(L); + } + return 2; } -void poller_remove_item(ZMQ_Poller *poller, int idx) { - zmq_pollitem_t *items; - int free_list; - int count; +/* method: connect */ +static int ZMQ_Socket__connect__meth(lua_State *L) { + ZMQ_Socket * this1 = obj_type_ZMQ_Socket_check(L,1); + size_t addr_len2; + const char * addr2 = luaL_checklstring(L,2,&(addr_len2)); + ZMQ_Error rc_zmq_connect1 = 0; + rc_zmq_connect1 = zmq_connect(this1, addr2); + /* check for error. */ + if((-1 == rc_zmq_connect1)) { + lua_pushnil(L); + error_code__ZMQ_Error__push(L, rc_zmq_connect1); + } else { + lua_pushboolean(L, 1); + lua_pushnil(L); + } + return 2; +} - count = poller->count; - /* no item to remove. */ - if(idx >= count || count == 0) return; +/* method: setopt */ +static int ZMQ_Socket__setopt__meth(lua_State *L) { + ZMQ_Socket * this1 = obj_type_ZMQ_Socket_check(L,1); + uint32_t opt2 = luaL_checkinteger(L,2); + ZMQ_Error err1 = 0; + size_t val_len; + const void *val; - items = poller->items; - free_list = poller->free_list; +#if VERSION_2_1 + socket_t fd_val; +#endif + int int_val; + uint32_t uint32_val; + uint64_t uint64_val; + int64_t int64_val; - /* link new free slot to head of free list. */ - if(free_list >= 0 && free_list < count) { - /* use socket pointer for free list's 'next' field. */ - items[idx].socket = &(items[free_list]); - } else { - /* free list is empty mark poller slot as the end. */ - items[idx].socket = NULL; +#if VERSION_3_0 + /* 3.0 backwards compatibility support for HWM. */ + if(opt2 == ZMQ_HWM) { + int_val = luaL_checklong(L, 3); + val = &int_val; + val_len = sizeof(int_val); + err1 = zmq_setsockopt(this1, ZMQ_SNDHWM, val, val_len); + if(-1 != err1) { + err1 = zmq_setsockopt(this1, ZMQ_RCVHWM, val, val_len); + } + goto finished; } - poller->free_list = idx; - /* mark poller slot as a free slot. */ - items[idx].events = FREE_ITEM_EVENTS_TAG; - /* clear old revents. */ - items[idx].revents = 0; -} +#endif -int poller_get_free_item(ZMQ_Poller *poller) { - zmq_pollitem_t *curr; - zmq_pollitem_t *next; - int count; - int idx; + if(opt2 > MAX_OPTS) { + return luaL_argerror(L, 2, "Invalid socket option."); + } - count = poller->count; - idx = poller->free_list; - /* check for a free slot in the free list. */ - if(idx >= 0 && idx < count) { - /* remove free slot from free list. */ - curr = &(poller->items[idx]); - /* valid free slot. */ - assert(curr->events == FREE_ITEM_EVENTS_TAG); - /* is poller the last free slot? */ - next = ((zmq_pollitem_t *)curr->socket); - if(next != NULL) { - /* set next free slot as head of free list. */ - poller->free_list = ITEM_TO_INDEX(poller->items, next); - } else { - /* free list is empty now. */ - poller->free_list = -1; - } - /* clear slot */ - memset(curr, 0, sizeof(zmq_pollitem_t)); - return idx; + switch(opt_types[opt2]) { +#if VERSION_2_1 + case OPT_TYPE_FD: + fd_val = luaL_checklong(L, 3); + val = &fd_val; + val_len = sizeof(fd_val); + break; +#endif + case OPT_TYPE_INT: + int_val = luaL_checklong(L, 3); + val = &int_val; + val_len = sizeof(int_val); + break; + case OPT_TYPE_UINT32: + uint32_val = luaL_checklong(L, 3); + val = &uint32_val; + val_len = sizeof(uint32_val); + break; + case OPT_TYPE_UINT64: + uint64_val = luaL_checklong(L, 3); + val = &uint64_val; + val_len = sizeof(uint64_val); + break; + case OPT_TYPE_INT64: + int64_val = luaL_checklong(L, 3); + val = &int64_val; + val_len = sizeof(int64_val); + break; + case OPT_TYPE_BLOB: + val = luaL_checklstring(L, 3, &(val_len)); + break; + default: + printf("Invalid socket option type, this shouldn't happen.\n"); + abort(); + break; } + err1 = zmq_setsockopt(this1, opt2, val, val_len); +finished: - idx = count; - poller->count = ++count; - /* make room for new item. */ - if(count >= poller->len) { - poller_resize_items(poller, poller->len + 10); - } - return idx; + /* check for error. */ + if((-1 == err1)) { + lua_pushnil(L); + error_code__ZMQ_Error__push(L, err1); + } else { + lua_pushboolean(L, 1); + lua_pushnil(L); + } + return 2; } -static int poller_compact_items(ZMQ_Poller *poller) { - zmq_pollitem_t *items; - int count; - int old_count; - int next; +/* method: getopt */ +static int ZMQ_Socket__getopt__meth(lua_State *L) { + ZMQ_Socket * this1 = obj_type_ZMQ_Socket_check(L,1); + uint32_t opt2 = luaL_checkinteger(L,2); + ZMQ_Error err2 = 0; + size_t val_len; - count = poller->count; - /* if no free slot, then return. */ - if(poller->free_list < 0) return count; - old_count = count; +#if VERSION_2_1 + socket_t fd_val; +#endif + int int_val; + uint32_t uint32_val; + uint64_t uint64_val; + int64_t int64_val; +#define STR_MAX 255 + char str_val[STR_MAX]; - items = poller->items; - next = 0; - /* find first free slot. */ - while(next < count && items[next].events != FREE_ITEM_EVENTS_TAG) { - ++next; + if(opt2 > MAX_OPTS) { + lua_pushnil(L); + lua_pushliteral(L, "Invalid socket option."); + return 2; } - /* move non-free slots into free slot. */ - count = next; - ++next; - while(next < old_count) { - if(items[next].events != FREE_ITEM_EVENTS_TAG) { - /* found non-free slot, move it to the current free slot. */ - items[count] = items[next]; - ++count; + switch(opt_types[opt2]) { +#if VERSION_2_1 + case OPT_TYPE_FD: + val_len = sizeof(fd_val); + err2 = zmq_getsockopt(this1, opt2, &fd_val, &val_len); + if(0 == err2) { + lua_pushinteger(L, (lua_Integer)fd_val); + return 1; } - ++next; + break; +#endif + case OPT_TYPE_INT: + val_len = sizeof(int_val); + err2 = zmq_getsockopt(this1, opt2, &int_val, &val_len); + if(0 == err2) { + lua_pushinteger(L, (lua_Integer)int_val); + return 1; + } + break; + case OPT_TYPE_UINT32: + val_len = sizeof(uint32_val); + err2 = zmq_getsockopt(this1, opt2, &uint32_val, &val_len); + if(0 == err2) { + lua_pushinteger(L, (lua_Integer)uint32_val); + return 1; + } + break; + case OPT_TYPE_UINT64: + val_len = sizeof(uint64_val); + err2 = zmq_getsockopt(this1, opt2, &uint64_val, &val_len); + if(0 == err2) { + lua_pushinteger(L, (lua_Integer)uint64_val); + return 1; + } + break; + case OPT_TYPE_INT64: + val_len = sizeof(int64_val); + err2 = zmq_getsockopt(this1, opt2, &int64_val, &val_len); + if(0 == err2) { + lua_pushinteger(L, (lua_Integer)int64_val); + return 1; + } + break; + case OPT_TYPE_BLOB: + val_len = STR_MAX; + err2 = zmq_getsockopt(this1, opt2, str_val, &val_len); + if(0 == err2) { + lua_pushlstring(L, str_val, val_len); + return 1; + } +#undef STR_MAX + break; + default: + printf("Invalid socket option type, this shouldn't happen.\n"); + abort(); + break; } + lua_pushnil(L); - /* clear old used-space */ - memset(&(items[count]), 0, ((old_count - count) * sizeof(zmq_pollitem_t))); - poller->count = count; - poller->free_list = -1; /* free list is now empty. */ - - assert(count <= poller->len); - return count; + error_code__ZMQ_Error__push(L, err2); + return 2; } -int poller_poll(ZMQ_Poller *poller, long timeout) { - int count; - /* remove free slots from items list. */ - if(poller->free_list >= 0) { - count = poller_compact_items(poller); - } else { - count = poller->count; - } - /* poll for events. */ - return zmq_poll(poller->items, count, timeout); +/* method: send_msg */ +static int ZMQ_Socket__send_msg__meth(lua_State *L) { + ZMQ_Socket * this1 = obj_type_ZMQ_Socket_check(L,1); + zmq_msg_t * msg2 = obj_type_zmq_msg_t_check(L,2); + int flags3 = luaL_optinteger(L,3,0); + ZMQ_Error rc_zmq_sendmsg1 = 0; + rc_zmq_sendmsg1 = zmq_sendmsg(this1, msg2, flags3); + /* check for error. */ + if((-1 == rc_zmq_sendmsg1)) { + lua_pushnil(L); + error_code__ZMQ_Error__push(L, rc_zmq_sendmsg1); + } else { + lua_pushboolean(L, 1); + lua_pushnil(L); + } + return 2; } -int poller_next_revents(ZMQ_Poller *poller, int *revents) { - zmq_pollitem_t *items; - int count; - int idx; - int next; - - idx = poller->next; - /* do we need to poll for more events? */ - if(idx < 0) { - return idx; - } - items = poller->items; - count = poller->count; - /* find next item with pending events. */ - for(;idx < count; ++idx) { - /* did we find a pending event? */ - if(items[idx].revents != 0) { - *revents = items[idx].revents; - poller->next = idx+1; - return idx; - } - } - /* processed all pending events. */ - poller->next = -1; - *revents = 0; - return -1; +/* method: send */ +static int ZMQ_Socket__send__meth(lua_State *L) { + ZMQ_Socket * this1 = obj_type_ZMQ_Socket_check(L,1); + size_t data_len2; + const char * data2 = luaL_checklstring(L,2,&(data_len2)); + int flags3 = luaL_optinteger(L,3,0); + ZMQ_Error rc_simple_zmq_send1 = 0; + rc_simple_zmq_send1 = simple_zmq_send(this1, data2, data_len2, flags3); + /* check for error. */ + if((-1 == rc_simple_zmq_send1)) { + lua_pushnil(L); + error_code__ZMQ_Error__push(L, rc_simple_zmq_send1); + } else { + lua_pushboolean(L, 1); + lua_pushnil(L); + } + return 2; } +/* method: recv_msg */ +static int ZMQ_Socket__recv_msg__meth(lua_State *L) { + ZMQ_Socket * this1 = obj_type_ZMQ_Socket_check(L,1); + zmq_msg_t * msg2 = obj_type_zmq_msg_t_check(L,2); + int flags3 = luaL_optinteger(L,3,0); + ZMQ_Error rc_zmq_recvmsg1 = 0; + rc_zmq_recvmsg1 = zmq_recvmsg(this1, msg2, flags3); + /* check for error. */ + if((-1 == rc_zmq_recvmsg1)) { + lua_pushnil(L); + error_code__ZMQ_Error__push(L, rc_zmq_recvmsg1); + } else { + lua_pushboolean(L, 1); + lua_pushnil(L); + } + return 2; +} -typedef struct ZMQ_Ctx ZMQ_Ctx; - -typedef struct ZMQ_StopWatch ZMQ_StopWatch; - - - -/* method: description */ -static int ZErrors__description__meth(lua_State *L) { - const char * msg1 = NULL; - int err_type; - int err_num = -1; - - err_type = lua_type(L, 2); - if(err_type == LUA_TSTRING) { - lua_pushvalue(L, 2); - lua_rawget(L, 1); - if(lua_isnumber(L, -1)) { - err_num = lua_tointeger(L, -1); - } - lua_pop(L, 1); - } else if(err_type == LUA_TNUMBER) { - err_num = lua_tointeger(L, 2); - } else { - return luaL_argerror(L, 2, "expected string/number"); - } - if(err_num < 0) { - lua_pushnil(L); - lua_pushliteral(L, "UNKNOWN ERROR"); - return 2; +/* method: recv */ +static int ZMQ_Socket__recv__meth(lua_State *L) { + ZMQ_Socket * this1 = obj_type_ZMQ_Socket_check(L,1); + int flags2 = luaL_optinteger(L,2,0); + size_t data_len1 = 0; + const char * data1 = NULL; + ZMQ_Error err2 = 0; + zmq_msg_t msg; + /* initialize message */ + err2 = zmq_msg_init(&msg); + if(0 == err2) { + /* receive message */ + err2 = zmq_recvmsg(this1, &msg, flags2); + if(0 == err2) { + data1 = zmq_msg_data(&msg); + data_len1 = zmq_msg_size(&msg); + } } - msg1 = strerror(err_num); - lua_pushstring(L, msg1); - return 1; + if(!(-1 == err2)) { + if(data1 == NULL) lua_pushnil(L); else lua_pushlstring(L, data1,data_len1); + } else { + lua_pushnil(L); + } + error_code__ZMQ_Error__push(L, err2); + /* close message */ + zmq_msg_close(&msg); + + return 2; } -/* method: __index */ -static int ZErrors____index__meth(lua_State *L) { - int err2 = luaL_checkinteger(L,2); - const char * msg1 = NULL; - switch(err2) { - case EAGAIN: - msg1 = "timeout"; - break; - case EINTR: - msg1 = "interrupted"; - break; -#if defined(ETERM) - case ETERM: - msg1 = "closed"; - break; +/* method: hwm */ +#if (VERSION_2_0|VERSION_3_0) +static int ZMQ_Socket__hwm__meth(lua_State *L) { + ZMQ_Socket * this1 = obj_type_ZMQ_Socket_check(L,1); + int value1 = 0; + ZMQ_Error rc_lzmq_socket_hwm2 = 0; + rc_lzmq_socket_hwm2 = lzmq_socket_hwm(this1, &(value1)); + if(!(-1 == rc_lzmq_socket_hwm2)) { + lua_pushinteger(L, value1); + } else { + lua_pushnil(L); + } + error_code__ZMQ_Error__push(L, rc_lzmq_socket_hwm2); + return 2; +} #endif - default: - msg1 = zmq_strerror(err2); - break; - } - lua_pushvalue(L, 2); - lua_pushstring(L, msg1); - lua_rawset(L, 1); - lua_pushstring(L, msg1); - return 1; +/* method: set_hwm */ +#if (VERSION_2_0|VERSION_3_0) +static int ZMQ_Socket__set_hwm__meth(lua_State *L) { + ZMQ_Socket * this1 = obj_type_ZMQ_Socket_check(L,1); + int value2 = luaL_checkinteger(L,2); + ZMQ_Error rc_lzmq_socket_set_hwm1 = 0; + rc_lzmq_socket_set_hwm1 = lzmq_socket_set_hwm(this1, value2); + /* check for error. */ + if((-1 == rc_lzmq_socket_set_hwm1)) { + lua_pushnil(L); + error_code__ZMQ_Error__push(L, rc_lzmq_socket_set_hwm1); + } else { + lua_pushboolean(L, 1); + lua_pushnil(L); + } + return 2; } +#endif -static void error_code__ZMQ_Error__push(lua_State *L, ZMQ_Error err) { - const char *err_str = NULL; - if(-1 == err) { - /* get ZErrors table. */ - lua_pushlightuserdata(L, zmq_ZErrors_key); - lua_rawget(L, LUA_REGISTRYINDEX); - /* convert zmq_errno to string. */ - lua_rawgeti(L, -1, zmq_errno()); - /* remove ZErrors table. */ - lua_remove(L, -2); - if(!lua_isnil(L, -1)) { - /* found error. */ - return; - } - /* Unknown error. */ - lua_pop(L, 1); - err_str = "UNKNOWN ERROR"; - } +/* method: swap */ +#if (VERSION_2_0) +static int ZMQ_Socket__swap__meth(lua_State *L) { + ZMQ_Socket * this1 = obj_type_ZMQ_Socket_check(L,1); + int value1 = 0; + ZMQ_Error rc_lzmq_socket_swap2 = 0; + rc_lzmq_socket_swap2 = lzmq_socket_swap(this1, &(value1)); + if(!(-1 == rc_lzmq_socket_swap2)) { + lua_pushinteger(L, value1); + } else { + lua_pushnil(L); + } + error_code__ZMQ_Error__push(L, rc_lzmq_socket_swap2); + return 2; +} +#endif - if(err_str) { - lua_pushstring(L, err_str); - } else { - lua_pushnil(L); - } +/* method: set_swap */ +#if (VERSION_2_0) +static int ZMQ_Socket__set_swap__meth(lua_State *L) { + ZMQ_Socket * this1 = obj_type_ZMQ_Socket_check(L,1); + int value2 = luaL_checkinteger(L,2); + ZMQ_Error rc_lzmq_socket_set_swap1 = 0; + rc_lzmq_socket_set_swap1 = lzmq_socket_set_swap(this1, value2); + /* check for error. */ + if((-1 == rc_lzmq_socket_set_swap1)) { + lua_pushnil(L); + error_code__ZMQ_Error__push(L, rc_lzmq_socket_set_swap1); + } else { + lua_pushboolean(L, 1); + lua_pushnil(L); + } + return 2; } +#endif -/* method: init */ -static int zmq_msg_t__init__meth(lua_State *L) { - zmq_msg_t * this1; - ZMQ_Error err2 = 0; - zmq_msg_t tmp; - this1 = &tmp; - err2 = zmq_msg_init(this1); +/* method: affinity */ +#if (VERSION_2_0|VERSION_3_0) +static int ZMQ_Socket__affinity__meth(lua_State *L) { + ZMQ_Socket * this1 = obj_type_ZMQ_Socket_check(L,1); + uint64_t value1 = 0; + ZMQ_Error rc_lzmq_socket_affinity2 = 0; + rc_lzmq_socket_affinity2 = lzmq_socket_affinity(this1, &(value1)); + if(!(-1 == rc_lzmq_socket_affinity2)) { + lua_pushinteger(L, value1); + } else { + lua_pushnil(L); + } + error_code__ZMQ_Error__push(L, rc_lzmq_socket_affinity2); + return 2; +} +#endif - if(!(-1 == err2)) { - obj_type_zmq_msg_t_push(L, this1); +/* method: set_affinity */ +#if (VERSION_2_0|VERSION_3_0) +static int ZMQ_Socket__set_affinity__meth(lua_State *L) { + ZMQ_Socket * this1 = obj_type_ZMQ_Socket_check(L,1); + uint64_t value2 = luaL_checkinteger(L,2); + ZMQ_Error rc_lzmq_socket_set_affinity1 = 0; + rc_lzmq_socket_set_affinity1 = lzmq_socket_set_affinity(this1, value2); + /* check for error. */ + if((-1 == rc_lzmq_socket_set_affinity1)) { + lua_pushnil(L); + error_code__ZMQ_Error__push(L, rc_lzmq_socket_set_affinity1); } else { + lua_pushboolean(L, 1); lua_pushnil(L); } - error_code__ZMQ_Error__push(L, err2); return 2; } +#endif -/* method: init_size */ -static int zmq_msg_t__init_size__meth(lua_State *L) { - size_t size1 = luaL_checkinteger(L,1); - zmq_msg_t * this1; - ZMQ_Error err2 = 0; - zmq_msg_t tmp; - this1 = &tmp; - err2 = zmq_msg_init_size(this1, size1); +/* method: identity */ +#if (VERSION_2_0|VERSION_3_0) +static int ZMQ_Socket__identity__meth(lua_State *L) { + ZMQ_Socket * this1 = obj_type_ZMQ_Socket_check(L,1); + size_t value_len1 = 0; + char * value1 = NULL; + ZMQ_Error rc_lzmq_socket_identity2 = 0; + rc_lzmq_socket_identity2 = lzmq_socket_identity(this1, value1, &(value_len1)); + if(!(-1 == rc_lzmq_socket_identity2)) { + if(value1 == NULL) lua_pushnil(L); else lua_pushlstring(L, value1,value_len1); + } else { + lua_pushnil(L); + } + error_code__ZMQ_Error__push(L, rc_lzmq_socket_identity2); + return 2; +} +#endif - if(!(-1 == err2)) { - obj_type_zmq_msg_t_push(L, this1); +/* method: set_identity */ +#if (VERSION_2_0|VERSION_3_0) +static int ZMQ_Socket__set_identity__meth(lua_State *L) { + ZMQ_Socket * this1 = obj_type_ZMQ_Socket_check(L,1); + size_t value_len2; + const char * value2 = luaL_checklstring(L,2,&(value_len2)); + ZMQ_Error rc_lzmq_socket_set_identity1 = 0; + rc_lzmq_socket_set_identity1 = lzmq_socket_set_identity(this1, value2, value_len2); + /* check for error. */ + if((-1 == rc_lzmq_socket_set_identity1)) { + lua_pushnil(L); + error_code__ZMQ_Error__push(L, rc_lzmq_socket_set_identity1); } else { + lua_pushboolean(L, 1); lua_pushnil(L); } - error_code__ZMQ_Error__push(L, err2); return 2; } +#endif -/* method: init_data */ -static int zmq_msg_t__init_data__meth(lua_State *L) { - size_t data_len1; - const char * data1 = luaL_checklstring(L,1,&(data_len1)); - zmq_msg_t * this1; - ZMQ_Error err2 = 0; - zmq_msg_t tmp; - this1 = &tmp; - err2 = zmq_msg_init_size(this1, data_len1); - if(0 == err2) { - /* fill message */ - memcpy(zmq_msg_data(this1), data1, data_len1); - } +/* method: subscribe */ +#if (VERSION_2_0|VERSION_3_0) +static int ZMQ_Socket__subscribe__meth(lua_State *L) { + ZMQ_Socket * this1 = obj_type_ZMQ_Socket_check(L,1); + size_t value_len2; + const char * value2 = luaL_checklstring(L,2,&(value_len2)); + ZMQ_Error rc_lzmq_socket_subscribe1 = 0; + rc_lzmq_socket_subscribe1 = lzmq_socket_subscribe(this1, value2, value_len2); + /* check for error. */ + if((-1 == rc_lzmq_socket_subscribe1)) { + lua_pushnil(L); + error_code__ZMQ_Error__push(L, rc_lzmq_socket_subscribe1); + } else { + lua_pushboolean(L, 1); + lua_pushnil(L); + } + return 2; +} +#endif - if(!(-1 == err2)) { - obj_type_zmq_msg_t_push(L, this1); +/* method: unsubscribe */ +#if (VERSION_2_0|VERSION_3_0) +static int ZMQ_Socket__unsubscribe__meth(lua_State *L) { + ZMQ_Socket * this1 = obj_type_ZMQ_Socket_check(L,1); + size_t value_len2; + const char * value2 = luaL_checklstring(L,2,&(value_len2)); + ZMQ_Error rc_lzmq_socket_unsubscribe1 = 0; + rc_lzmq_socket_unsubscribe1 = lzmq_socket_unsubscribe(this1, value2, value_len2); + /* check for error. */ + if((-1 == rc_lzmq_socket_unsubscribe1)) { + lua_pushnil(L); + error_code__ZMQ_Error__push(L, rc_lzmq_socket_unsubscribe1); } else { + lua_pushboolean(L, 1); lua_pushnil(L); } - error_code__ZMQ_Error__push(L, err2); return 2; } +#endif + +/* method: rate */ +#if (VERSION_2_0|VERSION_3_0) +static int ZMQ_Socket__rate__meth(lua_State *L) { + ZMQ_Socket * this1 = obj_type_ZMQ_Socket_check(L,1); + int value1 = 0; + ZMQ_Error rc_lzmq_socket_rate2 = 0; + rc_lzmq_socket_rate2 = lzmq_socket_rate(this1, &(value1)); + if(!(-1 == rc_lzmq_socket_rate2)) { + lua_pushinteger(L, value1); + } else { + lua_pushnil(L); + } + error_code__ZMQ_Error__push(L, rc_lzmq_socket_rate2); + return 2; +} +#endif -/* method: delete */ -static int zmq_msg_t__delete__meth(lua_State *L) { - zmq_msg_t * this1 = obj_type_zmq_msg_t_delete(L,1); - ZMQ_Error rc_zmq_msg_close1 = 0; - rc_zmq_msg_close1 = zmq_msg_close(this1); +/* method: set_rate */ +#if (VERSION_2_0|VERSION_3_0) +static int ZMQ_Socket__set_rate__meth(lua_State *L) { + ZMQ_Socket * this1 = obj_type_ZMQ_Socket_check(L,1); + int value2 = luaL_checkinteger(L,2); + ZMQ_Error rc_lzmq_socket_set_rate1 = 0; + rc_lzmq_socket_set_rate1 = lzmq_socket_set_rate(this1, value2); /* check for error. */ - if((-1 == rc_zmq_msg_close1)) { + if((-1 == rc_lzmq_socket_set_rate1)) { lua_pushnil(L); - error_code__ZMQ_Error__push(L, rc_zmq_msg_close1); + error_code__ZMQ_Error__push(L, rc_lzmq_socket_set_rate1); } else { lua_pushboolean(L, 1); lua_pushnil(L); } return 2; } +#endif + +/* method: recovery_ivl */ +#if (VERSION_2_0|VERSION_3_0) +static int ZMQ_Socket__recovery_ivl__meth(lua_State *L) { + ZMQ_Socket * this1 = obj_type_ZMQ_Socket_check(L,1); + int value1 = 0; + ZMQ_Error rc_lzmq_socket_recovery_ivl2 = 0; + rc_lzmq_socket_recovery_ivl2 = lzmq_socket_recovery_ivl(this1, &(value1)); + if(!(-1 == rc_lzmq_socket_recovery_ivl2)) { + lua_pushinteger(L, value1); + } else { + lua_pushnil(L); + } + error_code__ZMQ_Error__push(L, rc_lzmq_socket_recovery_ivl2); + return 2; +} +#endif -/* method: close */ -static int zmq_msg_t__close__meth(lua_State *L) { - zmq_msg_t * this1 = obj_type_zmq_msg_t_check(L,1); - ZMQ_Error rc_zmq_msg_close1 = 0; - rc_zmq_msg_close1 = zmq_msg_close(this1); +/* method: set_recovery_ivl */ +#if (VERSION_2_0|VERSION_3_0) +static int ZMQ_Socket__set_recovery_ivl__meth(lua_State *L) { + ZMQ_Socket * this1 = obj_type_ZMQ_Socket_check(L,1); + int value2 = luaL_checkinteger(L,2); + ZMQ_Error rc_lzmq_socket_set_recovery_ivl1 = 0; + rc_lzmq_socket_set_recovery_ivl1 = lzmq_socket_set_recovery_ivl(this1, value2); /* check for error. */ - if((-1 == rc_zmq_msg_close1)) { + if((-1 == rc_lzmq_socket_set_recovery_ivl1)) { lua_pushnil(L); - error_code__ZMQ_Error__push(L, rc_zmq_msg_close1); + error_code__ZMQ_Error__push(L, rc_lzmq_socket_set_recovery_ivl1); } else { lua_pushboolean(L, 1); lua_pushnil(L); } return 2; } +#endif -/* method: move */ -static int zmq_msg_t__move__meth(lua_State *L) { - zmq_msg_t * this1 = obj_type_zmq_msg_t_check(L,1); - zmq_msg_t * src2 = obj_type_zmq_msg_t_check(L,2); - ZMQ_Error rc_zmq_msg_move1 = 0; - rc_zmq_msg_move1 = zmq_msg_move(this1, src2); +/* method: mcast_loop */ +#if (VERSION_2_0|VERSION_3_0) +static int ZMQ_Socket__mcast_loop__meth(lua_State *L) { + ZMQ_Socket * this1 = obj_type_ZMQ_Socket_check(L,1); + int value1 = 0; + ZMQ_Error rc_lzmq_socket_mcast_loop2 = 0; + rc_lzmq_socket_mcast_loop2 = lzmq_socket_mcast_loop(this1, &(value1)); + if(!(-1 == rc_lzmq_socket_mcast_loop2)) { + lua_pushinteger(L, value1); + } else { + lua_pushnil(L); + } + error_code__ZMQ_Error__push(L, rc_lzmq_socket_mcast_loop2); + return 2; +} +#endif + +/* method: set_mcast_loop */ +#if (VERSION_2_0|VERSION_3_0) +static int ZMQ_Socket__set_mcast_loop__meth(lua_State *L) { + ZMQ_Socket * this1 = obj_type_ZMQ_Socket_check(L,1); + int value2 = luaL_checkinteger(L,2); + ZMQ_Error rc_lzmq_socket_set_mcast_loop1 = 0; + rc_lzmq_socket_set_mcast_loop1 = lzmq_socket_set_mcast_loop(this1, value2); /* check for error. */ - if((-1 == rc_zmq_msg_move1)) { + if((-1 == rc_lzmq_socket_set_mcast_loop1)) { lua_pushnil(L); - error_code__ZMQ_Error__push(L, rc_zmq_msg_move1); + error_code__ZMQ_Error__push(L, rc_lzmq_socket_set_mcast_loop1); } else { lua_pushboolean(L, 1); lua_pushnil(L); } return 2; } +#endif -/* method: copy */ -static int zmq_msg_t__copy__meth(lua_State *L) { - zmq_msg_t * this1 = obj_type_zmq_msg_t_check(L,1); - zmq_msg_t * src2 = obj_type_zmq_msg_t_check(L,2); - ZMQ_Error rc_zmq_msg_copy1 = 0; - rc_zmq_msg_copy1 = zmq_msg_copy(this1, src2); +/* method: sndbuf */ +#if (VERSION_2_0|VERSION_3_0) +static int ZMQ_Socket__sndbuf__meth(lua_State *L) { + ZMQ_Socket * this1 = obj_type_ZMQ_Socket_check(L,1); + int value1 = 0; + ZMQ_Error rc_lzmq_socket_sndbuf2 = 0; + rc_lzmq_socket_sndbuf2 = lzmq_socket_sndbuf(this1, &(value1)); + if(!(-1 == rc_lzmq_socket_sndbuf2)) { + lua_pushinteger(L, value1); + } else { + lua_pushnil(L); + } + error_code__ZMQ_Error__push(L, rc_lzmq_socket_sndbuf2); + return 2; +} +#endif + +/* method: set_sndbuf */ +#if (VERSION_2_0|VERSION_3_0) +static int ZMQ_Socket__set_sndbuf__meth(lua_State *L) { + ZMQ_Socket * this1 = obj_type_ZMQ_Socket_check(L,1); + int value2 = luaL_checkinteger(L,2); + ZMQ_Error rc_lzmq_socket_set_sndbuf1 = 0; + rc_lzmq_socket_set_sndbuf1 = lzmq_socket_set_sndbuf(this1, value2); /* check for error. */ - if((-1 == rc_zmq_msg_copy1)) { + if((-1 == rc_lzmq_socket_set_sndbuf1)) { lua_pushnil(L); - error_code__ZMQ_Error__push(L, rc_zmq_msg_copy1); + error_code__ZMQ_Error__push(L, rc_lzmq_socket_set_sndbuf1); } else { lua_pushboolean(L, 1); lua_pushnil(L); } return 2; } +#endif -/* method: set_data */ -static int zmq_msg_t__set_data__meth(lua_State *L) { - zmq_msg_t * this1 = obj_type_zmq_msg_t_check(L,1); - size_t data_len2; - const char * data2 = luaL_checklstring(L,2,&(data_len2)); - ZMQ_Error err1 = 0; - /* check message data size. */ - if(zmq_msg_size(this1) != data_len2) { - /* need to resize message. */ - zmq_msg_close(this1); /* close old message, to free old data. */ - err1 = zmq_msg_init_size(this1, data_len2); /* re-initialize message. */ - if(0 != err1) { - luaL_error(L, "set_data() failed: %s", get_zmq_strerror()); - } - } - /* copy data into message */ - memcpy(zmq_msg_data(this1), data2, data_len2); +/* method: rcvbuf */ +#if (VERSION_2_0|VERSION_3_0) +static int ZMQ_Socket__rcvbuf__meth(lua_State *L) { + ZMQ_Socket * this1 = obj_type_ZMQ_Socket_check(L,1); + int value1 = 0; + ZMQ_Error rc_lzmq_socket_rcvbuf2 = 0; + rc_lzmq_socket_rcvbuf2 = lzmq_socket_rcvbuf(this1, &(value1)); + if(!(-1 == rc_lzmq_socket_rcvbuf2)) { + lua_pushinteger(L, value1); + } else { + lua_pushnil(L); + } + error_code__ZMQ_Error__push(L, rc_lzmq_socket_rcvbuf2); + return 2; +} +#endif +/* method: set_rcvbuf */ +#if (VERSION_2_0|VERSION_3_0) +static int ZMQ_Socket__set_rcvbuf__meth(lua_State *L) { + ZMQ_Socket * this1 = obj_type_ZMQ_Socket_check(L,1); + int value2 = luaL_checkinteger(L,2); + ZMQ_Error rc_lzmq_socket_set_rcvbuf1 = 0; + rc_lzmq_socket_set_rcvbuf1 = lzmq_socket_set_rcvbuf(this1, value2); /* check for error. */ - if((-1 == err1)) { + if((-1 == rc_lzmq_socket_set_rcvbuf1)) { lua_pushnil(L); - error_code__ZMQ_Error__push(L, err1); + error_code__ZMQ_Error__push(L, rc_lzmq_socket_set_rcvbuf1); } else { lua_pushboolean(L, 1); lua_pushnil(L); } return 2; } +#endif -/* method: data */ -static int zmq_msg_t__data__meth(lua_State *L) { - zmq_msg_t * this1 = obj_type_zmq_msg_t_check(L,1); - void * rc_zmq_msg_data1 = NULL; - rc_zmq_msg_data1 = zmq_msg_data(this1); - lua_pushlightuserdata(L, rc_zmq_msg_data1); - return 1; +/* method: rcvmore */ +#if (VERSION_2_0|VERSION_3_0) +static int ZMQ_Socket__rcvmore__meth(lua_State *L) { + ZMQ_Socket * this1 = obj_type_ZMQ_Socket_check(L,1); + int value1 = 0; + ZMQ_Error rc_lzmq_socket_rcvmore2 = 0; + rc_lzmq_socket_rcvmore2 = lzmq_socket_rcvmore(this1, &(value1)); + if(!(-1 == rc_lzmq_socket_rcvmore2)) { + lua_pushinteger(L, value1); + } else { + lua_pushnil(L); + } + error_code__ZMQ_Error__push(L, rc_lzmq_socket_rcvmore2); + return 2; } +#endif -/* method: set_size */ -static int zmq_msg_t__set_size__meth(lua_State *L) { - zmq_msg_t * this1 = obj_type_zmq_msg_t_check(L,1); - size_t size2 = luaL_checkinteger(L,2); - ZMQ_Error err1 = 0; - /* check message data size. */ - if(zmq_msg_size(this1) != size2) { - /* need to resize message. */ - zmq_msg_close(this1); /* close old message, to free old data. */ - err1 = zmq_msg_init_size(this1, size2); /* re-initialize message. */ - if(0 != err1) { - luaL_error(L, "set_size() failed: %s", get_zmq_strerror()); - } - } - - /* check for error. */ - if((-1 == err1)) { - lua_pushnil(L); - error_code__ZMQ_Error__push(L, err1); +/* method: fd */ +#if (VERSION_2_1|VERSION_3_0) +static int ZMQ_Socket__fd__meth(lua_State *L) { + ZMQ_Socket * this1 = obj_type_ZMQ_Socket_check(L,1); + int value1 = 0; + ZMQ_Error rc_lzmq_socket_fd2 = 0; + rc_lzmq_socket_fd2 = lzmq_socket_fd(this1, &(value1)); + if(!(-1 == rc_lzmq_socket_fd2)) { + lua_pushinteger(L, value1); } else { - lua_pushboolean(L, 1); lua_pushnil(L); } + error_code__ZMQ_Error__push(L, rc_lzmq_socket_fd2); return 2; } +#endif -/* method: size */ -static int zmq_msg_t__size__meth(lua_State *L) { - zmq_msg_t * this1 = obj_type_zmq_msg_t_check(L,1); - size_t rc_zmq_msg_size1 = 0; - rc_zmq_msg_size1 = zmq_msg_size(this1); - lua_pushinteger(L, rc_zmq_msg_size1); - return 1; +/* method: events */ +#if (VERSION_2_1|VERSION_3_0) +static int ZMQ_Socket__events__meth(lua_State *L) { + ZMQ_Socket * this1 = obj_type_ZMQ_Socket_check(L,1); + int value1 = 0; + ZMQ_Error rc_lzmq_socket_events2 = 0; + rc_lzmq_socket_events2 = lzmq_socket_events(this1, &(value1)); + if(!(-1 == rc_lzmq_socket_events2)) { + lua_pushinteger(L, value1); + } else { + lua_pushnil(L); + } + error_code__ZMQ_Error__push(L, rc_lzmq_socket_events2); + return 2; } +#endif -/* method: __tostring */ -static int zmq_msg_t____tostring__meth(lua_State *L) { - zmq_msg_t * this1 = obj_type_zmq_msg_t_check(L,1); - size_t data_len1 = 0; - const char * data1 = NULL; - data1 = zmq_msg_data(this1); - data_len1 = zmq_msg_size(this1); +/* method: type */ +#if (VERSION_2_1|VERSION_3_0) +static int ZMQ_Socket__type__meth(lua_State *L) { + ZMQ_Socket * this1 = obj_type_ZMQ_Socket_check(L,1); + int value1 = 0; + ZMQ_Error rc_lzmq_socket_type2 = 0; + rc_lzmq_socket_type2 = lzmq_socket_type(this1, &(value1)); + if(!(-1 == rc_lzmq_socket_type2)) { + lua_pushinteger(L, value1); + } else { + lua_pushnil(L); + } + error_code__ZMQ_Error__push(L, rc_lzmq_socket_type2); + return 2; +} +#endif - if(data1 == NULL) lua_pushnil(L); else lua_pushlstring(L, data1,data_len1); - return 1; +/* method: linger */ +#if (VERSION_2_1|VERSION_3_0) +static int ZMQ_Socket__linger__meth(lua_State *L) { + ZMQ_Socket * this1 = obj_type_ZMQ_Socket_check(L,1); + int value1 = 0; + ZMQ_Error rc_lzmq_socket_linger2 = 0; + rc_lzmq_socket_linger2 = lzmq_socket_linger(this1, &(value1)); + if(!(-1 == rc_lzmq_socket_linger2)) { + lua_pushinteger(L, value1); + } else { + lua_pushnil(L); + } + error_code__ZMQ_Error__push(L, rc_lzmq_socket_linger2); + return 2; } +#endif -/* method: close */ -static int ZMQ_Socket__close__meth(lua_State *L) { - int this_flags1 = 0; - ZMQ_Socket * this1 = obj_type_ZMQ_Socket_delete(L,1,&(this_flags1)); - ZMQ_Error rc_zmq_close1 = 0; - if(!(this_flags1 & OBJ_UDATA_FLAG_OWN)) { return 0; } - rc_zmq_close1 = zmq_close(this1); +/* method: set_linger */ +#if (VERSION_2_1|VERSION_3_0) +static int ZMQ_Socket__set_linger__meth(lua_State *L) { + ZMQ_Socket * this1 = obj_type_ZMQ_Socket_check(L,1); + int value2 = luaL_checkinteger(L,2); + ZMQ_Error rc_lzmq_socket_set_linger1 = 0; + rc_lzmq_socket_set_linger1 = lzmq_socket_set_linger(this1, value2); /* check for error. */ - if((-1 == rc_zmq_close1)) { + if((-1 == rc_lzmq_socket_set_linger1)) { lua_pushnil(L); - error_code__ZMQ_Error__push(L, rc_zmq_close1); + error_code__ZMQ_Error__push(L, rc_lzmq_socket_set_linger1); } else { lua_pushboolean(L, 1); lua_pushnil(L); } return 2; } +#endif -/* method: bind */ -static int ZMQ_Socket__bind__meth(lua_State *L) { +/* method: reconnect_ivl */ +#if (VERSION_2_1|VERSION_3_0) +static int ZMQ_Socket__reconnect_ivl__meth(lua_State *L) { ZMQ_Socket * this1 = obj_type_ZMQ_Socket_check(L,1); - size_t addr_len2; - const char * addr2 = luaL_checklstring(L,2,&(addr_len2)); - ZMQ_Error rc_zmq_bind1 = 0; - rc_zmq_bind1 = zmq_bind(this1, addr2); - /* check for error. */ - if((-1 == rc_zmq_bind1)) { - lua_pushnil(L); - error_code__ZMQ_Error__push(L, rc_zmq_bind1); + int value1 = 0; + ZMQ_Error rc_lzmq_socket_reconnect_ivl2 = 0; + rc_lzmq_socket_reconnect_ivl2 = lzmq_socket_reconnect_ivl(this1, &(value1)); + if(!(-1 == rc_lzmq_socket_reconnect_ivl2)) { + lua_pushinteger(L, value1); } else { - lua_pushboolean(L, 1); lua_pushnil(L); } + error_code__ZMQ_Error__push(L, rc_lzmq_socket_reconnect_ivl2); return 2; } +#endif -/* method: connect */ -static int ZMQ_Socket__connect__meth(lua_State *L) { +/* method: set_reconnect_ivl */ +#if (VERSION_2_1|VERSION_3_0) +static int ZMQ_Socket__set_reconnect_ivl__meth(lua_State *L) { ZMQ_Socket * this1 = obj_type_ZMQ_Socket_check(L,1); - size_t addr_len2; - const char * addr2 = luaL_checklstring(L,2,&(addr_len2)); - ZMQ_Error rc_zmq_connect1 = 0; - rc_zmq_connect1 = zmq_connect(this1, addr2); + int value2 = luaL_checkinteger(L,2); + ZMQ_Error rc_lzmq_socket_set_reconnect_ivl1 = 0; + rc_lzmq_socket_set_reconnect_ivl1 = lzmq_socket_set_reconnect_ivl(this1, value2); /* check for error. */ - if((-1 == rc_zmq_connect1)) { + if((-1 == rc_lzmq_socket_set_reconnect_ivl1)) { lua_pushnil(L); - error_code__ZMQ_Error__push(L, rc_zmq_connect1); + error_code__ZMQ_Error__push(L, rc_lzmq_socket_set_reconnect_ivl1); } else { lua_pushboolean(L, 1); lua_pushnil(L); } return 2; } - -/* method: setopt */ -static int ZMQ_Socket__setopt__meth(lua_State *L) { - ZMQ_Socket * this1 = obj_type_ZMQ_Socket_check(L,1); - uint32_t opt2 = luaL_checkinteger(L,2); - ZMQ_Error err1 = 0; - size_t val_len; - const void *val; - -#if VERSION_2_1 - socket_t fd_val; #endif - int int_val; - uint32_t uint32_val; - uint64_t uint64_val; - int64_t int64_val; - - if(opt2 > MAX_OPTS) { - return luaL_argerror(L, 2, "Invalid socket option."); - } - switch(opt_types[opt2]) { -#if VERSION_2_1 - case OPT_TYPE_FD: - fd_val = luaL_checklong(L, 3); - val = &fd_val; - val_len = sizeof(fd_val); - break; +/* method: backlog */ +#if (VERSION_2_1|VERSION_3_0) +static int ZMQ_Socket__backlog__meth(lua_State *L) { + ZMQ_Socket * this1 = obj_type_ZMQ_Socket_check(L,1); + int value1 = 0; + ZMQ_Error rc_lzmq_socket_backlog2 = 0; + rc_lzmq_socket_backlog2 = lzmq_socket_backlog(this1, &(value1)); + if(!(-1 == rc_lzmq_socket_backlog2)) { + lua_pushinteger(L, value1); + } else { + lua_pushnil(L); + } + error_code__ZMQ_Error__push(L, rc_lzmq_socket_backlog2); + return 2; +} #endif - case OPT_TYPE_INT: - int_val = luaL_checklong(L, 3); - val = &int_val; - val_len = sizeof(int_val); - break; - case OPT_TYPE_UINT32: - uint32_val = luaL_checklong(L, 3); - val = &uint32_val; - val_len = sizeof(uint32_val); - break; - case OPT_TYPE_UINT64: - uint64_val = luaL_checklong(L, 3); - val = &uint64_val; - val_len = sizeof(uint64_val); - break; - case OPT_TYPE_INT64: - int64_val = luaL_checklong(L, 3); - val = &int64_val; - val_len = sizeof(int64_val); - break; - case OPT_TYPE_STR: - val = luaL_checklstring(L, 3, &(val_len)); - break; - default: - printf("Invalid socket option type, this shouldn't happen.\n"); - abort(); - break; - } - err1 = zmq_setsockopt(this1, opt2, val, val_len); +/* method: set_backlog */ +#if (VERSION_2_1|VERSION_3_0) +static int ZMQ_Socket__set_backlog__meth(lua_State *L) { + ZMQ_Socket * this1 = obj_type_ZMQ_Socket_check(L,1); + int value2 = luaL_checkinteger(L,2); + ZMQ_Error rc_lzmq_socket_set_backlog1 = 0; + rc_lzmq_socket_set_backlog1 = lzmq_socket_set_backlog(this1, value2); /* check for error. */ - if((-1 == err1)) { + if((-1 == rc_lzmq_socket_set_backlog1)) { lua_pushnil(L); - error_code__ZMQ_Error__push(L, err1); + error_code__ZMQ_Error__push(L, rc_lzmq_socket_set_backlog1); } else { lua_pushboolean(L, 1); lua_pushnil(L); } return 2; } +#endif -/* method: getopt */ -static int ZMQ_Socket__getopt__meth(lua_State *L) { +/* method: recovery_ivl_msec */ +#if (VERSION_2_1) +static int ZMQ_Socket__recovery_ivl_msec__meth(lua_State *L) { ZMQ_Socket * this1 = obj_type_ZMQ_Socket_check(L,1); - uint32_t opt2 = luaL_checkinteger(L,2); - ZMQ_Error err2 = 0; - size_t val_len; - -#if VERSION_2_1 - socket_t fd_val; + int64_t value1 = 0; + ZMQ_Error rc_lzmq_socket_recovery_ivl_msec2 = 0; + rc_lzmq_socket_recovery_ivl_msec2 = lzmq_socket_recovery_ivl_msec(this1, &(value1)); + if(!(-1 == rc_lzmq_socket_recovery_ivl_msec2)) { + lua_pushinteger(L, value1); + } else { + lua_pushnil(L); + } + error_code__ZMQ_Error__push(L, rc_lzmq_socket_recovery_ivl_msec2); + return 2; +} #endif - int int_val; - uint32_t uint32_val; - uint64_t uint64_val; - int64_t int64_val; -#define STR_MAX 255 - char str_val[STR_MAX]; - - if(opt2 > MAX_OPTS) { - lua_pushnil(L); - lua_pushliteral(L, "Invalid socket option."); - return 2; - } - switch(opt_types[opt2]) { -#if VERSION_2_1 - case OPT_TYPE_FD: - val_len = sizeof(fd_val); - err2 = zmq_getsockopt(this1, opt2, &fd_val, &val_len); - if(0 == err2) { - lua_pushinteger(L, (lua_Integer)fd_val); - return 1; - } - break; -#endif - case OPT_TYPE_INT: - val_len = sizeof(int_val); - err2 = zmq_getsockopt(this1, opt2, &int_val, &val_len); - if(0 == err2) { - lua_pushinteger(L, (lua_Integer)int_val); - return 1; - } - break; - case OPT_TYPE_UINT32: - val_len = sizeof(uint32_val); - err2 = zmq_getsockopt(this1, opt2, &uint32_val, &val_len); - if(0 == err2) { - lua_pushinteger(L, (lua_Integer)uint32_val); - return 1; - } - break; - case OPT_TYPE_UINT64: - val_len = sizeof(uint64_val); - err2 = zmq_getsockopt(this1, opt2, &uint64_val, &val_len); - if(0 == err2) { - lua_pushinteger(L, (lua_Integer)uint64_val); - return 1; - } - break; - case OPT_TYPE_INT64: - val_len = sizeof(int64_val); - err2 = zmq_getsockopt(this1, opt2, &int64_val, &val_len); - if(0 == err2) { - lua_pushinteger(L, (lua_Integer)int64_val); - return 1; - } - break; - case OPT_TYPE_STR: - val_len = STR_MAX; - err2 = zmq_getsockopt(this1, opt2, str_val, &val_len); - if(0 == err2) { - lua_pushlstring(L, str_val, val_len); - return 1; - } -#undef STR_MAX - break; - default: - printf("Invalid socket option type, this shouldn't happen.\n"); - abort(); - break; - } - lua_pushnil(L); +/* method: set_recovery_ivl_msec */ +#if (VERSION_2_1) +static int ZMQ_Socket__set_recovery_ivl_msec__meth(lua_State *L) { + ZMQ_Socket * this1 = obj_type_ZMQ_Socket_check(L,1); + int64_t value2 = luaL_checkinteger(L,2); + ZMQ_Error rc_lzmq_socket_set_recovery_ivl_msec1 = 0; + rc_lzmq_socket_set_recovery_ivl_msec1 = lzmq_socket_set_recovery_ivl_msec(this1, value2); + /* check for error. */ + if((-1 == rc_lzmq_socket_set_recovery_ivl_msec1)) { + lua_pushnil(L); + error_code__ZMQ_Error__push(L, rc_lzmq_socket_set_recovery_ivl_msec1); + } else { + lua_pushboolean(L, 1); + lua_pushnil(L); + } + return 2; +} +#endif - error_code__ZMQ_Error__push(L, err2); +/* method: reconnect_ivl_max */ +#if (VERSION_2_1|VERSION_3_0) +static int ZMQ_Socket__reconnect_ivl_max__meth(lua_State *L) { + ZMQ_Socket * this1 = obj_type_ZMQ_Socket_check(L,1); + int value1 = 0; + ZMQ_Error rc_lzmq_socket_reconnect_ivl_max2 = 0; + rc_lzmq_socket_reconnect_ivl_max2 = lzmq_socket_reconnect_ivl_max(this1, &(value1)); + if(!(-1 == rc_lzmq_socket_reconnect_ivl_max2)) { + lua_pushinteger(L, value1); + } else { + lua_pushnil(L); + } + error_code__ZMQ_Error__push(L, rc_lzmq_socket_reconnect_ivl_max2); return 2; } +#endif -/* method: events */ -static int ZMQ_Socket__events__meth(lua_State *L) { +/* method: set_reconnect_ivl_max */ +#if (VERSION_2_1|VERSION_3_0) +static int ZMQ_Socket__set_reconnect_ivl_max__meth(lua_State *L) { ZMQ_Socket * this1 = obj_type_ZMQ_Socket_check(L,1); - uint32_t events1 = 0; - ZMQ_Error err2 = 0; -#if VERSION_2_1 - size_t val_len = sizeof(events1); - err2 = zmq_getsockopt(this1, ZMQ_EVENTS, &(events1), &val_len); -#else - luaL_error(L, "'events' method only supported in 0MQ version >= 2.1"); + int value2 = luaL_checkinteger(L,2); + ZMQ_Error rc_lzmq_socket_set_reconnect_ivl_max1 = 0; + rc_lzmq_socket_set_reconnect_ivl_max1 = lzmq_socket_set_reconnect_ivl_max(this1, value2); + /* check for error. */ + if((-1 == rc_lzmq_socket_set_reconnect_ivl_max1)) { + lua_pushnil(L); + error_code__ZMQ_Error__push(L, rc_lzmq_socket_set_reconnect_ivl_max1); + } else { + lua_pushboolean(L, 1); + lua_pushnil(L); + } + return 2; +} #endif - if(!(-1 == err2)) { - lua_pushinteger(L, events1); +/* method: maxmsgsize */ +#if (VERSION_3_0) +static int ZMQ_Socket__maxmsgsize__meth(lua_State *L) { + ZMQ_Socket * this1 = obj_type_ZMQ_Socket_check(L,1); + int64_t value1 = 0; + ZMQ_Error rc_lzmq_socket_maxmsgsize2 = 0; + rc_lzmq_socket_maxmsgsize2 = lzmq_socket_maxmsgsize(this1, &(value1)); + if(!(-1 == rc_lzmq_socket_maxmsgsize2)) { + lua_pushinteger(L, value1); } else { lua_pushnil(L); } - error_code__ZMQ_Error__push(L, err2); + error_code__ZMQ_Error__push(L, rc_lzmq_socket_maxmsgsize2); return 2; } +#endif -/* method: send_msg */ -static int ZMQ_Socket__send_msg__meth(lua_State *L) { +/* method: set_maxmsgsize */ +#if (VERSION_3_0) +static int ZMQ_Socket__set_maxmsgsize__meth(lua_State *L) { ZMQ_Socket * this1 = obj_type_ZMQ_Socket_check(L,1); - zmq_msg_t * msg2 = obj_type_zmq_msg_t_check(L,2); - int flags3 = luaL_optinteger(L,3,0); - ZMQ_Error rc_zmq_send1 = 0; - rc_zmq_send1 = zmq_send(this1, msg2, flags3); + int64_t value2 = luaL_checkinteger(L,2); + ZMQ_Error rc_lzmq_socket_set_maxmsgsize1 = 0; + rc_lzmq_socket_set_maxmsgsize1 = lzmq_socket_set_maxmsgsize(this1, value2); /* check for error. */ - if((-1 == rc_zmq_send1)) { + if((-1 == rc_lzmq_socket_set_maxmsgsize1)) { lua_pushnil(L); - error_code__ZMQ_Error__push(L, rc_zmq_send1); + error_code__ZMQ_Error__push(L, rc_lzmq_socket_set_maxmsgsize1); } else { lua_pushboolean(L, 1); lua_pushnil(L); } return 2; } +#endif + +/* method: sndhwm */ +#if (VERSION_3_0) +static int ZMQ_Socket__sndhwm__meth(lua_State *L) { + ZMQ_Socket * this1 = obj_type_ZMQ_Socket_check(L,1); + int value1 = 0; + ZMQ_Error rc_lzmq_socket_sndhwm2 = 0; + rc_lzmq_socket_sndhwm2 = lzmq_socket_sndhwm(this1, &(value1)); + if(!(-1 == rc_lzmq_socket_sndhwm2)) { + lua_pushinteger(L, value1); + } else { + lua_pushnil(L); + } + error_code__ZMQ_Error__push(L, rc_lzmq_socket_sndhwm2); + return 2; +} +#endif -/* method: send */ -static int ZMQ_Socket__send__meth(lua_State *L) { +/* method: set_sndhwm */ +#if (VERSION_3_0) +static int ZMQ_Socket__set_sndhwm__meth(lua_State *L) { ZMQ_Socket * this1 = obj_type_ZMQ_Socket_check(L,1); - size_t data_len2; - const char * data2 = luaL_checklstring(L,2,&(data_len2)); - int flags3 = luaL_optinteger(L,3,0); - ZMQ_Error rc_simple_zmq_send1 = 0; - rc_simple_zmq_send1 = simple_zmq_send(this1, data2, data_len2, flags3); + int value2 = luaL_checkinteger(L,2); + ZMQ_Error rc_lzmq_socket_set_sndhwm1 = 0; + rc_lzmq_socket_set_sndhwm1 = lzmq_socket_set_sndhwm(this1, value2); /* check for error. */ - if((-1 == rc_simple_zmq_send1)) { + if((-1 == rc_lzmq_socket_set_sndhwm1)) { lua_pushnil(L); - error_code__ZMQ_Error__push(L, rc_simple_zmq_send1); + error_code__ZMQ_Error__push(L, rc_lzmq_socket_set_sndhwm1); } else { lua_pushboolean(L, 1); lua_pushnil(L); } return 2; } +#endif -/* method: recv_msg */ -static int ZMQ_Socket__recv_msg__meth(lua_State *L) { +/* method: rcvhwm */ +#if (VERSION_3_0) +static int ZMQ_Socket__rcvhwm__meth(lua_State *L) { ZMQ_Socket * this1 = obj_type_ZMQ_Socket_check(L,1); - zmq_msg_t * msg2 = obj_type_zmq_msg_t_check(L,2); - int flags3 = luaL_optinteger(L,3,0); - ZMQ_Error rc_zmq_recv1 = 0; - rc_zmq_recv1 = zmq_recv(this1, msg2, flags3); + int value1 = 0; + ZMQ_Error rc_lzmq_socket_rcvhwm2 = 0; + rc_lzmq_socket_rcvhwm2 = lzmq_socket_rcvhwm(this1, &(value1)); + if(!(-1 == rc_lzmq_socket_rcvhwm2)) { + lua_pushinteger(L, value1); + } else { + lua_pushnil(L); + } + error_code__ZMQ_Error__push(L, rc_lzmq_socket_rcvhwm2); + return 2; +} +#endif + +/* method: set_rcvhwm */ +#if (VERSION_3_0) +static int ZMQ_Socket__set_rcvhwm__meth(lua_State *L) { + ZMQ_Socket * this1 = obj_type_ZMQ_Socket_check(L,1); + int value2 = luaL_checkinteger(L,2); + ZMQ_Error rc_lzmq_socket_set_rcvhwm1 = 0; + rc_lzmq_socket_set_rcvhwm1 = lzmq_socket_set_rcvhwm(this1, value2); /* check for error. */ - if((-1 == rc_zmq_recv1)) { + if((-1 == rc_lzmq_socket_set_rcvhwm1)) { lua_pushnil(L); - error_code__ZMQ_Error__push(L, rc_zmq_recv1); + error_code__ZMQ_Error__push(L, rc_lzmq_socket_set_rcvhwm1); } else { lua_pushboolean(L, 1); lua_pushnil(L); } return 2; } +#endif -/* method: recv */ -static int ZMQ_Socket__recv__meth(lua_State *L) { +/* method: multicast_hops */ +#if (VERSION_3_0) +static int ZMQ_Socket__multicast_hops__meth(lua_State *L) { ZMQ_Socket * this1 = obj_type_ZMQ_Socket_check(L,1); - int flags2 = luaL_optinteger(L,2,0); - size_t data_len1 = 0; - const char * data1 = NULL; - ZMQ_Error err2 = 0; - zmq_msg_t msg; - /* initialize message */ - err2 = zmq_msg_init(&msg); - if(0 == err2) { - /* receive message */ - err2 = zmq_recv(this1, &msg, flags2); - if(0 == err2) { - data1 = zmq_msg_data(&msg); - data_len1 = zmq_msg_size(&msg); - } - } + int value1 = 0; + ZMQ_Error rc_lzmq_socket_multicast_hops2 = 0; + rc_lzmq_socket_multicast_hops2 = lzmq_socket_multicast_hops(this1, &(value1)); + if(!(-1 == rc_lzmq_socket_multicast_hops2)) { + lua_pushinteger(L, value1); + } else { + lua_pushnil(L); + } + error_code__ZMQ_Error__push(L, rc_lzmq_socket_multicast_hops2); + return 2; +} +#endif - if(!(-1 == err2)) { - if(data1 == NULL) lua_pushnil(L); else lua_pushlstring(L, data1,data_len1); +/* method: set_multicast_hops */ +#if (VERSION_3_0) +static int ZMQ_Socket__set_multicast_hops__meth(lua_State *L) { + ZMQ_Socket * this1 = obj_type_ZMQ_Socket_check(L,1); + int value2 = luaL_checkinteger(L,2); + ZMQ_Error rc_lzmq_socket_set_multicast_hops1 = 0; + rc_lzmq_socket_set_multicast_hops1 = lzmq_socket_set_multicast_hops(this1, value2); + /* check for error. */ + if((-1 == rc_lzmq_socket_set_multicast_hops1)) { + lua_pushnil(L); + error_code__ZMQ_Error__push(L, rc_lzmq_socket_set_multicast_hops1); } else { + lua_pushboolean(L, 1); lua_pushnil(L); } - error_code__ZMQ_Error__push(L, err2); - /* close message */ - zmq_msg_close(&msg); + return 2; +} +#endif + +/* method: rcvtimeo */ +#if (VERSION_3_0) +static int ZMQ_Socket__rcvtimeo__meth(lua_State *L) { + ZMQ_Socket * this1 = obj_type_ZMQ_Socket_check(L,1); + int value1 = 0; + ZMQ_Error rc_lzmq_socket_rcvtimeo2 = 0; + rc_lzmq_socket_rcvtimeo2 = lzmq_socket_rcvtimeo(this1, &(value1)); + if(!(-1 == rc_lzmq_socket_rcvtimeo2)) { + lua_pushinteger(L, value1); + } else { + lua_pushnil(L); + } + error_code__ZMQ_Error__push(L, rc_lzmq_socket_rcvtimeo2); + return 2; +} +#endif + +/* method: set_rcvtimeo */ +#if (VERSION_3_0) +static int ZMQ_Socket__set_rcvtimeo__meth(lua_State *L) { + ZMQ_Socket * this1 = obj_type_ZMQ_Socket_check(L,1); + int value2 = luaL_checkinteger(L,2); + ZMQ_Error rc_lzmq_socket_set_rcvtimeo1 = 0; + rc_lzmq_socket_set_rcvtimeo1 = lzmq_socket_set_rcvtimeo(this1, value2); + /* check for error. */ + if((-1 == rc_lzmq_socket_set_rcvtimeo1)) { + lua_pushnil(L); + error_code__ZMQ_Error__push(L, rc_lzmq_socket_set_rcvtimeo1); + } else { + lua_pushboolean(L, 1); + lua_pushnil(L); + } + return 2; +} +#endif + +/* method: sndtimeo */ +#if (VERSION_3_0) +static int ZMQ_Socket__sndtimeo__meth(lua_State *L) { + ZMQ_Socket * this1 = obj_type_ZMQ_Socket_check(L,1); + int value1 = 0; + ZMQ_Error rc_lzmq_socket_sndtimeo2 = 0; + rc_lzmq_socket_sndtimeo2 = lzmq_socket_sndtimeo(this1, &(value1)); + if(!(-1 == rc_lzmq_socket_sndtimeo2)) { + lua_pushinteger(L, value1); + } else { + lua_pushnil(L); + } + error_code__ZMQ_Error__push(L, rc_lzmq_socket_sndtimeo2); + return 2; +} +#endif + +/* method: set_sndtimeo */ +#if (VERSION_3_0) +static int ZMQ_Socket__set_sndtimeo__meth(lua_State *L) { + ZMQ_Socket * this1 = obj_type_ZMQ_Socket_check(L,1); + int value2 = luaL_checkinteger(L,2); + ZMQ_Error rc_lzmq_socket_set_sndtimeo1 = 0; + rc_lzmq_socket_set_sndtimeo1 = lzmq_socket_set_sndtimeo(this1, value2); + /* check for error. */ + if((-1 == rc_lzmq_socket_set_sndtimeo1)) { + lua_pushnil(L); + error_code__ZMQ_Error__push(L, rc_lzmq_socket_set_sndtimeo1); + } else { + lua_pushboolean(L, 1); + lua_pushnil(L); + } + return 2; +} +#endif + +/* method: rcvlabel */ +#if (VERSION_3_0) +static int ZMQ_Socket__rcvlabel__meth(lua_State *L) { + ZMQ_Socket * this1 = obj_type_ZMQ_Socket_check(L,1); + int value1 = 0; + ZMQ_Error rc_lzmq_socket_rcvlabel2 = 0; + rc_lzmq_socket_rcvlabel2 = lzmq_socket_rcvlabel(this1, &(value1)); + if(!(-1 == rc_lzmq_socket_rcvlabel2)) { + lua_pushinteger(L, value1); + } else { + lua_pushnil(L); + } + error_code__ZMQ_Error__push(L, rc_lzmq_socket_rcvlabel2); + return 2; +} +#endif +/* method: set_rcvlabel */ +#if (VERSION_3_0) +static int ZMQ_Socket__set_rcvlabel__meth(lua_State *L) { + ZMQ_Socket * this1 = obj_type_ZMQ_Socket_check(L,1); + int value2 = luaL_checkinteger(L,2); + ZMQ_Error rc_lzmq_socket_set_rcvlabel1 = 0; + rc_lzmq_socket_set_rcvlabel1 = lzmq_socket_set_rcvlabel(this1, value2); + /* check for error. */ + if((-1 == rc_lzmq_socket_set_rcvlabel1)) { + lua_pushnil(L); + error_code__ZMQ_Error__push(L, rc_lzmq_socket_set_rcvlabel1); + } else { + lua_pushboolean(L, 1); + lua_pushnil(L); + } return 2; } +#endif /* method: new */ static int ZMQ_Poller__new__meth(lua_State *L) { unsigned int length1 = luaL_optinteger(L,1,10); - ZMQ_Poller * this1; - ZMQ_Poller poller; - this1 = &poller; - + ZMQ_Poller this1_store; + ZMQ_Poller * this1 = &(this1_store);; poller_init(this1, length1); obj_type_ZMQ_Poller_push(L, this1); return 1; @@ -3841,11 +5849,154 @@ static const luaL_reg obj_ZMQ_Socket_methods[] = { {"connect", ZMQ_Socket__connect__meth}, {"setopt", ZMQ_Socket__setopt__meth}, {"getopt", ZMQ_Socket__getopt__meth}, - {"events", ZMQ_Socket__events__meth}, {"send_msg", ZMQ_Socket__send_msg__meth}, {"send", ZMQ_Socket__send__meth}, {"recv_msg", ZMQ_Socket__recv_msg__meth}, {"recv", ZMQ_Socket__recv__meth}, +#if (VERSION_2_0|VERSION_3_0) + {"hwm", ZMQ_Socket__hwm__meth}, +#endif +#if (VERSION_2_0|VERSION_3_0) + {"set_hwm", ZMQ_Socket__set_hwm__meth}, +#endif +#if (VERSION_2_0) + {"swap", ZMQ_Socket__swap__meth}, +#endif +#if (VERSION_2_0) + {"set_swap", ZMQ_Socket__set_swap__meth}, +#endif +#if (VERSION_2_0|VERSION_3_0) + {"affinity", ZMQ_Socket__affinity__meth}, +#endif +#if (VERSION_2_0|VERSION_3_0) + {"set_affinity", ZMQ_Socket__set_affinity__meth}, +#endif +#if (VERSION_2_0|VERSION_3_0) + {"identity", ZMQ_Socket__identity__meth}, +#endif +#if (VERSION_2_0|VERSION_3_0) + {"set_identity", ZMQ_Socket__set_identity__meth}, +#endif +#if (VERSION_2_0|VERSION_3_0) + {"subscribe", ZMQ_Socket__subscribe__meth}, +#endif +#if (VERSION_2_0|VERSION_3_0) + {"unsubscribe", ZMQ_Socket__unsubscribe__meth}, +#endif +#if (VERSION_2_0|VERSION_3_0) + {"rate", ZMQ_Socket__rate__meth}, +#endif +#if (VERSION_2_0|VERSION_3_0) + {"set_rate", ZMQ_Socket__set_rate__meth}, +#endif +#if (VERSION_2_0|VERSION_3_0) + {"recovery_ivl", ZMQ_Socket__recovery_ivl__meth}, +#endif +#if (VERSION_2_0|VERSION_3_0) + {"set_recovery_ivl", ZMQ_Socket__set_recovery_ivl__meth}, +#endif +#if (VERSION_2_0|VERSION_3_0) + {"mcast_loop", ZMQ_Socket__mcast_loop__meth}, +#endif +#if (VERSION_2_0|VERSION_3_0) + {"set_mcast_loop", ZMQ_Socket__set_mcast_loop__meth}, +#endif +#if (VERSION_2_0|VERSION_3_0) + {"sndbuf", ZMQ_Socket__sndbuf__meth}, +#endif +#if (VERSION_2_0|VERSION_3_0) + {"set_sndbuf", ZMQ_Socket__set_sndbuf__meth}, +#endif +#if (VERSION_2_0|VERSION_3_0) + {"rcvbuf", ZMQ_Socket__rcvbuf__meth}, +#endif +#if (VERSION_2_0|VERSION_3_0) + {"set_rcvbuf", ZMQ_Socket__set_rcvbuf__meth}, +#endif +#if (VERSION_2_0|VERSION_3_0) + {"rcvmore", ZMQ_Socket__rcvmore__meth}, +#endif +#if (VERSION_2_1|VERSION_3_0) + {"fd", ZMQ_Socket__fd__meth}, +#endif +#if (VERSION_2_1|VERSION_3_0) + {"events", ZMQ_Socket__events__meth}, +#endif +#if (VERSION_2_1|VERSION_3_0) + {"type", ZMQ_Socket__type__meth}, +#endif +#if (VERSION_2_1|VERSION_3_0) + {"linger", ZMQ_Socket__linger__meth}, +#endif +#if (VERSION_2_1|VERSION_3_0) + {"set_linger", ZMQ_Socket__set_linger__meth}, +#endif +#if (VERSION_2_1|VERSION_3_0) + {"reconnect_ivl", ZMQ_Socket__reconnect_ivl__meth}, +#endif +#if (VERSION_2_1|VERSION_3_0) + {"set_reconnect_ivl", ZMQ_Socket__set_reconnect_ivl__meth}, +#endif +#if (VERSION_2_1|VERSION_3_0) + {"backlog", ZMQ_Socket__backlog__meth}, +#endif +#if (VERSION_2_1|VERSION_3_0) + {"set_backlog", ZMQ_Socket__set_backlog__meth}, +#endif +#if (VERSION_2_1) + {"recovery_ivl_msec", ZMQ_Socket__recovery_ivl_msec__meth}, +#endif +#if (VERSION_2_1) + {"set_recovery_ivl_msec", ZMQ_Socket__set_recovery_ivl_msec__meth}, +#endif +#if (VERSION_2_1|VERSION_3_0) + {"reconnect_ivl_max", ZMQ_Socket__reconnect_ivl_max__meth}, +#endif +#if (VERSION_2_1|VERSION_3_0) + {"set_reconnect_ivl_max", ZMQ_Socket__set_reconnect_ivl_max__meth}, +#endif +#if (VERSION_3_0) + {"maxmsgsize", ZMQ_Socket__maxmsgsize__meth}, +#endif +#if (VERSION_3_0) + {"set_maxmsgsize", ZMQ_Socket__set_maxmsgsize__meth}, +#endif +#if (VERSION_3_0) + {"sndhwm", ZMQ_Socket__sndhwm__meth}, +#endif +#if (VERSION_3_0) + {"set_sndhwm", ZMQ_Socket__set_sndhwm__meth}, +#endif +#if (VERSION_3_0) + {"rcvhwm", ZMQ_Socket__rcvhwm__meth}, +#endif +#if (VERSION_3_0) + {"set_rcvhwm", ZMQ_Socket__set_rcvhwm__meth}, +#endif +#if (VERSION_3_0) + {"multicast_hops", ZMQ_Socket__multicast_hops__meth}, +#endif +#if (VERSION_3_0) + {"set_multicast_hops", ZMQ_Socket__set_multicast_hops__meth}, +#endif +#if (VERSION_3_0) + {"rcvtimeo", ZMQ_Socket__rcvtimeo__meth}, +#endif +#if (VERSION_3_0) + {"set_rcvtimeo", ZMQ_Socket__set_rcvtimeo__meth}, +#endif +#if (VERSION_3_0) + {"sndtimeo", ZMQ_Socket__sndtimeo__meth}, +#endif +#if (VERSION_3_0) + {"set_sndtimeo", ZMQ_Socket__set_sndtimeo__meth}, +#endif +#if (VERSION_3_0) + {"rcvlabel", ZMQ_Socket__rcvlabel__meth}, +#endif +#if (VERSION_3_0) + {"set_rcvlabel", ZMQ_Socket__set_rcvlabel__meth}, +#endif {NULL, NULL} }; @@ -3974,48 +6125,165 @@ static const luaL_reg zmq_function[] = { }; static const obj_const zmq_constants[] = { - {"TYPE", NULL, 16, CONST_NUMBER}, - {"RCVMORE", NULL, 13, CONST_NUMBER}, - {"LINGER", NULL, 17, CONST_NUMBER}, - {"SWAP", NULL, 3, CONST_NUMBER}, - {"MSG_SHARED", NULL, 128, CONST_NUMBER}, - {"SNDBUF", NULL, 11, CONST_NUMBER}, - {"STREAMER", NULL, 1, CONST_NUMBER}, - {"DEALER", NULL, 5, CONST_NUMBER}, - {"ROUTER", NULL, 6, CONST_NUMBER}, - {"NOBLOCK", NULL, 1, CONST_NUMBER}, - {"RCVBUF", NULL, 12, CONST_NUMBER}, - {"FORWARDER", NULL, 2, CONST_NUMBER}, - {"RATE", NULL, 8, CONST_NUMBER}, - {"IDENTITY", NULL, 5, CONST_NUMBER}, - {"SUB", NULL, 2, CONST_NUMBER}, - {"FD", NULL, 14, CONST_NUMBER}, - {"PUB", NULL, 1, CONST_NUMBER}, - {"DELIMITER", NULL, 31, CONST_NUMBER}, - {"BACKLOG", NULL, 19, CONST_NUMBER}, - {"SNDMORE", NULL, 2, CONST_NUMBER}, - {"POLLIN", NULL, 1, CONST_NUMBER}, - {"REP", NULL, 4, CONST_NUMBER}, - {"POLLERR", NULL, 4, CONST_NUMBER}, - {"AFFINITY", NULL, 4, CONST_NUMBER}, - {"VSM", NULL, 32, CONST_NUMBER}, - {"HWM", NULL, 1, CONST_NUMBER}, - {"MSG_MORE", NULL, 1, CONST_NUMBER}, - {"REQ", NULL, 3, CONST_NUMBER}, - {"UNSUBSCRIBE", NULL, 7, CONST_NUMBER}, - {"PULL", NULL, 7, CONST_NUMBER}, - {"PUSH", NULL, 8, CONST_NUMBER}, - {"QUEUE", NULL, 3, CONST_NUMBER}, - {"XREQ", NULL, 5, CONST_NUMBER}, - {"PAIR", NULL, 0, CONST_NUMBER}, - {"XREP", NULL, 6, CONST_NUMBER}, - {"SUBSCRIBE", NULL, 6, CONST_NUMBER}, - {"MCAST_LOOP", NULL, 10, CONST_NUMBER}, - {"EVENTS", NULL, 15, CONST_NUMBER}, - {"RECOVERY_IVL", NULL, 9, CONST_NUMBER}, - {"RECONNECT_IVL", NULL, 18, CONST_NUMBER}, - {"POLLOUT", NULL, 2, CONST_NUMBER}, - {"MAX_VSM_SIZE", NULL, 30, CONST_NUMBER}, +#ifdef ZMQ_TYPE + {"TYPE", NULL, ZMQ_TYPE, CONST_NUMBER}, +#endif +#ifdef ZMQ_RCVMORE + {"RCVMORE", NULL, ZMQ_RCVMORE, CONST_NUMBER}, +#endif +#ifdef ZMQ_LINGER + {"LINGER", NULL, ZMQ_LINGER, CONST_NUMBER}, +#endif +#ifdef ZMQ_REP + {"REP", NULL, ZMQ_REP, CONST_NUMBER}, +#endif +#ifdef ZMQ_MSG_SHARED + {"MSG_SHARED", NULL, ZMQ_MSG_SHARED, CONST_NUMBER}, +#endif +#ifdef ZMQ_SNDBUF + {"SNDBUF", NULL, ZMQ_SNDBUF, CONST_NUMBER}, +#endif +#ifdef ZMQ_MAX_VSM_SIZE + {"MAX_VSM_SIZE", NULL, ZMQ_MAX_VSM_SIZE, CONST_NUMBER}, +#endif +#ifdef ZMQ_DEALER + {"DEALER", NULL, ZMQ_DEALER, CONST_NUMBER}, +#endif +#ifdef ZMQ_ROUTER + {"ROUTER", NULL, ZMQ_ROUTER, CONST_NUMBER}, +#endif +#ifdef ZMQ_NOBLOCK + {"NOBLOCK", NULL, ZMQ_NOBLOCK, CONST_NUMBER}, +#endif +#ifdef ZMQ_RCVBUF + {"RCVBUF", NULL, ZMQ_RCVBUF, CONST_NUMBER}, +#endif +#ifdef ZMQ_FORWARDER + {"FORWARDER", NULL, ZMQ_FORWARDER, CONST_NUMBER}, +#endif +#ifdef ZMQ_SNDHWM + {"SNDHWM", NULL, ZMQ_SNDHWM, CONST_NUMBER}, +#endif +#ifdef ZMQ_IDENTITY + {"IDENTITY", NULL, ZMQ_IDENTITY, CONST_NUMBER}, +#endif +#ifdef ZMQ_SWAP + {"SWAP", NULL, ZMQ_SWAP, CONST_NUMBER}, +#endif +#ifdef ZMQ_RATE + {"RATE", NULL, ZMQ_RATE, CONST_NUMBER}, +#endif +#ifdef ZMQ_STREAMER + {"STREAMER", NULL, ZMQ_STREAMER, CONST_NUMBER}, +#endif +#ifdef ZMQ_MSG_MORE + {"MSG_MORE", NULL, ZMQ_MSG_MORE, CONST_NUMBER}, +#endif +#ifdef ZMQ_MAXMSGSIZE + {"MAXMSGSIZE", NULL, ZMQ_MAXMSGSIZE, CONST_NUMBER}, +#endif +#ifdef ZMQ_SUB + {"SUB", NULL, ZMQ_SUB, CONST_NUMBER}, +#endif +#ifdef ZMQ_PULL + {"PULL", NULL, ZMQ_PULL, CONST_NUMBER}, +#endif +#ifdef ZMQ_PAIR + {"PAIR", NULL, ZMQ_PAIR, CONST_NUMBER}, +#endif +#ifdef ZMQ_DEALER + {"XREQ", NULL, ZMQ_DEALER, CONST_NUMBER}, +#endif +#ifdef ZMQ_VSM + {"VSM", NULL, ZMQ_VSM, CONST_NUMBER}, +#endif +#ifdef ZMQ_PUB + {"PUB", NULL, ZMQ_PUB, CONST_NUMBER}, +#endif +#ifdef ZMQ_DELIMITER + {"DELIMITER", NULL, ZMQ_DELIMITER, CONST_NUMBER}, +#endif +#ifdef ZMQ_EVENTS + {"EVENTS", NULL, ZMQ_EVENTS, CONST_NUMBER}, +#endif +#ifdef ZMQ_SNDMORE + {"SNDMORE", NULL, ZMQ_SNDMORE, CONST_NUMBER}, +#endif +#ifdef ZMQ_FD + {"FD", NULL, ZMQ_FD, CONST_NUMBER}, +#endif +#ifdef ZMQ_MULTICAST_HOPS + {"MULTICAST_HOPS", NULL, ZMQ_MULTICAST_HOPS, CONST_NUMBER}, +#endif +#ifdef ZMQ_PUSH + {"PUSH", NULL, ZMQ_PUSH, CONST_NUMBER}, +#endif +#ifdef ZMQ_UNSUBSCRIBE + {"UNSUBSCRIBE", NULL, ZMQ_UNSUBSCRIBE, CONST_NUMBER}, +#endif +#ifdef ZMQ_RCVLABEL + {"RCVLABEL", NULL, ZMQ_RCVLABEL, CONST_NUMBER}, +#endif +#ifdef ZMQ_POLLERR + {"POLLERR", NULL, ZMQ_POLLERR, CONST_NUMBER}, +#endif +#ifdef ZMQ_RCVTIMEO + {"RCVTIMEO", NULL, ZMQ_RCVTIMEO, CONST_NUMBER}, +#endif +#ifdef ZMQ_SNDTIMEO + {"SNDTIMEO", NULL, ZMQ_SNDTIMEO, CONST_NUMBER}, +#endif +#ifdef ZMQ_HWM + {"HWM", NULL, ZMQ_HWM, CONST_NUMBER}, +#endif +#ifdef ZMQ_AFFINITY + {"AFFINITY", NULL, ZMQ_AFFINITY, CONST_NUMBER}, +#endif +#ifdef ZMQ_REQ + {"REQ", NULL, ZMQ_REQ, CONST_NUMBER}, +#endif +#ifdef ZMQ_RECONNECT_IVL_MSEC + {"RECONNECT_IVL_MSEC", NULL, ZMQ_RECONNECT_IVL_MSEC, CONST_NUMBER}, +#endif +#ifdef ZMQ_BACKLOG + {"BACKLOG", NULL, ZMQ_BACKLOG, CONST_NUMBER}, +#endif +#ifdef ZMQ_SNDLABEL + {"SNDLABEL", NULL, ZMQ_SNDLABEL, CONST_NUMBER}, +#endif +#ifdef ZMQ_QUEUE + {"QUEUE", NULL, ZMQ_QUEUE, CONST_NUMBER}, +#endif +#ifdef ZMQ_RECONNECT_IVL_MAX + {"RECONNECT_IVL_MAX", NULL, ZMQ_RECONNECT_IVL_MAX, CONST_NUMBER}, +#endif +#ifdef ZMQ_POLLIN + {"POLLIN", NULL, ZMQ_POLLIN, CONST_NUMBER}, +#endif +#ifdef ZMQ_ROUTER + {"XREP", NULL, ZMQ_ROUTER, CONST_NUMBER}, +#endif +#ifdef ZMQ_SUBSCRIBE + {"SUBSCRIBE", NULL, ZMQ_SUBSCRIBE, CONST_NUMBER}, +#endif +#ifdef ZMQ_MCAST_LOOP + {"MCAST_LOOP", NULL, ZMQ_MCAST_LOOP, CONST_NUMBER}, +#endif +#ifdef ZMQ_RCVHWM + {"RCVHWM", NULL, ZMQ_RCVHWM, CONST_NUMBER}, +#endif +#ifdef ZMQ_RECOVERY_IVL + {"RECOVERY_IVL", NULL, ZMQ_RECOVERY_IVL, CONST_NUMBER}, +#endif +#ifdef ZMQ_RECONNECT_IVL + {"RECONNECT_IVL", NULL, ZMQ_RECONNECT_IVL, CONST_NUMBER}, +#endif +#ifdef ZMQ_POLLOUT + {"POLLOUT", NULL, ZMQ_POLLOUT, CONST_NUMBER}, +#endif +#ifdef ZMQ_POLL_MSEC + {"POLL_MSEC", NULL, ZMQ_POLL_MSEC, CONST_NUMBER}, +#endif {NULL, NULL, 0.0 , 0} }; @@ -4037,6 +6305,8 @@ static const reg_sub_module reg_sub_modules[] = { #if LUAJIT_FFI static const ffi_export_symbol zmq_ffi_export[] = { +{ "zmq_sendmsg", zmq_sendmsg }, +{ "zmq_recvmsg", zmq_recvmsg }, {NULL, NULL} }; #endif @@ -4085,7 +6355,8 @@ LUA_NOBJ_API int luaopen_zmq(lua_State *L) { create_object_instance_cache(L); /* module table. */ - luaL_register(L, "zmq", zmq_function); + lua_newtable(L); + luaL_register(L, NULL, zmq_function); /* register module constants. */ obj_type_register_constants(L, zmq_constants, -1, false); diff --git a/src/socket.nobj.lua b/src/socket.nobj.lua index bdca021..ce2ad30 100644 --- a/src/socket.nobj.lua +++ b/src/socket.nobj.lua @@ -18,6 +18,12 @@ -- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -- THE SOFTWARE. +------------------------------------------------------------------------------------- +-- +-- Generate ZeroMQ socket option code customized for each version of zmq (2.0,2.1,3.x) +-- +------------------------------------------------------------------------------------- + local OPT_TYPES = { NONE = "NONE", INT = "int", @@ -34,7 +40,7 @@ w = { c_set = "lzmq_socket_", set='' }, } local socket_options = { - { ver_def = 'VERSION_2_0', + { ver_def = 'VERSION_2_0', major = 2, minor = 0, [1] = { name="hwm", otype="UINT64", mode="rw", ltype="int" }, [2] = { }, [3] = { name="swap", otype="INT64", mode="rw", ltype="int" }, @@ -49,7 +55,7 @@ local socket_options = { [12] = { name="rcvbuf", otype="UINT64", mode="rw", ltype="int" }, [13] = { name="rcvmore", otype="INT64", mode="r", ltype="int" }, }, - { ver_def = 'version_2_1', + { ver_def = 'VERSION_2_1', major = 2, minor = 1, [14] = { name="fd", otype="FD", mode="r", ltype="int" }, [15] = { name="events", otype="UINT32", mode="r", ltype="int" }, [16] = { name="type", otype="INT", mode="r", ltype="int" }, @@ -59,7 +65,7 @@ local socket_options = { [20] = { name="recovery_ivl_msec", otype="INT64", mode="rw", ltype="int64_t" }, [21] = { name="reconnect_ivl_max", otype="INT", mode="rw", ltype="int" }, }, - { ver_def = 'VERSION_3_0', + { ver_def = 'VERSION_3_0', major = 3, minor = 0, [1] = { name="hwm", otype="INT", mode="rw", custom = [[ ZMQ_Error lzmq_socket_set_hwm(ZMQ_Socket *sock, int value) { @@ -102,7 +108,7 @@ ZMQ_Error lzmq_socket_hwm(ZMQ_Socket *sock, int *value) { [19] = { name="backlog", otype="INT", mode="rw", ltype="int" }, [20] = { }, [21] = { name="reconnect_ivl_max", otype="INT", mode="rw", ltype="int" }, - [22] = { name="maxmsgsize", otype="INT64", mode="rw", ltype="int64" }, + [22] = { name="maxmsgsize", otype="INT64", mode="rw", ltype="int64_t" }, [23] = { name="sndhwm", otype="INT", mode="rw", ltype="int" }, [24] = { name="rcvhwm", otype="INT", mode="rw", ltype="int" }, [25] = { name="multicast_hops", otype="INT", mode="rw", ltype="int" }, @@ -112,24 +118,74 @@ ZMQ_Error lzmq_socket_hwm(ZMQ_Socket *sock, int *value) { [29] = { name="rcvlabel", otype="INT", mode="rw", ltype="int" }, }, } +local max_options = 50 local function foreach_opt(func) for i=1,#socket_options do local ver_opts = socket_options[i] - for num,opt in pairs(ver_opts) do - if type(num) == 'number' and opt.name then + for num=1,max_options do + local opt = ver_opts[num] + if opt then func(num, opt, ver_opts) end end end end +local add=function(t,val) return table.insert(t,val) end local function template(data, templ) return templ:gsub("%${(.-)}", data) end +local socket_methods = {} +local ffi_opt_names = {} +local max_methods = 0 +local function get_methods(opt, ver) + local num = opt.num + -- check if methods have been created + local methods = socket_methods[num] + + if not methods then + add(ffi_opt_names, "\t\t[".. num .. "] = '" .. opt.name .. "',\n") + -- need to create methods info. + methods = { + num=num, + name=opt.name, + get=opt.get, set=opt.set, c_get=opt.c_get, c_set=opt.c_set, + ltype=opt.ltype, otype=opt.otype, mode=opt.mode, + versions = {}, + } + + -- initialize all version as not-supported. + for i=1,#socket_options do + local ver_opts = socket_options[i] + methods[ver_opts.ver_def] = false + end + + if num > max_methods then max_methods = num end + + socket_methods[num] = methods + end + + -- mark this version as supporting the option. + methods[ver.ver_def] = true + add(methods.versions, ver) + + return methods +end + -- do pre-processing of options. -foreach_opt(function(num, opt) +foreach_opt(function(num, opt, ver) opt.num = num + if not opt.name then + opt.name = 'none' + opt.otype = 'NONE' + opt.DEF = 'unused' + return + end + -- track max option number for each version. + if not ver.max_opt or ver.max_opt < num then + ver.max_opt = num + end opt.DEF = "ZMQ_" .. opt.name:upper() -- ctype & ffi_type local ctype = OPT_TYPES[opt.otype] @@ -149,13 +205,22 @@ foreach_opt(function(num, opt) for meth,prefix in pairs(get_set_prefix[opt.mode]) do opt[meth] = prefix .. opt.name end + -- create common list of option get/set methods. + local methods = get_methods(opt, ver) end) -local add=function(t,val) return table.insert(t,val) end local options_c_code = {} +local opt_types = {} -local function endif(t, def) - return add(t, "#endif /* #if " .. def .. " */\n") +local function if_def(def) + local code = "#if " .. def .. "\n" + add(options_c_code, code) + add(opt_types, code) +end +local function endif(def) + local code = "#endif /* #if " .. def .. " */\n" + add(options_c_code, code) + add(opt_types, code) end -- build C code for socket options setters/getters @@ -163,11 +228,18 @@ local last_ver foreach_opt(function(num, opt, ver) if ver ~= last_ver then if last_ver then - endif(options_c_code, last_ver.ver_def) + endif(last_ver.ver_def) end last_ver = ver - add(options_c_code, "#if " .. ver.ver_def .. "\n") + if_def(ver.ver_def) + add(opt_types, template(ver,[[ +#define ${ver_def}_MAX_OPT ${max_opt} +]])) end + add(opt_types, template(opt,[[ + OPT_TYPE_${otype}, /* ${num} ${DEF} */ +]])) + if opt.name == 'none' then return end -- generate setter local set = '' local get = '' @@ -224,14 +296,105 @@ ZMQ_Error ${c_get}(ZMQ_Socket *sock, ${ltype} *value) { end add(options_c_code, template(opt,templ)) end) -endif(options_c_code, last_ver.ver_def) +endif(last_ver.ver_def) + +add(opt_types, [[ +#if VERSION_3_0 +# define MAX_OPTS VERSION_3_0_MAX_OPT +#else +# if VERSION_2_1 +# define MAX_OPTS VERSION_2_1_MAX_OPT +# else +# define MAX_OPTS VERSION_2_0_MAX_OPT +# endif +#endif +}; + +]]) options_c_code = table.concat(options_c_code) -print(options_c_code) +opt_types = table.concat(opt_types) +ffi_opt_names = table.concat(ffi_opt_names) + +local function tunpack(tab, idx, max) + if idx == max then return tab[idx] end + return tab[idx], tunpack(tab, idx + 1, max) +end + +local function build_meth_if_def(meth) + local v = {} + for i=1,#socket_options do + local ver_opts = socket_options[i] + if meth[ver_opts.ver_def] then + v[#v+1] = ver_opts.ver_def + end + end + return v +end + +local function build_option_methods() + local m = {} + + for i=1,max_methods do + local meth = socket_methods[i] + if meth then + local ltype = meth.ltype + local name + -- get list of version defs for this method. + local if_defs = build_meth_if_def(meth) + -- generate getter method. + name = meth.get + if name then + local args = { ltype, "&value" } + local val_out = { ltype, "&value" } + if meth.otype == 'BLOB' then + val_out = { 'char *', "value", has_length = true } + args = { 'char *', "value", "size_t", "&#value" } + end + m[#m+1] = method (name) { if_defs = if_defs, + var_out(val_out), + c_method_call "ZMQ_Error" (meth.c_get) (args), + } + end + -- generate setter method. + name = meth.set + if name then + local args = { ltype, "value" } + if meth.otype == 'BLOB' then + args = { ltype, "value", "size_t", "#value" } + end + m[#m+1] = method (name) { if_defs = if_defs, + c_method_call "ZMQ_Error" (meth.c_set) (args), + } + end + end + end + + return tunpack(m, 1, #m) +end + +------------------------------------------------------------------------------------- +-- +-- ZeroMQ socket object. +-- +------------------------------------------------------------------------------------- object "ZMQ_Socket" { error_on_null = "get_zmq_strerror()", - c_source [[ + ffi_source [[ +-- detect zmq version +local VERSION_2_0 = true +local VERSION_2_1 = false +local VERSION_3_0 = false +local zver = _M.version() +if zver[1] == 3 then + VERSION_2_0 = false + VERSION_3_0 = true +elseif zver[1] == 2 and zver[2] == 1 then + VERSION_2_1 = true +end +]], + c_source ([[ /* detect zmq version */ #define VERSION_2_0 1 #define VERSION_2_1 0 @@ -278,73 +441,8 @@ typedef int socket_t; #define OPT_TYPE_FD 6 static const int opt_types[] = { -#if VERSION_3_0 - OPT_TYPE_NONE, /* 0 unused */ - OPT_TYPE_INT, /* 1 ZMQ_HWM for backwards compatibility */ - OPT_TYPE_NONE, /* 2 unused */ - OPT_TYPE_NONE, /* 3 unused */ - OPT_TYPE_UINT64, /* 4 ZMQ_AFFINITY */ - OPT_TYPE_BLOB, /* 5 ZMQ_IDENTITY */ - OPT_TYPE_BLOB, /* 6 ZMQ_SUBSCRIBE */ - OPT_TYPE_BLOB, /* 7 ZMQ_UNSUBSCRIBE */ - OPT_TYPE_INT, /* 8 ZMQ_RATE */ - OPT_TYPE_INT, /* 9 ZMQ_RECOVERY_IVL */ - OPT_TYPE_INT, /* 10 ZMQ_MCAST_LOOP */ - OPT_TYPE_INT, /* 11 ZMQ_SNDBUF */ - OPT_TYPE_INT, /* 12 ZMQ_RCVBUF */ - OPT_TYPE_INT, /* 13 ZMQ_RCVMORE */ - OPT_TYPE_FD, /* 14 ZMQ_FD */ - OPT_TYPE_INT, /* 15 ZMQ_EVENTS */ - OPT_TYPE_INT, /* 16 ZMQ_TYPE */ - OPT_TYPE_INT, /* 17 ZMQ_LINGER */ - OPT_TYPE_INT, /* 18 ZMQ_RECONNECT_IVL */ - OPT_TYPE_INT, /* 19 ZMQ_BACKLOG */ - OPT_TYPE_NONE, /* 20 unused */ - OPT_TYPE_INT, /* 21 ZMQ_RECONNECT_IVL_MAX */ - OPT_TYPE_INT64, /* 22 ZMQ_MAXMSGSIZE */ - OPT_TYPE_INT, /* 23 ZMQ_SNDHWM */ - OPT_TYPE_INT, /* 24 ZMQ_RCVHWM */ - OPT_TYPE_INT, /* 25 ZMQ_MULTICAST_HOPS */ - OPT_TYPE_NONE, /* 26 unused */ - OPT_TYPE_INT, /* 27 ZMQ_RCVTIMEO */ - OPT_TYPE_INT, /* 28 ZMQ_SNDTIMEO */ - OPT_TYPE_INT, /* 29 ZMQ_RCVLABEL */ -# define MAX_OPTS 29 -#else - /* options for versions below 3.0 */ OPT_TYPE_NONE, /* 0 unused */ - OPT_TYPE_UINT64, /* 1 ZMQ_HWM */ - OPT_TYPE_NONE, /* 2 unused */ - OPT_TYPE_INT64, /* 3 ZMQ_SWAP */ - OPT_TYPE_UINT64, /* 4 ZMQ_AFFINITY */ - OPT_TYPE_BLOB, /* 5 ZMQ_IDENTITY */ - OPT_TYPE_BLOB, /* 6 ZMQ_SUBSCRIBE */ - OPT_TYPE_BLOB, /* 7 ZMQ_UNSUBSCRIBE */ - OPT_TYPE_INT64, /* 8 ZMQ_RATE */ - OPT_TYPE_INT64, /* 9 ZMQ_RECOVERY_IVL */ - OPT_TYPE_INT64, /* 10 ZMQ_MCAST_LOOP */ - OPT_TYPE_UINT64, /* 11 ZMQ_SNDBUF */ - OPT_TYPE_UINT64, /* 12 ZMQ_RCVBUF */ - OPT_TYPE_INT64, /* 13 ZMQ_RCVMORE */ - -# if VERSION_2_1 - OPT_TYPE_FD, /* 14 ZMQ_FD */ - OPT_TYPE_UINT32, /* 15 ZMQ_EVENTS */ - OPT_TYPE_INT, /* 16 ZMQ_TYPE */ - OPT_TYPE_INT, /* 17 ZMQ_LINGER */ - OPT_TYPE_INT, /* 18 ZMQ_RECONNECT_IVL */ - OPT_TYPE_INT, /* 19 ZMQ_BACKLOG */ - OPT_TYPE_INT64, /* 20 ZMQ_RECOVERY_IVL_MSEC */ - OPT_TYPE_INT, /* 21 ZMQ_RECONNECT_IVL_MAX */ -# define MAX_OPTS 21 -# else -# define MAX_OPTS 13 -# endif -#endif - -}; - -]], +]] .. opt_types .. options_c_code), destructor "close" { c_method_call "ZMQ_Error" "zmq_close" {} @@ -359,88 +457,32 @@ static const int opt_types[] = { int zmq_setsockopt (void *s, int option, const void *optval, size_t optvallen); int zmq_getsockopt (void *s, int option, void *optval, size_t *optvallen); ]], - ffi_source[[ -local option_len = {} -local option_types = {} -local option_tmps + ffi_source([[ +local option_gets = {} +local option_sets = {} do - local zmq = _M - local zver = zmq.version() - - local str_opt_temp_len = 255 - option_tmps = setmetatable({}, {__index = function(tab, ctype) - local temp - if ctype == 'string' then - tmp = ffi.new('uint8_t[?]', str_opt_temp_len) - else - tmp = ffi.new(ctype, 0) - end - rawset(tab, ctype, tmp) - return tmp + local opt_name + local methods = _meth.${object_name} + setmetatable(option_gets,{__index = function(tab,opt) + local opt_name = opt_name[opt] + if not opt_name then return nil end + local method = methods[opt_name] + rawset(tab, opt, method) + return method end}) - - local function def_opt(opt, ctype) - if not opt then return end - option_types[opt] = ctype - if ctype == 'string' then - option_len[opt] = str_opt_temp_len - else - option_len[opt] = ffi.sizeof(ctype) - end - end - - if zver[1] == 2 then - def_opt(zmq.HWM, 'uint64_t[1]') - def_opt(zmq.SWAP, 'int64_t[1]') - def_opt(zmq.AFFINITY, 'uint64_t[1]') - def_opt(zmq.IDENTITY, 'string') - def_opt(zmq.SUBSCRIBE, 'string') - def_opt(zmq.UNSUBSCRIBE, 'string') - def_opt(zmq.RATE, 'int64_t[1]') - def_opt(zmq.RECOVERY_IVL, 'int64_t[1]') - def_opt(zmq.RECOVERY_IVL_MSEC, 'int64_t[1]') - def_opt(zmq.MCAST_LOOP, 'int64_t[1]') - def_opt(zmq.SNDBUF, 'uint64_t[1]') - def_opt(zmq.RCVBUF, 'uint64_t[1]') - def_opt(zmq.RCVMORE, 'int64_t[1]') - def_opt(zmq.FD, 'int[1]') - def_opt(zmq.EVENTS, 'uint32_t[1]') - def_opt(zmq.TYPE, 'int[1]') - def_opt(zmq.LINGER, 'int[1]') - def_opt(zmq.RECONNECT_IVL, 'int[1]') - def_opt(zmq.BACKLOG, 'int[1]') - def_opt(zmq.RECONNECT_IVL_MAX, 'int[1]') - elseif zver[1] == 3 then - def_opt(zmq.AFFINITY, 'uint64_t[1]') - def_opt(zmq.IDENTITY, 'string') - def_opt(zmq.SUBSCRIBE, 'string') - def_opt(zmq.UNSUBSCRIBE, 'string') - def_opt(zmq.RATE, 'int[1]') - def_opt(zmq.RECOVERY_IVL, 'int[1]') - def_opt(zmq.RECOVERY_IVL_MSEC, 'int[1]') - def_opt(zmq.MCAST_LOOP, 'int[1]') - def_opt(zmq.SNDBUF, 'int[1]') - def_opt(zmq.RCVBUF, 'int[1]') - def_opt(zmq.RCVMORE, 'int[1]') - def_opt(zmq.FD, 'int[1]') - def_opt(zmq.EVENTS, 'int[1]') - def_opt(zmq.TYPE, 'int[1]') - def_opt(zmq.LINGER, 'int[1]') - def_opt(zmq.RECONNECT_IVL, 'int[1]') - def_opt(zmq.BACKLOG, 'int[1]') - def_opt(zmq.RECONNECT_IVL_MAX, 'int[1]') - def_opt(zmq.MAXMSGSIZE, 'int64_t[1]') - def_opt(zmq.SNDHWM, 'int[1]') - def_opt(zmq.RCVHWM, 'int[1]') - def_opt(zmq.MULTICAST_HOPS, 'int[1]') - def_opt(zmq.RCVTIMEO, 'int[1]') - def_opt(zmq.SNDTIMEO, 'int[1]') - def_opt(zmq.RCVLABEL, 'int[1]') - end + setmetatable(option_sets,{__index = function(tab,opt) + local opt_name = opt_name[opt] + if not opt_name then return nil end + local method = methods[opt_name] or methods['set_' .. opt_name] + rawset(tab, opt, method) + return method + end}) + opt_name = { +]] .. ffi_opt_names .. [[} end -]], +]]), method "setopt" { var_in{ "uint32_t", "opt" }, var_in{ "", "val" }, @@ -515,29 +557,9 @@ end finished: ]], ffi_source[[ - local ctype = option_types[${opt}] - local tval - local tval_len = 0 - if ctype then - if ctype == 'string' then - tval = tostring(${val}) - tval_len = #tval - else - tval = option_tmps[ctype] - tval[0] = ${val} - tval_len = option_len[${opt}] - end - ${err} = C.zmq_setsockopt(${this}, ${opt}, tval, tval_len) - elseif ${opt} == zmq.HWM then - -- 3.0 backwards compatibility support for HWM. - ctype = option_types[zmq.SNDHWM] - tval = option_tmps[ctype] - tval[0] = ${val} - tval_len = option_len[zmq.SNDHWM] - ${err} = C.zmq_setsockopt(${this}, zmq.SNDHWM, tval, tval_len) - if (-1 ~= ${err}) then - ${err} = C.zmq_setsockopt(${this}, zmq.RCVHWM, tval, tval_len) - end + local set = option_sets[${opt}] + if set then + return set(${this},${val}) else error("Invalid socket option.") end @@ -629,53 +651,12 @@ local tmp_val_len = ffi.new('size_t[1]', 4) lua_pushnil(L); ]], ffi_source[[ - local ctype = option_types[${opt}] - local val - local val_len - if ctype then - val = option_tmps[ctype] - val_len = option_len[${opt}] - ${err} = C.zmq_getsockopt(${this}, ${opt}, val, tmp_val_len) - end - if ${err} == 0 then - if ctype == 'string' then - return ffi.string(val, tmp_val_len[0]) - else - return tonumber(val[0]) - end + local get = option_gets[${opt}] + if get then + return get(${this}) + else + error("Invalid socket option.") end -]], - }, - ffi_source[[ -local ZMQ_EVENTS = _M.EVENTS --- temp. values for 'events' function. -local events_ctype = option_types[ZMQ_EVENTS] -local events_tmp = option_tmps[events_ctype] -local events_tmp_len = option_len[ZMQ_EVENTS] -local events_tmp_size = ffi.sizeof(events_tmp) -]], - method "events" { - var_out{ "uint32_t", "events" }, - var_out{ "ZMQ_Error", "err" }, - c_source[[ -#if VERSION_3_0 - int val; - size_t val_len = sizeof(val); - ${err} = zmq_getsockopt(${this}, ZMQ_EVENTS, &val, &val_len); - ${events} = val; -#else -# if VERSION_2_1 - size_t val_len = sizeof(${events}); - ${err} = zmq_getsockopt(${this}, ZMQ_EVENTS, &(${events}), &val_len); -# else - luaL_error(L, "'events' method only supported in 0MQ version >= 2.1"); -# endif -#endif -]], - ffi_source[[ - events_tmp_len[0] = events_tmp_size - ${err} = C.zmq_getsockopt(${this}, ZMQ_EVENTS, events_tmp, events_tmp_len); - ${events} = events_tmp[0] ]], }, -- @@ -757,5 +738,8 @@ local tmp_msg = ffi.new('zmq_msg_t') C.zmq_msg_close(msg) ]], }, + + -- build option set/get methods. THIS MUST BE LAST. + build_option_methods(), }