v0.5.1

Support cross compilation

.github/workflows/main.yml

@@ -32,10 +32,73 @@ jobs:
     - name: Build ${{ matrix.lua }} pkg-config
       if: ${{ matrix.os == 'ubuntu-18.04' && matrix.lua != 'lua54' }}
       run: |
-        sudo apt-get update -y
+        sudo apt-get update
         sudo apt-get install -y --no-install-recommends liblua5.3-dev liblua5.2-dev liblua5.1-0-dev libluajit-5.1-dev
         cargo build --release --features "${{ matrix.lua }}"
 
+  build_aarch64_cross_macos:
+    name: Cross-compile to aarch64-apple-darwin
+    runs-on: macos-11.0
+    needs: build
+    strategy:
+      matrix:
+        lua: [lua54, lua53, lua52, lua51, luajit]
+    steps:
+    - uses: actions/checkout@v2
+    - uses: actions-rs/toolchain@v1
+      with:
+        toolchain: nightly
+        target: aarch64-apple-darwin
+        override: true
+    - name: Cross-compile
+      run: cargo build --target aarch64-apple-darwin --features "${{ matrix.lua }} async send serialize vendored"
+
+  build_aarch64_cross_ubuntu:
+    name: Cross-compile to aarch64-unknown-linux-gnu
+    runs-on: ubuntu-18.04
+    needs: build
+    strategy:
+      matrix:
+        lua: [lua54, lua53, lua52, lua51, luajit]
+    steps:
+    - uses: actions/checkout@v2
+    - uses: actions-rs/toolchain@v1
+      with:
+        toolchain: nightly
+        target: aarch64-unknown-linux-gnu
+        override: true
+    - name: Install ARM compiler toolchain
+      run: |
+        sudo apt-get update
+        sudo apt-get install -y --no-install-recommends gcc-aarch64-linux-gnu libc6-dev-arm64-cross
+      shell: bash
+    - name: Cross-compile
+      run: cargo build --target aarch64-unknown-linux-gnu --features "${{ matrix.lua }} async send serialize vendored"
+      shell: bash
+
+  build_armv7_cross_ubuntu:
+    name: Cross-compile to armv7-unknown-linux-gnueabihf
+    runs-on: ubuntu-18.04
+    needs: build
+    strategy:
+      matrix:
+        lua: [lua54, lua53, lua52, lua51]
+    steps:
+    - uses: actions/checkout@v2
+    - uses: actions-rs/toolchain@v1
+      with:
+        toolchain: nightly
+        target: armv7-unknown-linux-gnueabihf
+        override: true
+    - name: Install ARM compiler toolchain
+      run: |
+        sudo apt-get update
+        sudo apt-get install -y --no-install-recommends gcc-arm-linux-gnueabihf libc-dev-armhf-cross
+      shell: bash
+    - name: Cross-compile
+      run: cargo build --target armv7-unknown-linux-gnueabihf --features "${{ matrix.lua }} async send serialize vendored"
+      shell: bash
+
   test:
     name: Test
     runs-on: ${{ matrix.os }}
@@ -94,7 +157,7 @@ jobs:
       shell: bash
 
   test_modules:
-    name: Test modules on Linux and macOS
+    name: Test modules
     runs-on: ${{ matrix.os }}
     needs: build
     strategy:

CHANGELOG.md

@@ -1,7 +1,14 @@
+## v0.5.1
+
+- Support cross compilation that should work well for vendored builds (including LuaJIT with some restrictions)
+- Fix numeric types conversion for 32bit Lua
+- Update tokio to 1.0 for async examples
+
 ## v0.5.0
 
 - Serde support under `serialize` feature flag.
 - Re-export `mlua_derive`.
+- impl `ToLua` and `FromLua` for `HashSet` and `BTreeSet`
 
 ## v0.4.2
 

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mlua"
-version = "0.5.0" # remember to update html_root_url and mlua_derive
+version = "0.5.1" # remember to update html_root_url and mlua_derive
 authors = ["Aleksandr Orlenko <zxteam@pm.me>", "kyren <catherine@chucklefish.org>"]
 edition = "2018"
 repository = "https://github.com/khvzak/mlua"
