mixal::ComputerWord Struct Reference

#include <memory.h>

Public Member Functions
	ComputerWord ()
	ComputerWord (int32_t value)
	ComputerWord (const std::string &chars)
	ComputerWord (bool _negative, uint8_t _byte1, uint8_t _byte2, uint8_t _byte3, uint8_t _byte4, uint8_t _byte5)
	ComputerWord (char sign, uint8_t _byte1, uint8_t _byte2, uint8_t _byte3, uint8_t _byte4, uint8_t _byte5)
	ComputerWord (bool _negative, uint16_t bytes12, uint8_t _byte3, uint8_t _byte4, uint8_t _byte5)
	ComputerWord (char sign, uint16_t bytes12, uint8_t _byte3, uint8_t _byte4, uint8_t _byte5)
void	reset ()
bool	operator== (const ComputerWord &word) const
std::string	getBytesString () const
uint8_t	operator[] (int index) const
uint8_t &	operator[] (int index)
uint16_t	bytes2 (int index1, int index2) const
uint16_t	bytes12 () const
uint16_t	bytes23 () const
uint16_t	bytes34 () const
uint16_t	bytes45 () const
int32_t	value () const
int16_t	addressValue () const
uint16_t	address () const
uint8_t	index () const
uint8_t	field () const
uint8_t	operation () const
void	setAddress (int16_t address)
void	setAddress (bool negative, uint16_t address)
void	setIndex (uint8_t index)
void	setField (uint8_t field)
void	setOperation (uint8_t operation)
uint8_t	getAt (int32_t index) const
std::string	getCharacters () const
void	set (int32_t value)
void	set (const std::string &chars)
void	set (int index, uint8_t val)
void	set (bool negative, uint8_t byte1, uint8_t byte2, uint8_t byte3, uint8_t byte4, uint8_t byte5)
void	set (char sign, uint8_t byte1, uint8_t byte2, uint8_t byte3, uint8_t byte4, uint8_t byte5)
void	set (bool negative, uint16_t bytes12, uint8_t byte3, uint8_t byte4, uint8_t byte5)
void	set (char sign, uint16_t bytes12, uint8_t byte3, uint8_t byte4, uint8_t byte5)

Public Attributes
bool	negative
uint8_t	byte1
uint8_t	byte2
uint8_t	byte3
uint8_t	byte4
uint8_t	byte5

Friends
std::ostream &	operator<< (std::ostream &out, const ComputerWord &word)

Detailed Description

Basic definition of a word.

A word contains a sign indicator (+ or -) and 5 bytes. Each byte can represent at least [0, 64) integers.

Definition at line 25 of file memory.h.

Constructor & Destructor Documentation

ComputerWord() [1/7]

mixal::ComputerWord::ComputerWord

(

)

Initialize with 0s. The default sign is '+'.

Definition at line 32 of file memory.cpp.

                           : negative(), byte1(), byte2(), byte3(), byte4(), byte5() {
}

ComputerWord() [2/7]

mixal::ComputerWord::ComputerWord ( int32_t  value )

explicit

Initialize with integer value.

See also

set(int32_t)

Definition at line 35 of file memory.cpp.

                                        : negative(), byte1(), byte2(), byte3(), byte4(), byte5() {
    set(value);
}

References set(), and value().

ComputerWord() [3/7]

mixal::ComputerWord::ComputerWord ( const std::string &  chars )

explicit

Initialize with five characters.

See also

set(const std::string&)

Definition at line 39 of file memory.cpp.

                                                 : negative(), byte1(), byte2(), byte3(), byte4(), byte5() {
    set(chars);
}

References set().

ComputerWord() [4/7]

mixal::ComputerWord::ComputerWord	(	bool	_negative,
		uint8_t	_byte1,
		uint8_t	_byte2,
		uint8_t	_byte3,
		uint8_t	_byte4,
		uint8_t	_byte5
	)

Initialize with full representation.

Definition at line 43 of file memory.cpp.

                                                                                    :
    negative(_negative), byte1(_byte1), byte2(_byte2), byte3(_byte3), byte4(_byte4), byte5(_byte5) {
}

ComputerWord() [5/7]

