rust-cssparser/src/unicode_range.rs at rm-parserinput · servo/rust-cssparser · GitHub

History

177 lines (161 loc) · 5.43 KB

Raw

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

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

/* This Source Code Form is subject to the terms of the Mozilla Public

* License, v. 2.0. If a copy of the MPL was not distributed with this

* file, You can obtain one at http://mozilla.org/MPL/2.0/. */

//! https://drafts.csswg.org/css-syntax/#urange

use crate::tokenizer::Token;

use crate::{BasicParseError, Parser, ToCss};

use std::char;

use std::fmt;

/// One contiguous range of code points.

///

/// Can not be empty. Can represent a single code point when start == end.

#[derive(PartialEq, Eq, Clone, Hash)]

#[repr(C)]

pub struct UnicodeRange {

/// Inclusive start of the range. In [0, end].

pub start: u32,

/// Inclusive end of the range. In [0, 0x10FFFF].

pub end: u32,

}

impl UnicodeRange {

/// https://drafts.csswg.org/css-syntax/#urange-syntax

pub fn parse(input: &mut Parser) -> Result<Self, BasicParseError> {

// <urange> =

// u '+' <ident-token> '?'* |

// u <dimension-token> '?'* |

// u <number-token> '?'* |

// u <number-token> <dimension-token> |

// u <number-token> <number-token> |

// u '+' '?'+

input.expect_ident_matching("u")?;

let after_u = input.position();

parse_tokens(input)?;

// This deviates from the spec in case there are CSS comments

// between tokens in the middle of one <unicode-range>,

// but oh well…

let concatenated_tokens = input.slice_from(after_u);

let range = match parse_concatenated(concatenated_tokens.as_bytes()) {

Ok(range) => range,

Err(()) => return Err(BasicParseError::unexpected_token()),

};

if range.end > char::MAX as u32 || range.start > range.end {

Err(BasicParseError::unexpected_token())

} else {

Ok(range)

}

fn parse_tokens(input: &mut Parser) -> Result<(), BasicParseError> {

match *input.next_including_whitespace()? {

Token::Delim('+') => {

match *input.next_including_whitespace()? {

Token::Ident(_) => {}

Token::Delim('?') => {}

_ => return Err(BasicParseError::unexpected_token()),

}

parse_question_marks(input)

}

Token::Dimension { .. } => parse_question_marks(input),

Token::Number { .. } => {

let after_number = input.state();

match input.next_including_whitespace() {

Ok(&Token::Delim('?')) => parse_question_marks(input),

Ok(&Token::Dimension { .. }) => {}

Ok(&Token::Number { .. }) => {}

_ => input.reset(&after_number),

}

_ => return Err(BasicParseError::unexpected_token()),

}

Ok(())

}

/// Consume as many '?' as possible

fn parse_question_marks(input: &mut Parser) {

loop {

let start = input.state();

match input.next_including_whitespace() {

Ok(&Token::Delim('?')) => {}

_ => {

input.reset(&start);

return;

}

fn parse_concatenated(text: &[u8]) -> Result<UnicodeRange, ()> {

let mut text = match text.split_first() {

Some((&b'+', text)) => text,

_ => return Err(()),

};

let (first_hex_value, hex_digit_count) = consume_hex(&mut text, 6)?;

let question_marks = consume_question_marks(&mut text);

let consumed = hex_digit_count + question_marks;

if consumed == 0 || consumed > 6 {

return Err(());

}

if question_marks > 0 {

if text.is_empty() {

return Ok(UnicodeRange {

start: first_hex_value << (question_marks * 4),

end: ((first_hex_value + 1) << (question_marks * 4)) - 1,

});

}

} else if text.is_empty() {

return Ok(UnicodeRange {

start: first_hex_value,

end: first_hex_value,

});

} else if let Some((&b'-', mut text)) = text.split_first() {

let (second_hex_value, hex_digit_count) = consume_hex(&mut text, 6)?;

if hex_digit_count > 0 && hex_digit_count <= 6 && text.is_empty() {

return Ok(UnicodeRange {

start: first_hex_value,

end: second_hex_value,

});

}

Err(())

}

// Consume hex digits, but return an error if more than digit_limit are found.

fn consume_hex(text: &mut &[u8], digit_limit: usize) -> Result<(u32, usize), ()> {

let mut value = 0;

let mut digits = 0;

while let Some((&byte, rest)) = text.split_first() {

if let Some(digit_value) = (byte as char).to_digit(16) {

if digits == digit_limit {

return Err(());

}

value = value * 0x10 + digit_value;

digits += 1;

*text = rest;

} else {

break;

}

Ok((value, digits))

}

fn consume_question_marks(text: &mut &[u8]) -> usize {

let mut question_marks = 0;

while let Some((&b'?', rest)) = text.split_first() {

question_marks += 1;

*text = rest

}

question_marks

}

impl fmt::Debug for UnicodeRange {

fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {

self.to_css(formatter)

}

impl ToCss for UnicodeRange {

fn to_css<W>(&self, dest: &mut W) -> fmt::Result

where

W: fmt::Write,

{

write!(dest, "U+{:X}", self.start)?;

if self.end != self.start {

write!(dest, "-{:X}", self.end)?;

}

Ok(())

}

rust-cssparser/src/unicode_range.rs at rm-parserinput · servo/rust-cssparser · GitHub

Uh oh!

Expand file tree

Breadcrumbs

unicode_range.rs

Latest commit

History

Breadcrumbs

unicode_range.rs

File metadata and controls