lemonlang 0.0.4

an experimental, modern, purely safe, programming language.
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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

use std::mem;

use crate::{checker::types::TypeId, report::throw_ir_build_error};

#[derive(Debug, Clone, PartialEq)]
pub enum BasicValue {
	Int(u64),
	Float(f64),
	String(String),
	Char(char),
	Bool(bool),
	Register(String), // register name
	None,
}

impl BasicValue {
	pub fn is_register(&self) -> bool {
		matches!(self, BasicValue::Register(_))
	}

	pub fn try_get_register(&self) -> Option<&str> {
		match self {
			BasicValue::Register(register) => Some(register),
			_ => None,
		}
	}
	pub fn as_str(&self) -> &str {
		match self {
			BasicValue::Register(register) => register,
			_ => throw_ir_build_error("not a valid register"),
		}
	}
}

#[derive(Debug, Clone)]
pub struct IrBasicValue {
	pub value: BasicValue,
	pub type_id: TypeId,
}

impl IrBasicValue {
	pub fn new(value: BasicValue, type_id: TypeId) -> Self {
		Self { value, type_id }
	}

	pub fn with_new_type(&mut self, type_id: TypeId) -> Self {
		Self { value: mem::take(&mut self.value), type_id }
	}

	pub fn get_type(&self) -> TypeId {
		self.type_id
	}

	pub fn get_value(&self) -> &BasicValue {
		&self.value
	}

	pub fn is_none(&self) -> bool {
		matches!(self.value, BasicValue::None)
	}

	pub fn is_int(&self) -> bool {
		matches!(self.value, BasicValue::Int(_))
	}

	pub fn is_float(&self) -> bool {
		matches!(self.value, BasicValue::Float(_))
	}

	pub fn is_string(&self) -> bool {
		matches!(self.value, BasicValue::String(_))
	}

	pub fn is_bool(&self) -> bool {
		matches!(self.value, BasicValue::Bool(_))
	}

	pub fn is_char(&self) -> bool {
		matches!(self.value, BasicValue::Char(_))
	}
	pub fn is_register(&self) -> bool {
		matches!(self.value, BasicValue::Register(_))
	}

	pub fn is_raw_value(&self) -> bool {
		self.is_int() || self.is_float() || self.is_string() || self.is_char() || self.is_bool()
	}
}

impl From<u64> for IrBasicValue {
	fn from(value: u64) -> Self {
		Self::new(BasicValue::Int(value), TypeId::I64)
	}
}

impl From<i64> for IrBasicValue {
	fn from(value: i64) -> Self {
		Self::new(BasicValue::Int(value as u64), TypeId::I32)
	}
}

impl From<usize> for IrBasicValue {
	fn from(value: usize) -> Self {
		Self::new(BasicValue::Int(value as u64), TypeId::I32)
	}
}
impl From<f64> for IrBasicValue {
	fn from(value: f64) -> Self {
		Self::new(BasicValue::Float(value), TypeId::F64)
	}
}
impl From<String> for IrBasicValue {
	fn from(value: String) -> Self {
		Self::new(BasicValue::String(value), TypeId::STR)
	}
}
impl From<char> for IrBasicValue {
	fn from(value: char) -> Self {
		Self::new(BasicValue::Char(value), TypeId::CHAR)
	}
}

impl From<bool> for IrBasicValue {
	fn from(value: bool) -> Self {
		Self::new(BasicValue::Bool(value), TypeId::BOOL)
	}
}

impl Default for BasicValue {
	fn default() -> Self {
		Self::None
	}
}

impl Default for IrBasicValue {
	fn default() -> Self {
		Self::new(BasicValue::None, TypeId::UNIT)
	}
}