Struct Address 

pub struct Address(Unsigned18Bit);

An address has 17 normal value bits. There are 18 bits for the operand base address in the instruction word, but the topmost bit signals a deferred (i.e. indirect) access, so we should never see a memory access to an address with the 0o400_000 bit set.

The program counter can also have its top bit set. This signals that in the TX-2 hardware, the associated sequence should be traced via Trap 42.

The Xj (index) registers form an 18-bit ring and are described on page 3-68 of the User Handbook (section 3-3.1) as being signed integers. Yet P (which also holds an address) is described on the same page as being a positive integer. Therefore when performing address arithmetic, we sometimes need to convert index register values to the Signed18Bit type.

Tuple Fields

0: Unsigned18Bit

Implementations

impl Address

pub const ZERO: Address

pub const MAX: Address

pub const fn new(a: Unsigned18Bit) -> Address

pub const fn and(&self, mask: u32) -> Address

Apply a bitmask to an address. This could also be done via std::ops::BitAnd, but trait implementations cannot be const. Implementing this const methods allows us to form address constants at compile time with code like Address::MAX & 0o03400.

pub fn mark_bit(&self) -> Unsigned18Bit

Extract the placeholder mark bit.

pub fn is_marked_placeholder(&self) -> bool

The placeholder phrasing here comes from the “TRAP 42” features. But the high bit in the operand address field in an instruction also marks the operand as using deferred addressing. We should choose more neutral naming to avoid confusion.

pub fn split(&self) -> (Unsigned18Bit, bool)

Split an address into its bottom 17 bits (which corresponds to an actual memory register on the TX-2) and a “mark” bit. The “mark” bit is variously used to signal deferred addressing when fetching operands, and to flag a sequence for tracing with trap 42 (in this context is is called a “placeholder mark bit”). The split method is the opposite of join.

pub fn join(addr: Unsigned18Bit, mark: bool) -> Address

Form an address from the bottom 17 bits of addr and a possilbe mark bit, mark. If mark is false, the resulting address will have a zero-valued top bit, no matter what is in addr. This is the opposite of split.

pub fn successor(&self) -> Address

Computes the address following the current address. Used, among other things, to increment the program counter.

The simulator relies on the fact that (as in the hardware TX-2 P register) this calculation will wrap from 0o377_777 to 0.

Trait Implementations

impl Clone for Address

fn clone(&self) -> Address

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Address

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

Formats the value using the given formatter.

impl Default for Address

fn default() -> Address

Returns the “default value” for a type.

impl Display for Address

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

Formats the value using the given formatter.

impl From<&Address> for Unsigned18Bit

fn from(addr: &Address) -> Self

Converts to this type from the input type.

impl From<&Address> for Unsigned36Bit

fn from(addr: &Address) -> Self

Converts to this type from the input type.

impl From<&Address> for u32

fn from(a: &Address) -> u32

Converts to this type from the input type.

impl From<Address> for Unsigned18Bit

fn from(addr: Address) -> Self

Converts to this type from the input type.

impl From<Address> for Unsigned36Bit

fn from(addr: Address) -> Self

Converts to this type from the input type.

impl From<Address> for u32

fn from(a: Address) -> u32

Converts to this type from the input type.

impl From<Unsigned18Bit> for Address

fn from(a: Unsigned18Bit) -> Address

Converts to this type from the input type.

impl Hash for Address

fn hash<H>(&self, h: &mut H)

where H: Hasher,

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 IndexBy<Signed18Bit> for Address

fn index_by(&self, delta: Signed18Bit) -> Address

impl IndexBy<Signed5Bit> for Address

fn index_by(&self, delta: Signed5Bit) -> Address

impl IndexBy<Signed6Bit> for Address

fn index_by(&self, delta: Signed6Bit) -> Address

impl IndexBy<Unsigned18Bit> for Address

fn index_by(&self, delta: Unsigned18Bit) -> Address

impl IndexBy<u8> for Address

fn index_by(&self, index: u8) -> Address

impl Octal for Address

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

Formats the value using the given formatter.

impl Ord for Address

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.

impl PartialEq<u32> for Address

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq for Address

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Address

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 TryFrom<Unsigned36Bit> for Address

type Error = ConversionFailed

The type returned in the event of a conversion error.

fn try_from(n: Unsigned36Bit) -> Result<Address, ConversionFailed>

Performs the conversion.

impl TryFrom<u32> for Address

type Error = ConversionFailed

The type returned in the event of a conversion error.

fn try_from(n: u32) -> Result<Address, ConversionFailed>

Performs the conversion.

impl Copy for Address

impl Eq for Address