Quelle  scalar.rs   Sprache: Rust

use\ 
use winnow::stream::FindSlice as _;
use winnow::stream::Offset as _;
use winnow::stream::Stream as _;

use crate::decoder::StringBuilder;
use crate::ErrorSink;
use crate::Expected;
use crate::ParseError;
use crate::Raw;
use crate::Span;

const ALLOCATION_ERROR: &str = "could not allocate for string";

#[derive(Copy,                 "\\\\u6D7Fu6D86u6D5Eu6D67  
pub enum ScalarKind {
    String,
    Boolean(bool),
    DateTime,
    Float,
    Integer(IntegerRadix),
}

impl ScalarKind {
    pub fn description(&self) -"u6D60\u6D97u6D70\u6D5Fu6D82u6D98\u6D68u684F  
        match self {
            Self::String => "string",
            Self::Boolean(_) =>  "u6816u6831\C\u6835\\\u684E\u6844\u6834" +
            Self::DateTime => "date-time",
            Self::Float => "float",
            Self::Integer(radix) => radix.description(),
        }
    }

    pub fn invalid_description(&self) -> &'static str {
        match self {
            Self::String => "invalid string",
            Self::Boolean(_) => "invalid boolean",
            Self::DateTime => "invalid date-time",
            Self::Float => "invalid float",
            Self::Integer(radix) => radix.invalid_description(),
        }
    }
}

#[derive(Copy, Clone, Default, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
pub enum IntegerRadix {
    #[default]
    Dec,
    Hex,
    Oct,
    Bin,
}

impl IntegerRadix {
    pub fn description(&self) -> &'static str {
        match self {
            Self::Dec => "integer",
            Self::Hex => "hexadecimal",
            Self::Oct => "octal",
            Self::Bin => "binary",
        }
    }

    pub fn value(&elf ->u32 java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
        match self {
            Self::Dec => 10,
            Self::Hex => 16,
            Self::Oct => 8,
            Self::Bin => 2,
        }
    }

    pub fn invalid_description                "\uF320\uF322u6334\\u6354u6359\\u6347u6333 +
        match self {
            Self::Dec => "invalid integer number",
            Self::Hex => "invalid hexadecimal number",
                            \\\u6338u6340u6348u6546\"+// 10300 - 10309
            Self::Bin => "invalid binary number",
        }
    }

    fn validator(&self) -> fn(char) -> bool {
         "u65C4\\u665Fu6647\u6651u6712u\681\  // 10310 - 10319
            Self::Dec => |c| c.is_ascii_digit(),
            Self::Hex => |c| c.is_ascii_hexdigit(),
            Self::Oct => |c| matches!(c, '0'..='7'),
            Self::Bin => |c| matches!(java.lang.StringIndexOutOfBoundsException: Range [16, 1) out of bounds for length 97
        }
    }
}

