wasmtime 9.0.4 → 10.0.1

data/ext/cargo-vendor/cranelift-wasm-0.97.1/src/sections_translator.rs

@@ -0,0 +1,417 @@
+//! Helper functions to gather information for each of the non-function sections of a
+//! WebAssembly module.
+//!
+//! The code of these helper functions is straightforward since they only read metadata
+//! about linear memories, tables, globals, etc. and store them for later use.
+//!
+//! The special case of the initialize expressions for table elements offsets or global variables
+//! is handled, according to the semantics of WebAssembly, to only specific expressions that are
+//! interpreted on the fly.
+use crate::environ::ModuleEnvironment;
+use crate::wasm_unsupported;
+use crate::{
+    DataIndex, ElemIndex, FuncIndex, GlobalIndex, GlobalInit, Memory, MemoryIndex, TableIndex, Tag,
+    TagIndex, TypeIndex, WasmError, WasmResult,
+};
+use cranelift_entity::packed_option::ReservedValue;
+use cranelift_entity::EntityRef;
+use std::boxed::Box;
+use std::vec::Vec;
+use wasmparser::{
+    self, Data, DataKind, DataSectionReader, Element, ElementItems, ElementKind,
+    ElementSectionReader, Export, ExportSectionReader, ExternalKind, FunctionSectionReader,
+    GlobalSectionReader, ImportSectionReader, MemorySectionReader, MemoryType, NameSectionReader,
+    Naming, Operator, TableSectionReader, TagSectionReader, TagType, Type, TypeRef,
+    TypeSectionReader,
+};
+
+fn memory(ty: MemoryType) -> Memory {
+    Memory {
+        minimum: ty.initial,
+        maximum: ty.maximum,
+        shared: ty.shared,
+        memory64: ty.memory64,
+    }
+}
+
+fn tag(e: TagType) -> Tag {
+    match e.kind {
+        wasmparser::TagKind::Exception => Tag {
+            ty: TypeIndex::from_u32(e.func_type_idx),
+        },
+    }
+}
+
+/// Parses the Type section of the wasm module.
+pub fn parse_type_section<'a>(
+    types: TypeSectionReader<'a>,
+    environ: &mut dyn ModuleEnvironment<'a>,
+) -> WasmResult<()> {
+    let count = types.count();
+    environ.reserve_types(count)?;
+
+    for entry in types {
+        match entry? {
+            Type::Func(wasm_func_ty) => {
+                let ty = environ.convert_func_type(&wasm_func_ty);
+                environ.declare_type_func(ty)?;
+            }
+            Type::Array(_) => {
+                unimplemented!("gc proposal");
+            }
+        }
+    }
+    Ok(())
+}
+
+/// Parses the Import section of the wasm module.
+pub fn parse_import_section<'data>(
+    imports: ImportSectionReader<'data>,
+    environ: &mut dyn ModuleEnvironment<'data>,
+) -> WasmResult<()> {
+    environ.reserve_imports(imports.count())?;
+
+    for entry in imports {
+        let import = entry?;
+        match import.ty {
+            TypeRef::Func(sig) => {
+                environ.declare_func_import(
+                    TypeIndex::from_u32(sig),
+                    import.module,
+                    import.name,
+                )?;
+            }
+            TypeRef::Memory(ty) => {
+                environ.declare_memory_import(memory(ty), import.module, import.name)?;
+            }
+            TypeRef::Tag(e) => {
+                environ.declare_tag_import(tag(e), import.module, import.name)?;
+            }
+            TypeRef::Global(ty) => {
+                let ty = environ.convert_global_type(&ty);
+                environ.declare_global_import(ty, import.module, import.name)?;
+            }
+            TypeRef::Table(ty) => {
+                let ty = environ.convert_table_type(&ty);
+                environ.declare_table_import(ty, import.module, import.name)?;
+            }
+        }
+    }
+
+    environ.finish_imports()?;
+    Ok(())
+}
+
+/// Parses the Function section of the wasm module.
+pub fn parse_function_section(
+    functions: FunctionSectionReader,
+    environ: &mut dyn ModuleEnvironment,
+) -> WasmResult<()> {
+    let num_functions = functions.count();
+    if num_functions == std::u32::MAX {
+        // We reserve `u32::MAX` for our own use in cranelift-entity.
+        return Err(WasmError::ImplLimitExceeded);
+    }
+
+    environ.reserve_func_types(num_functions)?;
+
+    for entry in functions {
+        let sigindex = entry?;
+        environ.declare_func_type(TypeIndex::from_u32(sigindex))?;
+    }
+
+    Ok(())
+}
+
+/// Parses the Table section of the wasm module.
+pub fn parse_table_section(
+    tables: TableSectionReader,
+    environ: &mut dyn ModuleEnvironment,
+) -> WasmResult<()> {
+    environ.reserve_tables(tables.count())?;
+
+    for entry in tables {
+        let ty = environ.convert_table_type(&entry?.ty);
+        environ.declare_table(ty)?;
+    }
+
+    Ok(())
+}
+
+/// Parses the Memory section of the wasm module.
+pub fn parse_memory_section(
+    memories: MemorySectionReader,
+    environ: &mut dyn ModuleEnvironment,
+) -> WasmResult<()> {
+    environ.reserve_memories(memories.count())?;
+
+    for entry in memories {
+        let memory = memory(entry?);
+        environ.declare_memory(memory)?;
+    }
+
+    Ok(())
+}
+
+/// Parses the Tag section of the wasm module.
+pub fn parse_tag_section(
+    tags: TagSectionReader,
+    environ: &mut dyn ModuleEnvironment,
+) -> WasmResult<()> {
+    environ.reserve_tags(tags.count())?;
+
+    for entry in tags {
+        let tag = tag(entry?);
+        environ.declare_tag(tag)?;
+    }
+
+    Ok(())
+}
+
+/// Parses the Global section of the wasm module.
+pub fn parse_global_section(
+    globals: GlobalSectionReader,
+    environ: &mut dyn ModuleEnvironment,
+) -> WasmResult<()> {
+    environ.reserve_globals(globals.count())?;
+
+    for entry in globals {
+        let wasmparser::Global { ty, init_expr } = entry?;
+        let mut init_expr_reader = init_expr.get_binary_reader();
+        let initializer = match init_expr_reader.read_operator()? {
+            Operator::I32Const { value } => GlobalInit::I32Const(value),
+            Operator::I64Const { value } => GlobalInit::I64Const(value),
+            Operator::F32Const { value } => GlobalInit::F32Const(value.bits()),
+            Operator::F64Const { value } => GlobalInit::F64Const(value.bits()),
+            Operator::V128Const { value } => {
+                GlobalInit::V128Const(u128::from_le_bytes(*value.bytes()))
+            }
+            Operator::RefNull { hty: _ } => GlobalInit::RefNullConst,
+            Operator::RefFunc { function_index } => {
+                GlobalInit::RefFunc(FuncIndex::from_u32(function_index))
+            }
+            Operator::GlobalGet { global_index } => {
+                GlobalInit::GetGlobal(GlobalIndex::from_u32(global_index))
+            }
+            ref s => {
+                return Err(wasm_unsupported!(
+                    "unsupported init expr in global section: {:?}",
+                    s
+                ));
+            }
+        };
+        let ty = environ.convert_global_type(&ty);
+        environ.declare_global(ty, initializer)?;
+    }
+
+    Ok(())
+}
+
+/// Parses the Export section of the wasm module.
+pub fn parse_export_section<'data>(
+    exports: ExportSectionReader<'data>,
+    environ: &mut dyn ModuleEnvironment<'data>,
+) -> WasmResult<()> {
+    environ.reserve_exports(exports.count())?;
+
+    for entry in exports {
+        let Export {
+            name,
+            ref kind,
+            index,
+        } = entry?;
+
+        // The input has already been validated, so we should be able to
+        // assume valid UTF-8 and use `from_utf8_unchecked` if performance
+        // becomes a concern here.
+        let index = index as usize;
+        match *kind {
+            ExternalKind::Func => environ.declare_func_export(FuncIndex::new(index), name)?,
+            ExternalKind::Table => environ.declare_table_export(TableIndex::new(index), name)?,
+            ExternalKind::Memory => environ.declare_memory_export(MemoryIndex::new(index), name)?,
+            ExternalKind::Tag => environ.declare_tag_export(TagIndex::new(index), name)?,
+            ExternalKind::Global => environ.declare_global_export(GlobalIndex::new(index), name)?,
+        }
+    }
+
+    environ.finish_exports()?;
+    Ok(())
+}
+
+/// Parses the Start section of the wasm module.
+pub fn parse_start_section(index: u32, environ: &mut dyn ModuleEnvironment) -> WasmResult<()> {
+    environ.declare_start_func(FuncIndex::from_u32(index))?;
+    Ok(())
+}
+
+fn read_elems(items: &ElementItems) -> WasmResult<Box<[FuncIndex]>> {
+    let mut elems = Vec::new();
+    match items {
+        ElementItems::Functions(funcs) => {
+            for func in funcs.clone() {
+                elems.push(FuncIndex::from_u32(func?));
+            }
+        }
+        ElementItems::Expressions(funcs) => {
+            for func in funcs.clone() {
+                let idx = match func?.get_binary_reader().read_operator()? {
+                    Operator::RefNull { .. } => FuncIndex::reserved_value(),
+                    Operator::RefFunc { function_index } => FuncIndex::from_u32(function_index),
+                    s => {
+                        return Err(WasmError::Unsupported(format!(
+                            "unsupported init expr in element section: {:?}",
+                            s
+                        )));
+                    }
+                };
+                elems.push(idx);
+            }
+        }
+    }
+    Ok(elems.into_boxed_slice())
+}
+
+/// Parses the Element section of the wasm module.
+pub fn parse_element_section<'data>(
+    elements: ElementSectionReader<'data>,
+    environ: &mut dyn ModuleEnvironment,
+) -> WasmResult<()> {
+    environ.reserve_table_elements(elements.count())?;
+
+    for (index, entry) in elements.into_iter().enumerate() {
+        let Element {
+            kind,
+            items,
+            ty: _,
+            range: _,
+        } = entry?;
+        let segments = read_elems(&items)?;
+        match kind {
+            ElementKind::Active {
+                table_index,
+                offset_expr,
+            } => {
+                let mut offset_expr_reader = offset_expr.get_binary_reader();
+                let (base, offset) = match offset_expr_reader.read_operator()? {
+                    Operator::I32Const { value } => (None, value as u32),
+                    Operator::GlobalGet { global_index } => {
+                        (Some(GlobalIndex::from_u32(global_index)), 0)
+                    }
+                    ref s => {
+                        return Err(wasm_unsupported!(
+                            "unsupported init expr in element section: {:?}",
+                            s
+                        ));
+                    }
+                };
+                environ.declare_table_elements(
+                    TableIndex::from_u32(table_index.unwrap_or(0)),
+                    base,
+                    offset,
+                    segments,
+                )?
+            }
+            ElementKind::Passive => {
+                let index = ElemIndex::from_u32(index as u32);
+                environ.declare_passive_element(index, segments)?;
+            }
+            ElementKind::Declared => {
+                environ.declare_elements(segments)?;
+            }
+        }
+    }
+    Ok(())
+}
+
+/// Parses the Data section of the wasm module.
+pub fn parse_data_section<'data>(
+    data: DataSectionReader<'data>,
+    environ: &mut dyn ModuleEnvironment<'data>,
+) -> WasmResult<()> {
+    environ.reserve_data_initializers(data.count())?;
+
+    for (index, entry) in data.into_iter().enumerate() {
+        let Data {
+            kind,
+            data,
+            range: _,
+        } = entry?;
+        match kind {
+            DataKind::Active {
+                memory_index,
+                offset_expr,
+            } => {
+                let mut offset_expr_reader = offset_expr.get_binary_reader();
+                let (base, offset) = match offset_expr_reader.read_operator()? {
+                    Operator::I32Const { value } => (None, value as u64),
+                    Operator::I64Const { value } => (None, value as u64),
+                    Operator::GlobalGet { global_index } => {
+                        (Some(GlobalIndex::from_u32(global_index)), 0)
+                    }
+                    ref s => {
+                        return Err(wasm_unsupported!(
+                            "unsupported init expr in data section: {:?}",
+                            s
+                        ))
+                    }
+                };
+                environ.declare_data_initialization(
+                    MemoryIndex::from_u32(memory_index),
+                    base,
+                    offset,
+                    data,
+                )?;
+            }
+            DataKind::Passive => {
+                let index = DataIndex::from_u32(index as u32);
+                environ.declare_passive_data(index, data)?;
+            }
+        }
+    }
+
+    Ok(())
+}
+
+/// Parses the Name section of the wasm module.
+pub fn parse_name_section<'data>(
+    names: NameSectionReader<'data>,
+    environ: &mut dyn ModuleEnvironment<'data>,
+) -> WasmResult<()> {
+    for subsection in names {
+        match subsection? {
+            wasmparser::Name::Function(names) => {
+                for name in names {
+                    let Naming { index, name } = name?;
+                    // We reserve `u32::MAX` for our own use in cranelift-entity.
+                    if index != u32::max_value() {
+                        environ.declare_func_name(FuncIndex::from_u32(index), name);
+                    }
+                }
+            }
+            wasmparser::Name::Module { name, .. } => {
+                environ.declare_module_name(name);
+            }
+            wasmparser::Name::Local(reader) => {
+                for f in reader {
+                    let f = f?;
+                    if f.index == u32::max_value() {
+                        continue;
+                    }
+                    for name in f.names {
+                        let Naming { index, name } = name?;
+                        environ.declare_local_name(FuncIndex::from_u32(f.index), index, name)
+                    }
+                }
+            }
+            wasmparser::Name::Label(_)
+            | wasmparser::Name::Type(_)
+            | wasmparser::Name::Table(_)
+            | wasmparser::Name::Global(_)
+            | wasmparser::Name::Memory(_)
+            | wasmparser::Name::Element(_)
+            | wasmparser::Name::Data(_)
+            | wasmparser::Name::Unknown { .. } => {}
+        }
+    }
+    Ok(())
+}

