aboutsummaryrefslogtreecommitdiffstats
path: root/testing
diff options
context:
space:
mode:
authorNatanael Copa <ncopa@alpinelinux.org>2013-08-30 13:57:26 +0000
committerNatanael Copa <ncopa@alpinelinux.org>2013-08-30 13:57:26 +0000
commit41e0b0f64ffc4d4aba7bd880b08569a034c55260 (patch)
treec6a02b9928e3e80830e563426af3030c8f087ff6 /testing
parent7bb75c03f72a307c1cff91d4c89fdbb34a4d9455 (diff)
downloadaports-41e0b0f64ffc4d4aba7bd880b08569a034c55260.tar.bz2
aports-41e0b0f64ffc4d4aba7bd880b08569a034c55260.tar.xz
testing/lua5.2-zmq: new aport
Lua zeromq2 binding https://github.com/Neopallium/lua-zmq
Diffstat (limited to 'testing')
-rw-r--r--testing/lua5.2-zmq/APKBUILD49
-rw-r--r--testing/lua5.2-zmq/git-20121231.patch13813
2 files changed, 13862 insertions, 0 deletions
diff --git a/testing/lua5.2-zmq/APKBUILD b/testing/lua5.2-zmq/APKBUILD
new file mode 100644
index 0000000000..33a4af3201
--- /dev/null
+++ b/testing/lua5.2-zmq/APKBUILD
@@ -0,0 +1,49 @@
+# Contributor: Natanael Copa <ncopa@alpinelinux.org>
+# Maintainer: Natanael Copa <ncopa@alpinelinux.org>
+pkgname=lua5.2-zmq
+pkgver=1.1_git20121231
+_ver=${pkgver%_git*}
+pkgrel=0
+pkgdesc="Lua zeromq2 binding"
+url="https://github.com/Neopallium/lua-zmq"
+arch="all"
+license="MIT"
+depends="lua5.2-llthreads"
+makedepends="zeromq-dev cmake lua5.2-dev"
+install=""
+subpackages=
+source="lua-zmq-$_ver.tar.gz::http://github.com/Neopallium/lua-zmq/archive/v$_ver.tar.gz
+ git-${pkgver##*_git}.patch"
+
+_builddir="$srcdir"/lua-zmq-$_ver
+
+prepare() {
+ local i
+ cd "$_builddir"
+ for i in $source; do
+ case $i in
+ *.patch) msg $i; patch -p1 -i "$srcdir"/$i || return 1;;
+ esac
+ done
+ sed -i -e 's:lua/5\.1:lua/5.2:g' CMakeLists.txt
+}
+
+build() {
+ cd "$_builddir"
+ cmake \
+ -DCMAKE_INSTALL_PREFIX=/usr \
+ . || return 1
+ make || return 1
+}
+
+package() {
+ cd "$_builddir"
+ make install DESTDIR="$pkgdir" || return 1
+}
+
+md5sums="cb4df81b4c884bf97bf6add88fcfa58d lua-zmq-1.1.tar.gz
+e568cb33eef6230454a70dddfd5d3978 git-20121231.patch"
+sha256sums="f2bdf3142b744971da4eb8bdb12020a34b62f8ba384be44d8448b4ef05ec3dcc lua-zmq-1.1.tar.gz
+9f3b2ddd87c0fd7064a317e5ed63c16c4d1999b020f3d98970f1c5962ed34354 git-20121231.patch"
+sha512sums="35d7da6215a96b80ea59b52591082473d2c54bcb9577ae95ead1235de894d5ef226b6c4e3030c327b2b146e07af6b3998d91c5b520dfb35e87c85e958069362d lua-zmq-1.1.tar.gz
+12ff90d9b01ca03f8c9f8e02e1392de839c19242570acb77d5078e4358a89dabe3df6f6b701a30b95121b35ed09a72eedd0259c34b2663e5193a963c588be64c git-20121231.patch"
diff --git a/testing/lua5.2-zmq/git-20121231.patch b/testing/lua5.2-zmq/git-20121231.patch
new file mode 100644
index 0000000000..cfeaaebc35
--- /dev/null
+++ b/testing/lua5.2-zmq/git-20121231.patch
@@ -0,0 +1,13813 @@
+diff --git a/API.md b/API.md
+index f15da79..9cdcb8e 100644
+--- a/API.md
++++ b/API.md
+@@ -147,6 +147,14 @@ See [zmq_msg_copy(3)](http://api.zeromq.org/zmq_msg_copy.html).
+
+ msg1:copy(msg2) -- copy contents from msg2 -> msg1
+
++## set_size(size)
++
++Re-initialize the message with a new size. The current contents will be lost.
++See [zmq_msg_init_size(3)](http://api.zeromq.org/zmq_msg_init_size.html).
++
++ msg:set_size(size) -- re-initialize message if size is different from current size.
++ local buf = msg:data() -- get buffer to fill message with new contents.
++
+ ## set_data(data)
+
+ Change the message contents.
+@@ -156,7 +164,7 @@ See [zmq_msg_data(3)](http://api.zeromq.org/zmq_msg_data.html).
+
+ ## data()
+
+-Get the message contents.
++Get a lightuserdata pointer to the message contents.
+ See [zmq_msg_data(3)](http://api.zeromq.org/zmq_msg_data.html).
+
+ local data = msg:data() -- get the message contents
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index 6c3ed78..6471a17 100755
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -9,12 +9,10 @@ set(BUILD_SHARED_LIBS TRUE)
+
+ set(CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake)
+
+-set(INSTALL_LMOD share/lua/5.1 CACHE PATH "Directory to install Lua source modules (configure lua via LUA_PATH)")
+-set(INSTALL_CMOD lib/lua/5.1 CACHE PATH "Directory to install Lua binary modules (configure lua via LUA_CPATH)")
+-set(LUA_NATIVE_OBJECTS_PATH ../LuaNativeObjects CACHE PATH
+- "Directory to LuaNativeObjects bindings generator.")
+-set(USE_PRE_GENERATED_BINDINGS TRUE CACHE BOOL
+- "Set this to FALSE to re-generate bindings using LuaNativeObjects")
++set(INSTALL_LMOD ${CMAKE_INSTALL_PREFIX}/share/lua/5.1 CACHE PATH
++ "Directory to install Lua source modules (configure lua via LUA_PATH)")
++set(INSTALL_CMOD ${CMAKE_INSTALL_PREFIX}/lib/lua/5.1 CACHE PATH
++ "Directory to install Lua binary modules (configure lua via LUA_CPATH)")
+ set(ZMQ_PATH "" CACHE PATH
+ "Directory to libzmq. (by default use pkg-config to detect path)")
+
+@@ -27,6 +25,17 @@ include(FindLua51)
+ if(NOT ${LUA51_FOUND})
+ message(FATAL_ERROR "The FindLua51 module could not find lua :-(")
+ endif()
++if(WIN32)
++ set(COMMON_CFLAGS "${COMMON_CFLAGS} -I${LUA_INCLUDE_DIR}")
++ set(COMMON_LDFLAGS "${COMMON_LDFLAGS} ${LUA_LIBRARY}")
++ if(NOT MSVC)
++ set(COMMON_LDFLAGS "${COMMON_LDFLAGS} -Wl,--export-all-symbols")
++ endif()
++endif()
++## MAC OSX needs extra linker flags
++if(APPLE)
++ set(COMMON_LDFLAGS "${COMMON_LDFLAGS} -undefined dynamic_lookup")
++endif()
+
+ ## LibZMQ
+ if(WIN32)
+@@ -38,8 +47,13 @@ if(WIN32)
+ endif()
+ if(IS_DIRECTORY ${ZMQ_PATH})
+ set(COMMON_CFLAGS "${COMMON_CFLAGS} -I${ZMQ_PATH}/include")
+- set(COMMON_LDFLAGS "${COMMON_LDFLAGS} -L${ZMQ_PATH}/lib")
+- set(COMMON_LIBS "${COMMON_LIBS};zmq")
++ if(MSVC)
++ set(COMMON_LIBS "${COMMON_LIBS};libzmq")
++ else()
++ set(COMMON_LDFLAGS "${COMMON_LDFLAGS} -L${ZMQ_PATH}/lib")
++ set(COMMON_LIBS "${COMMON_LIBS};zmq")
++ endif()
++ link_directories(${ZMQ_PATH}/lib)
+ else()
+ ## fallback to using pkg-config
+ include(FindPkgConfig)
+@@ -51,13 +65,12 @@ endif()
+
+ ## LuaNativeObjects
+ include(LuaNativeObjects)
++include(CustomMacros)
+
+ include_directories(${CMAKE_CURRENT_SOURCE_DIR}
+ ${CMAKE_CURRENT_BINARY_DIR}
+ ${LUA_INCLUDE_DIR})
+
+-link_directories(${ZMQ_LIBRARY_DIRS})
+-
+ ## LuaZMQ
+ set(LUA_ZMQ_SRC
+ zmq.nobj.lua
+@@ -79,8 +92,8 @@ endif()
+ add_library(lua-zmq MODULE ${LUA_ZMQ_SRC})
+ target_link_libraries(lua-zmq ${COMMON_LIBS})
+ set_target_properties(lua-zmq PROPERTIES PREFIX "")
+-set_target_properties(lua-zmq PROPERTIES COMPILE_FLAGS "${COMMON_CFLAGS}")
+-set_target_properties(lua-zmq PROPERTIES LINK_FLAGS "${COMMON_LDFLAGS}")
++add_target_properties(lua-zmq COMPILE_FLAGS "${COMMON_CFLAGS}")
++add_target_properties(lua-zmq LINK_FLAGS "${LD_FLAGS} ${COMMON_LDFLAGS}")
+ set_target_properties(lua-zmq PROPERTIES OUTPUT_NAME zmq)
+
+ install(TARGETS lua-zmq
+diff --git a/COPYRIGHT b/COPYRIGHT
+new file mode 100644
+index 0000000..9840d93
+--- /dev/null
++++ b/COPYRIGHT
+@@ -0,0 +1,19 @@
++Copyright (c) 2011 by Robert G. Jakabosky <bobby@neoawareness.com>
++
++Permission is hereby granted, free of charge, to any person obtaining a copy
++of this software and associated documentation files (the "Software"), to deal
++in the Software without restriction, including without limitation the rights
++to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
++copies of the Software, and to permit persons to whom the Software is
++furnished to do so, subject to the following conditions:
++
++The above copyright notice and this permission notice shall be included in
++all copies or substantial portions of the Software.
++
++THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
++AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
++OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
++THE SOFTWARE.
+diff --git a/README.md b/README.md
+index eac5f5f..830e350 100644
+--- a/README.md
++++ b/README.md
+@@ -3,6 +3,11 @@ About
+
+ Lua bindings to zeromq2. Check out the [ZeroMQ Guide with Lua examples](http://zguide.zeromq.org/lua:all).
+
++Windows
++=======
++
++Download a compiled version of [LuaJIT 2.0.0-beta11 + lua-zmq + zeromq2.2.0](https://github.com/downloads/Neopallium/lua-zmq/luajit2.0_beta11_zmq2.2_llthreads.zip) 32bit & 64bit.
++
+ API
+ ===
+
+@@ -12,7 +17,7 @@ See [API.md](https://github.com/Neopallium/lua-zmq/blob/master/API.md) and
+ Requirements
+ ============
+
+-* ZeroMQ version 2.1.x.
++* ZeroMQ version 2.1, 2.2 or 3.2.
+ * Might work with some 2.0.x versions (2.0.6 and lower are not supported).
+
+ For Ubuntu 10.10 users:
+@@ -22,7 +27,7 @@ For Ubuntu 10.10 users:
+ Installation
+ ============
+
+-It is recommended to either compile Lua with the "-pthread" flag or preload libpthread.so on Linux when using this module ([See this glibc bug report](http://sourceware.org/bugzilla/show_bug.cgi?id=10652):
++It is recommended to either compile Lua with the "-pthread" flag or preload libpthread.so on Linux when using this module ([see this glibc bug report](http://sourceware.org/bugzilla/show_bug.cgi?id=10652)):
+
+ $ LD_PRELOAD=/lib/libpthread.so lua
+
+@@ -45,12 +50,12 @@ Latest Git revision
+
+ With LuaRocks 2.0.4.1:
+
+- $ sudo luarocks install https://github.com/Neopallium/lua-zmq/raw/master/rockspecs/lua-zmq-scm-1.rockspec
++ $ sudo luarocks install https://raw.github.com/Neopallium/lua-zmq/master/rockspecs/lua-zmq-scm-1.rockspec
+
+ For threads support:
+
+- $ sudo luarocks install https://github.com/Neopallium/lua-llthreads/raw/master/rockspecs/lua-llthreads-scm-0.rockspec
+- $ sudo luarocks install https://github.com/Neopallium/lua-zmq/raw/master/rockspecs/lua-zmq-threads-scm-0.rockspec
++ $ sudo luarocks install https://raw.github.com/Neopallium/lua-llthreads/master/rockspecs/lua-llthreads-scm-0.rockspec
++ $ sudo luarocks install https://raw.github.com/Neopallium/lua-zmq/master/rockspecs/lua-zmq-threads-scm-0.rockspec
+
+ With CMake:
+
+diff --git a/cmake/CustomMacros.cmake b/cmake/CustomMacros.cmake
+new file mode 100644
+index 0000000..312eeff
+--- /dev/null
++++ b/cmake/CustomMacros.cmake
+@@ -0,0 +1,61 @@
++## Orignal Macros copied from lighttpd 2.0
++
++## modules are without the "lib" prefix
++
++macro(setup_static_modules TARGET)
++ file(WRITE ${TARGET}_builtins.h "/* auto-generated by CMake build do not edit */\n\n")
++endmacro(setup_static_modules)
++
++macro(add_module TARGET MODNAME)
++ set(_static_mod ${BUILD_STATIC})
++
++ ## create list of module source files.
++ set(_srcfiles)
++ set(_def_module_src ${CMAKE_CURRENT_SOURCE_DIR}/modules/${MODNAME}.c)
++ if(EXISTS ${_def_module_src})
++ set(_srcfiles ${_def_module_src})
++ endif(EXISTS ${_def_module_src})
++ foreach(_srcfile ${ARGN})
++ if(_srcfile STREQUAL "STATIC")
++ set(_static_mod TRUE)
++ else(_srcfile STREQUAL "STATIC")
++ set(_srcfiles ${_srcfiles} ${_srcfile})
++ endif(_srcfile STREQUAL "STATIC")
++ endforeach(_srcfile)
++
++ if(_static_mod)
++ set(STATIC_MODULE_SRC ${STATIC_MODULE_SRC} ${_srcfiles})
++ file(APPEND ${TARGET}_builtins.h "STATIC_MOD(${MODNAME})\n")
++ else(_static_mod)
++ add_library(${MODNAME} MODULE ${_srcfiles})
++ set(MODULE_TARGETS ${MODULE_TARGETS} ${MODNAME})
++
++ add_target_properties(${MODNAME} LINK_FLAGS ${COMMON_LDFLAGS})
++ add_target_properties(${MODNAME} COMPILE_FLAGS ${COMMON_CFLAGS})
++ set_target_properties(${MODNAME} PROPERTIES CMAKE_INSTALL_PREFIX ${CMAKE_INSTALL_PREFIX})
++
++ ## Windows likes to link it this way back to app!
++ if(WIN32)
++ set_target_properties(${MODNAME} PROPERTIES LINK_FLAGS ${TARGET}.lib)
++ endif(WIN32)
++
++ if(APPLE)
++ set_target_properties(${MODNAME} PROPERTIES LINK_FLAGS "-flat_namespace -undefined suppress")
++ endif(APPLE)
++ endif(_static_mod)
++endmacro(add_module)
++
++macro(add_target_properties _target _name)
++ set(_properties)
++ foreach(_prop ${ARGN})
++ set(_properties "${_properties} ${_prop}")
++ endforeach(_prop)
++ get_target_property(_old_properties ${_target} ${_name})
++ ##message(STATUS "adding property to ${_target} ${_name}:" ${_properties})
++ if(NOT _old_properties)
++ # in case it's NOTFOUND
++ set(_old_properties)
++ endif(NOT _old_properties)
++ set_target_properties(${_target} PROPERTIES ${_name} "${_old_properties} ${_properties}")
++endmacro(add_target_properties)
++
+diff --git a/cmake/LuaNativeObjects.cmake b/cmake/LuaNativeObjects.cmake
+index a1b0e2d..e9e47de 100644
+--- a/cmake/LuaNativeObjects.cmake
++++ b/cmake/LuaNativeObjects.cmake
+@@ -1,19 +1,39 @@
+ #
+ # Lua Native Objects
+ #
++
++set(LUA_NATIVE_OBJECTS_PATH ${CMAKE_SOURCE_DIR}/../LuaNativeObjects CACHE PATH
++ "Directory to LuaNativeObjects bindings generator.")
++set(USE_PRE_GENERATED_BINDINGS TRUE CACHE BOOL
++ "Set this to FALSE to re-generate bindings using LuaNativeObjects")
++
++set(GENERATE_LUADOCS TRUE CACHE BOOL
++ "Set this to FALSE to avoid generation of docs using LuaDoc")
++
+ macro(GenLuaNativeObjects _src_files_var)
+ set(_new_src_files)
+ foreach(_src_file ${${_src_files_var}})
+ if(_src_file MATCHES ".nobj.lua")
+ string(REGEX REPLACE ".nobj.lua" ".nobj.c" _src_file_out ${_src_file})
+- string(REGEX REPLACE ".nobj.lua" ".nobj.h" _header_file_out ${_src_file})
+- add_custom_command(OUTPUT ${_src_file_out} ${_header_file_out}
++ string(REGEX REPLACE ".nobj.lua" ".nobj.ffi.lua" _ffi_file_out ${_src_file})
++ add_custom_command(OUTPUT ${_src_file_out} ${_ffi_file_out}
+ COMMAND lua ${LUA_NATIVE_OBJECTS_PATH}/native_objects.lua -outpath ${CMAKE_CURRENT_BINARY_DIR} -gen lua ${_src_file}
+ WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+ DEPENDS ${_src_file}
+ )
+ set_source_files_properties(${_src_file_out} PROPERTIES GENERATED TRUE)
+- set_source_files_properties(${_header_file_out} PROPERTIES GENERATED TRUE)
++ set_source_files_properties(${_ffi_file_out} PROPERTIES GENERATED TRUE)
++ if (${GENERATE_LUADOCS})
++ string(REGEX REPLACE ".nobj.lua" "" _doc_base ${_src_file})
++ string(REGEX REPLACE ".nobj.lua" ".luadoc" _doc_file_out ${_src_file})
++ add_custom_target(${_doc_file_out} ALL
++ COMMAND lua ${LUA_NATIVE_OBJECTS_PATH}/native_objects.lua -outpath docs -gen luadoc ${_src_file}
++ COMMAND luadoc -nofiles -d docs docs
++ WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
++ DEPENDS ${_src_file}
++ )
++ endif()
++ set_source_files_properties(${_doc_file_out} PROPERTIES GENERATED TRUE)
+ set(_new_src_files ${_new_src_files} ${_src_file_out})
+ else(_src_file MATCHES ".nobj.lua")
+ set(_new_src_files ${_new_src_files} ${_src_file})
+diff --git a/examples/client.lua b/examples/client.lua
+index 682a549..5e9849c 100644
+--- a/examples/client.lua
++++ b/examples/client.lua
+@@ -18,15 +18,24 @@
+ -- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ -- THE SOFTWARE.
+
+-require("zmq")
++local zmq = require"zmq"
+
+-local ctx = zmq.init(1)
++local N=tonumber(arg[1] or 100)
++
++local ctx = zmq.init()
+ local s = ctx:socket(zmq.REQ)
+
+ s:connect("tcp://localhost:5555")
+
+-s:send("SELECT * FROM mytable")
+-print(s:recv())
++for i=1,N do
++ s:send("SELECT * FROM mytable")
++ local data, err = s:recv()
++ if data then
++ print(data)
++ else
++ print("s:recv() error:", err)
++ end
++end
+
+ s:close()
+ ctx:term()
+diff --git a/examples/client_multipart.lua b/examples/client_multipart.lua
+index e82ca26..4f10c58 100644
+--- a/examples/client_multipart.lua
++++ b/examples/client_multipart.lua
+@@ -18,17 +18,26 @@
+ -- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ -- THE SOFTWARE.
+
+-require("zmq")
++local zmq = require"zmq"
+
+-local ctx = zmq.init(1)
++local N=tonumber(arg[1] or 100)
++
++local ctx = zmq.init()
+ local s = ctx:socket(zmq.REQ)
+
+ s:connect("tcp://localhost:5555")
+
+-s:send("SELECT * FROM mytable ", zmq.SNDMORE)
+-s:send("WHERE library = 'zmq'")
++for i=1,N do
++ s:send("SELECT * FROM mytable ", zmq.SNDMORE)
++ s:send("WHERE library = 'zmq'")
+
+-print(s:recv())
++ local data, err = s:recv()
++ if data then
++ print(data)
++ else
++ print("s:recv() error:", err)
++ end
++end
+
+ s:close()
+ ctx:term()
+diff --git a/examples/client_poll.lua b/examples/client_poll.lua
+new file mode 100644
+index 0000000..c49af9b
+--- /dev/null
++++ b/examples/client_poll.lua
+@@ -0,0 +1,108 @@
++-- Copyright (c) 2012 Robert G. Jakabosky <bobby@sharedrealm.com>
++--
++-- Permission is hereby granted, free of charge, to any person obtaining a copy
++-- of this software and associated documentation files (the "Software"), to deal
++-- in the Software without restriction, including without limitation the rights
++-- to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
++-- copies of the Software, and to permit persons to whom the Software is
++-- furnished to do so, subject to the following conditions:
++--
++-- The above copyright notice and this permission notice shall be included in
++-- all copies or substantial portions of the Software.
++--
++-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++-- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++-- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
++-- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++-- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
++-- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
++-- THE SOFTWARE.
++
++local poller = require"examples.poller"
++local poll = poller.new()
++
++local zmq = require"zmq"
++local z_NOBLOCK = zmq.NOBLOCK
++local z_EVENTS = zmq.EVENTS
++local z_POLLIN = zmq.POLLIN
++local z_POLLOUT = zmq.POLLOUT
++local z_POLLIN_OUT = z_POLLIN + z_POLLOUT
++
++local N=tonumber(arg[1] or 100)
++
++local ctx = zmq.init()
++local s = ctx:socket(zmq.REQ)
++local s_FD = s:getopt(zmq.FD)
++
++s:connect("tcp://localhost:5555")
++
++-- current socket state
++local blocked_state
++local blocked_event
++local on_sock_recv
++local on_sock_send
++
++-- IO event callback when socket was blocked
++local function on_sock_io()
++ local events = s:getopt(z_EVENTS)
++ local unblocked = false
++ if events == blocked_event then
++ -- got the event the socket was blocked on.
++ unblocked = true
++ elseif events == z_POLLIN_OUT then
++ -- got both in & out events
++ unblocked = true
++ end
++ if unblocked then
++ -- got the event we are blocked on resume.
++ blocked_event = nil
++ blocked_state()
++ -- check if blocked event was processed.
++ if not blocked_event then
++ poll:remove_read(s_FD)
++ end
++ end
++end
++local function sock_blocked(state, event)
++ if not blocked_event then
++ -- need to register socket's fd with event loop
++ poll:add_read(s_FD, on_sock_io)
++ end
++ blocked_state = state
++ blocked_event = event
++end
++
++-- sock state functions
++function on_sock_send()
++ N = N - 1
++ if N == 0 then
++ return poll:stop()
++ end
++ local sent, err = s:send("SELECT * FROM mytable", z_NOBLOCK)
++ if not sent then
++ assert(err == 'timeout', "Bad error on zmq socket.")
++ return sock_blocked(on_sock_send, z_POLLOUT)
++ end
++ -- yield back to event loop
++ poll:add_work(on_sock_recv)
++end
++
++function on_sock_recv()
++ local data, err = s:recv(z_NOBLOCK)
++ if not data then
++ assert(err == 'timeout', "Bad error on zmq socket.")
++ return sock_blocked(on_sock_recv, z_POLLIN)
++ end
++ print(data)
++ return on_sock_send()
++end
++
++-- start processing of the socket.
++poll:add_work(on_sock_send)
++
++-- start event loop
++poll:start()
++
++s:close()
++ctx:term()
++
+diff --git a/examples/ev_subscriber.lua b/examples/ev_subscriber.lua
+deleted file mode 100644
+index 876a0ea..0000000
+--- a/examples/ev_subscriber.lua
++++ /dev/null
+@@ -1,92 +0,0 @@
+--- Copyright (c) 2010 Aleksey Yeschenko <aleksey@yeschenko.com>
+---
+--- Permission is hereby granted, free of charge, to any person obtaining a copy
+--- of this software and associated documentation files (the "Software"), to deal
+--- in the Software without restriction, including without limitation the rights
+--- to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+--- copies of the Software, and to permit persons to whom the Software is
+--- furnished to do so, subject to the following conditions:
+---
+--- The above copyright notice and this permission notice shall be included in
+--- all copies or substantial portions of the Software.
+---
+--- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+--- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+--- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+--- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+--- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+--- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+--- THE SOFTWARE.
+-
+-require("zmq")
+-local ev = require'ev'
+-local loop = ev.Loop.default
+-
+--- define a sub_worker class
+-local sub_worker_mt = {}
+-function sub_worker_mt:close(...)
+- self.s_io_idle:stop(self.loop)
+- self.s_io_read:stop(self.loop)
+- return self.socket:close(...)
+-end
+-function sub_worker_mt:bind(...)
+- return self.socket:bind(...)
+-end
+-function sub_worker_mt:connect(...)
+- return self.socket:connect(...)
+-end
+-function sub_worker_mt:sub(topic)
+- return self.socket:setopt(zmq.SUBSCRIBE, topic)
+-end
+-function sub_worker_mt:unsub(topic)
+- return self.socket:setopt(zmq.UNSUBSCRIBE, topic)
+-end
+-sub_worker_mt.__index = sub_worker_mt
+-
+-local function sub_worker(loop, ctx, msg_cb)
+- local s = ctx:socket(zmq.SUB)
+- local self = { loop = loop, socket = s, msg_cb = msg_cb }
+- setmetatable(self, sub_worker_mt)
+- -- create ev callbacks for recving data.
+- -- need idle watcher since ZeroMQ sockets are edge-triggered instead of level-triggered
+- local s_io_idle
+- local s_io_read
+- s_io_idle = ev.Idle.new(function()
+- local msg, err = s:recv(zmq.NOBLOCK)
+- if err == 'timeout' then
+- -- need to block on read IO
+- s_io_idle:stop(loop)
+- s_io_read:start(loop)
+- return
+- end
+- self:msg_cb(msg)
+- end)
+- s_io_idle:start(loop)
+- s_io_read = ev.IO.new(function()
+- s_io_idle:start(loop)
+- s_io_read:stop(loop)
+- end, s:getopt(zmq.FD), ev.READ)
+- self.s_io_idle = s_io_idle
+- self.s_io_read = s_io_read
+- return self
+-end
+-
+-local ctx = zmq.init(1)
+-
+--- message handling function.
+-local function handle_msg(worker, msg)
+- local msg_id = tonumber(msg)
+- if math.mod(msg_id, 10000) == 0 then print(worker.id, msg_id) end
+-end
+-
+-local sub1 = sub_worker(loop, ctx, handle_msg)
+-sub1.id = 'sub1'
+-sub1:sub('')
+-sub1:connect("tcp://localhost:5555")
+-local sub2 = sub_worker(loop, ctx, handle_msg)
+-sub2.id = 'sub2'
+-sub2:sub('')
+-sub2:connect("tcp://localhost:5555")
+-
+-loop:loop()
+-
+diff --git a/examples/forward_poll.lua b/examples/forward_poll.lua
+new file mode 100644
+index 0000000..25e1e4f
+--- /dev/null
++++ b/examples/forward_poll.lua
+@@ -0,0 +1,39 @@
++local zmq = require'zmq'
++local poller = require"examples.poller"
++local poll_zsock = require"examples.poll_zsock"
++
++local poll = poller.new()
++poll_zsock.set_poller(poll)
++
++local c = zmq.init(1)
++local xreq = poll_zsock(c:socket(zmq.XREQ))
++xreq:bind('tcp://127.0.0.1:13333')
++local xrep = poll_zsock(c:socket(zmq.XREP))
++xrep:bind('tcp://127.0.0.1:13334')
++
++local max_recv = 10
++
++local function forward_io(src,dst)
++ src.on_data = function()
++ for i=1,max_recv do
++ repeat
++ local data, err = src:recv(zmq.NOBLOCK)
++ if not data then
++ if err == 'timeout' then
++ return
++ else
++ error("socket recv error:" .. err)
++ end
++ end
++ local more = src:getopt(zmq.RCVMORE) > 0
++ dst:send(data,more and zmq.SNDMORE or 0)
++ until not more
++ end
++ end
++end
++
++forward_io(xrep,xreq)
++forward_io(xreq,xrep)
++
++poll:start()
++
+diff --git a/examples/poll_zsock.lua b/examples/poll_zsock.lua
+new file mode 100644
+index 0000000..5d2ca04
+--- /dev/null
++++ b/examples/poll_zsock.lua
+@@ -0,0 +1,177 @@
++-- Copyright (c) 2012 Robert G. Jakabosky <bobby@sharedrealm.com>
++--
++-- Permission is hereby granted, free of charge, to any person obtaining a copy
++-- of this software and associated documentation files (the "Software"), to deal
++-- in the Software without restriction, including without limitation the rights
++-- to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
++-- copies of the Software, and to permit persons to whom the Software is
++-- furnished to do so, subject to the following conditions:
++--
++-- The above copyright notice and this permission notice shall be included in
++-- all copies or substantial portions of the Software.
++--
++-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++-- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++-- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
++-- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++-- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
++-- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
++-- THE SOFTWARE.
++
++local zmq = require"zmq"
++
++local z_EVENTS = zmq.EVENTS
++
++local z_POLLIN = zmq.POLLIN
++local z_POLLOUT = zmq.POLLOUT
++local z_POLLIN_OUT = z_POLLIN + z_POLLOUT
++
++local poll
++
++local meths = {}
++local zsock_mt = { __index=meths }
++
++local function zsock_check_events(self)
++ if not self.check_enabled then
++ -- enable 'on_work' callback to handle checking for socket events.
++ self.check_enabled = true
++ poll:add_work(self.on_work)
++ end
++end
++
++function meths:events()
++ zsock_check_events(self)
++ return self.sock:events()
++end
++
++function meths:getopt(opt)
++ if (opt == z_EVENTS) then
++ zsock_check_events(self)
++ end
++ return self.sock:getopt(opt)
++end
++
++function meths:setopt(opt,val)
++ return self.sock:setopt(opt,val)
++end
++
++function meths:sub(topic)
++ return self.sock:sub(topic)
++end
++
++function meths:unsub(topic)
++ return self.sock:unsub(topic)
++end
++
++function meths:identity(id)
++ return self.sock:identity(id)
++end
++
++function meths:bind(addr)
++ return self.sock:bind(addr)
++end
++
++function meths:connect(addr)
++ return self.sock:connect(addr)
++end
++
++function meths:close()
++ return self.sock:close()
++end
++
++function meths:send(msg, flags)
++ zsock_check_events(self)
++ local sent, err = self.sock:send(msg, flags)
++ if not sent and err == 'timeout' then
++ self.send_blocked = true
++ end
++ return sent, err
++end
++
++function meths:send_msg(msg, flags)
++ zsock_check_events(self)
++ local sent, err = self.sock:send_msg(msg, flags)
++ if not sent and err == 'timeout' then
++ self.send_blocked = true
++ end
++ return sent, err
++end
++
++function meths:recv(flags)
++ zsock_check_events(self)
++ local msg, err = self.sock:recv(flags)
++ if not msg and err == 'timeout' then
++ self.recv_blocked = true
++ end
++ return msg, err
++end
++
++function meths:recv_msg(msg, flags)
++ zsock_check_events(self)
++ local stat, err = self.sock:recv_msg(msg, flags)
++ if not stat and err == 'timeout' then
++ self.recv_blocked = true
++ end
++ return stat, err
++end
++
++local function nil_cb()
++end
++
++local function wrap_zsock(sock, on_data, on_drain)
++ local self = setmetatable({
++ sock = sock,
++ on_data = on_data or nil_cb,
++ on_drain = on_drain or nil_cb,
++ recv_blocked = false,
++ send_blocked = false,
++ check_enabled = false,
++ }, zsock_mt)
++
++ local function on_work()
++ self.check_enabled = false
++ local events = sock:events()
++ local read = false
++ local write = false
++ if events == z_POLLIN_OUT then
++ read = true
++ write = true
++ elseif events == z_POLLIN then
++ read = true
++ elseif events == z_POLLOUT then
++ write = true
++ else
++ return
++ end
++ if read then
++ self.recv_blocked = false
++ self:on_data(sock)
++ -- there might be more messages to read.
++ if not self.recv_blocked then
++ zsock_check_events(self)
++ end
++ end
++ if write and self.send_blocked then
++ self:on_drain(sock)
++ end
++ end
++ self.on_work = on_work
++
++ -- listen for read events to enable socket.
++ poll:add_read(sock:fd(), function()
++ on_work()
++ end)
++
++ zsock_check_events(self)
++ return self
++end
++
++return setmetatable({
++set_poller = function(poller)
++ local old = poll
++ poll = poller
++ return old
++end,
++wrap_zsock = wrap_zsock,
++}, { __call = function(tab, ...) return wrap_zsock(...) end})
++
+diff --git a/examples/poller.lua b/examples/poller.lua
+new file mode 100644
+index 0000000..90bee0a
+--- /dev/null
++++ b/examples/poller.lua
+@@ -0,0 +1,45 @@
++-- Copyright (c) 2012 Robert G. Jakabosky <bobby@sharedrealm.com>
++--
++-- Permission is hereby granted, free of charge, to any person obtaining a copy
++-- of this software and associated documentation files (the "Software"), to deal
++-- in the Software without restriction, including without limitation the rights
++-- to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
++-- copies of the Software, and to permit persons to whom the Software is
++-- furnished to do so, subject to the following conditions:
++--
++-- The above copyright notice and this permission notice shall be included in
++-- all copies or substantial portions of the Software.
++--
++-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++-- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++-- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
++-- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++-- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
++-- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
++-- THE SOFTWARE.
++
++-- safe require.
++local require = require
++local function safe_require(...)
++ return pcall(require, ...)
++end
++
++local mod_name = ...
++
++local backends = {
++ "epoll",
++ "ev",
++}
++
++for i=1,#backends do
++ local backend = backends[i]
++ local name = mod_name .. '.' .. backend
++ local status, mod = safe_require(name)
++ if status then
++ --print("Loaded backend:", name)
++ return mod
++ end
++end
++
++error("Failed to load backend for: " .. mod_name)
++
+diff --git a/examples/poller/epoll.lua b/examples/poller/epoll.lua
+new file mode 100644
+index 0000000..d79597c
+--- /dev/null
++++ b/examples/poller/epoll.lua
+@@ -0,0 +1,121 @@
++-- Copyright (c) 2012 Robert G. Jakabosky <bobby@sharedrealm.com>
++--
++-- Permission is hereby granted, free of charge, to any person obtaining a copy
++-- of this software and associated documentation files (the "Software"), to deal
++-- in the Software without restriction, including without limitation the rights
++-- to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
++-- copies of the Software, and to permit persons to whom the Software is
++-- furnished to do so, subject to the following conditions:
++--
++-- The above copyright notice and this permission notice shall be included in
++-- all copies or substantial portions of the Software.
++--
++-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++-- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++-- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
++-- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++-- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
++-- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
++-- THE SOFTWARE.
++
++local epoll = require"epoll"
++local EPOLLIN = epoll.EPOLLIN
++local EPOLLOUT = epoll.EPOLLOUT
++
++local poller_meths = {}
++local poller_mt = {__index = poller_meths}
++
++local function poller_new()
++ local reads = {}
++ -- create closure for epoll io_event callback.
++ local function do_io_event(fd, ev)
++ local cb = reads[fd]
++ return cb(fd, ev)
++ end
++
++ return setmetatable({
++ work_cur = {},
++ work_last = {},
++ reads = reads,
++ io_events = 0,
++ do_io_event = do_io_event,
++ poller = epoll.new(),
++ }, poller_mt)
++end
++
++function poller_meths:add_work(task)
++ -- add task to current work queue.
++ self.work_cur[#self.work_cur + 1] = task
++end
++
++function poller_meths:add_read(fd, cb)
++ -- make sure read event hasn't been registered yet.
++ if not self.reads[fd] then
++ self.io_events = self.io_events + 1
++ self.reads[fd] = cb
++ return self.poller:add(fd, EPOLLIN, fd)
++ else
++ -- update read callback?
++ self.reads[fd] = cb
++ end
++end
++
++function poller_meths:remove_read(fd)
++ -- make sure there was a read event registered.
++ if self.reads[fd] then
++ self.io_events = self.io_events - 1
++ self.reads[fd] = nil
++ return self.poller:del(fd)
++ end
++end
++
++local function poller_do_work(self)
++ local tasks = #self.work_cur
++ -- check if there is any work
++ if tasks > 0 then
++ -- swap work queues.
++ local last, cur = self.work_cur, self.work_last
++ self.work_cur, self.work_last = cur, last
++ for i=1,tasks do
++ local task = last[i]
++ last[i] = nil
++ task()
++ end
++ -- return new work queue length.
++ return #cur
++ end
++ return tasks
++end
++
++function poller_meths:start()
++ local do_io_event = self.do_io_event
++ local poller = self.poller
++ self.is_running = true
++ while self.is_running do
++ -- run work task
++ local new_work = poller_do_work(self)
++ -- wait == 0, if there is work to do, else wait == -1
++ local wait = (new_work > 0) and 0 or -1
++ -- poll for fd events, if there are events to poll for.
++--print("poller:step()", new_work, self.io_events)
++ if self.io_events > 0 then
++ assert(poller:wait_callback(do_io_event, wait))
++ else
++ -- no io events to poll, do we still have work?
++ if #self.work_cur == 0 then
++ -- nothing to do, exit event loop
++ self.is_running = false
++ return
++ end
++ end
++ end
++end
++
++function poller_meths:stop()
++ self.is_running = false
++end
++
++-- module only exports a 'new' function.
++return {
++new = poller_new,
++}
+diff --git a/examples/poller/ev.lua b/examples/poller/ev.lua
+new file mode 100644
+index 0000000..f8b1733
+--- /dev/null
++++ b/examples/poller/ev.lua
+@@ -0,0 +1,119 @@
++-- Copyright (c) 2012 Robert G. Jakabosky <bobby@sharedrealm.com>
++--
++-- Permission is hereby granted, free of charge, to any person obtaining a copy
++-- of this software and associated documentation files (the "Software"), to deal
++-- in the Software without restriction, including without limitation the rights
++-- to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
++-- copies of the Software, and to permit persons to whom the Software is
++-- furnished to do so, subject to the following conditions:
++--
++-- The above copyright notice and this permission notice shall be included in
++-- all copies or substantial portions of the Software.
++--
++-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++-- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++-- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
++-- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++-- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
++-- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
++-- THE SOFTWARE.
++
++local ev = require'ev'
++local ev_READ = ev.READ
++local ev_WRITE = ev.WRITE
++local loop = ev.Loop.default
++
++assert(ev.Idle,"Need version > 1.3 of lua-ev that supports Idle watchers.")
++
++local poller_meths = {}
++local poller_mt = {__index = poller_meths}
++
++local function poller_new()
++ local self = {
++ work_cur = {},
++ work_last = {},
++ io_events = 0,
++ reads = {},
++ idle_enabled = false,
++ }
++
++ self.idle = ev.Idle.new(function()
++ local tasks = #self.work_cur
++ -- check if there is any work
++ if tasks > 0 then
++ -- swap work queues.
++ local last, cur = self.work_cur, self.work_last
++ self.work_cur, self.work_last = cur, last
++ for i=1,tasks do
++ local task = last[i]
++ last[i] = nil
++ task()
++ end
++ -- check if there is more work.
++ if #cur > 0 then
++ return -- don't disable idle watcher, when we have work.
++ end
++ end
++--print("STOP IDLE:", #self.work_cur, #self.work_last)
++ -- stop idle watcher, no work.
++ self.idle_enabled = false
++ self.idle:stop(loop)
++ end)
++ -- set priority to max, to make sure the work queue is processed on each loop.
++ self.idle:priority(ev.MAXPRI)
++
++ return setmetatable(self, poller_mt)
++end
++
++function poller_meths:add_work(task)
++ local idx = #self.work_cur + 1
++ -- add task to current work queue.
++ self.work_cur[idx] = task
++ -- make sure the idle watcher is enabled.
++ if not self.idle_enabled then
++ self.idle_enabled = true
++ self.idle:start(loop)
++ end
++end
++
++function poller_meths:add_read(fd, cb)
++ local io_read = self.reads[fd]
++ -- make sure read event hasn't been registered yet.
++ if not io_read then
++ self.io_events = self.io_events + 1
++ io_read = ev.IO.new(function()
++ cb(fd)
++ end, fd, ev_READ)
++ self.reads[fd] = io_read
++ io_read:start(loop)
++ else
++ -- update read callback?
++ io_read:callback(cb)
++ -- need to re-start watcher?
++ if not io_read:is_active() then
++ io_read:start(loop)
++ end
++ end
++end
++
++function poller_meths:remove_read(fd)
++ local io_read = self.reads[fd]
++ -- make sure there was a read event registered.
++ if io_read then
++ self.io_events = self.io_events - 1
++ io_read:stop(loop)
++ end
++end
++
++function poller_meths:start()
++ return loop:loop()
++end
++
++function poller_meths:stop()
++ return loop:unloop()
++end
++
++-- module only exports a 'new' function.
++return {
++new = poller_new,
++}
+diff --git a/examples/publiser.lua b/examples/publiser.lua
+deleted file mode 100644
+index 12e240e..0000000
+--- a/examples/publiser.lua
++++ /dev/null
+@@ -1,32 +0,0 @@
+--- Copyright (c) 2010 Aleksey Yeschenko <aleksey@yeschenko.com>
+---
+--- Permission is hereby granted, free of charge, to any person obtaining a copy
+--- of this software and associated documentation files (the "Software"), to deal
+--- in the Software without restriction, including without limitation the rights
+--- to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+--- copies of the Software, and to permit persons to whom the Software is
+--- furnished to do so, subject to the following conditions:
+---
+--- The above copyright notice and this permission notice shall be included in
+--- all copies or substantial portions of the Software.
+---
+--- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+--- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+--- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+--- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+--- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+--- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+--- THE SOFTWARE.
+-
+-require("zmq")
+-
+-local ctx = zmq.init(1)
+-local s = ctx:socket(zmq.PUB)
+-
+-s:bind("tcp://lo:5555")
+-
+-local msg_id = 1
+-while true do
+- s:send(tostring(msg_id))
+- msg_id = msg_id + 1
+-end
+diff --git a/examples/publisher.lua b/examples/publisher.lua
+new file mode 100644
+index 0000000..a5f943e
+--- /dev/null
++++ b/examples/publisher.lua
+@@ -0,0 +1,32 @@
++-- Copyright (c) 2010 Aleksey Yeschenko <aleksey@yeschenko.com>
++--
++-- Permission is hereby granted, free of charge, to any person obtaining a copy
++-- of this software and associated documentation files (the "Software"), to deal
++-- in the Software without restriction, including without limitation the rights
++-- to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
++-- copies of the Software, and to permit persons to whom the Software is
++-- furnished to do so, subject to the following conditions:
++--
++-- The above copyright notice and this permission notice shall be included in
++-- all copies or substantial portions of the Software.
++--
++-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++-- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++-- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
++-- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++-- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
++-- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
++-- THE SOFTWARE.
++
++local zmq = require"zmq"
++
++local ctx = zmq.init()
++local s = ctx:socket(zmq.PUB)
++
++s:bind("tcp://lo:5555")
++
++local msg_id = 1
++while true do
++ s:send(tostring(msg_id))
++ msg_id = msg_id + 1
++end
+diff --git a/examples/publisher_poll.lua b/examples/publisher_poll.lua
+new file mode 100644
+index 0000000..0cfbe79
+--- /dev/null
++++ b/examples/publisher_poll.lua
+@@ -0,0 +1,95 @@
++-- Copyright (c) 2012 Robert G. Jakabosky <bobby@sharedrealm.com>
++--
++-- Permission is hereby granted, free of charge, to any person obtaining a copy
++-- of this software and associated documentation files (the "Software"), to deal
++-- in the Software without restriction, including without limitation the rights
++-- to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
++-- copies of the Software, and to permit persons to whom the Software is
++-- furnished to do so, subject to the following conditions:
++--
++-- The above copyright notice and this permission notice shall be included in
++-- all copies or substantial portions of the Software.
++--
++-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++-- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++-- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
++-- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++-- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
++-- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
++-- THE SOFTWARE.
++
++local poller = require"examples.poller"
++local poll = poller.new()
++
++local zmq = require"zmq"
++local z_NOBLOCK = zmq.NOBLOCK
++local z_EVENTS = zmq.EVENTS
++local z_POLLIN = zmq.POLLIN
++local z_POLLOUT = zmq.POLLOUT
++local z_POLLIN_OUT = z_POLLIN + z_POLLOUT
++
++local ctx = zmq.init()
++local s = ctx:socket(zmq.PUB)
++local s_FD = s:getopt(zmq.FD)
++
++s:bind("tcp://lo:5555")
++
++-- current socket state
++local blocked_state
++local blocked_event
++local on_sock_recv
++local on_sock_send
++
++-- IO event callback when socket was blocked
++local function on_sock_io()
++ local events = s:getopt(z_EVENTS)
++ local unblocked = false
++ if events == blocked_event then
++ -- got the event the socket was blocked on.
++ unblocked = true
++ elseif events == z_POLLIN_OUT then
++ -- got both in & out events
++ unblocked = true
++ end
++ if unblocked then
++ -- got the event we are blocked on resume.
++ blocked_event = nil
++ blocked_state()
++ -- check if blocked event was processed.
++ if not blocked_event then
++ poll:remove_read(s_FD)
++ end
++ end
++end
++local function sock_blocked(state, event)
++ if not blocked_event then
++ -- need to register socket's fd with event loop
++ poll:add_read(s_FD, on_sock_io)
++ end
++ blocked_state = state
++ blocked_event = event
++end
++
++-- sock state functions
++local msg_id = 1
++function on_sock_send()
++ local sent, err = s:send(tostring(msg_id), z_NOBLOCK)
++ if not sent then
++ assert(err == 'timeout', "Bad error on zmq socket.")
++ return sock_blocked(on_sock_send, z_POLLOUT)
++ end
++ -- message sent, inc. id
++ msg_id = msg_id + 1
++ -- yield back to event loop
++ poll:add_work(on_sock_send)
++end
++
++-- start processing of the socket.
++poll:add_work(on_sock_send)
++
++-- start event loop
++poll:start()
++
++s:close()
++ctx:term()
++
+diff --git a/examples/server.lua b/examples/server.lua
+index 57bb278..3423c4e 100644
+--- a/examples/server.lua
++++ b/examples/server.lua
+@@ -18,14 +18,14 @@
+ -- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ -- THE SOFTWARE.
+
+-require("zmq")
++local zmq = require"zmq"
+
+-local ctx = zmq.init(1)
++local ctx = zmq.init()
+ local s = ctx:socket(zmq.REP)
+
+ s:bind("tcp://lo:5555")
+
+ while true do
+- print(string.format("Received query: '%s'", s:recv()))
+- s:send("OK")
++ print(string.format("Received query: '%s'", s:recv()))
++ s:send("OK")
+ end
+diff --git a/examples/server_multipart.lua b/examples/server_multipart.lua
+index 663c3f7..c26e3e0 100644
+--- a/examples/server_multipart.lua
++++ b/examples/server_multipart.lua
+@@ -18,18 +18,18 @@
+ -- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ -- THE SOFTWARE.
+
+-require("zmq")
++local zmq = require"zmq"
+
+-local ctx = zmq.init(1)
++local ctx = zmq.init()
+ local s = ctx:socket(zmq.REP)
+
+ s:bind("tcp://lo:5555")
+
+ while true do
+- local query = s:recv()
+- while s:getopt(zmq.RCVMORE) == 1 do
+- query = query .. s:recv()
+- end
+- print(string.format("Received query: '%s'", query))
+- s:send("OK")
++ local query = s:recv()
++ while s:getopt(zmq.RCVMORE) == 1 do
++ query = query .. s:recv()
++ end
++ print(string.format("Received query: '%s'", query))
++ s:send("OK")
+ end
+diff --git a/examples/server_poll.lua b/examples/server_poll.lua
+new file mode 100644
+index 0000000..42c8862
+--- /dev/null
++++ b/examples/server_poll.lua
+@@ -0,0 +1,102 @@
++-- Copyright (c) 2012 Robert G. Jakabosky <bobby@sharedrealm.com>
++--
++-- Permission is hereby granted, free of charge, to any person obtaining a copy
++-- of this software and associated documentation files (the "Software"), to deal
++-- in the Software without restriction, including without limitation the rights
++-- to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
++-- copies of the Software, and to permit persons to whom the Software is
++-- furnished to do so, subject to the following conditions:
++--
++-- The above copyright notice and this permission notice shall be included in
++-- all copies or substantial portions of the Software.
++--
++-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++-- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++-- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
++-- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++-- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
++-- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
++-- THE SOFTWARE.
++
++local poller = require"examples.poller"
++local poll = poller.new()
++
++local zmq = require"zmq"
++local z_NOBLOCK = zmq.NOBLOCK
++local z_EVENTS = zmq.EVENTS
++local z_POLLIN = zmq.POLLIN
++local z_POLLOUT = zmq.POLLOUT
++local z_POLLIN_OUT = z_POLLIN + z_POLLOUT
++
++local ctx = zmq.init()
++local s = ctx:socket(zmq.REP)
++local s_FD = s:getopt(zmq.FD)
++
++s:bind("tcp://lo:5555")
++
++-- current socket state
++local blocked_state
++local blocked_event
++local on_sock_recv
++local on_sock_send
++
++-- IO event callback when socket was blocked
++local function on_sock_io()
++ local events = s:getopt(z_EVENTS)
++ local unblocked = false
++ if events == blocked_event then
++ -- got the event the socket was blocked on.
++ unblocked = true
++ elseif events == z_POLLIN_OUT then
++ -- got both in & out events
++ unblocked = true
++ end
++ if unblocked then
++ -- got the event we are blocked on resume.
++ blocked_event = nil
++ blocked_state()
++ -- check if blocked event was processed.
++ if not blocked_event then
++ poll:remove_read(s_FD)
++ end
++ end
++end
++local function sock_blocked(state, event)
++ if not blocked_event then
++ -- need to register socket's fd with event loop
++ poll:add_read(s_FD, on_sock_io)
++ end
++ blocked_state = state
++ blocked_event = event
++end
++
++-- sock state functions
++function on_sock_recv()
++ local data, err = s:recv(z_NOBLOCK)
++ if not data then
++ assert(err == 'timeout', "Bad error on zmq socket.")
++ return sock_blocked(on_sock_recv, z_POLLIN)
++ end
++ print(string.format("Received query: '%s'", data))
++ return on_sock_send()
++end
++
++function on_sock_send()
++ local sent, err = s:send("OK", z_NOBLOCK)
++ if not sent then
++ assert(err == 'timeout', "Bad error on zmq socket.")
++ return sock_blocked(on_sock_send, z_POLLOUT)
++ end
++ -- yield back to event loop
++ poll:add_work(on_sock_recv)
++end
++
++-- start processing of the socket.
++poll:add_work(on_sock_recv)
++
++-- start event loop
++poll:start()
++
++s:close()
++ctx:term()
++
+diff --git a/examples/subscriber.lua b/examples/subscriber.lua
+index 370b7dc..41434c7 100644
+--- a/examples/subscriber.lua
++++ b/examples/subscriber.lua
+@@ -18,14 +18,14 @@
+ -- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ -- THE SOFTWARE.
+
+-require("zmq")
++local zmq = require"zmq"
+
+-local ctx = zmq.init(1)
++local ctx = zmq.init()
+ local s = ctx:socket(zmq.SUB)
+ s:setopt(zmq.SUBSCRIBE, "")
+ s:connect("tcp://localhost:5555")
+ while true do
+- local msg = s:recv()
+- local msg_id = tonumber(msg)
+- if math.mod(msg_id, 10000) == 0 then print(msg_id) end
++ local msg = s:recv()
++ local msg_id = tonumber(msg)
++ if math.mod(msg_id, 10000) == 0 then print(msg_id) end
+ end
+diff --git a/examples/subscriber_ev.lua b/examples/subscriber_ev.lua
+new file mode 100644
+index 0000000..ae8506c
+--- /dev/null
++++ b/examples/subscriber_ev.lua
+@@ -0,0 +1,113 @@
++-- Copyright (c) 2012 Robert G. Jakabosky <bobby@sharedrealm.com>
++--
++-- Permission is hereby granted, free of charge, to any person obtaining a copy
++-- of this software and associated documentation files (the "Software"), to deal
++-- in the Software without restriction, including without limitation the rights
++-- to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
++-- copies of the Software, and to permit persons to whom the Software is
++-- furnished to do so, subject to the following conditions:
++--
++-- The above copyright notice and this permission notice shall be included in
++-- all copies or substantial portions of the Software.
++--
++-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++-- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++-- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
++-- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++-- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
++-- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
++-- THE SOFTWARE.
++
++local zmq = require"zmq"
++local z_NOBLOCK = zmq.NOBLOCK
++local z_EVENTS = zmq.EVENTS
++local z_POLLIN = zmq.POLLIN
++local z_POLLOUT = zmq.POLLOUT
++local z_POLLIN_OUT = z_POLLIN + z_POLLOUT
++local ev = require'ev'
++local loop = ev.Loop.default
++
++-- define a sub_worker class
++local sub_worker_mt = {}
++function sub_worker_mt:close(...)
++ self.s_io_idle:stop(self.loop)
++ self.s_io_read:stop(self.loop)
++ return self.socket:close(...)
++end
++function sub_worker_mt:bind(...)
++ return self.socket:bind(...)
++end
++function sub_worker_mt:connect(...)
++ return self.socket:connect(...)
++end
++function sub_worker_mt:sub(topic)
++ return self.socket:setopt(zmq.SUBSCRIBE, topic)
++end
++function sub_worker_mt:unsub(topic)
++ return self.socket:setopt(zmq.UNSUBSCRIBE, topic)
++end
++sub_worker_mt.__index = sub_worker_mt
++
++local function sub_worker(loop, ctx, msg_cb)
++ local s = ctx:socket(zmq.SUB)
++ local self = { loop = loop, socket = s, msg_cb = msg_cb }
++ setmetatable(self, sub_worker_mt)
++ -- create ev callbacks for recving data.
++ -- need idle watcher since ZeroMQ sockets are edge-triggered instead of level-triggered
++ local s_io_idle
++ local s_io_read
++ local max_recvs = 10
++ local function s_recv(recv_cnt)
++ local msg, err = s:recv(z_NOBLOCK)
++ if err == 'timeout' then
++ -- need to block on read IO
++ return false
++ end
++ self:msg_cb(msg)
++ if recv_cnt > 1 then
++ return s_recv(recv_cnt - 1)
++ end
++ return true
++ end
++ s_io_idle = ev.Idle.new(function()
++ if not s_recv(max_recvs) then
++ -- need to block on read IO
++ s_io_idle:stop(loop)
++ s_io_read:start(loop)
++ end
++ end)
++ s_io_idle:start(loop)
++ s_io_read = ev.IO.new(function()
++ local events = s:getopt(z_EVENTS)
++ if events == z_POLLIN or events == z_POLLIN_OUT then
++ if s_recv(max_recvs) then
++ -- read IO is not block, enable idle watcher to handle reads.
++ s_io_idle:start(loop)
++ s_io_read:stop(loop)
++ end
++ end
++ end, s:getopt(zmq.FD), ev.READ)
++ self.s_io_idle = s_io_idle
++ self.s_io_read = s_io_read
++ return self
++end
++
++local ctx = zmq.init()
++
++-- message handling function.
++local function handle_msg(worker, msg)
++ local msg_id = tonumber(msg)
++ if math.mod(msg_id, 10000) == 0 then print(worker.id, msg_id) end
++end
++
++local sub1 = sub_worker(loop, ctx, handle_msg)
++sub1.id = 'sub1'
++sub1:sub('')
++sub1:connect("tcp://localhost:5555")
++local sub2 = sub_worker(loop, ctx, handle_msg)
++sub2.id = 'sub2'
++sub2:sub('')
++sub2:connect("tcp://localhost:5555")
++
++loop:loop()
++
+diff --git a/examples/subscriber_poll.lua b/examples/subscriber_poll.lua
+new file mode 100644
+index 0000000..1be24b2
+--- /dev/null
++++ b/examples/subscriber_poll.lua
+@@ -0,0 +1,96 @@
++-- Copyright (c) 2012 Robert G. Jakabosky <bobby@sharedrealm.com>
++--
++-- Permission is hereby granted, free of charge, to any person obtaining a copy
++-- of this software and associated documentation files (the "Software"), to deal
++-- in the Software without restriction, including without limitation the rights
++-- to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
++-- copies of the Software, and to permit persons to whom the Software is
++-- furnished to do so, subject to the following conditions:
++--
++-- The above copyright notice and this permission notice shall be included in
++-- all copies or substantial portions of the Software.
++--
++-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++-- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++-- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
++-- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++-- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
++-- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
++-- THE SOFTWARE.
++
++local poller = require"examples.poller"
++local poll = poller.new()
++
++local zmq = require"zmq"
++local z_NOBLOCK = zmq.NOBLOCK
++local z_EVENTS = zmq.EVENTS
++local z_POLLIN = zmq.POLLIN
++local z_POLLOUT = zmq.POLLOUT
++local z_POLLIN_OUT = z_POLLIN + z_POLLOUT
++
++local N=tonumber(arg[1] or 100)
++
++local ctx = zmq.init()
++local s = ctx:socket(zmq.SUB)
++local s_FD = s:getopt(zmq.FD)
++
++s:setopt(zmq.SUBSCRIBE, "")
++s:connect("tcp://localhost:5555")
++
++-- current socket state
++local blocked_state
++local blocked_event
++local on_sock_recv
++local on_sock_send
++
++-- IO event callback when socket was blocked
++local function on_sock_io()
++ local events = s:getopt(z_EVENTS)
++ local unblocked = false
++ if events == blocked_event then
++ -- got the event the socket was blocked on.
++ unblocked = true
++ elseif events == z_POLLIN_OUT then
++ -- got both in & out events
++ unblocked = true
++ end
++ if unblocked then
++ -- got the event we are blocked on resume.
++ blocked_event = nil
++ blocked_state()
++ -- check if blocked event was processed.
++ if not blocked_event then
++ poll:remove_read(s_FD)
++ end
++ end
++end
++local function sock_blocked(state, event)
++ if not blocked_event then
++ -- need to register socket's fd with event loop
++ poll:add_read(s_FD, on_sock_io)
++ end
++ blocked_state = state
++ blocked_event = event
++end
++
++-- sock state functions
++function on_sock_recv()
++ local data, err = s:recv(z_NOBLOCK)
++ if not data then
++ assert(err == 'timeout', "Bad error on zmq socket.")
++ return sock_blocked(on_sock_recv, z_POLLIN)
++ end
++ local msg_id = tonumber(data)
++ if (msg_id % 10000) == 0 then print(data) end
++ return on_sock_recv()
++end
++
++-- start processing of the socket.
++poll:add_work(on_sock_recv)
++
++-- start event loop
++poll:start()
++
++s:close()
++ctx:term()
++
+diff --git a/perf/local_lat.lua b/perf/local_lat.lua
+index d6a4ec1..027c583 100644
+--- a/perf/local_lat.lua
++++ b/perf/local_lat.lua
+@@ -35,11 +35,26 @@ s:bind(bind_to)
+
+ local msg = zmq.zmq_msg_t()
+
++local timer
++
+ for i = 1, roundtrip_count do
+ assert(s:recv_msg(msg))
++ if not timer then
++ timer = zmq.stopwatch_start()
++ end
+ assert(msg:size() == message_size, "Invalid message size")
+ assert(s:send_msg(msg))
+ end
+
++local elapsed = timer:stop()
++
+ s:close()
+ ctx:term()
++
++local latency = elapsed / roundtrip_count / 2
++
++print(string.format("mean latency: %.3f [us]", latency))
++local secs = elapsed / (1000 * 1000)
++print(string.format("elapsed = %f", secs))
++print(string.format("msg/sec = %f", roundtrip_count / secs))
++
+diff --git a/perf/local_thr_poll.lua b/perf/local_thr_poll.lua
+new file mode 100644
+index 0000000..bfe0d33
+--- /dev/null
++++ b/perf/local_thr_poll.lua
+@@ -0,0 +1,77 @@
++-- Copyright (c) 2010 Aleksey Yeschenko <aleksey@yeschenko.com>
++--
++-- Permission is hereby granted, free of charge, to any person obtaining a copy
++-- of this software and associated documentation files (the "Software"), to deal
++-- in the Software without restriction, including without limitation the rights
++-- to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
++-- copies of the Software, and to permit persons to whom the Software is
++-- furnished to do so, subject to the following conditions:
++--
++-- The above copyright notice and this permission notice shall be included in
++-- all copies or substantial portions of the Software.
++--
++-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++-- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++-- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
++-- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++-- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
++-- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
++-- THE SOFTWARE.
++
++if not arg[3] then
++ print("usage: lua local_thr.lua <bind-to> <message-size> <message-count>")
++ os.exit()
++end
++
++local bind_to = arg[1]
++local message_size = tonumber(arg[2])
++local message_count = tonumber(arg[3])
++
++local zmq = require"zmq"
++local z_poller = require"zmq.poller"
++local z_NOBLOCK = zmq.NOBLOCK
++
++local poller = z_poller(64)
++
++local ctx = zmq.init(1)
++local s = ctx:socket(zmq.SUB)
++s:setopt(zmq.SUBSCRIBE, "");
++s:bind(bind_to)
++
++print(string.format("message size: %i [B]", message_size))
++print(string.format("message count: %i", message_count))
++
++local msg
++msg = zmq.zmq_msg_t()
++
++local cnt = 0
++
++poller:add(s, zmq.POLLIN, function(sock)
++ while s:recv_msg(msg, z_NOBLOCK) do
++ --assert(msg:size() == message_size, "Invalid message size")
++ cnt = cnt + 1
++ if cnt == message_count then
++ poller:stop()
++ end
++ end
++end)
++
++-- wait for first message
++assert(s:recv_msg(msg))
++cnt = 1
++
++local timer = zmq.stopwatch_start()
++poller:start()
++local elapsed = timer:stop()
++
++s:close()
++ctx:term()
++
++if elapsed == 0 then elapsed = 1 end
++
++local throughput = message_count / (elapsed / 1000000)
++local megabits = throughput * message_size * 8 / 1000000
++
++print(string.format("mean throughput: %i [msg/s]", throughput))
++print(string.format("mean throughput: %.3f [Mb/s]", megabits))
++
+diff --git a/perf/local_thr_push_pull.lua b/perf/local_thr_push_pull.lua
+new file mode 100644
+index 0000000..9b2dee2
+--- /dev/null
++++ b/perf/local_thr_push_pull.lua
+@@ -0,0 +1,62 @@
++-- Copyright (c) 2010 Aleksey Yeschenko <aleksey@yeschenko.com>
++--
++-- Permission is hereby granted, free of charge, to any person obtaining a copy
++-- of this software and associated documentation files (the "Software"), to deal
++-- in the Software without restriction, including without limitation the rights
++-- to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
++-- copies of the Software, and to permit persons to whom the Software is
++-- furnished to do so, subject to the following conditions:
++--
++-- The above copyright notice and this permission notice shall be included in
++-- all copies or substantial portions of the Software.
++--
++-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++-- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++-- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
++-- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++-- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
++-- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
++-- THE SOFTWARE.
++
++if not arg[3] then
++ print("usage: lua local_thr.lua <bind-to> <message-size> <message-count>")
++ os.exit()
++end
++
++local bind_to = arg[1]
++local message_size = tonumber(arg[2])
++local message_count = tonumber(arg[3])
++
++local zmq = require"zmq"
++
++local ctx = zmq.init(1)
++local s = ctx:socket(zmq.PULL)
++s:bind(bind_to)
++
++print(string.format("message size: %i [B]", message_size))
++print(string.format("message count: %i", message_count))
++
++local msg
++msg = zmq.zmq_msg_t()
++assert(s:recv_msg(msg))
++
++local timer = zmq.stopwatch_start()
++
++for i = 1, message_count - 1 do
++ assert(s:recv_msg(msg))
++ assert(msg:size() == message_size, "Invalid message size")
++end
++
++local elapsed = timer:stop()
++
++s:close()
++ctx:term()
++
++if elapsed == 0 then elapsed = 1 end
++
++local throughput = message_count / (elapsed / 1000000)
++local megabits = throughput * message_size * 8 / 1000000
++
++print(string.format("mean throughput: %i [msg/s]", throughput))
++print(string.format("mean throughput: %.3f [Mb/s]", megabits))
++
+diff --git a/perf/remote_lat.lua b/perf/remote_lat.lua
+index 4376f60..ebcc680 100644
+--- a/perf/remote_lat.lua
++++ b/perf/remote_lat.lua
+@@ -54,3 +54,4 @@ local latency = elapsed / roundtrip_count / 2
+ print(string.format("message size: %i [B]", message_size))
+ print(string.format("roundtrip count: %i", roundtrip_count))
+ print(string.format("mean latency: %.3f [us]", latency))
++
+diff --git a/perf/remote_thr.lua b/perf/remote_thr.lua
+index 967e08b..5890508 100644
+--- a/perf/remote_thr.lua
++++ b/perf/remote_thr.lua
+@@ -31,8 +31,12 @@ local zmq = require"zmq"
+
+ local ctx = zmq.init(1)
+ local s = ctx:socket(zmq.PUB)
++-- for ZeroMQ 3.x need to change HWM option.
++s:set_hwm(0)
+ s:connect(connect_to)
+
++zmq.sleep(1)
++
+ local data = ("0"):rep(message_size)
+ local msg_data = zmq.zmq_msg_t.init_data(data)
+ local msg = zmq.zmq_msg_t.init()
+@@ -42,7 +46,6 @@ for i = 1, message_count do
+ assert(s:send_msg(msg))
+ end
+
+---os.execute("sleep " .. 10)
+-
+ s:close()
+ ctx:term()
++
+diff --git a/perf/remote_thr_push_pull.lua b/perf/remote_thr_push_pull.lua
+new file mode 100644
+index 0000000..11be905
+--- /dev/null
++++ b/perf/remote_thr_push_pull.lua
+@@ -0,0 +1,49 @@
++-- Copyright (c) 2010 Aleksey Yeschenko <aleksey@yeschenko.com>
++--
++-- Permission is hereby granted, free of charge, to any person obtaining a copy
++-- of this software and associated documentation files (the "Software"), to deal
++-- in the Software without restriction, including without limitation the rights
++-- to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
++-- copies of the Software, and to permit persons to whom the Software is
++-- furnished to do so, subject to the following conditions:
++--
++-- The above copyright notice and this permission notice shall be included in
++-- all copies or substantial portions of the Software.
++--
++-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++-- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++-- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
++-- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++-- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
++-- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
++-- THE SOFTWARE.
++
++if not arg[3] then
++ print("usage: lua remote_thr.lua <connect-to> <message-size> <message-count>")
++ os.exit()
++end
++
++local connect_to = arg[1]
++local message_size = tonumber(arg[2])
++local message_count = tonumber(arg[3])
++
++local zmq = require"zmq"
++
++local ctx = zmq.init(1)
++local s = ctx:socket(zmq.PUSH)
++s:connect(connect_to)
++
++zmq.sleep(1)
++
++local data = ("0"):rep(message_size)
++local msg_data = zmq.zmq_msg_t.init_data(data)
++local msg = zmq.zmq_msg_t.init()
++
++for i = 1, message_count do
++ msg:copy(msg_data)
++ assert(s:send_msg(msg))
++end
++
++s:close()
++ctx:term()
++
+diff --git a/perf/thread_lat.lua b/perf/thread_lat.lua
+index 93ed691..f781e55 100644
+--- a/perf/thread_lat.lua
++++ b/perf/thread_lat.lua
+@@ -64,6 +64,8 @@ local msg = zmq.zmq_msg_t.init_size(message_size)
+ print(string.format("message size: %i [B]", message_size))
+ print(string.format("roundtrip count: %i", roundtrip_count))
+
++zmq.sleep(2) -- wait for child thread to connect.
++
+ local timer = zmq.stopwatch_start()
+
+ for i = 1, roundtrip_count do
+@@ -81,4 +83,7 @@ ctx:term()
+ local latency = elapsed / roundtrip_count / 2
+
+ print(string.format("mean latency: %.3f [us]", latency))
++local secs = elapsed / (1000 * 1000)
++print(string.format("elapsed = %f", secs))
++print(string.format("msg/sec = %f", roundtrip_count / secs))
+
+diff --git a/perf/thread_push_pull.lua b/perf/thread_push_pull.lua
+index f69ff48..b3d96cb 100644
+--- a/perf/thread_push_pull.lua
++++ b/perf/thread_push_pull.lua
+@@ -42,12 +42,13 @@ local child_code = [[
+ s:connect(connect_to)
+
+ local data = ("0"):rep(message_size)
+- local msg = zmq.zmq_msg_t.init_size(message_size)
++ local msg_data = zmq.zmq_msg_t.init_data(data)
++ local msg = zmq.zmq_msg_t.init()
+
+ local timer = zmq.stopwatch_start()
+
+ for i = 1, message_count do
+- msg:set_data(data)
++ msg:copy(msg_data)
+ assert(s:send_msg(msg))
+ end
+
+diff --git a/perf/thread_thr.lua b/perf/thread_thr.lua
+index 7b9183a..d3958e8 100644
+--- a/perf/thread_thr.lua
++++ b/perf/thread_thr.lua
+@@ -38,6 +38,8 @@ local child_code = [[
+
+ local ctx = zthreads.get_parent_ctx()
+ local s = ctx:socket(zmq.PUB)
++ -- for ZeroMQ 3.x need to change HWM option.
++ s:set_hwm(0)
+ s:connect(connect_to)
+
+ local data = ("0"):rep(message_size)
+diff --git a/rockspecs/lua-zmq-scm-1.rockspec b/rockspecs/lua-zmq-scm-1.rockspec
+index 10737b7..b3cd3c6 100644
+--- a/rockspecs/lua-zmq-scm-1.rockspec
++++ b/rockspecs/lua-zmq-scm-1.rockspec
+@@ -12,12 +12,28 @@ dependencies = {
+ "lua >= 5.1",
+ }
+ external_dependencies = {
++ platforms = {
++ windows = {
++ ZEROMQ = {
++ library = "libzmq",
++ }
++ },
++ },
+ ZEROMQ = {
+ header = "zmq.h",
+ library = "zmq",
+ }
+ }
+ build = {
++ platforms = {
++ windows = {
++ modules = {
++ zmq = {
++ libraries = {"libzmq"},
++ }
++ }
++ },
++ },
+ type = "builtin",
+ modules = {
+ zmq = {
+diff --git a/rockspecs/lua-zmq-wireshark-scm-0.rockspec b/rockspecs/lua-zmq-wireshark-scm-0.rockspec
+new file mode 100644
+index 0000000..5e3e0e1
+--- /dev/null
++++ b/rockspecs/lua-zmq-wireshark-scm-0.rockspec
+@@ -0,0 +1,22 @@
++package = "lua-zmq-wireshark"
++version = "scm-0"
++source = {
++ url = "git://github.com/Neopallium/lua-zmq.git",
++}
++description = {
++ summary = "Lua Wireshark dissector for the ZeroMQ protocol.",
++ homepage = "http://github.com/Neopallium/lua-zmq",
++ -- Wireshark requires dissectors to be licensed under the GPL.
++ license = "GPL",
++}
++dependencies = {}
++build = {
++ type = "none",
++ install = {
++ lua = {
++ ['zmq.ws.dissector'] = "ws/dissector.lua",
++ ['zmq.ws.tap'] = "ws/tap.lua",
++ ['zmq.ws.stats_tap'] = "ws/stats_tap.lua",
++ },
++ },
++}
+diff --git a/src/ctx.nobj.lua b/src/ctx.nobj.lua
+index adc0c42..246b653 100644
+--- a/src/ctx.nobj.lua
++++ b/src/ctx.nobj.lua
+@@ -19,6 +19,7 @@
+ -- THE SOFTWARE.
+
+ object "ZMQ_Ctx" {
++ sys_include"string.h",
+ error_on_null = "get_zmq_strerror()",
+ c_source [[
+ typedef struct ZMQ_Ctx ZMQ_Ctx;
+diff --git a/src/error.nobj.lua b/src/error.nobj.lua
+index 4e353f3..b5559c7 100644
+--- a/src/error.nobj.lua
++++ b/src/error.nobj.lua
+@@ -18,26 +18,295 @@
+ -- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ -- THE SOFTWARE.
+
++-- E* error values.
++meta_object "ZErrors" {
++ export_definitions {
++ -- Native 0MQ error codes.
++ "EFSM",
++ "ENOCOMPATPROTO",
++ "ETERM",
++ "EMTHREAD",
++
++ "EPERM", -- Operation not permitted
++ "ENOENT", -- No such file or directory
++ "ESRCH", -- No such process
++ "EINTR", -- Interrupted system call
++ "EIO", -- I/O error
++ "ENXIO", -- No such device or address
++ "E2BIG", -- Argument list too long
++ "ENOEXEC", -- Exec format error
++ "EBADF", -- Bad file number
++ "ECHILD", -- No child processes
++ "EAGAIN", -- Try again
++ "ENOMEM", -- Out of memory
++ "EACCES", -- Permission denied
++ "EFAULT", -- Bad address
++ "ENOTBLK", -- Block device required
++ "EBUSY", -- Device or resource busy
++ "EEXIST", -- File exists
++ "EXDEV", -- Cross-device link
++ "ENODEV", -- No such device
++ "ENOTDIR", -- Not a directory
++ "EISDIR", -- Is a directory
++ "EINVAL", -- Invalid argument
++ "ENFILE", -- File table overflow
++ "EMFILE", -- Too many open files
++ "ENOTTY", -- Not a typewriter
++ "ETXTBSY", -- Text file busy
++ "EFBIG", -- File too large
++ "ENOSPC", -- No space left on device
++ "ESPIPE", -- Illegal seek
++ "EROFS", -- Read-only file system
++ "EMLINK", -- Too many links
++ "EPIPE", -- Broken pipe
++ "EDOM", -- Math argument out of domain of func
++ "ERANGE", -- Math result not representable
++
++ "EDEADLK", -- Resource deadlock would occur
++ "EDEADLOCK", -- EDEADLK
++ "ENAMETOOLONG", -- File name too long
++ "ENOLCK", -- No record locks available
++ "ENOSYS", -- Function not implemented
++ "ENOTEMPTY", -- Directory not empty
++ "ELOOP", -- Too many symbolic links encountered
++ "EWOULDBLOCK", -- Operation would block
++ "ENOMSG", -- No message of desired type
++ "EIDRM", -- Identifier removed
++ "ECHRNG", -- Channel number out of range
++ "EL2NSYNC", -- Level 2 not synchronized
++ "EL3HLT", -- Level 3 halted
++ "EL3RST", -- Level 3 reset
++ "ELNRNG", -- Link number out of range
++ "EUNATCH", -- Protocol driver not attached
++ "ENOCSI", -- No CSI structure available
++ "EL2HLT", -- Level 2 halted
++ "EBADE", -- Invalid exchange
++ "EBADR", -- Invalid request descriptor
++ "EXFULL", -- Exchange full
++ "ENOANO", -- No anode
++ "EBADRQC", -- Invalid request code
++ "EBADSLT", -- Invalid slot
++
++ "EBFONT", -- Bad font file format
++ "ENOSTR", -- Device not a stream
++ "ENODATA", -- No data available
++ "ETIME", -- Timer expired
++ "ENOSR", -- Out of streams resources
++ "ENONET", -- Machine is not on the network
++ "ENOPKG", -- Package not installed
++ "EREMOTE", -- Object is remote
++ "ENOLINK", -- Link has been severed
++ "EADV", -- Advertise error
++ "ESRMNT", -- Srmount error
++ "ECOMM", -- Communication error on send
++ "EPROTO", -- Protocol error
++ "EMULTIHOP", -- Multihop attempted
++ "EDOTDOT", -- RFS specific error
++ "EBADMSG", -- Not a data message
++ "EOVERFLOW", -- Value too large for defined data type
++ "ENOTUNIQ", -- Name not unique on network
++ "EBADFD", -- File descriptor in bad state
++ "EREMCHG", -- Remote address changed
++ "ELIBACC", -- Can not access a needed shared library
++ "ELIBBAD", -- Accessing a corrupted shared library
++ "ELIBSCN", -- .lib section in a.out corrupted
++ "ELIBMAX", -- Attempting to link in too many shared libraries
++ "ELIBEXEC", -- Cannot exec a shared library directly
++ "EILSEQ", -- Illegal byte sequence
++ "ERESTART", -- Interrupted system call should be restarted
++ "ESTRPIPE", -- Streams pipe error
++ "EUSERS", -- Too many users
++ "ENOTSOCK", -- Socket operation on non-socket
++ "EDESTADDRREQ", -- Destination address required
++ "EMSGSIZE", -- Message too long
++ "EPROTOTYPE", -- Protocol wrong type for socket
++ "ENOPROTOOPT", -- Protocol not available
++ "EPROTONOSUPPORT", -- Protocol not supported
++ "ESOCKTNOSUPPORT", -- Socket type not supported
++ "EOPNOTSUPP", -- Operation not supported on transport endpoint
++ "EPFNOSUPPORT", -- Protocol family not supported
++ "EAFNOSUPPORT", -- Address family not supported by protocol
++ "EADDRINUSE", -- Address already in use
++ "EADDRNOTAVAIL", -- Cannot assign requested address
++ "ENETDOWN", -- Network is down
++ "ENETUNREACH", -- Network is unreachable
++ "ENETRESET", -- Network dropped connection because of reset
++ "ECONNABORTED", -- Software caused connection abort
++ "ECONNRESET", -- Connection reset by peer
++ "ENOBUFS", -- No buffer space available
++ "EISCONN", -- Transport endpoint is already connected
++ "ENOTCONN", -- Transport endpoint is not connected
++ "ESHUTDOWN", -- Cannot send after transport endpoint shutdown
++ "ETOOMANYREFS", -- Too many references: cannot splice
++ "ETIMEDOUT", -- Connection timed out
++ "ECONNREFUSED", -- Connection refused
++ "EHOSTDOWN", -- Host is down
++ "EHOSTUNREACH", -- No route to host
++ "EALREADY", -- Operation already in progress
++ "EINPROGRESS", -- Operation now in progress
++ "ESTALE", -- Stale NFS file handle
++ "EUCLEAN", -- Structure needs cleaning
++ "ENOTNAM", -- Not a XENIX named type file
++ "ENAVAIL", -- No XENIX semaphores available
++ "EISNAM", -- Is a named type file
++ "EREMOTEIO", -- Remote I/O error
++ "EDQUOT", -- Quota exceeded
++
++ "ENOMEDIUM", -- No medium found
++ "EMEDIUMTYPE", -- Wrong medium type
++ "ECANCELED", -- Operation Canceled
++ "ENOKEY", -- Required key not available
++ "EKEYEXPIRED", -- Key has expired
++ "EKEYREVOKED", -- Key has been revoked
++ "EKEYREJECTED", -- Key was rejected by service
++
++ -- for robust mutexes
++ "EOWNERDEAD", -- Owner died
++ "ENOTRECOVERABLE", -- State not recoverable
++
++ "ERFKILL", -- Operation not possible due to RF-kill
++ },
++
++ method "description" {
++ var_in{ "<any>", "err" },
++ var_out{ "const char *", "msg" },
++ c_source "pre" [[
++ int err_type;
++ int err_num = -1;
++]],
++ c_source[[
++ err_type = lua_type(L, ${err::idx});
++ if(err_type == LUA_TSTRING) {
++ lua_pushvalue(L, ${err::idx});
++ lua_rawget(L, ${this::idx});
++ 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, ${err::idx});
++ } else {
++ return luaL_argerror(L, ${err::idx}, "expected string/number");
++ }
++ if(err_num < 0) {
++ lua_pushnil(L);
++ lua_pushliteral(L, "UNKNOWN ERROR");
++ return 2;
++ }
++ ${msg} = strerror(err_num);
++]],
++ },
++
++ method "__index" {
++ var_in{ "int", "err" },
++ var_out{ "const char *", "msg" },
++ c_source[[
++ switch(${err}) {
++ case EAGAIN:
++ ${msg} = "timeout";
++ break;
++ case EINTR:
++ ${msg} = "interrupted";
++ break;
++#if defined(ETERM)
++ case ETERM:
++ ${msg} = "closed";
++ break;
++#endif
++ default:
++ ${msg} = zmq_strerror(${err});
++ break;
++ }
++ lua_pushvalue(L, ${err::idx});
++ lua_pushstring(L, ${msg});
++ lua_rawset(L, ${this::idx});
++]],
++ },
++}
++
++ffi_cdef[[
++int zmq_errno (void);
++]]
++
++ffi_source "ffi_src" [[
++-- get ZErrors table to map errno to error name.
++local ZError_names = _M.ZErrors
++
++local function get_zmq_strerror()
++ return ZError_names[C.zmq_errno()]
++end
++]]
++
++c_source "extra_code" [[
++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);
++}
++
++]]
++
++c_source "module_init_src" [[
++ /* Cache reference to zmq.ZErrors table for errno->string convertion. */
++ lua_pushlightuserdata(L, zmq_ZErrors_key);
++ lua_getfield(L, -2, "ZErrors");
++ lua_rawset(L, LUA_REGISTRYINDEX);
++]]
++
+ -- Convert ZMQ Error codes into strings.
+ --
+ -- This is an error code wrapper object, it converts C-style 'int' return error code
+ -- into Lua-style 'nil, "Error message"' return values.
+ --
+ error_code "ZMQ_Error" "int" {
+- ffi_cdef[[
+-typedef int ZMQ_Error;
+-]],
++ ffi_type = "int",
+ is_error_check = function(rec) return "(-1 == ${" .. rec.name .. "})" end,
+ ffi_is_error_check = function(rec) return "(-1 == ${" .. rec.name .. "})" end,
+ default = "0",
+ c_source [[
++ int num;
+ if(-1 == err) {
+- err_str = get_zmq_strerror();
++ /* get ZErrors table. */
++ lua_pushlightuserdata(L, zmq_ZErrors_key);
++ lua_rawget(L, LUA_REGISTRYINDEX);
++ /* convert zmq_errno to string. */
++ num = zmq_errno();
++ lua_pushinteger(L, num);
++ lua_gettable(L, -2);
++ /* remove ZErrors table. */
++ lua_remove(L, -2);
++ if(!lua_isnil(L, -1)) {
++ /* found error. */
++ return;
++ }
++ /* Unknown error. */
++ lua_pop(L, 1);
++ lua_pushfstring(L, "UNKNOWN ERROR(%d)", num);
++ return;
+ }
+ ]],
+ ffi_source [[
+ if(-1 == err) then
+- err_str = get_zmq_strerror();
++ err_str = ZError_names[C.zmq_errno()]
+ end
+ ]],
+ }
+diff --git a/src/msg.nobj.lua b/src/msg.nobj.lua
+index 28e18ed..c46e189 100644
+--- a/src/msg.nobj.lua
++++ b/src/msg.nobj.lua
+@@ -21,6 +21,22 @@
+ object "zmq_msg_t" {
+ -- store the `zmq_msg_t` structure in Lua userdata object
+ userdata_type = "embed",
++ implements "Buffer" {
++ implement_method "const_data" {
++ c_function = "zmq_msg_data"
++ },
++ implement_method "get_size" {
++ c_function = "zmq_msg_size"
++ },
++ },
++ implements "MutableBuffer" {
++ implement_method "data" {
++ c_function = "zmq_msg_data"
++ },
++ implement_method "get_size" {
++ c_function = "zmq_msg_size"
++ },
++ },
+ --
+ -- Define zmq_msq_t type & function API for FFI
+ --
+@@ -34,42 +50,31 @@ struct zmq_msg_t
+ unsigned char vsm_data [30]; /* that '30' is from 'MAX_VSM_SIZE' */
+ };
+
+-typedef void (zmq_free_fn) (void *data, void *hint);
+-
+ int zmq_msg_init (zmq_msg_t *msg);
+ int zmq_msg_init_size (zmq_msg_t *msg, size_t size);
+-int zmq_msg_init_data (zmq_msg_t *msg, void *data, size_t size, zmq_free_fn *ffn, void *hint);
+
+ ]],
+ constructor "init" {
+- var_out{ "ZMQ_Error", "err" },
+- c_source[[
+- zmq_msg_t tmp;
+- ${this} = &tmp;
+- ${err} = zmq_msg_init(${this});
+-]],
++ c_method_call "ZMQ_Error" "zmq_msg_init" {},
+ },
+ constructor "init_size" {
+- var_in{ "size_t", "size" },
+- var_out{ "ZMQ_Error", "err" },
+- c_source[[
+- zmq_msg_t tmp;
+- ${this} = &tmp;
+- ${err} = zmq_msg_init_size(${this}, ${size});
+-]],
++ c_method_call "ZMQ_Error" "zmq_msg_init_size" { "size_t", "size" },
+ },
+ constructor "init_data" {
+ var_in{ "const char *", "data" },
+- var_out{ "ZMQ_Error", "err" },
++ c_method_call { "ZMQ_Error", "err" } "zmq_msg_init_size" { "size_t", "#data" },
+ c_source[[
+- zmq_msg_t tmp;
+- ${this} = &tmp;
+- ${err} = zmq_msg_init_size(${this}, ${data_len});
+ if(0 == ${err}) {
+ /* fill message */
+ memcpy(zmq_msg_data(${this}), ${data}, ${data_len});
+ }
+ ]],
++ ffi_source[[
++ if(0 == ${err}) then
++ -- fill message
++ ffi.copy(C.zmq_msg_data(${this}), ${data}, ${data_len})
++ end
++]],
+ },
+ destructor {
+ c_method_call "ZMQ_Error" "zmq_msg_close" {}
+@@ -143,7 +148,7 @@ int zmq_msg_init_data (zmq_msg_t *msg, void *data, size_t size, zmq_free_fn *ffn
+ ]],
+ },
+ method "size" {
+- c_method_call "size_t" "zmq_msg_size" {}
++ c_method_call { "size_t", "size", ffi_wrap = "tonumber"} "zmq_msg_size" {}
+ },
+ method "__tostring" {
+ var_out{ "const char *", "data", has_length = true },
+diff --git a/src/poller.lua b/src/poller.lua
+index 8c77337..2ca40ea 100644
+--- a/src/poller.lua
++++ b/src/poller.lua
+@@ -34,43 +34,36 @@ local poller_mt = {}
+ poller_mt.__index = poller_mt
+
+ function poller_mt:add(sock, events, cb)
+- self.poller:add(sock, events)
+- self.callbacks[sock] = cb
++ local id = self.poller:add(sock, events)
++ self.callbacks[id] = function(revents) return cb(sock, revents) end
+ end
+
+ function poller_mt:modify(sock, events, cb)
++ local id
+ if events ~= 0 and cb then
+- self.callbacks[sock] = cb
+- self.poller:modify(sock, events)
++ id = self.poller:modify(sock, events)
++ self.callbacks[id] = function(revents) return cb(sock, revents) end
+ else
+- self:remove(sock)
++ id = self:remove(sock)
++ self.callbacks[id] = nil
+ end
+ end
+
+ function poller_mt:remove(sock)
+- self.poller:remove(sock)
+- self.callbacks[sock] = nil
++ local id = self.poller:remove(sock)
++ self.callbacks[id] = nil
+ end
+
+ function poller_mt:poll(timeout)
+ local poller = self.poller
+- local status, err = poller:poll(timeout)
+- if not status then
++ local count, err = poller:poll(timeout)
++ if not count then
+ return nil, err
+ end
+ local callbacks = self.callbacks
+- local count = 0
+- while true do
+- local sock, revents = poller:next_revents()
+- if not sock then
+- break
+- end
+- local cb = callbacks[sock]
+- if not cb then
+- error("Missing callback for sock:" .. tostring(sock))
+- end
+- cb(sock, revents)
+- count = count + 1
++ for i=1,count do
++ local id, revents = poller:next_revents_idx()
++ callbacks[id](revents)
+ end
+ return count
+ end
+@@ -78,7 +71,7 @@ end
+ function poller_mt:start()
+ self.is_running = true
+ while self.is_running do
+- local status, err = self:poll(-1)
++ status, err = self:poll(-1)
+ if not status then
+ return false, err
+ end
+@@ -90,14 +83,15 @@ function poller_mt:stop()
+ self.is_running = false
+ end
+
+-module(...)
++local M = {}
+
+-function new(pre_alloc)
++function M.new(pre_alloc)
+ return setmetatable({
+ poller = zmq.ZMQ_Poller(pre_alloc),
+- callbacks = setmetatable({}, {__mode="k"}),
++ callbacks = {},
+ }, poller_mt)
+ end
+
+-setmetatable(_M, {__call = function(tab, ...) return new(...) end})
++zmq.poller = M
++return setmetatable(M, {__call = function(tab, ...) return M.new(...) end})
+
+diff --git a/src/poller.nobj.lua b/src/poller.nobj.lua
+index 66594d2..39b4938 100644
+--- a/src/poller.nobj.lua
++++ b/src/poller.nobj.lua
+@@ -58,7 +58,24 @@ static int poller_resize_items(ZMQ_Poller *poller, int len) {
+ return len;
+ }
+
+-static int poller_find_sock_item(ZMQ_Poller *poller, ZMQ_Socket *sock) {
++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;
+@@ -73,7 +90,7 @@ static int poller_find_sock_item(ZMQ_Poller *poller, ZMQ_Socket *sock) {
+ return -1;
+ }
+
+-static int poller_find_fd_item(ZMQ_Poller *poller, socket_t fd) {
++int poller_find_fd_item(ZMQ_Poller *poller, socket_t fd) {
+ zmq_pollitem_t *items;
+ int count;
+ int n;
+@@ -88,7 +105,7 @@ static int poller_find_fd_item(ZMQ_Poller *poller, socket_t fd) {
+ return -1;
+ }
+
+-static void poller_remove_item(ZMQ_Poller *poller, int idx) {
++void poller_remove_item(ZMQ_Poller *poller, int idx) {
+ zmq_pollitem_t *items;
+ int free_list;
+ int count;
+@@ -115,7 +132,7 @@ static void poller_remove_item(ZMQ_Poller *poller, int idx) {
+ items[idx].revents = 0;
+ }
+
+-static int poller_get_free_item(ZMQ_Poller *poller) {
++int poller_get_free_item(ZMQ_Poller *poller) {
+ zmq_pollitem_t *curr;
+ zmq_pollitem_t *next;
+ int count;
+@@ -191,14 +208,46 @@ static int poller_compact_items(ZMQ_Poller *poller) {
+ return count;
+ }
+
+-static int poller_poll(ZMQ_Poller *poller, long timeout) {
++int poller_poll(ZMQ_Poller *poller, long timeout) {
+ int count;
+ /* remove free slots from items list. */
+- count = poller_compact_items(poller);
++ 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;
++}
++
+ ]],
+ --
+ -- Define ZMQ_Poller type & function API for FFI
+@@ -212,36 +261,21 @@ typedef struct zmq_pollitem_t {
+ short revents;
+ } zmq_pollitem_t;
+
+-int zmq_poll(zmq_pollitem_t *items, int nitems, long timeout);
++int poller_find_sock_item(ZMQ_Poller *poller, ZMQ_Socket *sock);
++int poller_find_fd_item(ZMQ_Poller *poller, socket_t fd);
++int poller_get_free_item(ZMQ_Poller *poller);
++int poller_poll(ZMQ_Poller *poller, long timeout);
++void poller_remove_item(ZMQ_Poller *poller, int idx);
++
+ ]],
+ ffi_cdef(ZMQ_Poller_type),
+- ffi_export_function "int" "poller_find_sock_item" "(ZMQ_Poller *poller, ZMQ_Socket *sock)",
+- ffi_export_function "int" "poller_find_fd_item" "(ZMQ_Poller *poller, socket_t fd)",
+- ffi_export_function "int" "poller_get_free_item" "(ZMQ_Poller *poller)",
+- ffi_export_function "int" "poller_poll" "(ZMQ_Poller *poller, long timeout)",
+- ffi_export_function "void" "poller_remove_item" "(ZMQ_Poller *poller, int idx)",
+
+ constructor "new" {
+ var_in{ "unsigned int", "length", is_optional = true, default = 10 },
+- c_source[[
+- ZMQ_Poller poller;
+- ${this} = &poller;
+- ${this}->items = (zmq_pollitem_t *)calloc(${length}, sizeof(zmq_pollitem_t));
+- ${this}->next = -1;
+- ${this}->count = 0;
+- ${this}->len = ${length};
+- ${this}->free_list = -1;
+-]],
++ c_export_method_call "void" "poller_init" { "unsigned int", "length" },
+ },
+ destructor "close" {
+- c_source[[
+- free(${this}->items);
+- ${this}->items = NULL;
+- ${this}->next = -1;
+- ${this}->count = 0;
+- ${this}->len = 0;
+- ${this}->free_list = -1;
+-]],
++ c_export_method_call "void" "poller_cleanup" {},
+ },
+ method "add" {
+ var_in{ "<any>", "sock" },
+@@ -266,6 +300,22 @@ int zmq_poll(zmq_pollitem_t *items, int nitems, long timeout);
+ item->fd = fd;
+ item->events = ${events};
+ ]],
++ ffi_source[[
++ local fd = 0
++ local sock_type = type(${sock})
++ if sock_type == 'cdata' then
++ sock = obj_type_ZMQ_Socket_check(${sock})
++ elseif sock_type == 'number' then
++ fd = ${sock}
++ else
++ error("expected number or ZMQ_Socket")
++ end
++ ${idx} = Cmod.poller_get_free_item(${this})
++ local item = ${this}.items[${idx}]
++ item.socket = sock
++ item.fd = fd
++ item.events = ${events}
++]],
+ },
+ method "modify" {
+ var_in{ "<any>", "sock" },
+@@ -302,123 +352,99 @@ int zmq_poll(zmq_pollitem_t *items, int nitems, long timeout);
+ poller_remove_item(${this}, ${idx});
+ }
+ ]],
++ ffi_source[[
++ local fd = 0
++ local sock_type = type(${sock})
++ if sock_type == 'cdata' then
++ sock = obj_type_ZMQ_Socket_check(${sock})
++ -- find sock in items list.
++ ${idx} = Cmod.poller_find_sock_item(${this}, sock)
++ elseif sock_type == 'number' then
++ fd = ${sock}
++ -- find fd in items list.
++ ${idx} = Cmod.poller_find_fd_item(${this}, fd);
++ else
++ error("expected number or ZMQ_Socket")
++ end
++ if ${events} ~= 0 then
++ local item = ${this}.items[${idx}]
++ item.socket = sock
++ item.fd = fd
++ item.events = ${events}
++ else
++ Cmod.poller_remove_item(${this}, ${idx})
++ end
++]],
+ },
+ method "remove" {
+ var_in{ "<any>", "sock" },
++ var_out{ "int", "idx" },
+ c_source "pre" [[
+ ZMQ_Socket *sock;
+ socket_t fd;
+- int idx;
+ ]],
+ c_source[[
+ /* ZMQ_Socket or fd */
+ if(lua_isuserdata(L, ${sock::idx})) {
+ sock = obj_type_ZMQ_Socket_check(L, ${sock::idx});
+ /* find sock in items list. */
+- idx = poller_find_sock_item(${this}, sock);
++ ${idx} = poller_find_sock_item(${this}, sock);
+ } else if(lua_isnumber(L, ${sock::idx})) {
+ fd = lua_tonumber(L, ${sock::idx});
+ /* find fd in items list. */
+- idx = poller_find_fd_item(${this}, fd);
++ ${idx} = poller_find_fd_item(${this}, fd);
+ } else {
+ return luaL_typerror(L, ${sock::idx}, "number or ZMQ_Socket");
+ }
+ /* if sock/fd was found. */
+- if(idx >= 0) {
+- poller_remove_item(${this}, idx);
++ if(${idx} >= 0) {
++ poller_remove_item(${this}, ${idx});
+ }
+ ]],
++ ffi_source[[
++ local fd = 0
++ local sock_type = type(${sock})
++ if sock_type == 'cdata' then
++ sock = obj_type_ZMQ_Socket_check(${sock})
++ -- find sock in items list.
++ ${idx} = Cmod.poller_find_sock_item(${this}, sock)
++ elseif sock_type == 'number' then
++ fd = ${sock}
++ -- find fd in items list.
++ ${idx} = Cmod.poller_find_fd_item(${this}, fd);
++ else
++ error("expected number or ZMQ_Socket")
++ end
++ if ${idx} >= 0 then
++ Cmod.poller_remove_item(${this}, ${idx})
++ end
++]],
+ },
+ method "poll" {
+- var_in{ "long", "timeout" },
+- var_out{ "ZMQ_Error", "err" },
++ var_out{ "int", "count" },
++ -- poll for events
++ c_export_method_call { "ZMQ_Error", "err>2" } "poller_poll" { "long", "timeout" },
+ c_source[[
+- /* poll for events */
+- ${err} = poller_poll(${this}, ${timeout});
+ if(${err} > 0) {
+ ${this}->next = 0;
++ ${count} = ${err};
+ } else {
+ ${this}->next = -1;
++ ${count} = 0;
+ }
+ ]],
+ ffi_source[[
+- -- poll for events
+- ${err} = poller_poll(${this}, ${timeout})
+ if(${err} > 0) then
+ ${this}.next = 0
++ ${count} = ${err}
+ else
+ ${this}.next = -1
++ ${count} = 0
+ end
+ ]],
+ },
+- method "next_revents" {
+- var_out{ "<any>", "sock" },
+- var_out{ "short", "revents" },
+- c_source "pre" [[
+- zmq_pollitem_t *items;
+- int count;
+- int idx;
+-]],
+- c_source[[
+- ${revents} = -1;
+- idx = ${this}->next;
+- if(idx >= 0) {
+- count = ${this}->count;
+- items = ${this}->items;
+- /* find next item with pending events. */
+- while(idx < count && items[idx].revents == 0) ++idx;
+- /* did we find a pending event? */
+- if(idx < count) {
+- /* push the event's sock/fd. */
+- if(items[idx].socket != NULL) {
+- obj_type_ZMQ_Socket_push(L, items[idx].socket, 0);
+- } else {
+- lua_pushnumber(L, items[idx].fd);
+- }
+- ${revents} = items[idx].revents;
+- /* is this the last event. */
+- ++idx;
+- ${this}->next = (idx < count) ? idx : -1;
+- }
+- }
+- if(${revents} < 0) {
+- /* no more pending events. */
+- lua_pushnil(L);
+- ${this}->next = -1;
+- }
+-]],
+- ffi_source[[
+- local sock
+- local idx = ${this}.next
+- if (idx < 0) then return nil, -1 end
+- local count = ${this}.count
+- -- find next item with pending events.
+- while (idx < count and ${this}.items[idx].revents == 0) do
+- idx = idx + 1
+- if (idx >= count) then
+- idx = -1
+- break
+- end
+- end
+- -- did we find a pending event?
+- if(idx >= 0) then
+- -- push the event's sock/fd.
+- if(${this}.items[idx].socket ~= nil) then
+- sock = obj_type_ZMQ_Socket_push(${this}.items[idx].socket, 0)
+- else
+- sock = tonumber(${this}.items[idx].fd)
+- end
+- ${revents} = ${this}.items[idx].revents
+- -- is this the last event.
+- idx = idx + 1
+- if (idx >= count) then
+- idx = -1
+- end
+- ${this}.next = idx
+- return sock, ${revents}
+- end
+- ${this}.next = idx
+-]],
++ method "next_revents_idx" {
++ c_export_method_call { "int", "idx>1" } "poller_next_revents" { "int", "&revents>2" },
+ },
+ method "count" {
+ var_out{ "int", "count" },
+diff --git a/src/pre_generated-zmq.nobj.c b/src/pre_generated-zmq.nobj.c
+index a6d739d..7442736 100644
+--- a/src/pre_generated-zmq.nobj.c
++++ b/src/pre_generated-zmq.nobj.c
+@@ -10,16 +10,65 @@
+ #include "lauxlib.h"
+ #include "lualib.h"
+
+-#include <string.h>
+-#include "zmq.h"
+-#include "zmq_utils.h"
++/* some Lua 5.0 compatibility support. */
++#if !defined(lua_pushliteral)
++#define lua_pushliteral(L, s) lua_pushstring(L, "" s, (sizeof(s)/sizeof(char))-1)
++#endif
++
++#if !defined(LUA_VERSION_NUM)
++#define lua_pushinteger(L, n) lua_pushnumber(L, (lua_Number)n)
++#define luaL_Reg luaL_reg
++#endif
++
++/* some Lua 5.1 compatibility support. */
++#if !defined(LUA_VERSION_NUM) || (LUA_VERSION_NUM == 501)
++/*
++** Adapted from Lua 5.2.0
++*/
++static void luaL_setfuncs (lua_State *L, const luaL_Reg *l, int nup) {
++ luaL_checkstack(L, nup, "too many upvalues");
++ for (; l->name != NULL; l++) { /* fill the table with given functions */
++ int i;
++ for (i = 0; i < nup; i++) /* copy upvalues to the top */
++ lua_pushvalue(L, -nup);
++ lua_pushstring(L, l->name);
++ lua_pushcclosure(L, l->func, nup); /* closure with those upvalues */
++ lua_settable(L, -(nup + 3));
++ }
++ lua_pop(L, nup); /* remove upvalues */
++}
++
++#define lua_load_no_mode(L, reader, data, source) \
++ lua_load(L, reader, data, source)
++
++#define lua_rawlen(L, idx) lua_objlen(L, idx)
++
++#endif
++
++#if LUA_VERSION_NUM == 502
++
++#define lua_load_no_mode(L, reader, data, source) \
++ lua_load(L, reader, data, source, NULL)
+
++static int luaL_typerror (lua_State *L, int narg, const char *tname) {
++ const char *msg = lua_pushfstring(L, "%s expected, got %s",
++ tname, luaL_typename(L, narg));
++ return luaL_argerror(L, narg, msg);
++}
++
++#endif
+
+ #define REG_PACKAGE_IS_CONSTRUCTOR 0
++#define REG_MODULES_AS_GLOBALS 1
+ #define REG_OBJECTS_AS_GLOBALS 0
+ #define OBJ_DATA_HIDDEN_METATABLE 1
+-#define LUAJIT_FFI 1
+ #define USE_FIELD_GET_SET_METHODS 0
++#define LUAJIT_FFI 1
++
++
++#include <string.h>
++#include "zmq.h"
++#include "zmq_utils.h"
+
+
+
+@@ -41,6 +90,7 @@
+ /* for MinGW32 compiler need to include <stdint.h> */
+ #ifdef __GNUC__
+ #include <stdint.h>
++#include <stdbool.h>
+ #else
+
+ /* define some standard types missing on Windows. */
+@@ -57,7 +107,7 @@ typedef int bool;
+ #define true 1
+ #endif
+ #ifndef false
+-#define false 1
++#define false 0
+ #endif
+
+ #endif
+@@ -98,19 +148,26 @@ typedef int bool;
+ #define assert_obj_type(type, obj)
+ #endif
+
+-#ifndef obj_type_free
++void *nobj_realloc(void *ptr, size_t osize, size_t nsize);
++
++void *nobj_realloc(void *ptr, size_t osize, size_t nsize) {
++ (void)osize;
++ if(0 == nsize) {
++ free(ptr);
++ return NULL;
++ }
++ return realloc(ptr, nsize);
++}
++
+ #define obj_type_free(type, obj) do { \
+ assert_obj_type(type, obj); \
+- free((obj)); \
++ nobj_realloc((obj), sizeof(type), 0); \
+ } while(0)
+-#endif
+
+-#ifndef obj_type_new
+ #define obj_type_new(type, obj) do { \
+ assert_obj_type(type, obj); \
+- (obj) = malloc(sizeof(type)); \
++ (obj) = nobj_realloc(NULL, 0, sizeof(type)); \
+ } while(0)
+-#endif
+
+ typedef struct obj_type obj_type;
+
+@@ -120,6 +177,7 @@ typedef void (*dyn_caster_t)(void **obj, obj_type **type);
+
+ #define OBJ_TYPE_FLAG_WEAK_REF (1<<0)
+ #define OBJ_TYPE_SIMPLE (1<<1)
++#define OBJ_TYPE_IMPORT (1<<2)
+ struct obj_type {
+ dyn_caster_t dcaster; /**< caster to support casting to sub-objects. */
+ int32_t id; /**< type's id. */
+@@ -168,15 +226,28 @@ typedef struct obj_field {
+ uint32_t flags; /**< is_writable:1bit */
+ } obj_field;
+
++typedef enum {
++ REG_OBJECT,
++ REG_PACKAGE,
++ REG_META,
++} module_reg_type;
++
++typedef struct reg_impl {
++ const char *if_name;
++ const void *impl;
++} reg_impl;
++
+ typedef struct reg_sub_module {
+ obj_type *type;
+- int is_package;
+- const luaL_reg *pub_funcs;
+- const luaL_reg *methods;
+- const luaL_reg *metas;
++ module_reg_type req_type;
++ const luaL_Reg *pub_funcs;
++ const luaL_Reg *methods;
++ const luaL_Reg *metas;
+ const obj_base *bases;
+ const obj_field *fields;
+ const obj_const *constants;
++ const reg_impl *implements;
++ int bidirectional_consts;
+ } reg_sub_module;
+
+ #define OBJ_UDATA_FLAG_OWN (1<<0)
+@@ -188,15 +259,78 @@ typedef struct obj_udata {
+ } obj_udata;
+
+ /* use static pointer as key to weak userdata table. */
+-static char *obj_udata_weak_ref_key = "obj_udata_weak_ref_key";
++static char obj_udata_weak_ref_key[] = "obj_udata_weak_ref_key";
++
++/* use static pointer as key to module's private table. */
++static char obj_udata_private_key[] = "obj_udata_private_key";
+
+ #if LUAJIT_FFI
++typedef int (*ffi_export_func_t)(void);
+ typedef struct ffi_export_symbol {
+ const char *name;
+- void *sym;
++ union {
++ void *data;
++ ffi_export_func_t func;
++ } sym;
+ } ffi_export_symbol;
+ #endif
+
++/* detect zmq version */
++#define VERSION_2_0 1
++#define VERSION_2_1 0
++#define VERSION_2_2 0
++#define VERSION_3_0 0
++#if defined(ZMQ_VERSION_MAJOR)
++# if (ZMQ_VERSION_MAJOR == 2) && (ZMQ_VERSION_MINOR == 2)
++# undef VERSION_2_2
++# define VERSION_2_2 1
++# undef VERSION_2_1
++# define VERSION_2_1 1
++# endif
++# if (ZMQ_VERSION_MAJOR == 2) && (ZMQ_VERSION_MINOR == 1)
++# undef VERSION_2_1
++# define VERSION_2_1 1
++# endif
++# if (ZMQ_VERSION_MAJOR == 3)
++# undef VERSION_2_0
++# define VERSION_2_0 0
++# undef VERSION_3_0
++# define VERSION_3_0 1
++# endif
++#endif
++
++/* make sure ZMQ_DONTWAIT & ZMQ_NOBLOCK are both defined. */
++#ifndef ZMQ_DONTWAIT
++# define ZMQ_DONTWAIT ZMQ_NOBLOCK
++#endif
++#ifndef ZMQ_NOBLOCK
++# define ZMQ_NOBLOCK ZMQ_DONTWAIT
++#endif
++
++/* make sure DEALER/ROUTER & XREQ/XREP are all defined. */
++#ifndef ZMQ_DEALER
++# define ZMQ_DEALER ZMQ_XREQ
++#endif
++#ifndef ZMQ_ROUTER
++# define ZMQ_ROUTER ZMQ_XREP
++#endif
++#ifndef ZMQ_XREQ
++# define ZMQ_XREQ ZMQ_DEALER
++#endif
++#ifndef ZMQ_XREP
++# define ZMQ_XREP ZMQ_ROUTER
++#endif
++
++#if VERSION_2_0
++# define ZMQ_POLL_MSEC 1000 // zmq_poll is usec
++#elif VERSION_3_0
++# define ZMQ_POLL_MSEC 1 // zmq_poll is msec
++# ifndef ZMQ_HWM
++# define ZMQ_HWM 1 // backwards compatibility
++# endif
++#endif
++
++
+
+ typedef int ZMQ_Error;
+
+@@ -204,29 +338,329 @@ static void error_code__ZMQ_Error__push(lua_State *L, ZMQ_Error err);
+
+
+ static obj_type obj_types[] = {
+-#define obj_type_id_zmq_msg_t 0
++#define obj_type_id_ZErrors 0
++#define obj_type_ZErrors (obj_types[obj_type_id_ZErrors])
++ { NULL, 0, OBJ_TYPE_FLAG_WEAK_REF, "ZErrors" },
++#define obj_type_id_zmq_msg_t 1
+ #define obj_type_zmq_msg_t (obj_types[obj_type_id_zmq_msg_t])
+- { NULL, 0, OBJ_TYPE_SIMPLE, "zmq_msg_t" },
+-#define obj_type_id_ZMQ_Socket 1
++ { NULL, 1, OBJ_TYPE_SIMPLE, "zmq_msg_t" },
++#define obj_type_id_ZMQ_Socket 2
+ #define obj_type_ZMQ_Socket (obj_types[obj_type_id_ZMQ_Socket])
+- { NULL, 1, OBJ_TYPE_FLAG_WEAK_REF, "ZMQ_Socket" },
+-#define obj_type_id_ZMQ_Poller 2
++ { NULL, 2, OBJ_TYPE_FLAG_WEAK_REF, "ZMQ_Socket" },
++#define obj_type_id_ZMQ_Poller 3
+ #define obj_type_ZMQ_Poller (obj_types[obj_type_id_ZMQ_Poller])
+- { NULL, 2, OBJ_TYPE_SIMPLE, "ZMQ_Poller" },
+-#define obj_type_id_ZMQ_Ctx 3
++ { NULL, 3, OBJ_TYPE_SIMPLE, "ZMQ_Poller" },
++#define obj_type_id_ZMQ_Ctx 4
+ #define obj_type_ZMQ_Ctx (obj_types[obj_type_id_ZMQ_Ctx])
+- { NULL, 3, OBJ_TYPE_FLAG_WEAK_REF, "ZMQ_Ctx" },
+-#define obj_type_id_ZMQ_StopWatch 4
++ { NULL, 4, OBJ_TYPE_FLAG_WEAK_REF, "ZMQ_Ctx" },
++#define obj_type_id_ZMQ_StopWatch 5
+ #define obj_type_ZMQ_StopWatch (obj_types[obj_type_id_ZMQ_StopWatch])
+- { NULL, 4, OBJ_TYPE_FLAG_WEAK_REF, "ZMQ_StopWatch" },
++ { NULL, 5, OBJ_TYPE_FLAG_WEAK_REF, "ZMQ_StopWatch" },
+ {NULL, -1, 0, NULL},
+ };
+
+
++#if LUAJIT_FFI
++
++/* nobj_ffi_support_enabled_hint should be set to 1 when FFI support is enabled in at-least one
++ * instance of a LuaJIT state. It should never be set back to 0. */
++static int nobj_ffi_support_enabled_hint = 0;
++static const char nobj_ffi_support_key[] = "LuaNativeObject_FFI_SUPPORT";
++static const char nobj_check_ffi_support_code[] =
++"local stat, ffi=pcall(require,\"ffi\")\n" /* try loading LuaJIT`s FFI module. */
++"if not stat then return false end\n"
++"return true\n";
++
++static int nobj_check_ffi_support(lua_State *L) {
++ int rc;
++ int err;
++
++ /* check if ffi test has already been done. */
++ lua_pushstring(L, nobj_ffi_support_key);
++ lua_rawget(L, LUA_REGISTRYINDEX);
++ if(!lua_isnil(L, -1)) {
++ rc = lua_toboolean(L, -1);
++ lua_pop(L, 1);
++ /* use results of previous check. */
++ goto finished;
++ }
++ lua_pop(L, 1); /* pop nil. */
++
++ err = luaL_loadbuffer(L, nobj_check_ffi_support_code,
++ sizeof(nobj_check_ffi_support_code) - 1, nobj_ffi_support_key);
++ if(0 == err) {
++ err = lua_pcall(L, 0, 1, 0);
++ }
++ if(err) {
++ const char *msg = "<err not a string>";
++ if(lua_isstring(L, -1)) {
++ msg = lua_tostring(L, -1);
++ }
++ printf("Error when checking for FFI-support: %s\n", msg);
++ lua_pop(L, 1); /* pop error message. */
++ return 0;
++ }
++ /* check results of test. */
++ rc = lua_toboolean(L, -1);
++ lua_pop(L, 1); /* pop results. */
++ /* cache results. */
++ lua_pushstring(L, nobj_ffi_support_key);
++ lua_pushboolean(L, rc);
++ lua_rawset(L, LUA_REGISTRYINDEX);
++
++finished:
++ /* turn-on hint that there is FFI code enabled. */
++ if(rc) {
++ nobj_ffi_support_enabled_hint = 1;
++ }
++
++ return rc;
++}
++
++typedef struct {
++ const char **ffi_init_code;
++ int offset;
++} nobj_reader_state;
++
++static const char *nobj_lua_Reader(lua_State *L, void *data, size_t *size) {
++ nobj_reader_state *state = (nobj_reader_state *)data;
++ const char *ptr;
++
++ (void)L;
++ ptr = state->ffi_init_code[state->offset];
++ if(ptr != NULL) {
++ *size = strlen(ptr);
++ state->offset++;
++ } else {
++ *size = 0;
++ }
++ return ptr;
++}
++
++static int nobj_try_loading_ffi(lua_State *L, const char *ffi_mod_name,
++ const char *ffi_init_code[], const ffi_export_symbol *ffi_exports, int priv_table)
++{
++ nobj_reader_state state = { ffi_init_code, 0 };
++ int err;
++
++ /* export symbols to priv_table. */
++ while(ffi_exports->name != NULL) {
++ lua_pushstring(L, ffi_exports->name);
++ lua_pushlightuserdata(L, ffi_exports->sym.data);
++ lua_settable(L, priv_table);
++ ffi_exports++;
++ }
++ err = lua_load_no_mode(L, nobj_lua_Reader, &state, ffi_mod_name);
++ if(0 == err) {
++ lua_pushvalue(L, -2); /* dup C module's table. */
++ lua_pushvalue(L, priv_table); /* move priv_table to top of stack. */
++ lua_remove(L, priv_table);
++ lua_pushvalue(L, LUA_REGISTRYINDEX);
++ err = lua_pcall(L, 3, 0, 0);
++ }
++ if(err) {
++ const char *msg = "<err not a string>";
++ if(lua_isstring(L, -1)) {
++ msg = lua_tostring(L, -1);
++ }
++ printf("Failed to install FFI-based bindings: %s\n", msg);
++ lua_pop(L, 1); /* pop error message. */
++ }
++ return err;
++}
++#endif
++
++
++typedef struct {
++ void *impl;
++ void *obj;
++} obj_implement;
++
++static FUNC_UNUSED void *obj_implement_luaoptional(lua_State *L, int _index, void **impl, char *if_name) {
++ void *ud;
++ if(lua_isnoneornil(L, _index)) {
++ return NULL;
++ }
++ /* get the implements table for this interface. */
++ lua_pushlightuserdata(L, if_name);
++ lua_rawget(L, LUA_REGISTRYINDEX);
++
++ /* get pointer to userdata value & check if it is a userdata value. */
++ ud = (obj_implement *)lua_touserdata(L, _index);
++ if(ud != NULL) {
++ /* get the userdata's metatable */
++ if(lua_getmetatable(L, _index)) {
++ /* lookup metatable in interface table for this object's implementation of the interface. */
++ lua_gettable(L, -2);
++ } else {
++ /* no metatable. */
++ goto no_interface;
++ }
++#if LUAJIT_FFI
++ } else if(nobj_ffi_support_enabled_hint) { /* handle cdata. */
++ /* get cdata interface check function from interface table. */
++ lua_getfield(L, -1, "cdata");
++ if(lua_isfunction(L, -1)) {
++ /* pass cdata to function, return value should be an implmentation. */
++ lua_pushvalue(L, _index);
++ lua_call(L, 1, 1);
++ /* get pointer to cdata. */
++ ud = (void *)lua_topointer(L, _index);
++ } else {
++ lua_pop(L, 1); /* pop non-function. */
++ goto no_interface;
++ }
++#endif
++ } else {
++ goto no_interface;
++ }
++
++ if(!lua_isnil(L, -1)) {
++ *impl = lua_touserdata(L, -1);
++ lua_pop(L, 2); /* pop interface table & implementation. */
++ /* object implements interface. */
++ return ud;
++ } else {
++ lua_pop(L, 1); /* pop nil. */
++ }
++no_interface:
++ lua_pop(L, 1); /* pop interface table. */
++ return NULL;
++}
++
++static FUNC_UNUSED void *obj_implement_luacheck(lua_State *L, int _index, void **impl, char *type) {
++ void *ud = obj_implement_luaoptional(L, _index, impl, type);
++ if(ud == NULL) {
++#define ERROR_BUFFER_SIZE 256
++ char buf[ERROR_BUFFER_SIZE];
++ snprintf(buf, ERROR_BUFFER_SIZE-1,"Expected object with %s interface", type);
++ /* value doesn't implement this interface. */
++ luaL_argerror(L, _index, buf);
++ }
++ return ud;
++}
++
++/* use static pointer as key to interfaces table. (version 1.0) */
++static char obj_interfaces_table_key[] = "obj_interfaces<1.0>_table_key";
++
++static void obj_get_global_interfaces_table(lua_State *L) {
++ /* get global interfaces table. */
++ lua_getfield(L, LUA_REGISTRYINDEX, obj_interfaces_table_key);
++ if(lua_isnil(L, -1)) {
++ /* Need to create global interfaces table. */
++ lua_pop(L, 1); /* pop nil */
++ lua_createtable(L, 0, 4); /* 0 size array part, small hash part. */
++ lua_pushvalue(L, -1); /* dup table. */
++ /* store interfaces table in Lua registery. */
++ lua_setfield(L, LUA_REGISTRYINDEX, obj_interfaces_table_key);
++ }
++}
++
++static void obj_get_interface(lua_State *L, const char *name, int global_if_tab) {
++ /* get a interface's implementation table */
++ lua_getfield(L, global_if_tab, name);
++ if(lua_isnil(L, -1)) {
++ lua_pop(L, 1); /* pop nil */
++ /* new interface. (i.e. no object implement it yet.)
++ *
++ * create an empty table for this interface that will be used when an
++ * implementation is registered for this interface.
++ */
++ lua_createtable(L, 0, 2); /* 0 size array part, small hash part. */
++ lua_pushvalue(L, -1); /* dup table. */
++ lua_setfield(L, global_if_tab, name); /* store interface in global interfaces table. */
++ }
++}
++
++static int obj_get_userdata_interface(lua_State *L) {
++ /* get the userdata's metatable */
++ if(lua_getmetatable(L, 2)) {
++ /* lookup metatable in interface table for the userdata's implementation of the interface. */
++ lua_gettable(L, 1);
++ if(!lua_isnil(L, -1)) {
++ /* return the implementation. */
++ return 1;
++ }
++ }
++ /* no metatable or no implementation. */
++ return 0;
++}
++
++static void obj_interface_register(lua_State *L, char *name, int global_if_tab) {
++ /* get the table of implementations for this interface. */
++ obj_get_interface(L, name, global_if_tab);
++
++ /* check for 'userdata' function. */
++ lua_getfield(L, -1, "userdata");
++ if(lua_isnil(L, -1)) {
++ lua_pop(L, 1); /* pop nil. */
++ /* add C function for getting a userdata's implementation. */
++ lua_pushcfunction(L, obj_get_userdata_interface);
++ lua_setfield(L, -2, "userdata");
++ } else {
++ /* already have function. */
++ lua_pop(L, 1); /* pop C function. */
++ }
++ /* we are going to use a lightuserdata pointer for fast lookup of the interface's impl. table. */
++ lua_pushlightuserdata(L, name);
++ lua_insert(L, -2);
++ lua_settable(L, LUA_REGISTRYINDEX);
++}
++
++static void obj_register_interfaces(lua_State *L, char *interfaces[]) {
++ int i;
++ int if_tab;
++ /* get global interfaces table. */
++ obj_get_global_interfaces_table(L);
++ if_tab = lua_gettop(L);
++
++ for(i = 0; interfaces[i] != NULL ; i++) {
++ obj_interface_register(L, interfaces[i], if_tab);
++ }
++ lua_pop(L, 1); /* pop global interfaces table. */
++}
++
++static void obj_type_register_implement(lua_State *L, const reg_impl *impl, int global_if_tab, int mt_tab) {
++ /* get the table of implementations for this interface. */
++ obj_get_interface(L, impl->if_name, global_if_tab);
++
++ /* register object's implement in the interface table. */
++ lua_pushvalue(L, mt_tab);
++ lua_pushlightuserdata(L, (void *)impl->impl);
++ lua_settable(L, -3);
++
++ lua_pop(L, 1); /* pop inteface table. */
++}
++
++static void obj_type_register_implements(lua_State *L, const reg_impl *impls) {
++ int if_tab;
++ int mt_tab;
++ /* get absolute position of object's metatable. */
++ mt_tab = lua_gettop(L);
++ /* get global interfaces table. */
++ obj_get_global_interfaces_table(L);
++ if_tab = lua_gettop(L);
++
++ for(; impls->if_name != NULL ; impls++) {
++ obj_type_register_implement(L, impls, if_tab, mt_tab);
++ }
++ lua_pop(L, 1); /* pop global interfaces table. */
++}
++
+ #ifndef REG_PACKAGE_IS_CONSTRUCTOR
+ #define REG_PACKAGE_IS_CONSTRUCTOR 1
+ #endif
+
++#ifndef REG_MODULES_AS_GLOBALS
++#define REG_MODULES_AS_GLOBALS 0
++#endif
++
++/* For Lua 5.2 don't register modules as globals. */
++#if LUA_VERSION_NUM == 502
++#undef REG_MODULES_AS_GLOBALS
++#define REG_MODULES_AS_GLOBALS 0
++#endif
++
+ #ifndef REG_OBJECTS_AS_GLOBALS
+ #define REG_OBJECTS_AS_GLOBALS 0
+ #endif
+@@ -235,6 +669,48 @@ static obj_type obj_types[] = {
+ #define OBJ_DATA_HIDDEN_METATABLE 1
+ #endif
+
++static FUNC_UNUSED int obj_import_external_type(lua_State *L, obj_type *type) {
++ /* find the external type's metatable using it's name. */
++ lua_pushstring(L, type->name);
++ lua_rawget(L, LUA_REGISTRYINDEX); /* external type's metatable. */
++ if(!lua_isnil(L, -1)) {
++ /* found it. Now we will map our 'type' pointer to the metatable. */
++ /* REGISTERY[lightuserdata<type>] = REGISTERY[type->name] */
++ lua_pushlightuserdata(L, type); /* use our 'type' pointer as lookup key. */
++ lua_pushvalue(L, -2); /* dup. type's metatable. */
++ lua_rawset(L, LUA_REGISTRYINDEX); /* save external type's metatable. */
++ /* NOTE: top of Lua stack still has the type's metatable. */
++ return 1;
++ } else {
++ lua_pop(L, 1); /* pop nil. */
++ }
++ return 0;
++}
++
++static FUNC_UNUSED int obj_import_external_ffi_type(lua_State *L, obj_type *type) {
++ /* find the external type's metatable using it's name. */
++ lua_pushstring(L, type->name);
++ lua_rawget(L, LUA_REGISTRYINDEX); /* external type's metatable. */
++ if(!lua_isnil(L, -1)) {
++ /* found it. Now we will map our 'type' pointer to the C check function. */
++ /* _priv_table[lightuserdata<type>] = REGISTERY[type->name].c_check */
++ lua_getfield(L, -1, "c_check");
++ lua_remove(L, -2); /* remove metatable. */
++ if(lua_isfunction(L, -1)) {
++ lua_pushlightuserdata(L, type); /* use our 'type' pointer as lookup key. */
++ lua_pushvalue(L, -2); /* dup. check function */
++ lua_rawset(L, -4); /* save check function to module's private table. */
++ /* NOTE: top of Lua stack still has the type's C check function. */
++ return 1;
++ } else {
++ lua_pop(L, 1); /* pop non function value. */
++ }
++ } else {
++ lua_pop(L, 1); /* pop nil. */
++ }
++ return 0;
++}
++
+ static FUNC_UNUSED obj_udata *obj_udata_toobj(lua_State *L, int _index) {
+ obj_udata *ud;
+ size_t len;
+@@ -245,7 +721,7 @@ static FUNC_UNUSED obj_udata *obj_udata_toobj(lua_State *L, int _index) {
+ luaL_typerror(L, _index, "userdata"); /* is not a userdata value. */
+ }
+ /* verify userdata size. */
+- len = lua_objlen(L, _index);
++ len = lua_rawlen(L, _index);
+ if(len != sizeof(obj_udata)) {
+ /* This shouldn't be possible */
+ luaL_error(L, "invalid userdata size: size=%d, expected=%d", len, sizeof(obj_udata));
+@@ -258,10 +734,23 @@ static FUNC_UNUSED int obj_udata_is_compatible(lua_State *L, obj_udata *ud, void
+ obj_type *ud_type;
+ lua_pushlightuserdata(L, type);
+ lua_rawget(L, LUA_REGISTRYINDEX); /* type's metatable. */
++recheck_metatable:
+ if(lua_rawequal(L, -1, -2)) {
+ *obj = ud->obj;
+ /* same type no casting needed. */
+ return 1;
++ } else if(lua_isnil(L, -1)) {
++ lua_pop(L, 1); /* pop nil. */
++ if((type->flags & OBJ_TYPE_IMPORT) == 0) {
++ /* can't resolve internal type. */
++ luaL_error(L, "Unknown object type(id=%d, name=%s)", type->id, type->name);
++ }
++ /* try to import external type. */
++ if(obj_import_external_type(L, type)) {
++ /* imported type, re-try metatable check. */
++ goto recheck_metatable;
++ }
++ /* External type not yet available, so the object can't be compatible. */
+ } else {
+ /* Different types see if we can cast to the required type. */
+ lua_rawgeti(L, -2, type->id);
+@@ -314,6 +803,39 @@ static FUNC_UNUSED obj_udata *obj_udata_luacheck_internal(lua_State *L, int _ind
+ return ud;
+ }
+ }
++ } else if(!lua_isnoneornil(L, _index)) {
++ /* handle cdata. */
++ /* get private table. */
++ lua_pushlightuserdata(L, obj_udata_private_key);
++ lua_rawget(L, LUA_REGISTRYINDEX); /* private table. */
++ /* get cdata type check function from private table. */
++ lua_pushlightuserdata(L, type);
++ lua_rawget(L, -2);
++
++ /* check for function. */
++ if(!lua_isnil(L, -1)) {
++got_check_func:
++ /* pass cdata value to type checking function. */
++ lua_pushvalue(L, _index);
++ lua_call(L, 1, 1);
++ if(!lua_isnil(L, -1)) {
++ /* valid type get pointer from cdata. */
++ lua_pop(L, 2);
++ *obj = *(void **)lua_topointer(L, _index);
++ return ud;
++ }
++ lua_pop(L, 2);
++ } else {
++ lua_pop(L, 1); /* pop nil. */
++ if(type->flags & OBJ_TYPE_IMPORT) {
++ /* try to import external ffi type. */
++ if(obj_import_external_ffi_type(L, type)) {
++ /* imported type. */
++ goto got_check_func;
++ }
++ /* External type not yet available, so the object can't be compatible. */
++ }
++ }
+ }
+ if(not_delete) {
+ luaL_typerror(L, _index, type->name); /* is not a userdata value. */
+@@ -327,6 +849,15 @@ static FUNC_UNUSED void *obj_udata_luacheck(lua_State *L, int _index, obj_type *
+ return obj;
+ }
+
++static FUNC_UNUSED void *obj_udata_luaoptional(lua_State *L, int _index, obj_type *type) {
++ void *obj = NULL;
++ if(lua_isnoneornil(L, _index)) {
++ return obj;
++ }
++ obj_udata_luacheck_internal(L, _index, &(obj), type, 1);
++ return obj;
++}
++
+ static FUNC_UNUSED void *obj_udata_luadelete(lua_State *L, int _index, obj_type *type, int *flags) {
+ void *obj;
+ obj_udata *ud = obj_udata_luacheck_internal(L, _index, &(obj), type, 0);
+@@ -335,6 +866,9 @@ static FUNC_UNUSED void *obj_udata_luadelete(lua_State *L, int _index, obj_type
+ /* null userdata. */
+ ud->obj = NULL;
+ ud->flags = 0;
++ /* clear the metatable in invalidate userdata. */
++ lua_pushnil(L);
++ lua_setmetatable(L, _index);
+ return obj;
+ }
+
+@@ -345,6 +879,17 @@ static FUNC_UNUSED void obj_udata_luapush(lua_State *L, void *obj, obj_type *typ
+ lua_pushnil(L);
+ return;
+ }
++#if LUAJIT_FFI
++ lua_pushlightuserdata(L, type);
++ lua_rawget(L, LUA_REGISTRYINDEX); /* type's metatable. */
++ if(nobj_ffi_support_enabled_hint && lua_isfunction(L, -1)) {
++ /* call special FFI "void *" to FFI object convertion function. */
++ lua_pushlightuserdata(L, obj);
++ lua_pushinteger(L, flags);
++ lua_call(L, 2, 1);
++ return;
++ }
++#endif
+ /* check for type caster. */
+ if(type->dcaster) {
+ (type->dcaster)(&obj, &type);
+@@ -354,8 +899,12 @@ static FUNC_UNUSED void obj_udata_luapush(lua_State *L, void *obj, obj_type *typ
+ ud->obj = obj;
+ ud->flags = flags;
+ /* get obj_type metatable. */
++#if LUAJIT_FFI
++ lua_insert(L, -2); /* move userdata below metatable. */
++#else
+ lua_pushlightuserdata(L, type);
+ lua_rawget(L, LUA_REGISTRYINDEX); /* type's metatable. */
++#endif
+ lua_setmetatable(L, -2);
+ }
+
+@@ -367,6 +916,9 @@ static FUNC_UNUSED void *obj_udata_luadelete_weak(lua_State *L, int _index, obj_
+ /* null userdata. */
+ ud->obj = NULL;
+ ud->flags = 0;
++ /* clear the metatable in invalidate userdata. */
++ lua_pushnil(L);
++ lua_setmetatable(L, _index);
+ /* get objects weak table. */
+ lua_pushlightuserdata(L, obj_udata_weak_ref_key);
+ lua_rawget(L, LUA_REGISTRYINDEX); /* weak ref table. */
+@@ -401,6 +953,18 @@ static FUNC_UNUSED void obj_udata_luapush_weak(lua_State *L, void *obj, obj_type
+ }
+ lua_pop(L, 1); /* pop nil. */
+
++#if LUAJIT_FFI
++ lua_pushlightuserdata(L, type);
++ lua_rawget(L, LUA_REGISTRYINDEX); /* type's metatable. */
++ if(nobj_ffi_support_enabled_hint && lua_isfunction(L, -1)) {
++ lua_remove(L, -2);
++ /* call special FFI "void *" to FFI object convertion function. */
++ lua_pushlightuserdata(L, obj);
++ lua_pushinteger(L, flags);
++ lua_call(L, 2, 1);
++ return;
++ }
++#endif
+ /* create new userdata. */
+ ud = (obj_udata *)lua_newuserdata(L, sizeof(obj_udata));
+
+@@ -408,8 +972,12 @@ static FUNC_UNUSED void obj_udata_luapush_weak(lua_State *L, void *obj, obj_type
+ ud->obj = obj;
+ ud->flags = flags;
+ /* get obj_type metatable. */
++#if LUAJIT_FFI
++ lua_insert(L, -2); /* move userdata below metatable. */
++#else
+ lua_pushlightuserdata(L, type);
+ lua_rawget(L, LUA_REGISTRYINDEX); /* type's metatable. */
++#endif
+ lua_setmetatable(L, -2);
+
+ /* add weak reference to object. */
+@@ -468,9 +1036,53 @@ static FUNC_UNUSED void * obj_simple_udata_luacheck(lua_State *L, int _index, ob
+ if(lua_getmetatable(L, _index)) {
+ lua_pushlightuserdata(L, type);
+ lua_rawget(L, LUA_REGISTRYINDEX); /* type's metatable. */
++recheck_metatable:
+ if(lua_rawequal(L, -1, -2)) {
+ lua_pop(L, 2); /* pop both metatables. */
+ return ud;
++ } else if(lua_isnil(L, -1)) {
++ lua_pop(L, 1); /* pop nil. */
++ if((type->flags & OBJ_TYPE_IMPORT) == 0) {
++ /* can't resolve internal type. */
++ luaL_error(L, "Unknown object type(id=%d, name=%s)", type->id, type->name);
++ }
++ /* try to import external type. */
++ if(obj_import_external_type(L, type)) {
++ /* imported type, re-try metatable check. */
++ goto recheck_metatable;
++ }
++ /* External type not yet available, so the object can't be compatible. */
++ return 0;
++ }
++ }
++ } else if(!lua_isnoneornil(L, _index)) {
++ /* handle cdata. */
++ /* get private table. */
++ lua_pushlightuserdata(L, obj_udata_private_key);
++ lua_rawget(L, LUA_REGISTRYINDEX); /* private table. */
++ /* get cdata type check function from private table. */
++ lua_pushlightuserdata(L, type);
++ lua_rawget(L, -2);
++
++ /* check for function. */
++ if(!lua_isnil(L, -1)) {
++got_check_func:
++ /* pass cdata value to type checking function. */
++ lua_pushvalue(L, _index);
++ lua_call(L, 1, 1);
++ if(!lua_isnil(L, -1)) {
++ /* valid type get pointer from cdata. */
++ lua_pop(L, 2);
++ return (void *)lua_topointer(L, _index);
++ }
++ } else {
++ if(type->flags & OBJ_TYPE_IMPORT) {
++ /* try to import external ffi type. */
++ if(obj_import_external_ffi_type(L, type)) {
++ /* imported type. */
++ goto got_check_func;
++ }
++ /* External type not yet available, so the object can't be compatible. */
+ }
+ }
+ }
+@@ -478,10 +1090,16 @@ static FUNC_UNUSED void * obj_simple_udata_luacheck(lua_State *L, int _index, ob
+ return NULL;
+ }
+
+-static FUNC_UNUSED void * obj_simple_udata_luadelete(lua_State *L, int _index, obj_type *type, int *flags) {
++static FUNC_UNUSED void * obj_simple_udata_luaoptional(lua_State *L, int _index, obj_type *type) {
++ if(lua_isnoneornil(L, _index)) {
++ return NULL;
++ }
++ return obj_simple_udata_luacheck(L, _index, type);
++}
++
++static FUNC_UNUSED void * obj_simple_udata_luadelete(lua_State *L, int _index, obj_type *type) {
+ void *obj;
+ obj = obj_simple_udata_luacheck(L, _index, type);
+- *flags = OBJ_UDATA_FLAG_OWN;
+ /* clear the metatable to invalidate userdata. */
+ lua_pushnil(L);
+ lua_setmetatable(L, _index);
+@@ -490,12 +1108,27 @@ static FUNC_UNUSED void * obj_simple_udata_luadelete(lua_State *L, int _index, o
+
+ static FUNC_UNUSED void *obj_simple_udata_luapush(lua_State *L, void *obj, int size, obj_type *type)
+ {
++ void *ud;
++#if LUAJIT_FFI
++ lua_pushlightuserdata(L, type);
++ lua_rawget(L, LUA_REGISTRYINDEX); /* type's metatable. */
++ if(nobj_ffi_support_enabled_hint && lua_isfunction(L, -1)) {
++ /* call special FFI "void *" to FFI object convertion function. */
++ lua_pushlightuserdata(L, obj);
++ lua_call(L, 1, 1);
++ return obj;
++ }
++#endif
+ /* create new userdata. */
+- void *ud = lua_newuserdata(L, size);
++ ud = lua_newuserdata(L, size);
+ memcpy(ud, obj, size);
+ /* get obj_type metatable. */
++#if LUAJIT_FFI
++ lua_insert(L, -2); /* move userdata below metatable. */
++#else
+ lua_pushlightuserdata(L, type);
+ lua_rawget(L, LUA_REGISTRYINDEX); /* type's metatable. */
++#endif
+ lua_setmetatable(L, -2);
+
+ return ud;
+@@ -504,9 +1137,9 @@ static FUNC_UNUSED void *obj_simple_udata_luapush(lua_State *L, void *obj, int s
+ /* default simple object equal method. */
+ static FUNC_UNUSED int obj_simple_udata_default_equal(lua_State *L) {
+ void *ud1 = obj_simple_udata_toobj(L, 1);
+- size_t len1 = lua_objlen(L, 1);
++ size_t len1 = lua_rawlen(L, 1);
+ void *ud2 = obj_simple_udata_toobj(L, 2);
+- size_t len2 = lua_objlen(L, 2);
++ size_t len2 = lua_rawlen(L, 2);
+
+ if(len1 == len2) {
+ lua_pushboolean(L, (memcmp(ud1, ud2, len1) == 0));
+@@ -544,7 +1177,8 @@ static int obj_constructor_call_wrapper(lua_State *L) {
+ return lua_gettop(L);
+ }
+
+-static void obj_type_register_constants(lua_State *L, const obj_const *constants, int tab_idx) {
++static void obj_type_register_constants(lua_State *L, const obj_const *constants, int tab_idx,
++ int bidirectional) {
+ /* register constants. */
+ while(constants->name != NULL) {
+ lua_pushstring(L, constants->name);
+@@ -562,40 +1196,84 @@ static void obj_type_register_constants(lua_State *L, const obj_const *constants
+ lua_pushnil(L);
+ break;
+ }
++ /* map values back to keys. */
++ if(bidirectional) {
++ /* check if value already exists. */
++ lua_pushvalue(L, -1);
++ lua_rawget(L, tab_idx - 3);
++ if(lua_isnil(L, -1)) {
++ lua_pop(L, 1);
++ /* add value->key mapping. */
++ lua_pushvalue(L, -1);
++ lua_pushvalue(L, -3);
++ lua_rawset(L, tab_idx - 4);
++ } else {
++ /* value already exists. */
++ lua_pop(L, 1);
++ }
++ }
+ lua_rawset(L, tab_idx - 2);
+ constants++;
+ }
+ }
+
+ static void obj_type_register_package(lua_State *L, const reg_sub_module *type_reg) {
+- const luaL_reg *reg_list = type_reg->pub_funcs;
++ const luaL_Reg *reg_list = type_reg->pub_funcs;
+
+ /* create public functions table. */
+ if(reg_list != NULL && reg_list[0].name != NULL) {
+ /* register functions */
+- luaL_register(L, NULL, reg_list);
++ luaL_setfuncs(L, reg_list, 0);
+ }
+
+- obj_type_register_constants(L, type_reg->constants, -1);
++ obj_type_register_constants(L, type_reg->constants, -1, type_reg->bidirectional_consts);
+
+ lua_pop(L, 1); /* drop package table */
+ }
+
++static void obj_type_register_meta(lua_State *L, const reg_sub_module *type_reg) {
++ const luaL_Reg *reg_list;
++
++ /* create public functions table. */
++ reg_list = type_reg->pub_funcs;
++ if(reg_list != NULL && reg_list[0].name != NULL) {
++ /* register functions */
++ luaL_setfuncs(L, reg_list, 0);
++ }
++
++ obj_type_register_constants(L, type_reg->constants, -1, type_reg->bidirectional_consts);
++
++ /* register methods. */
++ luaL_setfuncs(L, type_reg->methods, 0);
++
++ /* create metatable table. */
++ lua_newtable(L);
++ luaL_setfuncs(L, type_reg->metas, 0); /* fill metatable */
++ /* setmetatable on meta-object. */
++ lua_setmetatable(L, -2);
++
++ lua_pop(L, 1); /* drop meta-object */
++}
++
+ static void obj_type_register(lua_State *L, const reg_sub_module *type_reg, int priv_table) {
+- const luaL_reg *reg_list;
++ const luaL_Reg *reg_list;
+ obj_type *type = type_reg->type;
+ const obj_base *base = type_reg->bases;
+
+- if(type_reg->is_package == 1) {
++ if(type_reg->req_type == REG_PACKAGE) {
+ obj_type_register_package(L, type_reg);
+ return;
+ }
++ if(type_reg->req_type == REG_META) {
++ obj_type_register_meta(L, type_reg);
++ return;
++ }
+
+ /* create public functions table. */
+ reg_list = type_reg->pub_funcs;
+ if(reg_list != NULL && reg_list[0].name != NULL) {
+ /* register "constructors" as to object's public API */
+- luaL_register(L, NULL, reg_list); /* fill public API table. */
++ luaL_setfuncs(L, reg_list, 0); /* fill public API table. */
+
+ /* make public API table callable as the default constructor. */
+ lua_newtable(L); /* create metatable */
+@@ -625,7 +1303,7 @@ static void obj_type_register(lua_State *L, const reg_sub_module *type_reg, int
+ #endif
+ }
+
+- luaL_register(L, NULL, type_reg->methods); /* fill methods table. */
++ luaL_setfuncs(L, type_reg->methods, 0); /* fill methods table. */
+
+ luaL_newmetatable(L, type->name); /* create metatable */
+ lua_pushliteral(L, ".name");
+@@ -638,16 +1316,12 @@ static void obj_type_register(lua_State *L, const reg_sub_module *type_reg, int
+ lua_pushvalue(L, -2); /* dup metatable. */
+ lua_rawset(L, LUA_REGISTRYINDEX); /* REGISTRY[type] = metatable */
+
+-#if LUAJIT_FFI
+ /* add metatable to 'priv_table' */
+ lua_pushstring(L, type->name);
+ lua_pushvalue(L, -2); /* dup metatable. */
+ lua_rawset(L, priv_table); /* priv_table["<object_name>"] = metatable */
+-#else
+- (void)priv_table;
+-#endif
+
+- luaL_register(L, NULL, type_reg->metas); /* fill metatable */
++ luaL_setfuncs(L, type_reg->metas, 0); /* fill metatable */
+
+ /* add obj_bases to metatable. */
+ while(base->id >= 0) {
+@@ -656,7 +1330,9 @@ static void obj_type_register(lua_State *L, const reg_sub_module *type_reg, int
+ base++;
+ }
+
+- obj_type_register_constants(L, type_reg->constants, -2);
++ obj_type_register_constants(L, type_reg->constants, -2, type_reg->bidirectional_consts);
++
++ obj_type_register_implements(L, type_reg->implements);
+
+ lua_pushliteral(L, "__index");
+ lua_pushvalue(L, -3); /* dup methods table */
+@@ -676,62 +1352,193 @@ static FUNC_UNUSED int lua_checktype_ref(lua_State *L, int _index, int _type) {
+ return luaL_ref(L, LUA_REGISTRYINDEX);
+ }
+
+-#if LUAJIT_FFI
+-static int nobj_udata_new_ffi(lua_State *L) {
+- size_t size = luaL_checkinteger(L, 1);
+- void *ud;
+- luaL_checktype(L, 2, LUA_TTABLE);
+- lua_settop(L, 2);
+- /* create userdata. */
+- ud = lua_newuserdata(L, size);
+- lua_replace(L, 1);
+- /* set userdata's metatable. */
+- lua_setmetatable(L, 1);
+- return 1;
+-}
++/* use static pointer as key to weak callback_state table. */
++static char obj_callback_state_weak_ref_key[] = "obj_callback_state_weak_ref_key";
+
+-static int nobj_try_loading_ffi(lua_State *L, const char *ffi_mod_name,
+- const char *ffi_init_code, const ffi_export_symbol *ffi_exports, int priv_table)
+-{
+- int err;
++static FUNC_UNUSED void *nobj_get_callback_state(lua_State *L, int owner_idx, int size) {
++ void *cb_state;
+
+- /* export symbols to priv_table. */
+- while(ffi_exports->name != NULL) {
+- lua_pushstring(L, ffi_exports->name);
+- lua_pushlightuserdata(L, ffi_exports->sym);
+- lua_settable(L, priv_table);
+- ffi_exports++;
++ lua_pushlightuserdata(L, obj_callback_state_weak_ref_key); /* key for weak table. */
++ lua_rawget(L, LUA_REGISTRYINDEX); /* check if weak table exists already. */
++ if(lua_isnil(L, -1)) {
++ lua_pop(L, 1); /* pop nil. */
++ /* create weak table for callback_state */
++ lua_newtable(L); /* weak table. */
++ lua_newtable(L); /* metatable for weak table. */
++ lua_pushliteral(L, "__mode");
++ lua_pushliteral(L, "k");
++ lua_rawset(L, -3); /* metatable.__mode = 'k' weak keys. */
++ lua_setmetatable(L, -2); /* add metatable to weak table. */
++ lua_pushlightuserdata(L, obj_callback_state_weak_ref_key); /* key for weak table. */
++ lua_pushvalue(L, -2); /* dup weak table. */
++ lua_rawset(L, LUA_REGISTRYINDEX); /* add weak table to registry. */
+ }
+- err = luaL_loadbuffer(L, ffi_init_code, strlen(ffi_init_code), ffi_mod_name);
+- if(0 == err) {
+- lua_pushvalue(L, -2); /* dup C module's table. */
+- lua_pushvalue(L, priv_table); /* move priv_table to top of stack. */
+- lua_remove(L, priv_table);
+- lua_pushcfunction(L, nobj_udata_new_ffi);
+- err = lua_pcall(L, 3, 0, 0);
++
++ /* check weak table for callback_state. */
++ lua_pushvalue(L, owner_idx); /* dup. owner as lookup key. */
++ lua_rawget(L, -2);
++ if(lua_isnil(L, -1)) {
++ lua_pop(L, 1); /* pop nil. */
++ lua_pushvalue(L, owner_idx); /* dup. owner as lookup key. */
++ /* create new callback state. */
++ cb_state = lua_newuserdata(L, size);
++ lua_rawset(L, -3);
++ lua_pop(L, 1); /* pop <weak table> */
++ } else {
++ /* got existing callback state. */
++ cb_state = lua_touserdata(L, -1);
++ lua_pop(L, 2); /* pop <weak table>, <callback_state> */
+ }
+- if(err) {
+- const char *msg = "<err not a string>";
+- if(lua_isstring(L, -1)) {
+- msg = lua_tostring(L, -1);
+- }
+- printf("Failed to install FFI-based bindings: %s\n", msg);
+- lua_pop(L, 1); /* pop error message. */
++
++ return cb_state;
++}
++
++static FUNC_UNUSED void *nobj_delete_callback_state(lua_State *L, int owner_idx) {
++ void *cb_state = NULL;
++
++ lua_pushlightuserdata(L, obj_callback_state_weak_ref_key); /* key for weak table. */
++ lua_rawget(L, LUA_REGISTRYINDEX); /* check if weak table exists already. */
++ if(lua_isnil(L, -1)) {
++ lua_pop(L, 1); /* pop nil. no weak table, so there is no callback state. */
++ return NULL;
+ }
+- return err;
++ /* get callback state. */
++ lua_pushvalue(L, owner_idx); /* dup. owner */
++ lua_rawget(L, -2);
++ if(lua_isnil(L, -1)) {
++ lua_pop(L, 2); /* pop <weak table>, nil. No callback state for the owner. */
++ } else {
++ cb_state = lua_touserdata(L, -1);
++ lua_pop(L, 1); /* pop <state> */
++ /* remove callback state. */
++ lua_pushvalue(L, owner_idx); /* dup. owner */
++ lua_pushnil(L);
++ lua_rawset(L, -3);
++ lua_pop(L, 1); /* pop <weak table> */
++ }
++
++ return cb_state;
+ }
+-#endif
++
++
++
++
++
++typedef struct MutableBuffer_if {
++ uint8_t * (* const data)(void *this_v);
++ size_t (* const get_size)(void *this_v);
++} MutableBufferIF;
++
++/* a per-module unique pointer for fast lookup of an interface's implementation table. */
++static char obj_interface_MutableBufferIF[] = "MutableBufferIF";
++
++#define MutableBufferIF_VAR(var_name) \
++ MutableBufferIF *var_name ## _if; \
++ void *var_name;
++
++#define MutableBufferIF_LUA_OPTIONAL(L, _index, var_name) \
++ var_name = obj_implement_luaoptional(L, _index, (void **)&(var_name ## _if), \
++ obj_interface_MutableBufferIF)
++
++#define MutableBufferIF_LUA_CHECK(L, _index, var_name) \
++ var_name = obj_implement_luacheck(L, _index, (void **)&(var_name ## _if), \
++ obj_interface_MutableBufferIF)
++
++
++
++
++
++
++typedef struct Buffer_if {
++ const uint8_t * (* const const_data)(void *this_v);
++ size_t (* const get_size)(void *this_v);
++} BufferIF;
++
++/* a per-module unique pointer for fast lookup of an interface's implementation table. */
++static char obj_interface_BufferIF[] = "BufferIF";
++
++#define BufferIF_VAR(var_name) \
++ BufferIF *var_name ## _if; \
++ void *var_name;
++
++#define BufferIF_LUA_OPTIONAL(L, _index, var_name) \
++ var_name = obj_implement_luaoptional(L, _index, (void **)&(var_name ## _if), \
++ obj_interface_BufferIF)
++
++#define BufferIF_LUA_CHECK(L, _index, var_name) \
++ var_name = obj_implement_luacheck(L, _index, (void **)&(var_name ## _if), \
++ obj_interface_BufferIF)
++
++
++
++
++static char *obj_interfaces[] = {
++ obj_interface_MutableBufferIF,
++ obj_interface_BufferIF,
++ NULL,
++};
++
++/**
++ * zmq_msg_t implements Buffer interface
++ */
++/**
++ * Buffer interface method const_data
++ */
++static const uint8_t * zmq_msg_t_Buffer_const_data(void *this_v) {
++ zmq_msg_t * this_p = this_v;
++ return zmq_msg_data(this_p);
++}
++/**
++ * Buffer interface method get_size
++ */
++static size_t zmq_msg_t_Buffer_get_size(void *this_v) {
++ zmq_msg_t * this_p = this_v;
++ return zmq_msg_size(this_p);
++}
++
++static const BufferIF zmq_msg_t_Buffer = {
++ zmq_msg_t_Buffer_const_data,
++ zmq_msg_t_Buffer_get_size
++};
++
++/**
++ * zmq_msg_t implements MutableBuffer interface
++ */
++/**
++ * MutableBuffer interface method data
++ */
++static uint8_t * zmq_msg_t_MutableBuffer_data(void *this_v) {
++ zmq_msg_t * this_p = this_v;
++ return zmq_msg_data(this_p);
++}
++/**
++ * MutableBuffer interface method get_size
++ */
++static size_t zmq_msg_t_MutableBuffer_get_size(void *this_v) {
++ zmq_msg_t * this_p = this_v;
++ return zmq_msg_size(this_p);
++}
++
++static const MutableBufferIF zmq_msg_t_MutableBuffer = {
++ zmq_msg_t_MutableBuffer_data,
++ zmq_msg_t_MutableBuffer_get_size
++};
++
+
+
+ #define obj_type_zmq_msg_t_check(L, _index) \
+ (zmq_msg_t *)obj_simple_udata_luacheck(L, _index, &(obj_type_zmq_msg_t))
+-#define obj_type_zmq_msg_t_delete(L, _index, flags) \
+- (zmq_msg_t *)obj_simple_udata_luadelete(L, _index, &(obj_type_zmq_msg_t), flags)
+-#define obj_type_zmq_msg_t_push(L, obj, flags) \
++#define obj_type_zmq_msg_t_optional(L, _index) \
++ (zmq_msg_t *)obj_simple_udata_luaoptional(L, _index, &(obj_type_zmq_msg_t))
++#define obj_type_zmq_msg_t_delete(L, _index) \
++ (zmq_msg_t *)obj_simple_udata_luadelete(L, _index, &(obj_type_zmq_msg_t))
++#define obj_type_zmq_msg_t_push(L, obj) \
+ obj_simple_udata_luapush(L, obj, sizeof(zmq_msg_t), &(obj_type_zmq_msg_t))
+
+ #define obj_type_ZMQ_Socket_check(L, _index) \
+ obj_udata_luacheck(L, _index, &(obj_type_ZMQ_Socket))
++#define obj_type_ZMQ_Socket_optional(L, _index) \
++ obj_udata_luaoptional(L, _index, &(obj_type_ZMQ_Socket))
+ #define obj_type_ZMQ_Socket_delete(L, _index, flags) \
+ obj_udata_luadelete_weak(L, _index, &(obj_type_ZMQ_Socket), flags)
+ #define obj_type_ZMQ_Socket_push(L, obj, flags) \
+@@ -739,13 +1546,17 @@ static int nobj_try_loading_ffi(lua_State *L, const char *ffi_mod_name,
+
+ #define obj_type_ZMQ_Poller_check(L, _index) \
+ (ZMQ_Poller *)obj_simple_udata_luacheck(L, _index, &(obj_type_ZMQ_Poller))
+-#define obj_type_ZMQ_Poller_delete(L, _index, flags) \
+- (ZMQ_Poller *)obj_simple_udata_luadelete(L, _index, &(obj_type_ZMQ_Poller), flags)
+-#define obj_type_ZMQ_Poller_push(L, obj, flags) \
++#define obj_type_ZMQ_Poller_optional(L, _index) \
++ (ZMQ_Poller *)obj_simple_udata_luaoptional(L, _index, &(obj_type_ZMQ_Poller))
++#define obj_type_ZMQ_Poller_delete(L, _index) \
++ (ZMQ_Poller *)obj_simple_udata_luadelete(L, _index, &(obj_type_ZMQ_Poller))
++#define obj_type_ZMQ_Poller_push(L, obj) \
+ obj_simple_udata_luapush(L, obj, sizeof(ZMQ_Poller), &(obj_type_ZMQ_Poller))
+
+ #define obj_type_ZMQ_Ctx_check(L, _index) \
+ obj_udata_luacheck(L, _index, &(obj_type_ZMQ_Ctx))
++#define obj_type_ZMQ_Ctx_optional(L, _index) \
++ obj_udata_luaoptional(L, _index, &(obj_type_ZMQ_Ctx))
+ #define obj_type_ZMQ_Ctx_delete(L, _index, flags) \
+ obj_udata_luadelete_weak(L, _index, &(obj_type_ZMQ_Ctx), flags)
+ #define obj_type_ZMQ_Ctx_push(L, obj, flags) \
+@@ -753,6 +1564,8 @@ static int nobj_try_loading_ffi(lua_State *L, const char *ffi_mod_name,
+
+ #define obj_type_ZMQ_StopWatch_check(L, _index) \
+ obj_udata_luacheck(L, _index, &(obj_type_ZMQ_StopWatch))
++#define obj_type_ZMQ_StopWatch_optional(L, _index) \
++ obj_udata_luaoptional(L, _index, &(obj_type_ZMQ_StopWatch))
+ #define obj_type_ZMQ_StopWatch_delete(L, _index, flags) \
+ obj_udata_luadelete_weak(L, _index, &(obj_type_ZMQ_StopWatch), flags)
+ #define obj_type_ZMQ_StopWatch_push(L, obj, flags) \
+@@ -761,30 +1574,83 @@ static int nobj_try_loading_ffi(lua_State *L, const char *ffi_mod_name,
+
+
+
+-static const char zmq_ffi_lua_code[] = "local error = error\n"
++static const char *zmq_ffi_lua_code[] = { "local ffi=require\"ffi\"\n"
++"local function ffi_safe_load(name, global)\n"
++" local stat, C = pcall(ffi.load, name, global)\n"
++" if not stat then return nil, C end\n"
++" if global then return ffi.C end\n"
++" return C\n"
++"end\n"
++"local function ffi_load(name, global)\n"
++" return assert(ffi_safe_load(name, global))\n"
++"end\n"
++"\n"
++"local function ffi_string(ptr)\n"
++" if ptr ~= nil then\n"
++" return ffi.string(ptr)\n"
++" end\n"
++" return nil\n"
++"end\n"
++"\n"
++"local function ffi_string_len(ptr, len)\n"
++" if ptr ~= nil then\n"
++" return ffi.string(ptr, len)\n"
++" end\n"
++" return nil\n"
++"end\n"
++"\n"
++"local f_cast = ffi.cast\n"
++"local pcall = pcall\n"
++"local error = error\n"
+ "local type = type\n"
+ "local tonumber = tonumber\n"
+ "local tostring = tostring\n"
++"local sformat = require\"string\".format\n"
+ "local rawset = rawset\n"
+-"\n"
+-"-- try loading luajit's ffi\n"
+-"local stat, ffi=pcall(require,\"ffi\")\n"
+-"if not stat then\n"
+-" return\n"
++"local setmetatable = setmetatable\n"
++"local package = (require\"package\") or {}\n"
++"local p_config = package.config\n"
++"local p_cpath = package.cpath\n"
++"\n"
++"\n"
++"local ffi_load_cmodule\n"
++"\n"
++"-- try to detect luvit.\n"
++"if p_config == nil and p_cpath == nil then\n"
++" ffi_load_cmodule = function(name, global)\n"
++" for path,module in pairs(package.loaded) do\n"
++" if module == name then\n"
++" local C, err = ffi_safe_load(path, global)\n"
++" -- return opened library\n"
++" if C then return C end\n"
++" end\n"
++" end\n"
++" error(\"Failed to find: \" .. name)\n"
++" end\n"
++"else\n"
++" ffi_load_cmodule = function(name, global)\n"
++" local dir_sep = p_config:sub(1,1)\n"
++" local path_sep = p_config:sub(3,3)\n"
++" local path_mark = p_config:sub(5,5)\n"
++" local path_match = \"([^\" .. path_sep .. \"]*)\" .. path_sep\n"
++" -- convert dotted name to directory path.\n"
++" name = name:gsub('%.', dir_sep)\n"
++" -- try each path in search path.\n"
++" for path in p_cpath:gmatch(path_match) do\n"
++" local fname = path:gsub(path_mark, name)\n"
++" local C, err = ffi_safe_load(fname, global)\n"
++" -- return opened library\n"
++" if C then return C end\n"
++" end\n"
++" error(\"Failed to find: \" .. name)\n"
++" end\n"
+ "end\n"
+ "\n"
+-"local _M, _priv, udata_new = ...\n"
+-"\n"
+-"local band = bit.band\n"
+-"local d_getmetatable = debug.getmetatable\n"
+-"local d_setmetatable = debug.setmetatable\n"
++"local _M, _priv, reg_table = ...\n"
++"local REG_OBJECTS_AS_GLOBALS = false\n"
++"local C = ffi.C\n"
+ "\n"
+ "local OBJ_UDATA_FLAG_OWN = 1\n"
+-"local OBJ_UDATA_FLAG_LOOKUP = 2\n"
+-"local OBJ_UDATA_LAST_FLAG = OBJ_UDATA_FLAG_LOOKUP\n"
+-"\n"
+-"local OBJ_TYPE_FLAG_WEAK_REF = 1\n"
+-"local OBJ_TYPE_SIMPLE = 2\n"
+ "\n"
+ "local function ffi_safe_cdef(block_name, cdefs)\n"
+ " local fake_type = \"struct sentinel_\" .. block_name .. \"_ty\"\n"
+@@ -822,151 +1688,94 @@ static const char zmq_ffi_lua_code[] = "local error = error\n"
+ " uint32_t flags; /**< lua_own:1bit */\n"
+ "} obj_udata;\n"
+ "\n"
+-"]])\n"
+-"\n"
+-"-- cache mapping of cdata to userdata\n"
+-"local weak_objects = setmetatable({}, { __mode = \"v\" })\n"
++"int memcmp(const void *s1, const void *s2, size_t n);\n"
+ "\n"
+-"local function obj_udata_luacheck_internal(obj, type_mt, not_delete)\n"
+-" local obj_mt = d_getmetatable(obj)\n"
+-" if obj_mt == type_mt then\n"
+-" -- convert userdata to cdata.\n"
+-" return ffi.cast(\"obj_udata *\", obj)\n"
+-" end\n"
+-" if not_delete then\n"
+-" error(\"(expected `\" .. type_mt['.name'] .. \"`, got \" .. type(obj) .. \")\", 3)\n"
+-" end\n"
+-"end\n"
++"]])\n"
+ "\n"
+-"local function obj_udata_luacheck(obj, type_mt)\n"
+-" local ud = obj_udata_luacheck_internal(obj, type_mt, true)\n"
+-" return ud.obj\n"
+-"end\n"
++"local nobj_callback_states = {}\n"
++"local nobj_weak_objects = setmetatable({}, {__mode = \"v\"})\n"
++"local nobj_obj_flags = {}\n"
+ "\n"
+-"local function obj_udata_to_cdata(objects, ud_obj, c_type, ud_mt)\n"
+-" -- convert userdata to cdata.\n"
+-" local c_obj = ffi.cast(c_type, obj_udata_luacheck(ud_obj, ud_mt))\n"
+-" -- cache converted cdata\n"
+-" rawset(objects, ud_obj, c_obj)\n"
+-" return c_obj\n"
++"local function obj_ptr_to_id(ptr)\n"
++" return tonumber(f_cast('uintptr_t', ptr))\n"
+ "end\n"
+ "\n"
+-"local function obj_udata_luadelete(ud_obj, type_mt)\n"
+-" local ud = obj_udata_luacheck_internal(ud_obj, type_mt, false)\n"
+-" if not ud then return nil, 0 end\n"
+-" local obj, flags = ud.obj, ud.flags\n"
+-" -- null userdata.\n"
+-" ud.obj = nil\n"
+-" ud.flags = 0\n"
+-" -- invalid userdata, by setting the metatable to nil.\n"
+-" d_setmetatable(ud_obj, nil)\n"
+-" return obj, flags\n"
++"local function obj_to_id(ptr)\n"
++" return tonumber(f_cast('uintptr_t', f_cast('void *', ptr)))\n"
+ "end\n"
+ "\n"
+-"local function obj_udata_luapush(obj, type_mt, obj_type, flags)\n"
+-" if obj == nil then return end\n"
+-"\n"
+-" -- apply type's dynamic caster.\n"
+-" if obj_type.dcaster ~= nil then\n"
+-" local obj_ptr = ffi.new(\"void *[1]\", obj)\n"
+-" local type_ptr = ffi.new(\"obj_type *[1]\", obj_type)\n"
+-" obj_type.dcaster(obj_ptr, type_ptr)\n"
+-" obj = obj_ptr[1]\n"
+-" type = type_ptr[1]\n"
++"local function register_default_constructor(_pub, obj_name, constructor)\n"
++" local obj_pub = _pub[obj_name]\n"
++" if type(obj_pub) == 'table' then\n"
++" -- copy table since it might have a locked metatable\n"
++" local new_pub = {}\n"
++" for k,v in pairs(obj_pub) do\n"
++" new_pub[k] = v\n"
++" end\n"
++" setmetatable(new_pub, { __call = function(t,...)\n"
++" return constructor(...)\n"
++" end,\n"
++" __metatable = false,\n"
++" })\n"
++" obj_pub = new_pub\n"
++" else\n"
++" obj_pub = constructor\n"
+ " end\n"
+-"\n"
+-" -- create new userdata\n"
+-" local ud_obj = udata_new(ffi.sizeof\"obj_udata\", type_mt)\n"
+-" local ud = ffi.cast(\"obj_udata *\", ud_obj)\n"
+-" -- init. object\n"
+-" ud.obj = obj\n"
+-" ud.flags = flags\n"
+-"\n"
+-" return ud_obj\n"
+-"end\n"
+-"\n"
+-"local function obj_udata_luadelete_weak(ud_obj, type_mt)\n"
+-" local ud = obj_udata_luacheck_internal(ud_obj, type_mt, false)\n"
+-" if not ud then return nil, 0 end\n"
+-" local obj, flags = ud.obj, ud.flags\n"
+-" -- null userdata.\n"
+-" ud.obj = nil\n"
+-" ud.flags = 0\n"
+-" -- invalid userdata, by setting the metatable to nil.\n"
+-" d_setmetatable(ud_obj, nil)\n"
+-" -- remove object from weak ref. table.\n"
+-" local obj_key = tonumber(ffi.cast('uintptr_t', obj))\n"
+-" weak_objects[obj_key] = nil\n"
+-" return obj, flags\n"
+-"end\n"
+-"\n"
+-"local function obj_udata_luapush_weak(obj, type_mt, obj_type, flags)\n"
+-" if obj == nil then return end\n"
+-"\n"
+-" -- apply type's dynamic caster.\n"
+-" if obj_type.dcaster ~= nil then\n"
+-" local obj_ptr = ffi.new(\"void *[1]\", obj)\n"
+-" local type_ptr = ffi.new(\"obj_type *[1]\", obj_type)\n"
+-" obj_type.dcaster(obj_ptr, type_ptr)\n"
+-" obj = obj_ptr[1]\n"
+-" type = type_ptr[1]\n"
++" _pub[obj_name] = obj_pub\n"
++" _M[obj_name] = obj_pub\n"
++" if REG_OBJECTS_AS_GLOBALS then\n"
++" _G[obj_name] = obj_pub\n"
+ " end\n"
+-"\n"
+-" -- lookup object in weak ref. table.\n"
+-" local obj_key = tonumber(ffi.cast('uintptr_t', obj))\n"
+-" local ud_obj = weak_objects[obj_key]\n"
+-" if ud_obj ~= nil then return ud_obj end\n"
+-"\n"
+-" -- create new userdata\n"
+-" ud_obj = udata_new(ffi.sizeof\"obj_udata\", type_mt)\n"
+-" local ud = ffi.cast(\"obj_udata *\", ud_obj)\n"
+-" -- init. object\n"
+-" ud.obj = obj\n"
+-" ud.flags = flags\n"
+-"\n"
+-" -- cache weak reference to object.\n"
+-" weak_objects[obj_key] = ud_obj\n"
+-"\n"
+-" return ud_obj\n"
+ "end\n"
+ "\n"
+-"local function obj_simple_udata_luacheck(ud_obj, type_mt)\n"
+-" local obj_mt = d_getmetatable(ud_obj)\n"
+-" if obj_mt == type_mt then\n"
+-" -- convert userdata to cdata.\n"
+-" return ffi.cast(\"void *\", ud_obj)\n"
+-" end\n"
+-" error(\"(expected `\" .. type_mt['.name'] .. \"`, got \" .. type(ud_obj) .. \")\", 3)\n"
+-"end\n"
+ "\n"
+-"local function obj_simple_udata_to_cdata(objects, ud_obj, c_type, ud_mt)\n"
+-" -- convert userdata to cdata.\n"
+-" local c_obj = ffi.cast(c_type, obj_simple_udata_luacheck(ud_obj, ud_mt))\n"
+-" -- cache converted cdata\n"
+-" rawset(objects, ud_obj, c_obj)\n"
+-" return c_obj\n"
++"-- detect zmq version\n"
++"local VERSION_2_0 = true\n"
++"local VERSION_2_1 = false\n"
++"local VERSION_2_2 = 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] == 2 then\n"
++" VERSION_2_2 = true\n"
++" VERSION_2_1 = true\n"
++"elseif zver[1] == 2 and zver[2] == 1 then\n"
++" VERSION_2_1 = true\n"
+ "end\n"
+ "\n"
+-"local function obj_simple_udata_luadelete(ud_obj, type_mt)\n"
+-" local c_obj = obj_simple_udata_luacheck(ud_obj, type_mt)\n"
+-" -- invalid userdata, by setting the metatable to nil.\n"
+-" d_setmetatable(ud_obj, nil)\n"
+-" return c_obj, OBJ_UDATA_FLAG_OWN\n"
++"if VERSION_2_0 then\n"
++" ffi.cdef[==[\n"
++"typedef int ZMQ_Error;\n"
++"typedef struct ZMQ_Socket ZMQ_Socket;\n"
++"typedef struct zmq_msg_t zmq_msg_t;\n"
++"\n"
++"ZMQ_Error zmq_sendmsg(ZMQ_Socket *sock, zmq_msg_t *msg, int flags) __asm__(\"zmq_send\");\n"
++"ZMQ_Error zmq_recvmsg(ZMQ_Socket *sock, zmq_msg_t *msg, int flags) __asm__(\"zmq_recv\");\n"
++"]==]\n"
+ "end\n"
+ "\n"
+-"local function obj_simple_udata_luapush(c_obj, size, type_mt)\n"
+-" if c_obj == nil then return end\n"
++"ffi_safe_cdef(\"MutableBufferIF\", [[\n"
++"typedef struct MutableBuffer_if {\n"
++" uint8_t * (* const data)(void *this_v);\n"
++" size_t (* const get_size)(void *this_v);\n"
++"} MutableBufferIF;\n"
++"]])\n"
+ "\n"
+-" -- create new userdata\n"
+-" local ud_obj = udata_new(size, type_mt)\n"
+-" local cdata = ffi.cast(\"void *\", ud_obj)\n"
+-" -- init. object\n"
+-" ffi.copy(cdata, c_obj, size)\n"
++"ffi_safe_cdef(\"BufferIF\", [[\n"
++"typedef struct Buffer_if {\n"
++" const uint8_t * (* const const_data)(void *this_v);\n"
++" size_t (* const get_size)(void *this_v);\n"
++"} BufferIF;\n"
++"]])\n"
+ "\n"
+-" return ud_obj, cdata\n"
+-"end\n"
++"local Cmod = ffi_load_cmodule(\"zmq\", false)\n"
++"local C = Cmod\n"
+ "\n"
+ "ffi.cdef[[\n"
++"typedef int ZMQ_Error;\n"
++"\n"
+ "typedef struct zmq_msg_t zmq_msg_t;\n"
+ "typedef struct ZMQ_Socket ZMQ_Socket;\n"
+ "typedef struct ZMQ_Poller ZMQ_Poller;\n"
+@@ -976,9 +1785,7 @@ static const char zmq_ffi_lua_code[] = "local error = error\n"
+ "]]\n"
+ "\n"
+ "ffi.cdef[[\n"
+-"typedef const char * (*get_zmq_strerror_func)();\n"
+-"\n"
+-"typedef int ZMQ_Error;\n"
++"int zmq_errno (void);\n"
+ "\n"
+ "\n"
+ "struct zmq_msg_t\n"
+@@ -989,39 +1796,134 @@ static const char zmq_ffi_lua_code[] = "local error = error\n"
+ " unsigned char vsm_data [30]; /* that '30' is from 'MAX_VSM_SIZE' */\n"
+ "};\n"
+ "\n"
+-"typedef void (zmq_free_fn) (void *data, void *hint);\n"
+-"\n"
+ "int zmq_msg_init (zmq_msg_t *msg);\n"
+ "int zmq_msg_init_size (zmq_msg_t *msg, size_t size);\n"
+-"int zmq_msg_init_data (zmq_msg_t *msg, void *data, size_t size, zmq_free_fn *ffn, void *hint);\n"
+ "\n"
+ "\n"
+-"ZMQ_Error zmq_msg_close(zmq_msg_t * this1);\n"
++"ZMQ_Error zmq_msg_init(zmq_msg_t *);\n"
+ "\n"
+-"ZMQ_Error zmq_msg_close(zmq_msg_t * this1);\n"
++"ZMQ_Error zmq_msg_init_size(zmq_msg_t *, size_t);\n"
+ "\n"
+-"ZMQ_Error zmq_msg_move(zmq_msg_t * this1, zmq_msg_t * src2);\n"
++"ZMQ_Error zmq_msg_close(zmq_msg_t *);\n"
+ "\n"
+-"ZMQ_Error zmq_msg_copy(zmq_msg_t * this1, zmq_msg_t * src2);\n"
++"ZMQ_Error zmq_msg_move(zmq_msg_t *, zmq_msg_t *);\n"
+ "\n"
+-"void * zmq_msg_data(zmq_msg_t * this1);\n"
++"ZMQ_Error zmq_msg_copy(zmq_msg_t *, zmq_msg_t *);\n"
+ "\n"
+-"size_t zmq_msg_size(zmq_msg_t * this1);\n"
++"void * zmq_msg_data(zmq_msg_t *);\n"
+ "\n"
+-"ZMQ_Error zmq_close(ZMQ_Socket * this1);\n"
++"size_t zmq_msg_size(zmq_msg_t *);\n"
+ "\n"
+-"ZMQ_Error zmq_bind(ZMQ_Socket * this1, const char * addr2);\n"
++"ZMQ_Error zmq_close(ZMQ_Socket *);\n"
+ "\n"
+-"ZMQ_Error zmq_connect(ZMQ_Socket * this1, const char * addr2);\n"
++"ZMQ_Error zmq_bind(ZMQ_Socket *, const char *);\n"
++"\n"
++"ZMQ_Error zmq_connect(ZMQ_Socket *, const char *);\n"
+ "\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 * this1, zmq_msg_t * msg2, int flags3);\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_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"
+-"typedef ZMQ_Error (*simple_zmq_send_func)(ZMQ_Socket *sock, const char *data, size_t data_len, int flags);\n"
++"ZMQ_Error lzmq_socket_type(ZMQ_Socket *, int*);\n"
+ "\n"
+-"ZMQ_Error zmq_recv(ZMQ_Socket * this1, zmq_msg_t * msg2, int flags3);\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_ipv4only(ZMQ_Socket *, int*);\n"
++"\n"
++"ZMQ_Error lzmq_socket_set_ipv4only(ZMQ_Socket *, int);\n"
+ "\n"
+ "typedef int socket_t;\n"
+ "typedef struct zmq_pollitem_t {\n"
+@@ -1031,7 +1933,12 @@ static const char zmq_ffi_lua_code[] = "local error = error\n"
+ " short revents;\n"
+ "} zmq_pollitem_t;\n"
+ "\n"
+-"int zmq_poll(zmq_pollitem_t *items, int nitems, long timeout);\n"
++"int poller_find_sock_item(ZMQ_Poller *poller, ZMQ_Socket *sock);\n"
++"int poller_find_fd_item(ZMQ_Poller *poller, socket_t fd);\n"
++"int poller_get_free_item(ZMQ_Poller *poller);\n"
++"int poller_poll(ZMQ_Poller *poller, long timeout);\n"
++"void poller_remove_item(ZMQ_Poller *poller, int idx);\n"
++"\n"
+ "\n"
+ "struct ZMQ_Poller {\n"
+ " zmq_pollitem_t *items;\n"
+@@ -1041,616 +1948,823 @@ static const char zmq_ffi_lua_code[] = "local error = error\n"
+ " int len;\n"
+ "};\n"
+ "\n"
+-"typedef int (*poller_find_sock_item_func)(ZMQ_Poller *poller, ZMQ_Socket *sock);\n"
++"void poller_init(ZMQ_Poller *, unsigned int);\n"
+ "\n"
+-"typedef int (*poller_find_fd_item_func)(ZMQ_Poller *poller, socket_t fd);\n"
++"void poller_cleanup(ZMQ_Poller *);\n"
+ "\n"
+-"typedef int (*poller_get_free_item_func)(ZMQ_Poller *poller);\n"
++"ZMQ_Error poller_poll(ZMQ_Poller *, long);\n"
+ "\n"
+-"typedef int (*poller_poll_func)(ZMQ_Poller *poller, long timeout);\n"
++"int poller_next_revents(ZMQ_Poller *, int*);\n"
+ "\n"
+-"typedef void (*poller_remove_item_func)(ZMQ_Poller *poller, int idx);\n"
++"ZMQ_Error zmq_term(ZMQ_Ctx *);\n"
+ "\n"
+-"ZMQ_Error zmq_term(ZMQ_Ctx * this1);\n"
+-"\n"
+-"ZMQ_Socket * zmq_socket(ZMQ_Ctx * this1, int type2);\n"
++"ZMQ_Socket * zmq_socket(ZMQ_Ctx *, int);\n"
+ "\n"
+ "ZMQ_StopWatch * zmq_stopwatch_start();\n"
+ "\n"
+-"unsigned long zmq_stopwatch_stop(ZMQ_StopWatch * this1);\n"
+-"\n"
+-"ZMQ_Ctx * zmq_init(int io_threads1);\n"
++"unsigned long zmq_stopwatch_stop(ZMQ_StopWatch *);\n"
+ "\n"
+-"ZMQ_Error zmq_device(int device1, ZMQ_Socket * insock2, ZMQ_Socket * outsock3);\n"
++"ZMQ_Ctx * zmq_init(int);\n"
+ "\n"
+-"ZMQ_StopWatch * zmq_stopwatch_start();\n"
++"ZMQ_Error zmq_device(int, ZMQ_Socket *, ZMQ_Socket *);\n"
+ "\n"
+-"void zmq_sleep(int seconds_1);\n"
++"void zmq_sleep(int);\n"
+ "\n"
+ "\n"
+ "]]\n"
+ "\n"
++"REG_OBJECTS_AS_GLOBALS = false\n"
++"local _obj_interfaces_ffi = {}\n"
+ "local _pub = {}\n"
+ "local _meth = {}\n"
++"local _push = {}\n"
++"local _obj_subs = {}\n"
+ "for obj_name,mt in pairs(_priv) do\n"
+-" if type(mt) == 'table' and mt.__index then\n"
+-" _meth[obj_name] = mt.__index\n"
++" if type(mt) == 'table' then\n"
++" _obj_subs[obj_name] = {}\n"
++" if mt.__index then\n"
++" _meth[obj_name] = mt.__index\n"
++" end\n"
+ " end\n"
+ "end\n"
+-"_pub.zmq = _M\n"
+ "for obj_name,pub in pairs(_M) do\n"
+ " _pub[obj_name] = pub\n"
+ "end\n"
+ "\n"
+-"\n"
+-"local obj_type_zmq_msg_t_check\n"
+-"local obj_type_zmq_msg_t_delete\n"
+-"local obj_type_zmq_msg_t_push\n"
+-"\n"
+-"(function()\n"
+-"local zmq_msg_t_mt = _priv.zmq_msg_t\n"
+-"local zmq_msg_t_objects = setmetatable({}, { __mode = \"k\",\n"
+-"__index = function(objects, ud_obj)\n"
+-" return obj_simple_udata_to_cdata(objects, ud_obj, \"zmq_msg_t *\", zmq_msg_t_mt)\n"
+-"end,\n"
+-"})\n"
+-"function obj_type_zmq_msg_t_check(ud_obj)\n"
+-" return zmq_msg_t_objects[ud_obj]\n"
++"--\n"
++"-- CData Metatable access\n"
++"--\n"
++"local _ctypes = {}\n"
++"local _type_names = {}\n"
++"local _get_mt_key = {}\n"
++"local _ctype_meta_map = {}\n"
++"\n"
++"local f_typeof = ffi.typeof\n"
++"local function get_cdata_type_id(cdata)\n"
++" return tonumber(f_typeof(cdata))\n"
+ "end\n"
+-"\n"
+-"function obj_type_zmq_msg_t_delete(ud_obj)\n"
+-" zmq_msg_t_objects[ud_obj] = nil\n"
+-" return obj_simple_udata_luadelete(ud_obj, zmq_msg_t_mt)\n"
++"local function get_cdata_mt(cdata)\n"
++" return _ctype_meta_map[tonumber(f_typeof(cdata))]\n"
+ "end\n"
+ "\n"
+-"local zmq_msg_t_sizeof = ffi.sizeof\"zmq_msg_t\"\n"
+-"function obj_type_zmq_msg_t_push(c_obj)\n"
+-" local ud_obj, cdata = obj_simple_udata_luapush(c_obj, zmq_msg_t_sizeof, zmq_msg_t_mt)\n"
+-" zmq_msg_t_objects[ud_obj] = cdata\n"
+-" return ud_obj\n"
++"local function obj_register_ctype(name, ctype)\n"
++" local obj_mt = _priv[name]\n"
++" local obj_type = obj_mt['.type']\n"
++" local obj_ctype = ffi.typeof(ctype)\n"
++" local obj_type_id = tonumber(obj_ctype)\n"
++" _ctypes[name] = obj_ctype\n"
++" _type_names[name] = tostring(obj_ctype)\n"
++" _ctype_meta_map[obj_type_id] = obj_mt\n"
++" _ctype_meta_map[obj_mt] = obj_type_id\n"
++" return obj_mt, obj_type, obj_ctype\n"
+ "end\n"
+-"end)()\n"
+-"\n"
+-"\n"
+-"local obj_type_ZMQ_Socket_check\n"
+-"local obj_type_ZMQ_Socket_delete\n"
+-"local obj_type_ZMQ_Socket_push\n"
+ "\n"
+-"(function()\n"
+-"local ZMQ_Socket_mt = _priv.ZMQ_Socket\n"
+-"local ZMQ_Socket_objects = setmetatable({}, { __mode = \"k\",\n"
+-"__index = function(objects, ud_obj)\n"
+-" return obj_udata_to_cdata(objects, ud_obj, \"ZMQ_Socket *\", ZMQ_Socket_mt)\n"
+-"end,\n"
+-"})\n"
+-"function obj_type_ZMQ_Socket_check(ud_obj)\n"
+-" return ZMQ_Socket_objects[ud_obj]\n"
++"--\n"
++"-- Interfaces helper code.\n"
++"--\n"
++"local _obj_interfaces_key = \"obj_interfaces<1.0>_table_key\"\n"
++"local _obj_interfaces_ud = reg_table[_obj_interfaces_key]\n"
++"local _obj_interfaces_key_ffi = _obj_interfaces_key .. \"_LJ2_FFI\"\n"
++"_obj_interfaces_ffi = reg_table[_obj_interfaces_key_ffi]\n"
++"if not _obj_interfaces_ffi then\n"
++" -- create missing interfaces table for FFI bindings.\n"
++" _obj_interfaces_ffi = {}\n"
++" reg_table[_obj_interfaces_key_ffi] = _obj_interfaces_ffi\n"
+ "end\n"
+ "\n"
+-"function obj_type_ZMQ_Socket_delete(ud_obj)\n"
+-" ZMQ_Socket_objects[ud_obj] = nil\n"
+-" return obj_udata_luadelete_weak(ud_obj, ZMQ_Socket_mt)\n"
++"local function obj_get_userdata_interface(if_name, expected_err)\n"
++" local impls_ud = _obj_interfaces_ud[if_name]\n"
++" if not impls_ud then\n"
++" impls_ud = {}\n"
++" _obj_interfaces_ud[if_name] = impls_ud\n"
++" end\n"
++" -- create cdata check function to be used by non-ffi bindings.\n"
++" if not impls_ud.cdata then\n"
++" function impls_ud.cdata(obj)\n"
++" return assert(impls_ud[get_cdata_mt(obj)], expected_err)\n"
++" end\n"
++" end\n"
++" return impls_ud\n"
+ "end\n"
+ "\n"
+-"local ZMQ_Socket_type = ffi.cast(\"obj_type *\", ZMQ_Socket_mt[\".type\"])\n"
+-"function obj_type_ZMQ_Socket_push(c_obj, flags)\n"
+-" local ud_obj = obj_udata_luapush_weak(c_obj, ZMQ_Socket_mt, ZMQ_Socket_type, flags)\n"
+-" ZMQ_Socket_objects[ud_obj] = c_obj\n"
+-" return ud_obj\n"
++"local function obj_get_interface_check(if_name, expected_err)\n"
++" local impls_ffi = _obj_interfaces_ffi[if_name]\n"
++" if not impls_ffi then\n"
++" local if_type = ffi.typeof(if_name .. \" *\")\n"
++" local impls_ud = obj_get_userdata_interface(if_name, expected_err)\n"
++" -- create table for FFI-based interface implementations.\n"
++" impls_ffi = setmetatable({}, {\n"
++" __index = function(impls_ffi, mt)\n"
++" local impl = impls_ud[mt]\n"
++" if impl then\n"
++" -- cast to cdata\n"
++" impl = if_type(impl)\n"
++" rawset(impls_ffi, mt, impl)\n"
++" end\n"
++" return impl\n"
++" end})\n"
++" _obj_interfaces_ffi[if_name] = impls_ffi\n"
++"\n"
++" -- create check function for this interface.\n"
++" function impls_ffi.check(obj)\n"
++" local impl\n"
++" if type(obj) == 'cdata' then\n"
++" impl = impls_ffi[get_cdata_type_id(obj)]\n"
++" else\n"
++" impl = impls_ud.userdata(impls_ffi, obj)\n"
++" end\n"
++" return assert(impl, expected_err)\n"
++" end\n"
++" end\n"
++" return impls_ffi.check\n"
+ "end\n"
+-"end)()\n"
+-"\n"
+-"\n"
+-"local obj_type_ZMQ_Poller_check\n"
+-"local obj_type_ZMQ_Poller_delete\n"
+-"local obj_type_ZMQ_Poller_push\n"
+ "\n"
+-"(function()\n"
+-"local ZMQ_Poller_mt = _priv.ZMQ_Poller\n"
+-"local ZMQ_Poller_objects = setmetatable({}, { __mode = \"k\",\n"
+-"__index = function(objects, ud_obj)\n"
+-" return obj_simple_udata_to_cdata(objects, ud_obj, \"ZMQ_Poller *\", ZMQ_Poller_mt)\n"
+-"end,\n"
+-"})\n"
+-"function obj_type_ZMQ_Poller_check(ud_obj)\n"
+-" return ZMQ_Poller_objects[ud_obj]\n"
++"local function obj_register_interface(if_name, obj_name)\n"
++" -- loopkup cdata id\n"
++" local obj_mt = _priv[obj_name]\n"
++" local obj_type_id = _ctype_meta_map[obj_mt]\n"
++" local impl_meths = {}\n"
++" local ffi_impls = _obj_interfaces_ffi[if_name]\n"
++" ffi_impls[obj_type_id] = impl_meths\n"
++" _meth[obj_name]['NOBJ_get_' .. if_name] = impl_meths\n"
++" return impl_meths\n"
+ "end\n"
+ "\n"
+-"function obj_type_ZMQ_Poller_delete(ud_obj)\n"
+-" ZMQ_Poller_objects[ud_obj] = nil\n"
+-" return obj_simple_udata_luadelete(ud_obj, ZMQ_Poller_mt)\n"
+-"end\n"
+ "\n"
+-"local ZMQ_Poller_sizeof = ffi.sizeof\"ZMQ_Poller\"\n"
+-"function obj_type_ZMQ_Poller_push(c_obj)\n"
+-" local ud_obj, cdata = obj_simple_udata_luapush(c_obj, ZMQ_Poller_sizeof, ZMQ_Poller_mt)\n"
+-" ZMQ_Poller_objects[ud_obj] = cdata\n"
+-" return ud_obj\n"
+-"end\n"
+-"end)()\n"
++"local obj_type_zmq_msg_t_check\n"
++"local obj_type_zmq_msg_t_delete\n"
++"local obj_type_zmq_msg_t_push\n"
+ "\n"
++"do\n"
++" local obj_mt, obj_type, obj_ctype = obj_register_ctype(\"zmq_msg_t\", \"zmq_msg_t\")\n"
++" local zmq_msg_t_sizeof = ffi.sizeof\"zmq_msg_t\"\n"
+ "\n"
+-"local obj_type_ZMQ_Ctx_check\n"
+-"local obj_type_ZMQ_Ctx_delete\n"
+-"local obj_type_ZMQ_Ctx_push\n"
++" function obj_type_zmq_msg_t_check(obj)\n"
++" return obj\n"
++" end\n"
+ "\n"
+-"(function()\n"
+-"local ZMQ_Ctx_mt = _priv.ZMQ_Ctx\n"
+-"local ZMQ_Ctx_objects = setmetatable({}, { __mode = \"k\",\n"
+-"__index = function(objects, ud_obj)\n"
+-" return obj_udata_to_cdata(objects, ud_obj, \"ZMQ_Ctx *\", ZMQ_Ctx_mt)\n"
+-"end,\n"
+-"})\n"
+-"function obj_type_ZMQ_Ctx_check(ud_obj)\n"
+-" return ZMQ_Ctx_objects[ud_obj]\n"
+-"end\n"
++" function obj_type_zmq_msg_t_delete(obj)\n"
++" return obj\n"
++" end\n"
+ "\n"
+-"function obj_type_ZMQ_Ctx_delete(ud_obj)\n"
+-" ZMQ_Ctx_objects[ud_obj] = nil\n"
+-" return obj_udata_luadelete_weak(ud_obj, ZMQ_Ctx_mt)\n"
+-"end\n"
++" function obj_type_zmq_msg_t_push(obj)\n"
++" return obj\n"
++" end\n"
+ "\n"
+-"local ZMQ_Ctx_type = ffi.cast(\"obj_type *\", ZMQ_Ctx_mt[\".type\"])\n"
+-"function obj_type_ZMQ_Ctx_push(c_obj, flags)\n"
+-" local ud_obj = obj_udata_luapush_weak(c_obj, ZMQ_Ctx_mt, ZMQ_Ctx_type, flags)\n"
+-" ZMQ_Ctx_objects[ud_obj] = c_obj\n"
+-" return ud_obj\n"
+-"end\n"
+-"end)()\n"
++" function obj_mt:__tostring()\n"
++" return sformat(\"zmq_msg_t: %p\", self)\n"
++" end\n"
+ "\n"
++" function obj_mt.__eq(val1, val2)\n"
++" if not ffi.istype(obj_type, val2) then return false end\n"
++" assert(ffi.istype(obj_type, val1), \"expected zmq_msg_t\")\n"
++" return (C.memcmp(val1, val2, zmq_msg_t_sizeof) == 0)\n"
++" end\n"
+ "\n"
+-"local obj_type_ZMQ_StopWatch_check\n"
+-"local obj_type_ZMQ_StopWatch_delete\n"
+-"local obj_type_ZMQ_StopWatch_push\n"
++" -- type checking function for C API.\n"
++" local function c_check(obj)\n"
++" if ffi.istype(obj_type, obj) then return obj end\n"
++" return nil\n"
++" end\n"
++" _priv[obj_type] = c_check\n"
++" -- push function for C API.\n"
++" reg_table[obj_type] = function(ptr)\n"
++" local obj = obj_ctype()\n"
++" ffi.copy(obj, ptr, zmq_msg_t_sizeof);\n"
++" return obj\n"
++" end\n"
+ "\n"
+-"(function()\n"
+-"local ZMQ_StopWatch_mt = _priv.ZMQ_StopWatch\n"
+-"local ZMQ_StopWatch_objects = setmetatable({}, { __mode = \"k\",\n"
+-"__index = function(objects, ud_obj)\n"
+-" return obj_udata_to_cdata(objects, ud_obj, \"ZMQ_StopWatch *\", ZMQ_StopWatch_mt)\n"
+-"end,\n"
+-"})\n"
+-"function obj_type_ZMQ_StopWatch_check(ud_obj)\n"
+-" return ZMQ_StopWatch_objects[ud_obj]\n"
++" -- export check functions for use in other modules.\n"
++" obj_mt.c_check = c_check\n"
++" obj_mt.ffi_check = obj_type_zmq_msg_t_check\n"
+ "end\n"
+ "\n"
+-"function obj_type_ZMQ_StopWatch_delete(ud_obj)\n"
+-" ZMQ_StopWatch_objects[ud_obj] = nil\n"
+-" return obj_udata_luadelete_weak(ud_obj, ZMQ_StopWatch_mt)\n"
+-"end\n"
++"\n", /* ----- CUT ----- */
++"local obj_type_ZMQ_Socket_check\n"
++"local obj_type_ZMQ_Socket_delete\n"
++"local obj_type_ZMQ_Socket_push\n"
+ "\n"
+-"local ZMQ_StopWatch_type = ffi.cast(\"obj_type *\", ZMQ_StopWatch_mt[\".type\"])\n"
+-"function obj_type_ZMQ_StopWatch_push(c_obj, flags)\n"
+-" local ud_obj = obj_udata_luapush_weak(c_obj, ZMQ_StopWatch_mt, ZMQ_StopWatch_type, flags)\n"
+-" ZMQ_StopWatch_objects[ud_obj] = c_obj\n"
+-" return ud_obj\n"
+-"end\n"
+-"end)()\n"
++"do\n"
++" local obj_mt, obj_type, obj_ctype = obj_register_ctype(\"ZMQ_Socket\", \"ZMQ_Socket *\")\n"
++"\n"
++" function obj_type_ZMQ_Socket_check(ptr)\n"
++" -- if ptr is nil or is the correct type, then just return it.\n"
++" if not ptr or ffi.istype(obj_ctype, ptr) then return ptr end\n"
++" -- check if it is a compatible type.\n"
++" local ctype = tostring(ffi.typeof(ptr))\n"
++" local bcaster = _obj_subs.ZMQ_Socket[ctype]\n"
++" if bcaster then\n"
++" return bcaster(ptr)\n"
++" end\n"
++" return error(\"Expected 'ZMQ_Socket *'\", 2)\n"
++" end\n"
+ "\n"
++" function obj_type_ZMQ_Socket_delete(ptr)\n"
++" local id = obj_ptr_to_id(ptr)\n"
++" local flags = nobj_obj_flags[id]\n"
++" if not flags then return nil, 0 end\n"
++" ffi.gc(ptr, nil)\n"
++" nobj_obj_flags[id] = nil\n"
++" return ptr, flags\n"
++" end\n"
+ "\n"
+-"local get_zmq_strerror = ffi.new(\"get_zmq_strerror_func\", _priv[\"get_zmq_strerror\"])\n"
++" function obj_type_ZMQ_Socket_push(ptr, flags)\n"
++" local id = obj_ptr_to_id(ptr)\n"
++" -- check weak refs\n"
++" if nobj_obj_flags[id] then return nobj_weak_objects[id] end\n"
+ "\n"
+-"local simple_zmq_send = ffi.new(\"simple_zmq_send_func\", _priv[\"simple_zmq_send\"])\n"
++" if flags ~= 0 then\n"
++" nobj_obj_flags[id] = flags\n"
++" ffi.gc(ptr, obj_mt.__gc)\n"
++" end\n"
++" nobj_weak_objects[id] = ptr\n"
++" return ptr\n"
++" end\n"
+ "\n"
+-"local poller_find_sock_item = ffi.new(\"poller_find_sock_item_func\", _priv[\"poller_find_sock_item\"])\n"
++" function obj_mt:__tostring()\n"
++" return sformat(\"ZMQ_Socket: %p, flags=%d\", self, nobj_obj_flags[obj_ptr_to_id(self)] or 0)\n"
++" end\n"
+ "\n"
+-"local poller_find_fd_item = ffi.new(\"poller_find_fd_item_func\", _priv[\"poller_find_fd_item\"])\n"
++" -- type checking function for C API.\n"
++" _priv[obj_type] = obj_type_ZMQ_Socket_check\n"
++" -- push function for C API.\n"
++" reg_table[obj_type] = function(ptr, flags)\n"
++" return obj_type_ZMQ_Socket_push(ffi.cast(obj_ctype,ptr), flags)\n"
++" end\n"
+ "\n"
+-"local poller_get_free_item = ffi.new(\"poller_get_free_item_func\", _priv[\"poller_get_free_item\"])\n"
++" -- export check functions for use in other modules.\n"
++" obj_mt.c_check = obj_type_ZMQ_Socket_check\n"
++" obj_mt.ffi_check = obj_type_ZMQ_Socket_check\n"
++"end\n"
+ "\n"
+-"local poller_poll = ffi.new(\"poller_poll_func\", _priv[\"poller_poll\"])\n"
+ "\n"
+-"local poller_remove_item = ffi.new(\"poller_remove_item_func\", _priv[\"poller_remove_item\"])\n"
++"local obj_type_ZMQ_Poller_check\n"
++"local obj_type_ZMQ_Poller_delete\n"
++"local obj_type_ZMQ_Poller_push\n"
+ "\n"
+-"local os_lib_table = {\n"
+-" [\"Windows\"] = \"libzmq\",\n"
+-"}\n"
+-"local C = ffi.load(os_lib_table[ffi.os] or \"zmq\")\n"
++"do\n"
++" local obj_mt, obj_type, obj_ctype = obj_register_ctype(\"ZMQ_Poller\", \"ZMQ_Poller\")\n"
++" local ZMQ_Poller_sizeof = ffi.sizeof\"ZMQ_Poller\"\n"
+ "\n"
+-"local C_get_zmq_strerror = get_zmq_strerror\n"
+-"-- make nicer wrapper for exported error function.\n"
+-"local function get_zmq_strerror()\n"
+-" return ffi.string(C_get_zmq_strerror())\n"
+-"end\n"
++" function obj_type_ZMQ_Poller_check(obj)\n"
++" return obj\n"
++" end\n"
+ "\n"
+-"local function error_code__ZMQ_Error__push(err)\n"
+-" local err_str\n"
+-" if(-1 == err) then\n"
+-" err_str = get_zmq_strerror();\n"
++" function obj_type_ZMQ_Poller_delete(obj)\n"
++" return obj\n"
+ " end\n"
+ "\n"
+-" return err_str\n"
++" function obj_type_ZMQ_Poller_push(obj)\n"
++" return obj\n"
++" end\n"
++"\n"
++" function obj_mt:__tostring()\n"
++" return sformat(\"ZMQ_Poller: %p\", self)\n"
++" end\n"
++"\n"
++" function obj_mt.__eq(val1, val2)\n"
++" if not ffi.istype(obj_type, val2) then return false end\n"
++" assert(ffi.istype(obj_type, val1), \"expected ZMQ_Poller\")\n"
++" return (C.memcmp(val1, val2, ZMQ_Poller_sizeof) == 0)\n"
++" end\n"
++"\n"
++" -- type checking function for C API.\n"
++" local function c_check(obj)\n"
++" if ffi.istype(obj_type, obj) then return obj end\n"
++" return nil\n"
++" end\n"
++" _priv[obj_type] = c_check\n"
++" -- push function for C API.\n"
++" reg_table[obj_type] = function(ptr)\n"
++" local obj = obj_ctype()\n"
++" ffi.copy(obj, ptr, ZMQ_Poller_sizeof);\n"
++" return obj\n"
++" end\n"
++"\n"
++" -- export check functions for use in other modules.\n"
++" obj_mt.c_check = c_check\n"
++" obj_mt.ffi_check = obj_type_ZMQ_Poller_check\n"
++"end\n"
++"\n"
++"\n"
++"local obj_type_ZMQ_Ctx_check\n"
++"local obj_type_ZMQ_Ctx_delete\n"
++"local obj_type_ZMQ_Ctx_push\n"
++"\n"
++"do\n"
++" local obj_mt, obj_type, obj_ctype = obj_register_ctype(\"ZMQ_Ctx\", \"ZMQ_Ctx *\")\n"
++"\n"
++" function obj_type_ZMQ_Ctx_check(ptr)\n"
++" -- if ptr is nil or is the correct type, then just return it.\n"
++" if not ptr or ffi.istype(obj_ctype, ptr) then return ptr end\n"
++" -- check if it is a compatible type.\n"
++" local ctype = tostring(ffi.typeof(ptr))\n"
++" local bcaster = _obj_subs.ZMQ_Ctx[ctype]\n"
++" if bcaster then\n"
++" return bcaster(ptr)\n"
++" end\n"
++" return error(\"Expected 'ZMQ_Ctx *'\", 2)\n"
++" end\n"
++"\n"
++" function obj_type_ZMQ_Ctx_delete(ptr)\n"
++" local id = obj_ptr_to_id(ptr)\n"
++" local flags = nobj_obj_flags[id]\n"
++" if not flags then return nil, 0 end\n"
++" ffi.gc(ptr, nil)\n"
++" nobj_obj_flags[id] = nil\n"
++" return ptr, flags\n"
++" end\n"
++"\n"
++" function obj_type_ZMQ_Ctx_push(ptr, flags)\n"
++" local id = obj_ptr_to_id(ptr)\n"
++" -- check weak refs\n"
++" if nobj_obj_flags[id] then return nobj_weak_objects[id] end\n"
++"\n"
++" if flags ~= 0 then\n"
++" nobj_obj_flags[id] = flags\n"
++" ffi.gc(ptr, obj_mt.__gc)\n"
++" end\n"
++" nobj_weak_objects[id] = ptr\n"
++" return ptr\n"
++" end\n"
++"\n"
++" function obj_mt:__tostring()\n"
++" return sformat(\"ZMQ_Ctx: %p, flags=%d\", self, nobj_obj_flags[obj_ptr_to_id(self)] or 0)\n"
++" end\n"
++"\n"
++" -- type checking function for C API.\n"
++" _priv[obj_type] = obj_type_ZMQ_Ctx_check\n"
++" -- push function for C API.\n"
++" reg_table[obj_type] = function(ptr, flags)\n"
++" return obj_type_ZMQ_Ctx_push(ffi.cast(obj_ctype,ptr), flags)\n"
++" end\n"
++"\n"
++" -- export check functions for use in other modules.\n"
++" obj_mt.c_check = obj_type_ZMQ_Ctx_check\n"
++" obj_mt.ffi_check = obj_type_ZMQ_Ctx_check\n"
++"end\n"
++"\n"
++"\n"
++"local obj_type_ZMQ_StopWatch_check\n"
++"local obj_type_ZMQ_StopWatch_delete\n"
++"local obj_type_ZMQ_StopWatch_push\n"
++"\n"
++"do\n"
++" local obj_mt, obj_type, obj_ctype = obj_register_ctype(\"ZMQ_StopWatch\", \"ZMQ_StopWatch *\")\n"
++"\n"
++" function obj_type_ZMQ_StopWatch_check(ptr)\n"
++" -- if ptr is nil or is the correct type, then just return it.\n"
++" if not ptr or ffi.istype(obj_ctype, ptr) then return ptr end\n"
++" -- check if it is a compatible type.\n"
++" local ctype = tostring(ffi.typeof(ptr))\n"
++" local bcaster = _obj_subs.ZMQ_StopWatch[ctype]\n"
++" if bcaster then\n"
++" return bcaster(ptr)\n"
++" end\n"
++" return error(\"Expected 'ZMQ_StopWatch *'\", 2)\n"
++" end\n"
++"\n"
++" function obj_type_ZMQ_StopWatch_delete(ptr)\n"
++" local id = obj_ptr_to_id(ptr)\n"
++" local flags = nobj_obj_flags[id]\n"
++" if not flags then return nil, 0 end\n"
++" ffi.gc(ptr, nil)\n"
++" nobj_obj_flags[id] = nil\n"
++" return ptr, flags\n"
++" end\n"
++"\n"
++" function obj_type_ZMQ_StopWatch_push(ptr, flags)\n"
++" local id = obj_ptr_to_id(ptr)\n"
++" -- check weak refs\n"
++" if nobj_obj_flags[id] then return nobj_weak_objects[id] end\n"
++"\n"
++" if flags ~= 0 then\n"
++" nobj_obj_flags[id] = flags\n"
++" ffi.gc(ptr, obj_mt.__gc)\n"
++" end\n"
++" nobj_weak_objects[id] = ptr\n"
++" return ptr\n"
++" end\n"
++"\n"
++" function obj_mt:__tostring()\n"
++" return sformat(\"ZMQ_StopWatch: %p, flags=%d\", self, nobj_obj_flags[obj_ptr_to_id(self)] or 0)\n"
++" end\n"
++"\n"
++" -- type checking function for C API.\n"
++" _priv[obj_type] = obj_type_ZMQ_StopWatch_check\n"
++" -- push function for C API.\n"
++" reg_table[obj_type] = function(ptr, flags)\n"
++" return obj_type_ZMQ_StopWatch_push(ffi.cast(obj_ctype,ptr), flags)\n"
++" end\n"
++"\n"
++" -- export check functions for use in other modules.\n"
++" obj_mt.c_check = obj_type_ZMQ_StopWatch_check\n"
++" obj_mt.ffi_check = obj_type_ZMQ_StopWatch_check\n"
++"end\n"
++"\n"
++"\n"
++"local obj_type_MutableBuffer_check =\n"
++" obj_get_interface_check(\"MutableBufferIF\", \"Expected object with MutableBuffer interface\")\n"
++"\n"
++"local obj_type_Buffer_check =\n"
++" obj_get_interface_check(\"BufferIF\", \"Expected object with Buffer interface\")\n"
++"\n"
++"local os_lib_table = {\n"
++" [\"Windows\"] = \"libzmq\",\n"
++"}\n"
++"C = ffi_load(os_lib_table[ffi.os] or \"zmq\")\n"
++"\n"
++"\n"
++"-- Start \"ZErrors\" FFI interface\n"
++"-- End \"ZErrors\" FFI interface\n"
++"\n"
++"-- get ZErrors table to map errno to error name.\n"
++"local ZError_names = _M.ZErrors\n"
++"\n"
++"local function get_zmq_strerror()\n"
++" return ZError_names[C.zmq_errno()]\n"
++"end\n"
++"\n"
++"local function error_code__ZMQ_Error__push(err)\n"
++" local err_str\n"
++" if(-1 == err) then\n"
++" err_str = ZError_names[C.zmq_errno()]\n"
++" end\n"
++"\n"
++" return err_str\n"
+ "end\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"
++"\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"
++"\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"
++"\n"
+ "-- method: __gc\n"
+ "function _priv.zmq_msg_t.__gc(self)\n"
+-" local this1,this_flags1 = obj_type_zmq_msg_t_delete(self)\n"
+-" if(band(this_flags1,OBJ_UDATA_FLAG_OWN) == 0) then return end\n"
+-" local rc_zmq_msg_close1\n"
+-" rc_zmq_msg_close1 = C.zmq_msg_close(this1)\n"
++" local self = obj_type_zmq_msg_t_delete(self)\n"
++" if not self then return end\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"
+-" local this1 = obj_type_zmq_msg_t_check(self)\n"
+-" local rc_zmq_msg_close1\n"
+-" rc_zmq_msg_close1 = C.zmq_msg_close(this1)\n"
++" \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"
+-" local this1 = obj_type_zmq_msg_t_check(self)\n"
+-" src2 = obj_type_zmq_msg_t_check(src2)\n"
+-" local rc_zmq_msg_move1\n"
+-" rc_zmq_msg_move1 = C.zmq_msg_move(this1, src2)\n"
++" \n"
++" \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"
+-" local this1 = obj_type_zmq_msg_t_check(self)\n"
+-" src2 = obj_type_zmq_msg_t_check(src2)\n"
+-" local rc_zmq_msg_copy1\n"
+-" rc_zmq_msg_copy1 = C.zmq_msg_copy(this1, src2)\n"
++" \n"
++" \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"
+-" local this1 = obj_type_zmq_msg_t_check(self)\n"
++" \n"
+ " local data_len2 = #data2\n"
+-" local err1\n"
++" local err1 = 0\n"
+ " -- check message data size.\n"
+-" if (C.zmq_msg_size(this1) ~= data_len2) then\n"
++" if (C.zmq_msg_size(self) ~= data_len2) then\n"
+ " -- need to resize message.\n"
+-" C.zmq_msg_close(this1); -- close old message, to free old data.\n"
+-" err1 = C.zmq_msg_init_size(this1, data_len2); -- re-initialize message.\n"
++" C.zmq_msg_close(self); -- close old message, to free old data.\n"
++" err1 = C.zmq_msg_init_size(self, data_len2); -- re-initialize message.\n"
+ " if (0 ~= err1) then\n"
+ " error(\"set_data() failed: \" .. get_zmq_strerror());\n"
+ " end\n"
+ " end\n"
+ " -- copy data into message\n"
+-" ffi.copy(C.zmq_msg_data(this1), data2, data_len2);\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"
+-" local this1 = obj_type_zmq_msg_t_check(self)\n"
++" \n"
+ " local rc_zmq_msg_data1\n"
+-" rc_zmq_msg_data1 = C.zmq_msg_data(this1)\n"
+-" rc_zmq_msg_data1 = rc_zmq_msg_data1\n"
++" rc_zmq_msg_data1 = C.zmq_msg_data(self)\n"
+ " return rc_zmq_msg_data1\n"
+ "end\n"
+ "\n"
+ "-- method: set_size\n"
+ "function _meth.zmq_msg_t.set_size(self, size2)\n"
+-" local this1 = obj_type_zmq_msg_t_check(self)\n"
+ " \n"
+-" local err1\n"
++" \n"
++" local err1 = 0\n"
+ " -- check message data size.\n"
+-" if (C.zmq_msg_size(this1) ~= size2) then\n"
++" if (C.zmq_msg_size(self) ~= size2) then\n"
+ " -- need to resize message.\n"
+-" C.zmq_msg_close(this1); -- close old message, to free old data.\n"
+-" err1 = C.zmq_msg_init_size(this1, size2); -- re-initialize message.\n"
++" C.zmq_msg_close(self); -- close old message, to free old data.\n"
++" err1 = C.zmq_msg_init_size(self, size2); -- re-initialize message.\n"
+ " if (0 ~= err1) then\n"
+ " error(\"set_size() failed: \" .. get_zmq_strerror());\n"
+ " end\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"
+-" local this1 = obj_type_zmq_msg_t_check(self)\n"
+-" local rc_zmq_msg_size1\n"
+-" rc_zmq_msg_size1 = C.zmq_msg_size(this1)\n"
+-" rc_zmq_msg_size1 = rc_zmq_msg_size1\n"
+-" return rc_zmq_msg_size1\n"
++" \n"
++" local size1 = 0\n"
++" size1 = C.zmq_msg_size(self)\n"
++" return tonumber(size1)\n"
+ "end\n"
+ "\n"
+ "-- method: __tostring\n"
+ "function _priv.zmq_msg_t.__tostring(self)\n"
+-" local this1 = obj_type_zmq_msg_t_check(self)\n"
++" \n"
+ " local data_len1 = 0\n"
+ " local data1\n"
+-" data1 = C.zmq_msg_data(this1);\n"
+-" data_len1 = C.zmq_msg_size(this1);\n"
++" data1 = C.zmq_msg_data(self);\n"
++" data_len1 = C.zmq_msg_size(self);\n"
++"\n"
++" return ffi_string_len(data1,data_len1)\n"
++"end\n"
++"\n"
++"-- zmq_msg_t implements Buffer interface\n"
++"do\n"
++" local impl_meths = obj_register_interface(\"BufferIF\", \"zmq_msg_t\")\n"
++"-- Buffer interface method const_data\n"
++"impl_meths.const_data = C.zmq_msg_data\n"
++"-- Buffer interface method get_size\n"
++"impl_meths.get_size = C.zmq_msg_size\n"
++"end\n"
+ "\n"
+-" data1 = ((nil ~= data1) and ffi.string(data1,data_len1))\n"
+-" return data1\n"
++"-- zmq_msg_t implements MutableBuffer interface\n"
++"do\n"
++" local impl_meths = obj_register_interface(\"MutableBufferIF\", \"zmq_msg_t\")\n"
++"-- MutableBuffer interface method data\n"
++"impl_meths.data = C.zmq_msg_data\n"
++"-- MutableBuffer interface method get_size\n"
++"impl_meths.get_size = C.zmq_msg_size\n"
+ "end\n"
+ "\n"
++"_push.zmq_msg_t = obj_type_zmq_msg_t_push\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"
+ "-- method: close\n"
+ "function _meth.ZMQ_Socket.close(self)\n"
+-" local this1,this_flags1 = obj_type_ZMQ_Socket_delete(self)\n"
+-" if(band(this_flags1,OBJ_UDATA_FLAG_OWN) == 0) then return end\n"
+-" local rc_zmq_close1\n"
+-" rc_zmq_close1 = C.zmq_close(this1)\n"
++" local self,this_flags1 = obj_type_ZMQ_Socket_delete(self)\n"
++" if not self then return end\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"
++"_priv.ZMQ_Socket.__gc = _meth.ZMQ_Socket.close\n"
+ "\n"
+ "-- method: bind\n"
+ "function _meth.ZMQ_Socket.bind(self, addr2)\n"
+-" local this1 = obj_type_ZMQ_Socket_check(self)\n"
++" \n"
+ " local addr_len2 = #addr2\n"
+-" local rc_zmq_bind1\n"
+-" rc_zmq_bind1 = C.zmq_bind(this1, addr2)\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"
+-" local this1 = obj_type_ZMQ_Socket_check(self)\n"
++" \n"
+ " local addr_len2 = #addr2\n"
+-" local rc_zmq_connect1\n"
+-" rc_zmq_connect1 = C.zmq_connect(this1, addr2)\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"
+-" 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"
+-"}\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"
++" return nil, error_code__ZMQ_Error__push(rc_zmq_connect1)\n"
+ " end\n"
++" return true\n"
++"end\n"
++"\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['set_' .. opt_name] or methods[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"
++" [27] = 'rcvtimeo',\n"
++" [28] = 'sndtimeo',\n"
++" [22] = 'maxmsgsize',\n"
++" [23] = 'sndhwm',\n"
++" [24] = 'rcvhwm',\n"
++" [25] = 'multicast_hops',\n"
++" [31] = 'ipv4only',\n"
++"}\n"
+ "end\n"
+ "\n"
+ "\n"
+ "-- method: setopt\n"
+ "function _meth.ZMQ_Socket.setopt(self, opt2, val3)\n"
+-" local this1 = obj_type_ZMQ_Socket_check(self)\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"
++" \n"
++" \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(this1, 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"
+ "function _meth.ZMQ_Socket.getopt(self, opt2)\n"
+-" local this1 = obj_type_ZMQ_Socket_check(self)\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", /* ----- CUT ----- */
++" 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(this1, 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"
+-" local this1 = obj_type_ZMQ_Socket_check(self)\n"
+-" local events1\n"
+-" local err2\n"
+-" events_tmp_len[0] = events_tmp_size\n"
+-" err2 = C.zmq_getsockopt(this1, 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"
+-" local this1 = obj_type_ZMQ_Socket_check(self)\n"
+-" msg2 = obj_type_zmq_msg_t_check(msg2)\n"
+-" flags3 = flags3 or 0\n"
+-" local rc_zmq_send1\n"
+-" rc_zmq_send1 = C.zmq_send(this1, msg2, flags3)\n"
++" \n"
++" \n"
++" flags3 = flags3 or 0\n"
++" local rc_zmq_sendmsg1 = 0\n"
++" rc_zmq_sendmsg1 = C.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"
+-" local this1 = obj_type_ZMQ_Socket_check(self)\n"
++" \n"
+ " local data_len2 = #data2\n"
+-" flags3 = flags3 or 0\n"
+-" local err1\n"
+-" err1 = simple_zmq_send(this1, data2, data_len2, flags3);\n"
+-"\n"
++" flags3 = flags3 or 0\n"
++" local rc_simple_zmq_send1 = 0\n"
++" rc_simple_zmq_send1 = Cmod.simple_zmq_send(self, data2, data_len2, flags3)\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"
++" if (-1 == rc_simple_zmq_send1) then\n"
++" return nil, error_code__ZMQ_Error__push(rc_simple_zmq_send1)\n"
+ " end\n"
+-" return err1, err1_err\n"
++" return true\n"
+ "end\n"
+ "\n"
+ "-- method: recv_msg\n"
+ "function _meth.ZMQ_Socket.recv_msg(self, msg2, flags3)\n"
+-" local this1 = obj_type_ZMQ_Socket_check(self)\n"
+-" msg2 = obj_type_zmq_msg_t_check(msg2)\n"
+-" flags3 = flags3 or 0\n"
+-" local rc_zmq_recv1\n"
+-" rc_zmq_recv1 = C.zmq_recv(this1, msg2, flags3)\n"
++" \n"
++" \n"
++" flags3 = flags3 or 0\n"
++" local rc_zmq_recvmsg1 = 0\n"
++" rc_zmq_recvmsg1 = C.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"
+ "function _meth.ZMQ_Socket.recv(self, flags2)\n"
+-" local this1 = obj_type_ZMQ_Socket_check(self)\n"
+-" flags2 = flags2 or 0\n"
++" \n"
++" flags2 = flags2 or 0\n"
+ " local data_len1 = 0\n"
+ " local data1\n"
+-" local err2\n"
++" local err2 = 0\n"
+ " local msg = tmp_msg\n"
+ " -- initialize blank message.\n"
+ " if C.zmq_msg_init(msg) < 0 then\n"
+@@ -1658,1106 +2772,3462 @@ static const char zmq_ffi_lua_code[] = "local error = error\n"
+ " end\n"
+ "\n"
+ " -- receive message\n"
+-" err2 = C.zmq_recv(this1, msg, flags2)\n"
+-" if 0 == err2 then\n"
++" err2 = C.zmq_recvmsg(self, msg, flags2)\n"
++" if err2 >= 0 then\n"
+ " local data = ffi.string(C.zmq_msg_data(msg), C.zmq_msg_size(msg))\n"
+ " -- close message\n"
+ " C.zmq_msg_close(msg)\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 ffi_string_len(data1,data_len1)\n"
+ "end\n"
+ "\n"
+-"-- End \"ZMQ_Socket\" FFI interface\n"
+-"\n"
+-"\n"
+-"-- Start \"ZMQ_Poller\" FFI interface\n"
+-"-- method: poll\n"
+-"function _meth.ZMQ_Poller.poll(self, timeout2)\n"
+-" local this1 = obj_type_ZMQ_Poller_check(self)\n"
++"do\n"
++" local hwm_value_tmp = ffi.new(\"int[1]\")\n"
++"-- method: hwm\n"
++"if (_meth.ZMQ_Socket.hwm) then\n"
++"function _meth.ZMQ_Socket.hwm(self)\n"
+ " \n"
+-" local err1\n"
+-" -- poll for events\n"
+-" err1 = poller_poll(this1, timeout2)\n"
+-" if(err1 > 0) then\n"
+-" this1.next = 0\n"
+-" else\n"
+-" this1.next = -1\n"
+-" end\n"
++" local value1 = hwm_value_tmp\n"
++" local rc_lzmq_socket_hwm2 = 0\n"
++" rc_lzmq_socket_hwm2 = Cmod.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"
++"end\n"
++"end\n"
+ "\n"
++"-- method: set_hwm\n"
++"if (_meth.ZMQ_Socket.set_hwm) then\n"
++"function _meth.ZMQ_Socket.set_hwm(self, value2)\n"
++" \n"
++" \n"
++" local rc_lzmq_socket_set_hwm1 = 0\n"
++" rc_lzmq_socket_set_hwm1 = Cmod.lzmq_socket_set_hwm(self, value2)\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"
+-" end\n"
+-" return err1, err1_err\n"
+-"end\n"
+-"\n"
+-"-- method: next_revents\n"
+-"function _meth.ZMQ_Poller.next_revents(self)\n"
+-" local this1 = obj_type_ZMQ_Poller_check(self)\n"
+-" local sock1\n"
+-" local revents2\n"
+-" local sock\n"
+-" local idx = this1.next\n"
+-" if (idx < 0) then return nil, -1 end\n"
+-" local count = this1.count\n"
+-" -- find next item with pending events.\n"
+-" while (idx < count and this1.items[idx].revents == 0) do\n"
+-" idx = idx + 1\n"
+-" if (idx >= count) then\n"
+-" idx = -1\n"
+-" break\n"
+-" end\n"
+-" end\n"
+-" -- did we find a pending event?\n"
+-" if(idx >= 0) then\n"
+-" -- push the event's sock/fd.\n"
+-" if(this1.items[idx].socket ~= nil) then\n"
+-" sock = obj_type_ZMQ_Socket_push(this1.items[idx].socket, 0)\n"
+-" else\n"
+-" sock = tonumber(this1.items[idx].fd)\n"
+-" end\n"
+-" revents2 = this1.items[idx].revents\n"
+-" -- is this the last event.\n"
+-" idx = idx + 1\n"
+-" if (idx >= count) then\n"
+-" idx = -1\n"
+-" end\n"
+-" this1.next = idx\n"
+-" return sock, revents2\n"
+-" end\n"
+-" this1.next = idx\n"
+-"\n"
+-" revents2 = revents2\n"
+-" return sock1, revents2\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"
+ "end\n"
+ "\n"
+-"-- method: count\n"
+-"function _meth.ZMQ_Poller.count(self)\n"
+-" local this1 = obj_type_ZMQ_Poller_check(self)\n"
+-" local count1\n"
+-" count1 = this1.count;\n"
+-"\n"
+-" count1 = count1\n"
+-" return count1\n"
++"do\n"
++" local swap_value_tmp = ffi.new(\"int[1]\")\n"
++"-- method: swap\n"
++"if (_meth.ZMQ_Socket.swap) 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 = Cmod.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"
+ "end\n"
+ "\n"
+-"-- End \"ZMQ_Poller\" FFI interface\n"
++"-- method: set_swap\n"
++"if (_meth.ZMQ_Socket.set_swap) then\n"
++"function _meth.ZMQ_Socket.set_swap(self, value2)\n"
++" \n"
++" \n"
++" local rc_lzmq_socket_set_swap1 = 0\n"
++" rc_lzmq_socket_set_swap1 = Cmod.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"
++"end\n"
+ "\n"
++"do\n"
++" local affinity_value_tmp = ffi.new(\"uint64_t[1]\")\n"
++"-- method: affinity\n"
++"if (_meth.ZMQ_Socket.affinity) then\n"
++"function _meth.ZMQ_Socket.affinity(self)\n"
++" \n"
++" local value1 = affinity_value_tmp\n"
++" local rc_lzmq_socket_affinity2 = 0\n"
++" rc_lzmq_socket_affinity2 = Cmod.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"
++"end\n"
++"end\n"
+ "\n"
+-"-- Start \"ZMQ_Ctx\" FFI interface\n"
+-"-- method: term\n"
+-"function _meth.ZMQ_Ctx.term(self)\n"
+-" local this1,this_flags1 = obj_type_ZMQ_Ctx_delete(self)\n"
+-" if(band(this_flags1,OBJ_UDATA_FLAG_OWN) == 0) then return end\n"
+-" local rc_zmq_term1\n"
+-" rc_zmq_term1 = C.zmq_term(this1)\n"
++"-- method: set_affinity\n"
++"if (_meth.ZMQ_Socket.set_affinity) then\n"
++"function _meth.ZMQ_Socket.set_affinity(self, value2)\n"
++" \n"
++" \n"
++" local rc_lzmq_socket_set_affinity1 = 0\n"
++" rc_lzmq_socket_set_affinity1 = Cmod.lzmq_socket_set_affinity(self, value2)\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_affinity1) then\n"
++" return nil, error_code__ZMQ_Error__push(rc_lzmq_socket_set_affinity1)\n"
+ " end\n"
+-" return rc_zmq_term1, rc_zmq_term1_err\n"
++" return true\n"
++"end\n"
+ "end\n"
+ "\n"
+-"-- method: socket\n"
+-"function _meth.ZMQ_Ctx.socket(self, type2)\n"
+-" local this1 = obj_type_ZMQ_Ctx_check(self)\n"
++"-- method: identity\n"
++"if (_meth.ZMQ_Socket.identity) then\n"
++"function _meth.ZMQ_Socket.identity(self)\n"
+ " \n"
+-" local rc_zmq_socket_flags1 = OBJ_UDATA_FLAG_OWN\n"
+-" local rc_zmq_socket1\n"
+-" rc_zmq_socket1 = C.zmq_socket(this1, 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_len1 = 0\n"
++" local value1\n"
++" local rc_lzmq_socket_identity2 = 0\n"
++" rc_lzmq_socket_identity2 = Cmod.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 rc_zmq_socket1, rc_zmq_socket1_err\n"
++" return ffi_string_len(value1,value_len1)\n"
++"end\n"
+ "end\n"
+ "\n"
+-"-- End \"ZMQ_Ctx\" FFI interface\n"
++"-- method: set_identity\n"
++"if (_meth.ZMQ_Socket.set_identity) 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 = Cmod.lzmq_socket_set_identity(self, value2, value_len2)\n"
++" -- check for error.\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 true\n"
++"end\n"
++"end\n"
+ "\n"
++"-- method: subscribe\n"
++"if (_meth.ZMQ_Socket.subscribe) then\n"
++"function _meth.ZMQ_Socket.subscribe(self, value2)\n"
++" \n"
++" local value_len2 = #value2\n"
++" local rc_lzmq_socket_subscribe1 = 0\n"
++" rc_lzmq_socket_subscribe1 = Cmod.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 true\n"
++"end\n"
++"end\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 this1\n"
+-" this1 = C.zmq_stopwatch_start()\n"
+-" this1 = obj_type_ZMQ_StopWatch_push(this1, this_flags1)\n"
+-" return this1\n"
++"-- method: unsubscribe\n"
++"if (_meth.ZMQ_Socket.unsubscribe) 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 = Cmod.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"
+ "end\n"
+ "\n"
+-"-- method: stop\n"
+-"function _meth.ZMQ_StopWatch.stop(self)\n"
+-" local this1,this_flags1 = obj_type_ZMQ_StopWatch_delete(self)\n"
+-" if(band(this_flags1,OBJ_UDATA_FLAG_OWN) == 0) then return end\n"
+-" local usecs1\n"
+-" usecs1 = C.zmq_stopwatch_stop(this1)\n"
+-" usecs1 = tonumber(usecs1)\n"
+-" return usecs1\n"
++"do\n"
++" local rate_value_tmp = ffi.new(\"int[1]\")\n"
++"-- method: rate\n"
++"if (_meth.ZMQ_Socket.rate) then\n"
++"function _meth.ZMQ_Socket.rate(self)\n"
++" \n"
++" local value1 = rate_value_tmp\n"
++" local rc_lzmq_socket_rate2 = 0\n"
++" rc_lzmq_socket_rate2 = Cmod.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 value1[0]\n"
++"end\n"
++"end\n"
+ "end\n"
+ "\n"
+-"-- End \"ZMQ_StopWatch\" FFI interface\n"
++"-- method: set_rate\n"
++"if (_meth.ZMQ_Socket.set_rate) 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 = Cmod.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 true\n"
++"end\n"
++"end\n"
+ "\n"
+-"-- method: init\n"
+-"function _pub.zmq.init(io_threads1)\n"
++"do\n"
++" local recovery_ivl_value_tmp = ffi.new(\"int[1]\")\n"
++"-- method: recovery_ivl\n"
++"if (_meth.ZMQ_Socket.recovery_ivl) then\n"
++"function _meth.ZMQ_Socket.recovery_ivl(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 = recovery_ivl_value_tmp\n"
++" local rc_lzmq_socket_recovery_ivl2 = 0\n"
++" rc_lzmq_socket_recovery_ivl2 = Cmod.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 rc_zmq_init1, rc_zmq_init1_err\n"
++" return value1[0]\n"
++"end\n"
++"end\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('void *', ptr1);\n"
+-" elseif p_type == 'cdata' then\n"
+-" ctx1 = ptr1;\n"
+-" else\n"
+-" return error(\"expected lightuserdata/cdata<void *>\");\n"
+-" end\n"
++"-- method: set_recovery_ivl\n"
++"if (_meth.ZMQ_Socket.set_recovery_ivl) then\n"
++"function _meth.ZMQ_Socket.set_recovery_ivl(self, value2)\n"
++" \n"
++" \n"
++" local rc_lzmq_socket_set_recovery_ivl1 = 0\n"
++" rc_lzmq_socket_set_recovery_ivl1 = Cmod.lzmq_socket_set_recovery_ivl(self, value2)\n"
++" -- check for error.\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 true\n"
++"end\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"
++"do\n"
++" local mcast_loop_value_tmp = ffi.new(\"int[1]\")\n"
++"-- method: mcast_loop\n"
++"if (_meth.ZMQ_Socket.mcast_loop) then\n"
++"function _meth.ZMQ_Socket.mcast_loop(self)\n"
++" \n"
++" local value1 = mcast_loop_value_tmp\n"
++" local rc_lzmq_socket_mcast_loop2 = 0\n"
++" rc_lzmq_socket_mcast_loop2 = Cmod.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 ctx1, ctx1_err\n"
++" return value1[0]\n"
++"end\n"
++"end\n"
+ "end\n"
+ "\n"
+-"-- method: device\n"
+-"function _pub.zmq.device(device1, insock2, outsock3)\n"
++"-- method: set_mcast_loop\n"
++"if (_meth.ZMQ_Socket.set_mcast_loop) then\n"
++"function _meth.ZMQ_Socket.set_mcast_loop(self, value2)\n"
+ " \n"
+-" insock2 = obj_type_ZMQ_Socket_check(insock2)\n"
+-" outsock3 = obj_type_ZMQ_Socket_check(outsock3)\n"
+-" local rc_zmq_device1\n"
+-" rc_zmq_device1 = C.zmq_device(device1, insock2, outsock3)\n"
++" \n"
++" local rc_lzmq_socket_set_mcast_loop1 = 0\n"
++" rc_lzmq_socket_set_mcast_loop1 = Cmod.lzmq_socket_set_mcast_loop(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_mcast_loop1) then\n"
++" return nil, error_code__ZMQ_Error__push(rc_lzmq_socket_set_mcast_loop1)\n"
+ " end\n"
+-" return rc_zmq_device1, rc_zmq_device1_err\n"
++" return true\n"
++"end\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"
++"do\n"
++" local sndbuf_value_tmp = ffi.new(\"int[1]\")\n"
++"-- method: sndbuf\n"
++"if (_meth.ZMQ_Socket.sndbuf) 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 = Cmod.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"
+ "end\n"
+ "\n"
+-"-- method: sleep\n"
+-"function _pub.zmq.sleep(seconds_1)\n"
++"-- method: set_sndbuf\n"
++"if (_meth.ZMQ_Socket.set_sndbuf) then\n"
++"function _meth.ZMQ_Socket.set_sndbuf(self, value2)\n"
+ " \n"
+-" C.zmq_sleep(seconds_1)\n"
+-" return \n"
++" \n"
++" local rc_lzmq_socket_set_sndbuf1 = 0\n"
++" rc_lzmq_socket_set_sndbuf1 = Cmod.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"
+ "\n"
+-"";
+-
+-/* 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
++"do\n"
++" local rcvbuf_value_tmp = ffi.new(\"int[1]\")\n"
++"-- method: rcvbuf\n"
++"if (_meth.ZMQ_Socket.rcvbuf) 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 = Cmod.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"
++"end\n"
++"\n"
++"-- method: set_rcvbuf\n"
++"if (_meth.ZMQ_Socket.set_rcvbuf) 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 = Cmod.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"
++"\n"
++"do\n"
++" local rcvmore_value_tmp = ffi.new(\"int[1]\")\n"
++"-- method: rcvmore\n"
++"if (_meth.ZMQ_Socket.rcvmore) 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 = Cmod.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"
++"end\n"
++"\n"
++"do\n"
++" local fd_value_tmp = ffi.new(\"int[1]\")\n"
++"-- method: fd\n"
++"if (_meth.ZMQ_Socket.fd) 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 = Cmod.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"
++"end\n"
++"\n"
++"do\n"
++" local events_value_tmp = ffi.new(\"int[1]\")\n"
++"-- method: events\n"
++"if (_meth.ZMQ_Socket.events) 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 = Cmod.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"
++"end\n"
++"\n"
++"do\n"
++" local type_value_tmp = ffi.new(\"int[1]\")\n"
++"-- method: type\n"
++"if (_meth.ZMQ_Socket.type) 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 = Cmod.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"
++"end\n"
++"\n"
++"do\n"
++" local linger_value_tmp = ffi.new(\"int[1]\")\n"
++"-- method: linger\n"
++"if (_meth.ZMQ_Socket.linger) 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 = Cmod.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"
++"end\n"
++"\n"
++"-- method: set_linger\n"
++"if (_meth.ZMQ_Socket.set_linger) 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 = Cmod.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"
++"\n"
++"do\n"
++" local reconnect_ivl_value_tmp = ffi.new(\"int[1]\")\n"
++"-- method: reconnect_ivl\n"
++"if (_meth.ZMQ_Socket.reconnect_ivl) 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 = Cmod.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"
++"end\n"
++"\n"
++"-- method: set_reconnect_ivl\n"
++"if (_meth.ZMQ_Socket.set_reconnect_ivl) 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 = Cmod.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"
++"\n"
++"do\n"
++" local backlog_value_tmp = ffi.new(\"int[1]\")\n"
++"-- method: backlog\n"
++"if (_meth.ZMQ_Socket.backlog) 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 = Cmod.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"
++"end\n"
++"\n"
++"-- method: set_backlog\n"
++"if (_meth.ZMQ_Socket.set_backlog) then\n"
++"function _meth.ZMQ_Socket.set_backlog(self, value2)\n"
++" \n"
++" \n", /* ----- CUT ----- */
++" local rc_lzmq_socket_set_backlog1 = 0\n"
++" rc_lzmq_socket_set_backlog1 = Cmod.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"
++"\n"
++"do\n"
++" local recovery_ivl_msec_value_tmp = ffi.new(\"int64_t[1]\")\n"
++"-- method: recovery_ivl_msec\n"
++"if (_meth.ZMQ_Socket.recovery_ivl_msec) 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 = Cmod.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"
++"end\n"
++"\n"
++"-- method: set_recovery_ivl_msec\n"
++"if (_meth.ZMQ_Socket.set_recovery_ivl_msec) 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 = Cmod.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"
++"\n"
++"do\n"
++" local reconnect_ivl_max_value_tmp = ffi.new(\"int[1]\")\n"
++"-- method: reconnect_ivl_max\n"
++"if (_meth.ZMQ_Socket.reconnect_ivl_max) 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 = Cmod.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"
++"end\n"
++"\n"
++"-- method: set_reconnect_ivl_max\n"
++"if (_meth.ZMQ_Socket.set_reconnect_ivl_max) 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 = Cmod.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"
++"\n"
++"do\n"
++" local maxmsgsize_value_tmp = ffi.new(\"int64_t[1]\")\n"
++"-- method: maxmsgsize\n"
++"if (_meth.ZMQ_Socket.maxmsgsize) 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 = Cmod.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"
++"end\n"
++"\n"
++"-- method: set_maxmsgsize\n"
++"if (_meth.ZMQ_Socket.set_maxmsgsize) 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 = Cmod.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"
++"\n"
++"do\n"
++" local sndhwm_value_tmp = ffi.new(\"int[1]\")\n"
++"-- method: sndhwm\n"
++"if (_meth.ZMQ_Socket.sndhwm) 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 = Cmod.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"
++"end\n"
++"\n"
++"-- method: set_sndhwm\n"
++"if (_meth.ZMQ_Socket.set_sndhwm) 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 = Cmod.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"
++"\n"
++"do\n"
++" local rcvhwm_value_tmp = ffi.new(\"int[1]\")\n"
++"-- method: rcvhwm\n"
++"if (_meth.ZMQ_Socket.rcvhwm) 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 = Cmod.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"
++"end\n"
++"\n"
++"-- method: set_rcvhwm\n"
++"if (_meth.ZMQ_Socket.set_rcvhwm) 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 = Cmod.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"
++"\n"
++"do\n"
++" local multicast_hops_value_tmp = ffi.new(\"int[1]\")\n"
++"-- method: multicast_hops\n"
++"if (_meth.ZMQ_Socket.multicast_hops) 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 = Cmod.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"
++"end\n"
++"\n"
++"-- method: set_multicast_hops\n"
++"if (_meth.ZMQ_Socket.set_multicast_hops) 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 = Cmod.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"
++"\n"
++"do\n"
++" local rcvtimeo_value_tmp = ffi.new(\"int[1]\")\n"
++"-- method: rcvtimeo\n"
++"if (_meth.ZMQ_Socket.rcvtimeo) 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 = Cmod.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"
++"end\n"
++"\n"
++"-- method: set_rcvtimeo\n"
++"if (_meth.ZMQ_Socket.set_rcvtimeo) 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 = Cmod.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"
++"\n"
++"do\n"
++" local sndtimeo_value_tmp = ffi.new(\"int[1]\")\n"
++"-- method: sndtimeo\n"
++"if (_meth.ZMQ_Socket.sndtimeo) 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 = Cmod.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"
++"end\n"
++"\n"
++"-- method: set_sndtimeo\n"
++"if (_meth.ZMQ_Socket.set_sndtimeo) 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 = Cmod.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"
++"\n"
++"do\n"
++" local ipv4only_value_tmp = ffi.new(\"int[1]\")\n"
++"-- method: ipv4only\n"
++"if (_meth.ZMQ_Socket.ipv4only) then\n"
++"function _meth.ZMQ_Socket.ipv4only(self)\n"
++" \n"
++" local value1 = ipv4only_value_tmp\n"
++" local rc_lzmq_socket_ipv4only2 = 0\n"
++" rc_lzmq_socket_ipv4only2 = Cmod.lzmq_socket_ipv4only(self, value1)\n"
++" if (-1 == rc_lzmq_socket_ipv4only2) then\n"
++" return nil,error_code__ZMQ_Error__push(rc_lzmq_socket_ipv4only2)\n"
++" end\n"
++" return value1[0]\n"
++"end\n"
++"end\n"
++"end\n"
++"\n"
++"-- method: set_ipv4only\n"
++"if (_meth.ZMQ_Socket.set_ipv4only) then\n"
++"function _meth.ZMQ_Socket.set_ipv4only(self, value2)\n"
++" \n"
++" \n"
++" local rc_lzmq_socket_set_ipv4only1 = 0\n"
++" rc_lzmq_socket_set_ipv4only1 = Cmod.lzmq_socket_set_ipv4only(self, value2)\n"
++" -- check for error.\n"
++" if (-1 == rc_lzmq_socket_set_ipv4only1) then\n"
++" return nil, error_code__ZMQ_Error__push(rc_lzmq_socket_set_ipv4only1)\n"
++" end\n"
++" return true\n"
++"end\n"
++"end\n"
++"\n"
++"_push.ZMQ_Socket = obj_type_ZMQ_Socket_push\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 = ffi.new(\"ZMQ_Poller\")\n"
++" Cmod.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"
++"\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"
++" Cmod.poller_cleanup(self)\n"
++" return \n"
++"end\n"
++"_priv.ZMQ_Poller.__gc = _meth.ZMQ_Poller.close\n"
++"\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 = Cmod.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"
++"\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 = Cmod.poller_find_sock_item(self, sock)\n"
++" elseif sock_type == 'number' then\n"
++" fd = sock2\n"
++" -- find fd in items list.\n"
++" idx1 = Cmod.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"
++" Cmod.poller_remove_item(self, idx1)\n"
++" end\n"
++"\n"
++" return idx1\n"
++"end\n"
++"\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 = Cmod.poller_find_sock_item(self, sock)\n"
++" elseif sock_type == 'number' then\n"
++" fd = sock2\n"
++" -- find fd in items list.\n"
++" idx1 = Cmod.poller_find_fd_item(self, fd);\n"
++" else\n"
++" error(\"expected number or ZMQ_Socket\")\n"
++" end\n"
++" if idx1 >= 0 then\n"
++" Cmod.poller_remove_item(self, idx1)\n"
++" end\n"
++"\n"
++" return idx1\n"
++"end\n"
++"\n"
++"-- method: poll\n"
++"function _meth.ZMQ_Poller.poll(self, timeout2)\n"
++" \n"
++" \n"
++" local count1 = 0\n"
++" local err2 = 0\n"
++" err2 = Cmod.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"
++"\n"
++"do\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 = Cmod.poller_next_revents(self, revents2)\n"
++" return idx1, revents2[0]\n"
++"end\n"
++"end\n"
++"\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"
++"\n"
++"_push.ZMQ_Poller = obj_type_ZMQ_Poller_push\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"
++"\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"
++"\n"
++"_push.ZMQ_Ctx = obj_type_ZMQ_Ctx_push\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"
++"\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"
++"\n"
++"_push.ZMQ_StopWatch = obj_type_ZMQ_StopWatch_push\n"
++"ffi.metatype(\"ZMQ_StopWatch\", _priv.ZMQ_StopWatch)\n"
++"-- End \"ZMQ_StopWatch\" FFI interface\n"
++"\n"
++"-- method: init\n"
++"function _M.init(io_threads1)\n"
++" io_threads1 = io_threads1 or 1\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"
++"\n"
++"-- method: init_ctx\n"
++"function _M.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<void *>\");\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"
++"\n"
++"-- method: device\n"
++"if (_M.device) then\n"
++"function _M.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", /* ----- CUT ----- */
++" return nil, error_code__ZMQ_Error__push(rc_zmq_device1)\n"
++" end\n"
++" return true\n"
++"end\n"
++"end\n"
++"\n"
++"-- method: stopwatch_start\n"
++"function _M.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"
++"\n"
++"-- method: sleep\n"
++"function _M.sleep(seconds_1)\n"
++" \n"
++" C.zmq_sleep(seconds_1)\n"
++" return \n"
++"end\n"
++"\n", NULL };
++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 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
+
+-/* 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 <winsock2.h>
++typedef SOCKET socket_t;
++#else
++typedef int socket_t;
++#endif
++
++#if VERSION_2_0
++# 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_2_2
++#define VERSION_2_2_MAX_OPT 28
++ OPT_TYPE_NONE, /* 22 unused */
++ OPT_TYPE_NONE, /* 23 unused */
++ OPT_TYPE_NONE, /* 24 unused */
++ OPT_TYPE_NONE, /* 25 unused */
++ OPT_TYPE_NONE, /* 26 unused */
++ OPT_TYPE_INT, /* 27 ZMQ_RCVTIMEO */
++ OPT_TYPE_INT, /* 28 ZMQ_SNDTIMEO */
++#endif /* #if VERSION_2_2 */
++#if VERSION_3_0
++#define VERSION_3_0_MAX_OPT 31
++ 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_NONE, /* 10 unused */
++ 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_NONE, /* 29 unused */
++ OPT_TYPE_NONE, /* 30 unused */
++ OPT_TYPE_INT, /* 31 ZMQ_IPV4ONLY */
++#endif /* #if VERSION_3_0 */
++#if VERSION_3_0
++# define MAX_OPTS VERSION_3_0_MAX_OPT
++#else
++# if VERSION_2_2
++# define MAX_OPTS VERSION_2_2_MAX_OPT
++# elif 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
++LUA_NOBJ_API 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));
++}
++
++LUA_NOBJ_API 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;
++}
++
++LUA_NOBJ_API 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));
++}
++
++LUA_NOBJ_API 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;
++}
++
++LUA_NOBJ_API ZMQ_Error lzmq_socket_set_affinity(ZMQ_Socket *sock, uint64_t value) {
++ return zmq_setsockopt(sock, ZMQ_AFFINITY, &value, sizeof(value));
++}
++
++LUA_NOBJ_API 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);
++}
++
++LUA_NOBJ_API 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);
++}
++
++LUA_NOBJ_API ZMQ_Error lzmq_socket_identity(ZMQ_Socket *sock, char *value, size_t *len) {
++ return zmq_getsockopt(sock, ZMQ_IDENTITY, value, len);
++}
++
++LUA_NOBJ_API ZMQ_Error lzmq_socket_subscribe(ZMQ_Socket *sock, const char *value, size_t str_len) {
++ return zmq_setsockopt(sock, ZMQ_SUBSCRIBE, value, str_len);
++}
++
++LUA_NOBJ_API ZMQ_Error lzmq_socket_unsubscribe(ZMQ_Socket *sock, const char *value, size_t str_len) {
++ return zmq_setsockopt(sock, ZMQ_UNSUBSCRIBE, value, str_len);
++}
++
++LUA_NOBJ_API 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));
++}
++
++LUA_NOBJ_API 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;
++}
++
++LUA_NOBJ_API 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));
++}
++
++LUA_NOBJ_API 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;
++}
++
++LUA_NOBJ_API 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));
++}
++
++LUA_NOBJ_API 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;
++}
++
++LUA_NOBJ_API 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));
++}
++
++LUA_NOBJ_API 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;
++}
++
++LUA_NOBJ_API 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));
++}
++
++LUA_NOBJ_API 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;
++}
++
++LUA_NOBJ_API 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
++LUA_NOBJ_API 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);
++}
++
++LUA_NOBJ_API 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;
++}
++
++LUA_NOBJ_API 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);
++}
++
++LUA_NOBJ_API ZMQ_Error lzmq_socket_set_linger(ZMQ_Socket *sock, int value) {
++ return zmq_setsockopt(sock, ZMQ_LINGER, &value, sizeof(value));
++}
++
++LUA_NOBJ_API 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);
++}
++
++LUA_NOBJ_API ZMQ_Error lzmq_socket_set_reconnect_ivl(ZMQ_Socket *sock, int value) {
++ return zmq_setsockopt(sock, ZMQ_RECONNECT_IVL, &value, sizeof(value));
++}
++
++LUA_NOBJ_API 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);
++}
++
++LUA_NOBJ_API ZMQ_Error lzmq_socket_set_backlog(ZMQ_Socket *sock, int value) {
++ return zmq_setsockopt(sock, ZMQ_BACKLOG, &value, sizeof(value));
++}
++
++LUA_NOBJ_API 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);
++}
++
++LUA_NOBJ_API 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));
++}
++
++LUA_NOBJ_API 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);
++}
++
++LUA_NOBJ_API ZMQ_Error lzmq_socket_set_reconnect_ivl_max(ZMQ_Socket *sock, int value) {
++ return zmq_setsockopt(sock, ZMQ_RECONNECT_IVL_MAX, &value, sizeof(value));
++}
++
++LUA_NOBJ_API 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_2_2
++LUA_NOBJ_API ZMQ_Error lzmq_socket_set_rcvtimeo(ZMQ_Socket *sock, int value) {
++ return zmq_setsockopt(sock, ZMQ_RCVTIMEO, &value, sizeof(value));
++}
++
++LUA_NOBJ_API 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);
++}
++
++LUA_NOBJ_API ZMQ_Error lzmq_socket_set_sndtimeo(ZMQ_Socket *sock, int value) {
++ return zmq_setsockopt(sock, ZMQ_SNDTIMEO, &value, sizeof(value));
++}
++
++LUA_NOBJ_API 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);
++}
++
++#endif /* #if VERSION_2_2 */
++#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);
++}
++
++LUA_NOBJ_API ZMQ_Error lzmq_socket_set_affinity(ZMQ_Socket *sock, uint64_t value) {
++ return zmq_setsockopt(sock, ZMQ_AFFINITY, &value, sizeof(value));
++}
++
++LUA_NOBJ_API 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);
++}
++
++LUA_NOBJ_API 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);
++}
++
++LUA_NOBJ_API ZMQ_Error lzmq_socket_identity(ZMQ_Socket *sock, char *value, size_t *len) {
++ return zmq_getsockopt(sock, ZMQ_IDENTITY, value, len);
++}
++
++LUA_NOBJ_API ZMQ_Error lzmq_socket_subscribe(ZMQ_Socket *sock, const char *value, size_t str_len) {
++ return zmq_setsockopt(sock, ZMQ_SUBSCRIBE, value, str_len);
++}
++
++LUA_NOBJ_API ZMQ_Error lzmq_socket_unsubscribe(ZMQ_Socket *sock, const char *value, size_t str_len) {
++ return zmq_setsockopt(sock, ZMQ_UNSUBSCRIBE, value, str_len);
++}
++
++LUA_NOBJ_API ZMQ_Error lzmq_socket_set_rate(ZMQ_Socket *sock, int value) {
++ return zmq_setsockopt(sock, ZMQ_RATE, &value, sizeof(value));
++}
++
++LUA_NOBJ_API 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);
++}
++
++LUA_NOBJ_API ZMQ_Error lzmq_socket_set_recovery_ivl(ZMQ_Socket *sock, int value) {
++ return zmq_setsockopt(sock, ZMQ_RECOVERY_IVL, &value, sizeof(value));
++}
++
++LUA_NOBJ_API 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);
++}
++
++LUA_NOBJ_API ZMQ_Error lzmq_socket_set_sndbuf(ZMQ_Socket *sock, int value) {
++ return zmq_setsockopt(sock, ZMQ_SNDBUF, &value, sizeof(value));
++}
++
++LUA_NOBJ_API 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);
++}
++
++LUA_NOBJ_API ZMQ_Error lzmq_socket_set_rcvbuf(ZMQ_Socket *sock, int value) {
++ return zmq_setsockopt(sock, ZMQ_RCVBUF, &value, sizeof(value));
++}
++
++LUA_NOBJ_API 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);
++}
++
++LUA_NOBJ_API 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);
++}
++
++LUA_NOBJ_API 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);
++}
++
++LUA_NOBJ_API 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);
++}
++
++LUA_NOBJ_API 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);
++}
++
++LUA_NOBJ_API ZMQ_Error lzmq_socket_set_linger(ZMQ_Socket *sock, int value) {
++ return zmq_setsockopt(sock, ZMQ_LINGER, &value, sizeof(value));
++}
++
++LUA_NOBJ_API 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);
++}
++
++LUA_NOBJ_API ZMQ_Error lzmq_socket_set_reconnect_ivl(ZMQ_Socket *sock, int value) {
++ return zmq_setsockopt(sock, ZMQ_RECONNECT_IVL, &value, sizeof(value));
++}
++
++LUA_NOBJ_API 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);
++}
++
++LUA_NOBJ_API ZMQ_Error lzmq_socket_set_backlog(ZMQ_Socket *sock, int value) {
++ return zmq_setsockopt(sock, ZMQ_BACKLOG, &value, sizeof(value));
++}
++
++LUA_NOBJ_API 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);
++}
++
++LUA_NOBJ_API ZMQ_Error lzmq_socket_set_reconnect_ivl_max(ZMQ_Socket *sock, int value) {
++ return zmq_setsockopt(sock, ZMQ_RECONNECT_IVL_MAX, &value, sizeof(value));
++}
++
++LUA_NOBJ_API 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);
++}
++
++LUA_NOBJ_API ZMQ_Error lzmq_socket_set_maxmsgsize(ZMQ_Socket *sock, int64_t value) {
++ return zmq_setsockopt(sock, ZMQ_MAXMSGSIZE, &value, sizeof(value));
++}
++
++LUA_NOBJ_API 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);
++}
++
++LUA_NOBJ_API ZMQ_Error lzmq_socket_set_sndhwm(ZMQ_Socket *sock, int value) {
++ return zmq_setsockopt(sock, ZMQ_SNDHWM, &value, sizeof(value));
++}
++
++LUA_NOBJ_API 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);
++}
++
++LUA_NOBJ_API ZMQ_Error lzmq_socket_set_rcvhwm(ZMQ_Socket *sock, int value) {
++ return zmq_setsockopt(sock, ZMQ_RCVHWM, &value, sizeof(value));
++}
++
++LUA_NOBJ_API 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);
++}
++
++LUA_NOBJ_API ZMQ_Error lzmq_socket_set_multicast_hops(ZMQ_Socket *sock, int value) {
++ return zmq_setsockopt(sock, ZMQ_MULTICAST_HOPS, &value, sizeof(value));
++}
++
++LUA_NOBJ_API 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);
++}
++
++LUA_NOBJ_API ZMQ_Error lzmq_socket_set_rcvtimeo(ZMQ_Socket *sock, int value) {
++ return zmq_setsockopt(sock, ZMQ_RCVTIMEO, &value, sizeof(value));
++}
++
++LUA_NOBJ_API 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);
++}
++
++LUA_NOBJ_API ZMQ_Error lzmq_socket_set_sndtimeo(ZMQ_Socket *sock, int value) {
++ return zmq_setsockopt(sock, ZMQ_SNDTIMEO, &value, sizeof(value));
++}
++
++LUA_NOBJ_API 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);
++}
++
++LUA_NOBJ_API ZMQ_Error lzmq_socket_set_ipv4only(ZMQ_Socket *sock, int value) {
++ return zmq_setsockopt(sock, ZMQ_IPV4ONLY, &value, sizeof(value));
++}
++
++LUA_NOBJ_API ZMQ_Error lzmq_socket_ipv4only(ZMQ_Socket *sock, int *value) {
++ size_t val_len = sizeof(int);
++ return zmq_getsockopt(sock, ZMQ_IPV4ONLY, value, &val_len);
++}
++
++#endif /* #if VERSION_3_0 */
++
++LUA_NOBJ_API 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. */
+
+-typedef struct ZMQ_Socket ZMQ_Socket;
++ assert(count <= poller->len);
++ return count;
++}
+
+-#ifdef _WIN32
+-#include <winsock2.h>
+-typedef SOCKET socket_t;
+-#else
+-typedef int socket_t;
+-#endif
++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);
++}
+
+-/* 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
++int poller_next_revents(ZMQ_Poller *poller, int *revents) {
++ zmq_pollitem_t *items;
++ int count;
++ int idx;
++ int next;
+
+-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 */
++ 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;
++}
+
+-#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
++
++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;
++ const char * msg1 = NULL;
++ err2 = luaL_checkinteger(L,2);
++ switch(err2) {
++ case EAGAIN:
++ msg1 = "timeout";
++ break;
++ case EINTR:
++ msg1 = "interrupted";
++ break;
++#if defined(ETERM)
++ case ETERM:
++ msg1 = "closed";
++ break;
+ #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;
++}
+
+-static 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) {
++static void error_code__ZMQ_Error__push(lua_State *L, ZMQ_Error err) {
++ const char *err_str = NULL;
++ int num;
++ if(-1 == err) {
++ /* get ZErrors table. */
++ lua_pushlightuserdata(L, zmq_ZErrors_key);
++ lua_rawget(L, LUA_REGISTRYINDEX);
++ /* convert zmq_errno to string. */
++ num = zmq_errno();
++ lua_pushinteger(L, num);
++ lua_gettable(L, -2);
++ /* remove ZErrors table. */
++ lua_remove(L, -2);
++ if(!lua_isnil(L, -1)) {
++ /* found error. */
++ return;
++ }
++ /* Unknown error. */
++ lua_pop(L, 1);
++ lua_pushfstring(L, "UNKNOWN ERROR(%d)", num);
++ return;
++ }
++
++ if(err_str) {
++ lua_pushstring(L, err_str);
++ } else {
++ lua_pushnil(L);
++ }
++}
++
++/* 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;
++ zmq_msg_t this1_store;
++ zmq_msg_t * this1 = &(this1_store);
++ ZMQ_Error rc_zmq_msg_init_size2 = 0;
++ size1 = luaL_checkinteger(L,1);
++ 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;
++}
++
++/* method: init_data */
++static int zmq_msg_t__init_data__meth(lua_State *L) {
++ size_t data_len1;
++ const char * data1;
++ zmq_msg_t this1_store;
++ zmq_msg_t * this1 = &(this1_store);
++ ZMQ_Error err2 = 0;
++ data1 = luaL_checklstring(L,1,&(data_len1));
++ 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;
++
++ 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;
++ ZMQ_Error rc_zmq_msg_close1 = 0;
++ this1 = obj_type_zmq_msg_t_delete(L,1);
++ 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;
++}
++
++/* method: close */
++static int zmq_msg_t__close__meth(lua_State *L) {
++ zmq_msg_t * this1;
++ ZMQ_Error rc_zmq_msg_close1 = 0;
++ this1 = obj_type_zmq_msg_t_check(L,1);
++ 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;
++}
++
++/* method: move */
++static int zmq_msg_t__move__meth(lua_State *L) {
++ zmq_msg_t * this1;
++ zmq_msg_t * src2;
++ ZMQ_Error rc_zmq_msg_move1 = 0;
++ this1 = obj_type_zmq_msg_t_check(L,1);
++ src2 = obj_type_zmq_msg_t_check(L,2);
++ 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;
++}
++
++/* method: copy */
++static int zmq_msg_t__copy__meth(lua_State *L) {
++ zmq_msg_t * this1;
++ zmq_msg_t * src2;
++ ZMQ_Error rc_zmq_msg_copy1 = 0;
++ this1 = obj_type_zmq_msg_t_check(L,1);
++ src2 = obj_type_zmq_msg_t_check(L,2);
++ 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;
++}
++
++/* method: set_data */
++static int zmq_msg_t__set_data__meth(lua_State *L) {
++ zmq_msg_t * this1;
++ size_t data_len2;
++ const char * data2;
++ ZMQ_Error err1 = 0;
++ this1 = obj_type_zmq_msg_t_check(L,1);
++ data2 = luaL_checklstring(L,2,&(data_len2));
++ /* 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);
++
++ /* 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;
++}
++
++/* method: data */
++static int zmq_msg_t__data__meth(lua_State *L) {
++ zmq_msg_t * this1;
++ void * rc_zmq_msg_data1 = NULL;
++ this1 = obj_type_zmq_msg_t_check(L,1);
++ rc_zmq_msg_data1 = zmq_msg_data(this1);
++ lua_pushlightuserdata(L, rc_zmq_msg_data1);
++ return 1;
++}
++
++/* method: set_size */
++static int zmq_msg_t__set_size__meth(lua_State *L) {
++ zmq_msg_t * this1;
++ size_t size2;
++ ZMQ_Error err1 = 0;
++ this1 = obj_type_zmq_msg_t_check(L,1);
++ size2 = luaL_checkinteger(L,2);
++ /* 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);
++ } else {
++ lua_pushboolean(L, 1);
++ lua_pushnil(L);
++ }
++ return 2;
+ }
+
+-struct ZMQ_Poller {
+- zmq_pollitem_t *items;
+- int next;
+- int count;
+- int free_list;
+- int len;
+-};
++/* method: size */
++static int zmq_msg_t__size__meth(lua_State *L) {
++ zmq_msg_t * this1;
++ size_t size1 = 0;
++ this1 = obj_type_zmq_msg_t_check(L,1);
++ size1 = zmq_msg_size(this1);
++ lua_pushinteger(L, size1);
++ return 1;
++}
+
++/* method: __tostring */
++static int zmq_msg_t____tostring__meth(lua_State *L) {
++ zmq_msg_t * this1;
++ size_t data_len1 = 0;
++ const char * data1 = NULL;
++ this1 = obj_type_zmq_msg_t_check(L,1);
++ data1 = zmq_msg_data(this1);
++ data_len1 = zmq_msg_size(this1);
+
+-typedef struct ZMQ_Poller ZMQ_Poller;
++ if(data1 == NULL) lua_pushnil(L); else lua_pushlstring(L, data1,data_len1);
++ return 1;
++}
+
+-#define FREE_ITEM_EVENTS_TAG ((short)0xFFFF)
++/* method: close */
++static int ZMQ_Socket__close__meth(lua_State *L) {
++ int this_flags1 = 0;
++ ZMQ_Socket * this1;
++ ZMQ_Error rc_zmq_close1 = 0;
++ this1 = obj_type_ZMQ_Socket_delete(L,1,&(this_flags1));
++ 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;
++}
+
+-#define ITEM_TO_INDEX(items, item) (item - (items))
++/* method: bind */
++static int ZMQ_Socket__bind__meth(lua_State *L) {
++ ZMQ_Socket * this1;
++ size_t addr_len2;
++ const char * addr2;
++ ZMQ_Error rc_zmq_bind1 = 0;
++ this1 = obj_type_ZMQ_Socket_check(L,1);
++ addr2 = luaL_checklstring(L,2,&(addr_len2));
++ 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;
++}
+
+-static int poller_resize_items(ZMQ_Poller *poller, int len) {
+- int old_len = poller->len;
++/* method: connect */
++static int ZMQ_Socket__connect__meth(lua_State *L) {
++ ZMQ_Socket * this1;
++ size_t addr_len2;
++ const char * addr2;
++ ZMQ_Error rc_zmq_connect1 = 0;
++ this1 = obj_type_ZMQ_Socket_check(L,1);
++ addr2 = luaL_checklstring(L,2,&(addr_len2));
++ 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;
++}
+
+- /* make sure new length is atleast as large as items count. */
+- len = (poller->count <= len) ? len : poller->count;
++/* method: setopt */
++static int ZMQ_Socket__setopt__meth(lua_State *L) {
++ ZMQ_Socket * this1;
++ uint32_t opt2;
++ ZMQ_Error err1 = 0;
++ this1 = obj_type_ZMQ_Socket_check(L,1);
++ opt2 = luaL_checkinteger(L,2);
++ size_t val_len;
++ const void *val;
+
+- /* if the new length is the same as the old length, then don't try to resize. */
+- if(old_len == len) return len;
++#if defined(VERSION_2_1) || defined(VERSION_3_0)
++ socket_t fd_val;
++#endif
++ int int_val;
++ uint32_t uint32_val;
++ uint64_t uint64_val;
++ int64_t int64_val;
+
+- 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));
++#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;
+ }
+- return len;
+-}
+-
+-static int poller_find_sock_item(ZMQ_Poller *poller, ZMQ_Socket *sock) {
+- zmq_pollitem_t *items;
+- int count;
+- int n;
++#endif
+
+- /* find ZMQ_Socket */
+- items = poller->items;
+- count = poller->count;
+- for(n=0; n < count; n++) {
+- if(items[n].socket == sock) return n;
++ if(opt2 > MAX_OPTS) {
++ return luaL_argerror(L, 2, "Invalid socket option.");
+ }
+- /* not found. */
+- return -1;
+-}
+-
+-static 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;
++ switch(opt_types[opt2]) {
++#if defined(VERSION_2_1) || defined(VERSION_3_0)
++ 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;
+ }
+- /* not found. */
+- return -1;
+-}
++ err1 = zmq_setsockopt(this1, opt2, val, val_len);
++finished:
+
+-static void poller_remove_item(ZMQ_Poller *poller, int idx) {
+- zmq_pollitem_t *items;
+- int free_list;
+- int 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;
++}
+
+- count = poller->count;
+- /* no item to remove. */
+- if(idx >= count || count == 0) return;
++/* method: getopt */
++static int ZMQ_Socket__getopt__meth(lua_State *L) {
++ ZMQ_Socket * this1;
++ uint32_t opt2;
++ ZMQ_Error err2 = 0;
++ this1 = obj_type_ZMQ_Socket_check(L,1);
++ opt2 = luaL_checkinteger(L,2);
++ size_t val_len;
+
+- items = poller->items;
+- free_list = poller->free_list;
++#if defined(VERSION_2_1) || defined(VERSION_3_0)
++ 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];
+
+- /* 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(opt2 > MAX_OPTS) {
++ lua_pushnil(L);
++ lua_pushliteral(L, "Invalid socket option.");
++ return 2;
+ }
+- 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;
+-}
+
+-static 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;
++ switch(opt_types[opt2]) {
++#if defined(VERSION_2_1) || defined(VERSION_3_0)
++ 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;
+ }
+- /* clear slot */
+- memset(curr, 0, sizeof(zmq_pollitem_t));
+- return idx;
++ 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);
+
+- idx = count;
+- poller->count = ++count;
+- /* make room for new item. */
+- if(count >= poller->len) {
+- poller_resize_items(poller, poller->len + 10);
+- }
+- return idx;
++ error_code__ZMQ_Error__push(L, err2);
++ return 2;
+ }
+
+-static int poller_compact_items(ZMQ_Poller *poller) {
+- zmq_pollitem_t *items;
+- int count;
+- int old_count;
+- int next;
++/* method: send_msg */
++static int ZMQ_Socket__send_msg__meth(lua_State *L) {
++ ZMQ_Socket * this1;
++ zmq_msg_t * msg2;
++ int flags3;
++ ZMQ_Error rc_zmq_sendmsg1 = 0;
++ this1 = obj_type_ZMQ_Socket_check(L,1);
++ msg2 = obj_type_zmq_msg_t_check(L,2);
++ flags3 = luaL_optinteger(L,3,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;
++}
+
+- count = poller->count;
+- /* if no free slot, then return. */
+- if(poller->free_list < 0) return count;
+- old_count = count;
++/* method: send */
++static int ZMQ_Socket__send__meth(lua_State *L) {
++ ZMQ_Socket * this1;
++ size_t data_len2;
++ const char * data2;
++ int flags3;
++ ZMQ_Error rc_simple_zmq_send1 = 0;
++ this1 = obj_type_ZMQ_Socket_check(L,1);
++ data2 = luaL_checklstring(L,2,&(data_len2));
++ flags3 = luaL_optinteger(L,3,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;
++}
+
+- items = poller->items;
+- next = 0;
+- /* find first free slot. */
+- while(next < count && items[next].events != FREE_ITEM_EVENTS_TAG) {
+- ++next;
+- }
++/* method: recv_msg */
++static int ZMQ_Socket__recv_msg__meth(lua_State *L) {
++ ZMQ_Socket * this1;
++ zmq_msg_t * msg2;
++ int flags3;
++ ZMQ_Error rc_zmq_recvmsg1 = 0;
++ this1 = obj_type_ZMQ_Socket_check(L,1);
++ msg2 = obj_type_zmq_msg_t_check(L,2);
++ flags3 = luaL_optinteger(L,3,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;
++}
+
+- /* 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;
++/* method: recv */
++static int ZMQ_Socket__recv__meth(lua_State *L) {
++ ZMQ_Socket * this1;
++ int flags2;
++ size_t data_len1 = 0;
++ const char * data1 = NULL;
++ ZMQ_Error err2 = 0;
++ this1 = obj_type_ZMQ_Socket_check(L,1);
++ flags2 = luaL_optinteger(L,2,0);
++ zmq_msg_t msg;
++ /* initialize message */
++ err2 = zmq_msg_init(&msg);
++ if(0 == err2) {
++ /* receive message */
++ err2 = zmq_recvmsg(this1, &msg, flags2);
++ if(err2 >= 0) {
++ data1 = zmq_msg_data(&msg);
++ data_len1 = zmq_msg_size(&msg);
+ }
+- ++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. */
++ 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);
+
+- assert(count <= poller->len);
+- return count;
++ return 2;
+ }
+
+-static int poller_poll(ZMQ_Poller *poller, long timeout) {
+- int count;
+- /* remove free slots from items list. */
+- count = poller_compact_items(poller);
+- /* poll for events. */
+- return zmq_poll(poller->items, count, timeout);
++/* method: hwm */
++#if (VERSION_2_0|VERSION_3_0)
++static int ZMQ_Socket__hwm__meth(lua_State *L) {
++ ZMQ_Socket * this1;
++ int value1 = 0;
++ ZMQ_Error rc_lzmq_socket_hwm2 = 0;
++ this1 = obj_type_ZMQ_Socket_check(L,1);
++ 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
+
++/* method: set_hwm */
++#if (VERSION_2_0|VERSION_3_0)
++static int ZMQ_Socket__set_hwm__meth(lua_State *L) {
++ ZMQ_Socket * this1;
++ int value2;
++ ZMQ_Error rc_lzmq_socket_set_hwm1 = 0;
++ this1 = obj_type_ZMQ_Socket_check(L,1);
++ value2 = luaL_checkinteger(L,2);
++ 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
+
+-typedef struct ZMQ_Ctx ZMQ_Ctx;
++/* method: swap */
++#if (VERSION_2_0)
++static int ZMQ_Socket__swap__meth(lua_State *L) {
++ ZMQ_Socket * this1;
++ int value1 = 0;
++ ZMQ_Error rc_lzmq_socket_swap2 = 0;
++ this1 = obj_type_ZMQ_Socket_check(L,1);
++ 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
+
+-typedef struct ZMQ_StopWatch ZMQ_StopWatch;
++/* method: set_swap */
++#if (VERSION_2_0)
++static int ZMQ_Socket__set_swap__meth(lua_State *L) {
++ ZMQ_Socket * this1;
++ int value2;
++ ZMQ_Error rc_lzmq_socket_set_swap1 = 0;
++ this1 = obj_type_ZMQ_Socket_check(L,1);
++ value2 = luaL_checkinteger(L,2);
++ 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
+
+-/*
+- * 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;
+-#if defined(ETERM)
+- case ETERM:
+- return "closed";
+- break;
++/* method: affinity */
++#if (VERSION_2_0|VERSION_3_0)
++static int ZMQ_Socket__affinity__meth(lua_State *L) {
++ ZMQ_Socket * this1;
++ uint64_t value1 = 0;
++ ZMQ_Error rc_lzmq_socket_affinity2 = 0;
++ this1 = obj_type_ZMQ_Socket_check(L,1);
++ 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
+- default:
+- break;
+- }
+- return zmq_strerror(err);
++
++/* method: set_affinity */
++#if (VERSION_2_0|VERSION_3_0)
++static int ZMQ_Socket__set_affinity__meth(lua_State *L) {
++ ZMQ_Socket * this1;
++ uint64_t value2;
++ ZMQ_Error rc_lzmq_socket_set_affinity1 = 0;
++ this1 = obj_type_ZMQ_Socket_check(L,1);
++ value2 = luaL_checkinteger(L,2);
++ 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);
++ }
++ return 2;
++}
++#endif
++
++/* method: identity */
++#if (VERSION_2_0|VERSION_3_0)
++static int ZMQ_Socket__identity__meth(lua_State *L) {
++ ZMQ_Socket * this1;
++ size_t value_len1 = 0;
++ char * value1 = NULL;
++ ZMQ_Error rc_lzmq_socket_identity2 = 0;
++ this1 = obj_type_ZMQ_Socket_check(L,1);
++ 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
+
++/* method: set_identity */
++#if (VERSION_2_0|VERSION_3_0)
++static int ZMQ_Socket__set_identity__meth(lua_State *L) {
++ ZMQ_Socket * this1;
++ size_t value_len2;
++ const char * value2;
++ ZMQ_Error rc_lzmq_socket_set_identity1 = 0;
++ this1 = obj_type_ZMQ_Socket_check(L,1);
++ value2 = luaL_checklstring(L,2,&(value_len2));
++ 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);
++ }
++ return 2;
++}
++#endif
+
++/* method: subscribe */
++#if (VERSION_2_0|VERSION_3_0)
++static int ZMQ_Socket__subscribe__meth(lua_State *L) {
++ ZMQ_Socket * this1;
++ size_t value_len2;
++ const char * value2;
++ ZMQ_Error rc_lzmq_socket_subscribe1 = 0;
++ this1 = obj_type_ZMQ_Socket_check(L,1);
++ value2 = luaL_checklstring(L,2,&(value_len2));
++ 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
+
++/* method: unsubscribe */
++#if (VERSION_2_0|VERSION_3_0)
++static int ZMQ_Socket__unsubscribe__meth(lua_State *L) {
++ ZMQ_Socket * this1;
++ size_t value_len2;
++ const char * value2;
++ ZMQ_Error rc_lzmq_socket_unsubscribe1 = 0;
++ this1 = obj_type_ZMQ_Socket_check(L,1);
++ value2 = luaL_checklstring(L,2,&(value_len2));
++ 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);
++ }
++ return 2;
++}
++#endif
+
+-static void error_code__ZMQ_Error__push(lua_State *L, ZMQ_Error err) {
+- const char *err_str = NULL;
+- if(-1 == err) {
+- err_str = get_zmq_strerror();
+- }
++/* method: rate */
++#if (VERSION_2_0|VERSION_3_0)
++static int ZMQ_Socket__rate__meth(lua_State *L) {
++ ZMQ_Socket * this1;
++ int value1 = 0;
++ ZMQ_Error rc_lzmq_socket_rate2 = 0;
++ this1 = obj_type_ZMQ_Socket_check(L,1);
++ 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
+
+- if(err_str) {
+- lua_pushstring(L, err_str);
+- } else {
+- lua_pushnil(L);
+- }
++/* method: set_rate */
++#if (VERSION_2_0|VERSION_3_0)
++static int ZMQ_Socket__set_rate__meth(lua_State *L) {
++ ZMQ_Socket * this1;
++ int value2;
++ ZMQ_Error rc_lzmq_socket_set_rate1 = 0;
++ this1 = obj_type_ZMQ_Socket_check(L,1);
++ value2 = luaL_checkinteger(L,2);
++ rc_lzmq_socket_set_rate1 = lzmq_socket_set_rate(this1, value2);
++ /* check for error. */
++ if((-1 == rc_lzmq_socket_set_rate1)) {
++ lua_pushnil(L);
++ error_code__ZMQ_Error__push(L, rc_lzmq_socket_set_rate1);
++ } else {
++ lua_pushboolean(L, 1);
++ lua_pushnil(L);
++ }
++ return 2;
+ }
++#endif
+
+-/* method: init */
+-static int zmq_msg_t__init__meth(lua_State *L) {
+- int this_flags1 = OBJ_UDATA_FLAG_OWN;
+- zmq_msg_t * this1;
+- ZMQ_Error err2 = 0;
+- zmq_msg_t tmp;
+- this1 = &tmp;
+- err2 = zmq_msg_init(this1);
++/* method: recovery_ivl */
++#if (VERSION_2_0|VERSION_3_0)
++static int ZMQ_Socket__recovery_ivl__meth(lua_State *L) {
++ ZMQ_Socket * this1;
++ int value1 = 0;
++ ZMQ_Error rc_lzmq_socket_recovery_ivl2 = 0;
++ this1 = obj_type_ZMQ_Socket_check(L,1);
++ 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
+
+- if(!(-1 == err2)) {
+- obj_type_zmq_msg_t_push(L, this1, this_flags1);
++/* 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;
++ int value2;
++ ZMQ_Error rc_lzmq_socket_set_recovery_ivl1 = 0;
++ this1 = obj_type_ZMQ_Socket_check(L,1);
++ value2 = luaL_checkinteger(L,2);
++ rc_lzmq_socket_set_recovery_ivl1 = lzmq_socket_set_recovery_ivl(this1, value2);
++ /* check for error. */
++ if((-1 == rc_lzmq_socket_set_recovery_ivl1)) {
++ lua_pushnil(L);
++ error_code__ZMQ_Error__push(L, rc_lzmq_socket_set_recovery_ivl1);
+ } 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);
+- int this_flags1 = OBJ_UDATA_FLAG_OWN;
+- zmq_msg_t * this1;
+- ZMQ_Error err2 = 0;
+- zmq_msg_t tmp;
+- this1 = &tmp;
+- err2 = zmq_msg_init_size(this1, size1);
+-
+- if(!(-1 == err2)) {
+- obj_type_zmq_msg_t_push(L, this1, this_flags1);
++/* method: mcast_loop */
++#if (VERSION_2_0)
++static int ZMQ_Socket__mcast_loop__meth(lua_State *L) {
++ ZMQ_Socket * this1;
++ int value1 = 0;
++ ZMQ_Error rc_lzmq_socket_mcast_loop2 = 0;
++ this1 = obj_type_ZMQ_Socket_check(L,1);
++ 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, err2);
++ error_code__ZMQ_Error__push(L, rc_lzmq_socket_mcast_loop2);
+ 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));
+- int this_flags1 = OBJ_UDATA_FLAG_OWN;
+- 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: set_mcast_loop */
++#if (VERSION_2_0)
++static int ZMQ_Socket__set_mcast_loop__meth(lua_State *L) {
++ ZMQ_Socket * this1;
++ int value2;
++ ZMQ_Error rc_lzmq_socket_set_mcast_loop1 = 0;
++ this1 = obj_type_ZMQ_Socket_check(L,1);
++ value2 = luaL_checkinteger(L,2);
++ rc_lzmq_socket_set_mcast_loop1 = lzmq_socket_set_mcast_loop(this1, value2);
++ /* check for error. */
++ if((-1 == rc_lzmq_socket_set_mcast_loop1)) {
++ lua_pushnil(L);
++ error_code__ZMQ_Error__push(L, rc_lzmq_socket_set_mcast_loop1);
++ } else {
++ lua_pushboolean(L, 1);
++ lua_pushnil(L);
++ }
++ return 2;
++}
++#endif
+
+- if(!(-1 == err2)) {
+- obj_type_zmq_msg_t_push(L, this1, this_flags1);
++/* method: sndbuf */
++#if (VERSION_2_0|VERSION_3_0)
++static int ZMQ_Socket__sndbuf__meth(lua_State *L) {
++ ZMQ_Socket * this1;
++ int value1 = 0;
++ ZMQ_Error rc_lzmq_socket_sndbuf2 = 0;
++ this1 = obj_type_ZMQ_Socket_check(L,1);
++ 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, err2);
++ error_code__ZMQ_Error__push(L, rc_lzmq_socket_sndbuf2);
+ return 2;
+ }
++#endif
+
+-/* method: delete */
+-static int zmq_msg_t__delete__meth(lua_State *L) {
+- int this_flags1 = 0;
+- zmq_msg_t * this1 = obj_type_zmq_msg_t_delete(L,1,&(this_flags1));
+- ZMQ_Error rc_zmq_msg_close1 = 0;
+- if(!(this_flags1 & OBJ_UDATA_FLAG_OWN)) { return 0; }
+- rc_zmq_msg_close1 = zmq_msg_close(this1);
++/* method: set_sndbuf */
++#if (VERSION_2_0|VERSION_3_0)
++static int ZMQ_Socket__set_sndbuf__meth(lua_State *L) {
++ ZMQ_Socket * this1;
++ int value2;
++ ZMQ_Error rc_lzmq_socket_set_sndbuf1 = 0;
++ this1 = obj_type_ZMQ_Socket_check(L,1);
++ value2 = luaL_checkinteger(L,2);
++ rc_lzmq_socket_set_sndbuf1 = lzmq_socket_set_sndbuf(this1, value2);
+ /* check for error. */
+- if((-1 == rc_zmq_msg_close1)) {
++ if((-1 == rc_lzmq_socket_set_sndbuf1)) {
+ lua_pushnil(L);
+- error_code__ZMQ_Error__push(L, rc_zmq_msg_close1);
++ error_code__ZMQ_Error__push(L, rc_lzmq_socket_set_sndbuf1);
+ } else {
+ lua_pushboolean(L, 1);
+ lua_pushnil(L);
+ }
+ 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: rcvbuf */
++#if (VERSION_2_0|VERSION_3_0)
++static int ZMQ_Socket__rcvbuf__meth(lua_State *L) {
++ ZMQ_Socket * this1;
++ int value1 = 0;
++ ZMQ_Error rc_lzmq_socket_rcvbuf2 = 0;
++ this1 = obj_type_ZMQ_Socket_check(L,1);
++ 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;
++ int value2;
++ ZMQ_Error rc_lzmq_socket_set_rcvbuf1 = 0;
++ this1 = obj_type_ZMQ_Socket_check(L,1);
++ value2 = luaL_checkinteger(L,2);
++ rc_lzmq_socket_set_rcvbuf1 = lzmq_socket_set_rcvbuf(this1, value2);
+ /* check for error. */
+- if((-1 == rc_zmq_msg_close1)) {
++ if((-1 == rc_lzmq_socket_set_rcvbuf1)) {
+ lua_pushnil(L);
+- error_code__ZMQ_Error__push(L, rc_zmq_msg_close1);
++ error_code__ZMQ_Error__push(L, rc_lzmq_socket_set_rcvbuf1);
+ } 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);
+- /* check for error. */
+- if((-1 == rc_zmq_msg_move1)) {
++/* method: rcvmore */
++#if (VERSION_2_0|VERSION_3_0)
++static int ZMQ_Socket__rcvmore__meth(lua_State *L) {
++ ZMQ_Socket * this1;
++ int value1 = 0;
++ ZMQ_Error rc_lzmq_socket_rcvmore2 = 0;
++ this1 = obj_type_ZMQ_Socket_check(L,1);
++ 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_zmq_msg_move1);
++ }
++ error_code__ZMQ_Error__push(L, rc_lzmq_socket_rcvmore2);
++ return 2;
++}
++#endif
++
++/* method: fd */
++#if (VERSION_2_1|VERSION_3_0)
++static int ZMQ_Socket__fd__meth(lua_State *L) {
++ ZMQ_Socket * this1;
++ int value1 = 0;
++ ZMQ_Error rc_lzmq_socket_fd2 = 0;
++ this1 = obj_type_ZMQ_Socket_check(L,1);
++ 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: 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)) {
++/* method: events */
++#if (VERSION_2_1|VERSION_3_0)
++static int ZMQ_Socket__events__meth(lua_State *L) {
++ ZMQ_Socket * this1;
++ int value1 = 0;
++ ZMQ_Error rc_lzmq_socket_events2 = 0;
++ this1 = obj_type_ZMQ_Socket_check(L,1);
++ 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_zmq_msg_copy1);
++ }
++ error_code__ZMQ_Error__push(L, rc_lzmq_socket_events2);
++ return 2;
++}
++#endif
++
++/* method: type */
++#if (VERSION_2_1|VERSION_3_0)
++static int ZMQ_Socket__type__meth(lua_State *L) {
++ ZMQ_Socket * this1;
++ int value1 = 0;
++ ZMQ_Error rc_lzmq_socket_type2 = 0;
++ this1 = obj_type_ZMQ_Socket_check(L,1);
++ rc_lzmq_socket_type2 = lzmq_socket_type(this1, &(value1));
++ if(!(-1 == rc_lzmq_socket_type2)) {
++ lua_pushinteger(L, value1);
+ } else {
+- lua_pushboolean(L, 1);
+ lua_pushnil(L);
+ }
++ error_code__ZMQ_Error__push(L, rc_lzmq_socket_type2);
+ 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: linger */
++#if (VERSION_2_1|VERSION_3_0)
++static int ZMQ_Socket__linger__meth(lua_State *L) {
++ ZMQ_Socket * this1;
++ int value1 = 0;
++ ZMQ_Error rc_lzmq_socket_linger2 = 0;
++ this1 = obj_type_ZMQ_Socket_check(L,1);
++ 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: set_linger */
++#if (VERSION_2_1|VERSION_3_0)
++static int ZMQ_Socket__set_linger__meth(lua_State *L) {
++ ZMQ_Socket * this1;
++ int value2;
++ ZMQ_Error rc_lzmq_socket_set_linger1 = 0;
++ this1 = obj_type_ZMQ_Socket_check(L,1);
++ value2 = luaL_checkinteger(L,2);
++ rc_lzmq_socket_set_linger1 = lzmq_socket_set_linger(this1, value2);
+ /* check for error. */
+- if((-1 == err1)) {
++ if((-1 == rc_lzmq_socket_set_linger1)) {
+ lua_pushnil(L);
+- error_code__ZMQ_Error__push(L, err1);
++ error_code__ZMQ_Error__push(L, rc_lzmq_socket_set_linger1);
+ } 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: reconnect_ivl */
++#if (VERSION_2_1|VERSION_3_0)
++static int ZMQ_Socket__reconnect_ivl__meth(lua_State *L) {
++ ZMQ_Socket * this1;
++ int value1 = 0;
++ ZMQ_Error rc_lzmq_socket_reconnect_ivl2 = 0;
++ this1 = obj_type_ZMQ_Socket_check(L,1);
++ rc_lzmq_socket_reconnect_ivl2 = lzmq_socket_reconnect_ivl(this1, &(value1));
++ if(!(-1 == rc_lzmq_socket_reconnect_ivl2)) {
++ lua_pushinteger(L, value1);
++ } else {
++ lua_pushnil(L);
++ }
++ error_code__ZMQ_Error__push(L, rc_lzmq_socket_reconnect_ivl2);
++ 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());
+- }
+- }
+-
++/* 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;
++ int value2;
++ ZMQ_Error rc_lzmq_socket_set_reconnect_ivl1 = 0;
++ this1 = obj_type_ZMQ_Socket_check(L,1);
++ value2 = luaL_checkinteger(L,2);
++ rc_lzmq_socket_set_reconnect_ivl1 = lzmq_socket_set_reconnect_ivl(this1, value2);
+ /* check for error. */
+- if((-1 == err1)) {
++ if((-1 == rc_lzmq_socket_set_reconnect_ivl1)) {
+ lua_pushnil(L);
+- error_code__ZMQ_Error__push(L, err1);
++ error_code__ZMQ_Error__push(L, rc_lzmq_socket_set_reconnect_ivl1);
+ } else {
+ lua_pushboolean(L, 1);
+ lua_pushnil(L);
+ }
+ 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: __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);
+-
+- if(data1 == NULL) lua_pushnil(L); else lua_pushlstring(L, data1,data_len1);
+- return 1;
++/* method: backlog */
++#if (VERSION_2_1|VERSION_3_0)
++static int ZMQ_Socket__backlog__meth(lua_State *L) {
++ ZMQ_Socket * this1;
++ int value1 = 0;
++ ZMQ_Error rc_lzmq_socket_backlog2 = 0;
++ this1 = obj_type_ZMQ_Socket_check(L,1);
++ 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
+
+-/* 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_backlog */
++#if (VERSION_2_1|VERSION_3_0)
++static int ZMQ_Socket__set_backlog__meth(lua_State *L) {
++ ZMQ_Socket * this1;
++ int value2;
++ ZMQ_Error rc_lzmq_socket_set_backlog1 = 0;
++ this1 = obj_type_ZMQ_Socket_check(L,1);
++ value2 = luaL_checkinteger(L,2);
++ rc_lzmq_socket_set_backlog1 = lzmq_socket_set_backlog(this1, value2);
+ /* check for error. */
+- if((-1 == rc_zmq_close1)) {
++ if((-1 == rc_lzmq_socket_set_backlog1)) {
+ lua_pushnil(L);
+- error_code__ZMQ_Error__push(L, rc_zmq_close1);
++ error_code__ZMQ_Error__push(L, rc_lzmq_socket_set_backlog1);
+ } else {
+ lua_pushboolean(L, 1);
+ lua_pushnil(L);
+ }
+ return 2;
+ }
++#endif
+
+-/* 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);
++/* method: recovery_ivl_msec */
++#if (VERSION_2_1)
++static int ZMQ_Socket__recovery_ivl_msec__meth(lua_State *L) {
++ ZMQ_Socket * this1;
++ int64_t value1 = 0;
++ ZMQ_Error rc_lzmq_socket_recovery_ivl_msec2 = 0;
++ this1 = obj_type_ZMQ_Socket_check(L,1);
++ 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
++
++/* method: set_recovery_ivl_msec */
++#if (VERSION_2_1)
++static int ZMQ_Socket__set_recovery_ivl_msec__meth(lua_State *L) {
++ ZMQ_Socket * this1;
++ int64_t value2;
++ ZMQ_Error rc_lzmq_socket_set_recovery_ivl_msec1 = 0;
++ this1 = obj_type_ZMQ_Socket_check(L,1);
++ value2 = luaL_checkinteger(L,2);
++ rc_lzmq_socket_set_recovery_ivl_msec1 = lzmq_socket_set_recovery_ivl_msec(this1, value2);
+ /* check for error. */
+- if((-1 == rc_zmq_bind1)) {
++ if((-1 == rc_lzmq_socket_set_recovery_ivl_msec1)) {
+ lua_pushnil(L);
+- error_code__ZMQ_Error__push(L, rc_zmq_bind1);
++ error_code__ZMQ_Error__push(L, rc_lzmq_socket_set_recovery_ivl_msec1);
+ } else {
+ lua_pushboolean(L, 1);
+ lua_pushnil(L);
+ }
+ return 2;
+ }
++#endif
+
+-/* 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);
++/* 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;
++ int value1 = 0;
++ ZMQ_Error rc_lzmq_socket_reconnect_ivl_max2 = 0;
++ this1 = obj_type_ZMQ_Socket_check(L,1);
++ 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: 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;
++ int value2;
++ ZMQ_Error rc_lzmq_socket_set_reconnect_ivl_max1 = 0;
++ this1 = obj_type_ZMQ_Socket_check(L,1);
++ value2 = luaL_checkinteger(L,2);
++ rc_lzmq_socket_set_reconnect_ivl_max1 = lzmq_socket_set_reconnect_ivl_max(this1, value2);
+ /* check for error. */
+- if((-1 == rc_zmq_connect1)) {
++ if((-1 == rc_lzmq_socket_set_reconnect_ivl_max1)) {
+ lua_pushnil(L);
+- error_code__ZMQ_Error__push(L, rc_zmq_connect1);
++ error_code__ZMQ_Error__push(L, rc_lzmq_socket_set_reconnect_ivl_max1);
+ } 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: maxmsgsize */
++#if (VERSION_3_0)
++static int ZMQ_Socket__maxmsgsize__meth(lua_State *L) {
++ ZMQ_Socket * this1;
++ int64_t value1 = 0;
++ ZMQ_Error rc_lzmq_socket_maxmsgsize2 = 0;
++ this1 = obj_type_ZMQ_Socket_check(L,1);
++ 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, rc_lzmq_socket_maxmsgsize2);
++ 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_maxmsgsize */
++#if (VERSION_3_0)
++static int ZMQ_Socket__set_maxmsgsize__meth(lua_State *L) {
++ ZMQ_Socket * this1;
++ int64_t value2;
++ ZMQ_Error rc_lzmq_socket_set_maxmsgsize1 = 0;
++ this1 = obj_type_ZMQ_Socket_check(L,1);
++ value2 = luaL_checkinteger(L,2);
++ rc_lzmq_socket_set_maxmsgsize1 = lzmq_socket_set_maxmsgsize(this1, value2);
+ /* check for error. */
+- if((-1 == err1)) {
++ if((-1 == rc_lzmq_socket_set_maxmsgsize1)) {
+ lua_pushnil(L);
+- error_code__ZMQ_Error__push(L, err1);
++ error_code__ZMQ_Error__push(L, rc_lzmq_socket_set_maxmsgsize1);
+ } else {
+ lua_pushboolean(L, 1);
+ lua_pushnil(L);
+ }
+ return 2;
+ }
+-
+-/* 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;
+-
+-#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];
+
+- if(opt2 > MAX_OPTS) {
+- lua_pushnil(L);
+- lua_pushliteral(L, "Invalid socket option.");
+- return 2;
+- }
++/* method: sndhwm */
++#if (VERSION_3_0)
++static int ZMQ_Socket__sndhwm__meth(lua_State *L) {
++ ZMQ_Socket * this1;
++ int value1 = 0;
++ ZMQ_Error rc_lzmq_socket_sndhwm2 = 0;
++ this1 = obj_type_ZMQ_Socket_check(L,1);
++ 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
+
+- 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;
++/* method: set_sndhwm */
++#if (VERSION_3_0)
++static int ZMQ_Socket__set_sndhwm__meth(lua_State *L) {
++ ZMQ_Socket * this1;
++ int value2;
++ ZMQ_Error rc_lzmq_socket_set_sndhwm1 = 0;
++ this1 = obj_type_ZMQ_Socket_check(L,1);
++ value2 = luaL_checkinteger(L,2);
++ rc_lzmq_socket_set_sndhwm1 = lzmq_socket_set_sndhwm(this1, value2);
++ /* check for error. */
++ if((-1 == rc_lzmq_socket_set_sndhwm1)) {
++ lua_pushnil(L);
++ error_code__ZMQ_Error__push(L, rc_lzmq_socket_set_sndhwm1);
++ } else {
++ lua_pushboolean(L, 1);
++ lua_pushnil(L);
++ }
++ return 2;
++}
+ #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);
+
+- error_code__ZMQ_Error__push(L, err2);
++/* method: rcvhwm */
++#if (VERSION_3_0)
++static int ZMQ_Socket__rcvhwm__meth(lua_State *L) {
++ ZMQ_Socket * this1;
++ int value1 = 0;
++ ZMQ_Error rc_lzmq_socket_rcvhwm2 = 0;
++ this1 = obj_type_ZMQ_Socket_check(L,1);
++ 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: events */
+-static int ZMQ_Socket__events__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");
++/* method: set_rcvhwm */
++#if (VERSION_3_0)
++static int ZMQ_Socket__set_rcvhwm__meth(lua_State *L) {
++ ZMQ_Socket * this1;
++ int value2;
++ ZMQ_Error rc_lzmq_socket_set_rcvhwm1 = 0;
++ this1 = obj_type_ZMQ_Socket_check(L,1);
++ value2 = luaL_checkinteger(L,2);
++ rc_lzmq_socket_set_rcvhwm1 = lzmq_socket_set_rcvhwm(this1, value2);
++ /* check for error. */
++ if((-1 == rc_lzmq_socket_set_rcvhwm1)) {
++ lua_pushnil(L);
++ error_code__ZMQ_Error__push(L, rc_lzmq_socket_set_rcvhwm1);
++ } else {
++ lua_pushboolean(L, 1);
++ lua_pushnil(L);
++ }
++ return 2;
++}
+ #endif
+
+- if(!(-1 == err2)) {
+- lua_pushinteger(L, events1);
++/* method: multicast_hops */
++#if (VERSION_3_0)
++static int ZMQ_Socket__multicast_hops__meth(lua_State *L) {
++ ZMQ_Socket * this1;
++ int value1 = 0;
++ ZMQ_Error rc_lzmq_socket_multicast_hops2 = 0;
++ this1 = obj_type_ZMQ_Socket_check(L,1);
++ 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, err2);
++ error_code__ZMQ_Error__push(L, rc_lzmq_socket_multicast_hops2);
+ return 2;
+ }
++#endif
+
+-/* 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_send1 = 0;
+- rc_zmq_send1 = zmq_send(this1, msg2, flags3);
++/* method: set_multicast_hops */
++#if (VERSION_3_0)
++static int ZMQ_Socket__set_multicast_hops__meth(lua_State *L) {
++ ZMQ_Socket * this1;
++ int value2;
++ ZMQ_Error rc_lzmq_socket_set_multicast_hops1 = 0;
++ this1 = obj_type_ZMQ_Socket_check(L,1);
++ value2 = luaL_checkinteger(L,2);
++ rc_lzmq_socket_set_multicast_hops1 = lzmq_socket_set_multicast_hops(this1, value2);
+ /* check for error. */
+- if((-1 == rc_zmq_send1)) {
++ if((-1 == rc_lzmq_socket_set_multicast_hops1)) {
+ lua_pushnil(L);
+- error_code__ZMQ_Error__push(L, rc_zmq_send1);
++ error_code__ZMQ_Error__push(L, rc_lzmq_socket_set_multicast_hops1);
+ } else {
+ lua_pushboolean(L, 1);
+ lua_pushnil(L);
+ }
+ return 2;
+ }
++#endif
+
+-/* 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 err1 = 0;
+- err1 = simple_zmq_send(this1, data2, data_len2, flags3);
++/* method: rcvtimeo */
++#if (VERSION_2_2|VERSION_3_0)
++static int ZMQ_Socket__rcvtimeo__meth(lua_State *L) {
++ ZMQ_Socket * this1;
++ int value1 = 0;
++ ZMQ_Error rc_lzmq_socket_rcvtimeo2 = 0;
++ this1 = obj_type_ZMQ_Socket_check(L,1);
++ 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_2_2|VERSION_3_0)
++static int ZMQ_Socket__set_rcvtimeo__meth(lua_State *L) {
++ ZMQ_Socket * this1;
++ int value2;
++ ZMQ_Error rc_lzmq_socket_set_rcvtimeo1 = 0;
++ this1 = obj_type_ZMQ_Socket_check(L,1);
++ value2 = luaL_checkinteger(L,2);
++ rc_lzmq_socket_set_rcvtimeo1 = lzmq_socket_set_rcvtimeo(this1, value2);
+ /* check for error. */
+- if((-1 == err1)) {
++ if((-1 == rc_lzmq_socket_set_rcvtimeo1)) {
+ lua_pushnil(L);
+- error_code__ZMQ_Error__push(L, err1);
++ 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_2_2|VERSION_3_0)
++static int ZMQ_Socket__sndtimeo__meth(lua_State *L) {
++ ZMQ_Socket * this1;
++ int value1 = 0;
++ ZMQ_Error rc_lzmq_socket_sndtimeo2 = 0;
++ this1 = obj_type_ZMQ_Socket_check(L,1);
++ 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: 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_recv1 = 0;
+- rc_zmq_recv1 = zmq_recv(this1, msg2, flags3);
++/* method: set_sndtimeo */
++#if (VERSION_2_2|VERSION_3_0)
++static int ZMQ_Socket__set_sndtimeo__meth(lua_State *L) {
++ ZMQ_Socket * this1;
++ int value2;
++ ZMQ_Error rc_lzmq_socket_set_sndtimeo1 = 0;
++ this1 = obj_type_ZMQ_Socket_check(L,1);
++ value2 = luaL_checkinteger(L,2);
++ rc_lzmq_socket_set_sndtimeo1 = lzmq_socket_set_sndtimeo(this1, value2);
+ /* check for error. */
+- if((-1 == rc_zmq_recv1)) {
++ if((-1 == rc_lzmq_socket_set_sndtimeo1)) {
+ lua_pushnil(L);
+- error_code__ZMQ_Error__push(L, rc_zmq_recv1);
++ error_code__ZMQ_Error__push(L, rc_lzmq_socket_set_sndtimeo1);
+ } else {
+ lua_pushboolean(L, 1);
+ lua_pushnil(L);
+ }
+ return 2;
+ }
++#endif
+
+-/* 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_recv(this1, &msg, flags2);
+- if(0 == err2) {
+- data1 = zmq_msg_data(&msg);
+- data_len1 = zmq_msg_size(&msg);
+- }
+- }
+-
+- if(!(-1 == err2)) {
+- if(data1 == NULL) lua_pushnil(L); else lua_pushlstring(L, data1,data_len1);
++/* method: ipv4only */
++#if (VERSION_3_0)
++static int ZMQ_Socket__ipv4only__meth(lua_State *L) {
++ ZMQ_Socket * this1;
++ int value1 = 0;
++ ZMQ_Error rc_lzmq_socket_ipv4only2 = 0;
++ this1 = obj_type_ZMQ_Socket_check(L,1);
++ rc_lzmq_socket_ipv4only2 = lzmq_socket_ipv4only(this1, &(value1));
++ if(!(-1 == rc_lzmq_socket_ipv4only2)) {
++ lua_pushinteger(L, value1);
+ } else {
+ lua_pushnil(L);
+ }
+- error_code__ZMQ_Error__push(L, err2);
+- /* close message */
+- zmq_msg_close(&msg);
++ error_code__ZMQ_Error__push(L, rc_lzmq_socket_ipv4only2);
++ return 2;
++}
++#endif
+
++/* method: set_ipv4only */
++#if (VERSION_3_0)
++static int ZMQ_Socket__set_ipv4only__meth(lua_State *L) {
++ ZMQ_Socket * this1;
++ int value2;
++ ZMQ_Error rc_lzmq_socket_set_ipv4only1 = 0;
++ this1 = obj_type_ZMQ_Socket_check(L,1);
++ value2 = luaL_checkinteger(L,2);
++ rc_lzmq_socket_set_ipv4only1 = lzmq_socket_set_ipv4only(this1, value2);
++ /* check for error. */
++ if((-1 == rc_lzmq_socket_set_ipv4only1)) {
++ lua_pushnil(L);
++ error_code__ZMQ_Error__push(L, rc_lzmq_socket_set_ipv4only1);
++ } 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);
+- int this_flags1 = OBJ_UDATA_FLAG_OWN;
+- ZMQ_Poller * this1;
+- ZMQ_Poller poller;
+- this1 = &poller;
+- this1->items = (zmq_pollitem_t *)calloc(length1, sizeof(zmq_pollitem_t));
+- this1->next = -1;
+- this1->count = 0;
+- this1->len = length1;
+- this1->free_list = -1;
+-
+- obj_type_ZMQ_Poller_push(L, this1, this_flags1);
++ unsigned int length1;
++ ZMQ_Poller this1_store;
++ ZMQ_Poller * this1 = &(this1_store);
++ length1 = luaL_optinteger(L,1,10);
++ poller_init(this1, length1);
++ obj_type_ZMQ_Poller_push(L, this1);
+ return 1;
+ }
+
+ /* method: close */
+ static int ZMQ_Poller__close__meth(lua_State *L) {
+- int this_flags1 = 0;
+- ZMQ_Poller * this1 = obj_type_ZMQ_Poller_delete(L,1,&(this_flags1));
+- if(!(this_flags1 & OBJ_UDATA_FLAG_OWN)) { return 0; }
+- free(this1->items);
+- this1->items = NULL;
+- this1->next = -1;
+- this1->count = 0;
+- this1->len = 0;
+- this1->free_list = -1;
+-
++ ZMQ_Poller * this1;
++ this1 = obj_type_ZMQ_Poller_delete(L,1);
++ poller_cleanup(this1);
+ return 0;
+ }
+
+ /* method: add */
+ static int ZMQ_Poller__add__meth(lua_State *L) {
+- ZMQ_Poller * this1 = obj_type_ZMQ_Poller_check(L,1);
+- short events3 = luaL_checkinteger(L,3);
++ ZMQ_Poller * this1;
++ short events3;
+ int idx1 = 0;
+ zmq_pollitem_t *item;
+ ZMQ_Socket *sock = NULL;
+ socket_t fd = 0;
+
++ this1 = obj_type_ZMQ_Poller_check(L,1);
++ events3 = luaL_checkinteger(L,3);
+ if(lua_isuserdata(L, 2)) {
+ sock = obj_type_ZMQ_Socket_check(L, 2);
+ } else if(lua_isnumber(L, 2)) {
+@@ -2777,13 +6247,15 @@ static int ZMQ_Poller__add__meth(lua_State *L) {
+
+ /* method: modify */
+ static int ZMQ_Poller__modify__meth(lua_State *L) {
+- ZMQ_Poller * this1 = obj_type_ZMQ_Poller_check(L,1);
+- short events3 = luaL_checkinteger(L,3);
++ ZMQ_Poller * this1;
++ short events3;
+ int idx1 = 0;
+ zmq_pollitem_t *item;
+ ZMQ_Socket *sock = NULL;
+ socket_t fd = 0;
+
++ this1 = obj_type_ZMQ_Poller_check(L,1);
++ events3 = luaL_checkinteger(L,3);
+ if(lua_isuserdata(L, 2)) {
+ sock = obj_type_ZMQ_Socket_check(L, 2);
+ /* find sock in items list. */
+@@ -2815,98 +6287,76 @@ static int ZMQ_Poller__modify__meth(lua_State *L) {
+
+ /* method: remove */
+ static int ZMQ_Poller__remove__meth(lua_State *L) {
+- ZMQ_Poller * this1 = obj_type_ZMQ_Poller_check(L,1);
++ ZMQ_Poller * this1;
++ int idx1 = 0;
+ ZMQ_Socket *sock;
+ socket_t fd;
+- int idx;
+
++ this1 = obj_type_ZMQ_Poller_check(L,1);
+ /* ZMQ_Socket or fd */
+ if(lua_isuserdata(L, 2)) {
+ sock = obj_type_ZMQ_Socket_check(L, 2);
+ /* find sock in items list. */
+- idx = poller_find_sock_item(this1, sock);
++ idx1 = poller_find_sock_item(this1, sock);
+ } else if(lua_isnumber(L, 2)) {
+ fd = lua_tonumber(L, 2);
+ /* find fd in items list. */
+- idx = poller_find_fd_item(this1, fd);
++ idx1 = poller_find_fd_item(this1, fd);
+ } else {
+ return luaL_typerror(L, 2, "number or ZMQ_Socket");
+ }
+ /* if sock/fd was found. */
+- if(idx >= 0) {
+- poller_remove_item(this1, idx);
++ if(idx1 >= 0) {
++ poller_remove_item(this1, idx1);
+ }
+
+- return 0;
++ lua_pushinteger(L, idx1);
++ return 1;
+ }
+
+ /* method: poll */
+ static int ZMQ_Poller__poll__meth(lua_State *L) {
+- ZMQ_Poller * this1 = obj_type_ZMQ_Poller_check(L,1);
+- long timeout2 = luaL_checkinteger(L,2);
+- ZMQ_Error err1 = 0;
+- /* poll for events */
+- err1 = poller_poll(this1, timeout2);
+- if(err1 > 0) {
++ ZMQ_Poller * this1;
++ long timeout2;
++ int count1 = 0;
++ ZMQ_Error err2 = 0;
++ this1 = obj_type_ZMQ_Poller_check(L,1);
++ timeout2 = luaL_checkinteger(L,2);
++ err2 = poller_poll(this1, timeout2);
++ if(err2 > 0) {
+ this1->next = 0;
++ count1 = err2;
+ } else {
+ this1->next = -1;
++ count1 = 0;
+ }
+
+- /* check for error. */
+- if((-1 == err1)) {
+- lua_pushnil(L);
+- error_code__ZMQ_Error__push(L, err1);
++ if(!(-1 == err2)) {
++ lua_pushinteger(L, count1);
+ } else {
+- lua_pushboolean(L, 1);
+ lua_pushnil(L);
+ }
++ error_code__ZMQ_Error__push(L, err2);
+ return 2;
+ }
+
+-/* method: next_revents */
+-static int ZMQ_Poller__next_revents__meth(lua_State *L) {
+- ZMQ_Poller * this1 = obj_type_ZMQ_Poller_check(L,1);
+- short revents2 = 0;
+- zmq_pollitem_t *items;
+- int count;
+- int idx;
+-
+- revents2 = -1;
+- idx = this1->next;
+- if(idx >= 0) {
+- count = this1->count;
+- items = this1->items;
+- /* find next item with pending events. */
+- while(idx < count && items[idx].revents == 0) ++idx;
+- /* did we find a pending event? */
+- if(idx < count) {
+- /* push the event's sock/fd. */
+- if(items[idx].socket != NULL) {
+- obj_type_ZMQ_Socket_push(L, items[idx].socket, 0);
+- } else {
+- lua_pushnumber(L, items[idx].fd);
+- }
+- revents2 = items[idx].revents;
+- /* is this the last event. */
+- ++idx;
+- this1->next = (idx < count) ? idx : -1;
+- }
+- }
+- if(revents2 < 0) {
+- /* no more pending events. */
+- lua_pushnil(L);
+- this1->next = -1;
+- }
+-
++/* method: next_revents_idx */
++static int ZMQ_Poller__next_revents_idx__meth(lua_State *L) {
++ ZMQ_Poller * this1;
++ int idx1 = 0;
++ int revents2 = 0;
++ this1 = obj_type_ZMQ_Poller_check(L,1);
++ idx1 = poller_next_revents(this1, &(revents2));
++ lua_pushinteger(L, idx1);
+ lua_pushinteger(L, revents2);
+ return 2;
+ }
+
+ /* method: count */
+ static int ZMQ_Poller__count__meth(lua_State *L) {
+- ZMQ_Poller * this1 = obj_type_ZMQ_Poller_check(L,1);
++ ZMQ_Poller * this1;
+ int count1 = 0;
++ this1 = obj_type_ZMQ_Poller_check(L,1);
+ count1 = this1->count;
+
+ lua_pushinteger(L, count1);
+@@ -2916,8 +6366,9 @@ static int ZMQ_Poller__count__meth(lua_State *L) {
+ /* method: term */
+ static int ZMQ_Ctx__term__meth(lua_State *L) {
+ int this_flags1 = 0;
+- ZMQ_Ctx * this1 = obj_type_ZMQ_Ctx_delete(L,1,&(this_flags1));
++ ZMQ_Ctx * this1;
+ ZMQ_Error rc_zmq_term1 = 0;
++ this1 = obj_type_ZMQ_Ctx_delete(L,1,&(this_flags1));
+ if(!(this_flags1 & OBJ_UDATA_FLAG_OWN)) { return 0; }
+ rc_zmq_term1 = zmq_term(this1);
+ /* check for error. */
+@@ -2933,8 +6384,9 @@ static int ZMQ_Ctx__term__meth(lua_State *L) {
+
+ /* method: lightuserdata */
+ static int ZMQ_Ctx__lightuserdata__meth(lua_State *L) {
+- ZMQ_Ctx * this1 = obj_type_ZMQ_Ctx_check(L,1);
++ ZMQ_Ctx * this1;
+ void * ptr1 = NULL;
++ this1 = obj_type_ZMQ_Ctx_check(L,1);
+ ptr1 = this1;
+
+ lua_pushlightuserdata(L, ptr1);
+@@ -2943,10 +6395,12 @@ static int ZMQ_Ctx__lightuserdata__meth(lua_State *L) {
+
+ /* method: socket */
+ static int ZMQ_Ctx__socket__meth(lua_State *L) {
+- ZMQ_Ctx * this1 = obj_type_ZMQ_Ctx_check(L,1);
+- int type2 = luaL_checkinteger(L,2);
++ ZMQ_Ctx * this1;
++ int type2;
+ int rc_zmq_socket_flags1 = OBJ_UDATA_FLAG_OWN;
+ ZMQ_Socket * rc_zmq_socket1;
++ this1 = obj_type_ZMQ_Ctx_check(L,1);
++ type2 = luaL_checkinteger(L,2);
+ rc_zmq_socket1 = zmq_socket(this1, type2);
+ if((NULL == rc_zmq_socket1)) {
+ lua_pushnil(L);
+@@ -2969,8 +6423,9 @@ static int ZMQ_StopWatch__start__meth(lua_State *L) {
+ /* method: stop */
+ static int ZMQ_StopWatch__stop__meth(lua_State *L) {
+ int this_flags1 = 0;
+- ZMQ_StopWatch * this1 = obj_type_ZMQ_StopWatch_delete(L,1,&(this_flags1));
++ ZMQ_StopWatch * this1;
+ unsigned long usecs1 = 0;
++ this1 = obj_type_ZMQ_StopWatch_delete(L,1,&(this_flags1));
+ if(!(this_flags1 & OBJ_UDATA_FLAG_OWN)) { return 0; }
+ usecs1 = zmq_stopwatch_stop(this1);
+ lua_pushinteger(L, usecs1);
+@@ -2996,9 +6451,10 @@ static int zmq__version__func(lua_State *L) {
+
+ /* method: init */
+ static int zmq__init__func(lua_State *L) {
+- int io_threads1 = luaL_checkinteger(L,1);
++ int io_threads1;
+ int rc_zmq_init_flags1 = OBJ_UDATA_FLAG_OWN;
+ ZMQ_Ctx * rc_zmq_init1;
++ io_threads1 = luaL_optinteger(L,1,1);
+ rc_zmq_init1 = zmq_init(io_threads1);
+ if((NULL == rc_zmq_init1)) {
+ lua_pushnil(L);
+@@ -3028,11 +6484,15 @@ static int zmq__init_ctx__func(lua_State *L) {
+ }
+
+ /* method: device */
++#if (VERSION_2_0)
+ static int zmq__device__func(lua_State *L) {
+- int device1 = luaL_checkinteger(L,1);
+- ZMQ_Socket * insock2 = obj_type_ZMQ_Socket_check(L,2);
+- ZMQ_Socket * outsock3 = obj_type_ZMQ_Socket_check(L,3);
++ int device1;
++ ZMQ_Socket * insock2;
++ ZMQ_Socket * outsock3;
+ ZMQ_Error rc_zmq_device1 = 0;
++ device1 = luaL_checkinteger(L,1);
++ insock2 = obj_type_ZMQ_Socket_check(L,2);
++ outsock3 = obj_type_ZMQ_Socket_check(L,3);
+ rc_zmq_device1 = zmq_device(device1, insock2, outsock3);
+ /* check for error. */
+ if((-1 == rc_zmq_device1)) {
+@@ -3044,6 +6504,7 @@ static int zmq__device__func(lua_State *L) {
+ }
+ return 2;
+ }
++#endif
+
+ /* method: stopwatch_start */
+ static int zmq__stopwatch_start__func(lua_State *L) {
+@@ -3056,32 +6517,452 @@ static int zmq__stopwatch_start__func(lua_State *L) {
+
+ /* method: sleep */
+ static int zmq__sleep__func(lua_State *L) {
+- int seconds_1 = luaL_checkinteger(L,1);
++ int seconds_1;
++ seconds_1 = luaL_checkinteger(L,1);
+ zmq_sleep(seconds_1);
+ return 0;
+ }
+
+-/* method: dump_ffi */
+-static int zmq__dump_ffi__func(lua_State *L) {
+- size_t ffi_code_len1 = 0;
+- const char * ffi_code1 = NULL;
+- ffi_code1 = zmq_ffi_lua_code;
+- ffi_code_len1 = sizeof(zmq_ffi_lua_code) - 1;
+
+- if(ffi_code1 == NULL) lua_pushnil(L); else lua_pushlstring(L, ffi_code1,ffi_code_len1);
+- return 1;
+-}
+
++static const luaL_Reg obj_ZErrors_pub_funcs[] = {
++ {NULL, NULL}
++};
++
++static const luaL_Reg obj_ZErrors_methods[] = {
++ {"description", ZErrors__description__meth},
++ {NULL, NULL}
++};
++
++static const luaL_Reg obj_ZErrors_metas[] = {
++ {"__index", ZErrors____index__meth},
++ {NULL, NULL}
++};
++
++static const obj_const obj_ZErrors_constants[] = {
++#ifdef ELNRNG
++ {"ELNRNG", NULL, ELNRNG, CONST_NUMBER},
++#endif
++#ifdef EPFNOSUPPORT
++ {"EPFNOSUPPORT", NULL, EPFNOSUPPORT, CONST_NUMBER},
++#endif
++#ifdef EBADR
++ {"EBADR", NULL, EBADR, CONST_NUMBER},
++#endif
++#ifdef ENOLINK
++ {"ENOLINK", NULL, ENOLINK, CONST_NUMBER},
++#endif
++#ifdef ENOSTR
++ {"ENOSTR", NULL, ENOSTR, CONST_NUMBER},
++#endif
++#ifdef ERESTART
++ {"ERESTART", NULL, ERESTART, CONST_NUMBER},
++#endif
++#ifdef EUCLEAN
++ {"EUCLEAN", NULL, EUCLEAN, CONST_NUMBER},
++#endif
++#ifdef ELIBSCN
++ {"ELIBSCN", NULL, ELIBSCN, CONST_NUMBER},
++#endif
++#ifdef EROFS
++ {"EROFS", NULL, EROFS, CONST_NUMBER},
++#endif
++#ifdef EBADE
++ {"EBADE", NULL, EBADE, CONST_NUMBER},
++#endif
++#ifdef ENOTSOCK
++ {"ENOTSOCK", NULL, ENOTSOCK, CONST_NUMBER},
++#endif
++#ifdef ENOTCONN
++ {"ENOTCONN", NULL, ENOTCONN, CONST_NUMBER},
++#endif
++#ifdef EREMOTE
++ {"EREMOTE", NULL, EREMOTE, CONST_NUMBER},
++#endif
++#ifdef ECOMM
++ {"ECOMM", NULL, ECOMM, CONST_NUMBER},
++#endif
++#ifdef ENODATA
++ {"ENODATA", NULL, ENODATA, CONST_NUMBER},
++#endif
++#ifdef EPERM
++ {"EPERM", NULL, EPERM, CONST_NUMBER},
++#endif
++#ifdef EBADRQC
++ {"EBADRQC", NULL, EBADRQC, CONST_NUMBER},
++#endif
++#ifdef ENOSR
++ {"ENOSR", NULL, ENOSR, CONST_NUMBER},
++#endif
++#ifdef ELIBMAX
++ {"ELIBMAX", NULL, ELIBMAX, CONST_NUMBER},
++#endif
++#ifdef EDOTDOT
++ {"EDOTDOT", NULL, EDOTDOT, CONST_NUMBER},
++#endif
++#ifdef EFSM
++ {"EFSM", NULL, EFSM, CONST_NUMBER},
++#endif
++#ifdef ENOPROTOOPT
++ {"ENOPROTOOPT", NULL, ENOPROTOOPT, CONST_NUMBER},
++#endif
++#ifdef EBFONT
++ {"EBFONT", NULL, EBFONT, CONST_NUMBER},
++#endif
++#ifdef ENOCOMPATPROTO
++ {"ENOCOMPATPROTO", NULL, ENOCOMPATPROTO, CONST_NUMBER},
++#endif
++#ifdef EKEYREVOKED
++ {"EKEYREVOKED", NULL, EKEYREVOKED, CONST_NUMBER},
++#endif
++#ifdef ESRMNT
++ {"ESRMNT", NULL, ESRMNT, CONST_NUMBER},
++#endif
++#ifdef EOVERFLOW
++ {"EOVERFLOW", NULL, EOVERFLOW, CONST_NUMBER},
++#endif
++#ifdef EDQUOT
++ {"EDQUOT", NULL, EDQUOT, CONST_NUMBER},
++#endif
++#ifdef EFBIG
++ {"EFBIG", NULL, EFBIG, CONST_NUMBER},
++#endif
++#ifdef EIDRM
++ {"EIDRM", NULL, EIDRM, CONST_NUMBER},
++#endif
++#ifdef EDOM
++ {"EDOM", NULL, EDOM, CONST_NUMBER},
++#endif
++#ifdef EPROTO
++ {"EPROTO", NULL, EPROTO, CONST_NUMBER},
++#endif
++#ifdef EMULTIHOP
++ {"EMULTIHOP", NULL, EMULTIHOP, CONST_NUMBER},
++#endif
++#ifdef ENOCSI
++ {"ENOCSI", NULL, ENOCSI, CONST_NUMBER},
++#endif
++#ifdef EDEADLOCK
++ {"EDEADLOCK", NULL, EDEADLOCK, CONST_NUMBER},
++#endif
++#ifdef ENOPKG
++ {"ENOPKG", NULL, ENOPKG, CONST_NUMBER},
++#endif
++#ifdef EPIPE
++ {"EPIPE", NULL, EPIPE, CONST_NUMBER},
++#endif
++#ifdef EADDRINUSE
++ {"EADDRINUSE", NULL, EADDRINUSE, CONST_NUMBER},
++#endif
++#ifdef EFAULT
++ {"EFAULT", NULL, EFAULT, CONST_NUMBER},
++#endif
++#ifdef EDEADLK
++ {"EDEADLK", NULL, EDEADLK, CONST_NUMBER},
++#endif
++#ifdef ENFILE
++ {"ENFILE", NULL, ENFILE, CONST_NUMBER},
++#endif
++#ifdef EAGAIN
++ {"EAGAIN", NULL, EAGAIN, CONST_NUMBER},
++#endif
++#ifdef ECONNABORTED
++ {"ECONNABORTED", NULL, ECONNABORTED, CONST_NUMBER},
++#endif
++#ifdef EMLINK
++ {"EMLINK", NULL, EMLINK, CONST_NUMBER},
++#endif
++#ifdef EBADMSG
++ {"EBADMSG", NULL, EBADMSG, CONST_NUMBER},
++#endif
++#ifdef ERFKILL
++ {"ERFKILL", NULL, ERFKILL, CONST_NUMBER},
++#endif
++#ifdef ENOTTY
++ {"ENOTTY", NULL, ENOTTY, CONST_NUMBER},
++#endif
++#ifdef ELIBACC
++ {"ELIBACC", NULL, ELIBACC, CONST_NUMBER},
++#endif
++#ifdef ETIME
++ {"ETIME", NULL, ETIME, CONST_NUMBER},
++#endif
++#ifdef ECHILD
++ {"ECHILD", NULL, ECHILD, CONST_NUMBER},
++#endif
++#ifdef ENOTRECOVERABLE
++ {"ENOTRECOVERABLE", NULL, ENOTRECOVERABLE, CONST_NUMBER},
++#endif
++#ifdef EISCONN
++ {"EISCONN", NULL, EISCONN, CONST_NUMBER},
++#endif
++#ifdef ENAVAIL
++ {"ENAVAIL", NULL, ENAVAIL, CONST_NUMBER},
++#endif
++#ifdef EDESTADDRREQ
++ {"EDESTADDRREQ", NULL, EDESTADDRREQ, CONST_NUMBER},
++#endif
++#ifdef EREMOTEIO
++ {"EREMOTEIO", NULL, EREMOTEIO, CONST_NUMBER},
++#endif
++#ifdef ESTALE
++ {"ESTALE", NULL, ESTALE, CONST_NUMBER},
++#endif
++#ifdef ESTRPIPE
++ {"ESTRPIPE", NULL, ESTRPIPE, CONST_NUMBER},
++#endif
++#ifdef EHOSTUNREACH
++ {"EHOSTUNREACH", NULL, EHOSTUNREACH, CONST_NUMBER},
++#endif
++#ifdef ENOTBLK
++ {"ENOTBLK", NULL, ENOTBLK, CONST_NUMBER},
++#endif
++#ifdef EEXIST
++ {"EEXIST", NULL, EEXIST, CONST_NUMBER},
++#endif
++#ifdef ENOTDIR
++ {"ENOTDIR", NULL, ENOTDIR, CONST_NUMBER},
++#endif
++#ifdef EWOULDBLOCK
++ {"EWOULDBLOCK", NULL, EWOULDBLOCK, CONST_NUMBER},
++#endif
++#ifdef EREMCHG
++ {"EREMCHG", NULL, EREMCHG, CONST_NUMBER},
++#endif
++#ifdef ELOOP
++ {"ELOOP", NULL, ELOOP, CONST_NUMBER},
++#endif
++#ifdef ENOTUNIQ
++ {"ENOTUNIQ", NULL, ENOTUNIQ, CONST_NUMBER},
++#endif
++#ifdef EMEDIUMTYPE
++ {"EMEDIUMTYPE", NULL, EMEDIUMTYPE, CONST_NUMBER},
++#endif
++#ifdef ENOLCK
++ {"ENOLCK", NULL, ENOLCK, CONST_NUMBER},
++#endif
++#ifdef EUNATCH
++ {"EUNATCH", NULL, EUNATCH, CONST_NUMBER},
++#endif
++#ifdef EPROTONOSUPPORT
++ {"EPROTONOSUPPORT", NULL, EPROTONOSUPPORT, CONST_NUMBER},
++#endif
++#ifdef EHOSTDOWN
++ {"EHOSTDOWN", NULL, EHOSTDOWN, CONST_NUMBER},
++#endif
++#ifdef EINTR
++ {"EINTR", NULL, EINTR, CONST_NUMBER},
++#endif
++#ifdef ETIMEDOUT
++ {"ETIMEDOUT", NULL, ETIMEDOUT, CONST_NUMBER},
++#endif
++#ifdef EOWNERDEAD
++ {"EOWNERDEAD", NULL, EOWNERDEAD, CONST_NUMBER},
++#endif
++#ifdef EL2HLT
++ {"EL2HLT", NULL, EL2HLT, CONST_NUMBER},
++#endif
++#ifdef ETERM
++ {"ETERM", NULL, ETERM, CONST_NUMBER},
++#endif
++#ifdef EBADSLT
++ {"EBADSLT", NULL, EBADSLT, CONST_NUMBER},
++#endif
++#ifdef ESHUTDOWN
++ {"ESHUTDOWN", NULL, ESHUTDOWN, CONST_NUMBER},
++#endif
++#ifdef EIO
++ {"EIO", NULL, EIO, CONST_NUMBER},
++#endif
++#ifdef ENOANO
++ {"ENOANO", NULL, ENOANO, CONST_NUMBER},
++#endif
++#ifdef EACCES
++ {"EACCES", NULL, EACCES, CONST_NUMBER},
++#endif
++#ifdef EOPNOTSUPP
++ {"EOPNOTSUPP", NULL, EOPNOTSUPP, CONST_NUMBER},
++#endif
++#ifdef EKEYREJECTED
++ {"EKEYREJECTED", NULL, EKEYREJECTED, CONST_NUMBER},
++#endif
++#ifdef ESOCKTNOSUPPORT
++ {"ESOCKTNOSUPPORT", NULL, ESOCKTNOSUPPORT, CONST_NUMBER},
++#endif
++#ifdef ENOKEY
++ {"ENOKEY", NULL, ENOKEY, CONST_NUMBER},
++#endif
++#ifdef ELIBBAD
++ {"ELIBBAD", NULL, ELIBBAD, CONST_NUMBER},
++#endif
++#ifdef ENODEV
++ {"ENODEV", NULL, ENODEV, CONST_NUMBER},
++#endif
++#ifdef ECANCELED
++ {"ECANCELED", NULL, ECANCELED, CONST_NUMBER},
++#endif
++#ifdef ENOBUFS
++ {"ENOBUFS", NULL, ENOBUFS, CONST_NUMBER},
++#endif
++#ifdef ENETUNREACH
++ {"ENETUNREACH", NULL, ENETUNREACH, CONST_NUMBER},
++#endif
++#ifdef EL3HLT
++ {"EL3HLT", NULL, EL3HLT, CONST_NUMBER},
++#endif
++#ifdef ENXIO
++ {"ENXIO", NULL, ENXIO, CONST_NUMBER},
++#endif
++#ifdef ENETRESET
++ {"ENETRESET", NULL, ENETRESET, CONST_NUMBER},
++#endif
++#ifdef ENOENT
++ {"ENOENT", NULL, ENOENT, CONST_NUMBER},
++#endif
++#ifdef ENOMSG
++ {"ENOMSG", NULL, ENOMSG, CONST_NUMBER},
++#endif
++#ifdef EL3RST
++ {"EL3RST", NULL, EL3RST, CONST_NUMBER},
++#endif
++#ifdef EMFILE
++ {"EMFILE", NULL, EMFILE, CONST_NUMBER},
++#endif
++#ifdef ENOEXEC
++ {"ENOEXEC", NULL, ENOEXEC, CONST_NUMBER},
++#endif
++#ifdef ENOTEMPTY
++ {"ENOTEMPTY", NULL, ENOTEMPTY, CONST_NUMBER},
++#endif
++#ifdef EMTHREAD
++ {"EMTHREAD", NULL, EMTHREAD, CONST_NUMBER},
++#endif
++#ifdef EISNAM
++ {"EISNAM", NULL, EISNAM, CONST_NUMBER},
++#endif
++#ifdef EINVAL
++ {"EINVAL", NULL, EINVAL, CONST_NUMBER},
++#endif
++#ifdef ERANGE
++ {"ERANGE", NULL, ERANGE, CONST_NUMBER},
++#endif
++#ifdef E2BIG
++ {"E2BIG", NULL, E2BIG, CONST_NUMBER},
++#endif
++#ifdef ENOTNAM
++ {"ENOTNAM", NULL, ENOTNAM, CONST_NUMBER},
++#endif
++#ifdef ENONET
++ {"ENONET", NULL, ENONET, CONST_NUMBER},
++#endif
++#ifdef EADDRNOTAVAIL
++ {"EADDRNOTAVAIL", NULL, EADDRNOTAVAIL, CONST_NUMBER},
++#endif
++#ifdef ENOSYS
++ {"ENOSYS", NULL, ENOSYS, CONST_NUMBER},
++#endif
++#ifdef EINPROGRESS
++ {"EINPROGRESS", NULL, EINPROGRESS, CONST_NUMBER},
++#endif
++#ifdef EBUSY
++ {"EBUSY", NULL, EBUSY, CONST_NUMBER},
++#endif
++#ifdef EBADFD
++ {"EBADFD", NULL, EBADFD, CONST_NUMBER},
++#endif
++#ifdef EISDIR
++ {"EISDIR", NULL, EISDIR, CONST_NUMBER},
++#endif
++#ifdef EADV
++ {"EADV", NULL, EADV, CONST_NUMBER},
++#endif
++#ifdef ECONNRESET
++ {"ECONNRESET", NULL, ECONNRESET, CONST_NUMBER},
++#endif
++#ifdef ENOSPC
++ {"ENOSPC", NULL, ENOSPC, CONST_NUMBER},
++#endif
++#ifdef ETOOMANYREFS
++ {"ETOOMANYREFS", NULL, ETOOMANYREFS, CONST_NUMBER},
++#endif
++#ifdef EXFULL
++ {"EXFULL", NULL, EXFULL, CONST_NUMBER},
++#endif
++#ifdef EPROTOTYPE
++ {"EPROTOTYPE", NULL, EPROTOTYPE, CONST_NUMBER},
++#endif
++#ifdef ESRCH
++ {"ESRCH", NULL, ESRCH, CONST_NUMBER},
++#endif
++#ifdef EMSGSIZE
++ {"EMSGSIZE", NULL, EMSGSIZE, CONST_NUMBER},
++#endif
++#ifdef EAFNOSUPPORT
++ {"EAFNOSUPPORT", NULL, EAFNOSUPPORT, CONST_NUMBER},
++#endif
++#ifdef ESPIPE
++ {"ESPIPE", NULL, ESPIPE, CONST_NUMBER},
++#endif
++#ifdef ENETDOWN
++ {"ENETDOWN", NULL, ENETDOWN, CONST_NUMBER},
++#endif
++#ifdef ECHRNG
++ {"ECHRNG", NULL, ECHRNG, CONST_NUMBER},
++#endif
++#ifdef ENOMEM
++ {"ENOMEM", NULL, ENOMEM, CONST_NUMBER},
++#endif
++#ifdef ECONNREFUSED
++ {"ECONNREFUSED", NULL, ECONNREFUSED, CONST_NUMBER},
++#endif
++#ifdef ETXTBSY
++ {"ETXTBSY", NULL, ETXTBSY, CONST_NUMBER},
++#endif
++#ifdef EKEYEXPIRED
++ {"EKEYEXPIRED", NULL, EKEYEXPIRED, CONST_NUMBER},
++#endif
++#ifdef ENOMEDIUM
++ {"ENOMEDIUM", NULL, ENOMEDIUM, CONST_NUMBER},
++#endif
++#ifdef EUSERS
++ {"EUSERS", NULL, EUSERS, CONST_NUMBER},
++#endif
++#ifdef EILSEQ
++ {"EILSEQ", NULL, EILSEQ, CONST_NUMBER},
++#endif
++#ifdef ELIBEXEC
++ {"ELIBEXEC", NULL, ELIBEXEC, CONST_NUMBER},
++#endif
++#ifdef EALREADY
++ {"EALREADY", NULL, EALREADY, CONST_NUMBER},
++#endif
++#ifdef ENAMETOOLONG
++ {"ENAMETOOLONG", NULL, ENAMETOOLONG, CONST_NUMBER},
++#endif
++#ifdef EXDEV
++ {"EXDEV", NULL, EXDEV, CONST_NUMBER},
++#endif
++#ifdef EBADF
++ {"EBADF", NULL, EBADF, CONST_NUMBER},
++#endif
++#ifdef EL2NSYNC
++ {"EL2NSYNC", NULL, EL2NSYNC, CONST_NUMBER},
++#endif
++ {NULL, NULL, 0.0 , 0}
++};
+
++static const reg_impl obj_ZErrors_implements[] = {
++ {NULL, NULL}
++};
+
+-static const luaL_reg obj_zmq_msg_t_pub_funcs[] = {
++static const luaL_Reg obj_zmq_msg_t_pub_funcs[] = {
+ {"init", zmq_msg_t__init__meth},
+ {"init_size", zmq_msg_t__init_size__meth},
+ {"init_data", zmq_msg_t__init_data__meth},
+ {NULL, NULL}
+ };
+
+-static const luaL_reg obj_zmq_msg_t_methods[] = {
++static const luaL_Reg obj_zmq_msg_t_methods[] = {
+ {"close", zmq_msg_t__close__meth},
+ {"move", zmq_msg_t__move__meth},
+ {"copy", zmq_msg_t__copy__meth},
+@@ -3092,7 +6973,7 @@ static const luaL_reg obj_zmq_msg_t_methods[] = {
+ {NULL, NULL}
+ };
+
+-static const luaL_reg obj_zmq_msg_t_metas[] = {
++static const luaL_Reg obj_zmq_msg_t_metas[] = {
+ {"__gc", zmq_msg_t__delete__meth},
+ {"__tostring", zmq_msg_t____tostring__meth},
+ {"__eq", obj_simple_udata_default_equal},
+@@ -3111,25 +6992,176 @@ static const obj_const obj_zmq_msg_t_constants[] = {
+ {NULL, NULL, 0.0 , 0}
+ };
+
+-static const luaL_reg obj_ZMQ_Socket_pub_funcs[] = {
++static const reg_impl obj_zmq_msg_t_implements[] = {
++ { "BufferIF", &(zmq_msg_t_Buffer) },
++
++ { "MutableBufferIF", &(zmq_msg_t_MutableBuffer) },
++
++ {NULL, NULL}
++};
++
++static const luaL_Reg obj_ZMQ_Socket_pub_funcs[] = {
+ {NULL, NULL}
+ };
+
+-static const luaL_reg obj_ZMQ_Socket_methods[] = {
++static const luaL_Reg obj_ZMQ_Socket_methods[] = {
+ {"close", ZMQ_Socket__close__meth},
+ {"bind", ZMQ_Socket__bind__meth},
+ {"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)
++ {"mcast_loop", ZMQ_Socket__mcast_loop__meth},
++#endif
++#if (VERSION_2_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_2_2|VERSION_3_0)
++ {"rcvtimeo", ZMQ_Socket__rcvtimeo__meth},
++#endif
++#if (VERSION_2_2|VERSION_3_0)
++ {"set_rcvtimeo", ZMQ_Socket__set_rcvtimeo__meth},
++#endif
++#if (VERSION_2_2|VERSION_3_0)
++ {"sndtimeo", ZMQ_Socket__sndtimeo__meth},
++#endif
++#if (VERSION_2_2|VERSION_3_0)
++ {"set_sndtimeo", ZMQ_Socket__set_sndtimeo__meth},
++#endif
++#if (VERSION_3_0)
++ {"ipv4only", ZMQ_Socket__ipv4only__meth},
++#endif
++#if (VERSION_3_0)
++ {"set_ipv4only", ZMQ_Socket__set_ipv4only__meth},
++#endif
+ {NULL, NULL}
+ };
+
+-static const luaL_reg obj_ZMQ_Socket_metas[] = {
++static const luaL_Reg obj_ZMQ_Socket_metas[] = {
+ {"__gc", ZMQ_Socket__close__meth},
+ {"__tostring", obj_udata_default_tostring},
+ {"__eq", obj_udata_default_equal},
+@@ -3148,23 +7180,27 @@ static const obj_const obj_ZMQ_Socket_constants[] = {
+ {NULL, NULL, 0.0 , 0}
+ };
+
+-static const luaL_reg obj_ZMQ_Poller_pub_funcs[] = {
++static const reg_impl obj_ZMQ_Socket_implements[] = {
++ {NULL, NULL}
++};
++
++static const luaL_Reg obj_ZMQ_Poller_pub_funcs[] = {
+ {"new", ZMQ_Poller__new__meth},
+ {NULL, NULL}
+ };
+
+-static const luaL_reg obj_ZMQ_Poller_methods[] = {
++static const luaL_Reg obj_ZMQ_Poller_methods[] = {
+ {"close", ZMQ_Poller__close__meth},
+ {"add", ZMQ_Poller__add__meth},
+ {"modify", ZMQ_Poller__modify__meth},
+ {"remove", ZMQ_Poller__remove__meth},
+ {"poll", ZMQ_Poller__poll__meth},
+- {"next_revents", ZMQ_Poller__next_revents__meth},
++ {"next_revents_idx", ZMQ_Poller__next_revents_idx__meth},
+ {"count", ZMQ_Poller__count__meth},
+ {NULL, NULL}
+ };
+
+-static const luaL_reg obj_ZMQ_Poller_metas[] = {
++static const luaL_Reg obj_ZMQ_Poller_metas[] = {
+ {"__gc", ZMQ_Poller__close__meth},
+ {"__tostring", obj_simple_udata_default_tostring},
+ {"__eq", obj_simple_udata_default_equal},
+@@ -3183,18 +7219,22 @@ static const obj_const obj_ZMQ_Poller_constants[] = {
+ {NULL, NULL, 0.0 , 0}
+ };
+
+-static const luaL_reg obj_ZMQ_Ctx_pub_funcs[] = {
++static const reg_impl obj_ZMQ_Poller_implements[] = {
++ {NULL, NULL}
++};
++
++static const luaL_Reg obj_ZMQ_Ctx_pub_funcs[] = {
+ {NULL, NULL}
+ };
+
+-static const luaL_reg obj_ZMQ_Ctx_methods[] = {
++static const luaL_Reg obj_ZMQ_Ctx_methods[] = {
+ {"term", ZMQ_Ctx__term__meth},
+ {"lightuserdata", ZMQ_Ctx__lightuserdata__meth},
+ {"socket", ZMQ_Ctx__socket__meth},
+ {NULL, NULL}
+ };
+
+-static const luaL_reg obj_ZMQ_Ctx_metas[] = {
++static const luaL_Reg obj_ZMQ_Ctx_metas[] = {
+ {"__gc", ZMQ_Ctx__term__meth},
+ {"__tostring", obj_udata_default_tostring},
+ {"__eq", obj_udata_default_equal},
+@@ -3213,17 +7253,21 @@ static const obj_const obj_ZMQ_Ctx_constants[] = {
+ {NULL, NULL, 0.0 , 0}
+ };
+
+-static const luaL_reg obj_ZMQ_StopWatch_pub_funcs[] = {
++static const reg_impl obj_ZMQ_Ctx_implements[] = {
++ {NULL, NULL}
++};
++
++static const luaL_Reg obj_ZMQ_StopWatch_pub_funcs[] = {
+ {"start", ZMQ_StopWatch__start__meth},
+ {NULL, NULL}
+ };
+
+-static const luaL_reg obj_ZMQ_StopWatch_methods[] = {
++static const luaL_Reg obj_ZMQ_StopWatch_methods[] = {
+ {"stop", ZMQ_StopWatch__stop__meth},
+ {NULL, NULL}
+ };
+
+-static const luaL_reg obj_ZMQ_StopWatch_metas[] = {
++static const luaL_Reg obj_ZMQ_StopWatch_metas[] = {
+ {"__gc", ZMQ_StopWatch__stop__meth},
+ {"__tostring", obj_udata_default_tostring},
+ {"__eq", obj_udata_default_equal},
+@@ -3242,87 +7286,217 @@ static const obj_const obj_ZMQ_StopWatch_constants[] = {
+ {NULL, NULL, 0.0 , 0}
+ };
+
+-static const luaL_reg zmq_function[] = {
++static const reg_impl obj_ZMQ_StopWatch_implements[] = {
++ {NULL, NULL}
++};
++
++static const luaL_Reg zmq_function[] = {
+ {"version", zmq__version__func},
+ {"init", zmq__init__func},
+ {"init_ctx", zmq__init_ctx__func},
++#if (VERSION_2_0)
+ {"device", zmq__device__func},
++#endif
+ {"stopwatch_start", zmq__stopwatch_start__func},
+ {"sleep", zmq__sleep__func},
+- {"dump_ffi", zmq__dump_ffi__func},
+ {NULL, NULL}
+ };
+
+ 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},
+- {"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},
+- {"MAX_VSM_SIZE", NULL, 30, CONST_NUMBER},
+- {"PUSH", NULL, 8, 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},
+- {"PAIR", NULL, 0, CONST_NUMBER},
+- {"QUEUE", NULL, 3, CONST_NUMBER},
+- {"EVENTS", NULL, 15, CONST_NUMBER},
+- {"XREQ", NULL, 5, CONST_NUMBER},
+- {"XREP", NULL, 6, CONST_NUMBER},
+- {"SUBSCRIBE", NULL, 6, CONST_NUMBER},
+- {"MCAST_LOOP", NULL, 10, CONST_NUMBER},
+- {"VSM", NULL, 32, CONST_NUMBER},
+- {"RECOVERY_IVL", NULL, 9, CONST_NUMBER},
+- {"RECONNECT_IVL", NULL, 18, CONST_NUMBER},
+- {"POLLOUT", NULL, 2, CONST_NUMBER},
+- {"AFFINITY", NULL, 4, 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_XSUB
++ {"XSUB", NULL, ZMQ_XSUB, CONST_NUMBER},
++#endif
++#ifdef ZMQ_STREAMER
++ {"STREAMER", NULL, ZMQ_STREAMER, CONST_NUMBER},
++#endif
++#ifdef ZMQ_RECONNECT_IVL_MSEC
++ {"RECONNECT_IVL_MSEC", NULL, ZMQ_RECONNECT_IVL_MSEC, CONST_NUMBER},
++#endif
++#ifdef ZMQ_MAX_VSM_SIZE
++ {"MAX_VSM_SIZE", NULL, ZMQ_MAX_VSM_SIZE, CONST_NUMBER},
++#endif
++#ifdef ZMQ_PAIR
++ {"PAIR", NULL, ZMQ_PAIR, 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_RATE
++ {"RATE", NULL, ZMQ_RATE, CONST_NUMBER},
++#endif
++#ifdef ZMQ_IDENTITY
++ {"IDENTITY", NULL, ZMQ_IDENTITY, 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_PULL
++ {"PULL", NULL, ZMQ_PULL, CONST_NUMBER},
++#endif
++#ifdef ZMQ_MULTICAST_HOPS
++ {"MULTICAST_HOPS", NULL, ZMQ_MULTICAST_HOPS, CONST_NUMBER},
++#endif
++#ifdef ZMQ_RCVHWM
++ {"RCVHWM", NULL, ZMQ_RCVHWM, CONST_NUMBER},
++#endif
++#ifdef ZMQ_SUB
++ {"SUB", NULL, ZMQ_SUB, CONST_NUMBER},
++#endif
++#ifdef ZMQ_UNSUBSCRIBE
++ {"UNSUBSCRIBE", NULL, ZMQ_UNSUBSCRIBE, CONST_NUMBER},
++#endif
++#ifdef ZMQ_BACKLOG
++ {"BACKLOG", NULL, ZMQ_BACKLOG, CONST_NUMBER},
++#endif
++#ifdef ZMQ_XREQ
++ {"XREQ", NULL, ZMQ_XREQ, CONST_NUMBER},
++#endif
++#ifdef ZMQ_PUSH
++ {"PUSH", NULL, ZMQ_PUSH, 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_RCVLABEL
++ {"RCVLABEL", NULL, ZMQ_RCVLABEL, CONST_NUMBER},
++#endif
++#ifdef ZMQ_SNDBUF
++ {"SNDBUF", NULL, ZMQ_SNDBUF, CONST_NUMBER},
++#endif
++#ifdef ZMQ_FD
++ {"FD", NULL, ZMQ_FD, CONST_NUMBER},
++#endif
++#ifdef ZMQ_POLLIN
++ {"POLLIN", NULL, ZMQ_POLLIN, CONST_NUMBER},
++#endif
++#ifdef ZMQ_XPUB
++ {"XPUB", NULL, ZMQ_XPUB, 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_SWAP
++ {"SWAP", NULL, ZMQ_SWAP, CONST_NUMBER},
++#endif
++#ifdef ZMQ_REQ
++ {"REQ", NULL, ZMQ_REQ, CONST_NUMBER},
++#endif
++#ifdef ZMQ_RECONNECT_IVL_MAX
++ {"RECONNECT_IVL_MAX", NULL, ZMQ_RECONNECT_IVL_MAX, CONST_NUMBER},
++#endif
++#ifdef ZMQ_AFFINITY
++ {"AFFINITY", NULL, ZMQ_AFFINITY, 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_VSM
++ {"VSM", NULL, ZMQ_VSM, CONST_NUMBER},
++#endif
++#ifdef ZMQ_SNDHWM
++ {"SNDHWM", NULL, ZMQ_SNDHWM, CONST_NUMBER},
++#endif
++#ifdef ZMQ_XREP
++ {"XREP", NULL, ZMQ_XREP, 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_DONTWAIT
++ {"DONTWAIT", NULL, ZMQ_DONTWAIT, 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}
+ };
+
+-static const ffi_export_symbol zmq_ffi_export[] = {
+-{ "get_zmq_strerror", get_zmq_strerror },
+-{ "simple_zmq_send", simple_zmq_send },
+-{ "poller_find_sock_item", poller_find_sock_item },
+-{ "poller_find_fd_item", poller_find_fd_item },
+-{ "poller_get_free_item", poller_get_free_item },
+-{ "poller_poll", poller_poll },
+-{ "poller_remove_item", poller_remove_item },
+- {NULL, NULL}
+-};
+-
+
+
+ static const reg_sub_module reg_sub_modules[] = {
+- { &(obj_type_zmq_msg_t), 0, obj_zmq_msg_t_pub_funcs, obj_zmq_msg_t_methods, obj_zmq_msg_t_metas, obj_zmq_msg_t_bases, obj_zmq_msg_t_fields, obj_zmq_msg_t_constants},
+- { &(obj_type_ZMQ_Socket), 0, obj_ZMQ_Socket_pub_funcs, obj_ZMQ_Socket_methods, obj_ZMQ_Socket_metas, obj_ZMQ_Socket_bases, obj_ZMQ_Socket_fields, obj_ZMQ_Socket_constants},
+- { &(obj_type_ZMQ_Poller), 0, obj_ZMQ_Poller_pub_funcs, obj_ZMQ_Poller_methods, obj_ZMQ_Poller_metas, obj_ZMQ_Poller_bases, obj_ZMQ_Poller_fields, obj_ZMQ_Poller_constants},
+- { &(obj_type_ZMQ_Ctx), 0, obj_ZMQ_Ctx_pub_funcs, obj_ZMQ_Ctx_methods, obj_ZMQ_Ctx_metas, obj_ZMQ_Ctx_bases, obj_ZMQ_Ctx_fields, obj_ZMQ_Ctx_constants},
+- { &(obj_type_ZMQ_StopWatch), 0, obj_ZMQ_StopWatch_pub_funcs, obj_ZMQ_StopWatch_methods, obj_ZMQ_StopWatch_metas, obj_ZMQ_StopWatch_bases, obj_ZMQ_StopWatch_fields, obj_ZMQ_StopWatch_constants},
+- {NULL, 0, NULL, NULL, NULL, NULL, NULL, NULL}
++ { &(obj_type_ZErrors), REG_META, obj_ZErrors_pub_funcs, obj_ZErrors_methods, obj_ZErrors_metas, NULL, NULL, obj_ZErrors_constants, NULL, 0},
++ { &(obj_type_zmq_msg_t), REG_OBJECT, obj_zmq_msg_t_pub_funcs, obj_zmq_msg_t_methods, obj_zmq_msg_t_metas, obj_zmq_msg_t_bases, obj_zmq_msg_t_fields, obj_zmq_msg_t_constants, obj_zmq_msg_t_implements, 0},
++ { &(obj_type_ZMQ_Socket), REG_OBJECT, obj_ZMQ_Socket_pub_funcs, obj_ZMQ_Socket_methods, obj_ZMQ_Socket_metas, obj_ZMQ_Socket_bases, obj_ZMQ_Socket_fields, obj_ZMQ_Socket_constants, obj_ZMQ_Socket_implements, 0},
++ { &(obj_type_ZMQ_Poller), REG_OBJECT, obj_ZMQ_Poller_pub_funcs, obj_ZMQ_Poller_methods, obj_ZMQ_Poller_metas, obj_ZMQ_Poller_bases, obj_ZMQ_Poller_fields, obj_ZMQ_Poller_constants, obj_ZMQ_Poller_implements, 0},
++ { &(obj_type_ZMQ_Ctx), REG_OBJECT, obj_ZMQ_Ctx_pub_funcs, obj_ZMQ_Ctx_methods, obj_ZMQ_Ctx_metas, obj_ZMQ_Ctx_bases, obj_ZMQ_Ctx_fields, obj_ZMQ_Ctx_constants, obj_ZMQ_Ctx_implements, 0},
++ { &(obj_type_ZMQ_StopWatch), REG_OBJECT, obj_ZMQ_StopWatch_pub_funcs, obj_ZMQ_StopWatch_methods, obj_ZMQ_StopWatch_metas, obj_ZMQ_StopWatch_bases, obj_ZMQ_StopWatch_fields, obj_ZMQ_StopWatch_constants, obj_ZMQ_StopWatch_implements, 0},
++ {NULL, 0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, 0}
+ };
+
+
+
+
+
++#if LUAJIT_FFI
++static const ffi_export_symbol zmq_ffi_export[] = {
++ {NULL, { NULL } }
++};
++#endif
++
++
+
+
+ static const luaL_Reg submodule_libs[] = {
+@@ -3355,20 +7529,29 @@ LUA_NOBJ_API int luaopen_zmq(lua_State *L) {
+ const luaL_Reg *submodules = submodule_libs;
+ int priv_table = -1;
+
+-#if LUAJIT_FFI
++ /* register interfaces */
++ obj_register_interfaces(L, obj_interfaces);
++
+ /* private table to hold reference to object metatables. */
+ lua_newtable(L);
+ priv_table = lua_gettop(L);
+-#endif
++ lua_pushlightuserdata(L, obj_udata_private_key);
++ lua_pushvalue(L, priv_table);
++ lua_rawset(L, LUA_REGISTRYINDEX); /* store private table in registry. */
+
+ /* create object cache. */
+ create_object_instance_cache(L);
+
+ /* module table. */
++#if REG_MODULES_AS_GLOBALS
+ luaL_register(L, "zmq", zmq_function);
++#else
++ lua_newtable(L);
++ luaL_setfuncs(L, zmq_function, 0);
++#endif
+
+ /* register module constants. */
+- obj_type_register_constants(L, zmq_constants, -1);
++ obj_type_register_constants(L, zmq_constants, -1, 0);
+
+ for(; submodules->func != NULL ; submodules++) {
+ lua_pushcfunction(L, submodules->func);
+@@ -3389,9 +7572,19 @@ LUA_NOBJ_API int luaopen_zmq(lua_State *L) {
+ }
+
+ #if LUAJIT_FFI
+- nobj_try_loading_ffi(L, "zmq", zmq_ffi_lua_code,
+- zmq_ffi_export, priv_table);
++ if(nobj_check_ffi_support(L)) {
++ nobj_try_loading_ffi(L, "zmq.nobj.ffi.lua", zmq_ffi_lua_code,
++ zmq_ffi_export, priv_table);
++ }
+ #endif
++
++ /* Cache reference to zmq.ZErrors table for errno->string convertion. */
++ lua_pushlightuserdata(L, zmq_ZErrors_key);
++ lua_getfield(L, -2, "ZErrors");
++ lua_rawset(L, LUA_REGISTRYINDEX);
++
++
++
+ return 1;
+ }
+
+diff --git a/src/socket.nobj.lua b/src/socket.nobj.lua
+index 207f52b..ef7a0db 100644
+--- a/src/socket.nobj.lua
++++ b/src/socket.nobj.lua
+@@ -18,21 +18,416 @@
+ -- 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",
++UINT32 = "uint32_t",
++UINT64 = "uint64_t",
++INT64 = "int64_t",
++BLOB = "const char *",
++FD = "int",
++}
++local get_set_prefix = {
++rw = { c_get = "lzmq_socket_", get='', c_set = "lzmq_socket_set_", set='set_' },
++r = { c_get = "lzmq_socket_", get='' },
++w = { c_set = "lzmq_socket_", set='' },
++}
++
++local socket_options = {
++ { 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" },
++ [4] = { name="affinity", otype="UINT64", mode="rw", ltype="uint64_t" },
++ [5] = { name="identity", otype="BLOB", mode="rw", ltype="const char *" },
++ [6] = { name="subscribe", otype="BLOB", mode="w", ltype="const char *" },
++ [7] = { name="unsubscribe", otype="BLOB", mode="w", ltype="const char *" },
++ [8] = { name="rate", otype="INT64", mode="rw", ltype="int" },
++ [9] = { name="recovery_ivl", otype="INT64", mode="rw", ltype="int" },
++ [10] = { name="mcast_loop", otype="INT64", mode="rw", ltype="int" },
++ [11] = { name="sndbuf", otype="UINT64", mode="rw", ltype="int" },
++ [12] = { name="rcvbuf", otype="UINT64", mode="rw", ltype="int" },
++ [13] = { name="rcvmore", otype="INT64", mode="r", ltype="int" },
++ },
++ { 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" },
++ [17] = { name="linger", otype="INT", mode="rw", ltype="int" },
++ [18] = { name="reconnect_ivl", otype="INT", mode="rw", ltype="int" },
++ [19] = { name="backlog", otype="INT", mode="rw", ltype="int" },
++ [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_2_2', major = 2, minor = 2,
++ [22] = { },
++ [23] = { },
++ [24] = { },
++ [25] = { },
++ [26] = { },
++ [27] = { name="rcvtimeo", otype="INT", mode="rw", ltype="int" },
++ [28] = { name="sndtimeo", otype="INT", mode="rw", ltype="int" },
++ },
++ { 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) {
++ 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);
++}
++
++]] },
++ [2] = { },
++ [3] = { },
++ [4] = { name="affinity", otype="UINT64", mode="rw", ltype="uint64_t" },
++ [5] = { name="identity", otype="BLOB", mode="rw", ltype="const char *" },
++ [6] = { name="subscribe", otype="BLOB", mode="w", ltype="const char *" },
++ [7] = { name="unsubscribe", otype="BLOB", mode="w", ltype="const char *" },
++ [8] = { name="rate", otype="INT", mode="rw", ltype="int" },
++ [9] = { name="recovery_ivl", otype="INT", mode="rw", ltype="int" },
++ [10] = { },
++ [11] = { name="sndbuf", otype="INT", mode="rw", ltype="int" },
++ [12] = { name="rcvbuf", otype="INT", mode="rw", ltype="int" },
++ [13] = { name="rcvmore", otype="INT", mode="r", ltype="int" },
++ [14] = { name="fd", otype="FD", mode="r", ltype="int" },
++ [15] = { name="events", otype="INT", mode="r", ltype="int" },
++ [16] = { name="type", otype="INT", mode="r", ltype="int" },
++ [17] = { name="linger", otype="INT", mode="rw", ltype="int" },
++ [18] = { name="reconnect_ivl", otype="INT", mode="rw", ltype="int" },
++ [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_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" },
++ [26] = { },
++ [27] = { name="rcvtimeo", otype="INT", mode="rw", ltype="int" },
++ [28] = { name="sndtimeo", otype="INT", mode="rw", ltype="int" },
++ [29] = { },
++ [30] = { },
++ [31] = { name="ipv4only", 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=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, 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]
++ opt.ctype = ctype
++ if opt.otype == 'BLOB' then
++ opt.ffi_type = 'string'
++ opt.set_len_param = ', size_t value_len'
++ opt.set_val_name = 'value'
++ opt.set_len_name = 'value_len'
++ elseif ctype ~= 'NONE' then
++ opt.ffi_type = ctype .. '[1]'
++ opt.set_len_param = ''
++ opt.set_val_name = '&value'
++ opt.set_len_name = 'sizeof(value)'
++ end
++ -- getter/setter names
++ 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 options_c_code = {}
++local opt_types = {}
++
++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
++local last_ver
++foreach_opt(function(num, opt, ver)
++ if ver ~= last_ver then
++ if last_ver then
++ endif(last_ver.ver_def)
++ end
++ last_ver = ver
++ 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 = ''
++ if opt.c_set then
++ if opt.otype == 'BLOB' then
++ set = [[
++LUA_NOBJ_API ZMQ_Error ${c_set}(ZMQ_Socket *sock, const char *value, size_t str_len) {
++ return zmq_setsockopt(sock, ${DEF}, value, str_len);
++]]
++ elseif opt.ctype == opt.ltype then
++ set = [[
++LUA_NOBJ_API ZMQ_Error ${c_set}(ZMQ_Socket *sock, ${ltype} value) {
++ return zmq_setsockopt(sock, ${DEF}, &value, sizeof(value));
++]]
++ else
++ set = [[
++LUA_NOBJ_API ZMQ_Error ${c_set}(ZMQ_Socket *sock, ${ltype} value) {
++ ${ctype} val = (${ctype})value;
++ return zmq_setsockopt(sock, ${DEF}, &val, sizeof(val));
++]]
++ end
++ set = set .. "}\n\n"
++ end
++ -- generate getter
++ if opt.c_get then
++ if opt.otype == 'BLOB' then
++ get = [[
++LUA_NOBJ_API ZMQ_Error ${c_get}(ZMQ_Socket *sock, char *value, size_t *len) {
++ return zmq_getsockopt(sock, ${DEF}, value, len);
++]]
++ elseif opt.ctype == opt.ltype then
++ get = [[
++LUA_NOBJ_API ZMQ_Error ${c_get}(ZMQ_Socket *sock, ${ltype} *value) {
++ size_t val_len = sizeof(${ltype});
++ return zmq_getsockopt(sock, ${DEF}, value, &val_len);
++]]
++ else
++ get = [[
++LUA_NOBJ_API ZMQ_Error ${c_get}(ZMQ_Socket *sock, ${ltype} *value) {
++ ${ctype} val;
++ size_t val_len = sizeof(val);
++ int rc = zmq_getsockopt(sock, ${DEF}, &val, &val_len);
++ *value = (${ltype})val;
++ return rc;
++]]
++ end
++ get = get .. "}\n\n"
++ end
++ local templ
++ if opt.custom then
++ templ = opt.custom
++ else
++ templ = set .. get
++ end
++ add(options_c_code, template(opt,templ))
++end)
++endif(last_ver.ver_def)
++
++add(opt_types, [[
++#if VERSION_3_0
++# define MAX_OPTS VERSION_3_0_MAX_OPT
++#else
++# if VERSION_2_2
++# define MAX_OPTS VERSION_2_2_MAX_OPT
++# elif 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)
++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_export_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_export_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 [[
+-/* 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
++ ffi_source "ffi_pre_cdef" [[
++
++-- detect zmq version
++local VERSION_2_0 = true
++local VERSION_2_1 = false
++local VERSION_2_2 = 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] == 2 then
++ VERSION_2_2 = true
++ VERSION_2_1 = true
++elseif zver[1] == 2 and zver[2] == 1 then
++ VERSION_2_1 = true
++end
++
++if VERSION_2_0 then
++ ffi.cdef[==[
++typedef int ZMQ_Error;
++typedef struct ZMQ_Socket ZMQ_Socket;
++typedef struct zmq_msg_t zmq_msg_t;
++
++ZMQ_Error zmq_sendmsg(ZMQ_Socket *sock, zmq_msg_t *msg, int flags) __asm__("zmq_send");
++ZMQ_Error zmq_recvmsg(ZMQ_Socket *sock, zmq_msg_t *msg, int flags) __asm__("zmq_recv");
++]==]
++end
++]],
++ c_source ([[
+
+ /* 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"
++# 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;
+@@ -44,47 +439,23 @@ typedef SOCKET socket_t;
+ typedef int socket_t;
+ #endif
+
++#if VERSION_2_0
++# 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_STR 5
++#define OPT_TYPE_BLOB 5
+ #define OPT_TYPE_FD 6
+
+ 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 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
+-
+-]],
++ OPT_TYPE_NONE, /* 0 unused */
++]] .. opt_types .. options_c_code),
+
+ destructor "close" {
+ c_method_call "ZMQ_Error" "zmq_close" {}
+@@ -99,37 +470,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_types = {
+-[zmq.HWM] = 'uint64_t[1]',
+-[zmq.SWAP] = 'int64_t[1]',
+-[zmq.AFFINITY] = 'uint64_t[1]',
+-[zmq.IDENTITY] = 'string',
+-[zmq.SUBSCRIBE] = 'string',
+-[zmq.UNSUBSCRIBE] = 'string',
+-[zmq.RATE] = 'int64_t[1]',
+-[zmq.RECOVERY_IVL] = 'int64_t[1]',
+-[zmq.MCAST_LOOP] = 'int64_t[1]',
+-[zmq.SNDBUF] = 'uint64_t[1]',
+-[zmq.RCVBUF] = 'uint64_t[1]',
+-[zmq.RCVMORE] = 'int64_t[1]',
+-[zmq.FD] = 'int[1]',
+-[zmq.EVENTS] = 'uint32_t[1]',
+-[zmq.TYPE] = 'int[1]',
+-[zmq.LINGER] = 'int[1]',
+-[zmq.RECONNECT_IVL] = 'int[1]',
+-[zmq.BACKLOG] = 'int[1]',
+-}
+-local option_len = {}
+-local option_tmps = {}
+-for k,v in pairs(option_types) do
+- if v ~= 'string' then
+- option_len[k] = ffi.sizeof(v)
+- option_tmps[k] = ffi.new(v, 0)
+- end
++ ffi_source([[
++local option_gets = {}
++local option_sets = {}
++
++do
++ 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})
++ setmetatable(option_sets,{__index = function(tab,opt)
++ local opt_name = opt_name[opt]
++ if not opt_name then return nil end
++ local method = methods['set_' .. opt_name] or methods[opt_name]
++ rawset(tab, opt, method)
++ return method
++ end})
++ opt_name = {
++]] .. ffi_opt_names .. [[}
+ end
+
+-]],
++]]),
+ method "setopt" {
+ var_in{ "uint32_t", "opt" },
+ var_in{ "<any>", "val" },
+@@ -138,7 +504,7 @@ end
+ size_t val_len;
+ const void *val;
+
+-#if VERSION_2_1
++#if defined(VERSION_2_1) || defined(VERSION_3_0)
+ socket_t fd_val;
+ #endif
+ int int_val;
+@@ -146,12 +512,26 @@ end
+ uint64_t uint64_val;
+ int64_t int64_val;
+
++#if VERSION_3_0
++ /* 3.0 backwards compatibility support for HWM. */
++ if(${opt} == ZMQ_HWM) {
++ int_val = luaL_checklong(L, ${val::idx});
++ val = &int_val;
++ val_len = sizeof(int_val);
++ ${err} = zmq_setsockopt(${this}, ZMQ_SNDHWM, val, val_len);
++ if(-1 != ${err}) {
++ ${err} = zmq_setsockopt(${this}, ZMQ_RCVHWM, val, val_len);
++ }
++ goto finished;
++ }
++#endif
++
+ if(${opt} > MAX_OPTS) {
+ return luaL_argerror(L, ${opt::idx}, "Invalid socket option.");
+ }
+
+ switch(opt_types[${opt}]) {
+-#if VERSION_2_1
++#if defined(VERSION_2_1) || defined(VERSION_3_0)
+ case OPT_TYPE_FD:
+ fd_val = luaL_checklong(L, ${val::idx});
+ val = &fd_val;
+@@ -178,7 +558,7 @@ end
+ val = &int64_val;
+ val_len = sizeof(int64_val);
+ break;
+- case OPT_TYPE_STR:
++ case OPT_TYPE_BLOB:
+ val = luaL_checklstring(L, ${val::idx}, &(val_len));
+ break;
+ default:
+@@ -187,20 +567,15 @@ end
+ break;
+ }
+ ${err} = zmq_setsockopt(${this}, ${opt}, val, val_len);
++finished:
+ ]],
+ ffi_source[[
+- local ctype = option_types[${opt}]
+- local tval
+- local tval_len = 0
+- if ctype == 'string' then
+- tval = tostring(${val})
+- tval_len = #${val}
++ local set = option_sets[${opt}]
++ if set then
++ return set(${this},${val})
+ else
+- tval = option_tmps[${opt}]
+- tval[0] = ${val}
+- tval_len = option_len[${opt}]
++ error("Invalid socket option.")
+ end
+- ${err} = C.zmq_setsockopt(${this}, ${opt}, tval, tval_len)
+ ]],
+ },
+ ffi_source[[
+@@ -213,7 +588,7 @@ local tmp_val_len = ffi.new('size_t[1]', 4)
+ c_source[[
+ size_t val_len;
+
+-#if VERSION_2_1
++#if defined(VERSION_2_1) || defined(VERSION_3_0)
+ socket_t fd_val;
+ #endif
+ int int_val;
+@@ -230,7 +605,7 @@ local tmp_val_len = ffi.new('size_t[1]', 4)
+ }
+
+ switch(opt_types[${opt}]) {
+-#if VERSION_2_1
++#if defined(VERSION_2_1) || defined(VERSION_3_0)
+ case OPT_TYPE_FD:
+ val_len = sizeof(fd_val);
+ ${err} = zmq_getsockopt(${this}, ${opt}, &fd_val, &val_len);
+@@ -272,7 +647,7 @@ local tmp_val_len = ffi.new('size_t[1]', 4)
+ return 1;
+ }
+ break;
+- case OPT_TYPE_STR:
++ case OPT_TYPE_BLOB:
+ val_len = STR_MAX;
+ ${err} = zmq_getsockopt(${this}, ${opt}, str_val, &val_len);
+ if(0 == ${err}) {
+@@ -289,62 +664,23 @@ 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 = tmp_val_len
+- if ctype == 'string' then
+- val_len[0] = 255
+- val = ffi.new('uint8_t[?]', val_len[0])
+- ffi.fill(val, val_len[0])
++ local get = option_gets[${opt}]
++ if get then
++ return get(${this})
+ else
+- val = option_tmps[${opt}]
+- val[0] = 0
+- val_len[0] = option_len[${opt}]
+- end
+- ${err} = C.zmq_getsockopt(${this}, ${opt}, val, val_len)
+- if ${err} == 0 then
+- if ctype == 'string' then
+- val_len = val_len[0]
+- return ffi.string(val, val_len)
+- else
+- return tonumber(val[0])
+- end
++ error("Invalid socket option.")
+ end
+ ]],
+ },
+- ffi_source[[
+--- temp. values for 'events' function.
+-local events_tmp = ffi.new('uint32_t[1]', 0)
+-local events_tmp_size = ffi.sizeof('uint32_t')
+-local events_tmp_len = ffi.new('size_t[1]', events_tmp_size)
+-local ZMQ_EVENTS = _M.EVENTS
+-]],
+- method "events" {
+- var_out{ "uint32_t", "events" },
+- var_out{ "ZMQ_Error", "err" },
+- c_source[[
+-#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
+-]],
+- 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]
+-]],
+- },
+ --
+ -- zmq_send
+ --
+ method "send_msg" {
+- c_method_call "ZMQ_Error" "zmq_send" { "zmq_msg_t *", "msg", "int", "flags?" },
++ c_method_call "ZMQ_Error" "zmq_sendmsg" { "zmq_msg_t *", "msg", "int", "flags?" },
+ },
+ -- create helper function for `zmq_send`
+ c_source[[
+-static ZMQ_Error simple_zmq_send(ZMQ_Socket *sock, const char *data, size_t data_len, int flags) {
++LUA_NOBJ_API 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 */
+@@ -353,32 +689,22 @@ static ZMQ_Error simple_zmq_send(ZMQ_Socket *sock, const char *data, size_t data
+ /* fill message */
+ memcpy(zmq_msg_data(&msg), data, data_len);
+ /* send message */
+- err = zmq_send(sock, &msg, flags);
++ err = zmq_sendmsg(sock, &msg, flags);
+ /* close message */
+ zmq_msg_close(&msg);
+ }
+ return err;
+ }
+ ]],
+- -- export helper function.
+- ffi_export_function "ZMQ_Error" "simple_zmq_send"
+- "(ZMQ_Socket *sock, const char *data, size_t data_len, int flags)",
+ method "send" {
+- var_in{ "const char *", "data" },
+- var_in{ "int", "flags?" },
+- var_out{ "ZMQ_Error", "err" },
+- c_source[[
+- ${err} = simple_zmq_send(${this}, ${data}, ${data_len}, ${flags});
+-]],
+- ffi_source[[
+- ${err} = simple_zmq_send(${this}, ${data}, ${data_len}, ${flags});
+-]],
++ c_export_method_call "ZMQ_Error" "simple_zmq_send"
++ { "const char *", "data", "size_t", "#data", "int", "flags?"}
+ },
+ --
+ -- zmq_recv
+ --
+ method "recv_msg" {
+- c_method_call "ZMQ_Error" "zmq_recv" { "zmq_msg_t *", "msg", "int", "flags?" },
++ c_method_call "ZMQ_Error" "zmq_recvmsg" { "zmq_msg_t *", "msg", "int", "flags?" },
+ },
+ ffi_source[[
+ local tmp_msg = ffi.new('zmq_msg_t')
+@@ -393,8 +719,8 @@ local tmp_msg = ffi.new('zmq_msg_t')
+ ${err} = zmq_msg_init(&msg);
+ if(0 == ${err}) {
+ /* receive message */
+- ${err} = zmq_recv(${this}, &msg, ${flags});
+- if(0 == ${err}) {
++ ${err} = zmq_recvmsg(${this}, &msg, ${flags});
++ if(${err} >= 0) {
+ ${data} = zmq_msg_data(&msg);
+ ${data_len} = zmq_msg_size(&msg);
+ }
+@@ -412,8 +738,8 @@ local tmp_msg = ffi.new('zmq_msg_t')
+ end
+
+ -- receive message
+- ${err} = C.zmq_recv(${this}, msg, ${flags})
+- if 0 == ${err} then
++ ${err} = C.zmq_recvmsg(${this}, msg, ${flags})
++ if ${err} >= 0 then
+ local data = ffi.string(C.zmq_msg_data(msg), C.zmq_msg_size(msg))
+ -- close message
+ C.zmq_msg_close(msg)
+@@ -425,5 +751,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(),
+ }
+
+diff --git a/src/threads.lua b/src/threads.lua
+index 99257ea..e37838a 100644
+--- a/src/threads.lua
++++ b/src/threads.lua
+@@ -85,26 +85,28 @@ local function new_thread(ctx, action, action_arg, ...)
+ }, thread_mt)
+ end
+
+-module(...)
++local M = {}
+
+-function set_bootstrap_prelude(code)
++function M.set_bootstrap_prelude(code)
+ bootstrap_code = bootstrap_pre .. code .. bootstrap_post
+ end
+
+-function runfile(ctx, file, ...)
++function M.runfile(ctx, file, ...)
+ return new_thread(ctx, 'runfile', file, ...)
+ end
+
+-function runstring(ctx, code, ...)
++function M.runstring(ctx, code, ...)
+ return new_thread(ctx, 'runstring', code, ...)
+ end
+
+ local parent_ctx = nil
+-function set_parent_ctx(ctx)
++function M.set_parent_ctx(ctx)
+ parent_ctx = ctx
+ end
+
+-function get_parent_ctx(ctx)
++function M.get_parent_ctx(ctx)
+ return parent_ctx
+ end
+
++zmq.threads = M
++return M
+diff --git a/ws/LICENSE_GPL.txt b/ws/LICENSE_GPL.txt
+new file mode 100644
+index 0000000..94a9ed0
+--- /dev/null
++++ b/ws/LICENSE_GPL.txt
+@@ -0,0 +1,674 @@
++ GNU GENERAL PUBLIC LICENSE
++ Version 3, 29 June 2007
++
++ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
++ Everyone is permitted to copy and distribute verbatim copies
++ of this license document, but changing it is not allowed.
++
++ Preamble
++
++ The GNU General Public License is a free, copyleft license for
++software and other kinds of works.
++
++ The licenses for most software and other practical works are designed
++to take away your freedom to share and change the works. By contrast,
++the GNU General Public License is intended to guarantee your freedom to
++share and change all versions of a program--to make sure it remains free
++software for all its users. We, the Free Software Foundation, use the
++GNU General Public License for most of our software; it applies also to
++any other work released this way by its authors. You can apply it to
++your programs, too.
++
++ When we speak of free software, we are referring to freedom, not
++price. Our General Public Licenses are designed to make sure that you
++have the freedom to distribute copies of free software (and charge for
++them if you wish), that you receive source code or can get it if you
++want it, that you can change the software or use pieces of it in new
++free programs, and that you know you can do these things.
++
++ To protect your rights, we need to prevent others from denying you
++these rights or asking you to surrender the rights. Therefore, you have
++certain responsibilities if you distribute copies of the software, or if
++you modify it: responsibilities to respect the freedom of others.
++
++ For example, if you distribute copies of such a program, whether
++gratis or for a fee, you must pass on to the recipients the same
++freedoms that you received. You must make sure that they, too, receive
++or can get the source code. And you must show them these terms so they
++know their rights.
++
++ Developers that use the GNU GPL protect your rights with two steps:
++(1) assert copyright on the software, and (2) offer you this License
++giving you legal permission to copy, distribute and/or modify it.
++
++ For the developers' and authors' protection, the GPL clearly explains
++that there is no warranty for this free software. For both users' and
++authors' sake, the GPL requires that modified versions be marked as
++changed, so that their problems will not be attributed erroneously to
++authors of previous versions.
++
++ Some devices are designed to deny users access to install or run
++modified versions of the software inside them, although the manufacturer
++can do so. This is fundamentally incompatible with the aim of
++protecting users' freedom to change the software. The systematic
++pattern of such abuse occurs in the area of products for individuals to
++use, which is precisely where it is most unacceptable. Therefore, we
++have designed this version of the GPL to prohibit the practice for those
++products. If such problems arise substantially in other domains, we
++stand ready to extend this provision to those domains in future versions
++of the GPL, as needed to protect the freedom of users.
++
++ Finally, every program is threatened constantly by software patents.
++States should not allow patents to restrict development and use of
++software on general-purpose computers, but in those that do, we wish to
++avoid the special danger that patents applied to a free program could
++make it effectively proprietary. To prevent this, the GPL assures that
++patents cannot be used to render the program non-free.
++
++ The precise terms and conditions for copying, distribution and
++modification follow.
++
++ TERMS AND CONDITIONS
++
++ 0. Definitions.
++
++ "This License" refers to version 3 of the GNU General Public License.
++
++ "Copyright" also means copyright-like laws that apply to other kinds of
++works, such as semiconductor masks.
++
++ "The Program" refers to any copyrightable work licensed under this
++License. Each licensee is addressed as "you". "Licensees" and
++"recipients" may be individuals or organizations.
++
++ To "modify" a work means to copy from or adapt all or part of the work
++in a fashion requiring copyright permission, other than the making of an
++exact copy. The resulting work is called a "modified version" of the
++earlier work or a work "based on" the earlier work.
++
++ A "covered work" means either the unmodified Program or a work based
++on the Program.
++
++ To "propagate" a work means to do anything with it that, without
++permission, would make you directly or secondarily liable for
++infringement under applicable copyright law, except executing it on a
++computer or modifying a private copy. Propagation includes copying,
++distribution (with or without modification), making available to the
++public, and in some countries other activities as well.
++
++ To "convey" a work means any kind of propagation that enables other
++parties to make or receive copies. Mere interaction with a user through
++a computer network, with no transfer of a copy, is not conveying.
++
++ An interactive user interface displays "Appropriate Legal Notices"
++to the extent that it includes a convenient and prominently visible
++feature that (1) displays an appropriate copyright notice, and (2)
++tells the user that there is no warranty for the work (except to the
++extent that warranties are provided), that licensees may convey the
++work under this License, and how to view a copy of this License. If
++the interface presents a list of user commands or options, such as a
++menu, a prominent item in the list meets this criterion.
++
++ 1. Source Code.
++
++ The "source code" for a work means the preferred form of the work
++for making modifications to it. "Object code" means any non-source
++form of a work.
++
++ A "Standard Interface" means an interface that either is an official
++standard defined by a recognized standards body, or, in the case of
++interfaces specified for a particular programming language, one that
++is widely used among developers working in that language.
++
++ The "System Libraries" of an executable work include anything, other
++than the work as a whole, that (a) is included in the normal form of
++packaging a Major Component, but which is not part of that Major
++Component, and (b) serves only to enable use of the work with that
++Major Component, or to implement a Standard Interface for which an
++implementation is available to the public in source code form. A
++"Major Component", in this context, means a major essential component
++(kernel, window system, and so on) of the specific operating system
++(if any) on which the executable work runs, or a compiler used to
++produce the work, or an object code interpreter used to run it.
++
++ The "Corresponding Source" for a work in object code form means all
++the source code needed to generate, install, and (for an executable
++work) run the object code and to modify the work, including scripts to
++control those activities. However, it does not include the work's
++System Libraries, or general-purpose tools or generally available free
++programs which are used unmodified in performing those activities but
++which are not part of the work. For example, Corresponding Source
++includes interface definition files associated with source files for
++the work, and the source code for shared libraries and dynamically
++linked subprograms that the work is specifically designed to require,
++such as by intimate data communication or control flow between those
++subprograms and other parts of the work.
++
++ The Corresponding Source need not include anything that users
++can regenerate automatically from other parts of the Corresponding
++Source.
++
++ The Corresponding Source for a work in source code form is that
++same work.
++
++ 2. Basic Permissions.
++
++ All rights granted under this License are granted for the term of
++copyright on the Program, and are irrevocable provided the stated
++conditions are met. This License explicitly affirms your unlimited
++permission to run the unmodified Program. The output from running a
++covered work is covered by this License only if the output, given its
++content, constitutes a covered work. This License acknowledges your
++rights of fair use or other equivalent, as provided by copyright law.
++
++ You may make, run and propagate covered works that you do not
++convey, without conditions so long as your license otherwise remains
++in force. You may convey covered works to others for the sole purpose
++of having them make modifications exclusively for you, or provide you
++with facilities for running those works, provided that you comply with
++the terms of this License in conveying all material for which you do
++not control copyright. Those thus making or running the covered works
++for you must do so exclusively on your behalf, under your direction
++and control, on terms that prohibit them from making any copies of
++your copyrighted material outside their relationship with you.
++
++ Conveying under any other circumstances is permitted solely under
++the conditions stated below. Sublicensing is not allowed; section 10
++makes it unnecessary.
++
++ 3. Protecting Users' Legal Rights From Anti-Circumvention Law.
++
++ No covered work shall be deemed part of an effective technological
++measure under any applicable law fulfilling obligations under article
++11 of the WIPO copyright treaty adopted on 20 December 1996, or
++similar laws prohibiting or restricting circumvention of such
++measures.
++
++ When you convey a covered work, you waive any legal power to forbid
++circumvention of technological measures to the extent such circumvention
++is effected by exercising rights under this License with respect to
++the covered work, and you disclaim any intention to limit operation or
++modification of the work as a means of enforcing, against the work's
++users, your or third parties' legal rights to forbid circumvention of
++technological measures.
++
++ 4. Conveying Verbatim Copies.
++
++ You may convey verbatim copies of the Program's source code as you
++receive it, in any medium, provided that you conspicuously and
++appropriately publish on each copy an appropriate copyright notice;
++keep intact all notices stating that this License and any
++non-permissive terms added in accord with section 7 apply to the code;
++keep intact all notices of the absence of any warranty; and give all
++recipients a copy of this License along with the Program.
++
++ You may charge any price or no price for each copy that you convey,
++and you may offer support or warranty protection for a fee.
++
++ 5. Conveying Modified Source Versions.
++
++ You may convey a work based on the Program, or the modifications to
++produce it from the Program, in the form of source code under the
++terms of section 4, provided that you also meet all of these conditions:
++
++ a) The work must carry prominent notices stating that you modified
++ it, and giving a relevant date.
++
++ b) The work must carry prominent notices stating that it is
++ released under this License and any conditions added under section
++ 7. This requirement modifies the requirement in section 4 to
++ "keep intact all notices".
++
++ c) You must license the entire work, as a whole, under this
++ License to anyone who comes into possession of a copy. This
++ License will therefore apply, along with any applicable section 7
++ additional terms, to the whole of the work, and all its parts,
++ regardless of how they are packaged. This License gives no
++ permission to license the work in any other way, but it does not
++ invalidate such permission if you have separately received it.
++
++ d) If the work has interactive user interfaces, each must display
++ Appropriate Legal Notices; however, if the Program has interactive
++ interfaces that do not display Appropriate Legal Notices, your
++ work need not make them do so.
++
++ A compilation of a covered work with other separate and independent
++works, which are not by their nature extensions of the covered work,
++and which are not combined with it such as to form a larger program,
++in or on a volume of a storage or distribution medium, is called an
++"aggregate" if the compilation and its resulting copyright are not
++used to limit the access or legal rights of the compilation's users
++beyond what the individual works permit. Inclusion of a covered work
++in an aggregate does not cause this License to apply to the other
++parts of the aggregate.
++
++ 6. Conveying Non-Source Forms.
++
++ You may convey a covered work in object code form under the terms
++of sections 4 and 5, provided that you also convey the
++machine-readable Corresponding Source under the terms of this License,
++in one of these ways:
++
++ a) Convey the object code in, or embodied in, a physical product
++ (including a physical distribution medium), accompanied by the
++ Corresponding Source fixed on a durable physical medium
++ customarily used for software interchange.
++
++ b) Convey the object code in, or embodied in, a physical product
++ (including a physical distribution medium), accompanied by a
++ written offer, valid for at least three years and valid for as
++ long as you offer spare parts or customer support for that product
++ model, to give anyone who possesses the object code either (1) a
++ copy of the Corresponding Source for all the software in the
++ product that is covered by this License, on a durable physical
++ medium customarily used for software interchange, for a price no
++ more than your reasonable cost of physically performing this
++ conveying of source, or (2) access to copy the
++ Corresponding Source from a network server at no charge.
++
++ c) Convey individual copies of the object code with a copy of the
++ written offer to provide the Corresponding Source. This
++ alternative is allowed only occasionally and noncommercially, and
++ only if you received the object code with such an offer, in accord
++ with subsection 6b.
++
++ d) Convey the object code by offering access from a designated
++ place (gratis or for a charge), and offer equivalent access to the
++ Corresponding Source in the same way through the same place at no
++ further charge. You need not require recipients to copy the
++ Corresponding Source along with the object code. If the place to
++ copy the object code is a network server, the Corresponding Source
++ may be on a different server (operated by you or a third party)
++ that supports equivalent copying facilities, provided you maintain
++ clear directions next to the object code saying where to find the
++ Corresponding Source. Regardless of what server hosts the
++ Corresponding Source, you remain obligated to ensure that it is
++ available for as long as needed to satisfy these requirements.
++
++ e) Convey the object code using peer-to-peer transmission, provided
++ you inform other peers where the object code and Corresponding
++ Source of the work are being offered to the general public at no
++ charge under subsection 6d.
++
++ A separable portion of the object code, whose source code is excluded
++from the Corresponding Source as a System Library, need not be
++included in conveying the object code work.
++
++ A "User Product" is either (1) a "consumer product", which means any
++tangible personal property which is normally used for personal, family,
++or household purposes, or (2) anything designed or sold for incorporation
++into a dwelling. In determining whether a product is a consumer product,
++doubtful cases shall be resolved in favor of coverage. For a particular
++product received by a particular user, "normally used" refers to a
++typical or common use of that class of product, regardless of the status
++of the particular user or of the way in which the particular user
++actually uses, or expects or is expected to use, the product. A product
++is a consumer product regardless of whether the product has substantial
++commercial, industrial or non-consumer uses, unless such uses represent
++the only significant mode of use of the product.
++
++ "Installation Information" for a User Product means any methods,
++procedures, authorization keys, or other information required to install
++and execute modified versions of a covered work in that User Product from
++a modified version of its Corresponding Source. The information must
++suffice to ensure that the continued functioning of the modified object
++code is in no case prevented or interfered with solely because
++modification has been made.
++
++ If you convey an object code work under this section in, or with, or
++specifically for use in, a User Product, and the conveying occurs as
++part of a transaction in which the right of possession and use of the
++User Product is transferred to the recipient in perpetuity or for a
++fixed term (regardless of how the transaction is characterized), the
++Corresponding Source conveyed under this section must be accompanied
++by the Installation Information. But this requirement does not apply
++if neither you nor any third party retains the ability to install
++modified object code on the User Product (for example, the work has
++been installed in ROM).
++
++ The requirement to provide Installation Information does not include a
++requirement to continue to provide support service, warranty, or updates
++for a work that has been modified or installed by the recipient, or for
++the User Product in which it has been modified or installed. Access to a
++network may be denied when the modification itself materially and
++adversely affects the operation of the network or violates the rules and
++protocols for communication across the network.
++
++ Corresponding Source conveyed, and Installation Information provided,
++in accord with this section must be in a format that is publicly
++documented (and with an implementation available to the public in
++source code form), and must require no special password or key for
++unpacking, reading or copying.
++
++ 7. Additional Terms.
++
++ "Additional permissions" are terms that supplement the terms of this
++License by making exceptions from one or more of its conditions.
++Additional permissions that are applicable to the entire Program shall
++be treated as though they were included in this License, to the extent
++that they are valid under applicable law. If additional permissions
++apply only to part of the Program, that part may be used separately
++under those permissions, but the entire Program remains governed by
++this License without regard to the additional permissions.
++
++ When you convey a copy of a covered work, you may at your option
++remove any additional permissions from that copy, or from any part of
++it. (Additional permissions may be written to require their own
++removal in certain cases when you modify the work.) You may place
++additional permissions on material, added by you to a covered work,
++for which you have or can give appropriate copyright permission.
++
++ Notwithstanding any other provision of this License, for material you
++add to a covered work, you may (if authorized by the copyright holders of
++that material) supplement the terms of this License with terms:
++
++ a) Disclaiming warranty or limiting liability differently from the
++ terms of sections 15 and 16 of this License; or
++
++ b) Requiring preservation of specified reasonable legal notices or
++ author attributions in that material or in the Appropriate Legal
++ Notices displayed by works containing it; or
++
++ c) Prohibiting misrepresentation of the origin of that material, or
++ requiring that modified versions of such material be marked in
++ reasonable ways as different from the original version; or
++
++ d) Limiting the use for publicity purposes of names of licensors or
++ authors of the material; or
++
++ e) Declining to grant rights under trademark law for use of some
++ trade names, trademarks, or service marks; or
++
++ f) Requiring indemnification of licensors and authors of that
++ material by anyone who conveys the material (or modified versions of
++ it) with contractual assumptions of liability to the recipient, for
++ any liability that these contractual assumptions directly impose on
++ those licensors and authors.
++
++ All other non-permissive additional terms are considered "further
++restrictions" within the meaning of section 10. If the Program as you
++received it, or any part of it, contains a notice stating that it is
++governed by this License along with a term that is a further
++restriction, you may remove that term. If a license document contains
++a further restriction but permits relicensing or conveying under this
++License, you may add to a covered work material governed by the terms
++of that license document, provided that the further restriction does
++not survive such relicensing or conveying.
++
++ If you add terms to a covered work in accord with this section, you
++must place, in the relevant source files, a statement of the
++additional terms that apply to those files, or a notice indicating
++where to find the applicable terms.
++
++ Additional terms, permissive or non-permissive, may be stated in the
++form of a separately written license, or stated as exceptions;
++the above requirements apply either way.
++
++ 8. Termination.
++
++ You may not propagate or modify a covered work except as expressly
++provided under this License. Any attempt otherwise to propagate or
++modify it is void, and will automatically terminate your rights under
++this License (including any patent licenses granted under the third
++paragraph of section 11).
++
++ However, if you cease all violation of this License, then your
++license from a particular copyright holder is reinstated (a)
++provisionally, unless and until the copyright holder explicitly and
++finally terminates your license, and (b) permanently, if the copyright
++holder fails to notify you of the violation by some reasonable means
++prior to 60 days after the cessation.
++
++ Moreover, your license from a particular copyright holder is
++reinstated permanently if the copyright holder notifies you of the
++violation by some reasonable means, this is the first time you have
++received notice of violation of this License (for any work) from that
++copyright holder, and you cure the violation prior to 30 days after
++your receipt of the notice.
++
++ Termination of your rights under this section does not terminate the
++licenses of parties who have received copies or rights from you under
++this License. If your rights have been terminated and not permanently
++reinstated, you do not qualify to receive new licenses for the same
++material under section 10.
++
++ 9. Acceptance Not Required for Having Copies.
++
++ You are not required to accept this License in order to receive or
++run a copy of the Program. Ancillary propagation of a covered work
++occurring solely as a consequence of using peer-to-peer transmission
++to receive a copy likewise does not require acceptance. However,
++nothing other than this License grants you permission to propagate or
++modify any covered work. These actions infringe copyright if you do
++not accept this License. Therefore, by modifying or propagating a
++covered work, you indicate your acceptance of this License to do so.
++
++ 10. Automatic Licensing of Downstream Recipients.
++
++ Each time you convey a covered work, the recipient automatically
++receives a license from the original licensors, to run, modify and
++propagate that work, subject to this License. You are not responsible
++for enforcing compliance by third parties with this License.
++
++ An "entity transaction" is a transaction transferring control of an
++organization, or substantially all assets of one, or subdividing an
++organization, or merging organizations. If propagation of a covered
++work results from an entity transaction, each party to that
++transaction who receives a copy of the work also receives whatever
++licenses to the work the party's predecessor in interest had or could
++give under the previous paragraph, plus a right to possession of the
++Corresponding Source of the work from the predecessor in interest, if
++the predecessor has it or can get it with reasonable efforts.
++
++ You may not impose any further restrictions on the exercise of the
++rights granted or affirmed under this License. For example, you may
++not impose a license fee, royalty, or other charge for exercise of
++rights granted under this License, and you may not initiate litigation
++(including a cross-claim or counterclaim in a lawsuit) alleging that
++any patent claim is infringed by making, using, selling, offering for
++sale, or importing the Program or any portion of it.
++
++ 11. Patents.
++
++ A "contributor" is a copyright holder who authorizes use under this
++License of the Program or a work on which the Program is based. The
++work thus licensed is called the contributor's "contributor version".
++
++ A contributor's "essential patent claims" are all patent claims
++owned or controlled by the contributor, whether already acquired or
++hereafter acquired, that would be infringed by some manner, permitted
++by this License, of making, using, or selling its contributor version,
++but do not include claims that would be infringed only as a
++consequence of further modification of the contributor version. For
++purposes of this definition, "control" includes the right to grant
++patent sublicenses in a manner consistent with the requirements of
++this License.
++
++ Each contributor grants you a non-exclusive, worldwide, royalty-free
++patent license under the contributor's essential patent claims, to
++make, use, sell, offer for sale, import and otherwise run, modify and
++propagate the contents of its contributor version.
++
++ In the following three paragraphs, a "patent license" is any express
++agreement or commitment, however denominated, not to enforce a patent
++(such as an express permission to practice a patent or covenant not to
++sue for patent infringement). To "grant" such a patent license to a
++party means to make such an agreement or commitment not to enforce a
++patent against the party.
++
++ If you convey a covered work, knowingly relying on a patent license,
++and the Corresponding Source of the work is not available for anyone
++to copy, free of charge and under the terms of this License, through a
++publicly available network server or other readily accessible means,
++then you must either (1) cause the Corresponding Source to be so
++available, or (2) arrange to deprive yourself of the benefit of the
++patent license for this particular work, or (3) arrange, in a manner
++consistent with the requirements of this License, to extend the patent
++license to downstream recipients. "Knowingly relying" means you have
++actual knowledge that, but for the patent license, your conveying the
++covered work in a country, or your recipient's use of the covered work
++in a country, would infringe one or more identifiable patents in that
++country that you have reason to believe are valid.
++
++ If, pursuant to or in connection with a single transaction or
++arrangement, you convey, or propagate by procuring conveyance of, a
++covered work, and grant a patent license to some of the parties
++receiving the covered work authorizing them to use, propagate, modify
++or convey a specific copy of the covered work, then the patent license
++you grant is automatically extended to all recipients of the covered
++work and works based on it.
++
++ A patent license is "discriminatory" if it does not include within
++the scope of its coverage, prohibits the exercise of, or is
++conditioned on the non-exercise of one or more of the rights that are
++specifically granted under this License. You may not convey a covered
++work if you are a party to an arrangement with a third party that is
++in the business of distributing software, under which you make payment
++to the third party based on the extent of your activity of conveying
++the work, and under which the third party grants, to any of the
++parties who would receive the covered work from you, a discriminatory
++patent license (a) in connection with copies of the covered work
++conveyed by you (or copies made from those copies), or (b) primarily
++for and in connection with specific products or compilations that
++contain the covered work, unless you entered into that arrangement,
++or that patent license was granted, prior to 28 March 2007.
++
++ Nothing in this License shall be construed as excluding or limiting
++any implied license or other defenses to infringement that may
++otherwise be available to you under applicable patent law.
++
++ 12. No Surrender of Others' Freedom.
++
++ If conditions are imposed on you (whether by court order, agreement or
++otherwise) that contradict the conditions of this License, they do not
++excuse you from the conditions of this License. If you cannot convey a
++covered work so as to satisfy simultaneously your obligations under this
++License and any other pertinent obligations, then as a consequence you may
++not convey it at all. For example, if you agree to terms that obligate you
++to collect a royalty for further conveying from those to whom you convey
++the Program, the only way you could satisfy both those terms and this
++License would be to refrain entirely from conveying the Program.
++
++ 13. Use with the GNU Affero General Public License.
++
++ Notwithstanding any other provision of this License, you have
++permission to link or combine any covered work with a work licensed
++under version 3 of the GNU Affero General Public License into a single
++combined work, and to convey the resulting work. The terms of this
++License will continue to apply to the part which is the covered work,
++but the special requirements of the GNU Affero General Public License,
++section 13, concerning interaction through a network will apply to the
++combination as such.
++
++ 14. Revised Versions of this License.
++
++ The Free Software Foundation may publish revised and/or new versions of
++the GNU General Public License from time to time. Such new versions will
++be similar in spirit to the present version, but may differ in detail to
++address new problems or concerns.
++
++ Each version is given a distinguishing version number. If the
++Program specifies that a certain numbered version of the GNU General
++Public License "or any later version" applies to it, you have the
++option of following the terms and conditions either of that numbered
++version or of any later version published by the Free Software
++Foundation. If the Program does not specify a version number of the
++GNU General Public License, you may choose any version ever published
++by the Free Software Foundation.
++
++ If the Program specifies that a proxy can decide which future
++versions of the GNU General Public License can be used, that proxy's
++public statement of acceptance of a version permanently authorizes you
++to choose that version for the Program.
++
++ Later license versions may give you additional or different
++permissions. However, no additional obligations are imposed on any
++author or copyright holder as a result of your choosing to follow a
++later version.
++
++ 15. Disclaimer of Warranty.
++
++ THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
++APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
++HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
++OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
++THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
++PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
++IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
++ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
++
++ 16. Limitation of Liability.
++
++ IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
++WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
++THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
++GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
++USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
++DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
++PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
++EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
++SUCH DAMAGES.
++
++ 17. Interpretation of Sections 15 and 16.
++
++ If the disclaimer of warranty and limitation of liability provided
++above cannot be given local legal effect according to their terms,
++reviewing courts shall apply local law that most closely approximates
++an absolute waiver of all civil liability in connection with the
++Program, unless a warranty or assumption of liability accompanies a
++copy of the Program in return for a fee.
++
++ END OF TERMS AND CONDITIONS
++
++ How to Apply These Terms to Your New Programs
++
++ If you develop a new program, and you want it to be of the greatest
++possible use to the public, the best way to achieve this is to make it
++free software which everyone can redistribute and change under these terms.
++
++ To do so, attach the following notices to the program. It is safest
++to attach them to the start of each source file to most effectively
++state the exclusion of warranty; and each file should have at least
++the "copyright" line and a pointer to where the full notice is found.
++
++ <one line to give the program's name and a brief idea of what it does.>
++ Copyright (C) <year> <name of author>
++
++ This program is free software: you can redistribute it and/or modify
++ it under the terms of the GNU General Public License as published by
++ the Free Software Foundation, either version 3 of the License, or
++ (at your option) any later version.
++
++ This program is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ GNU General Public License for more details.
++
++ You should have received a copy of the GNU General Public License
++ along with this program. If not, see <http://www.gnu.org/licenses/>.
++
++Also add information on how to contact you by electronic and paper mail.
++
++ If the program does terminal interaction, make it output a short
++notice like this when it starts in an interactive mode:
++
++ <program> Copyright (C) <year> <name of author>
++ This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
++ This is free software, and you are welcome to redistribute it
++ under certain conditions; type `show c' for details.
++
++The hypothetical commands `show w' and `show c' should show the appropriate
++parts of the General Public License. Of course, your program's commands
++might be different; for a GUI interface, you would use an "about box".
++
++ You should also get your employer (if you work as a programmer) or school,
++if any, to sign a "copyright disclaimer" for the program, if necessary.
++For more information on this, and how to apply and follow the GNU GPL, see
++<http://www.gnu.org/licenses/>.
++
++ The GNU General Public License does not permit incorporating your program
++into proprietary programs. If your program is a subroutine library, you
++may consider it more useful to permit linking proprietary applications with
++the library. If this is what you want to do, use the GNU Lesser General
++Public License instead of this License. But first, please read
++<http://www.gnu.org/philosophy/why-not-lgpl.html>.
+diff --git a/ws/dissector.lua b/ws/dissector.lua
+new file mode 100644
+index 0000000..0431c67
+--- /dev/null
++++ b/ws/dissector.lua
+@@ -0,0 +1,306 @@
++-- Copyright (c) 2011, Robert G. Jakabosky <bobby@sharedrealm.com> All rights reserved.
++
++-- cache globals to local for speed.
++local format=string.format
++local tostring=tostring
++local tonumber=tonumber
++local sqrt=math.sqrt
++local pairs=pairs
++
++-- wireshark API globals
++local Pref = Pref
++local Proto = Proto
++local ProtoField = ProtoField
++local DissectorTable = DissectorTable
++local ByteArray = ByteArray
++local PI_MALFORMED = PI_MALFORMED
++local PI_ERROR = PI_ERROR
++
++-- zmq protocol example
++-- declare our protocol
++local zmq_proto = Proto("zmq","ZMQ","ZeroMQ Protocol")
++
++-- setup preferences
++zmq_proto.prefs["tcp_port_start"] =
++ Pref.string("TCP port range start", "5555", "First TCP port to decode as this protocol")
++zmq_proto.prefs["tcp_port_end"] =
++ Pref.string("TCP port range end", "5555", "Last TCP port to decode as this protocol")
++-- current preferences settings.
++local current_settings = {
++tcp_port_start = -1,
++tcp_port_end = -1,
++}
++
++-- setup protocol fields.
++zmq_proto.fields = {}
++local fds = zmq_proto.fields
++fds.frame = ProtoField.new("Frame", "zmq.frame", "FT_BYTES", nil, "BASE_NONE")
++fds.length = ProtoField.new("Frame Length", "zmq.frame.len", "FT_UINT64", nil, "BASE_DEC")
++fds.length8 = ProtoField.new("Frame 8bit Length", "zmq.frame.len8", "FT_UINT8", nil, "BASE_DEC")
++fds.length64 = ProtoField.new("Frame 64bit Length", "zmq.frame.len64", "FT_UINT64", nil, "BASE_DEC")
++fds.flags = ProtoField.new("Frame Flags", "zmq.frame.flags", "FT_UINT8", nil, "BASE_HEX", "0xFF")
++fds.flags_more = ProtoField.new("More", "zmq.frame.flags.more", "FT_UINT8", nil, "BASE_HEX", "0x01")
++fds.body = ProtoField.new("Frame body", "zmq.frame.body", "FT_BYTES", nil, "BASE_NONE")
++
++-- un-register zmq to handle tcp port range
++local function unregister_tcp_port_range(start_port, end_port)
++ if not start_port or start_port <= 0 or not end_port or end_port <= 0 then
++ return
++ end
++ local tcp_port_table = DissectorTable.get("tcp.port")
++ for port = start_port,end_port do
++ tcp_port_table:remove(port,zmq_proto)
++ end
++end
++
++-- register zmq to handle tcp port range
++local function register_tcp_port_range(start_port, end_port)
++ if not start_port or start_port <= 0 or not end_port or end_port <= 0 then
++ return
++ end
++ local tcp_port_table = DissectorTable.get("tcp.port")
++ for port = start_port,end_port do
++ tcp_port_table:add(port,zmq_proto)
++ end
++end
++
++-- handle preferences changes.
++function zmq_proto.init(arg1, arg2)
++ local old_start, old_end
++ local new_start, new_end
++ -- check if preferences have changed.
++ for pref_name,old_v in pairs(current_settings) do
++ local new_v = zmq_proto.prefs[pref_name]
++ if new_v ~= old_v then
++ if pref_name == "tcp_port_start" then
++ old_start = old_v
++ new_start = new_v
++ elseif pref_name == "tcp_port_end" then
++ old_end = old_v
++ new_end = new_v
++ end
++ -- save new value.
++ current_settings[pref_name] = new_v
++ end
++ end
++ -- un-register old port range
++ if old_start and old_end then
++ unregister_tcp_port_range(tonumber(old_start), tonumber(old_end))
++ end
++ -- register new port range.
++ if new_start and new_end then
++ register_tcp_port_range(tonumber(new_start), tonumber(new_end))
++ end
++end
++
++-- parse flag bits.
++local BITS = {
++ MORE = 0x01,
++ RESERVED = 0x7E,
++}
++local flag_names = {"MORE"}
++local bits_lookup = {}
++local bits_list = {
++ {},
++ {MORE = true},
++ {MORE = true, RESERVED = true},
++ {RESERVED = true},
++}
++local function parse_flags(flags)
++ return bits_lookup[flags] or bits_lookup[1]
++end
++
++-- make bits object
++local function make_bits(bits)
++ local proxy = newproxy(true)
++ local meta = getmetatable(proxy)
++ meta.__index = bits
++ meta.__tostring = function()
++ return bits.flags
++ end
++ -- combind bits into string description.
++ local flags = nil
++ for i=1,#flag_names do
++ local name = flag_names[i]
++ if bits[name] then
++ if flags then
++ flags = flags .. ',' .. name
++ else
++ flags = name
++ end
++ end
++ end
++ -- combind bits into one byte value.
++ local byte = 0x00
++ for k,v in pairs(bits) do
++ local bit = assert(BITS[k], "Invalid bit name.")
++ byte = byte + BITS[k]
++ end
++ bits.flags = flags or ''
++ bits.byte = byte
++ return proxy
++end
++-- make bits objects in bis_lookup
++for i=1,#bits_list do
++ local bits = bits_list[i]
++ bits = make_bits(bits)
++ bits_lookup[bits.byte] = bits
++end
++
++local function zmq_dissect_frame(buffer, pinfo, frame_tree, tap)
++ local rang,offset
++ -- Frame length
++ offset = 0
++ local len_off = offset
++ local len8_rang = buffer(offset,1)
++ local len_rang = len8_rang
++ local frame_len = len8_rang:uint()
++ -- 8bit length field
++ local ti = frame_tree:add(fds.length8, len8_rang)
++ ti:set_hidden()
++ offset = offset + 1
++ if frame_len == 255 then
++ local len64_rang = buffer(offset, 8)
++ len_rang = buffer(len_off, 9)
++ frame_len = tonumber(tostring(len64_rang:uint64()))
++ -- 64bit length field.
++ local ti = frame_tree:add(fds.length64, len64_rang)
++ ti:set_hidden()
++ offset = offset + 8
++ local ti = frame_tree:add(fds.length, len_rang)
++ ti:set_text(format("Frame Length: %d", frame_length))
++ else
++ frame_tree:add(fds.length, len_rang)
++ end
++ -- Frame flags
++ rang = buffer(offset,1)
++ local flags = rang:uint()
++ local flags_bits = parse_flags(flags)
++ local flags_list = flags_bits.flags
++ local flags_tree = frame_tree:add(fds.flags, rang)
++ flags_tree:set_text(format('Flags: 0x%02X (%s)', flags, flags_list))
++ flags_tree:add(fds.flags_more, rang)
++ offset = offset + 1
++ if flags_bits.MORE then
++ tap.more = tap.more + 1
++ else
++ -- if the 'more' flag is not set then this is the last frame in a message.
++ tap.msgs = tap.msgs + 1
++ end
++ -- Frame body
++ local body_len = frame_len - 1
++ local body = ''
++ if body_len > 0 then
++ tap.body_bytes = tap.body_bytes + body_len
++ rang = buffer(offset, body_len)
++ local ti = frame_tree:add_le(fds.body, rang)
++ if body_len <= 4 then
++ body = format("%08x", rang:uint())
++ else
++ body = tostring(rang)
++ end
++ ti:set_text(format("%s", body))
++ end
++ offset = offset + body_len
++ -- frame summary
++ if body_len > 0 then
++ if flags_bits.MORE then
++ frame_tree:set_text(format("Frame: [MORE] Body[%u]=%s", body_len, body))
++ else
++ frame_tree:set_text(format("Frame: Body[%u]=%s", body_len, body))
++ end
++ else
++ if flags_bits.MORE then
++ frame_tree:set_text(format("Frame: [MORE] No data"))
++ else
++ frame_tree:set_text(format("Frame: No data"))
++ end
++ end
++end
++
++local DESEGMENT_ONE_MORE_SEGMENT = 0x0fffffff
++local DESEGMENT_UNTIL_FIN = 0x0ffffffe
++
++-- packet dissector
++function zmq_proto.dissector(tvb,pinfo,tree)
++ local offset = 0
++ local tvb_length = tvb:len()
++ local reported_length = tvb:reported_len()
++ local length_remaining
++ local zmq_tree
++ local rang
++ local frames = 0
++ local tap = {}
++
++ tap.frames = 0
++ tap.msgs = 0
++ tap.more = 0
++ tap.body_bytes = 0
++
++ while(offset < reported_length and offset < tvb_length) do
++ length_remaining = tvb_length - offset
++ -- check for fixed part of PDU
++ if length_remaining < 2 then
++ pinfo.desegment_offset = offset
++ pinfo.desegment_len = DESEGMENT_ONE_MORE_SEGMENT
++ break
++ end
++ -- decode frame length
++ -- decode single byte frame length
++ rang = tvb(offset, 1)
++ local frame_len = rang:le_uint()
++ local pdu_len = frame_len + 1
++ if frame_len == 255 then
++ -- make sure there is enough bytes
++ if length_remaining < 10 then
++ pinfo.desegment_offset = offset
++ pinfo.desegment_len = DESEGMENT_ONE_MORE_SEGMENT
++ break
++ end
++ -- decode extra long frame length.
++ rang = tvb(offset + 1, 8)
++ frame_len = tonumber(tostring(rang:uint64()))
++ pdu_len = frame_len + 9
++ end
++ -- provide hints to tcp
++ if not pinfo.visited then
++ local remaining_bytes = reported_length - offset
++ if pdu_len > remaining_bytes then
++ pinfo.want_pdu_tracking = 2
++ pinfo.bytes_until_next_pdu = pdu_len - remaining_bytes
++ end
++ end
++ -- check if we need more bytes to dissect this frame.
++ if length_remaining < pdu_len then
++ pinfo.desegment_offset = offset
++ pinfo.desegment_len = (pdu_len - length_remaining)
++ break
++ end
++ -- dissect zmq frame
++ if not zmq_tree then
++ zmq_tree = tree:add(zmq_proto,tvb(),"ZMQ frames")
++ end
++ rang = tvb(offset, pdu_len)
++ local frame_tree = zmq_tree:add(fds.frame, rang)
++ zmq_dissect_frame(rang:tvb(), pinfo, frame_tree, tap)
++ frames = frames + 1
++ -- step to next frame.
++ local offset_before = offset
++ offset = offset + pdu_len
++ if offset < offset_before then break end
++ end
++ if zmq_tree then
++ zmq_tree:set_text(format("ZMQ frames=%u", frames))
++ end
++ if frames > 0 then
++ tap.frames = frames
++ pinfo.tap_data = tap
++ end
++ -- Info column
++ pinfo.cols.protocol = "ZMQ"
++ pinfo.cols.info = format('ZMQ frames=%u',frames)
++end
++
++-- register zmq to handle tcp ports 5550-5560
++register_tcp_port_range(5550,5560)
++
+diff --git a/ws/init.lua b/ws/init.lua
+new file mode 100644
+index 0000000..0282fba
+--- /dev/null
++++ b/ws/init.lua
+@@ -0,0 +1,16 @@
++
++local prequire = function(name)
++ local status, result1 = pcall(require, name)
++ if not status then
++ debug("Failed to load " .. name .. ": " .. result1)
++ end
++ return result1
++end
++
++prequire("zmq.ws.dissector")
++
++-- if running from wireshark, register all taps.
++if gui_enabled() then
++ prequire("zmq.ws.stats_tap")
++end
++
+diff --git a/ws/stats_tap.lua b/ws/stats_tap.lua
+new file mode 100644
+index 0000000..1d39f16
+--- /dev/null
++++ b/ws/stats_tap.lua
+@@ -0,0 +1,58 @@
++-- Copyright (c) 2011, Robert G. Jakabosky <bobby@sharedrealm.com> All rights reserved.
++
++local tap = require"zmq.ws.tap"
++
++local format = string.format
++
++local stats_tap_mt = {}
++stats_tap_mt.__index = stats_tap_mt
++
++function stats_tap_mt:packet(pinfo, tvb, tree, data)
++ -- count all ZeroMQ packets
++ self.count = self.count + 1
++ data = data or pinfo.tap_data
++ if not data then
++ return
++ end
++ -- frames
++ self.frames = self.frames + (data.frames or 0)
++ -- frames with more flag set
++ self.more = self.more + (data.more or 0)
++ -- whole messages.
++ self.msgs = self.msgs + (data.msgs or 0)
++ -- total bytes in frame bodies.
++ self.body_bytes = self.body_bytes + (data.body_bytes or 0)
++end
++
++function stats_tap_mt:draw()
++ return format([[
++ZeroMQ Packets: %d
++Frames: %d
++Messages: %d
++Flags: More: %d
++Payload bytes: %d
++]],
++ self.count,
++ self.frames,
++ self.msgs,
++ self.more,
++ self.body_bytes)
++end
++
++function stats_tap_mt:reset()
++ self.count = 0
++ self.frames = 0
++ self.msgs = 0
++ self.more = 0
++ self.body_bytes = 0
++end
++
++local function create_stats_tap()
++ local tap = setmetatable({}, stats_tap_mt)
++
++ tap:reset() -- initialize tap.
++ return tap, 'zmq', 'lua'
++end
++
++tap("ZeroMQ stats tap", create_stats_tap)
++
+diff --git a/ws/tap.lua b/ws/tap.lua
+new file mode 100644
+index 0000000..096332d
+--- /dev/null
++++ b/ws/tap.lua
+@@ -0,0 +1,84 @@
++-- Copyright (c) 2011, Robert G. Jakabosky <bobby@sharedrealm.com> All rights reserved.
++
++local gui_enabled = gui_enabled
++local register_menu = register_menu
++local MENU_TOOLS_UNSORTED = MENU_TOOLS_UNSORTED
++
++local win_instances = 0
++
++local function create_window_tap(name, create)
++ win_instances = win_instances + 1
++
++ local td, tap_filter, tap_type = create()
++
++ -- tap's output window.
++ local win = TextWindow.new(name .. " " .. win_instances)
++
++ -- this tap will be local to the menu_function that called it
++ local tap = Listener.new(tap_type, tap_filter)
++
++ -- callback to remove the tap when the text window closes
++ function remove_tap()
++ if tap and tap.remove then
++ tap:remove()
++ end
++ end
++
++ -- make sure the tap doesn't hang around after the window was closed
++ win:set_atclose(remove_tap)
++
++ -- this function will be called for every packet
++ function tap.packet(pinfo,tvb, tree, tapdata)
++ return td:packet(pinfo, tvb, tree, tapdata)
++ end
++
++ -- this function will be called once every few seconds to redraw the window
++ function tap.draw()
++ local text = td:draw()
++ win:set(text)
++ end
++
++ -- this function will be called at the end of the capture run.
++ function tap.reset()
++ return td:reset()
++ end
++end
++
++local function create_tshark_tap(name, create)
++
++ local td, tap_filter, tap_type = create()
++
++ -- this tap will be local to the menu_function that called it
++ local tap = Listener.new(tap_type, tap_filter)
++
++ -- this function will be called for every packet
++ function tap.packet(pinfo,tvb,tapdata)
++ return td:packet(pinfo, tvb, tapdata)
++ end
++
++ -- this function will be called once every few seconds to redraw the window
++ function tap.draw()
++ local text = td:draw()
++ debug(name .. " results:\n" .. text)
++ end
++
++ -- this function will be called at the end of the capture run.
++ function tap.reset()
++ return td:reset()
++ end
++end
++
++return function (name, create)
++ if gui_enabled() then
++ -- menu callback.
++ local create_tap = function()
++ create_window_tap(name, create)
++ end
++ -- register menu item if running from wireshark
++ register_menu(name, create_tap, MENU_TOOLS_UNSORTED)
++ else
++ -- we are running from tshark, create a non-gui tap now.
++ create_tshark_tap(name, create)
++ end
++end
++
+diff --git a/zmq.nobj.lua b/zmq.nobj.lua
+index 83c0aa5..3be6e76 100644
+--- a/zmq.nobj.lua
++++ b/zmq.nobj.lua
+@@ -23,110 +23,157 @@ set_variable_format "%s%d"
+
+ c_module "zmq" {
+ -- module settings.
++module_globals = true, -- support old code that doesn't do: local zmq = require"zmq"
+ use_globals = false,
+ hide_meta_info = true,
+ luajit_ffi = true,
+-
+-sys_include "string.h",
+-include "zmq.h",
++-- needed for functions exported from module.
++luajit_ffi_load_cmodule = true,
+
+ ffi_load {
+ "zmq", -- default lib name.
+ Windows = "libzmq", -- lib name for on windows.
+ },
+
+-c_source[[
+-/*
+- * 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;
+-#if defined(ETERM)
+- case ETERM:
+- return "closed";
+- break;
++sys_include "string.h",
++include "zmq.h",
++
++c_source "typedefs" [[
++/* detect zmq version */
++#define VERSION_2_0 1
++#define VERSION_2_1 0
++#define VERSION_2_2 0
++#define VERSION_3_0 0
++#if defined(ZMQ_VERSION_MAJOR)
++# if (ZMQ_VERSION_MAJOR == 2) && (ZMQ_VERSION_MINOR == 2)
++# undef VERSION_2_2
++# define VERSION_2_2 1
++# undef VERSION_2_1
++# define VERSION_2_1 1
++# endif
++# if (ZMQ_VERSION_MAJOR == 2) && (ZMQ_VERSION_MINOR == 1)
++# undef VERSION_2_1
++# define VERSION_2_1 1
++# endif
++# if (ZMQ_VERSION_MAJOR == 3)
++# undef VERSION_2_0
++# define VERSION_2_0 0
++# undef VERSION_3_0
++# define VERSION_3_0 1
++# endif
+ #endif
+- default:
+- break;
+- }
+- return zmq_strerror(err);
+-}
+
+-]],
++/* make sure ZMQ_DONTWAIT & ZMQ_NOBLOCK are both defined. */
++#ifndef ZMQ_DONTWAIT
++# define ZMQ_DONTWAIT ZMQ_NOBLOCK
++#endif
++#ifndef ZMQ_NOBLOCK
++# define ZMQ_NOBLOCK ZMQ_DONTWAIT
++#endif
+
+--- export helper function 'get_zmq_strerror' to FFI code.
+-ffi_export_function "const char *" "get_zmq_strerror" "()",
+-ffi_source[[
+-local C_get_zmq_strerror = get_zmq_strerror
+--- make nicer wrapper for exported error function.
+-local function get_zmq_strerror()
+- return ffi.string(C_get_zmq_strerror())
+-end
++/* make sure DEALER/ROUTER & XREQ/XREP are all defined. */
++#ifndef ZMQ_DEALER
++# define ZMQ_DEALER ZMQ_XREQ
++#endif
++#ifndef ZMQ_ROUTER
++# define ZMQ_ROUTER ZMQ_XREP
++#endif
++#ifndef ZMQ_XREQ
++# define ZMQ_XREQ ZMQ_DEALER
++#endif
++#ifndef ZMQ_XREP
++# define ZMQ_XREP ZMQ_ROUTER
++#endif
++
++#if VERSION_2_0
++# define ZMQ_POLL_MSEC 1000 // zmq_poll is usec
++#elif VERSION_3_0
++# define ZMQ_POLL_MSEC 1 // zmq_poll is msec
++# ifndef ZMQ_HWM
++# define ZMQ_HWM 1 // backwards compatibility
++# endif
++#endif
+ ]],
+
+ --
+ -- Module constants
+ --
+-constants {
+-MAX_VSM_SIZE = 30,
++export_definitions {
++MAX_VSM_SIZE = "ZMQ_MAX_VSM_SIZE",
+
+ -- message types
+-DELIMITER = 31,
+-VSM = 32,
++DELIMITER = "ZMQ_DELIMITER",
++VSM = "ZMQ_VSM",
+
+ -- message flags
+-MSG_MORE = 1,
+-MSG_SHARED = 128,
++MSG_MORE = "ZMQ_MSG_MORE",
++MSG_SHARED = "ZMQ_MSG_SHARED",
+
+ -- socket types
+-PAIR = 0,
+-PUB = 1,
+-SUB = 2,
+-REQ = 3,
+-REP = 4,
+-XREQ = 5,
+-XREP = 6,
+-PULL = 7,
+-PUSH = 8,
++PAIR = "ZMQ_PAIR",
++PUB = "ZMQ_PUB",
++SUB = "ZMQ_SUB",
++REQ = "ZMQ_REQ",
++REP = "ZMQ_REP",
++PULL = "ZMQ_PULL",
++PUSH = "ZMQ_PUSH",
++
++DEALER = "ZMQ_DEALER",
++ROUTER = "ZMQ_ROUTER",
++XREQ = "ZMQ_XREQ",
++XREP = "ZMQ_XREP",
++
++-- new 3.1 socket types
++XPUB = "ZMQ_XPUB",
++XSUB = "ZMQ_XSUB",
+
+ -- socket options
+-HWM = 1,
+-SWAP = 3,
+-AFFINITY = 4,
+-IDENTITY = 5,
+-SUBSCRIBE = 6,
+-UNSUBSCRIBE = 7,
+-RATE = 8,
+-RECOVERY_IVL = 9,
+-MCAST_LOOP = 10,
+-SNDBUF = 11,
+-RCVBUF = 12,
+-RCVMORE = 13,
+-FD = 14,
+-EVENTS = 15,
+-TYPE = 16,
+-LINGER = 17,
+-RECONNECT_IVL = 18,
+-BACKLOG = 19,
++HWM = "ZMQ_HWM",
++SWAP = "ZMQ_SWAP",
++AFFINITY = "ZMQ_AFFINITY",
++IDENTITY = "ZMQ_IDENTITY",
++SUBSCRIBE = "ZMQ_SUBSCRIBE",
++UNSUBSCRIBE = "ZMQ_UNSUBSCRIBE",
++RATE = "ZMQ_RATE",
++RECOVERY_IVL = "ZMQ_RECOVERY_IVL",
++MCAST_LOOP = "ZMQ_MCAST_LOOP",
++SNDBUF = "ZMQ_SNDBUF",
++RCVBUF = "ZMQ_RCVBUF",
++RCVMORE = "ZMQ_RCVMORE",
++FD = "ZMQ_FD",
++EVENTS = "ZMQ_EVENTS",
++TYPE = "ZMQ_TYPE",
++LINGER = "ZMQ_LINGER",
++RECONNECT_IVL = "ZMQ_RECONNECT_IVL",
++RECONNECT_IVL_MSEC= "ZMQ_RECONNECT_IVL_MSEC",
++BACKLOG = "ZMQ_BACKLOG",
++RECONNECT_IVL_MAX = "ZMQ_RECONNECT_IVL_MAX",
++MAXMSGSIZE = "ZMQ_MAXMSGSIZE",
++SNDHWM = "ZMQ_SNDHWM",
++RCVHWM = "ZMQ_RCVHWM",
++MULTICAST_HOPS = "ZMQ_MULTICAST_HOPS",
++RCVTIMEO = "ZMQ_RCVTIMEO",
++SNDTIMEO = "ZMQ_SNDTIMEO",
++RCVLABEL = "ZMQ_RCVLABEL",
+
+ -- send/recv flags
+-NOBLOCK = 1,
+-SNDMORE = 2,
++NOBLOCK = "ZMQ_NOBLOCK",
++DONTWAIT = "ZMQ_DONTWAIT",
++SNDMORE = "ZMQ_SNDMORE",
++SNDLABEL = "ZMQ_SNDLABEL",
+
+ -- poll events
+-POLLIN = 1,
+-POLLOUT = 2,
+-POLLERR = 4,
++POLLIN = "ZMQ_POLLIN",
++POLLOUT = "ZMQ_POLLOUT",
++POLLERR = "ZMQ_POLLERR",
++
++-- poll milliseconds.
++POLL_MSEC = "ZMQ_POLL_MSEC",
+
+ -- devices
+-STREAMER = 1,
+-FORWARDER = 2,
+-QUEUE = 3,
++STREAMER = "ZMQ_STREAMER",
++FORWARDER = "ZMQ_FORWARDER",
++QUEUE = "ZMQ_QUEUE",
+ },
+
+
+@@ -159,6 +206,7 @@ c_function "version" {
+ ]],
+ },
+ c_function "init" {
++ var_in{ "int", "io_threads?", default = "1" },
+ c_call "!ZMQ_Ctx *" "zmq_init" { "int", "io_threads" },
+ },
+ c_function "init_ctx" {
+@@ -174,15 +222,15 @@ c_function "init_ctx" {
+ ffi_source[[
+ local p_type = type(${ptr})
+ if p_type == 'userdata' then
+- ${ctx} = ffi.cast('void *', ${ptr});
+- elseif p_type == 'cdata' then
+- ${ctx} = ${ptr};
++ ${ctx} = ffi.cast('ZMQ_Ctx *', ${ptr});
++ elseif p_type == 'cdata' and ffi.istype('void *', ${ptr}) then
++ ${ctx} = ffi.cast('ZMQ_Ctx *', ${ptr});
+ else
+ return error("expected lightuserdata/cdata<void *>");
+ end
+ ]],
+ },
+-c_function "device" {
++c_function "device" { if_defs = "VERSION_2_0",
+ c_call "ZMQ_Error" "zmq_device"
+ { "int", "device", "ZMQ_Socket *", "insock", "ZMQ_Socket *", "outsock" },
+ },
+@@ -197,16 +245,5 @@ c_function "stopwatch_start" {
+ c_function "sleep" {
+ c_call "void" "zmq_sleep" { "int", "seconds_" },
+ },
+---
+--- This dump function is for getting a copy of the FFI-based bindings code and is
+--- only for debugging.
+---
+-c_function "dump_ffi" {
+- var_out{ "const char *", "ffi_code", has_length = true, },
+- c_source[[
+- ${ffi_code} = ${module_c_name}_ffi_lua_code;
+- ${ffi_code_len} = sizeof(${module_c_name}_ffi_lua_code) - 1;
+-]],
+-},
+ }
+