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

use std::fmt;

use yolol_number::YololNumber;

use crate::types::{
    ast::expression::Expression,
    Token,
};

mod literal_value;
pub use literal_value::*;

#[derive(Debug, PartialEq, Clone)]
pub enum Value
{
    Group(Box<Expression>),
    LocalVar(String),
    DataField(String),
    NumberVal(YololNumber),
    StringVal(String)
}

impl fmt::Display for Value
{
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result
    {
        match self
        {
            Value::Group(expr) => write!(f, "({})", *expr),
            Value::LocalVar(string) => write!(f, "{}", string),
            Value::DataField(string) => write!(f, "{}", string),
            Value::NumberVal(num) => write!(f, "{}", num),
            Value::StringVal(string) => write!(f, "\"{}\"", string),
        }
    }
}

impl From<Token> for Value
{
    fn from(input: Token) -> Value
    {
        match input
        {
            Token::Identifier(ident) => {
                if let Some(':') = ident.chars().next()
                {
                    Value::DataField(ident)
                }
                else
                {
                    Value::LocalVar(ident)
                }
            },
            Token::StringToken(string) => Value::StringVal(string),
            Token::YololNum(num) => Value::NumberVal(num),

            _ => panic!("Invalid conversion from Token to Value!")
        }
    }
}