Crate dukt

bindings for Duktape javascript engine

Initialize a context

    use dukt::Context;

    let mut ctx = Context::default();
    let x: u32 = ctx.eval("1+2").unwrap();
    assert_eq!(x, 3);

Add rust function binding

    use dukt::Context;
    use dukt_macros::dukt;

    let mut ctx = Context::default();
    #[dukt]
    fn native_adder(ctx: &mut Context) -> u32 {
        let n = ctx.stack_len();
        let mut res = 0;

        for i in 0..n {
            res += ctx.get_uint(i);
        }
        res
    }

    ctx.register_function("adder", NativeAdder);
    let res: u32 = ctx.eval("adder(2,3)").unwrap();
    assert_eq!(res, 5);

Push an object

    use dukt::{PushValue, PeekValue, Context};
    use dukt_macros::{dukt, Value};

    let mut ctx = Context::default();
    #[derive(Value)]
    #[dukt(Peek, Push, Methods("sumFields"))]
    struct Test {
        a: u32,
        b: u32,
    }

    impl Test {
        #[dukt(this = "Test")]
        fn sum_fields(&self) -> u32 {
            self.a + self.b
        }
    }

    let t = Test { a: 4, b: 2 };
    let obj_id = t.push_to(&mut ctx);
    ctx.push_string("sumFields");
    ctx.call_prop(obj_id as i32, 0);
    let sum = u32::peek_at(&mut ctx, -1).unwrap();
    assert_eq!(sum, 6);

Re-exports

pub use value::PeekValue;

pub use value::PushValue;

Modules

serialize

value

Structs

Context

Enums

Error

Traits

Function

Attribute Macros

dukt

Derive Macros

Value