mixal::ComputerWord::ComputerWord	(	char	sign,
		uint8_t	_byte1,
		uint8_t	_byte2,
		uint8_t	_byte3,
		uint8_t	_byte4,
		uint8_t	_byte5
	)

Initialize with full representation.

Exceptions

std::runtime_error

when the sign is neither '+' nor '-'.

Definition at line 48 of file memory.cpp.

                                                                                                                    :
    negative(sign == '-'), byte1(_byte1), byte2(_byte2), byte3(_byte3), byte4(_byte4), byte5(_byte5) {
    if (sign != '+' && sign != '-') {
        throw std::runtime_error("Invalid sign: " + std::string(1, sign));
    }
}

ComputerWord() [6/7]

mixal::ComputerWord::ComputerWord	(	bool	_negative,
		uint16_t	bytes12,
		uint8_t	_byte3,
		uint8_t	_byte4,
		uint8_t	_byte5
	)

Initialize with the first two bytes combined.

See also

set(bool, uint16_t, uint8_t, uint8_t, uint8_t)

Definition at line 55 of file memory.cpp.

                                                                                                           :
    negative(_negative), byte1(bytes12 / 64), byte2(bytes12 % 64), byte3(_byte3), byte4(_byte4), byte5(_byte5) {
}

ComputerWord() [7/7]

mixal::ComputerWord::ComputerWord	(	char	sign,
		uint16_t	bytes12,
		uint8_t	_byte3,
		uint8_t	_byte4,
		uint8_t	_byte5
	)

Initialize with the first two bytes combined.

See also

set(sign, uint16_t, uint8_t, uint8_t, uint8_t)

Exceptions

std::runtime_error

when the sign is neither '+' nor '-'.

Definition at line 59 of file memory.cpp.

                                                                                                      :
    negative(sign == '-'), byte1(bytes12 / 64), byte2(bytes12 % 64), byte3(_byte3), byte4(_byte4), byte5(_byte5) {
    if (sign != '+' && sign != '-') {
        throw std::runtime_error("Invalid sign: " + std::string(1, sign));
    }
}

Member Function Documentation

address()

uint16_t mixal::ComputerWord::address ( ) const

inline

When representing an instruction, the function returns the value represented by the first two bytes without the sign.

See also

bytes12

Definition at line 134 of file memory.h.

{ return bytes12(); }

References bytes12().

Referenced by setAddress().

addressValue()

int16_t mixal::ComputerWord::addressValue

(

)

const

When representing an instruction, the function returns the value represented by the first two bytes with the sign.

See also

bytes12()

Returns

Note that -0 can not be returned.

Definition at line 141 of file memory.cpp.

                                         {
    int16_t value = static_cast<int16_t>(this->bytes12());
    if (negative) {
        value = -value;
    }
    return value;
}

References bytes12(), and value().

bytes12()

uint16_t mixal::ComputerWord::bytes12

(

)

const

Get the value of the first two bytes.

See also

bytes2(int, int)

Definition at line 116 of file memory.cpp.

                                     {
    return bytes2(1, 2);
}

References bytes2().

Referenced by address(), addressValue(), and set().

bytes2()

uint16_t mixal::ComputerWord::bytes2	(	int	index1,
		int	index2
	)		const

Get the value that represented by the indices of two bytes.

Definition at line 110 of file memory.cpp.

                                                          {
    int16_t high = static_cast<int16_t>(static_cast<uint8_t>((*this)[index1]));
    int16_t low = static_cast<int16_t>(static_cast<uint8_t>((*this)[index2]));
    return high * 64 + low;
}

Referenced by bytes12(), bytes23(), bytes34(), and bytes45().

bytes23()

uint16_t mixal::ComputerWord::bytes23

(

)

const

Get the value of the second and third bytes.

See also

bytes2(int, int)

Definition at line 120 of file memory.cpp.

                                     {
    return bytes2(2, 3);
}

References bytes2().

bytes34()

uint16_t mixal::ComputerWord::bytes34

(

)

const

Get the value of the third and fourth bytes.

See also

bytes2(int, int)

Definition at line 124 of file memory.cpp.

                                     {
    return bytes2(3, 4);
}

References bytes2().

bytes45()

uint16_t mixal::ComputerWord::bytes45

