pomsky 0.12.0

A new regular expression language
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

use pomsky_syntax::exprs::{Lookaround, LookaroundKind};

use crate::{
    compile::{CompileResult, CompileState},
    diagnose::CompileErrorKind,
    options::{CompileOptions, RegexFlavor},
    regex::Regex,
};

use super::Compile;

impl Compile for Lookaround {
    fn compile<'c>(
        &'c self,
        options: CompileOptions,
        state: &mut CompileState<'c>,
    ) -> CompileResult {
        match options.flavor {
            RegexFlavor::Ruby if state.in_lookbehind => {
                if let LookaroundKind::Ahead | LookaroundKind::AheadNegative = self.kind {
                    return Err(CompileErrorKind::RubyLookaheadInLookbehind {
                        was_word_boundary: false,
                    }
                    .at(self.span));
                }
            }
            _ => (),
        }

        revert_on_drop!(state.in_lookbehind);
        if let LookaroundKind::Behind | LookaroundKind::BehindNegative = self.kind {
            state.in_lookbehind = true;
        }

        let content = self.rule.compile(options, &mut state)?;
        let lookaround = RegexLookaround::new(content, self.kind, options.flavor)
            .map_err(|e| e.at(self.span))?;

        Ok(Regex::Lookaround(Box::new(lookaround)))
    }
}

#[cfg_attr(feature = "dbg", derive(Debug))]
pub(crate) struct RegexLookaround {
    pub(crate) content: Regex,
    pub(crate) kind: LookaroundKind,
}

impl RegexLookaround {
    pub(crate) fn new(
        content: Regex,
        kind: LookaroundKind,
        flavor: RegexFlavor,
    ) -> Result<Self, CompileErrorKind> {
        if let LookaroundKind::Behind | LookaroundKind::BehindNegative = kind {
            match flavor {
                RegexFlavor::Python => {
                    content.validate_in_lookbehind_py()?;
                }
                RegexFlavor::Pcre => {
                    content.validate_in_lookbehind_pcre()?;
                }
                RegexFlavor::Java => {
                    content.validate_in_lookbehind_java()?;
                }
                _ => {}
            }
        }

        Ok(RegexLookaround { content, kind })
    }

    pub(crate) fn codegen(&self, buf: &mut String, flavor: RegexFlavor) {
        buf.push_str(match self.kind {
            LookaroundKind::Ahead => "(?=",
            LookaroundKind::Behind => "(?<=",
            LookaroundKind::AheadNegative => "(?!",
            LookaroundKind::BehindNegative => "(?<!",
        });
        self.content.codegen(buf, flavor);
        buf.push(')');
    }
}