path: root/rfc2822/src/grammar.lalrpop

// -*- mode: Rust; -*-
use Error;

use strings::{
    strings_flatten_into,
    strings_flatten2,
    strings_flatten,
};
use component::{
    Component,
    components_kill_ws,
    components_merge,
};
use lexer;
use lexer::Token;

grammar<'input>;

// RFC 4880 says:
//
//   5.11.  User ID Packet (Tag 13)
//
//   A User ID packet consists of UTF-8 text that is intended to represent
//   the name and email address of the key holder.  By convention, it
//   includes an RFC 2822 [RFC2822] mail name-addr, but there are no
//   restrictions on its content.
//
// At least today, the convention is more along the lines of RFC
// 2822's mailbox instead of its name-addr.  The only different is
// that the mailbox production allows for a bare email address i.e.,
// one without angle brackets whereas the name-addr production
// requires angle brackets.
//
// A further convention is an ssh-host-uri production:
//
//   ssh-host-uri = "ssh://" dns-hostname


CRLF: () = {
    CR LF
}

// text            =       %d1-9 /         ; Characters excluding CR and LF
//                         %d11 /
//                         %d12 /
//                         %d14-127 /
//                         obs-text
text : Token<'input> = {
    WSP,
    NO_WS_CTL,
    specials,
    OTHER,
}

// specials        =       "(" / ")" /     ; Special characters used in
//                         "<" / ">" /     ;  other parts of the syntax
//                         "[" / "]" /
//                         ":" / ";" /
//                         "@" / "\" /
//                         "," / "." /
//                         DQUOTE
specials : Token<'input> = {
    LPAREN,
    RPAREN,
    LANGLE,
    RANGLE,
    LBRACKET,
    RBRACKET,
    COLON,
    SEMICOLON,
    AT,
    BACKSLASH,
    COMMA,
    DOT,
    DQUOTE,
};


// 3.2.2. Quoted characters

// quoted-pair     =       ("\" text) / obs-qp
//
// In RFC 2822, text is a single character and the BACKSLAH is
// followed by exactly one character.  As an optimization, our lexer
// groups runs of 'text' characters into a single token, Token::OTHER.
// Since a quoted pair can always be followed by a run of OTHER
// characters, the semantics are preserved.
quoted_pair : Token<'input> = {
    BACKSLASH <text>,
}

// 3.2.3. Folding white space and comments

// Folding white space
//
// FWS             =       ([*WSP CRLF] 1*WSP) /   ;
//                         obs-FWS
//
//   Runs of FWS, comment or CFWS that occur between lexical tokens in
//   a structured field header are semantically interpreted as a
//   single space character.
#[inline]
FWS : Component = {
   (WSP* CRLF)? WSP+ => Component::WS,
}

// ctext           =       NO-WS-CTL /     ; Non white space controls
//                         %d33-39 /       ; The rest of the US-ASCII
//                         %d42-91 /       ;  characters not including "(",
//                         %d93-126        ;  ")", or "\"
ctext : Token<'input> = {
    NO_WS_CTL,

    // LPAREN,
    // RPAREN,
    LANGLE,
    RANGLE,
    LBRACKET,
    RBRACKET,
    COLON,
    SEMICOLON,
    AT,
    // BACKSLASH,
    COMMA,
    DOT,
    DQUOTE,

    OTHER,
}

// ccontent        =       ctext / quoted-pair / comment
ccontent : String = {
    <c:ctext> => c.to_string(),
    <c:quoted_pair> => c.to_string(),
    <c:comment> => {
        let mut s = String::new();
        s.push('(');
        if let Component::Comment(comment) = c {
            s.push_str(&comment[..]);
        } else {
            panic!("Expected a Component::Comment");
        }
        s.push(')');
        s
    },
}

// comment         =       "(" *([FWS] ccontent) [FWS] ")"
pub(crate) Comment : Component = {
    <comment>
}

comment : Component = {
    LPAREN <c:(<FWS?> <ccontent>)*> <d:FWS?> RPAREN => {
        let mut s = strings_flatten2(
            c.into_iter().map(|(fws, c)| (fws.is_some(), c)), " ");

        if d.is_some() {
            s.push(' ');
        }

        Component::Comment(s)
    },
}

// CFWS            =       *([FWS] comment) (([FWS] comment) / FWS)
pub(crate) Cfws : Vec<Component> = {
    <c:CFWS> => {
        components_merge(c)
    }
}