(

)

const

Get the value of the last two bytes.

See also

bytes2(int, int)

Definition at line 128 of file memory.cpp.

                                     {
    return bytes2(4, 5);
}

References bytes2().

field()

uint8_t mixal::ComputerWord::field ( ) const

inline

When representing an instruction, the function returns the field value of the instruction.

Returns

The value should be in [0, 63]. For most of the operations the default field value is 5.

Definition at line 147 of file memory.h.

{ return byte4; }

Referenced by mixal::Computer::executeSingle(), and setField().

getAt()

uint8_t mixal::ComputerWord::getAt ( int32_t  index ) const

inline

Get the value with index in [1, 5].

See also

operator[](int) const

Exceptions

std::runtime_error

when the index is not in [1, 5].

Definition at line 172 of file memory.h.

{ return (*this)[index]; }

References index().

Referenced by getCharacters().

getBytesString()

std::string mixal::ComputerWord::getBytesString

(

)

const

Get the string of bytes with padded spaces like: - 0 12 3 43 49

Definition at line 71 of file memory.cpp.

                                             {
    std::string result;
    result += negative ? '-' : '+';
    for (int i = 1; i <= 5; ++i) {
        result += ' ';
        if ((*this)[i] < 10) {
            result += ' ';
        }
        result += std::to_string(static_cast<int>((*this)[i]));
    }
    return result;
}

getCharacters()

std::string mixal::ComputerWord::getCharacters

(

)

const

Get a UTF8 string represents the 5 characters in the word.

Definition at line 165 of file memory.cpp.

                                            {
    std::string chars;
    for (int i = 1; i <= 5; ++i) {
        if (getAt(i) < CHAR_CODES_NUM) {
            uint16_t code = CHAR_CODES[getAt(i)];
            chars += unicode::toUTF8(static_cast<unicode::UChar>(code));
        } else {
            chars += ' ';
        }
    }
    return chars;
}

References mixal::CHAR_CODES, mixal::CHAR_CODES_NUM, and getAt().

index()

uint8_t mixal::ComputerWord::index ( ) const

inline

When representing an instruction, the function returns the index value of the instruction.

Returns

The value should be in [0, 6].

Definition at line 140 of file memory.h.

{ return byte3; }

Referenced by getAt(), operator[](), set(), and setIndex().

operation()

uint8_t mixal::ComputerWord::operation ( ) const

inline

When representing an instruction, the function returns the type of operation of the instruction.

Returns

The value should be in [0, 63].

Definition at line 153 of file memory.h.

{ return byte5; }

Referenced by mixal::Computer::executeSingle(), mixal::Computer::executeSinglePesudo(), mixal::Parser::parseLine(), and setOperation().

operator==()

bool mixal::ComputerWord::operator==

(

const ComputerWord &

word

)

const

Whether two words are strictly equal.

+0 does not equal to -0.

Definition at line 18 of file memory.cpp.

                                                            {
    return negative == word.negative && byte1 == word.byte1 &&
           byte2 == word.byte2 && byte3 == word.byte3 &&
           byte4 == word.byte4 && byte5 == word.byte5;
}

operator[]() [1/2]

uint8_t & mixal::ComputerWord::operator[]

(

int

index

)

Get the reference with index in [1, 5].

Exceptions

std::runtime_error

when the index is not in [1, 5].

Definition at line 97 of file memory.cpp.

                                           {
    if (index <= 0 || index > 5) {
        throw std::runtime_error("Invalid index for a word: " + std::to_string(index));
    }
    switch (index) {
    case 1: return byte1;
    case 2: return byte2;
    case 3: return byte3;
    case 4: return byte4;
    default: return byte5;
    }
}

References index().

operator[]() [2/2]

uint8_t mixal::ComputerWord::operator[]

(

int

index

)

const

Get the value with index in [1, 5].

Exceptions

std::runtime_error

when the index is not in [1, 5].

Definition at line 84 of file memory.cpp.

                                                {
    if (index <= 0 || index > 5) {
        throw std::runtime_error("Invalid index for a word: " + std::to_string(index));
    }
    switch (index) {
    case 1: return byte1;
    case 2: return byte2;
    case 3: return byte3;
    case 4: return byte4;
    default: return byte5;
    }
}

