xref: /commonlibrary/rust/ylong_json/src/states.rs

16     consts::*, deserializer::Deserializer, Array, Error, JsonValue, Number, Object, ParseError,
23     ($deserializer: expr) => {{
24         let position = $deserializer.reader.position();
25         match read_error_char($deserializer) {
36     ($deserializer: expr) => {
37         Err(ParseError::UnexpectedEndOfJson($deserializer.reader.position().line()).into())
42     ($deserializer: expr) => {{
44             match $deserializer.reader.peek().map_err(Error::new_reader)? {
45                 Some(ch) if WHITE_SPACE_SET.contains(&ch) => $deserializer.reader.discard(),
53     ($deserializer: expr) => {{
55             match $deserializer.reader.peek().map_err(Error::new_reader)? {
56                 Some(ch) if (ZERO..=NINE).contains(&ch) => $deserializer.reader.discard(),
64     ($deserializer: expr, $str: expr) => {{
66             match $deserializer.reader.peek().map_err(Error::new_reader)? {
67                 Some(ch) if ch == *item => $deserializer.reader.discard(),
68                 Some(_) => return unexpected_character!($deserializer),
69                 None => return unexpected_eoj!($deserializer),
76     deserializer: &mut Deserializer<R>,
78     if deserializer.recursion_depth > RECURSION_LIMIT {
87     deserializer: &mut Deserializer<R>,
89     let value = parse_value(deserializer)?;
92     if eat_whitespace_until_not!(deserializer).is_some() {
93         return Err(ParseError::TrailingBytes(deserializer.reader.position().line()).into());
99 fn parse_value<R: Cacheable>(deserializer: &mut Deserializer<R>) -> Result<JsonValue, Error> {
100     match eat_whitespace_until_not!(deserializer) {
101         Some(ZERO..=NINE | MINUS) => Ok(JsonValue::Number(parse_number(deserializer)?)),
103             deserializer.reader.discard();
104             parse_object(deserializer)
107             deserializer.reader.discard();
108             parse_array(deserializer)
111             deserializer.reader.discard();
112             Ok(JsonValue::String(parse_string(deserializer)?))
115             deserializer.reader.discard();
116             match_str!(deserializer, TRUE_LEFT_STR);
120             deserializer.reader.discard();
121             match_str!(deserializer, FALSE_LEFT_STR);
125             deserializer.reader.discard();
126             match_str!(deserializer, NULL_LEFT_STR);
129         Some(_) => unexpected_character!(deserializer),
130         None => unexpected_eoj!(deserializer),
135 fn parse_object<R: Cacheable>(deserializer: &mut Deserializer<R>) -> Result<JsonValue, Error> {
143     deserializer.recursion_depth += 1;
144     check_recursion(deserializer)?;
152         match (state, eat_whitespace_until_not!(deserializer)) {
155                 deserializer.reader.discard();
156                 deserializer.recursion_depth -= 1;
162                 deserializer.reader.discard();
163                 let k = parse_key(deserializer)?;
166                 match eat_whitespace_until_not!(deserializer) {
167                     Some(COLON) => deserializer.reader.discard(),
168                     Some(_) => return unexpected_character!(deserializer),
169                     None => return unexpected_eoj!(deserializer),
173                 object.insert(k, parse_value(deserializer)?);
179             (InnerState::Start, Some(_)) => return unexpected_character!(deserializer),
182                 deserializer.reader.discard();
186             (InnerState::NoComma, Some(_)) => return unexpected_character!(deserializer),
188             (InnerState::AfterComma, Some(_)) => return unexpected_character!(deserializer),
190             (_, None) => return unexpected_eoj!(deserializer),
199     deserializer: &mut Deserializer<R>,
201     let vec = parse_string_inner(deserializer)?;
208     deserializer: &mut Deserializer<R>,
210     let vec = parse_string_inner(deserializer)?;
217 fn parse_key<R: Cacheable>(deserializer: &mut Deserializer<R>) -> Result<String, Error> {
218     let vec = parse_string_inner(deserializer)?;
224     deserializer: &mut Deserializer<R>,
230     deserializer.reader.start_caching();
233         match deserializer.reader.peek().map_err(Error::new_reader)? {
238                     deserializer.reader.discard();
244                         vec.extend_from_slice(deserializer.reader.cached_slice().unwrap());
245                         deserializer.reader.end_caching();
246                         deserializer.reader.discard();
251                         vec.extend_from_slice(deserializer.reader.cached_slice().unwrap());
252                         deserializer.reader.discard();
253                         parse_escape_character(deserializer, &mut vec)?;
254                         deserializer.reader.start_caching();
259                         return unexpected_character!(deserializer);
263             None => return unexpected_eoj!(deserializer),
271     deserializer: &mut Deserializer<R>,
275         match deserializer.reader.peek().map_err(Error::new_reader)? {
285                 deserializer.reader.discard();
286                 return parse_unicode(deserializer, vec);
288             Some(_) => return unexpected_character!(deserializer),
289             None => return unexpected_eoj!(deserializer),
292     deserializer.reader.discard();
298     deserializer: &mut Deserializer<R>,
303     fn get_next_digit<R: Cacheable>(deserializer: &mut Deserializer<R>) -> Result<u16, Error> {
304         if let Some(ch) = deserializer.reader.peek().map_err(Error::new_reader)? {
309                 _ => return unexpected_character!(deserializer),
311             deserializer.reader.discard();
314         unexpected_eoj!(deserializer)
320         deserializer: &mut Deserializer<R>,
322         Ok(get_next_digit(deserializer)? << 12
323             | get_next_digit(deserializer)? << 8
324             | get_next_digit(deserializer)? << 4
325             | get_next_digit(deserializer)?)
329     let unicode1 = get_next_four_digits(deserializer)?;
333             match_str!(deserializer, UNICODE_START_STR);
336                 [unicode1, get_next_four_digits(deserializer)?]
353     deserializer: &mut Deserializer<R>,
356     deserializer.reader.start_caching();
364     if let Some(MINUS) = deserializer.reader.peek().map_err(Error::new_reader)? {
365         deserializer.reader.discard();
370     let mut next_ch = match deserializer.reader.peek().map_err(Error::new_reader)? {
374             deserializer.reader.discard();
377             deserializer.reader.peek().map_err(Error::new_reader)?
381             deserializer.reader.discard();
383             eat_digits_until_not!(deserializer)
385         Some(_) => return unexpected_character!(deserializer),
386         None => return unexpected_eoj!(deserializer),
391         deserializer.reader.discard();
395         match deserializer.reader.peek().map_err(Error::new_reader)? {
396             Some(ZERO..=NINE) => deserializer.reader.discard(),
397             Some(_) => return unexpected_character!(deserializer),
398             None => return unexpected_eoj!(deserializer),
401         next_ch = eat_digits_until_not!(deserializer)
406         deserializer.reader.discard();
409         match deserializer.reader.peek().map_err(Error::new_reader)? {
410             Some(PLUS | MINUS) => deserializer.reader.discard(),
412             None => return unexpected_eoj!(deserializer),
415         match deserializer.reader.peek().map_err(Error::new_reader)? {
416             Some(ZERO..=NINE) => deserializer.reader.discard(),
417             Some(_) => return unexpected_character!(deserializer),
418             None => return unexpected_eoj!(deserializer),
421         eat_digits_until_not!(deserializer);
426         unsafe { core::str::from_utf8_unchecked(deserializer.reader.cached_slice().unwrap()) };
435     deserializer.reader.end_caching();
439 fn parse_array<R: Cacheable>(deserializer: &mut Deserializer<R>) -> Result<JsonValue, Error> {
446     deserializer.recursion_depth += 1;
447     check_recursion(deserializer)?;
455         match (state, eat_whitespace_until_not!(deserializer)) {
461                 array.push(parse_value(deserializer)?);
470                 deserializer.reader.discard();
474             (InnerState::NoComma, Some(_)) => return unexpected_character!(deserializer),
476             (_, None) => return unexpected_eoj!(deserializer),
479     deserializer.reader.discard();
480     deserializer.recursion_depth -= 1;
485     deserializer: &mut Deserializer<R>,
499     let x = match deserializer.reader.next().map_err(Error::new_reader)? {
509         let y = match deserializer.reader.next().map_err(Error::new_reader)? {
517             let z = match deserializer.reader.next().map_err(Error::new_reader)? {
526                 let w = match deserializer.reader.next().map_err(Error::new_reader)? {
564             deserializer: &mut Deserializer<R>,
566             Ok(eat_whitespace_until_not!(deserializer))
569         let mut deserializer = Deserializer::new_from_slice(b"      n");
570         assert_eq!(test_func(&mut deserializer).unwrap(), Some(b'n'));
572         let mut deserializer = Deserializer::new_from_slice(b"      ");
573         assert_eq!(test_func(&mut deserializer).unwrap(), None);
575         let mut deserializer = Deserializer::new_from_io(ErrorIo);
576         assert!(test_func(&mut deserializer).is_err());
591             deserializer: &mut Deserializer<R>,
593             Ok(eat_digits_until_not!(deserializer))
596         let mut deserializer = Deserializer::new_from_slice(b"1234n");
597         assert_eq!(test_func(&mut deserializer).unwrap(), Some(b'n'));
599         let mut deserializer = Deserializer::new_from_slice(b"1234");
600         assert_eq!(test_func(&mut deserializer).unwrap(), None);
602         let mut deserializer = Deserializer::new_from_io(ErrorIo);
603         assert!(test_func(&mut deserializer).is_err());
619             deserializer: &mut Deserializer<R>,
622             Ok(match_str!(deserializer, target))
625         let mut deserializer = Deserializer::new_from_slice(b"1234");
626         assert!(test_func(&mut deserializer, b"1234").is_ok());
628         let mut deserializer = Deserializer::new_from_io(ErrorIo);
629         assert!(test_func(&mut deserializer, b"1234").is_err());
643         let mut deserializer = Deserializer::new_from_slice(b"null");
644         assert_eq!(start_parsing(&mut deserializer).unwrap(), JsonValue::Null);
646         let mut deserializer = Deserializer::new_from_slice(b"null      invalid");
647         assert!(start_parsing(&mut deserializer).is_err());
661         let mut deserializer = Deserializer::new_from_slice("?".as_bytes());
662         assert_eq!(read_error_char(&mut deserializer).unwrap(), Some('?'));
664         let mut deserializer = Deserializer::new_from_slice(&[]);
665         assert_eq!(read_error_char(&mut deserializer).unwrap(), None);
667         let mut deserializer = Deserializer::new_from_slice(&[0xf0]);
668         assert_eq!(read_error_char(&mut deserializer).unwrap(), None);
670         let mut deserializer = Deserializer::new_from_slice(&[0xf0, 0xa4]);
671         assert_eq!(read_error_char(&mut deserializer).unwrap(), None);
673         let mut deserializer = Deserializer::new_from_slice(&[0xf0, 0xa4, 0xad]);
674         assert_eq!(read_error_char(&mut deserializer).unwrap(), None);
688         let mut deserializer = Deserializer::new_from_slice(b"null");
689         assert_eq!(parse_value(&mut deserializer).unwrap(), JsonValue::Null);
691         let mut deserializer = Deserializer::new_from_slice(b"true");
693             parse_value(&mut deserializer).unwrap(),
697         let mut deserializer = Deserializer::new_from_slice(b"false");
699             parse_value(&mut deserializer).unwrap(),
703         let mut deserializer = Deserializer::new_from_slice(b"123");
704         assert!(parse_value(&mut deserializer).is_ok());
706         let mut deserializer = Deserializer::new_from_slice(b"\"abc\"");
707         assert!(parse_value(&mut deserializer).is_ok());
709         let mut deserializer = Deserializer::new_from_slice(b"[1, 2, 3]");
710         assert!(parse_value(&mut deserializer).is_ok());
712         let mut deserializer = Deserializer::new_from_slice(b"{\"key\":\"value\"}");
713         assert!(parse_value(&mut deserializer).is_ok());
715         let mut deserializer = Deserializer::new_from_slice(b"\"abc\"");
716         assert!(parse_value(&mut deserializer).is_ok());
739         let mut deserializer = Deserializer::new_from_slice(str.as_bytes());
741         assert_eq!(parse_string(&mut deserializer).unwrap(), String::from(""));
744             parse_string(&mut deserializer).unwrap(),
750         let mut deserializer = Deserializer::new_from_slice(str.as_bytes());
753             parse_string(&mut deserializer).unwrap(),
758             parse_string(&mut deserializer).unwrap(),
764         let mut deserializer = Deserializer::new_from_slice(str.as_bytes());
767             parse_string(&mut deserializer).unwrap(),
774             parse_string(&mut deserializer).unwrap(),
782         let mut deserializer = Deserializer::new_from_slice(str.as_bytes());
784         assert_eq!(parse_string(&mut deserializer).unwrap(), String::from("?"),);
787             parse_string(&mut deserializer).unwrap(),
794         let mut deserializer = Deserializer::new_from_slice(str.as_bytes());
795         assert!(parse_string(&mut deserializer).is_err());
799         let mut deserializer = Deserializer::new_from_slice(str.as_bytes());
800         assert!(parse_string(&mut deserializer).is_err());
804         let mut deserializer = Deserializer::new_from_slice(str.as_bytes());
805         assert!(parse_string(&mut deserializer).is_err());
809         let mut deserializer = Deserializer::new_from_slice(str.as_bytes());
810         assert!(parse_string(&mut deserializer).is_err());
813         let mut deserializer = Deserializer::new_from_slice(str.as_bytes());
814         assert!(parse_string(&mut deserializer).is_err());
817         let mut deserializer = Deserializer::new_from_slice(str.as_bytes());
818         assert!(parse_string(&mut deserializer).is_err());
821         let mut deserializer = Deserializer::new_from_slice(str.as_bytes());
822         assert!(parse_string(&mut deserializer).is_err());
826         let mut deserializer = Deserializer::new_from_slice(str.as_bytes());
827         assert!(parse_string(&mut deserializer).is_err());
846         let mut deserializer = Deserializer::new_from_slice(str.as_bytes());
847         assert_eq!(parse_number(&mut deserializer).unwrap(), 0.into());
850         let mut deserializer = Deserializer::new_from_slice(str.as_bytes());
851         assert_eq!(parse_number(&mut deserializer).unwrap(), 0.into());
854         let mut deserializer = Deserializer::new_from_slice(str.as_bytes());
855         assert_eq!(parse_number(&mut deserializer).unwrap(), 1230.into());
860         let mut deserializer = Deserializer::new_from_slice(str.as_bytes());
861         assert!(parse_number(&mut deserializer).is_err());
865         let mut deserializer = Deserializer::new_from_slice(str.as_bytes());
866         assert!(parse_number(&mut deserializer).is_err());
870         let mut deserializer = Deserializer::new_from_slice(str.as_bytes());
871         assert!(parse_number(&mut deserializer).is_err());
875         let mut deserializer = Deserializer::new_from_slice(str.as_bytes());
876         assert!(parse_number(&mut deserializer).is_err());
880         let mut deserializer = Deserializer::new_from_slice(str.as_bytes());
883         assert_eq!(parse_number(&mut deserializer).unwrap(), 0.into());
887         let mut deserializer = Deserializer::new_from_slice(str.as_bytes());
890         assert_eq!(parse_number(&mut deserializer).unwrap(), 12.into());
894         let mut deserializer = Deserializer::new_from_slice(str.as_bytes());
895         assert!(parse_number(&mut deserializer).is_err());
898         let mut deserializer = Deserializer::new_from_slice(str.as_bytes());
899         assert!(parse_number(&mut deserializer).is_err());
902         let mut deserializer = Deserializer::new_from_slice(str.as_bytes());
905         assert_eq!(parse_number(&mut deserializer).unwrap(), (12.3).into());
909         let mut deserializer = Deserializer::new_from_slice(str.as_bytes());
912         assert_eq!(parse_number(&mut deserializer).unwrap(), (1234).into());
915         let mut deserializer = Deserializer::new_from_slice(str.as_bytes());
916         assert!(parse_number(&mut deserializer).is_err());
919         let mut deserializer = Deserializer::new_from_slice(str.as_bytes());
920         assert!(parse_number(&mut deserializer).is_err());
923         let mut deserializer = Deserializer::new_from_slice(str.as_bytes());
924         assert!(parse_number(&mut deserializer).is_err());
944         let mut deserializer = Deserializer::new_from_slice(str.as_bytes());
945         assert_eq!(parse_array(&mut deserializer).unwrap(), Array::new().into());
948         let mut deserializer = Deserializer::new_from_slice(str.as_bytes());
949         assert_eq!(parse_array(&mut deserializer).unwrap(), Array::new().into());
952         let mut deserializer = Deserializer::new_from_slice(str.as_bytes());
954         assert_eq!(parse_array(&mut deserializer).unwrap(), array.into());
961         let mut deserializer = Deserializer::new_from_slice(str.as_bytes());
963         assert_eq!(parse_array(&mut deserializer).unwrap(), array.into());
968         let mut deserializer = Deserializer::new_from_slice(str.as_bytes());
969         assert!(parse_array(&mut deserializer).is_err());
972         let mut deserializer = Deserializer::new_from_slice(str.as_bytes());
973         assert!(parse_array(&mut deserializer).is_err());
977         let mut deserializer = Deserializer::new_from_slice(str.as_bytes());
978         assert!(parse_array(&mut deserializer).is_err());
982         let mut deserializer = Deserializer::new_from_slice(str.as_bytes());
983         assert!(parse_array(&mut deserializer).is_err());
1003         let mut deserializer = Deserializer::new_from_slice(str.as_bytes());
1005             parse_object(&mut deserializer).unwrap(),
1010         let mut deserializer = Deserializer::new_from_slice(str.as_bytes());
1012         assert_eq!(parse_object(&mut deserializer).unwrap(), object.into());
1018         let mut deserializer = Deserializer::new_from_slice(str.as_bytes());
1020         assert_eq!(parse_object(&mut deserializer).unwrap(), object.into());
1025         let mut deserializer = Deserializer::new_from_slice(str.as_bytes());
1026         assert!(parse_object(&mut deserializer).is_err());
1030         let mut deserializer = Deserializer::new_from_slice(str.as_bytes());
1031         assert!(parse_object(&mut deserializer).is_err());
1035         let mut deserializer = Deserializer::new_from_slice(str.as_bytes());
1036         assert!(parse_object(&mut deserializer).is_err());
1040         let mut deserializer = Deserializer::new_from_slice(str.as_bytes());
1041         assert!(parse_object(&mut deserializer).is_err());
1044         let mut deserializer = Deserializer::new_from_slice(str.as_bytes());
1045         assert!(parse_object(&mut deserializer).is_err());
1049         let mut deserializer = Deserializer::new_from_slice(str.as_bytes());
1050         assert!(parse_object(&mut deserializer).is_err());
1053         let mut deserializer = Deserializer::new_from_slice(str.as_bytes());
1054         assert!(parse_object(&mut deserializer).is_err());
1079         let mut deserializer = Deserializer::new_from_slice(text.as_ref());
1080         assert!(start_parsing(&mut deserializer).is_ok());
1093         let mut deserializer = Deserializer::new_from_slice(text.as_ref());
1094         assert!(start_parsing(&mut deserializer).is_err());
1103         let mut deserializer = Deserializer::new_from_slice(text);
1104         assert!(start_parsing(&mut deserializer).is_ok());
1112         let mut deserializer = Deserializer::new_from_slice(text);
1113         assert!(start_parsing(&mut deserializer).is_err());

Indexes created Thu Nov 07 10:32:03 CST 2024