encoding_rs/
variant.rs

1// Copyright Mozilla Foundation. See the COPYRIGHT
2// file at the top-level directory of this distribution.
3//
4// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
5// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
6// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
7// option. This file may not be copied, modified, or distributed
8// except according to those terms.
9
10// THIS IS A GENERATED FILE. PLEASE DO NOT EDIT.
11// Instead, please regenerate using generate-encoding-data.py
12
13//! This module provides enums that wrap the various decoders and encoders.
14//! The purpose is to make `Decoder` and `Encoder` `Sized` by writing the
15//! dispatch explicitly for a finite set of specialized decoders and encoders.
16//! Unfortunately, this means the compiler doesn't generate the dispatch code
17//! and it has to be written here instead.
18//!
19//! The purpose of making `Decoder` and `Encoder` `Sized` is to allow stack
20//! allocation in Rust code, including the convenience methods on `Encoding`.
21
22use super::*;
23use big5::*;
24use euc_jp::*;
25use euc_kr::*;
26use gb18030::*;
27use iso_2022_jp::*;
28use replacement::*;
29use shift_jis::*;
30use single_byte::*;
31use utf_8::*;
32use utf_16::*;
33use x_user_defined::*;
34
35pub enum VariantDecoder {
36    SingleByte(SingleByteDecoder),
37    Utf8(Utf8Decoder),
38    Gb18030(Gb18030Decoder),
39    Big5(Big5Decoder),
40    EucJp(EucJpDecoder),
41    Iso2022Jp(Iso2022JpDecoder),
42    ShiftJis(ShiftJisDecoder),
43    EucKr(EucKrDecoder),
44    Replacement(ReplacementDecoder),
45    UserDefined(UserDefinedDecoder),
46    Utf16(Utf16Decoder),
47}
48
49impl VariantDecoder {
50    pub fn max_utf16_buffer_length(&self, byte_length: usize) -> Option<usize> {
51        match *self {
52            VariantDecoder::SingleByte(ref v) => v.max_utf16_buffer_length(byte_length),
53            VariantDecoder::Utf8(ref v) => v.max_utf16_buffer_length(byte_length),
54            VariantDecoder::Gb18030(ref v) => v.max_utf16_buffer_length(byte_length),
55            VariantDecoder::Big5(ref v) => v.max_utf16_buffer_length(byte_length),
56            VariantDecoder::EucJp(ref v) => v.max_utf16_buffer_length(byte_length),
57            VariantDecoder::Iso2022Jp(ref v) => v.max_utf16_buffer_length(byte_length),
58            VariantDecoder::ShiftJis(ref v) => v.max_utf16_buffer_length(byte_length),
59            VariantDecoder::EucKr(ref v) => v.max_utf16_buffer_length(byte_length),
60            VariantDecoder::Replacement(ref v) => v.max_utf16_buffer_length(byte_length),
61            VariantDecoder::UserDefined(ref v) => v.max_utf16_buffer_length(byte_length),
62            VariantDecoder::Utf16(ref v) => v.max_utf16_buffer_length(byte_length),
63        }
64    }
65
66    pub fn max_utf8_buffer_length_without_replacement(&self, byte_length: usize) -> Option<usize> {
67        match *self {
68            VariantDecoder::SingleByte(ref v) => {
69                v.max_utf8_buffer_length_without_replacement(byte_length)
70            }
71            VariantDecoder::Utf8(ref v) => {
72                v.max_utf8_buffer_length_without_replacement(byte_length)
73            }
74            VariantDecoder::Gb18030(ref v) => {
75                v.max_utf8_buffer_length_without_replacement(byte_length)
76            }
77            VariantDecoder::Big5(ref v) => {
78                v.max_utf8_buffer_length_without_replacement(byte_length)
79            }
80            VariantDecoder::EucJp(ref v) => {
81                v.max_utf8_buffer_length_without_replacement(byte_length)
82            }
83            VariantDecoder::Iso2022Jp(ref v) => {
84                v.max_utf8_buffer_length_without_replacement(byte_length)
85            }
86            VariantDecoder::ShiftJis(ref v) => {
87                v.max_utf8_buffer_length_without_replacement(byte_length)
88            }
89            VariantDecoder::EucKr(ref v) => {
90                v.max_utf8_buffer_length_without_replacement(byte_length)
91            }
92            VariantDecoder::Replacement(ref v) => {
93                v.max_utf8_buffer_length_without_replacement(byte_length)
94            }
95            VariantDecoder::UserDefined(ref v) => {
96                v.max_utf8_buffer_length_without_replacement(byte_length)
97            }
98            VariantDecoder::Utf16(ref v) => {
99                v.max_utf8_buffer_length_without_replacement(byte_length)
100            }
101        }
102    }
103
104    pub fn max_utf8_buffer_length(&self, byte_length: usize) -> Option<usize> {
105        match *self {
106            VariantDecoder::SingleByte(ref v) => v.max_utf8_buffer_length(byte_length),
107            VariantDecoder::Utf8(ref v) => v.max_utf8_buffer_length(byte_length),
108            VariantDecoder::Gb18030(ref v) => v.max_utf8_buffer_length(byte_length),
109            VariantDecoder::Big5(ref v) => v.max_utf8_buffer_length(byte_length),
110            VariantDecoder::EucJp(ref v) => v.max_utf8_buffer_length(byte_length),
111            VariantDecoder::Iso2022Jp(ref v) => v.max_utf8_buffer_length(byte_length),
112            VariantDecoder::ShiftJis(ref v) => v.max_utf8_buffer_length(byte_length),
113            VariantDecoder::EucKr(ref v) => v.max_utf8_buffer_length(byte_length),
114            VariantDecoder::Replacement(ref v) => v.max_utf8_buffer_length(byte_length),
115            VariantDecoder::UserDefined(ref v) => v.max_utf8_buffer_length(byte_length),
116            VariantDecoder::Utf16(ref v) => v.max_utf8_buffer_length(byte_length),
117        }
118    }
119
120    pub fn decode_to_utf8_raw(
121        &mut self,
122        src: &[u8],
123        dst: &mut [u8],
124        last: bool,
125    ) -> (DecoderResult, usize, usize) {
126        match *self {
127            VariantDecoder::SingleByte(ref mut v) => v.decode_to_utf8_raw(src, dst, last),
128            VariantDecoder::Utf8(ref mut v) => v.decode_to_utf8_raw(src, dst, last),
129            VariantDecoder::Gb18030(ref mut v) => v.decode_to_utf8_raw(src, dst, last),
130            VariantDecoder::Big5(ref mut v) => v.decode_to_utf8_raw(src, dst, last),
131            VariantDecoder::EucJp(ref mut v) => v.decode_to_utf8_raw(src, dst, last),
132            VariantDecoder::Iso2022Jp(ref mut v) => v.decode_to_utf8_raw(src, dst, last),
133            VariantDecoder::ShiftJis(ref mut v) => v.decode_to_utf8_raw(src, dst, last),
134            VariantDecoder::EucKr(ref mut v) => v.decode_to_utf8_raw(src, dst, last),
135            VariantDecoder::Replacement(ref mut v) => v.decode_to_utf8_raw(src, dst, last),
136            VariantDecoder::UserDefined(ref mut v) => v.decode_to_utf8_raw(src, dst, last),
137            VariantDecoder::Utf16(ref mut v) => v.decode_to_utf8_raw(src, dst, last),
138        }
139    }
140
141    pub fn decode_to_utf16_raw(
142        &mut self,
143        src: &[u8],
144        dst: &mut [u16],
145        last: bool,
146    ) -> (DecoderResult, usize, usize) {
147        decode_to_utf16_raw_impl(self, src, dst, last)
148    }
149
150    pub fn latin1_byte_compatible_up_to(&self, buffer: &[u8]) -> Option<usize> {
151        match *self {
152            VariantDecoder::SingleByte(ref v) => {
153                return Some(v.latin1_byte_compatible_up_to(buffer));
154            }
155            VariantDecoder::Utf8(ref v) => {
156                if !v.in_neutral_state() {
157                    return None;
158                }
159            }
160            VariantDecoder::Gb18030(ref v) => {
161                if !v.in_neutral_state() {
162                    return None;
163                }
164            }
165            VariantDecoder::Big5(ref v) => {
166                if !v.in_neutral_state() {
167                    return None;
168                }
169            }
170            VariantDecoder::EucJp(ref v) => {
171                if !v.in_neutral_state() {
172                    return None;
173                }
174            }
175            VariantDecoder::Iso2022Jp(ref v) => {
176                if v.in_neutral_state() {
177                    return Some(Encoding::iso_2022_jp_ascii_valid_up_to(buffer));
178                }
179                return None;
180            }
181            VariantDecoder::ShiftJis(ref v) => {
182                if !v.in_neutral_state() {
183                    return None;
184                }
185            }
186            VariantDecoder::EucKr(ref v) => {
187                if !v.in_neutral_state() {
188                    return None;
189                }
190            }
191            VariantDecoder::UserDefined(_) => {}
192            VariantDecoder::Replacement(_) | VariantDecoder::Utf16(_) => {
193                return None;
194            }
195        };
196        Some(Encoding::ascii_valid_up_to(buffer))
197    }
198}
199
200#[crate::multiversion(targets("x86_64+avx2+bmi1", "x86+avx2+bmi1"))]
201fn decode_to_utf16_raw_impl(
202    dec: &mut VariantDecoder,
203    src: &[u8],
204    dst: &mut [u16],
205    last: bool,
206) -> (DecoderResult, usize, usize) {
207    match *dec {
208        VariantDecoder::SingleByte(ref mut v) => v.decode_to_utf16_raw(src, dst, last),
209        VariantDecoder::Utf8(ref mut v) => v.decode_to_utf16_raw(src, dst, last),
210        VariantDecoder::Gb18030(ref mut v) => v.decode_to_utf16_raw(src, dst, last),
211        VariantDecoder::Big5(ref mut v) => v.decode_to_utf16_raw(src, dst, last),
212        VariantDecoder::EucJp(ref mut v) => v.decode_to_utf16_raw(src, dst, last),
213        VariantDecoder::Iso2022Jp(ref mut v) => v.decode_to_utf16_raw(src, dst, last),
214        VariantDecoder::ShiftJis(ref mut v) => v.decode_to_utf16_raw(src, dst, last),
215        VariantDecoder::EucKr(ref mut v) => v.decode_to_utf16_raw(src, dst, last),
216        VariantDecoder::Replacement(ref mut v) => v.decode_to_utf16_raw(src, dst, last),
217        VariantDecoder::UserDefined(ref mut v) => v.decode_to_utf16_raw(src, dst, last),
218        VariantDecoder::Utf16(ref mut v) => v.decode_to_utf16_raw(src, dst, last),
219    }
220}
221
222pub enum VariantEncoder {
223    SingleByte(SingleByteEncoder),
224    Utf8(Utf8Encoder),
225    Gb18030(Gb18030Encoder),
226    Big5(Big5Encoder),
227    EucJp(EucJpEncoder),
228    Iso2022Jp(Iso2022JpEncoder),
229    ShiftJis(ShiftJisEncoder),
230    EucKr(EucKrEncoder),
231    UserDefined(UserDefinedEncoder),
232}
233
234impl VariantEncoder {
235    pub fn has_pending_state(&self) -> bool {
236        match *self {
237            VariantEncoder::Iso2022Jp(ref v) => v.has_pending_state(),
238            _ => false,
239        }
240    }
241    pub fn max_buffer_length_from_utf16_without_replacement(
242        &self,
243        u16_length: usize,
244    ) -> Option<usize> {
245        match *self {
246            VariantEncoder::SingleByte(ref v) => {
247                v.max_buffer_length_from_utf16_without_replacement(u16_length)
248            }
249            VariantEncoder::Utf8(ref v) => {
250                v.max_buffer_length_from_utf16_without_replacement(u16_length)
251            }
252            VariantEncoder::Gb18030(ref v) => {
253                v.max_buffer_length_from_utf16_without_replacement(u16_length)
254            }
255            VariantEncoder::Big5(ref v) => {
256                v.max_buffer_length_from_utf16_without_replacement(u16_length)
257            }
258            VariantEncoder::EucJp(ref v) => {
259                v.max_buffer_length_from_utf16_without_replacement(u16_length)
260            }
261            VariantEncoder::Iso2022Jp(ref v) => {
262                v.max_buffer_length_from_utf16_without_replacement(u16_length)
263            }
264            VariantEncoder::ShiftJis(ref v) => {
265                v.max_buffer_length_from_utf16_without_replacement(u16_length)
266            }
267            VariantEncoder::EucKr(ref v) => {
268                v.max_buffer_length_from_utf16_without_replacement(u16_length)
269            }
270            VariantEncoder::UserDefined(ref v) => {
271                v.max_buffer_length_from_utf16_without_replacement(u16_length)
272            }
273        }
274    }
275
276    pub fn max_buffer_length_from_utf8_without_replacement(
277        &self,
278        byte_length: usize,
279    ) -> Option<usize> {
280        match *self {
281            VariantEncoder::SingleByte(ref v) => {
282                v.max_buffer_length_from_utf8_without_replacement(byte_length)
283            }
284            VariantEncoder::Utf8(ref v) => {
285                v.max_buffer_length_from_utf8_without_replacement(byte_length)
286            }
287            VariantEncoder::Gb18030(ref v) => {
288                v.max_buffer_length_from_utf8_without_replacement(byte_length)
289            }
290            VariantEncoder::Big5(ref v) => {
291                v.max_buffer_length_from_utf8_without_replacement(byte_length)
292            }
293            VariantEncoder::EucJp(ref v) => {
294                v.max_buffer_length_from_utf8_without_replacement(byte_length)
295            }
296            VariantEncoder::Iso2022Jp(ref v) => {
297                v.max_buffer_length_from_utf8_without_replacement(byte_length)
298            }
299            VariantEncoder::ShiftJis(ref v) => {
300                v.max_buffer_length_from_utf8_without_replacement(byte_length)
301            }
302            VariantEncoder::EucKr(ref v) => {
303                v.max_buffer_length_from_utf8_without_replacement(byte_length)
304            }
305            VariantEncoder::UserDefined(ref v) => {
306                v.max_buffer_length_from_utf8_without_replacement(byte_length)
307            }
308        }
309    }
310
311    pub fn encode_from_utf16_raw(
312        &mut self,
313        src: &[u16],
314        dst: &mut [u8],
315        last: bool,
316    ) -> (EncoderResult, usize, usize) {
317        match *self {
318            VariantEncoder::SingleByte(ref mut v) => v.encode_from_utf16_raw(src, dst, last),
319            VariantEncoder::Utf8(ref mut v) => v.encode_from_utf16_raw(src, dst, last),
320            VariantEncoder::Gb18030(ref mut v) => v.encode_from_utf16_raw(src, dst, last),
321            VariantEncoder::Big5(ref mut v) => v.encode_from_utf16_raw(src, dst, last),
322            VariantEncoder::EucJp(ref mut v) => v.encode_from_utf16_raw(src, dst, last),
323            VariantEncoder::Iso2022Jp(ref mut v) => v.encode_from_utf16_raw(src, dst, last),
324            VariantEncoder::ShiftJis(ref mut v) => v.encode_from_utf16_raw(src, dst, last),
325            VariantEncoder::EucKr(ref mut v) => v.encode_from_utf16_raw(src, dst, last),
326            VariantEncoder::UserDefined(ref mut v) => v.encode_from_utf16_raw(src, dst, last),
327        }
328    }
329
330    pub fn encode_from_utf8_raw(
331        &mut self,
332        src: &str,
333        dst: &mut [u8],
334        last: bool,
335    ) -> (EncoderResult, usize, usize) {
336        match *self {
337            VariantEncoder::SingleByte(ref mut v) => v.encode_from_utf8_raw(src, dst, last),
338            VariantEncoder::Utf8(ref mut v) => v.encode_from_utf8_raw(src, dst, last),
339            VariantEncoder::Gb18030(ref mut v) => v.encode_from_utf8_raw(src, dst, last),
340            VariantEncoder::Big5(ref mut v) => v.encode_from_utf8_raw(src, dst, last),
341            VariantEncoder::EucJp(ref mut v) => v.encode_from_utf8_raw(src, dst, last),
342            VariantEncoder::Iso2022Jp(ref mut v) => v.encode_from_utf8_raw(src, dst, last),
343            VariantEncoder::ShiftJis(ref mut v) => v.encode_from_utf8_raw(src, dst, last),
344            VariantEncoder::EucKr(ref mut v) => v.encode_from_utf8_raw(src, dst, last),
345            VariantEncoder::UserDefined(ref mut v) => v.encode_from_utf8_raw(src, dst, last),
346        }
347    }
348}
349
350pub enum VariantEncoding {
351    SingleByte(&'static [u16; 128], u16, u8, u8),
352    Utf8,
353    Gbk,
354    Gb18030,
355    Big5,
356    EucJp,
357    Iso2022Jp,
358    ShiftJis,
359    EucKr,
360    Replacement,
361    Utf16Be,
362    Utf16Le,
363    UserDefined,
364}
365
366impl VariantEncoding {
367    pub fn new_variant_decoder(&self) -> VariantDecoder {
368        match *self {
369            VariantEncoding::SingleByte(table, _, _, _) => SingleByteDecoder::new(table),
370            VariantEncoding::Utf8 => Utf8Decoder::new(),
371            VariantEncoding::Gbk | VariantEncoding::Gb18030 => Gb18030Decoder::new(),
372            VariantEncoding::Big5 => Big5Decoder::new(),
373            VariantEncoding::EucJp => EucJpDecoder::new(),
374            VariantEncoding::Iso2022Jp => Iso2022JpDecoder::new(),
375            VariantEncoding::ShiftJis => ShiftJisDecoder::new(),
376            VariantEncoding::EucKr => EucKrDecoder::new(),
377            VariantEncoding::Replacement => ReplacementDecoder::new(),
378            VariantEncoding::UserDefined => UserDefinedDecoder::new(),
379            VariantEncoding::Utf16Be => Utf16Decoder::new(true),
380            VariantEncoding::Utf16Le => Utf16Decoder::new(false),
381        }
382    }
383
384    pub fn new_encoder(&self, encoding: &'static Encoding) -> Encoder {
385        match *self {
386            VariantEncoding::SingleByte(table, run_bmp_offset, run_byte_offset, run_length) => {
387                SingleByteEncoder::new(encoding, table, run_bmp_offset, run_byte_offset, run_length)
388            }
389            VariantEncoding::Utf8 => Utf8Encoder::new(encoding),
390            VariantEncoding::Gbk => Gb18030Encoder::new(encoding, false),
391            VariantEncoding::Gb18030 => Gb18030Encoder::new(encoding, true),
392            VariantEncoding::Big5 => Big5Encoder::new(encoding),
393            VariantEncoding::EucJp => EucJpEncoder::new(encoding),
394            VariantEncoding::Iso2022Jp => Iso2022JpEncoder::new(encoding),
395            VariantEncoding::ShiftJis => ShiftJisEncoder::new(encoding),
396            VariantEncoding::EucKr => EucKrEncoder::new(encoding),
397            VariantEncoding::UserDefined => UserDefinedEncoder::new(encoding),
398            VariantEncoding::Utf16Be | VariantEncoding::Replacement | VariantEncoding::Utf16Le => {
399                unreachable!()
400            }
401        }
402    }
403
404    pub fn is_single_byte(&self) -> bool {
405        matches!(
406            *self,
407            VariantEncoding::SingleByte(_, _, _, _) | VariantEncoding::UserDefined
408        )
409    }
410}
encoding_rs/variant.rs

encoding_rs/
variant.rs
