hush 0.1.0

Hush is a unix shell scripting language based on the Lua 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
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
167
168
169
170

use super::{Cursor, Error, Literal, Root, SourcePos, State, Token, TokenKind, Transition};


/// The state for lexing byte literals.
#[derive(Debug)]
pub(super) struct ByteLiteral {
	/// The parsed value, if any.
	value: Option<u8>,
	/// The position of the current escape sequence, if any.
	escaping: Option<(usize, SourcePos)>,
	/// The position of the literal.
	pos: SourcePos,
}


impl ByteLiteral {
	pub fn at(cursor: &Cursor) -> Self {
		Self { value: None, escaping: None, pos: cursor.pos() }
	}


	pub fn visit(mut self, cursor: &Cursor) -> Transition {
		match (&self, cursor.peek()) {
			// EOF while scanning a literal is always an error.
			(_, None) => Transition::error(Root, Error::unexpected_eof(cursor.pos())),

			// Closing quote.
			(&Self { value: Some(c), .. }, Some(b'\'')) => Transition::produce(
				Root,
				Token {
					kind: TokenKind::Literal(Literal::Byte(c)),
					pos: self.pos,
				},
			),

			// If a value has already been scanned (including incorrect escape sequences). There
			// should be no further characters except for the closing quote.
			(&Self { value: Some(_), .. }, Some(c)) => {
				Transition::error(self, Error::unexpected(c, cursor.pos()))
			}

			// Escaped character.
			(&Self { escaping: Some((offset, pos)), .. }, Some(value)) => {
				self.escaping = None;

				if let Some(c) = validate_escape(value) {
					self.value = Some(c);
					Transition::step(self)
				} else {
					// Use a placeholder to produce a valid literal after reporting the error. This
					// won't get to be actually used, because the program won't be interpreted after
					// parsing.
					self.value = Some(b'\0');
					let escape_sequence = &cursor.slice()[offset ..= cursor.offset()];
					Transition::error(self, Error::invalid_escape_sequence(escape_sequence, pos))
				}
			}

			// Begin of escape sequence.
			(_, Some(b'\\')) => {
				self.escaping = Some((cursor.offset(), cursor.pos()));
				Transition::step(self)
			}

			// Empty literal.
			(&Self { value: None, .. }, Some(b'\'')) => {
				Transition::error(Root, Error::empty_byte_literal(self.pos))
			}

			// Ordinary character.
			(_, Some(value)) => {
				self.value = Some(value);
				Transition::step(self)
			}
		}
	}
}


impl From<ByteLiteral> for State {
	fn from(state: ByteLiteral) -> State {
		Self::ByteLiteral(state)
	}
}


/// The state for lexing string literals.
#[derive(Debug)]
pub(super) struct StringLiteral {
	/// The parsed bytes, if any.
	value: Vec<u8>,
	/// The position of the current escape sequence, if any.
	escaping: Option<(usize, SourcePos)>,
	/// The position of the literal.
	pos: SourcePos,
}


impl StringLiteral {
	pub fn at(cursor: &Cursor) -> Self {
		Self {
			value: Vec::with_capacity(8), // We expect most literals to not be empty.
			escaping: None,
			pos: cursor.pos(),
		}
	}


	pub fn visit(mut self, cursor: &Cursor) -> Transition {
		match (&self, cursor.peek()) {
			// EOF while scanning a literal is always an error.
			(_, None) => Transition::error(Root, Error::unexpected_eof(cursor.pos())),

			// Escaped character.
			(&Self { escaping: Some((offset, pos)), .. }, Some(value)) => {
				self.escaping = None;

				if let Some(c) = validate_escape(value) {
					self.value.push(c);
					Transition::step(self)
				} else {
					let escape_sequence = &cursor.slice()[offset ..= cursor.offset()];
					Transition::error(self, Error::invalid_escape_sequence(escape_sequence, pos))
				}
			}

			// Begin of escape sequence.
			(_, Some(b'\\')) => {
				self.escaping = Some((cursor.offset(), cursor.pos()));
				Transition::step(self)
			}

			// Closing quote.
			(_, Some(b'\"')) => Transition::produce(
				Root,
				Token {
					kind: TokenKind::Literal(Literal::String(self.value.into_boxed_slice())),
					pos: self.pos,
				},
			),

			// Ordinary character.
			(_, Some(value)) => {
				self.value.push(value);
				Transition::step(self)
			}
		}
	}
}


impl From<StringLiteral> for State {
	fn from(state: StringLiteral) -> State {
		Self::StringLiteral(state)
	}
}


/// Check if a escape sequence is valid, producing the correspondent byte if so.
fn validate_escape(sequence: u8) -> Option<u8> {
	match sequence {
		b'"' => Some(b'"'),
		b'\'' => Some(b'\''),
		b'n' => Some(b'\n'),
		b't' => Some(b'\t'),
		b'0' => Some(b'\0'),
		b'\\' => Some(b'\\'),
		_ => None,
	}
}