trion 0.7.2

Trion is an assembler designed to be used with the Raspberry Pico (RP2040) microcontroller.
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
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
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166

use super::*;
	
macro_rules!expect
{
	($t:ident, $want:pat, {$($then:tt)*}) =>
	{
		match $t.next()
		{
			None => panic!("end of token stream"),
			Some(Ok($want)) => {$($then)*},
			Some(Ok(v)) => panic!("unexpected output {v:?}"),
			Some(Err(e)) => panic!("unexpected error {e}"),
		}
	};
}

#[test]
fn whitespace()
{
	let mut t = Tokenizer::new("  \t\t\n\t \n  \r\n  \t ".as_bytes());
	assert!(t.next().is_none());
	assert_eq!((t.get_line(), t.get_column()), (4, 5));
}

#[test]
fn unicode()
{
	let mut t = Tokenizer::new(b"\n\tevil: \x83");
	expect!(t, Positioned{value: TokenValue::Identifier(s), ..}, {assert_eq!(s, "evil");});
	expect!(t, Positioned{value: TokenValue::LabelMark, ..}, {});
	assert_eq!(t.next().unwrap().unwrap_err().value, TokenErrorKind::BadUnicode);
	assert_eq!((t.get_line(), t.get_column()), (2, 8));
}

#[test]
fn comments()
{
	let mut t = Tokenizer::new("// hello world\n\n/*\ncomment\n// comment */".as_bytes());
	assert!(t.next().is_none());
	assert_eq!((t.get_line(), t.get_column()), (5, 14));
	let mut t = Tokenizer::new("\t// hello world".as_bytes());
	assert!(t.next().is_none());
	assert_eq!((t.get_line(), t.get_column()), (1, 16));
	let mut t = Tokenizer::new("// hello world\n".as_bytes());
	assert!(t.next().is_none());
	assert_eq!((t.get_line(), t.get_column()), (2, 1));
}

#[test]
fn numbers()
{
	let mut t = Tokenizer::new("0 0000 1 9 10 11 19 100 0o100 0x100 0b100 0".as_bytes());
	expect!(t, Positioned{value: TokenValue::Number(Number::Integer(n)), ..}, {assert_eq!(n, 0);});
	expect!(t, Positioned{value: TokenValue::Number(Number::Integer(n)), ..}, {assert_eq!(n, 0);});
	expect!(t, Positioned{value: TokenValue::Number(Number::Integer(n)), ..}, {assert_eq!(n, 1);});
	expect!(t, Positioned{value: TokenValue::Number(Number::Integer(n)), ..}, {assert_eq!(n, 9);});
	expect!(t, Positioned{value: TokenValue::Number(Number::Integer(n)), ..}, {assert_eq!(n, 10);});
	expect!(t, Positioned{value: TokenValue::Number(Number::Integer(n)), ..}, {assert_eq!(n, 11);});
	expect!(t, Positioned{value: TokenValue::Number(Number::Integer(n)), ..}, {assert_eq!(n, 19);});
	expect!(t, Positioned{value: TokenValue::Number(Number::Integer(n)), ..}, {assert_eq!(n, 100);});
	expect!(t, Positioned{value: TokenValue::Number(Number::Integer(n)), ..}, {assert_eq!(n, 0o100);});
	expect!(t, Positioned{value: TokenValue::Number(Number::Integer(n)), ..}, {assert_eq!(n, 0x100);});
	expect!(t, Positioned{value: TokenValue::Number(Number::Integer(n)), ..}, {assert_eq!(n, 0b100);});
	expect!(t, Positioned{value: TokenValue::Number(Number::Integer(n)), ..}, {assert_eq!(n, 0);});
	assert!(t.next().is_none());
	
	assert_eq!(Tokenizer::new("0x".as_bytes()).next().unwrap().unwrap_err().value, TokenErrorKind::BadNumber);
	assert_eq!(Tokenizer::new("0x".as_bytes()).next().unwrap().unwrap_err().value, TokenErrorKind::BadNumber);
	assert_eq!(Tokenizer::new("0xz".as_bytes()).next().unwrap().unwrap_err().value, TokenErrorKind::BadNumber);
	assert_eq!(Tokenizer::new("0bz".as_bytes()).next().unwrap().unwrap_err().value, TokenErrorKind::BadNumber);
}

#[test]
fn chars()
{
	let mut t = Tokenizer::new("' '   'a' '\t' '\\t' '\\n' '\\r'".as_bytes());
	expect!(t, Positioned{value: TokenValue::Number(Number::Integer(n)), ..}, {assert_eq!(n, ' ' as i64);});
	expect!(t, Positioned{value: TokenValue::Number(Number::Integer(n)), ..}, {assert_eq!(n, 'a' as i64);});
	expect!(t, Positioned{value: TokenValue::Number(Number::Integer(n)), ..}, {assert_eq!(n, '\t' as i64);});
	expect!(t, Positioned{value: TokenValue::Number(Number::Integer(n)), ..}, {assert_eq!(n, '\t' as i64);});
	expect!(t, Positioned{value: TokenValue::Number(Number::Integer(n)), ..}, {assert_eq!(n, '\n' as i64);});
	expect!(t, Positioned{value: TokenValue::Number(Number::Integer(n)), ..}, {assert_eq!(n, '\r' as i64);});
	assert!(t.next().is_none());
	
	assert_eq!(Tokenizer::new("'".as_bytes()).next().unwrap().unwrap_err().value, TokenErrorKind::BadCharacter);
	assert_eq!(Tokenizer::new("'a".as_bytes()).next().unwrap().unwrap_err().value, TokenErrorKind::BadCharacter);
	assert_eq!(Tokenizer::new("'aa'".as_bytes()).next().unwrap().unwrap_err().value, TokenErrorKind::BadCharacter);
	assert_eq!(Tokenizer::new("''".as_bytes()).next().unwrap().unwrap_err().value, TokenErrorKind::BadCharacter);
}

