FFI中的错误处理

说明

在像C语言这种，错误是用返回码表示的。然而，Rust的类型系统支持通过一个完整的类型来提供更加丰富的错误信息。

下面的实践展示了错误代码的不同类型，以及如何在使用层面上去暴露它们：

  1. 扁平的枚举（译者注：无实际的成员数据）转换成整型并且作为错误码返回。
  2. 结构体枚举应该被转换为一个整型错误码和一个包含详细错误信息的字符串。
  3. 自定义错误类型应该被转换为C语言标准下的表示类型。

代码示例

扁平枚举

  1. enum DatabaseError {
  2.     IsReadOnly = 1, // user attempted a write operation
  3.     IOError = 2, // user should read the C errno() for what it was
  4.     FileCorrupted = 3, // user should run a repair tool to recover it
  5. }
  7. impl From<DatabaseError> for libc::c_int {
  8.     fn from(e: DatabaseError) -> libc::c_int {
  9.         (e as i8).into()
  10.     }
  11. }

结构体枚举

  1. pub mod errors {
  2.     enum DatabaseError {
  3.         IsReadOnly,
  4.         IOError(std::io::Error),
  5.         FileCorrupted(String), // message describing the issue
  6.     }
  8.     impl From<DatabaseError> for libc::c_int {
  9.         fn from(e: DatabaseError) -> libc::c_int {
  10.             match e {
  11.                 DatabaseError::IsReadOnly => 1,
  12.                 DatabaseError::IOError(_) => 2,
  13.                 DatabaseError::FileCorrupted(_) => 3,
  14.             }
  15.         }
  16.     }
  17. }
  19. pub mod c_api {
  20.     use super::errors::DatabaseError;
  22.     #[no_mangle]
  23.     pub extern "C" fn db_error_description(
  24.         e: *const DatabaseError
  25.         ) -> *mut libc::c_char {
  27.         let error: &DatabaseError = unsafe {
  28.             // SAFETY: pointer lifetime is greater than the current stack frame
  29.             &*e
  30.         };
  32.         let error_str: String = match error {
  33.             DatabaseError::IsReadOnly => {
  34.                 format!("cannot write to read-only database");
  35.             }
  36.             DatabaseError::IOError(e) => {
  37.                 format!("I/O Error: {}", e);
  38.             }
  39.             DatabaseError::FileCorrupted(s) => {
  40.                 format!("File corrupted, run repair: {}", &s);
  41.             }
  42.         };
  44.         let c_error = unsafe {
  45.             // SAFETY: copying error_str to an allocated buffer with a NUL
  46.             // character at the end
  47.             let mut malloc: *mut u8 = libc::malloc(error_str.len() + 1) as *mut _;
  49.             if malloc.is_null() {
  50.                 return std::ptr::null_mut();
  51.             }
  53.             let src = error_str.as_bytes().as_ptr();
  55.             std::ptr::copy_nonoverlapping(src, malloc, error_str.len());
  57.             std::ptr::write(malloc.add(error_str.len()), 0);
  59.             malloc as *mut libc::c_char
  60.         };
  62.         c_error
  63.     }
  64. }

自定义错误类型

  1. struct ParseError {
  2.     expected: char,
  3.     line: u32,
  4.     ch: u16
  5. }
  7. impl ParseError { /* ... */ }
  9. /* Create a second version which is exposed as a C structure */
  10. #[repr(C)]
  11. pub struct parse_error {
  12.     pub expected: libc::c_char,
  13.     pub line: u32,
  14.     pub ch: u16
  15. }
  17. impl From<ParseError> for parse_error {
  18.     fn from(e: ParseError) -> parse_error {
  19.         let ParseError { expected, line, ch } = e;
  20.         parse_error { expected, line, ch }
  21.     }
  22. }

优点

这样能确保其他语言能够正确访问错误信息，并且不用为此改动Rust代码的API。（译者注：相当于在错误处理时再封装一层，返回最简单的整型和字符串作为错误信息表示）

缺点

这样多写了很多代码，并且有些类型不能很容易地转换成C语言的标准。