little 0.3.0

Little interpreter designed as fast template backend.
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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

extern crate little;

use std::collections::HashMap;
use std::io::{ Read, Write };
use std::fmt;

use little::*;
use little::interpreter::Interpreter;

/// Simple value implementation.
/// You can provide your own value implementation for interpreter,
/// it is generic.
#[derive(Debug, Clone, Eq, PartialEq, PartialOrd)]
pub enum Value {
    Null,
    Str(String)
}

/// One requirement: this trait needs to be implemented for it.
impl LittleValue for Value { }

/// Implement hashing to fingerprint so that values can be compared using fingerprints.
/// Otherwise Little will treat all values as separate.
impl IdentifyValue for Value {
    fn identify_value(&self) -> Option<Fingerprint> {
        None
    }

    fn hash_value<H: Sha1Hasher>(&self, _hasher: &mut H) -> Result<(), ()> {
        Err(())
    }
}

/// And also requires Default trait.
impl Default for Value {
    fn default() -> Value {
        Value::Null
    }
}

/// And Display trait.
impl fmt::Display for Value {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            Value::Null => Ok(()),
            Value::Str(ref s) => write!(f, "{}", s),
        }
    }
}

/// Concatenates "Hello" and "World" and prints "Hello World"
fn main() {
    // Function that converts two values to strings and joins them.
    // This function expects to receive 2 arguments.
    // When generating instructions you should take care of that.
    let join = |args: &[Value]| {
        Ok(Value::Str(format!("{} {}", args[0], args[1])))
    };

    // Functions that can be called from template.
    let mut funs = HashMap::<&'static str, &Function<Value>>::new();
    funs.insert("join", &join);

    // Create new template with instructions and constants.
    let template = Template::empty()
        .with_instructions(vec![
            // Push constant 0 to stack. It is mapped to "Hello" in this template.
            Instruction::Push { location: Mem::Const(Constant(0)) },
            // Push template parameter 1 to stack. It will be received on the "run" call.
            Instruction::Push { location: Mem::Parameters },
            // Call function mapped to 0 with 2 arguments and put the return value in stack.
            Instruction::Call { call: Call(0), argc: 2, push_result_to_stack: true },
            // Result is on the stack, output the stack top.
            Instruction::Output { location: Mem::StackTop1 },
        ])
        // Map "join" function to 0. Actual function will be received when interpreter is
        // constructed.
        .with_call("join", Call(0))
        // Map constant "Hello" to 0.
        .with_constant(Constant(0), Value::Str("Hello".into()));

    let mut i = Interpreter::new();

    // Create the processor for this template and map its functions to function list.
    // It would fail if some functions are not found.
    let p = i.build("", template, &funs).unwrap();

    // Run template with parameters and print the output.
    let mut output = String::new();
    p.execute(
        Value::Str("World".into())
    )
        .read_to_string(&mut output)
        .unwrap();

    println!("{}", output);
}