CFWS : Vec<Component> = {
    // <c:(FWS? <comment>)*> FWS? <d:comment> => ...,
    // <c:(FWS? <comment>)*> FWS => ...,

    // The following is equivalent to the above, but the actions are a
    // bit simpler.
    <c:(<FWS?> <comment>)+> => {
        let v : Vec<Component> = c.into_iter()
            .map(|(w, c)| {
                if let Some(w) = w {
                    vec![w, c]
                } else {
                    vec![c]
                }
            })
            .flatten()
            .collect();
        v
    },
    <c:(<FWS?> <comment>)*> <w2:FWS> => {
        let mut v : Vec<Component> = c.into_iter()
            .map(|(w, c)| {
                if let Some(w) = w {
                    vec![w, c]
                } else {
                    vec![c]
                }
            })
            .flatten()
            .collect();
        v.push(w2);
        v
    }
}

// 3.2.4. Atom

// atext           =       ALPHA / DIGIT / ; Any character except controls,
//                         "!" / "#" /     ;  SP, and specials.
//                         "$" / "%" /     ;  Used for atoms
//                         "&" / "'" /
//                         "*" / "+" /
//                         "-" / "/" /
//                         "=" / "?" /
//                         "^" / "_" /
//                         "`" / "{" /
//                         "|" / "}" /
//                         "~"
//
// As an optimization the lexer collects atexts, i.e., Token::OTHER is
// 1*atext.
atext_plus : String = {
    <a:OTHER> => {
        let a = a.to_string();
        assert!(a.len() > 0);
        a
    },
}


// The display-name in a name-addr production often includes a ., but
// is not quoted.  The RFC even recommends supporting this variation.
other_or_dot : String = {
    <a:OTHER> => a.to_string(),
    <d:DOT> => d.to_string(),
}

atext_dot_plus : String = {
    <a:other_or_dot+> => strings_flatten(a.into_iter(), ""),
}

// atom            =       [CFWS] 1*atext [CFWS]
//
// "Both atom and dot-atom are interpreted as a single unit, comprised
// of the string of characters that make it up.  Semantically, the
// optional comments and FWS surrounding the rest of the characters
// are not part of the atom"
pub(crate) Atom : Vec<Component> = {
    <a:atom> => components_merge(a),
}

atom : Vec<Component> = {
    <c1:CFWS?> <a:atext_dot_plus> <c2:CFWS?> =>
        components_concat!(
            components_kill_ws(c1, false, true),
            Component::Text(a),
            components_kill_ws(c2, true, false)),
}

// See the phrase production for this variant of the 'atom' production
// exists, and why the 'CFWS?'es are not included.
atom_prime : Component = {
    <a:atext_dot_plus> => Component::Text(a),
}

// dot-atom        =       [CFWS] dot-atom-text [CFWS]
//
// "Both atom and dot-atom are interpreted as a single unit, comprised
// of the string of characters that make it up.  Semantically, the
// optional comments and FWS surrounding the rest of the characters
// are not part of the atom"
pub(crate) DotAtom : Vec<Component> = {
    <d:dot_atom> => components_merge(d),
}

dot_atom : Vec<Component> = {
    <c1:CFWS?> <a:dot_atom_text> <c2:CFWS?> =>
        components_concat!(
            components_kill_ws(c1, false, true),
            a,
            components_kill_ws(c2, true, false)),
}

// A variant of dot_atom that places all comments to the left.
dot_atom_left : Vec<Component> = {
    <c1:CFWS?> <a:dot_atom_text> <c2:CFWS?> =>
        components_concat!(
            components_kill_ws(
                Some(components_concat!(c1, c2)), false, true),
            a),
}

// A variant of dot_atom that places all comments to the right.
dot_atom_right : Vec<Component> = {
    <c1:CFWS?> <a:dot_atom_text> <c2:CFWS?> =>
        components_concat!(
            a,
            components_kill_ws(
                Some(components_concat!(c1, c2)), true, false)),
}

// dot-atom-text   =       1*atext *("." 1*atext)
dot_atom_text : Component = {
    <v:atext_plus> <w:(DOT <atext_plus>)*> => {
        let mut v = v;
        if w.len() > 0 {
            v.push('.');
        }
        Component::Text(
            strings_flatten_into(v, w.into_iter(), "."))
    },
}

// 3.2.5. Quoted strings

// qtext           =       NO-WS-CTL /     ; Non white space controls
//                         %d33 /          ; The rest of the US-ASCII
//                         %d35-91 /       ;  characters not including "\"
//                         %d93-126        ;  or the quote character
qtext : Token<'input> = {
    NO_WS_CTL,

    LPAREN,
    RPAREN,
    LANGLE,
    RANGLE,
    LBRACKET,
    RBRACKET,
    COLON,
    SEMICOLON,
    AT,
    // BACKSLASH,
    COMMA,
    DOT,
    // DQUOTE,

    OTHER,
}

// qcontent        =       qtext / quoted-pair
qcontent : Component = {
    <c:qtext> => Component::Text(c.to_string()),
    <c:quoted_pair> => Component::Text(c.to_string()),
}