References index().

reset()

void mixal::ComputerWord::reset

(

)

Set the sign to + and all the bytes to 0.

Definition at line 66 of file memory.cpp.

                         {
    negative = false;
    byte1 = byte2 = byte3 = byte4 = byte5 = 0;
}

Referenced by mixal::Computer::reset().

set() [1/7]

void mixal::ComputerWord::set	(	bool	negative,
		uint16_t	bytes12,
		uint8_t	byte3,
		uint8_t	byte4,
		uint8_t	byte5
	)

Set all the values.

Parameters

bytes12

Use the first two bytes to represent an integer within 4096. The behavior is undefined if the number can not be represented.

Definition at line 242 of file memory.cpp.

                                                                                                   {
    this->negative = negative;
    this->byte1 = static_cast<uint8_t>(bytes12 / 64);
    this->byte2 = static_cast<uint8_t>(bytes12 % 64);
    this->byte3 = byte3;
    this->byte4 = byte4;
    this->byte5 = byte5;
}

References bytes12().

set() [2/7]

void mixal::ComputerWord::set	(	bool	negative,
		uint8_t	byte1,
		uint8_t	byte2,
		uint8_t	byte3,
		uint8_t	byte4,
		uint8_t	byte5
	)

Set all the values.

Definition at line 221 of file memory.cpp.

                                                                                                               {
    this->negative = negative;
    this->byte1 = byte1;
    this->byte2 = byte2;
    this->byte3 = byte3;
    this->byte4 = byte4;
    this->byte5 = byte5;
}

set() [3/7]

void mixal::ComputerWord::set	(	char	sign,
		uint16_t	bytes12,
		uint8_t	byte3,
		uint8_t	byte4,
		uint8_t	byte5
	)

Set all the values.

Parameters

bytes12

Use the first two bytes to represent an integer within 4096. The behavior is undefined if the number can not be represented.

Exceptions

std::runtime_error

when the sign is neither '+' nor '-'.

Definition at line 251 of file memory.cpp.

                                                                                               {
    if (sign != '+' && sign != '-') {
        throw std::runtime_error("Invalid sign: " + std::string(1, sign));
    }
    this->negative = sign == '-';
    this->byte1 = static_cast<uint8_t>(bytes12 / 64);
    this->byte2 = static_cast<uint8_t>(bytes12 % 64);
    this->byte3 = byte3;
    this->byte4 = byte4;
    this->byte5 = byte5;
}

References bytes12().

set() [4/7]

void mixal::ComputerWord::set	(	char	sign,
		uint8_t	byte1,
		uint8_t	byte2,
		uint8_t	byte3,
		uint8_t	byte4,
		uint8_t	byte5
	)

Set all the values.

Exceptions

std::runtime_error

when the sign is neither '+' nor '-'.

Definition at line 230 of file memory.cpp.

                                                                                                           {
    if (sign != '+' && sign != '-') {
        throw std::runtime_error("Invalid sign: " + std::string(1, sign));
    }
    this->negative = sign == '-';
    this->byte1 = byte1;
    this->byte2 = byte2;
    this->byte3 = byte3;
    this->byte4 = byte4;
    this->byte5 = byte5;
}

set() [5/7]

void mixal::ComputerWord::set

(

const std::string &

chars

)

Set the word with a UTF8 string.

Only a subset of characters are allowed. The invalid characters with be replaced with spaces.

The sign will always be +.

Parameters

chars

UTF8 encoded string.

Exceptions

std::runtime_error

when the size of characters in the string is not 5.

Definition at line 191 of file memory.cpp.

                                             {
    auto codes = unicode::fromUTF8(chars);
    if (codes.size() != 5) {
        throw std::runtime_error("Invalid length of characters for a word: " + chars);
    }
    negative = false;
    for (int i = 0; i < 5; ++i) {
        (*this)[i + 1] = 0;
        for (int j = 0; j < CHAR_CODES_NUM; ++j) {
            if (static_cast<uint16_t>(codes[i]) == CHAR_CODES[j]) {
                (*this)[i + 1] = j;
                break;
            }
        }
    }
}

