wasmtime 21.0.1 → 23.0.2

data/ext/cargo-vendor/cranelift-codegen-0.108.1/src/ir/jumptable.rs

@@ -1,168 +0,0 @@
-//! Jump table representation.
-//!
-//! Jump tables are declared in the preamble and assigned an `ir::entities::JumpTable` reference.
-//! The actual table of destinations is stored in a `JumpTableData` struct defined in this module.
-
-use crate::ir::instructions::ValueListPool;
-use crate::ir::BlockCall;
-use alloc::vec::Vec;
-use core::fmt::{self, Display, Formatter};
-use core::slice::{Iter, IterMut};
-
-#[cfg(feature = "enable-serde")]
-use serde_derive::{Deserialize, Serialize};
-
-/// Contents of a jump table.
-///
-/// All jump tables use 0-based indexing and are densely populated.
-///
-/// The default block for the jump table is stored as the first element of the underlying vector.
-/// It can be accessed through the `default_block` and `default_block_mut` functions. All blocks
-/// may be iterated using the `all_branches` and `all_branches_mut` functions, which will both
-/// iterate over the default block first.
-#[derive(Clone, PartialEq, Hash)]
-#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
-pub struct JumpTableData {
-    // Table entries.
-    table: Vec<BlockCall>,
-}
-
-impl JumpTableData {
-    /// Create a new jump table with the provided blocks.
-    pub fn new(def: BlockCall, table: &[BlockCall]) -> Self {
-        Self {
-            table: std::iter::once(def).chain(table.iter().copied()).collect(),
-        }
-    }
-
-    /// Fetch the default block for this jump table.
-    pub fn default_block(&self) -> BlockCall {
-        *self.table.first().unwrap()
-    }
-
-    /// Mutable access to the default block of this jump table.
-    pub fn default_block_mut(&mut self) -> &mut BlockCall {
-        self.table.first_mut().unwrap()
-    }
-
-    /// The jump table and default block as a single slice. The default block will always be first.
-    pub fn all_branches(&self) -> &[BlockCall] {
-        self.table.as_slice()
-    }
-
-    /// The jump table and default block as a single mutable slice. The default block will always
-    /// be first.
-    pub fn all_branches_mut(&mut self) -> &mut [BlockCall] {
-        self.table.as_mut_slice()
-    }
-
-    /// Access the jump table as a slice. This excludes the default block.
-    pub fn as_slice(&self) -> &[BlockCall] {
-        &self.table.as_slice()[1..]
-    }
-
-    /// Access the jump table as a mutable slice. This excludes the default block.
-    pub fn as_mut_slice(&mut self) -> &mut [BlockCall] {
-        &mut self.table.as_mut_slice()[1..]
-    }
-
-    /// Returns an iterator to the jump table, excluding the default block.
-    #[deprecated(since = "7.0.0", note = "please use `.as_slice()` instead")]
-    pub fn iter(&self) -> Iter<BlockCall> {
-        self.as_slice().iter()
-    }
-
-    /// Returns an iterator that allows modifying each value, excluding the default block.
-    #[deprecated(since = "7.0.0", note = "please use `.as_mut_slice()` instead")]
-    pub fn iter_mut(&mut self) -> IterMut<BlockCall> {
-        self.as_mut_slice().iter_mut()
-    }
-
-    /// Clears all entries in this jump table, except for the default block.
-    pub fn clear(&mut self) {
-        self.table.drain(1..);
-    }
-
-    /// Return a value that can display the contents of this jump table.
-    pub fn display<'a>(&'a self, pool: &'a ValueListPool) -> DisplayJumpTable<'a> {
-        DisplayJumpTable { jt: self, pool }
-    }
-}
-
-/// A wrapper for the context required to display a [JumpTableData].
-pub struct DisplayJumpTable<'a> {
-    jt: &'a JumpTableData,
-    pool: &'a ValueListPool,
-}
-
-impl<'a> Display for DisplayJumpTable<'a> {
-    fn fmt(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
-        write!(fmt, "{}, [", self.jt.default_block().display(self.pool))?;
-        if let Some((first, rest)) = self.jt.as_slice().split_first() {
-            write!(fmt, "{}", first.display(self.pool))?;
-            for block in rest {
-                write!(fmt, ", {}", block.display(self.pool))?;
-            }
-        }
-        write!(fmt, "]")
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::JumpTableData;
-    use crate::entity::EntityRef;
-    use crate::ir::instructions::ValueListPool;
-    use crate::ir::{Block, BlockCall, Value};
-    use std::string::ToString;
-
-    #[test]
-    fn empty() {
-        let mut pool = ValueListPool::default();
-        let def = BlockCall::new(Block::new(0), &[], &mut pool);
-
-        let jt = JumpTableData::new(def, &[]);
-
-        assert_eq!(jt.all_branches().get(0), Some(&def));
-
-        assert_eq!(jt.as_slice().get(0), None);
-        assert_eq!(jt.as_slice().get(10), None);
-
-        assert_eq!(jt.display(&pool).to_string(), "block0, []");
-
-        assert_eq!(jt.all_branches(), [def]);
-        assert_eq!(jt.as_slice(), []);
-    }
-
-    #[test]
-    fn insert() {
-        let mut pool = ValueListPool::default();
-
-        let v0 = Value::new(0);
-        let v1 = Value::new(1);
-
-        let e0 = Block::new(0);
-        let e1 = Block::new(1);
-        let e2 = Block::new(2);
-
-        let def = BlockCall::new(e0, &[], &mut pool);
-        let b1 = BlockCall::new(e1, &[v0], &mut pool);
-        let b2 = BlockCall::new(e2, &[], &mut pool);
-        let b3 = BlockCall::new(e1, &[v1], &mut pool);
-
-        let jt = JumpTableData::new(def, &[b1, b2, b3]);
-
-        assert_eq!(jt.default_block(), def);
-        assert_eq!(
-            jt.display(&pool).to_string(),
-            "block0, [block1(v0), block2, block1(v1)]"
-        );
-
-        assert_eq!(jt.all_branches(), [def, b1, b2, b3]);
-        assert_eq!(jt.as_slice(), [b1, b2, b3]);
-
-        assert_eq!(jt.as_slice()[0].args_slice(&pool), [v0]);
-        assert_eq!(jt.as_slice()[1].args_slice(&pool), []);
-        assert_eq!(jt.as_slice()[2].args_slice(&pool), [v1]);
-    }
-}

data/ext/cargo-vendor/cranelift-codegen-0.108.1/src/ir/mod.rs

@@ -1,108 +0,0 @@
-//! Representation of Cranelift IR functions.
-
-mod atomic_rmw_op;
-mod builder;
-pub mod condcodes;
-pub mod constant;
-pub mod dfg;
-pub mod dynamic_type;
-pub mod entities;
-mod extfunc;
-mod extname;
-pub mod function;
-mod globalvalue;
-pub mod immediates;
-pub mod instructions;
-pub mod jumptable;
-pub(crate) mod known_symbol;
-pub mod layout;
-pub(crate) mod libcall;
-mod memflags;
-mod memtype;
-pub mod pcc;
-mod progpoint;
-mod sourceloc;
-pub mod stackslot;
-mod trapcode;
-pub mod types;
-
-#[cfg(feature = "enable-serde")]
-use serde_derive::{Deserialize, Serialize};
-
-pub use crate::ir::atomic_rmw_op::AtomicRmwOp;
-pub use crate::ir::builder::{
-    InsertBuilder, InstBuilder, InstBuilderBase, InstInserterBase, ReplaceBuilder,
-};
-pub use crate::ir::constant::{ConstantData, ConstantPool};
-pub use crate::ir::dfg::{BlockData, DataFlowGraph, ValueDef};
-pub use crate::ir::dynamic_type::{dynamic_to_fixed, DynamicTypeData, DynamicTypes};
-pub use crate::ir::entities::{
-    Block, Constant, DynamicStackSlot, DynamicType, FuncRef, GlobalValue, Immediate, Inst,
-    JumpTable, MemoryType, SigRef, StackSlot, UserExternalNameRef, Value,
-};
-pub use crate::ir::extfunc::{
-    AbiParam, ArgumentExtension, ArgumentPurpose, ExtFuncData, Signature,
-};
-pub use crate::ir::extname::{ExternalName, UserExternalName, UserFuncName};
-pub use crate::ir::function::Function;
-pub use crate::ir::globalvalue::GlobalValueData;
-pub use crate::ir::instructions::{
-    BlockCall, InstructionData, Opcode, ValueList, ValueListPool, VariableArgs,
-};
-pub use crate::ir::jumptable::JumpTableData;
-pub use crate::ir::known_symbol::KnownSymbol;
-pub use crate::ir::layout::Layout;
-pub use crate::ir::libcall::{get_probestack_funcref, LibCall};
-pub use crate::ir::memflags::{AliasRegion, Endianness, MemFlags};
-pub use crate::ir::memtype::{MemoryTypeData, MemoryTypeField};
-pub use crate::ir::pcc::{BaseExpr, Expr, Fact, FactContext, PccError, PccResult};
-pub use crate::ir::progpoint::ProgramPoint;
-pub use crate::ir::sourceloc::RelSourceLoc;
-pub use crate::ir::sourceloc::SourceLoc;
-pub use crate::ir::stackslot::{
-    DynamicStackSlotData, DynamicStackSlots, StackSlotData, StackSlotKind, StackSlots,
-};
-pub use crate::ir::trapcode::TrapCode;
-pub use crate::ir::types::Type;
-
-use crate::entity::{entity_impl, PrimaryMap, SecondaryMap};
-
-/// Map of jump tables.
-pub type JumpTables = PrimaryMap<JumpTable, JumpTableData>;
-
-/// Source locations for instructions.
-pub(crate) type SourceLocs = SecondaryMap<Inst, RelSourceLoc>;
-
-/// Marked with a label value.
-#[derive(Copy, Clone, PartialEq, Eq, Hash)]
-#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
-pub struct ValueLabel(u32);
-entity_impl!(ValueLabel, "val");
-
-/// A label of a Value.
-#[derive(Debug, Clone, PartialEq, Hash)]
-#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
-pub struct ValueLabelStart {
-    /// Source location when it is in effect
-    pub from: RelSourceLoc,
-
-    /// The label index.
-    pub label: ValueLabel,
-}
-
-/// Value label assignments: label starts or value aliases.
-#[derive(Debug, Clone, PartialEq, Hash)]
-#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
-pub enum ValueLabelAssignments {
-    /// Original value labels assigned at transform.
-    Starts(alloc::vec::Vec<ValueLabelStart>),
-
-    /// A value alias to original value.
-    Alias {
-        /// Source location when it is in effect
-        from: RelSourceLoc,
-
-        /// The label index.
-        value: Value,
-    },
-}

data/ext/cargo-vendor/cranelift-codegen-0.108.1/src/ir/stackslot.rs

@@ -1,216 +0,0 @@
-//! Stack slots.
-//!
-//! The `StackSlotData` struct keeps track of a single stack slot in a function.
-//!
-
-use crate::entity::PrimaryMap;
-use crate::ir::entities::{DynamicStackSlot, DynamicType};
-use crate::ir::StackSlot;
-use core::fmt;
-use core::str::FromStr;
-
-/// imports only needed for testing.
-#[allow(unused_imports)]
-use crate::ir::{DynamicTypeData, GlobalValueData};
-
-#[allow(unused_imports)]
-use crate::ir::types::*;
-
-#[cfg(feature = "enable-serde")]
-use serde_derive::{Deserialize, Serialize};
-
-/// The size of an object on the stack, or the size of a stack frame.
-///
-/// We don't use `usize` to represent object sizes on the target platform because Cranelift supports
-/// cross-compilation, and `usize` is a type that depends on the host platform, not the target
-/// platform.
-pub type StackSize = u32;
-
-/// The kind of a stack slot.
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
-#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
-pub enum StackSlotKind {
-    /// An explicit stack slot. This is a chunk of stack memory for use by the `stack_load`
-    /// and `stack_store` instructions.
-    ExplicitSlot,
-    /// An explicit stack slot for dynamic vector types. This is a chunk of stack memory
-    /// for use by the `dynamic_stack_load` and `dynamic_stack_store` instructions.
-    ExplicitDynamicSlot,
-}
-
-impl FromStr for StackSlotKind {
-    type Err = ();
-
-    fn from_str(s: &str) -> Result<Self, ()> {
-        use self::StackSlotKind::*;
-        match s {
-            "explicit_slot" => Ok(ExplicitSlot),
-            "explicit_dynamic_slot" => Ok(ExplicitDynamicSlot),
-            _ => Err(()),
-        }
-    }
-}
-
-impl fmt::Display for StackSlotKind {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use self::StackSlotKind::*;
-        f.write_str(match *self {
-            ExplicitSlot => "explicit_slot",
-            ExplicitDynamicSlot => "explicit_dynamic_slot",
-        })
-    }
-}
-
-/// Contents of a stack slot.
-#[derive(Clone, Debug, PartialEq, Eq, Hash)]
-#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
-pub struct StackSlotData {
-    /// The kind of stack slot.
-    pub kind: StackSlotKind,
-
-    /// Size of stack slot in bytes.
-    pub size: StackSize,
-}
-
-impl StackSlotData {
-    /// Create a stack slot with the specified byte size.
-    pub fn new(kind: StackSlotKind, size: StackSize) -> Self {
-        Self { kind, size }
-    }
-
-    /// Get the alignment in bytes of this stack slot given the stack pointer alignment.
-    pub fn alignment(&self, max_align: StackSize) -> StackSize {
-        debug_assert!(max_align.is_power_of_two());
-        if self.kind == StackSlotKind::ExplicitDynamicSlot {
-            max_align
-        } else {
-            // We want to find the largest power of two that divides both `self.size` and `max_align`.
-            // That is the same as isolating the rightmost bit in `x`.
-            let x = self.size | max_align;
-            // C.f. Hacker's delight.
-            x & x.wrapping_neg()
-        }
-    }
-}
-
-impl fmt::Display for StackSlotData {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{} {}", self.kind, self.size)
-    }
-}
-
-/// Contents of a dynamic stack slot.
-#[derive(Clone, Debug, PartialEq, Eq, Hash)]
-#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
-pub struct DynamicStackSlotData {
-    /// The kind of stack slot.
-    pub kind: StackSlotKind,
-
-    /// The type of this slot.
-    pub dyn_ty: DynamicType,
-}
-
-impl DynamicStackSlotData {
-    /// Create a stack slot with the specified byte size.
-    pub fn new(kind: StackSlotKind, dyn_ty: DynamicType) -> Self {
-        assert!(kind == StackSlotKind::ExplicitDynamicSlot);
-        Self { kind, dyn_ty }
-    }
-
-    /// Get the alignment in bytes of this stack slot given the stack pointer alignment.
-    pub fn alignment(&self, max_align: StackSize) -> StackSize {
-        debug_assert!(max_align.is_power_of_two());
-        max_align
-    }
-}
-
-impl fmt::Display for DynamicStackSlotData {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{} {}", self.kind, self.dyn_ty)
-    }
-}
-
-/// All allocated stack slots.
-pub type StackSlots = PrimaryMap<StackSlot, StackSlotData>;
-
-/// All allocated dynamic stack slots.
-pub type DynamicStackSlots = PrimaryMap<DynamicStackSlot, DynamicStackSlotData>;
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::ir::Function;
-    use alloc::string::ToString;
-
-    #[test]
-    fn stack_slot() {
-        let mut func = Function::new();
-
-        let ss0 = func.create_sized_stack_slot(StackSlotData::new(StackSlotKind::ExplicitSlot, 4));
-        let ss1 = func.create_sized_stack_slot(StackSlotData::new(StackSlotKind::ExplicitSlot, 8));
-        assert_eq!(ss0.to_string(), "ss0");
-        assert_eq!(ss1.to_string(), "ss1");
-
-        assert_eq!(func.sized_stack_slots[ss0].size, 4);
-        assert_eq!(func.sized_stack_slots[ss1].size, 8);
-
-        assert_eq!(func.sized_stack_slots[ss0].to_string(), "explicit_slot 4");
-        assert_eq!(func.sized_stack_slots[ss1].to_string(), "explicit_slot 8");
-    }
-
-    #[test]
-    fn dynamic_stack_slot() {
-        let mut func = Function::new();
-
-        let int_vector_ty = I32X4;
-        let fp_vector_ty = F64X2;
-        let scale0 = GlobalValueData::DynScaleTargetConst {
-            vector_type: int_vector_ty,
-        };
-        let scale1 = GlobalValueData::DynScaleTargetConst {
-            vector_type: fp_vector_ty,
-        };
-        let gv0 = func.create_global_value(scale0);
-        let gv1 = func.create_global_value(scale1);
-        let dtd0 = DynamicTypeData::new(int_vector_ty, gv0);
-        let dtd1 = DynamicTypeData::new(fp_vector_ty, gv1);
-        let dt0 = func.dfg.make_dynamic_ty(dtd0);
-        let dt1 = func.dfg.make_dynamic_ty(dtd1);
-
-        let dss0 = func.create_dynamic_stack_slot(DynamicStackSlotData::new(
-            StackSlotKind::ExplicitDynamicSlot,
-            dt0,
-        ));
-        let dss1 = func.create_dynamic_stack_slot(DynamicStackSlotData::new(
-            StackSlotKind::ExplicitDynamicSlot,
-            dt1,
-        ));
-        assert_eq!(dss0.to_string(), "dss0");
-        assert_eq!(dss1.to_string(), "dss1");
-
-        assert_eq!(
-            func.dynamic_stack_slots[dss0].to_string(),
-            "explicit_dynamic_slot dt0"
-        );
-        assert_eq!(
-            func.dynamic_stack_slots[dss1].to_string(),
-            "explicit_dynamic_slot dt1"
-        );
-    }
-
-    #[test]
-    fn alignment() {
-        let slot = StackSlotData::new(StackSlotKind::ExplicitSlot, 8);
-
-        assert_eq!(slot.alignment(4), 4);
-        assert_eq!(slot.alignment(8), 8);
-        assert_eq!(slot.alignment(16), 8);
-
-        let slot2 = StackSlotData::new(StackSlotKind::ExplicitSlot, 24);
-
-        assert_eq!(slot2.alignment(4), 4);
-        assert_eq!(slot2.alignment(8), 8);
-        assert_eq!(slot2.alignment(16), 8);
-        assert_eq!(slot2.alignment(32), 8);
-    }
-}

