#[derive(Debug, Clone)]
pub enum DataItem {
Value(String),
Str(String),
}
#[derive(Debug, Clone)]
pub enum LineKind {
Instr { mnemonic: String, operands: Vec<String> },
Db(Vec<DataItem>),
Dw(Vec<DataItem>),
}
#[derive(Debug, Clone)]
pub struct RawLine {
pub line_no: usize,
pub label: Option<String>,
pub kind: Option<LineKind>,
}
pub fn lex(source: &str) -> Vec<RawLine> {
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) {
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);
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) });
}
lines
}
fn parse_data_items(s: &str) -> Vec<DataItem> {
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 = String::new();
let mut closed = false;
for (_, c) in chars.by_ref() {
if c == '"' { closed = true; break; }
if c == '\\' { continue; } buf.push(c);
}
if closed {
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();
}
}
items
}
fn strip_comment(line: &str) -> &str {
let semi = line.find(';');
let slash = line.find("//");
match (semi, slash) {
(Some(s), Some(sl)) => &line[..s.min(sl)],
(Some(s), None) => &line[..s],
(None, Some(sl)) => &line[..sl],
(None, None) => line,
}
}