References mixal::CHAR_CODES, and mixal::CHAR_CODES_NUM.

set() [6/7]

void mixal::ComputerWord::set	(	int	index,
		uint8_t	val
	)

Set specific byte with the given index in [1, 5].

Parameters

val	The behavior is undefined if it is greater than 63.

Exceptions

std::runtime_error

when the index is not in [1, 5].

Definition at line 208 of file memory.cpp.

                                             {
    if (index <= 0 || index > 5) {
        throw std::runtime_error("Invalid index for a word: " + std::to_string(index));
    }
    switch (index) {
    case 1: byte1 = val; break;
    case 2: byte2 = val; break;
    case 3: byte3 = val; break;
    case 4: byte4 = val; break;
    default: byte5 = val;
    }
}

References index().

set() [7/7]

void mixal::ComputerWord::set

(

int32_t

value

)

Set the word with an integer.

The sign will be set only when the input is non-zero. Therefore to set the word to -0 with this function, one can set it with a negative value first, then set it to 0.

The least significant 30 bits will be saved to the word. Each byte contains 6 bits. The byte5 will contain the least significant 6 bits.

Definition at line 178 of file memory.cpp.

                                    {
    if (value > 0) {
        negative = false;
    } else if (value < 0) {
        negative = true;
        value = -value;
    }
    for (int i = 5; i >= 1; --i) {
        set(i, static_cast<uint8_t>(value & ((1 << 6) - 1)));
        value >>= 6;
    }
}

References value().

Referenced by ComputerWord(), and mixal::Computer::loadCodes().

setAddress() [1/2]

void mixal::ComputerWord::setAddress	(	bool	negative,
		uint16_t	address
	)

When representing an instruction, set the address value.

Definition at line 159 of file memory.cpp.

                                                             {
    this->negative = negative;
    byte1 = static_cast<uint8_t>(address / 64);
    byte2 = static_cast<uint8_t>(address % 64);
}

References address().

setAddress() [2/2]

void mixal::ComputerWord::setAddress

(

int16_t

address

)

When representing an instruction, set the address value.

Definition at line 149 of file memory.cpp.

                                             {
    negative = false;
    if (address < 0) {
        negative = true;
        address = -address;
    }
    byte1 = static_cast<uint8_t>(address / 64);
    byte2 = static_cast<uint8_t>(address % 64);
}

References address().

setField()

void mixal::ComputerWord::setField ( uint8_t  field )

inline

When representing an instruction, set the field value.

Definition at line 162 of file memory.h.

{ byte4 = field; }

References field().

Referenced by mixal::Parser::parseLine().

setIndex()

void mixal::ComputerWord::setIndex ( uint8_t  index )

inline

When representing an instruction, set the index value.

Definition at line 160 of file memory.h.

{ byte3 = index; }

References index().

setOperation()

void mixal::ComputerWord::setOperation ( uint8_t  operation )

inline

When representing an instruction, set the type of operation.

Definition at line 164 of file memory.h.

{ byte5 = operation; }

References operation().

Referenced by mixal::Parser::parseLine().

value()

int32_t mixal::ComputerWord::value

(

)

const

Get the value the word represents.

The range of the result should be [-1073741824, 1073741824].

Definition at line 132 of file memory.cpp.

                                  {
    int32_t value = static_cast<int32_t>(byte1 << 24) |
                    static_cast<int32_t>(byte2 << 18) |
                    static_cast<int32_t>(byte3 << 12) |
                    static_cast<int32_t>(byte4 << 6) |
                    static_cast<int32_t>(byte5);
    return negative ? -value : value;
}

Referenced by addressValue(), ComputerWord(), mixal::Parser::parseLine(), and set().

Friends And Related Function Documentation

operator<<

std::ostream& operator<< ( std::ostream &  out, const ComputerWord &  word  )

friend

Output the word in the format like: + 0 1 2 13 24

Definition at line 24 of file memory.cpp.

                                                                  {
    out << (word.negative ? '-' : '+');
    for (int i = 1; i <= 5; ++i) {
        out << ' ' << static_cast<int>(word[i]);
    }
    return out;
}

---

The documentation for this struct was generated from the following files:

• include/memory.h
• src/memory.cpp