data/ext/cargo-vendor/cranelift-codegen-0.108.1/src/ir/trapcode.rs

@@ -1,149 +0,0 @@
-//! Trap codes describing the reason for a trap.
-
-use core::fmt::{self, Display, Formatter};
-use core::str::FromStr;
-#[cfg(feature = "enable-serde")]
-use serde_derive::{Deserialize, Serialize};
-
-/// A trap code describing the reason for a trap.
-///
-/// All trap instructions have an explicit trap code.
-#[derive(Clone, Copy, PartialEq, Eq, Debug, Hash)]
-#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
-pub enum TrapCode {
-    /// The current stack space was exhausted.
-    StackOverflow,
-
-    /// A `heap_addr` instruction detected an out-of-bounds error.
-    ///
-    /// Note that not all out-of-bounds heap accesses are reported this way;
-    /// some are detected by a segmentation fault on the heap unmapped or
-    /// offset-guard pages.
-    HeapOutOfBounds,
-
-    /// A wasm atomic operation was presented with a not-naturally-aligned linear-memory address.
-    HeapMisaligned,
-
-    /// A `table_addr` instruction detected an out-of-bounds error.
-    TableOutOfBounds,
-
-    /// Indirect call to a null table entry.
-    IndirectCallToNull,
-
-    /// Signature mismatch on indirect call.
-    BadSignature,
-
-    /// An integer arithmetic operation caused an overflow.
-    IntegerOverflow,
-
-    /// An integer division by zero.
-    IntegerDivisionByZero,
-
-    /// Failed float-to-int conversion.
-    BadConversionToInteger,
-
-    /// Code that was supposed to have been unreachable was reached.
-    UnreachableCodeReached,
-
-    /// Execution has potentially run too long and may be interrupted.
-    /// This trap is resumable.
-    Interrupt,
-
-    /// A user-defined trap code.
-    User(u16),
-
-    /// A null reference was encountered which was required to be non-null.
-    NullReference,
-
-    /// A null `i31ref` was encountered which was required to be non-null.
-    NullI31Ref,
-}
-
-impl TrapCode {
-    /// Returns a slice of all traps except `TrapCode::User` traps
-    pub const fn non_user_traps() -> &'static [TrapCode] {
-        &[
-            TrapCode::StackOverflow,
-            TrapCode::HeapOutOfBounds,
-            TrapCode::HeapMisaligned,
-            TrapCode::TableOutOfBounds,
-            TrapCode::IndirectCallToNull,
-            TrapCode::BadSignature,
-            TrapCode::IntegerOverflow,
-            TrapCode::IntegerDivisionByZero,
-            TrapCode::BadConversionToInteger,
-            TrapCode::UnreachableCodeReached,
-            TrapCode::Interrupt,
-            TrapCode::NullReference,
-        ]
-    }
-}
-
-impl Display for TrapCode {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        use self::TrapCode::*;
-        let identifier = match *self {
-            StackOverflow => "stk_ovf",
-            HeapOutOfBounds => "heap_oob",
-            HeapMisaligned => "heap_misaligned",
-            TableOutOfBounds => "table_oob",
-            IndirectCallToNull => "icall_null",
-            BadSignature => "bad_sig",
-            IntegerOverflow => "int_ovf",
-            IntegerDivisionByZero => "int_divz",
-            BadConversionToInteger => "bad_toint",
-            UnreachableCodeReached => "unreachable",
-            Interrupt => "interrupt",
-            User(x) => return write!(f, "user{}", x),
-            NullReference => "null_reference",
-            NullI31Ref => "null_i31ref",
-        };
-        f.write_str(identifier)
-    }
-}
-
-impl FromStr for TrapCode {
-    type Err = ();
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        use self::TrapCode::*;
-        match s {
-            "stk_ovf" => Ok(StackOverflow),
-            "heap_oob" => Ok(HeapOutOfBounds),
-            "heap_misaligned" => Ok(HeapMisaligned),
-            "table_oob" => Ok(TableOutOfBounds),
-            "icall_null" => Ok(IndirectCallToNull),
-            "bad_sig" => Ok(BadSignature),
-            "int_ovf" => Ok(IntegerOverflow),
-            "int_divz" => Ok(IntegerDivisionByZero),
-            "bad_toint" => Ok(BadConversionToInteger),
-            "unreachable" => Ok(UnreachableCodeReached),
-            "interrupt" => Ok(Interrupt),
-            "null_reference" => Ok(NullReference),
-            "null_i31ref" => Ok(NullI31Ref),
-            _ if s.starts_with("user") => s[4..].parse().map(User).map_err(|_| ()),
-            _ => Err(()),
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use alloc::string::ToString;
-
-    #[test]
-    fn display() {
-        for r in TrapCode::non_user_traps() {
-            let tc = *r;
-            assert_eq!(tc.to_string().parse(), Ok(tc));
-        }
-        assert_eq!("bogus".parse::<TrapCode>(), Err(()));
-
-        assert_eq!(TrapCode::User(17).to_string(), "user17");
-        assert_eq!("user22".parse(), Ok(TrapCode::User(22)));
-        assert_eq!("user".parse::<TrapCode>(), Err(()));
-        assert_eq!("user-1".parse::<TrapCode>(), Err(()));
-        assert_eq!("users".parse::<TrapCode>(), Err(()));
-    }
-}