    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

    //! Character specific parsers and combinators
    //!
    //! Functions recognizing specific characters

    #[cfg(test)]
    mod tests;

    pub mod complete;
    pub mod streaming;

    /// Tests if byte is ASCII alphabetic: A-Z, a-z
    ///
    /// # Example
    ///
    /// ```
    /// # use nom::character::is_alphabetic;
    /// assert_eq!(is_alphabetic(b'9'), false);
    /// assert_eq!(is_alphabetic(b'a'), true);
    /// ```
    #[inline]
    pub fn is_alphabetic(chr: u8) -> bool {
      (chr >= 0x41 && chr <= 0x5A) || (chr >= 0x61 && chr <= 0x7A)
    }

    /// Tests if byte is ASCII digit: 0-9
    ///
    /// # Example
    ///
    /// ```
    /// # use nom::character::is_digit;
    /// assert_eq!(is_digit(b'a'), false);
    /// assert_eq!(is_digit(b'9'), true);
    /// ```
    #[inline]
    pub fn is_digit(chr: u8) -> bool {
      chr >= 0x30 && chr <= 0x39
    }

    /// Tests if byte is ASCII hex digit: 0-9, A-F, a-f
    ///
    /// # Example
    ///
    /// ```
    /// # use nom::character::is_hex_digit;
    /// assert_eq!(is_hex_digit(b'a'), true);
    /// assert_eq!(is_hex_digit(b'9'), true);
    /// assert_eq!(is_hex_digit(b'A'), true);
    /// assert_eq!(is_hex_digit(b'x'), false);
    /// ```
    #[inline]
    pub fn is_hex_digit(chr: u8) -> bool {
      (chr >= 0x30 && chr <= 0x39) || (chr >= 0x41 && chr <= 0x46) || (chr >= 0x61 && chr <= 0x66)
    }

    /// Tests if byte is ASCII octal digit: 0-7
    ///
    /// # Example
    ///
    /// ```
    /// # use nom::character::is_oct_digit;
    /// assert_eq!(is_oct_digit(b'a'), false);
    /// assert_eq!(is_oct_digit(b'9'), false);
    /// assert_eq!(is_oct_digit(b'6'), true);
    /// ```
    #[inline]
    pub fn is_oct_digit(chr: u8) -> bool {
      chr >= 0x30 && chr <= 0x37
    }

    /// Tests if byte is ASCII alphanumeric: A-Z, a-z, 0-9
    ///
    /// # Example
    ///
    /// ```
    /// # use nom::character::is_alphanumeric;
    /// assert_eq!(is_alphanumeric(b'-'), false);
    /// assert_eq!(is_alphanumeric(b'a'), true);
    /// assert_eq!(is_alphanumeric(b'9'), true);
    /// assert_eq!(is_alphanumeric(b'A'), true);
    /// ```
    #[inline]
    pub fn is_alphanumeric(chr: u8) -> bool {
      is_alphabetic(chr) || is_digit(chr)
    }

    /// Tests if byte is ASCII space or tab
    ///
    /// # Example
    ///
    /// ```
    /// # use nom::character::is_space;
    /// assert_eq!(is_space(b'\n'), false);
    /// assert_eq!(is_space(b'\r'), false);
    /// assert_eq!(is_space(b' '), true);
    /// assert_eq!(is_space(b'\t'), true);
    /// ```
    #[inline]
    pub fn is_space(chr: u8) -> bool {
      chr == b' ' || chr == b'\t'
    }

    /// Tests if byte is ASCII newline: \n
    ///
    /// # Example
    ///
    /// ```
    /// # use nom::character::is_newline;
    /// assert_eq!(is_newline(b'\n'), true);
    /// assert_eq!(is_newline(b'\r'), false);
    /// assert_eq!(is_newline(b' '), false);
    /// assert_eq!(is_newline(b'\t'), false);
    /// ```
    #[inline]
    pub fn is_newline(chr: u8) -> bool {
      chr == b'\n'
    }