// quoted-string   =       [CFWS]
//                         DQUOTE *([FWS] qcontent) [FWS] DQUOTE
//                         [CFWS]
pub(crate) QuotedString : Vec<Component> = {
    <q:quoted_string> => components_merge(q),
}

quoted_string : Vec<Component> = {
    <c1:CFWS?> DQUOTE <c:(<FWS?> <qcontent>)*> <d:FWS?> DQUOTE <c2:CFWS?> => {
        // Make sure any leading and trailing whitespace *inside* the
        // quotes is turned into Component::Text.
        components_concat!(
            // c1 is an Option<Vec<Component>>.
            c1,
            // c is a Vec<(Option<Component>, Component)>.  Turn it
            // into a Vec<Component>.
            c.into_iter()
                .map(|(fws, c)| {
                    if let Some(_) = fws {
                        vec![Component::Text(" ".to_string()), c]
                    } else {
                        vec![c]
                    }
                })
                .flatten()
                .collect::<Vec<Component>>(),
            // d is an Option<Component>, turn it into a
            // Option<Vec<Component>>.
            d.map(|_| vec![Component::Text(" ".to_string())]),
            c2)
    },
}

// Variant of quoted_string that moves all comments to the left.
quoted_string_left : Vec<Component> = {
    <c1:CFWS?> DQUOTE <c:(<FWS?> <qcontent>)*> <d:FWS?> DQUOTE <c2:CFWS?> => {
        // Make sure any leading and trailing whitespace *inside* the
        // quotes is turned into Component::Text.
        components_concat!(
            // c1 is an Option<Vec<Component>>.
            components_kill_ws(Some(components_concat!(c1, c2)), false, true),
            // c is a Vec<(Option<Component>, Component)>.  Turn it
            // into a Vec<Component>.
            c.into_iter()
                .map(|(fws, c)| {
                    if let Some(_) = fws {
                        vec![Component::Text(" ".to_string()), c]
                    } else {
                        vec![c]
                    }
                })
                .flatten()
                .collect::<Vec<Component>>(),
            // d is an Option<Component>, turn it into a
            // Option<Vec<Component>>.
            d.map(|_| vec![Component::Text(" ".to_string())]))
    },
}

// See the phrase production for this variant of the 'quoted_string'
// production exists, and why the 'CFWS?'es are not included.
quoted_string_prime : Vec<Component> = {
    DQUOTE <c:(<FWS?> <qcontent>)*> <d:FWS?> DQUOTE => {
        // Make sure any leading and trailing whitespace *inside* the
        // quotes is turned into Component::Text.
        components_concat!(
            // c is a Vec<(Option<Component>, Component)>.  Turn it
            // into a Vec<Component>.
            c.into_iter()
                .map(|(fws, c)| {
                    if let Some(_) = fws {
                        vec![Component::Text(" ".to_string()), c]
                    } else {
                        vec![c]
                    }
                })
                .flatten()
                .collect::<Vec<Component>>(),
            // d is an Option<Component>, turn it into a
            // Option<Vec<Component>>.
            d.map(|_| vec![Component::Text(" ".to_string())]))
    },
}

// 3.2.6. Miscellaneous tokens

// word            =       atom / quoted-string
pub(crate) Word : Vec<Component> = {
    <w:word> => components_merge(w),
}

word : Vec<Component> = {
    atom,
    quoted_string,
}

// phrase          =       1*word / obs-phrase

pub(crate) Phrase : Vec<Component> = {
    <p:phrase> => components_merge(p),
}

// phrase : String = {
//     <v:word+> => strings_flatten(v, ""),
// }
//
// Note: consider the following parse tree:
//
//                         phrase
//                        /      \
//                  word           word
//                /                    \
//           atom                        atom
//       /    |    \                 /    |    \
// CFWS+?   atext+   CFWS?     CFWS+?   atext+   CFWS?
//
// This has an ambiguity!  Does a CFWS immediate after the first
// atext+ belong to the first atom or the second?  And, if there are
// no CFWSes, how do we split the atext?
//
// To avoid these problems, we modify the grammar as presented in the
// RFC as follows:
atom_or_quoted_string : Vec<Component> = {
    <a:atom_prime> <r:cfws_or_quoted_string?> => {
        // Note: it's not possible to have multiple atoms in a row.
        // The following:
        //
        //   foo bar
        //
        // is 'atom_prime CFWS atom_prime'.

        components_concat!(a, r)
    },
    <q:quoted_string_prime+> <r:cfws_or_atom?> => {
        // But, it's possible to have multiple quoted strings in a
        // row, e.g.:
        //
        //   "foo""bar"
        //
        // Note that '"foo" "bar"' would match quoted_string_prime,
        // CFWS, quoted_string_prime.

        components_concat!(
            q.into_iter().flatten().collect::<Vec<Component>>(), r)
    },
}

