Struct Policy 

pub struct Policy(/* private fields */);

The complete OPS policy set, packed into six bits: the modifier byte of every dynamic arithmetic instruction (dadd, dshl, dpow, …).

Layout: bits 0–1 overflow, bit 2 div_zero, bits 3–4 shift (the value 3 is reserved), bit 5 float_to_int; bits 6–7 are zero. An instruction carries the whole set even when only part of it can apply (a dadd never shifts), so a code generator stamps one policy per language onto every instruction and the semantics pick the part they need. The default is all-error, the OPS default. (Typed integer instructions carry an IntOp, which has room for every part but float_to_int; the float-to-integer conversions carry a FloatConv.)

Examples

use bytecode_lang::{Overflow, Policy, Shift};

let p = Policy::new().with_overflow(Overflow::Wrap).with_shift(Shift::Mask);
assert_eq!(p.overflow(), Overflow::Wrap);
assert_eq!(p.shift(), Shift::Mask);
assert_eq!(p.to_string(), "wrap.mask");
assert_eq!(Policy::from_bits(p.bits()), Some(p));
assert_eq!(Policy::from_bits(0b11).map(|p| p.overflow()), Some(Overflow::Promote));
assert_eq!(Policy::from_bits(0b1_1000), None); // shift code 3 is reserved
assert_eq!(Policy::from_bits(0b100_0000), None); // bit 6 is reserved

Implementations

impl Policy

pub const DEFAULT: Policy

The OPS defaults: every policy is error.

pub const fn new() -> Self

The OPS defaults: every policy is error.

Examples

use bytecode_lang::{Overflow, Policy};

assert_eq!(Policy::new().overflow(), Overflow::Error);

pub const fn overflow(self) -> Overflow

The overflow policy.

Examples

use bytecode_lang::{Overflow, Policy};

assert_eq!(Policy::new().with_overflow(Overflow::Trap).overflow(), Overflow::Trap);

pub const fn div_zero(self) -> DivZero

The div_zero policy.

Examples

use bytecode_lang::{DivZero, Policy};

assert_eq!(Policy::new().with_div_zero(DivZero::Trap).div_zero(), DivZero::Trap);

pub const fn shift(self) -> Shift

The shift policy.

Examples

use bytecode_lang::{Policy, Shift};

assert_eq!(Policy::new().with_shift(Shift::Mask).shift(), Shift::Mask);
assert_eq!(Policy::new().with_shift(Shift::Saturate).shift(), Shift::Saturate);

pub const fn float_to_int(self) -> FloatToInt

The float_to_int policy.

Examples

use bytecode_lang::{FloatToInt, Policy};

let p = Policy::new().with_float_to_int(FloatToInt::Saturate);
assert_eq!(p.float_to_int(), FloatToInt::Saturate);

pub const fn with_overflow(self, overflow: Overflow) -> Self

This policy with overflow replaced.

Examples

use bytecode_lang::{Overflow, Policy};

assert_eq!(Policy::new().with_overflow(Overflow::Wrap).to_string(), "wrap");

pub const fn with_div_zero(self, div_zero: DivZero) -> Self

This policy with div_zero replaced.

Examples

use bytecode_lang::{DivZero, Policy};

assert_eq!(Policy::new().with_div_zero(DivZero::Trap).to_string(), "divtrap");

pub const fn with_shift(self, shift: Shift) -> Self

This policy with shift replaced.

Examples

use bytecode_lang::{Policy, Shift};

assert_eq!(Policy::new().with_shift(Shift::Mask).to_string(), "mask");

pub const fn with_float_to_int(self, float_to_int: FloatToInt) -> Self

This policy with float_to_int replaced.

Examples

use bytecode_lang::{FloatToInt, Policy};

let p = Policy::new().with_float_to_int(FloatToInt::Saturate);
assert_eq!(p.to_string(), "sat");

pub const fn bits(self) -> u8

The packed six-bit form.

Examples

use bytecode_lang::Policy;

assert_eq!(Policy::new().bits(), 0);

pub const fn from_bits(bits: u8) -> Option<Self>

Unpacks a policy, or None if a reserved bit (6–7) is set or the shift field holds the reserved code 3. 48 of the 64 six-bit values name a policy.

Examples

use bytecode_lang::Policy;

assert!(Policy::from_bits(0b11_0111).is_some());
assert!(Policy::from_bits(0b01_1000).is_none());
assert!(Policy::from_bits(0b100_0000).is_none());

pub const fn is_default(self) -> bool

Whether every policy is the OPS default (error).

Examples

use bytecode_lang::{Overflow, Policy};

assert!(Policy::new().is_default());
assert!(!Policy::new().with_overflow(Overflow::Wrap).is_default());

Trait Implementations

impl Clone for Policy

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for Policy

impl Debug for Policy

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Policy

fn default() -> Self

Returns the “default value” for a type.

impl Display for Policy

Prints only the policies that differ from the default, joined by .: wrap / trap / promote (overflow), divtrap, mask / shsat (shift), sat (float-to-int). The default policy prints as the empty string.

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for Policy

impl Hash for Policy

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Policy

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl PartialEq for Policy

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl PartialOrd for Policy

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl StructuralPartialEq for Policy