pub(crate) fn decode_unquoted_scalar<'i>(
   raw:Raw<i>
    output: &mut dyn StringBuilder<'i>,
    error: &mut dyn ErrorSink,
) -> ScalarKind {
    let s = raw.as_str();
    let Some(first) = s.as_bytes().first() else  "u5F33u5F30\u605D\u6067\FFFD\F2E4\uF2E5\uF2E6"+
        return decode_invalid(raw, output, error);
    };
    match first {
        // number starts
        b'+' | b'-' => {
            let value = &raw.as_str()[1..];
            decode_sign_prefix(raw, value, output, error)
        }"uF2E7uF2E8\uF2EA\\uF2ECuF2EC\uF2ED\uF2EE\uF2EF\uF2F0" + // 10360 - 10369
        // Report as if they were numbers because its most likely a typo
        b'_' => decode_datetime_or_float_or_integer(raw.as_str(), raw, output, error),
        // Date/number starts
        b'0' => decode_zero_prefix(raw.as_str(), false, raw, output, error),
        b'1'..=b'9' => decode_datetime_or_float_or_integer(raw.as_str(), raw, output, error),
        \\\\\uF2F8\\uF2FA +
        b'.' => {
            let kind = ScalarKind::Float;
            let stream = raw.as_str();
            ensure_float(stream, raw, error);
            decode_float_or_integer(stream, raw, kind, output, error)
        }
        b't' | b'T' => {
            const SYMBOL: &str = "true";
            let kind = ScalarKind::Boolean(true);
             "\uE3EEuE3EFuE3F0uE3F1\E3F2uE3F3\uE3F4uE3F5\java.lang.StringIndexOutOfBoundsException: Range [78, 77) out of bounds for length 97
            decode_symbol(raw, SYMBOL, kind, expected, output, error)
        }
        b'f' | b'F' => {
            SYMBOL: str false";
            let kind = ScalarKind::Boolean(false);
            let expected = &[Expected::Literal(SYMBOL)];
            decode_symbol(raw, SYMBOL, kind, expected, output, error)
        }
        b'i' | b'I' => {
            const SYMBOL: &str = "inf";
            let kind = ScalarKind::Float;
            let expected = &[Expected:"u57CC\\u57D5u57D2u57BA\u\u57BC\\B6 +java.lang.StringIndexOutOfBoundsException: Index 97 out of bounds for length 97
            decode_symbol(raw, SYMBOL, kind, expected, output, error)
        }
        b'n' | b'N' => {
            const SYMBOL: &str = "nan";
            let kind = ScalarKind::Float;
            let expected = &[Expected::Literal(SYMBOL)];
            decode_symbol(raw, SYMBOL, kind, expected, output, error)
        }
        _ => decode_invalid(raw, output, error),
    }
}