#[test]
fn identifiers()
{
	let mut t = Tokenizer::new("hello _world /*nope*/ te$Tw@rd".as_bytes());
	expect!(t, Positioned{value: TokenValue::Identifier(s), ..}, {assert_eq!(s, "hello");});
	expect!(t, Positioned{value: TokenValue::Identifier(s), ..}, {assert_eq!(s, "_world");});
	expect!(t, Positioned{value: TokenValue::Identifier(s), ..}, {assert_eq!(s, "te$Tw@rd");});
	assert!(t.next().is_none());
	
	let mut t = Tokenizer::new("keyäöüword".as_bytes());
	expect!(t, Positioned{value: TokenValue::Identifier(s), ..}, {assert_eq!(s, "key");});
	assert_eq!(t.next().unwrap().unwrap_err().value, TokenErrorKind::Unexpected('ä'));
	assert!(t.next().is_none());
}

#[test]
fn symbols()
{
	let mut t = Tokenizer::new("/,;:.+-*!&|^<<>>()[]{}".as_bytes());
	expect!(t, Positioned{value: TokenValue::Divide, ..}, {});
	expect!(t, Positioned{value: TokenValue::Separator, ..}, {});
	expect!(t, Positioned{value: TokenValue::Terminator, ..}, {});
	expect!(t, Positioned{value: TokenValue::LabelMark, ..}, {});
	expect!(t, Positioned{value: TokenValue::DirectiveMark, ..}, {});
	expect!(t, Positioned{value: TokenValue::Plus, ..}, {});
	expect!(t, Positioned{value: TokenValue::Minus, ..}, {});
	expect!(t, Positioned{value: TokenValue::Multiply, ..}, {});
	expect!(t, Positioned{value: TokenValue::Not, ..}, {});
	expect!(t, Positioned{value: TokenValue::BitAnd, ..}, {});
	expect!(t, Positioned{value: TokenValue::BitOr, ..}, {});
	expect!(t, Positioned{value: TokenValue::BitXor, ..}, {});
	expect!(t, Positioned{value: TokenValue::LeftShift, ..}, {});
	expect!(t, Positioned{value: TokenValue::RightShift, ..}, {});
	expect!(t, Positioned{value: TokenValue::BeginGroup, ..}, {});
	expect!(t, Positioned{value: TokenValue::EndGroup, ..}, {});
	expect!(t, Positioned{value: TokenValue::BeginAddr, ..}, {});
	expect!(t, Positioned{value: TokenValue::EndAddr, ..}, {});
	expect!(t, Positioned{value: TokenValue::BeginSeq, ..}, {});
	expect!(t, Positioned{value: TokenValue::EndSeq, ..}, {});
	assert!(t.next().is_none());
}

#[test]
fn strings()
{
	let mut t = Tokenizer::new(r#" ""  "hello world" "\0\r\n" "a\u{62}c" "#.as_bytes());
	expect!(t, Positioned{value: TokenValue::String(s), ..}, {assert_eq!(s.as_ref(), "")});
	expect!(t, Positioned{value: TokenValue::String(s), ..}, {assert_eq!(s.as_ref(), "hello world")});
	expect!(t, Positioned{value: TokenValue::String(s), ..}, {assert_eq!(s.as_ref(), "\0\r\n")});
	expect!(t, Positioned{value: TokenValue::String(s), ..}, {assert_eq!(s.as_ref(), "abc")});
	assert!(t.next().is_none());
}

#[test]
fn instructions()
{
	let mut t = Tokenizer::new("LDR R7, [R0 + 0x24]; // read the thing from somewhere".as_bytes());
	expect!(t, Positioned{value: TokenValue::Identifier(s), ..}, {assert_eq!(s, "LDR");});
	expect!(t, Positioned{value: TokenValue::Identifier(s), ..}, {assert_eq!(s, "R7");});
	expect!(t, Positioned{value: TokenValue::Separator, ..}, {});
	expect!(t, Positioned{value: TokenValue::BeginAddr, ..}, {});
	expect!(t, Positioned{value: TokenValue::Identifier(s), ..}, {assert_eq!(s, "R0");});
	expect!(t, Positioned{value: TokenValue::Plus, ..}, {});
	expect!(t, Positioned{value: TokenValue::Number(Number::Integer(n)), ..}, {assert_eq!(n, 0x24);});
	expect!(t, Positioned{value: TokenValue::EndAddr, ..}, {});
	expect!(t, Positioned{value: TokenValue::Terminator, ..}, {});
	assert!(t.next().is_none());
	
	let mut t = Tokenizer::new("SUBS R0, 'A'; // free comparison < 'A'".as_bytes());
	expect!(t, Positioned{value: TokenValue::Identifier(s), ..}, {assert_eq!(s, "SUBS");});
	expect!(t, Positioned{value: TokenValue::Identifier(s), ..}, {assert_eq!(s, "R0");});
	expect!(t, Positioned{value: TokenValue::Separator, ..}, {});
	expect!(t, Positioned{value: TokenValue::Number(Number::Integer(n)), ..}, {assert_eq!(n, 'A' as i64);});
	expect!(t, Positioned{value: TokenValue::Terminator, ..}, {});
	assert!(t.next().is_none());
}