jimtcl 0.1.0

Embed Jim Tcl in Rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

//! Jim Tcl errors.
use std::{ffi, os::raw::c_int};

use crate::sys;
use parse_display::Display;
use thiserror::Error;

/// Wrapper for Jim error codes.
#[derive(Debug, Display)]
#[repr(u32)]
pub enum ExitCode {
    Ok = sys::JIM_OK,
    Err = sys::JIM_ERR,
    Return = sys::JIM_RETURN,
    Break = sys::JIM_BREAK,
    Continue = sys::JIM_CONTINUE,
    Signal = sys::JIM_SIGNAL,
    Exit = sys::JIM_EXIT,
    #[display("format")]
    InvalidCode(u32),
}

impl From<u32> for ExitCode {
    fn from(value: u32) -> Self {
        match value {
            sys::JIM_OK => ExitCode::Ok,
            sys::JIM_ERR => ExitCode::Err,
            sys::JIM_RETURN => ExitCode::Return,
            sys::JIM_BREAK => ExitCode::Break,
            sys::JIM_CONTINUE => ExitCode::Continue,
            sys::JIM_SIGNAL => ExitCode::Signal,
            sys::JIM_EXIT => ExitCode::Exit,
            x => ExitCode::InvalidCode(x),
        }
    }
}

impl Into<c_int> for ExitCode {
    fn into(self) -> c_int {
        let ec: u32 = self.into();
        ec as c_int
    }
}

impl Into<u32> for ExitCode {
    fn into(self) -> u32 {
        match self {
            ExitCode::Ok => sys::JIM_OK,
            ExitCode::Err => sys::JIM_ERR,
            ExitCode::Return => sys::JIM_RETURN,
            ExitCode::Break => sys::JIM_BREAK,
            ExitCode::Continue => sys::JIM_CONTINUE,
            ExitCode::Signal => sys::JIM_SIGNAL,
            ExitCode::Exit => sys::JIM_EXIT,
            ExitCode::InvalidCode(c) => c,
        }
    }
}

/// Error type Jim Tcl results.
#[derive(Error, Debug)]
pub enum JimError {
    #[error("Tcl evaluation error: {0}")]
    Error(String),
    #[error("Tcl return code {0}")]
    OtherCode(ExitCode),
    #[error("Jim object is null")]
    NullObject,
    #[error("Input string has null character")]
    NullCharacter,
}

impl From<ffi::NulError> for JimError {
    fn from(_value: ffi::NulError) -> Self {
        JimError::NullCharacter
    }
}

/// Result of a Jim Tcl error.
pub type JimResult<T> = Result<T, JimError>;