data/ext/cargo-vendor/cranelift-wasm-0.97.1/src/translation_utils.rs

@@ -0,0 +1,99 @@
+//! Helper functions and structures for the translation.
+use crate::environ::TargetEnvironment;
+use crate::WasmResult;
+use core::u32;
+use cranelift_codegen::ir;
+use cranelift_frontend::FunctionBuilder;
+#[cfg(feature = "enable-serde")]
+use serde::{Deserialize, Serialize};
+use wasmparser::{FuncValidator, WasmFuncType, WasmModuleResources};
+
+/// Get the parameter and result types for the given Wasm blocktype.
+pub fn blocktype_params_results<'a, T>(
+    validator: &'a FuncValidator<T>,
+    ty: wasmparser::BlockType,
+) -> WasmResult<(
+    impl ExactSizeIterator<Item = wasmparser::ValType> + Clone + 'a,
+    impl ExactSizeIterator<Item = wasmparser::ValType> + Clone + 'a,
+)>
+where
+    T: WasmModuleResources,
+{
+    return Ok(match ty {
+        wasmparser::BlockType::Empty => {
+            let params: &'static [wasmparser::ValType] = &[];
+            let results: std::vec::Vec<wasmparser::ValType> = vec![];
+            (
+                itertools::Either::Left(params.iter().copied()),
+                itertools::Either::Left(results.into_iter()),
+            )
+        }
+        wasmparser::BlockType::Type(ty) => {
+            let params: &'static [wasmparser::ValType] = &[];
+            let results: std::vec::Vec<wasmparser::ValType> = vec![ty.clone()];
+            (
+                itertools::Either::Left(params.iter().copied()),
+                itertools::Either::Left(results.into_iter()),
+            )
+        }
+        wasmparser::BlockType::FuncType(ty_index) => {
+            let ty = validator
+                .resources()
+                .func_type_at(ty_index)
+                .expect("should be valid");
+            (
+                itertools::Either::Right(ty.inputs()),
+                itertools::Either::Right(ty.outputs()),
+            )
+        }
+    });
+}
+
+/// Create a `Block` with the given Wasm parameters.
+pub fn block_with_params<PE: TargetEnvironment + ?Sized>(
+    builder: &mut FunctionBuilder,
+    params: impl IntoIterator<Item = wasmparser::ValType>,
+    environ: &PE,
+) -> WasmResult<ir::Block> {
+    let block = builder.create_block();
+    for ty in params {
+        match ty {
+            wasmparser::ValType::I32 => {
+                builder.append_block_param(block, ir::types::I32);
+            }
+            wasmparser::ValType::I64 => {
+                builder.append_block_param(block, ir::types::I64);
+            }
+            wasmparser::ValType::F32 => {
+                builder.append_block_param(block, ir::types::F32);
+            }
+            wasmparser::ValType::F64 => {
+                builder.append_block_param(block, ir::types::F64);
+            }
+            wasmparser::ValType::Ref(rt) => {
+                let hty = environ.convert_heap_type(rt.heap_type());
+                builder.append_block_param(block, environ.reference_type(hty));
+            }
+            wasmparser::ValType::V128 => {
+                builder.append_block_param(block, ir::types::I8X16);
+            }
+        }
+    }
+    Ok(block)
+}
+
+/// Turns a `wasmparser` `f32` into a `Cranelift` one.
+pub fn f32_translation(x: wasmparser::Ieee32) -> ir::immediates::Ieee32 {
+    ir::immediates::Ieee32::with_bits(x.bits())
+}
+
+/// Turns a `wasmparser` `f64` into a `Cranelift` one.
+pub fn f64_translation(x: wasmparser::Ieee64) -> ir::immediates::Ieee64 {
+    ir::immediates::Ieee64::with_bits(x.bits())
+}
+
+/// Special VMContext value label. It is tracked as 0xffff_fffe label.
+pub fn get_vmctx_value_label() -> ir::ValueLabel {
+    const VMCTX_LABEL: u32 = 0xffff_fffe;
+    ir::ValueLabel::from_u32(VMCTX_LABEL)
+}

