rsasm 0.1.0

A multi-syntax, multi-architecture assembler
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

//! A cursor over the tokens of a single statement.
//!
//! Statements are tokenized in full before parsing, so operand parsers (which
//! are architecture- and syntax-specific) can be handed plain slices and can
//! backtrack freely.

use crate::lexer::{Punct, TokKind, Token};
use crate::source::Span;

#[derive(Clone)]
pub struct Cursor<'a> {
    toks: &'a [Token],
    pos: usize,
}

impl<'a> Cursor<'a> {
    pub fn new(toks: &'a [Token]) -> Cursor<'a> {
        Cursor { toks, pos: 0 }
    }

    pub fn pos(&self) -> usize {
        self.pos
    }

    pub fn set_pos(&mut self, pos: usize) {
        self.pos = pos;
    }

    pub fn rest(&self) -> &'a [Token] {
        &self.toks[self.pos.min(self.toks.len())..]
    }

    pub fn all(&self) -> &'a [Token] {
        self.toks
    }

    /// The token at the cursor. Past the end this yields a synthetic `Eof`
    /// positioned at the end of the statement, so error spans stay sensible.
    pub fn peek(&self) -> Token {
        self.nth(0)
    }

    pub fn nth(&self, n: usize) -> Token {
        match self.toks.get(self.pos + n) {
            Some(t) => *t,
            None => Token {
                kind: TokKind::Eof,
                span: self.end_span(),
                preceded_by_space: true,
            },
        }
    }

    fn end_span(&self) -> Span {
        match self.toks.last() {
            Some(t) => Span::new(t.span.hi, t.span.hi),
            None => Span::DUMMY,
        }
    }

    pub fn is_empty(&self) -> bool {
        self.pos >= self.toks.len()
    }

    /// True when nothing but end-of-statement remains.
    pub fn at_end(&self) -> bool {
        matches!(self.peek().kind, TokKind::Eof | TokKind::Eol)
    }

    pub fn advance(&mut self) -> Token {
        let t = self.peek();
        if self.pos < self.toks.len() {
            self.pos += 1;
        }
        t
    }

    /// Consumes and returns the next token if it is `p`.
    pub fn eat_punct(&mut self, p: Punct) -> Option<Token> {
        if self.peek().is_punct(p) {
            Some(self.advance())
        } else {
            None
        }
    }

    pub fn check_punct(&self, p: Punct) -> bool {
        self.peek().is_punct(p)
    }

    /// Span covering everything from the cursor to the end of the statement.
    pub fn remaining_span(&self) -> Span {
        let rest = self.rest();
        match (rest.first(), rest.last()) {
            (Some(a), Some(b)) => a.span.to(b.span),
            _ => self.end_span(),
        }
    }

    /// Splits the remaining tokens on top-level commas, ignoring commas nested
    /// inside `()`, `[]` or `{}`. Used to break an operand list apart before
    /// handing each piece to an architecture's operand parser.
    pub fn split_commas(&self) -> Vec<&'a [Token]> {
        let rest = self.rest();
        let mut out = Vec::new();
        let mut depth = 0i32;
        let mut start = 0usize;
        let mut saw_any = false;
        for (i, t) in rest.iter().enumerate() {
            match t.kind {
                TokKind::Punct(Punct::LParen | Punct::LBracket | Punct::LBrace) => depth += 1,
                TokKind::Punct(Punct::RParen | Punct::RBracket | Punct::RBrace) => depth -= 1,
                TokKind::Punct(Punct::Comma) if depth <= 0 => {
                    out.push(&rest[start..i]);
                    start = i + 1;
                    saw_any = true;
                    continue;
                }
                _ => {}
            }
            saw_any = true;
        }
        if saw_any || start < rest.len() {
            out.push(&rest[start..]);
        }
        out
    }
}