adfeaeab49
Previously, on an internal panic, the Lua stack would be reset before panicking in an attempt to make sure that such panics would not cause stack leaks or leave the stack in an unknown state. Now, such panic handling is done in stack_guard and stack_err_guard instead, and this is for a few reasons: 1) The previous approach did NOT handle user triggered panics that were outside of `rlua`, such as a panic in a ToLua / FromLua implementation. This is especially bad since most other panics would be indicative of an internal bug anyway, so the utility of keeping `rlua` types usable after such panics was questionable. It is much more sensible to ensure that `rlua` types are usable after *user generated* panics. 2) Every entry point into `rlua` should be guarded by a stack_guard or stack_err_guard anyway, so this should restore the Lua stack on exiting back to user code in all cases. 3) The method of stack restoration no longer *clears* the stack, only resets it to what it previously was. This allows us, potentially, to keep values at the beginning of the Lua stack long term and know that panics will not clobber them. There may be a way of dramatically speeding up ref types by using a small static area at the beginning of the stack instead of only the registry, so this may be important.
114 lines
3.4 KiB
Rust
114 lines
3.4 KiB
Rust
use std::{slice, str};
|
|
|
|
use ffi;
|
|
use error::{Error, Result};
|
|
use util::{check_stack, stack_guard};
|
|
use types::LuaRef;
|
|
|
|
/// Handle to an internal Lua string.
|
|
///
|
|
/// Unlike Rust strings, Lua strings may not be valid UTF-8.
|
|
#[derive(Clone, Debug)]
|
|
pub struct String<'lua>(pub(crate) LuaRef<'lua>);
|
|
|
|
impl<'lua> String<'lua> {
|
|
/// Get a `&str` slice if the Lua string is valid UTF-8.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// # extern crate rlua;
|
|
/// # use rlua::{Lua, String, Result};
|
|
/// # fn try_main() -> Result<()> {
|
|
/// let lua = Lua::new();
|
|
/// let globals = lua.globals();
|
|
///
|
|
/// let version: String = globals.get("_VERSION")?;
|
|
/// assert!(version.to_str().unwrap().contains("Lua"));
|
|
///
|
|
/// let non_utf8: String = lua.eval(r#" "test\xff" "#, None)?;
|
|
/// assert!(non_utf8.to_str().is_err());
|
|
/// # Ok(())
|
|
/// # }
|
|
/// # fn main() {
|
|
/// # try_main().unwrap();
|
|
/// # }
|
|
/// ```
|
|
pub fn to_str(&self) -> Result<&str> {
|
|
str::from_utf8(self.as_bytes()).map_err(|e| Error::FromLuaConversionError {
|
|
from: "string",
|
|
to: "&str",
|
|
message: Some(e.to_string()),
|
|
})
|
|
}
|
|
|
|
/// Get the bytes that make up this string.
|
|
///
|
|
/// The returned slice will not contain the terminating nul byte, but will contain any nul
|
|
/// bytes embedded into the Lua string.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// # extern crate rlua;
|
|
/// # use rlua::{Lua, String};
|
|
/// # fn main() {
|
|
/// let lua = Lua::new();
|
|
///
|
|
/// let non_utf8: String = lua.eval(r#" "test\xff" "#, None).unwrap();
|
|
/// assert!(non_utf8.to_str().is_err()); // oh no :(
|
|
/// assert_eq!(non_utf8.as_bytes(), &b"test\xff"[..]);
|
|
/// # }
|
|
/// ```
|
|
pub fn as_bytes(&self) -> &[u8] {
|
|
let nulled = self.as_bytes_with_nul();
|
|
&nulled[..nulled.len() - 1]
|
|
}
|
|
|
|
/// Get the bytes that make up this string, including the trailing nul byte.
|
|
pub fn as_bytes_with_nul(&self) -> &[u8] {
|
|
let lua = self.0.lua;
|
|
unsafe {
|
|
stack_guard(lua.state, 0, || {
|
|
check_stack(lua.state, 1);
|
|
lua.push_ref(lua.state, &self.0);
|
|
rlua_assert!(
|
|
ffi::lua_type(lua.state, -1) == ffi::LUA_TSTRING,
|
|
"string ref is not string type"
|
|
);
|
|
|
|
let mut size = 0;
|
|
// This will not trigger a 'm' error, because the reference is guaranteed to be of
|
|
// string type
|
|
let data = ffi::lua_tolstring(lua.state, -1, &mut size);
|
|
|
|
ffi::lua_pop(lua.state, 1);
|
|
slice::from_raw_parts(data as *const u8, size + 1)
|
|
})
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<'lua> AsRef<[u8]> for String<'lua> {
|
|
fn as_ref(&self) -> &[u8] {
|
|
self.as_bytes()
|
|
}
|
|
}
|
|
|
|
// Lua strings are basically &[u8] slices, so implement PartialEq for anything resembling that.
|
|
//
|
|
// This makes our `String` comparable with `Vec<u8>`, `[u8]`, `&str`, `String` and `rlua::String`
|
|
// itself.
|
|
//
|
|
// The only downside is that this disallows a comparison with `Cow<str>`, as that only implements
|
|
// `AsRef<str>`, which collides with this impl. Requiring `AsRef<str>` would fix that, but limit us
|
|
// in other ways.
|
|
impl<'lua, T> PartialEq<T> for String<'lua>
|
|
where
|
|
T: AsRef<[u8]>,
|
|
{
|
|
fn eq(&self, other: &T) -> bool {
|
|
self.as_bytes() == other.as_ref()
|
|
}
|
|
}
|