data/ext/cargo-vendor/encoding_rs-0.8.32/.cargo-checksum.json

@@ -0,0 +1 @@
+{"files":{"CONTRIBUTING.md":"ca1901f3e8532fb4cec894fd3664f0eaa898c0c4b961d1b992d1ed54eacf362a","COPYRIGHT":"11789f45bb180841cd362a5eee6789c68ddb573a11105e30768c308a6add0190","Cargo.toml":"ea1bdb0b73a66e4a6b25d8fdda6b64cadea8e99ac89f9739eeada6801d5e9010","Ideas.md":"b7452893f500163868d8de52c09addaf91e1632454ed02e892c467ed7ec39dbd","LICENSE-APACHE":"cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30","LICENSE-MIT":"3fa4ca83dcc9237839b1bdeb2e6d16bdfb5ec0c5ce42b24694d8bbf0dcbef72c","LICENSE-WHATWG":"838118388fe5c2e7f1dbbaeed13e1c7f3ebf88be91319c7c1d77c18e987d1a50","README.md":"8781ee38bba8ab4e752b2d63d7674d8ce4a557af896221434dd057a1198a9ed4","ci/miri.sh":"43cb8d82f49e3bfe2d2274b6ccd6f0714a4188ccef0cecc040829883cfdbee25","doc/Big5.txt":"f73a2edc5cb6c2d140ba6e07f4542e1c4a234950378acde1df93480f0ca0be0b","doc/EUC-JP.txt":"ee2818b907d0137f40a9ab9fd525fc700a44dbdddb6cf0c157a656566bae4bf1","doc/EUC-KR.txt":"71d9e2ccf3b124e8bdfb433c8cf2773fd878077038d0cec3c7237a50f4a78a30","doc/GBK.txt":"c1b522b5a799884e5001da661f42c5a8f4d0acb9ef1d74b206f22b5f65365606","doc/IBM866.txt":"a5a433e804d0f83af785015179fbc1d9b0eaf1f7960efcd04093e136b51fbd0e","doc/ISO-2022-JP.txt":"af86684f5a8f0e2868d7b2c292860140c3d2e5527530ca091f1b28198e8e2fe6","doc/ISO-8859-10.txt":"6d3949ad7c81ca176895101ed81a1db7df1060d64e262880b94bd31bb344ab4d","doc/ISO-8859-13.txt":"3951dd89cf93f7729148091683cf8511f4529388b7dc8dcd0d62eaed55be93fa","doc/ISO-8859-14.txt":"3d330784a0374fd255a38b47949675cc7168c800530534b0a01cac6edc623adc","doc/ISO-8859-15.txt":"24b1084aab5127a85aab99153f86e24694d0a3615f53b5ce23683f97cf66c47a","doc/ISO-8859-16.txt":"ce0272559b92ba76d7a7e476f6424ae4a5cc72e75b183611b08392e44add4d25","doc/ISO-8859-2.txt":"18ceff88c13d1b5ba455a3919b1e3de489045c4c3d2dd7e8527c125c75d54aad","doc/ISO-8859-3.txt":"21798404c68f4f5db59223362f24999da96968c0628427321fccce7d2849a130","doc/ISO-8859-4.txt":"d27f6520c6c5bfbcc19176b71d081cdb3bccde1622bb3e420d5680e812632d53","doc/ISO-8859-5.txt":"a10ec8d6ea7a78ad15da7275f6cb1a3365118527e28f9af6d0d5830501303f3a","doc/ISO-8859-6.txt":"ccda8a2efc96115336bdd77776637b9712425e44fbcf745353b9057fbef144e7","doc/ISO-8859-7.txt":"17900fa1f27a445958f0a77d7d9056be375a6bd7ee4492aa680c7c1500bab85e","doc/ISO-8859-8-I.txt":"8357555646d54265a9b9ffa3e68b08d132312f1561c60108ff9b8b1167b6ecf2","doc/ISO-8859-8.txt":"72cd6f3afb7b4a9c16a66a362473315770b7755d72c86c870e52fc3eba86c8af","doc/KOI8-R.txt":"839cf19a38da994488004ed7814b1f6151640156a9a2af02bf2efca745fb5966","doc/KOI8-U.txt":"0cc76624ed1f024183e2298b7e019957da2c70c8ca06e0fc4e6f353f50a5054f","doc/Shift_JIS.txt":"34c49141818cb9ddbcf59cc858f78a79be8ad148d563f26415108ae1f148443f","doc/UTF-16BE.txt":"e2e280d8acbaa6d2a6b3569d60e17500a285f2baa0df3363dd85537cd5a1ef8f","doc/UTF-16LE.txt":"70bdc170e3fc5298ba68f10125fb5eeb8b077036cc96bb4416c4de396f6d76c1","doc/UTF-8.txt":"ea7bae742e613010ced002cf4b601a737d2203fad65e115611451bc4428f548a","doc/gb18030.txt":"dc71378a8f07a2d8659f69ee81fb8791fef56ba86f124b429978285237bb4a7b","doc/macintosh.txt":"57491e53866711b4672d9b9ff35380b9dac9e0d8e3d6c20bdd6140603687c023","doc/replacement.txt":"4b6c3bbd7999d9d4108a281594bd02d13607e334a95465afff8c2c08d395f0e4","doc/windows-1250.txt":"61296bb6a21cdab602300d32ecfba434cb82de5ac3bc88d58710d2f125e28d39","doc/windows-1251.txt":"7deea1c61dea1485c8ff02db2c7d578db7a9aab63ab1cfd02ec04b515864689e","doc/windows-1252.txt":"933ef3bdddfce5ee132b9f1a1aa8b47423d2587bbe475b19028d0a6d38e180b6","doc/windows-1253.txt":"1a38748b88e99071a5c7b3d5456ead4caedeabab50d50d658be105bc113714de","doc/windows-1254.txt":"f8372f86c6f8d642563cd6ddc025260553292a39423df1683a98670bd7bf2b47","doc/windows-1255.txt":"4e5852494730054e2da258a74e1b9d780abbcdd8ce22ebc218ca2efe9e90493d","doc/windows-1256.txt":"c0879c5172abedead302a406e8f60d9cd9598694a0ffa4fd288ffe4fef7b8ea1","doc/windows-1257.txt":"c28a0c9f964fcb2b46d21f537c402446501a2800670481d6abf9fd9e9018d523","doc/windows-1258.txt":"5019ae4d61805c79aacbf17c93793342dbb098d65a1837783bc3e2c6d6a23602","doc/windows-874.txt":"4ef0e4501c5feba8b17aee1818602ed44b36ca8475db771ce2fc16d392cabecc","doc/x-mac-cyrillic.txt":"58be154d8a888ca3d484b83b44f749823ef339ab27f14d90ca9a856f5050a8bd","doc/x-user-defined.txt":"f9cd07c4321bf5cfb0be4bdddd251072999b04a6cf7a6f5bc63709a84e2c1ffc","generate-encoding-data.py":"be989dd25c6b946e3e8745fdc8e8a80fcf24b3be99ad0b4b78153ba3f6ab6310","rustfmt.toml":"85c1a3b4382fd89e991cbb81b70fb52780472edc064c963943cdaaa56e0a2030","src/ascii.rs":"c44c002641adb5ebc4368707a8cc0a076d2f33e6a5c27b1b69988eb515f5653d","src/big5.rs":"ec6e2913011a38e9a3e825a1731f139a7ca1d5b264fefae51a3cc1a68a57cef9","src/data.rs":"8a617cc57032092d65850eb27e00de687c80aea3299e839a1f58b42d0b35abf3","src/euc_jp.rs":"32047f5b540188c4cb19c07165f846b9786a09f18e315ed3e9bda1293dae52aa","src/euc_kr.rs":"9b25afc72d9378700eecfac58d55ad1c5946d6cd0ccde2c29c08200ef2de6bb9","src/gb18030.rs":"808587168d73f0c80f8520f0ca9b161866ed2efeb17a05e85fdf3b8efe7ba28a","src/handles.rs":"cc83dc0754751d67f5688a65c5e0191cba02f6bacce81a0813a243cba55eef7a","src/iso_2022_jp.rs":"9bb485e82574f4b7d4b2364f0ff276acb6a0bc111758420a3b0ec5e04c196652","src/lib.rs":"1dc07b818e45846b16ddcaf0de46c8862dd7df8099123ec38b95c3f8ad9c91ec","src/macros.rs":"200997f8870de8bfd8cdc475e92115df42108c0df661e49d3d1cbc32056e1d99","src/mem.rs":"0bf34103e0ad1b842a13a082dee2b920b05cf4fb0f145c9ee7f608f4cb4a544f","src/replacement.rs":"7660b34a53f8c1ca2bdfa0e51e843ec28326950952ad8bc96569feb93ac62308","src/shift_jis.rs":"6951ae67e36b1a12fa3a30734957f444d8b1b4ae0e2bde52060b29bd0f16d9d9","src/simd_funcs.rs":"2612aba86e1d201096d7e47a859bc3444f85934cc82d8adc6d39a4304d9eecfc","src/single_byte.rs":"3c9e9c1f946ae622c725ba9421240c1faa9a05e95fa10dd4642a25cb276a1edc","src/test_data/big5_in.txt":"4c5a8691f8dc717311889c63894026d2fb62725a86c4208ca274a9cc8d42a503","src/test_data/big5_in_ref.txt":"99d399e17750cf9c7cf30bb253dbfe35b81c4fcbdead93cfa48b1429213473c7","src/test_data/big5_out.txt":"6193ca97c297aa20e09396038d18e938bb7ea331c26f0f2454097296723a0b13","src/test_data/big5_out_ref.txt":"36567691f557df144f6cc520015a87038dfa156f296fcf103b56ae9a718be1fc","src/test_data/euc_kr_in.txt":"c86a7224f3215fa0d04e685622a752fdc72763e8ae076230c7fd62de57ec4074","src/test_data/euc_kr_in_ref.txt":"1f419f4ca47d708b54c73c461545a022ae2e20498fdbf8005a483d752a204883","src/test_data/euc_kr_out.txt":"e7f32e026f70be1e1b58e0047baf7d3d2c520269c4f9b9992e158b4decb0a1a3","src/test_data/euc_kr_out_ref.txt":"c9907857980b20b8e9e3b584482ed6567a2be6185d72237b6322f0404944924e","src/test_data/gb18030_in.txt":"ab7231b2d3e9afacdbd7d7f3b9e5361a7ff9f7e1cfdb4f3bd905b9362b309e53","src/test_data/gb18030_in_ref.txt":"dc5069421adca2043c55f5012b55a76fdff651d22e6e699fd0978f8d5706815c","src/test_data/gb18030_out.txt":"f0208d527f5ca63de7d9a0323be8d5cf12d8a104b2943d92c2701f0c3364dac1","src/test_data/gb18030_out_ref.txt":"6819fe47627e4ea01027003fc514b9f21a1322e732d7f1fb92cc6c5455bc6c07","src/test_data/iso_2022_jp_in.txt":"cd24bbdcb1834e25db54646fbf4c41560a13dc7540f6be3dba4f5d97d44513af","src/test_data/iso_2022_jp_in_ref.txt":"3dc4e6a5e06471942d086b16c9440945e78415f6f3f47e43717e4bc2eac2cdf5","src/test_data/iso_2022_jp_out.txt":"9b6f015329dda6c3f9ee5ce6dbd6fa9c89acc21283e886836c78b8d833480c21","src/test_data/iso_2022_jp_out_ref.txt":"78cb260093a20116ad9a42f43b05d1848c5ab100b6b9a850749809e943884b35","src/test_data/jis0208_in.txt":"6df3030553ffb0a6615bb33dc8ea9dca6d9623a9028e2ffec754ce3c3da824cc","src/test_data/jis0208_in_ref.txt":"3dc4e6a5e06471942d086b16c9440945e78415f6f3f47e43717e4bc2eac2cdf5","src/test_data/jis0208_out.txt":"4ec24477e1675ce750733bdc3c5add1cd27b6bd4ce1f09289564646e9654e857","src/test_data/jis0208_out_ref.txt":"c3e1cef5032b2b1d93a406f31ff940c4e2dfe8859b8b17ca2761fee7a75a0e48","src/test_data/jis0212_in.txt":"c011f0dd72bd7c8cd922df9374ef8d2769a77190514c77f6c62b415852eeb9fe","src/test_data/jis0212_in_ref.txt":"7d9458b3d2f73e7092a7f505c08ce1d233dde18aa679fbcf9889256239cc9e06","src/test_data/shift_jis_in.txt":"02e389ccef0dd2122e63f503899402cb7f797912c2444cc80ab93131116c5524","src/test_data/shift_jis_in_ref.txt":"512f985950ca902e643c88682dba9708b7c38d3c5ec2925168ab00ac94ab19f9","src/test_data/shift_jis_out.txt":"5fbc44da7bf639bf6cfe0fa1fd3eba7102b88f81919c9ea991302712f69426fb","src/test_data/shift_jis_out_ref.txt":"466322c6fed8286c64582731755290c2296508efdd258826e6279686649b481f","src/test_labels_names.rs":"23a2e11b02b3b8d15fb5613a625e3edb2c61e70e3c581abfd638719a4088200d","src/testing.rs":"f59e671e95a98a56f6b573e8c6be4d71e670bf52f7e20eb1605d990aafa1894e","src/utf_16.rs":"c071a147fad38d750c2c247e141b76b929a48007b99f26b2922b9caecdaf2f25","src/utf_8.rs":"7b7d887b347f1aefa03246b028a36a72758a4ce76c28f3b45c19467851aa7839","src/variant.rs":"1fab5363588a1554a7169de8731ea9cded7ac63ea35caabdd1c27a8dde68c27b","src/x_user_defined.rs":"c9c010730dfb9f141d4fed19350c08a21af240913a54bb64f5ca89ff93b6b7d1"},"package":"071a31f4ee85403370b58aca746f01041ede6f0da2730960ad001edc2b71b394"}

