#[derive(Debug, Clone)]
pub enum DataItem {
Value(String),
Str(Vec<u8>),
}
#[derive(Debug, Clone)]
pub enum LineKind {
Instr { mnemonic: String, operands: Vec<String> },
Db(Vec<DataItem>),
Dw(Vec<DataItem>),
}
#[derive(Debug)]
pub struct LexError {
pub line_no: usize,
pub message: String,
}
#[derive(Debug, Clone)]
pub struct RawLine {
pub line_no: usize,
pub label: Option<String>,
pub kind: Option<LineKind>,
}
pub fn lex(source: &str) -> Result<Vec<RawLine>, LexError> {
let mut lines = Vec::new();
for (i, raw_line) in source.lines().enumerate() {
let line_no = i + 1;
let code = strip_comment(raw_line).trim();
if code.is_empty() {
continue;
}
let mut rest = code;
let mut label = None;
if let Some(colon_idx) = rest.find(':') {
let (maybe_label, after) = rest.split_at(colon_idx);
let maybe_label = maybe_label.trim();
if !maybe_label.is_empty()
&& !maybe_label.contains(char::is_whitespace)
&& !maybe_label.contains('"')
{
label = Some(maybe_label.to_string());
rest = after[1..].trim();
}
}
if rest.is_empty() {
lines.push(RawLine { line_no, label, kind: None });
continue;
}
let first_end = rest.find(char::is_whitespace).unwrap_or(rest.len());
let first = rest[..first_end].to_lowercase();
let after_first = rest[first_end..].trim();
let kind = match first.as_str() {
"db" | "dw" => {
let items = parse_data_items(after_first)
.map_err(|message| LexError { line_no, message })?;
if first == "db" { LineKind::Db(items) } else { LineKind::Dw(items) }
}
_ => {
let mut tokens = rest
.split(|c: char| c == ',' || c.is_whitespace())
.filter(|s| !s.is_empty());
let mnemonic = tokens.next().unwrap().to_lowercase();
let operands = tokens.map(|s| s.to_string()).collect();
LineKind::Instr { mnemonic, operands }
}
};
lines.push(RawLine { line_no, label, kind: Some(kind) });
}
Ok(lines)
}
fn parse_data_items(s: &str) -> Result<Vec<DataItem>, String> {
let mut items = Vec::new();
let mut chars = s.char_indices().peekable();
while chars.peek().is_some() {
while chars.peek().map(|(_, c)| c.is_whitespace()) == Some(true) {
chars.next();
}
let Some(&(start, ch)) = chars.peek() else { break };
if ch == '"' {
chars.next(); let mut buf: Vec<u8> = Vec::new();
let mut closed = false;
while let Some((_, c)) = chars.next() {
match c {
'"' => {
closed = true;
break;
}
'\\' => {
let Some((_, esc)) = chars.next() else { break };
match esc {
'n' => buf.push(b'\n'),
't' => buf.push(b'\t'),
'r' => buf.push(b'\r'),
'0' => buf.push(0),
'\\' => buf.push(b'\\'),
'"' => buf.push(b'"'),
'x' => {
let hi = chars.next().and_then(|(_, c)| c.to_digit(16));
let lo = chars.next().and_then(|(_, c)| c.to_digit(16));
match (hi, lo) {
(Some(h), Some(l)) => buf.push((h * 16 + l) as u8),
_ => return Err("invalid \\x escape (expected two hex digits)".to_string()),
}
}
other => {
return Err(format!("unknown escape sequence '\\{other}'"));
}
}
}
other => {
let mut tmp = [0u8; 4];
buf.extend_from_slice(other.encode_utf8(&mut tmp).as_bytes());
}
}
}
if !closed {
return Err("unterminated string literal".to_string());
}
items.push(DataItem::Str(buf));
} else if ch != ',' {
let mut end = start;
for (i, c) in chars.by_ref() {
if c == ',' || c.is_whitespace() { break; }
end = i + c.len_utf8();
}
let token = s[start..end].trim().to_string();
if !token.is_empty() {
items.push(DataItem::Value(token));
}
continue;
}
if chars.peek().map(|(_, c)| *c) == Some(',') {
chars.next();
}
}
Ok(items)
}
fn strip_comment(line: &str) -> &str {
let bytes = line.as_bytes();
let mut in_str = false;
let mut i = 0;
while i < bytes.len() {
let b = bytes[i];
if in_str {
match b {
b'\\' => i += 1, b'"' => in_str = false,
_ => {}
}
} else {
match b {
b'"' => in_str = true,
b';' => return &line[..i],
b'/' if bytes.get(i + 1) == Some(&b'/') => return &line[..i],
_ => {}
}
}
i += 1;
}
line
}