Adding upstream version 110.0.1.upstream/110.0.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 400 insertions, 0 deletions

diff --git a/third_party/rust/encoding_rs/src/variant.rs b/third_party/rust/encoding_rs/src/variant.rs
new file mode 100644
index 0000000000..dffaf053e3
--- /dev/null
+++ b/third_party/rust/encoding_rs/src/variant.rs
@@ -0,0 +1,400 @@
+// Copyright Mozilla Foundation. See the COPYRIGHT
+// file at the top-level directory of this distribution.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// THIS IS A GENERATED FILE. PLEASE DO NOT EDIT.
+// Instead, please regenerate using generate-encoding-data.py
+
+//! This module provides enums that wrap the various decoders and encoders.
+//! The purpose is to make `Decoder` and `Encoder` `Sized` by writing the
+//! dispatch explicitly for a finite set of specialized decoders and encoders.
+//! Unfortunately, this means the compiler doesn't generate the dispatch code
+//! and it has to be written here instead.
+//!
+//! The purpose of making `Decoder` and `Encoder` `Sized` is to allow stack
+//! allocation in Rust code, including the convenience methods on `Encoding`.
+
+use super::*;
+use big5::*;
+use euc_jp::*;
+use euc_kr::*;
+use gb18030::*;
+use iso_2022_jp::*;
+use replacement::*;
+use shift_jis::*;
+use single_byte::*;
+use utf_16::*;
+use utf_8::*;
+use x_user_defined::*;
+
+pub enum VariantDecoder {
+    SingleByte(SingleByteDecoder),
+    Utf8(Utf8Decoder),
+    Gb18030(Gb18030Decoder),
+    Big5(Big5Decoder),
+    EucJp(EucJpDecoder),
+    Iso2022Jp(Iso2022JpDecoder),
+    ShiftJis(ShiftJisDecoder),
+    EucKr(EucKrDecoder),
+    Replacement(ReplacementDecoder),
+    UserDefined(UserDefinedDecoder),
+    Utf16(Utf16Decoder),
+}
+
+impl VariantDecoder {
+    pub fn max_utf16_buffer_length(&self, byte_length: usize) -> Option<usize> {
+        match *self {
+            VariantDecoder::SingleByte(ref v) => v.max_utf16_buffer_length(byte_length),
+            VariantDecoder::Utf8(ref v) => v.max_utf16_buffer_length(byte_length),
+            VariantDecoder::Gb18030(ref v) => v.max_utf16_buffer_length(byte_length),
+            VariantDecoder::Big5(ref v) => v.max_utf16_buffer_length(byte_length),
+            VariantDecoder::EucJp(ref v) => v.max_utf16_buffer_length(byte_length),
+            VariantDecoder::Iso2022Jp(ref v) => v.max_utf16_buffer_length(byte_length),
+            VariantDecoder::ShiftJis(ref v) => v.max_utf16_buffer_length(byte_length),
+            VariantDecoder::EucKr(ref v) => v.max_utf16_buffer_length(byte_length),
+            VariantDecoder::Replacement(ref v) => v.max_utf16_buffer_length(byte_length),
+            VariantDecoder::UserDefined(ref v) => v.max_utf16_buffer_length(byte_length),
+            VariantDecoder::Utf16(ref v) => v.max_utf16_buffer_length(byte_length),
+        }
+    }
+
+    pub fn max_utf8_buffer_length_without_replacement(&self, byte_length: usize) -> Option<usize> {
+        match *self {
+            VariantDecoder::SingleByte(ref v) => {
+                v.max_utf8_buffer_length_without_replacement(byte_length)
+            }
+            VariantDecoder::Utf8(ref v) => {
+                v.max_utf8_buffer_length_without_replacement(byte_length)
+            }
+            VariantDecoder::Gb18030(ref v) => {
+                v.max_utf8_buffer_length_without_replacement(byte_length)
+            }
+            VariantDecoder::Big5(ref v) => {
+                v.max_utf8_buffer_length_without_replacement(byte_length)
+            }
+            VariantDecoder::EucJp(ref v) => {
+                v.max_utf8_buffer_length_without_replacement(byte_length)
+            }
+            VariantDecoder::Iso2022Jp(ref v) => {
+                v.max_utf8_buffer_length_without_replacement(byte_length)
+            }
+            VariantDecoder::ShiftJis(ref v) => {
+                v.max_utf8_buffer_length_without_replacement(byte_length)
+            }
+            VariantDecoder::EucKr(ref v) => {
+                v.max_utf8_buffer_length_without_replacement(byte_length)
+            }
+            VariantDecoder::Replacement(ref v) => {
+                v.max_utf8_buffer_length_without_replacement(byte_length)
+            }
+            VariantDecoder::UserDefined(ref v) => {
+                v.max_utf8_buffer_length_without_replacement(byte_length)
+            }
+            VariantDecoder::Utf16(ref v) => {
+                v.max_utf8_buffer_length_without_replacement(byte_length)
+            }
+        }
+    }
+
+    pub fn max_utf8_buffer_length(&self, byte_length: usize) -> Option<usize> {
+        match *self {
+            VariantDecoder::SingleByte(ref v) => v.max_utf8_buffer_length(byte_length),
+            VariantDecoder::Utf8(ref v) => v.max_utf8_buffer_length(byte_length),
+            VariantDecoder::Gb18030(ref v) => v.max_utf8_buffer_length(byte_length),
+            VariantDecoder::Big5(ref v) => v.max_utf8_buffer_length(byte_length),
+            VariantDecoder::EucJp(ref v) => v.max_utf8_buffer_length(byte_length),
+            VariantDecoder::Iso2022Jp(ref v) => v.max_utf8_buffer_length(byte_length),
+            VariantDecoder::ShiftJis(ref v) => v.max_utf8_buffer_length(byte_length),
+            VariantDecoder::EucKr(ref v) => v.max_utf8_buffer_length(byte_length),
+            VariantDecoder::Replacement(ref v) => v.max_utf8_buffer_length(byte_length),
+            VariantDecoder::UserDefined(ref v) => v.max_utf8_buffer_length(byte_length),
+            VariantDecoder::Utf16(ref v) => v.max_utf8_buffer_length(byte_length),
+        }
+    }
+
+    pub fn decode_to_utf16_raw(
+        &mut self,
+        src: &[u8],
+        dst: &mut [u16],
+        last: bool,
+    ) -> (DecoderResult, usize, usize) {
+        match *self {
+            VariantDecoder::SingleByte(ref mut v) => v.decode_to_utf16_raw(src, dst, last),
+            VariantDecoder::Utf8(ref mut v) => v.decode_to_utf16_raw(src, dst, last),
+            VariantDecoder::Gb18030(ref mut v) => v.decode_to_utf16_raw(src, dst, last),
+            VariantDecoder::Big5(ref mut v) => v.decode_to_utf16_raw(src, dst, last),
+            VariantDecoder::EucJp(ref mut v) => v.decode_to_utf16_raw(src, dst, last),
+            VariantDecoder::Iso2022Jp(ref mut v) => v.decode_to_utf16_raw(src, dst, last),
+            VariantDecoder::ShiftJis(ref mut v) => v.decode_to_utf16_raw(src, dst, last),
+            VariantDecoder::EucKr(ref mut v) => v.decode_to_utf16_raw(src, dst, last),
+            VariantDecoder::Replacement(ref mut v) => v.decode_to_utf16_raw(src, dst, last),
+            VariantDecoder::UserDefined(ref mut v) => v.decode_to_utf16_raw(src, dst, last),
+            VariantDecoder::Utf16(ref mut v) => v.decode_to_utf16_raw(src, dst, last),
+        }
+    }
+
+    pub fn decode_to_utf8_raw(
+        &mut self,
+        src: &[u8],
+        dst: &mut [u8],
+        last: bool,
+    ) -> (DecoderResult, usize, usize) {
+        match *self {
+            VariantDecoder::SingleByte(ref mut v) => v.decode_to_utf8_raw(src, dst, last),
+            VariantDecoder::Utf8(ref mut v) => v.decode_to_utf8_raw(src, dst, last),
+            VariantDecoder::Gb18030(ref mut v) => v.decode_to_utf8_raw(src, dst, last),
+            VariantDecoder::Big5(ref mut v) => v.decode_to_utf8_raw(src, dst, last),
+            VariantDecoder::EucJp(ref mut v) => v.decode_to_utf8_raw(src, dst, last),
+            VariantDecoder::Iso2022Jp(ref mut v) => v.decode_to_utf8_raw(src, dst, last),
+            VariantDecoder::ShiftJis(ref mut v) => v.decode_to_utf8_raw(src, dst, last),
+            VariantDecoder::EucKr(ref mut v) => v.decode_to_utf8_raw(src, dst, last),
+            VariantDecoder::Replacement(ref mut v) => v.decode_to_utf8_raw(src, dst, last),
+            VariantDecoder::UserDefined(ref mut v) => v.decode_to_utf8_raw(src, dst, last),
+            VariantDecoder::Utf16(ref mut v) => v.decode_to_utf8_raw(src, dst, last),
+        }
+    }
+
+    pub fn latin1_byte_compatible_up_to(&self, buffer: &[u8]) -> Option<usize> {
+        match *self {
+            VariantDecoder::SingleByte(ref v) => {
+                return Some(v.latin1_byte_compatible_up_to(buffer));
+            }
+            VariantDecoder::Utf8(ref v) => {
+                if !v.in_neutral_state() {
+                    return None;
+                }
+            }
+            VariantDecoder::Gb18030(ref v) => {
+                if !v.in_neutral_state() {
+                    return None;
+                }
+            }
+            VariantDecoder::Big5(ref v) => {
+                if !v.in_neutral_state() {
+                    return None;
+                }
+            }
+            VariantDecoder::EucJp(ref v) => {
+                if !v.in_neutral_state() {
+                    return None;
+                }
+            }
+            VariantDecoder::Iso2022Jp(ref v) => {
+                if v.in_neutral_state() {
+                    return Some(Encoding::iso_2022_jp_ascii_valid_up_to(buffer));
+                }
+                return None;
+            }
+            VariantDecoder::ShiftJis(ref v) => {
+                if !v.in_neutral_state() {
+                    return None;
+                }
+            }
+            VariantDecoder::EucKr(ref v) => {
+                if !v.in_neutral_state() {
+                    return None;
+                }
+            }
+            VariantDecoder::UserDefined(_) => {}
+            VariantDecoder::Replacement(_) | VariantDecoder::Utf16(_) => {
+                return None;
+            }
+        };
+        Some(Encoding::ascii_valid_up_to(buffer))
+    }
+}
+
+pub enum VariantEncoder {
+    SingleByte(SingleByteEncoder),
+    Utf8(Utf8Encoder),
+    Gb18030(Gb18030Encoder),
+    Big5(Big5Encoder),
+    EucJp(EucJpEncoder),
+    Iso2022Jp(Iso2022JpEncoder),
+    ShiftJis(ShiftJisEncoder),
+    EucKr(EucKrEncoder),
+    UserDefined(UserDefinedEncoder),
+}
+
+impl VariantEncoder {
+    pub fn has_pending_state(&self) -> bool {
+        match *self {
+            VariantEncoder::Iso2022Jp(ref v) => v.has_pending_state(),
+            _ => false,
+        }
+    }
+    pub fn max_buffer_length_from_utf16_without_replacement(
+        &self,
+        u16_length: usize,
+    ) -> Option<usize> {
+        match *self {
+            VariantEncoder::SingleByte(ref v) => {
+                v.max_buffer_length_from_utf16_without_replacement(u16_length)
+            }
+            VariantEncoder::Utf8(ref v) => {
+                v.max_buffer_length_from_utf16_without_replacement(u16_length)
+            }
+            VariantEncoder::Gb18030(ref v) => {
+                v.max_buffer_length_from_utf16_without_replacement(u16_length)
+            }
+            VariantEncoder::Big5(ref v) => {
+                v.max_buffer_length_from_utf16_without_replacement(u16_length)
+            }
+            VariantEncoder::EucJp(ref v) => {
+                v.max_buffer_length_from_utf16_without_replacement(u16_length)
+            }
+            VariantEncoder::Iso2022Jp(ref v) => {
+                v.max_buffer_length_from_utf16_without_replacement(u16_length)
+            }
+            VariantEncoder::ShiftJis(ref v) => {
+                v.max_buffer_length_from_utf16_without_replacement(u16_length)
+            }
+            VariantEncoder::EucKr(ref v) => {
+                v.max_buffer_length_from_utf16_without_replacement(u16_length)
+            }
+            VariantEncoder::UserDefined(ref v) => {
+                v.max_buffer_length_from_utf16_without_replacement(u16_length)
+            }
+        }
+    }
+
+    pub fn max_buffer_length_from_utf8_without_replacement(
+        &self,
+        byte_length: usize,
+    ) -> Option<usize> {
+        match *self {
+            VariantEncoder::SingleByte(ref v) => {
+                v.max_buffer_length_from_utf8_without_replacement(byte_length)
+            }
+            VariantEncoder::Utf8(ref v) => {
+                v.max_buffer_length_from_utf8_without_replacement(byte_length)
+            }
+            VariantEncoder::Gb18030(ref v) => {
+                v.max_buffer_length_from_utf8_without_replacement(byte_length)
+            }
+            VariantEncoder::Big5(ref v) => {
+                v.max_buffer_length_from_utf8_without_replacement(byte_length)
+            }
+            VariantEncoder::EucJp(ref v) => {
+                v.max_buffer_length_from_utf8_without_replacement(byte_length)
+            }
+            VariantEncoder::Iso2022Jp(ref v) => {
+                v.max_buffer_length_from_utf8_without_replacement(byte_length)
+            }
+            VariantEncoder::ShiftJis(ref v) => {
+                v.max_buffer_length_from_utf8_without_replacement(byte_length)
+            }
+            VariantEncoder::EucKr(ref v) => {
+                v.max_buffer_length_from_utf8_without_replacement(byte_length)
+            }
+            VariantEncoder::UserDefined(ref v) => {
+                v.max_buffer_length_from_utf8_without_replacement(byte_length)
+            }
+        }
+    }
+
+    pub fn encode_from_utf16_raw(
+        &mut self,
+        src: &[u16],
+        dst: &mut [u8],
+        last: bool,
+    ) -> (EncoderResult, usize, usize) {
+        match *self {
+            VariantEncoder::SingleByte(ref mut v) => v.encode_from_utf16_raw(src, dst, last),
+            VariantEncoder::Utf8(ref mut v) => v.encode_from_utf16_raw(src, dst, last),
+            VariantEncoder::Gb18030(ref mut v) => v.encode_from_utf16_raw(src, dst, last),
+            VariantEncoder::Big5(ref mut v) => v.encode_from_utf16_raw(src, dst, last),
+            VariantEncoder::EucJp(ref mut v) => v.encode_from_utf16_raw(src, dst, last),
+            VariantEncoder::Iso2022Jp(ref mut v) => v.encode_from_utf16_raw(src, dst, last),
+            VariantEncoder::ShiftJis(ref mut v) => v.encode_from_utf16_raw(src, dst, last),
+            VariantEncoder::EucKr(ref mut v) => v.encode_from_utf16_raw(src, dst, last),
+            VariantEncoder::UserDefined(ref mut v) => v.encode_from_utf16_raw(src, dst, last),
+        }
+    }
+
+    pub fn encode_from_utf8_raw(
+        &mut self,
+        src: &str,
+        dst: &mut [u8],
+        last: bool,
+    ) -> (EncoderResult, usize, usize) {
+        match *self {
+            VariantEncoder::SingleByte(ref mut v) => v.encode_from_utf8_raw(src, dst, last),
+            VariantEncoder::Utf8(ref mut v) => v.encode_from_utf8_raw(src, dst, last),
+            VariantEncoder::Gb18030(ref mut v) => v.encode_from_utf8_raw(src, dst, last),
+            VariantEncoder::Big5(ref mut v) => v.encode_from_utf8_raw(src, dst, last),
+            VariantEncoder::EucJp(ref mut v) => v.encode_from_utf8_raw(src, dst, last),
+            VariantEncoder::Iso2022Jp(ref mut v) => v.encode_from_utf8_raw(src, dst, last),
+            VariantEncoder::ShiftJis(ref mut v) => v.encode_from_utf8_raw(src, dst, last),
+            VariantEncoder::EucKr(ref mut v) => v.encode_from_utf8_raw(src, dst, last),
+            VariantEncoder::UserDefined(ref mut v) => v.encode_from_utf8_raw(src, dst, last),
+        }
+    }
+}
+
+pub enum VariantEncoding {
+    SingleByte(&'static [u16; 128], u16, u8, u8),
+    Utf8,
+    Gbk,
+    Gb18030,
+    Big5,
+    EucJp,
+    Iso2022Jp,
+    ShiftJis,
+    EucKr,
+    Replacement,
+    Utf16Be,
+    Utf16Le,
+    UserDefined,
+}
+
+impl VariantEncoding {
+    pub fn new_variant_decoder(&self) -> VariantDecoder {
+        match *self {
+            VariantEncoding::SingleByte(table, _, _, _) => SingleByteDecoder::new(table),
+            VariantEncoding::Utf8 => Utf8Decoder::new(),
+            VariantEncoding::Gbk | VariantEncoding::Gb18030 => Gb18030Decoder::new(),
+            VariantEncoding::Big5 => Big5Decoder::new(),
+            VariantEncoding::EucJp => EucJpDecoder::new(),
+            VariantEncoding::Iso2022Jp => Iso2022JpDecoder::new(),
+            VariantEncoding::ShiftJis => ShiftJisDecoder::new(),
+            VariantEncoding::EucKr => EucKrDecoder::new(),
+            VariantEncoding::Replacement => ReplacementDecoder::new(),
+            VariantEncoding::UserDefined => UserDefinedDecoder::new(),
+            VariantEncoding::Utf16Be => Utf16Decoder::new(true),
+            VariantEncoding::Utf16Le => Utf16Decoder::new(false),
+        }
+    }
+
+    pub fn new_encoder(&self, encoding: &'static Encoding) -> Encoder {
+        match *self {
+            VariantEncoding::SingleByte(table, run_bmp_offset, run_byte_offset, run_length) => {
+                SingleByteEncoder::new(encoding, table, run_bmp_offset, run_byte_offset, run_length)
+            }
+            VariantEncoding::Utf8 => Utf8Encoder::new(encoding),
+            VariantEncoding::Gbk => Gb18030Encoder::new(encoding, false),
+            VariantEncoding::Gb18030 => Gb18030Encoder::new(encoding, true),
+            VariantEncoding::Big5 => Big5Encoder::new(encoding),
+            VariantEncoding::EucJp => EucJpEncoder::new(encoding),
+            VariantEncoding::Iso2022Jp => Iso2022JpEncoder::new(encoding),
+            VariantEncoding::ShiftJis => ShiftJisEncoder::new(encoding),
+            VariantEncoding::EucKr => EucKrEncoder::new(encoding),
+            VariantEncoding::UserDefined => UserDefinedEncoder::new(encoding),
+            VariantEncoding::Utf16Be | VariantEncoding::Replacement | VariantEncoding::Utf16Le => {
+                unreachable!()
+            }
+        }
+    }
+
+    pub fn is_single_byte(&self) -> bool {
+        match *self {
+            VariantEncoding::SingleByte(_, _, _, _) | VariantEncoding::UserDefined => true,
+            _ => false,
+        }
+    }
+}