data/ext/cargo-vendor/encoding_rs-0.8.32/CONTRIBUTING.md

@@ -0,0 +1,48 @@
+If you send a pull request / patch, please observe the following.
+
+## Licensing
+
+Since this crate is dual-licensed,
+[section 5 of the Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0#contributions)
+is considered to apply in the sense of Contributions being automatically
+under the Apache License 2.0 or MIT dual license (see the `COPYRIGHT` file).
+That is, by the act of offering a Contribution, you place your Contribution
+under the Apache License 2.0 or MIT dual license stated in the `COPYRIGHT`
+file. Please do not contribute if you aren't willing or allowed to license your
+contributions in this manner.
+
+You are encouraged to dedicate test code that you contribute to the Public
+Domain using the CC0 dedication. If you contribute test code that is not
+dedicated to the Public Domain, please be sure not to put it in a part of
+source code that the comments designate as being dedicated to the Public
+Domain.
+
+## Copyright Notices
+
+If you require the addition of your copyright notice, it's up to you to edit in
+your notice as part of your Contribution. Not adding a copyright notice is
+taken as a waiver of copyright notice.
+
+## No Encodings Beyond The Encoding Standard
+
+Please do not contribute implementations of encodings that are not specified
+in the [Encoding Standard](https://encoding.spec.whatwg.org/).
+
+For example, an implementation of UTF-7 is explicitly out of scope for this
+crate and is, therefore, provided by the [`charset`](https://crates.io/crates/charset)
+crate instead. For single-byte DOS encodings, please see the
+[`oem_cp`](https://crates.io/crates/oem_cp) crate.
+
+## Compatibility with Stable Rust
+
+Please ensure that your Contribution compiles with the latest stable-channel
+rustc.
+
+## rustfmt
+
+The `rustfmt` version used for this code is `rustfmt-nightly`. Please either
+use that version or avoid using `rustfmt` (so as not to reformat all the code).
+
+## Unit tests
+
+Please ensure that `cargo test` succeeds.

data/ext/cargo-vendor/encoding_rs-0.8.32/COPYRIGHT

@@ -0,0 +1,17 @@
+encoding_rs is copyright Mozilla Foundation.
+
+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. All files in the project carrying such
+notice may not be copied, modified, or distributed except
+according to those terms.
+
+This crate includes data derived from the data files supplied
+with the WHATWG Encoding Standard, which, when incorporated into
+source code, are licensed under the BSD 3-Clause License
+<LICENSE-WHATWG>.
+
+Test code within encoding_rs is dedicated to the Public Domain when so
+designated (see the individual files for PD/CC0-dedicated sections).

data/ext/cargo-vendor/encoding_rs-0.8.32/Cargo.toml

@@ -0,0 +1,84 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies.
+#
+# If you are reading this file be aware that the original Cargo.toml
+# will likely look very different (and much more reasonable).
+# See Cargo.toml.orig for the original contents.
+
+[package]
+edition = "2018"
+name = "encoding_rs"
+version = "0.8.32"
+authors = ["Henri Sivonen <hsivonen@hsivonen.fi>"]
+description = "A Gecko-oriented implementation of the Encoding Standard"
+homepage = "https://docs.rs/encoding_rs/"
+documentation = "https://docs.rs/encoding_rs/"
+readme = "README.md"
+keywords = [
+    "encoding",
+    "web",
+    "unicode",
+    "charset",
+]
+categories = [
+    "text-processing",
+    "encoding",
+    "web-programming",
+    "internationalization",
+]
+license = "(Apache-2.0 OR MIT) AND BSD-3-Clause"
+repository = "https://github.com/hsivonen/encoding_rs"
+
+[profile.release]
+lto = true
+
+[dependencies.cfg-if]
+version = "1.0"
+
+[dependencies.packed_simd]
+version = "0.3.4"
+optional = true
+package = "packed_simd_2"
+
+[dependencies.serde]
+version = "1.0"
+optional = true
+
+[dev-dependencies.bincode]
+version = "1.0"
+
+[dev-dependencies.serde_derive]
+version = "1.0"
+
+[dev-dependencies.serde_json]
+version = "1.0"
+
+[features]
+alloc = []
+default = ["alloc"]
+fast-big5-hanzi-encode = []
+fast-gb-hanzi-encode = []
+fast-hangul-encode = []
+fast-hanja-encode = []
+fast-kanji-encode = []
+fast-legacy-encode = [
+    "fast-hangul-encode",
+    "fast-hanja-encode",
+    "fast-kanji-encode",
+    "fast-gb-hanzi-encode",
+    "fast-big5-hanzi-encode",
+]
+less-slow-big5-hanzi-encode = []
+less-slow-gb-hanzi-encode = []
+less-slow-kanji-encode = []
+simd-accel = [
+    "packed_simd",
+    "packed_simd/into_bits",
+]
+
+[badges.travis-ci]
+repository = "hsivonen/encoding_rs"