ripex 0.2.0

Multi-language structural parsing and fact extraction.
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

use super::state::Parser;
use crate::cpp::lexer::TokenKind;

pub fn skip_to_stmt_boundary(parser: &mut Parser) {
    loop {
        let kind = parser.peek();
        match kind {
            TokenKind::Semicolon | TokenKind::RBrace | TokenKind::Eof => return,
            // Keywords that can start a new statement
            TokenKind::Break
            | TokenKind::Case
            | TokenKind::Catch
            | TokenKind::Class
            | TokenKind::Constexpr
            | TokenKind::Constinit
            | TokenKind::Continue
            | TokenKind::Default
            | TokenKind::Delete
            | TokenKind::Do
            | TokenKind::Else
            | TokenKind::Enum
            | TokenKind::Explicit
            | TokenKind::Export
            | TokenKind::Extern
            | TokenKind::For
            | TokenKind::Friend
            | TokenKind::Goto
            | TokenKind::If
            | TokenKind::IfConstexpr
            | TokenKind::Mutable
            | TokenKind::Namespace
            | TokenKind::Operator
            | TokenKind::Return
            | TokenKind::StaticAssert
            | TokenKind::Struct
            | TokenKind::Switch
            | TokenKind::Template
            | TokenKind::Throw
            | TokenKind::Try
            | TokenKind::Typedef
            | TokenKind::Union
            | TokenKind::Using
            | TokenKind::Virtual
            | TokenKind::While
            | TokenKind::CoAwait
            | TokenKind::CoReturn
            | TokenKind::CoYield
            | TokenKind::ConstCast
            | TokenKind::DynamicCast
            | TokenKind::ReinterpretCast
            | TokenKind::StaticCast
            | TokenKind::Typeid
            | TokenKind::Typename
            | TokenKind::Requires
            | TokenKind::Concept
            | TokenKind::Asm
            | TokenKind::Nullptr
            | TokenKind::New => return,
            _ => {
                parser.advance();
            }
        }
    }
}

pub fn recover_from_error(parser: &mut Parser) {
    let pos_before = parser.pos;
    skip_to_stmt_boundary(parser);
    if parser.peek() == TokenKind::Semicolon {
        parser.advance();
    }
    if parser.pos == pos_before {
        parser.advance();
    }
}

pub fn is_eof(parser: &Parser) -> bool {
    parser.peek() == TokenKind::Eof
}