@@ -54,16 +54,16 @@ erased-serde = { version = "0.3", optional = true }
 cc = { version = "1.0" }
 pkg-config = { version = "0.3.17" }
 lua-src = { version = ">= 540.0.0, < 550.0.0", optional = true }
-luajit-src = { version = ">= 210.1.0, < 220.0.0", optional = true }
+luajit-src = { version = ">= 210.1.2, < 220.0.0", optional = true }
 
 [dev-dependencies]
 rustyline = "7.0"
 criterion = "0.3"
 trybuild = "1.0"
 futures = "0.3.5"
-hyper = "0.13"
-reqwest = { version = "0.10", features = ["json"] }
-tokio = { version = "0.2", features = ["full"] }
+hyper = { version = "0.14", features = ["client", "server"] }
+reqwest = { version = "0.11", features = ["json"] }
+tokio = { version = "1.0", features = ["full"] }
 futures-timer = "3.0"
 serde_json = "1.0"
 

README.md

@@ -141,11 +141,17 @@ rustflags = [
   "-C", "link-arg=-undefined",
   "-C", "link-arg=dynamic_lookup",
 ]
+
+[target.aarch64-apple-darwin]
+rustflags = [
+  "-C", "link-arg=-undefined",
+  "-C", "link-arg=dynamic_lookup",
+]
 ```
 On Linux you can build modules normally with `cargo build --release`.
 Vendored and non-vendored builds are supported for these OS.
 
-On Windows `vendored` mode is not supported since you need to link to a Lua dll.
+On Windows `vendored` mode for modules is not supported since you need to link to a Lua dll.
 Easiest way is to use either MinGW64 (as part of [MSYS2](https://github.com/msys2/msys2) package) with `pkg-config` or
 MSVC with `LUA_INC` / `LUA_LIB` / `LUA_LIB_NAME` environment variables.
 

build/main.rs

@@ -1,7 +1,8 @@
 #![allow(unreachable_code)]
 
 use std::env;
-use std::io::{Error, ErrorKind, Result};
+use std::fs::File;
+use std::io::{Error, ErrorKind, Result, Write};
 use std::path::{Path, PathBuf};
 use std::process::Command;
 
@@ -91,6 +92,105 @@ fn build_glue<P: AsRef<Path> + std::fmt::Debug>(include_path: &P) {
         .unwrap();
 }
 
+// When cross-compiling, we cannot use `build_glue` as we cannot run the generated
+// executable.  Instead, let's take a stab at synthesizing the likely values.
+// If you're cross-compiling and using a non-vendored library then there is a chance
+// that the values selected here may be incorrect, but we have no way to determine
+// that here.
+fn generate_glue() -> Result<()> {
+    let build_dir = PathBuf::from(env::var_os("OUT_DIR").unwrap());
+    let mut glue = File::create(build_dir.join("glue.rs"))?;
+    writeln!(
+        glue,
+        "/* This file was generated by build/main.rs; do not modify by hand */"
+    )?;
+    writeln!(glue, "use std::os::raw::*;")?;
+
+    writeln!(glue, "/* luaconf.h */")?;
+    let pointer_bit_width: usize = env::var("CARGO_CFG_TARGET_POINTER_WIDTH")
+        .unwrap()
+        .parse()
+        .unwrap();
+    writeln!(
+        glue,
+        "pub const LUA_EXTRASPACE: c_int = {} / 8;",
+        pointer_bit_width
+    )?;
+
+    // This is generally hardcoded to this size
+    writeln!(glue, "pub const LUA_IDSIZE: c_int = 60;")?;
+
+    // Unless the target is restricted, the defaults are 64 bit
+    writeln!(glue, "pub type LUA_NUMBER = c_double;")?;
+    writeln!(glue, "pub type LUA_INTEGER = i64;")?;
+    writeln!(glue, "pub type LUA_UNSIGNED = u64;")?;
+
+    writeln!(glue, "/* lua.h */")?;
+    let version = if cfg!(any(feature = "luajit", feature = "lua51")) {
+        (5, 1, 0)
+    } else if cfg!(feature = "lua52") {
+        (5, 2, 0)
+    } else if cfg!(feature = "lua53") {
+        (5, 3, 0)
+    } else if cfg!(feature = "lua54") {
+        (5, 4, 0)
+    } else {
+        unreachable!();
+    };
+    writeln!(
+        glue,
+        "pub const LUA_VERSION_NUM: c_int = {};",
+        (version.0 * 100) + version.1
+    )?;
+
+    let max_stack = if pointer_bit_width >= 32 {
+        1_000_000
+    } else {
+        15_000
+    };
+    writeln!(
+        glue,
+        "pub const LUA_REGISTRYINDEX: c_int = -{} - 1000;",
+        max_stack
+    )?;
+
+    // These two are only defined in lua 5.1
+    writeln!(glue, "pub const LUA_ENVIRONINDEX: c_int = -10001;")?;
+    writeln!(glue, "pub const LUA_GLOBALSINDEX: c_int = -10002;")?;
+
+    writeln!(glue, "/* lauxlib.h */")?;
+    // This is only defined in lua 5.3 and up, but we can always generate its value here,
+    // even if we don't use it.
+    // This matches the default definition in lauxlib.h
+    writeln!(glue, "pub const LUAL_NUMSIZES: c_int = std::mem::size_of::<LUA_INTEGER>() as c_int * 16 + std::mem::size_of::<LUA_NUMBER>() as c_int;")?;
+
+    writeln!(glue, "/* lualib.h */")?;
+    write!(
+        glue,
+        r#"
+#[cfg(feature = "luajit")]
+pub const LUA_BITLIBNAME: &str = "bit";
+#[cfg(not(feature = "luajit"))]
+pub const LUA_BITLIBNAME: &str = "bit32";
+
+pub const LUA_COLIBNAME: &str = "coroutine";
+pub const LUA_DBLIBNAME: &str = "debug";
+pub const LUA_IOLIBNAME: &str = "io";
+pub const LUA_LOADLIBNAME: &str = "package";
+pub const LUA_MATHLIBNAME: &str = "math";
+pub const LUA_OSLIBNAME: &str = "os";
+pub const LUA_STRLIBNAME: &str = "string";
+pub const LUA_TABLIBNAME: &str = "table";
+pub const LUA_UTF8LIBNAME: &str = "utf8";
+
+pub const LUA_JITLIBNAME: &str = "jit";
+pub const LUA_FFILIBNAME: &str = "ffi";
+"#
+    )?;
+
+    Ok(())
+}
+
 fn main() {
     #[cfg(not(any(
         feature = "lua54",
@@ -132,5 +232,9 @@ fn main() {
     );
 
     let include_dir = find::probe_lua();
-    build_glue(&include_dir);
+    if env::var("TARGET").unwrap() != env::var("HOST").unwrap() {
+        generate_glue().unwrap();
+    } else {
+        build_glue(&include_dir);
+    }
 }

examples/async_http_client.rs

@@ -2,8 +2,9 @@ use std::collections::HashMap;
 use std::sync::Arc;
 
 use bstr::BString;
-use hyper::{body::Body as HyperBody, Client as HyperClient};
-use tokio::{stream::StreamExt, sync::Mutex};
+use hyper::body::{Body as HyperBody, HttpBody as _};
+use hyper::Client as HyperClient;
+use tokio::sync::Mutex;
 
 use mlua::{Error, Lua, Result, UserData, UserDataMethods};
 
@@ -20,8 +21,8 @@ impl UserData for BodyReader {
     fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
         methods.add_async_method("read", |_, reader, ()| async move {
             let mut reader = reader.0.lock().await;
-            let bytes = reader.try_next().await.map_err(Error::external)?;
-            if let Some(bytes) = bytes {
+            if let Some(bytes) = reader.data().await {
+                let bytes = bytes.map_err(Error::external)?;
                 return Ok(Some(BString::from(bytes.as_ref())));
             }
             Ok(None)

examples/async_tcp_server.rs

@@ -1,4 +1,3 @@
-use std::net::Shutdown;
 use std::sync::Arc;
 
 use bstr::BString;
@@ -55,7 +54,7 @@ impl UserData for LuaTcpStream {
         });
 
         methods.add_async_method("close", |_, stream, ()| async move {
-            stream.0.lock().await.shutdown(Shutdown::Both)?;
+            stream.0.lock().await.shutdown().await?;
             Ok(())
         });
     }

src/conversion.rs

@@ -12,7 +12,7 @@ use crate::lua::Lua;
 use crate::string::String;
 use crate::table::Table;
 use crate::thread::Thread;
-use crate::types::{LightUserData, MaybeSend, Number};
+use crate::types::{LightUserData, MaybeSend};
 use crate::userdata::{AnyUserData, UserData};
 use crate::value::{FromLua, Nil, ToLua, Value};
 
@@ -345,7 +345,13 @@ macro_rules! lua_convert_float {
     ($x:ty) => {
         impl<'lua> ToLua<'lua> for $x {
             fn to_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
-                Ok(Value::Number(self as Number))
+                cast(self)
+                    .ok_or_else(|| Error::ToLuaConversionError {
+                        from: stringify!($x),
+                        to: "number",
+                        message: Some("out of range".to_string()),
+                    })
+                    .map(Value::Number)
             }
         }
 

src/ffi/glue/glue.c

@@ -225,12 +225,8 @@ int main(int argc, const char **argv) {
       // == luaconf.h ==========================================================
 
       RS_COMMENT("luaconf.h"),
-      RS_STR("LUA_PATH_DEFAULT", LUA_PATH_DEFAULT),
-      RS_STR("LUA_CPATH_DEFAULT", LUA_CPATH_DEFAULT),
-      RS_STR("LUA_DIRSEP", LUA_DIRSEP),
       RS_INT("LUA_EXTRASPACE", LUA_EXTRASPACE),
       RS_INT("LUA_IDSIZE", LUA_IDSIZE),
-      RS_INT("LUAL_BUFFERSIZE", LUAL_BUFFERSIZE),
       RS_TYPE("LUA_NUMBER",
               sizeof(LUA_NUMBER) > sizeof(float) ? "c_double" : "c_float"),
       RS_TYPE("LUA_INTEGER", rs_int_type(sizeof(LUA_INTEGER))),
@@ -244,8 +240,6 @@ int main(int argc, const char **argv) {
 
       RS_COMMENT("lua.h"),
       RS_INT("LUA_VERSION_NUM", LUA_VERSION_NUM),
-      RS_STR("LUA_VERSION", LUA_VERSION),
-      RS_STR("LUA_RELEASE", LUA_RELEASE),
       RS_INT("LUA_REGISTRYINDEX", LUA_REGISTRYINDEX),
 #if LUA_VERSION_NUM == 501
       RS_INT("LUA_ENVIRONINDEX", LUA_ENVIRONINDEX),

src/ffi/lua.rs

@@ -32,11 +32,9 @@ use std::ptr;
 
 use super::luaconf;
 
-pub use super::glue::{LUA_RELEASE, LUA_VERSION, LUA_VERSION_NUM};
-
-pub use super::glue::LUA_REGISTRYINDEX;
 #[cfg(any(feature = "lua51", feature = "luajit"))]
 pub use super::glue::{LUA_ENVIRONINDEX, LUA_GLOBALSINDEX};
+pub use super::glue::{LUA_REGISTRYINDEX, LUA_VERSION_NUM};
 
 #[cfg(not(feature = "luajit"))]
 pub const LUA_SIGNATURE: &[u8] = b"\x1bLua";

src/ffi/luaconf.rs

@@ -23,7 +23,6 @@
 
 //! Contains definitions from `luaconf.h`.
 
-pub use super::glue::LUAL_BUFFERSIZE;
 pub use super::glue::LUA_INTEGER;
 pub use super::glue::LUA_NUMBER;
 pub use super::glue::LUA_UNSIGNED;

src/lib.rs

@@ -70,7 +70,7 @@
 //! [`serde::Deserialize`]: https://docs.serde.rs/serde/de/trait.Deserialize.html
 
 // mlua types in rustdoc of other crates get linked to here.
-#![doc(html_root_url = "https://docs.rs/mlua/0.5.0")]
+#![doc(html_root_url = "https://docs.rs/mlua/0.5.1")]
 // Deny warnings inside doc tests / examples. When this isn't present, rustdoc doesn't show *any*
 // warnings at all.
 #![doc(test(attr(deny(warnings))))]

src/serde/de.rs

@@ -20,8 +20,8 @@ impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
         match self.0 {
             Value::Nil => visitor.visit_unit(),
             Value::Boolean(b) => visitor.visit_bool(b),
-            Value::Integer(i) => visitor.visit_i64(i),
-            Value::Number(n) => visitor.visit_f64(n),
+            Value::Integer(i) => visitor.visit_i64(i.into()),
+            Value::Number(n) => visitor.visit_f64(n.into()),
             Value::String(s) => match s.to_str() {
                 Ok(s) => visitor.visit_str(s),
                 Err(_) => visitor.visit_bytes(s.as_bytes()),

src/serde/ser.rs

@@ -8,18 +8,18 @@ use crate::ffi;
 use crate::lua::Lua;
 use crate::string::String;
 use crate::table::Table;
-use crate::types::{Integer, Number};
+use crate::types::Integer;
 use crate::util::{assert_stack, protect_lua, StackGuard};
-use crate::value::Value;
+use crate::value::{ToLua, Value};
 
 /// A struct for serializing Rust values into Lua values.
 pub struct Serializer<'lua>(pub &'lua Lua);
 
-macro_rules! lua_serialize_integer {
+macro_rules! lua_serialize_number {
     ($name:ident, $t:ty) => {
         #[inline]
         fn $name(self, value: $t) -> Result<Value<'lua>> {
-            Ok(Value::Integer(value as Integer))
+            value.to_lua(self.0)
         }
     };
 }
@@ -43,28 +43,17 @@ impl<'lua> ser::Serializer for Serializer<'lua> {
         Ok(Value::Boolean(value))
     }
 
-    lua_serialize_integer!(serialize_i8, i8);
-    lua_serialize_integer!(serialize_u8, u8);
-    lua_serialize_integer!(serialize_i16, i16);
-    lua_serialize_integer!(serialize_u16, u16);
-    lua_serialize_integer!(serialize_i32, i32);
-    lua_serialize_integer!(serialize_u32, u32);
-    lua_serialize_integer!(serialize_u64, u64);
+    lua_serialize_number!(serialize_i8, i8);
+    lua_serialize_number!(serialize_u8, u8);
+    lua_serialize_number!(serialize_i16, i16);
+    lua_serialize_number!(serialize_u16, u16);
+    lua_serialize_number!(serialize_i32, i32);
+    lua_serialize_number!(serialize_u32, u32);
+    lua_serialize_number!(serialize_i64, i64);
+    lua_serialize_number!(serialize_u64, u64);
 
-    #[inline]
-    fn serialize_i64(self, value: i64) -> Result<Value<'lua>> {
-        Ok(Value::Integer(value))
-    }
-
-    #[inline]
-    fn serialize_f32(self, value: f32) -> Result<Value<'lua>> {
-        Ok(Value::Number(value as Number))
-    }
-
-    #[inline]
-    fn serialize_f64(self, value: f64) -> Result<Value<'lua>> {
-        Ok(Value::Number(value))
-    }
+    lua_serialize_number!(serialize_f32, f32);
+    lua_serialize_number!(serialize_f64, f64);
 
     #[inline]
     fn serialize_char(self, value: char) -> Result<Value<'lua>> {

src/value.rs

@@ -125,8 +125,8 @@ impl<'lua> Serialize for Value<'lua> {
         match self {
             Value::Nil => serializer.serialize_unit(),
             Value::Boolean(b) => serializer.serialize_bool(*b),
-            Value::Integer(i) => serializer.serialize_i64(*i),
-            Value::Number(n) => serializer.serialize_f64(*n),
+            Value::Integer(i) => serializer.serialize_i64((*i).into()),
+            Value::Number(n) => serializer.serialize_f64((*n).into()),
             Value::String(s) => s.serialize(serializer),
             Value::Table(t) => t.serialize(serializer),
             Value::UserData(ud) => ud.serialize(serializer),