Enum Instruction

pub enum Instruction {
    Jump(Value),
    RelativeJump(Value),
    Negate(Value),
    Store(Value),
    Subtract(Value),
    Test,
    Stop,
}

Represents all the instructions.

Variants

Jump(Value)

See BabyInstruction::Jump.

RelativeJump(Value)

See BabyInstruction::RelativeJump.

Negate(Value)

See BabyInstruction::Negate.

Store(Value)

See BabyInstruction::Store.

Subtract(Value)

See BabyInstruction::Subtract.

Test

See BabyInstruction::SkipNextIfNegative.

Stop

See BabyInstruction::Stop.

Implementations

impl Instruction

pub fn parse(instruction: &str) -> Result<Instruction, InstructionError>

Parses Baby asm instruction & operands using modern notation

Possible Instruction

Asm	Description
JMP #	Jump to the instruction at the address obtained from the specified memory address # (absolute unconditional jump)
JRP #	Jump to the instruction at the program counter plus (+) the relative value obtained from the specified memory address # (relative unconditional jump)
LDN #	Take the number from the specified memory address #, negate it, and load it into the accumulator
STO #	Store the number in the accumulator to the specified memory address #
SUB #	Subtract the number at the specified memory address # from the value in accumulator, and store the result in the accumulator
CMP	Skip next instruction if the accumulator contains a negative value
STP	Stop

• # is a always a memory address, and will try to be parsed into a Value.

pub fn parse_ogn(instruction: &str) -> Result<Instruction, InstructionError>

Parses Baby asm instructions & operands using original notation

Possible Instructions

Asm	Description
#, Cl	Jump to the instruction at the address obtained from the specified memory address # (absolute unconditional jump)
Add #, Cl	Jump to the instruction at the program counter plus (+) the relative value obtained from the specified memory address # (relative unconditional jump)
-#, C	Take the number from the specified memory address #, negate it, and load it into the accumulator
c, #	Store the number in the accumulator to the specified memory address #
SUB #	Subtract the number at the specified memory address # from the value in accumulator, and store the result in the accumulator
Test	Skip next instruction if the accumulator contains a negative value
Stop	Stop

• # is a always a memory address

pub fn describe(&self) -> String

Returns a string with a short description of the instruction.

pub fn get_operand(&self) -> Value

Returns the stored memory address operand of a instruction, returns a 0 if a stop or test.

pub fn make_instruction( instr: Instruction, operand: String, ) -> Result<Instruction, InstructionError>

Tries to parse an operand value expression, combining it with an instruction.

Will return an InstructionError if parsing the operand value fails.

Parameters

• instr - The instruction to be used.
• operand - The operand value expression to be parsed and combined.

Trait Implementations

impl Clone for Instruction

fn clone(&self) -> Instruction

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Instruction

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

Formats the value using the given formatter.

impl PartialEq for Instruction

fn eq(&self, other: &Instruction) -> 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 StructuralPartialEq for Instruction