cfws_or_quoted_string : Vec<Component> = {
    <c:CFWS> <r:atom_or_quoted_string?> => components_concat!(c, r),
    <q:quoted_string_prime+> <r:cfws_or_atom?> =>
        components_concat!(
            q.into_iter().flatten().collect::<Vec<Component>>(), r),
}

cfws_or_atom : Vec<Component> = {
    <c:CFWS> <r:atom_or_quoted_string?> => components_concat!(c, r),
    <a:atom_prime> <r:cfws_or_quoted_string?> => components_concat!(a, r),
}

phrase : Vec<Component> = {
    <c:CFWS?> <r:atom_or_quoted_string> => components_concat!(c, r),
}

// 3.4. Address Specification

// mailbox         =       name-addr / addr-spec
// pub(crate) Mailbox : Vec<Component> = {
//     mailbox,
// }
// 
// mailbox : Vec<Component> = {
//     name_addr,
//     addr_spec,
// }

// name-addr       =       [display-name] angle-addr
pub(crate) NameAddr : Vec<Component> = {
    <n:name_addr> => components_merge(n),
}

// The display_name ends in an optional CFWS and the angle_addr starts
// with one.  This causes an ambiguity.  The angle_addr_prime
// production removes the optional leading CFWS non-terminal.
name_addr : Vec<Component> = {
    <n:display_name?> <a:angle_addr_prime> =>
        components_concat!(n, a),
}


// angle-addr      =       [CFWS] "<" addr-spec ">" [CFWS] / obs-angle-addr
pub(crate) AngleAddr : Vec<Component> = {
    <a:angle_addr> => components_merge(a),
}

angle_addr : Vec<Component> = {
    <c1:CFWS?> LANGLE <a:addr_spec> RANGLE <c2:CFWS?> =>
        components_concat!(c1, a, c2),
}

angle_addr_prime : Vec<Component> = {
    LANGLE <a:addr_spec> RANGLE <c2:CFWS?> =>
        components_concat!(a, c2),
}


// display-name    =       phrase
display_name : Vec<Component> = {
    <p:phrase> => components_kill_ws(Some(p), true, true),
}

// 3.4.1. Addr-spec specification

// addr-spec       =       local-part "@" domain
pub(crate) AddrSpec : Vec<Component> = {
    <a:addr_spec> => components_merge(a),
}

addr_spec : Vec<Component> = {
    <l:local_part> AT <d:domain> => {
        let mut l = components_merge(l);
        let mut d = components_merge(d);

        // local_part and domain can both be preceded or followed by
        // comment-folding whitespace.  So, something like:
        //
        //   "<(comment) (comment) \r\n foo (comment)@ (comment) bar.com (comment)>"
        //
        // is valid (it's foo@bar.com).

        // The local part may start with commends and the domain part
        // may end with comments.
        let local_part = l.pop().expect("empty local_part");
        let domain = d.remove(0);

        let mut v = components_merge(
            vec![local_part, Component::Text("@".into()), domain]);
        assert_eq!(v.len(), 1, "Expected 1 component, got: {:?}", v);
        let addr = match v.pop() {
            Some(Component::Text(addr)) =>
                Component::Address(addr),
            Some(c) =>
                panic!("addr_spec production failed: {:?}", c),
            None =>
                panic!("addr_spec production failed"),
        };

        components_concat!(l, addr, d)
    },
}

// local-part      =       dot-atom / quoted-string / obs-local-part
local_part : Vec<Component> = {
    dot_atom_left,
    quoted_string_left,
}

// domain          =       dot-atom / domain-literal / obs-domain
domain : Vec<Component> = {
    dot_atom_right,
    domain_literal,
}


// domain-literal  =       [CFWS] "[" *([FWS] dcontent) [FWS] "]" [CFWS]
pub(crate) DomainLiteral : Vec<Component> = {
    <d:domain_literal> => components_merge(d),
}

domain_literal : Vec<Component> = {
    <c1:CFWS?> LBRACKET <c:(<FWS?> <dcontent>)*> <d:FWS?> RBRACKET <c2:CFWS?> => {
        components_concat!(
            // c1 is an Option<Vec<Component>>.
            c1,
            Component::Text("[".into()),
            // c is a Vec<(Option<Component>, Component)>.  Turn it
            // into a Vec<Component>.
            c.into_iter()
                .map(|(fws, c)| {
                    let c = Component::Text(c.to_string());
                    if let Some(fws) = fws {
                        vec![fws, c]
                    } else {
                        vec![c]
                    }
                })
                .flatten()