lib-ruby-parser 3.0.3

Ruby parser
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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

use crate::{
    containers::{List, Ptr, SharedList, StringPtr},
    debug_level,
    source::{CustomDecoder, CustomDecoderResult},
    token_rewriter::{TokenRewriter, TokenRewriterResult},
    ParserOptions, Token,
};

type ForeignCustomDecoderFn = extern "C" fn(StringPtr, List<u8>) -> CustomDecoderResult;

extern "C" fn dummy_decode(_encoding: StringPtr, input: List<u8>) -> CustomDecoderResult {
    CustomDecoderResult::Ok(input)
}

/// C-compatible custom decoder
#[repr(C)]
#[derive(Debug)]
pub struct ForeignCustomDecoder {
    f: ForeignCustomDecoderFn,
    dummy: bool,
}

impl ForeignCustomDecoder {
    /// Constructs a custom decoder with a given foreign function
    pub fn new(f: ForeignCustomDecoderFn) -> Self {
        Self { f, dummy: false }
    }

    fn none() -> Self {
        Self {
            f: dummy_decode,
            dummy: true,
        }
    }

    fn as_option(&self) -> Option<ForeignCustomDecoderFn> {
        if self.dummy {
            None
        } else {
            Some(self.f)
        }
    }
}

type ForeignTokenRewriterFn = extern "C" fn(Ptr<Token>, SharedList<u8>) -> TokenRewriterResult;

extern "C" fn dummy_rewrite(_token: Ptr<Token>, _input: SharedList<u8>) -> TokenRewriterResult {
    unreachable!()
}

/// C-compatible token rewriter struct
#[repr(C)]
#[derive(Debug)]
pub struct ForeignTokenRewriter {
    f: ForeignTokenRewriterFn,
    dummy: bool,
}

impl ForeignTokenRewriter {
    /// Constructs a token rewriter with a given foreign function
    pub fn new(f: ForeignTokenRewriterFn) -> Self {
        Self { f, dummy: false }
    }

    fn none() -> Self {
        Self {
            f: dummy_rewrite,
            dummy: true,
        }
    }

    fn as_option(&self) -> Option<ForeignTokenRewriterFn> {
        if self.dummy {
            None
        } else {
            Some(self.f)
        }
    }
}

/// Foreign parser options, can be casted to Rust ParserOptions
#[repr(C)]
#[derive(Debug)]
pub struct ForeignParserOptions {
    /// Equivalent of ParserOptions.buffer_name
    pub buffer_name: StringPtr,

    /// Equivalent of ParserOptions.debug
    pub debug: debug_level::Type,

    /// Equivalent of ParserOptions.decoder
    pub decoder: ForeignCustomDecoder,

    /// Equivalent of ParserOptions.token_rewriter
    pub token_rewriter: ForeignTokenRewriter,

    /// Equivalent of ParserOptions.record_tokens
    pub record_tokens: bool,
}

impl Default for ForeignParserOptions {
    fn default() -> Self {
        Self {
            buffer_name: StringPtr::from("(eval)"),
            debug: debug_level::NONE,
            decoder: ForeignCustomDecoder::none(),
            token_rewriter: ForeignTokenRewriter::none(),
            record_tokens: true,
        }
    }
}

impl From<ForeignParserOptions> for ParserOptions {
    fn from(options: ForeignParserOptions) -> Self {
        let ForeignParserOptions {
            buffer_name,
            debug,
            decoder,
            token_rewriter,
            record_tokens,
        } = options;

        let decoder = if let Some(decoder) = decoder.as_option() {
            let rust_decode = move |encoding: StringPtr, input: List<u8>| decoder(encoding, input);
            CustomDecoder::new(Box::new(rust_decode))
        } else {
            CustomDecoder::none()
        };

        let token_rewriter = if let Some(token_rewriter) = token_rewriter.as_option() {
            let rust_rewrite =
                move |token: Ptr<Token>, input: SharedList<u8>| token_rewriter(token, input);
            TokenRewriter::new(Box::new(rust_rewrite))
        } else {
            TokenRewriter::none()
        };

        ParserOptions {
            buffer_name: String::from(buffer_name),
            debug,
            decoder,
            token_rewriter,
            record_tokens,
        }
    }
}