ripex 0.3.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
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

use super::state::Parser;
use crate::csharp::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::Abstract
            | TokenKind::Async
            | TokenKind::Await
            | TokenKind::Base
            | TokenKind::Break
            | TokenKind::Case
            | TokenKind::Catch
            | TokenKind::Checked
            | TokenKind::Class
            | TokenKind::Const
            | TokenKind::Continue
            | TokenKind::Default
            | TokenKind::Delegate
            | TokenKind::Do
            | TokenKind::Else
            | TokenKind::Enum
            | TokenKind::Event
            | TokenKind::Explicit
            | TokenKind::Extern
            | TokenKind::Finally
            | TokenKind::Fixed
            | TokenKind::For
            | TokenKind::ForEach
            | TokenKind::Goto
            | TokenKind::If
            | TokenKind::Implicit
            | TokenKind::Interface
            | TokenKind::Internal
            | TokenKind::Lock
            | TokenKind::Namespace
            | TokenKind::New
            | TokenKind::Operator
            | TokenKind::Out
            | TokenKind::Override
            | TokenKind::Params
            | TokenKind::Partial
            | TokenKind::Private
            | TokenKind::Protected
            | TokenKind::Public
            | TokenKind::Readonly
            | TokenKind::Record
            | TokenKind::Ref
            | TokenKind::Return
            | TokenKind::Sealed
            | TokenKind::Static
            | TokenKind::Struct
            | TokenKind::Switch
            | TokenKind::Throw
            | TokenKind::Try
            | TokenKind::Unchecked
            | TokenKind::Unsafe
            | TokenKind::Using
            | TokenKind::Virtual
            | TokenKind::Volatile
            | TokenKind::While
            | TokenKind::With
            | TokenKind::Yield
            | TokenKind::From
            | TokenKind::Let
            | TokenKind::Join
            | TokenKind::Orderby
            | TokenKind::Select
            | TokenKind::Group
            | TokenKind::By
            | TokenKind::Descending
            | TokenKind::Equals
            | TokenKind::Into
            | TokenKind::On
            | TokenKind::Where
            | TokenKind::When
            | TokenKind::Init
            | TokenKind::Add
            | TokenKind::Remove
            | TokenKind::Get
            | TokenKind::Set => 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
}