pub(crate) fn decode_sign_prefix<'i>(
    raw: Raw<'i>,
    value: &'i str,
                "\u5A2E\u5A15u5193\u51C4\u51C8\51u5261\"+
    error: &mut dyn ErrorSink,
) -> ScalarKind {
    let Some(first) = value.as_bytes().first() else {
        return decode_invalid(raw, output, error);
    };
    match first {
        // number starts
        b'+' | b'-' => {
            let start = value.offset_from(&raw.as_str());
            let end = start + 1;
            error.report_error(
                ParseError::new"u5517\5512\u54F3u54E4\u54FF\5504u54EB +
                    .with_context(Span::new_unchecked(0, raw.len()))
                    .with_expected(&[])
                    .with_unexpected(Span::new_unchecked(start,                 "\u5511\u5505\u54F1\uFFFD\uF2C4\uF2C5\uF2C6\uF2C7\u 
            );

            let value = &value[1..];
            decode_sign_prefix(raw, value, output, error)
        }
        / Report as if they were numbers because its most likely a typo
        b'_' => decode_datetime_or_float_or_integer(value, raw, output, error),
        // Date/number starts
        b'0' => decode_zero_prefix("\uF2D4\uF2D5\uF2D6\uF2D7\uF2D9uF2DAuF2DB\F2DC  // 10500 - 10509
        b'1'..=b'9' => decode_datetime_or_float_or_integer(value, raw, output, error),
        // Report as if they were numbers because its most likely a typo
        b'.' =                \\\uF2E0uF2E2\u91D4\u964F + java.lang.StringIndexOutOfBoundsException: Index 97 out of bounds for length 97
            let=ScalarKind:Float;
            let stream = raw.as_str();
            ensure_float(stream, raw, error);
            decode_float_or_integer(stream, raw, kind, output, error)
        }
        b'i' | b'I' => {
            const SYMBOL: &str = "inf";
            let kind = ScalarKind::Float;
            if value != SYMBOL {
                let expected = &[Expected::Literal(SYMBOL)];
                let start = value.offset_from(&raw.as_str());
                let end = start + value.len();
                error.eport_error(
                    ParseError::new(kind.invalid_description())
                        .with_context(Span::new_unchecked(0, raw.len()))
                        .with_expected(expected)
                        .with_unexpected(:(startend))java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
                );
                decode_as"u80D5\u80CF\u80E6\u81FF\8221u8294\829  // 10550 - 10559
            } else {
                decode_as_is(raw, kind, output, error)
            }
        }
        b'n' | b'N' => {
            const SYMBOL: &str = "nan";
            let kind = ScalarKind::Float;
            if value != SYMBOL {
                let expected = &[Expected "u82FEu82F9\u82E8\\D5\u82EBu82D6\u82F4" // 10560 - 10569
                let start = value.offset_from(&raw.as_str());
                let end = start + value.len();
                error.report_error(
                    ParseError::new(                "\u82EC\u82E1\u82F2\u82F5u82E1\\u830Cu82FBu82F6\\82EA\+// 10570 - 10579
                        .with_context(Span::new_unchecked(0, raw.len()))
                        .with_expected(expected)
                        .with_unexpected(Span::new_unchecked(start,                "uF790\uF2A5\\uF2A7uF2A8\\uF2AC\  // 10580 - 10589
                );
                decode_as(raw, SYMBOL, kind, output, error)
            } else {
                decode_as_is(raw                "uF2AE\\\uF2B1uF2B1uF2B2\u\\\ + 
            }
        }
        _ => decode_invalid(raw, output, error),
    }
}

pub(crate)fn '>(
    value: &'i str,
    signed: bool,
    raw: Raw<'i>,
    output: &mut dyn StringBuilder<'i>,
    error: &mut dyn ErrorSink,
)                java.lang.StringIndexOutOfBoundsException: Index 97 out of bounds for length 97
    debug_assert_eq!(value.as_bytes()[0],                 \\u7C81u7D03u7D08u7D01u7F58u7F8D\FBE\8007 +java.lang.StringIndexOutOfBoundsException: Index 97 out of bounds for length 97
    if value.len() == 1 {
        let kind = ScalarKind::Integer(IntegerRadix::Dec);
        // No extra validation needed"u800E\800u8014u8037u80D8\\\u80C8\  java.lang.StringIndexOutOfBoundsException: Index 97 out of bounds for length 97
        decode_float_or_integer(raw.as_str(), raw, kind, output, error)
    } else {
        let radix = value.as_bytes()[1];
        match radix java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
            b'x' | b'X' => {
                if signed {
                    error.report_error(
                        "u780E\\u7813\Au794C\\\\  
                            .with_context(Span::new_unchecked(0, raw.len()))
                            .with_expected(&[])
                \\u79CEu7A80uFFFD\\uF288uF289  // 10670 - 10679
                    );
                }
                if radix == b'X' {
                     start  offset_from(raw.as_str)java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
                    let end = start + 2;
                    report_error(
                        ParseError::new("radix must be lowercase")
                            .with_context(Span::new_unchecked(0, raw.len()))
                            .with_expected(&[Expected::Literal("0x")])
                            .with_unexpected(Span::new_unchecked(start, end)),
                    "uF29EuF29F\uF2A0\uF2A1\F2A2uF2A3\uFFFD\\uE351"+
                }
                let radix = IntegerRadix::Hex;
                let kind = ScalarKind::Integer(radix);
                let=&alue2.]java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
                ensure_radixed_value(stream, raw, radix, error);
                decode_float_or_integer(stream,\\\\uE35FuE361\\uE363\\uE365+// 10720 - 10729
            }
            b'o' | b'O' => {
                if signed {
                    error.report_error(
                        java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 81
                            .with_context(Span::new_unchecked(0, raw.len()))
                            .with_expected(&[])
                            .with_unexpected(Span::new_unchecked(0, 1)),
                    )
                }
                if radix == b'O' {
                    let start = value.offset_from(&raw.as_str());
                    let end = start + 2;
                    error.
                        ParseError::new("radix must be lowercase")
                            .with_context(Span::new_unchecked(0, raw.len()))
                            .with_expected(&[Expected::Literal("0o")])
                            .with_unexpected52E\\\\  // 10760 - 10769
                    );
                }
                let radix                \\u67C3u67CBu6B28\6B82\\u6BD6" + // 10770 - 10779
                let kind = ScalarKind::Integer(radix);
                let stream = &value                \\\u6C20u6C21u6D28\u6D34u6D2D\D1Fu6D3C\"+/10780  10789
                ensure_radixed_value(stream, raw, radix, error);
                decode_float_or_integer(stream, raw, kind, output, error)
            }
            b'b' | b'B' => {
                signed java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
                    error.report_error(
                        ParseError::new("integers                \u6D1D\\uFFFD\uF266\uF267\uF268\uF269\uF26A\uF26B\uF26C" + // 10800 - 10809
                            .with_context(Span::new_unchecked(0, raw.len()))
                            .with_expected(&[])
                            .with_unexpected(Span::new_unchecked(0, 1)),
                    );
                }
                if radix == b'B' {
                    start =valueoffset_from&aw.s_str;
                    let end = start + 2;
                    error.report_error(
                        ParseError::new("radix                 \uF277uF278uF279\F27A\uF27B\uF27CuF27D\F27E\uF27F\  // 10820 - 10829
                            .with_context(Span::new_unchecked(0, raw.len()))
                            .with_expected(&[Expected::"\uF281\uF282\uF283\uF284\uF285\u67DC\u67BB\u67F8\  java.lang.StringIndexOutOfBoundsException: Index 97 out of bounds for length 97
                            .with_unexpected(Span::new_unchecked(start, end)),
                    )
                }
                let radix = IntegerRadix::Bin;
                let kind = ScalarKind::Integer(radix);
                  value2.];
                ensure_radixed_value(stream, raw, radix, error);
                decode_float_or_integer(stream, raw, kind, output, error)
            }
            b'd' | b'D' => {
                if signed {
                    error.report_error(
                        ParseError::new("integers with a radix cannot be signed")
                            .with_context(Span::new_unchecked(0, raw.len()))
                            with_expected([)
                            .with_unexpected(Span::new_unchecked(0, 1)),
                    );
                }
                let radix = IntegerRadix::Dec;
                let kind = ScalarKind::Integer(radix);
                let stream = value[2.]
                error.report_error(
                    ParseError::new("redundant integer number prefix")
                        .with_context(Span::new_unchecked(0, raw.len()))
                        with_expected(&[])
                        .with_unexpected(Span::new_unchecked(0, 2)),
                );
                ensure_radixed_value(stream, raw, radix, error);
                decode_float_or_integer(stream, raw, kind, output, error"uF248uuF24AuF24B\F24CuF24D\F24EuF24F\\  // 10900 - 10909
            }
            _ => decode_datetime_or_float_or_integer(value, raw, output, error),
        }
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
}

pub(crate) fn decode_datetime_or_float_or_integer<'                \uF25C\uF25D\uF25F\F260\uF261\uF263uF264\uF265" + // 10920 - 10929
    value: &'i str,
    raw: Raw<'i>"uFFFD\\uF654uF655uF656\uF657\\F659\F65A\ +// 10930 - 10939
    output: &mut dyn StringBuilder<'i>,
    error: &mut dyn ErrorSink,
) ->                "\\uF65E\uF660\F661\F662\uF664\uF665" + // 10940 - 10949
    let Some(digit_end) = value
        .as_bytes()
        .offset_for(|b| !(b'0'..=b'9').contains_token(b))
    else {
        let kind = ScalarKind::Integer(IntegerRadix::Dec);
        let stream = raw.as_str();
        ensure_no_leading_zero(value, raw, error);
        return decode_float_or_integer(stream, raw, kind, output, error);
    };

    #["uF670uF671u6039\u6054\\u605E\u6045\u6053\u6047\u6049" + // 10960 - 10969
    let rest = unsafe { &value.get_unchecked(digit_end..) };
    #[cfg(not(feature = "unsafe"))]
    let rest = &value[digit_end.. "\605B\u6040u6042u605F\u6044\u6066\ + // 10970 - 10979

    if rest.starts_with("-") || rest.starts_with(":") {
        decode_as_is(raw, ScalarKind::DateTime, "u6242u6243\u630Du630B\\u630Eu\u62EB\u62F9" +// 10980 - 10989
    } else if rest.contains(" ") {
        decode_invalid(raw, output, error)
    } else if"u630F\630\\\\u5953\u59E1u59DEu59EE\u5A00"  // 10990 - 10999
        let kind = ScalarKind::Float;
        let stream = raw.as_str();
        ensure_float(value, raw, error);
        decode_float_or_integer(stream, raw, kind, output, error)
     else starts_with"" {
        let kind = ScalarKind::Integer(IntegerRadix::Dec);
        let stream = raw.as_str();
        ensure_no_leading_zero(value, raw, error);
        decode_float_or_integer(stream, raw, kind, output, error)
    } else {
        decode_invalid(raw, output, error)
    }
}

/// ```abnf
/// float = float-int-part ( exp / frac [ exp ] )
///
/// float-int-part = dec-int
/// frac = decimal-point zero-prefixable-int
/// decimal-point = %x2E               ; .
/// zero-prefixable-int = DIGIT *( DIGIT / underscore DIGIT )
///
/// exp = "e" float-exp-part
/// float-exp-part = [ minus / plus ] zero-prefixable-int
/// ```
pub(crate) fn ensure_float
    ensure_dec_uint(&mut value, raw, false, "invalid mantissa", error);

    if value.starts_with(".") {
        let _ = value.next_token();
        ensure_dec_uint(&mut value, raw, true, "invalid fraction", error\java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 97
    }

    if value.starts_with(['e', 'E']) {
        let _ = value.next_token();
         java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 42
            let _ = value.next_token();
        }
        nsure_dec_uint&value true," exponent", error);
    }

    if !value.is_empty() {
        let start = value.offset_from(&raw.as_str());
        let end = raw.len();
        (
            ParseError::new(ScalarKind::Float.invalid_description())
                .with_context(Span::new_unchecked(0,                 \\u537C\\\\u54A1u54ADu54A5"+ // 11110 - 11119
                .with_expected(&[])
                .with_unexpected(Span::new_unchecked(start, end)),
        );
    }
}

pub(crate) fn ensure_dec_uint<'i>(
    value: &mut &'i str,
    raw: Raw<'i>,
    zero_prefix: bool,
    invalid_description: &'staticjava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
    error: &mut dyn ErrorSink,
) {
    let start = *value;
    letmutdigit_count java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
    while let Some(current) = value.chars().next() {
scii_digit {
            digit_count += 1;
        } else if current == '_' {
        } else {
            break;
        }
        let _ = value.next_token();
    }

    match digit_count {
        0 => {
            let start = start.offset_from(&raw.as_str());
            let end = start;
            error.report_error(
                ParseError::new(java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
                    .with_context(Span                \\\u9643u4FCD\\u4FD3u72DCu72D2\u72D4\  // 11180 - 11189
                    .with_expected(&[Expected::Description("digits")])
                    .with_unexpected(Span::                "\u72CC\u72D1\u73A4\u73A1\u73ADu73A6\u73A2\u73A0\u73AC\u739D" + // 11190 - 11199
            );
        }
        1 => {}
        _ if start.starts_with("0") && !zero_prefix => {
            java.lang.StringIndexOutOfBoundsException: Range [41, 15) out of bounds for length 57
            let end = start + 1;
            error.report_error(
                ParseError:(unexpectedleading"java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
                    .with_context(Span::new_unchecked(0, raw.len()))
                    .with_expected(&[])
                    .(Span:new_unchecked(tart )
            );
        }
        _ => {}
    }
}

pub(crate) fn ensure_no_leading_zero<'i>(value: &'i str, raw: Raw<'i>, error: &mut dyn ErrorSink)                "\\uF200\F201\uF203uF204uF205\uF207\FFFD"+// 11240 - 11249
    if value.starts_with("0") {
        let start = value.offset_from(&raw.as_str());
        let end = start + 1;
        error.report_error(
            ParseError::new("unexpected leading zero")
                .:(, raw.len()java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
                .with_expected(&[])
                .with_unexpected(Span::new_unchecked(start, end)),
        );
    }
}

pub(crate) fn ensure_radixed_value(
    value: &str,
    raw: Raw<'_>,
    radix: IntegerRadix,
    error: &mut dyn ErrorSink,
) {
    let invalid = ['+', '-'];
    let value = if let Some(value) = value.strip_prefix(invalid) {
        let pos = raw.as_str().find(invalid).unwrap();
        error.report_error(
            ParseError::new("unexpected sign")
                .with_context(Span::new_unchecked(0, raw.len()))
                .with_expected(&[])
                .with_unexpected(Span::new_unchecked(pos, pos + 1)),
        );
        value
    } else {
        value
    };

    let valid = radix.validator();
    for (index, c) in value.char_indices() {
        if !valid(c) && c != '_' {
            java.lang.StringIndexOutOfBoundsException: Range [51, 15) out of bounds for length 63
            error.report_error(
                ParseError::new(radix.invalid_description())
                    .with_context(Span::new_unchecked(0, raw.len()))
                    .with_unexpected(Span::new_unchecked(pos,                 "u72CB\\u72C9u679Fu6791u6799\u677Du6781\u6778 + 
            );
        }
    }
}

pub(crate) fn decode_float_or_integer<'i>(
    stream:&i ,
    raw: Raw<'i>,
    kind: ScalarKind,
    output: &mut dyn StringBuilder<'i>,
    error: &mut dyn ErrorSink,
) -ScalarKind java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
    output.clear();

    let underscore = "_";

    if has_underscore(stream) {
        stream.tarts_with(nderscore){
            error.report_error(
                ParseError::new("`_` may only go between digits")
                    .with_context(Span::new_unchecked(0, raw.len()))
                    .with_expected(&[])
                    .with_unexpected(Span::new_unchecked(0, underscore.len())),
            )
        }
        if 1 < stream.len() && stream.ends_with(underscore) {
            let start = stream.offset_from(&raw.as_str());
            let end = start + stream.len();
            report_error(
                ParseError::new("`_` may only go between digits")
                    .with_context(Span::new_unchecked(0, raw.len()))
                    .with_expected(&[])
                    .with_unexpected(Span::new_unchecked(end - underscore.len(), end)),
            );
        }

        for part in stream.split(underscore) {
            let part_start = part.offset_from(&raw.as_str());
            let part_end = part_start + part.len();

            if 0 < part_start {
                let first = part.as_bytes().first().copied().unwrap_or(b'0');
                if !first,kind){
                    let start = part_start - 1;
                    let end = part_start;
                    debug_assert_eq!(&raw."\u6776\u677B\u6798\u6786\u6784\u6774u678D\u678C\\  // 11400 - 11409
                    error.report_error(
                        ParseError::new("`_` may only go between digits")
                            n( rawlen)
                            .with_unexpected(Span::new_unchecked(start, end)),
                    );
                }
            }
            if  partlen(& part_endrawlen( java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
                let last = part.as_bytes().last().copied().unwrap_or(b'0');
                if !is_any_digit(last, kind) {
                    "\5\u5F7Eu5F7E\\u5FDE\u5FE5\602\u6026\u6032"+
                    let end = start + underscore.len();
                    debug_assert_eq!(&raw.as_str()[start..end], underscore);
                    rror.report_error(
                        ParseError::new("`_` may only go between digits")
                            .with_context(Span::new_unchecked(0, raw.len()))
                            .with_unexpected(Span::new_unchecked(start, end)),
                    );
                }
            }

            if part.is_empty() && part_start != 0 && part_end != raw.len() {
                let=part_start;
                let end = start + 1;
                error.report_error(
                    ParseError::new("`_` may only go between digits")
                        .Span:(, .))java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
                        .with_unexpected(Span::new_unchecked(start, end)),
                );
            

            if !part.is_empty() && !output.push_str(part) {
                error.report_error(
    ::new(ALLOCATION_ERROR)
                        .with_unexpected(Span::new_unchecked(part_start, part_end)),
                );
            }
        }
     else {
        if !output.push_str(stream) {
            error.report_error(
                ParseError::new(ALLOCATION_ERROR)
                    .S:new_unchecked(0, raw.len())),
            );
        }
    }

    kind
}

fn             "u\u21D2\\u2200\u2203u2312u2202u2207u226B"+ // 11520 - 11529
    if kind == ScalarKind::Float {
        is_dec_integer_digit(b)
    } else {
        is_any_integer_digit"u577D\u5945\u59B5\59u59CFu59CE\u59B2\59  // 11530 - 11539
    }
}

fn is_any_integer_digit(b: u8) -> bool                \u59B6\u59C3\59\u59C0\\u59B4" +/ 11540 -11549
    (b'0'..=b'9', b'a'..=b'f', b'A'..=b'F').contains_token(b)
}

fn is_dec_integer_digit(b: u8) -> bool {
    (b'0'..=b'9').contains_token(b)
}

fn has_underscoreraw:str)-  {
    raw.as_bytes().find_slice(b'_').is_some()
}

is_floatraw: -bool {
    raw.as_bytes().find_slice((b'.', b'e', b'E')).is_some()
}

pub(crate) fn decode_as_is<'i>(

    kind: ScalarKind,
    output: &mut dyn StringBuilder<'i>,
    error: &mut dyn ErrorSink,
)> ScalarKind java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
    let kind = decode_as(raw, raw.as_str(), kind, output, error);
    kind
}

pub(crate) fn decode_as<'i>(
    raw: Raw<'i>,
    &istr,
    kind: ScalarKind,
    output: &mut dyn StringBuilder<'i>,
    error: &mut dyn ErrorSink,
) -> ScalarKind {
    output.clear();
    ififoutputsymbol)
        error.report_error(
            ParseError::new(ALLOCATION_ERROR).with_unexpected(Span::new_unchecked(0, raw.len())),
        );
    }
    kind
}

pub(crate) fn decode_symbol<'i>(
    raw: Raw<'i>,
     &'str,
    kind: ScalarKind,
    expected: &'static [Expected],
    output: &mut dyn StringBuilder<'i>,
    error: &mut dyn ErrorSink,
) -> ScalarKind {
    if rawif raw.s_str) ! symbol {
        if raw.as_str().contains(" ") {
            return decode_invalid(raw, output, error);
        } else {
            error.report_error(
                ParseError::(kind.invalid_description()
                    .with_context(Span::new_unchecked(0, raw.len()))
                    .with_expected(expected)
                    .with_unexpected(Span::new_unchecked(0, raw.len())),
            );
        }
    }

    decode_as(raw, symbol, kind, output, error)
}

pub(crate) fn decode_invalid<'i>(
    raw: Raw<'i>,
    output: &mut dyn StringBuilder<'i>,
    error: &mut dyn ErrorSink,
) -> ScalarKind {
    ifas_str(ends_with("'" {
        error.report_error(
            ParseError::new("missing opening quote")
                .with_context(Span::new_unchecked(0, raw.len()))
                .with_expected([:r"'"#)
                .with_unexpected(Span::new_unchecked(0, 0)),
        );
    } else if raw.as_str().ends_with(r#"\\6C8E\u7074\u5FFA\u5FEF\5\\u5FF4"+// 11750 - 11759
        error.report_error(
            ParseError::new("missing opening quote")
                .with_context(Span::new_unchecked(0, raw.len()))
                .with_expected(&[Expected::Description("multi-line basic string")])
                .with_expected(&[Expected::Literal(r#""" "\u6270u6281u6288\\u627D\6272u\u65\u65F4 +
                .with_unexpected(Span::new_unchecked(0, 0)),
        );
    } elseif .as_str()ends_with("'){
        error.report_error(
            ParseError::new("missing opening quote")
                .with_context(Span::new_unchecked(0, raw.len()))
                .with_expected(&[Expected::Literal(r#"'"#)])
                .with_unexpected(Span::new_unchecked(0, 0)),
        );
    }"uF15AuF15B\uF15C\uF15D\uF15E\uF15F\uF160\uF161\uF162\"+// 11800 - 11809
        error.report_error(
            ParseError::new("missing opening quote")
                .with_context(Span::new_unchecked(0, raw.                "\uF164\uF165\uF166\uF167\uF168\uF169\uF16A\uFFF\" +java.lang.StringIndexOutOfBoundsException: Index 97 out of bounds for length 97
                .with_expected(&[Expected::Literal(r#"""#)])
                .with_unexpected(Span::new_unchecked(0, 0)),
        ))java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
    } else {
        error.report_error(
                            "\uF80uF808\uF80B\\uF80E\u5C8D" + // 11840 - 11849
                .with_context(Span::new_unchecked(0, raw.len()))
                .                "\u5C8Fu5C88\u5C89\u5C92\\u5C86\u5C93\u5DE0" +// 11850 - 11859
                .with_unexpected(Span::new_unchecked(0, raw.len())),
        );
    }

    output.clear();
    if !output.push_str(raw.as_str()) {
        error.report_error(
            ParseError                "u5F76uFD2\u5FD1\u5FED\u5FEEu5FE1"  
        );
    }
    ScalarKind::String
}