MIXAL
Public Member Functions | Public Attributes | Static Public Attributes | List of all members
mixal::Computer Class Reference

Public Member Functions

 Computer ()
 
Register2 & rI (int index)
 
const ComputerWord & memoryAt (int16_t index) const
 
ComputerWord & memoryAt (int16_t index)
 
IODevice * getDevice (int32_t index)
 
void waitDevice (IODevice *device)
 
void waitDevices ()
 
ComputerWord & getDeviceWordAt (int32_t device, int32_t index)
 
void reset ()
 
int line () const
 
int elapsed () const
 
std::string getSingleLineSymbol ()
 
void executeSingle ()
 
void executeUntilSelfLoop ()
 
void executeUntilHalt ()
 
void executeSingle (ParsedResult *instruction)
 
void executeSingle (const InstructionWord &instruction)
 
void executeSinglePesudo (ParsedResult *instruction)
 
void loadCodes (const std::string &codes, bool addHalt=true)
 
void loadCodes (const std::vector< std::string > &codes, bool addHalt=true)
 

Public Attributes

Register5 rA
 
Register5 rX
 
Register2 rI1
 
Register2 rI2
 
Register2 rI3
 
Register2 rI4
 
Register2 rI5
 
Register2 rI6
 
Register2 rJ
 
bool overflow
 
ComparisonIndicator comparison
 
ComputerWord memory [NUM_MEMORY]
 
std::vector< IODevice * > devices
 

Static Public Attributes

static const int NUM_INDEX_REGISTER = 6
 
static const int NUM_MEMORY = 4000
 
static const int NUM_IO_DEVICE = 21
 

Detailed Description

Definition at line 26 of file machine.h.

Constructor & Destructor Documentation

◆ Computer()

mixal::Computer::Computer ( )

Initialize the machine with zeros.

Definition at line 11 of file machine.cpp.

11  : rA(), rX(), rI1(), rI2(), rI3(), rI4(), rI5(), rI6(), rJ(),
12  overflow(false), comparison(ComparisonIndicator::EQUAL), memory(),
13  devices(NUM_IO_DEVICE, nullptr),
14  _pesudoVarIndex(), _lineOffset(), _elapsed(), _constants() {}

Member Function Documentation

◆ elapsed()

int mixal::Computer::elapsed ( ) const
inline

Get elapsed unit time after executing the codes.

Definition at line 65 of file machine.h.

65 { return _elapsed; }

◆ executeSingle() [1/3]

void mixal::Computer::executeSingle ( )

Execute a single instruction in the memory.

Definition at line 69 of file machine.cpp.

69  {
70  executeSingle(memory[_lineOffset]);
71 }

References executeSingle(), and memory.

Referenced by executeSingle(), executeUntilHalt(), and executeUntilSelfLoop().

◆ executeSingle() [2/3]

void mixal::Computer::executeSingle ( const InstructionWord &  instruction)

Execute a single instruction based on the given instruction.

Definition at line 121 of file machine.cpp.

121  {
122  switch (instruction.operation()) {
123  case Instructions::ADD:
124  executeADD(instruction);
125  break;
126  case Instructions::SUB:
127  executeSUB(instruction);
128  break;
129  case Instructions::MUL:
130  executeMUL(instruction);
131  break;
132  case Instructions::DIV:
133  executeDIV(instruction);
134  break;
135  case Instructions::HLT:
136  switch (instruction.field()) {
137  case 0: executeNUM(); break;
138  case 1: executeCHAR(); break;
139  }
140  break;
141  case Instructions::SLA:
142  switch (instruction.field()) {
143  case 0: executeSLA(instruction); break;
144  case 1: executeSRA(instruction); break;
145  case 2: executeSLAX(instruction); break;
146  case 3: executeSRAX(instruction); break;
147  case 4: executeSLC(instruction); break;
148  case 5: executeSRC(instruction); break;
149  }
150  break;
151  case Instructions::MOVE:
152  executeMOVE(instruction);
153  break;
154  case Instructions::LDA:
155  executeLD(instruction, &rA);
156  break;
157  case Instructions::LD1:
158  case Instructions::LD2:
159  case Instructions::LD3:
160  case Instructions::LD4:
161  case Instructions::LD5:
162  case Instructions::LD6:
163  executeLDi(instruction);
164  break;
165  case Instructions::LDX:
166  executeLD(instruction, &rX);
167  break;
168  case Instructions::LDAN:
169  executeLDN(instruction, &rA);
170  break;
171  case Instructions::LD1N:
172  case Instructions::LD2N:
173  case Instructions::LD3N:
174  case Instructions::LD4N:
175  case Instructions::LD5N:
176  case Instructions::LD6N:
177  executeLDiN(instruction);
178  break;
179  case Instructions::LDXN:
180  executeLDN(instruction, &rX);
181  break;
182  case Instructions::STA:
183  executeST(instruction, &rA);
184  break;
185  case Instructions::ST1:
186  case Instructions::ST2:
187  case Instructions::ST3:
188  case Instructions::ST4:
189  case Instructions::ST5:
190  case Instructions::ST6:
191  executeSTi(instruction);
192  break;
193  case Instructions::STX:
194  executeST(instruction, &rX);
195  break;
196  case Instructions::STJ:
197  executeSTJ(instruction);
198  break;
199  case Instructions::STZ:
200  executeSTZ(instruction);
201  break;
202  case Instructions::JBUS:
203  executeJBUS(instruction);
204  break;
205  case Instructions::IOC:
206  executeIOC(instruction);
207  break;
208  case Instructions::IN:
209  executeIN(instruction);
210  break;
211  case Instructions::OUT:
212  executeOUT(instruction);
213  break;
214  case Instructions::JRED:
215  executeJRED(instruction);
216  break;
217  case Instructions::JMP:
218  switch (instruction.field()) {
219  case 0: executeJMP(instruction); break;
220  case 1: executeJSJ(instruction); break;
221  case 2: executeJOV(instruction); break;
222  case 3: executeJNOV(instruction); break;
223  case 4: executeJL(instruction); break;
224  case 5: executeJE(instruction); break;
225  case 6: executeJG(instruction); break;
226  case 7: executeJGE(instruction); break;
227  case 8: executeJNE(instruction); break;
228  case 9: executeJLE(instruction); break;
229  }
230  break;
231  case Instructions::JAN:
232  switch (instruction.field()) {
233  case 0: executeJN(instruction, &rA); break;
234  case 1: executeJZ(instruction, &rA); break;
235  case 2: executeJP(instruction, &rA); break;
236  case 3: executeJNN(instruction, &rA); break;
237  case 4: executeJNZ(instruction, &rA); break;
238  case 5: executeJNP(instruction, &rA); break;
239  }
240  break;
241  case Instructions::J1N:
242  case Instructions::J2N:
243  case Instructions::J3N:
244  case Instructions::J4N:
245  case Instructions::J5N:
246  case Instructions::J6N:
247  switch (instruction.field()) {
248  case 0: executeJiN(instruction); break;
249  case 1: executeJiZ(instruction); break;
250  case 2: executeJiP(instruction); break;
251  case 3: executeJiNN(instruction); break;
252  case 4: executeJiNZ(instruction); break;
253  case 5: executeJiNP(instruction); break;
254  }
255  break;
256  case Instructions::JXN:
257  switch (instruction.field()) {
258  case 0: executeJN(instruction, &rX); break;
259  case 1: executeJZ(instruction, &rX); break;
260  case 2: executeJP(instruction, &rX); break;
261  case 3: executeJNN(instruction, &rX); break;
262  case 4: executeJNZ(instruction, &rX); break;
263  case 5: executeJNP(instruction, &rX); break;
264  }
265  break;
266  case Instructions::INCA:
267  switch (instruction.field()) {
268  case 0: executeINC(instruction, &rA); break;
269  case 1: executeDEC(instruction, &rA); break;
270  case 2: executeENT(instruction, &rA); break;
271  case 3: executeENN(instruction, &rA); break;
272  }
273  break;
274  case Instructions::INC1:
275  case Instructions::INC2:
276  case Instructions::INC3:
277  case Instructions::INC4:
278  case Instructions::INC5:
279  case Instructions::INC6:
280  switch (instruction.field()) {
281  case 0: executeINCi(instruction); break;
282  case 1: executeDECi(instruction); break;
283  case 2: executeENTi(instruction); break;
284  case 3: executeENNi(instruction); break;
285  }
286  break;
287  case Instructions::INCX:
288  switch (instruction.field()) {
289  case 0: executeINC(instruction, &rX); break;
290  case 1: executeDEC(instruction, &rX); break;
291  case 2: executeENT(instruction, &rX); break;
292  case 3: executeENN(instruction, &rX); break;
293  }
294  break;
295  case Instructions::CMPA:
296  executeCMP(instruction, &rA);
297  break;
298  case Instructions::CMP1:
299  case Instructions::CMP2:
300  case Instructions::CMP3:
301  case Instructions::CMP4:
302  case Instructions::CMP5:
303  case Instructions::CMP6:
304  executeCMPi(instruction);
305  break;
306  case Instructions::CMPX:
307  executeCMP(instruction, &rX);
308  break;
309  }
310  ++_lineOffset;
311  _elapsed += Instructions::getCost(static_cast<Instructions::Code>(instruction.operation()),
312  instruction.field());
313 }

References mixal::ComputerWord::field(), mixal::Instructions::getCost(), mixal::ComputerWord::operation(), rA, and rX.

◆ executeSingle() [3/3]

void mixal::Computer::executeSingle ( ParsedResult *  instruction)

Execute a single instruction based on the given instruction.

Definition at line 103 of file machine.cpp.

103  {
104  if (instruction->address.literalConstant() ||
105  instruction->index.literalConstant() ||
106  instruction->field.literalConstant()) {
107  throw RuntimeError(_lineOffset, "Literal constant cannot be used in single execution");
108  }
109  if (instruction->parsedType == ParsedType::INSTRUCTION) {
110  if (!instruction->evaluated()) {
111  if (!instruction->evaluate(_constants)) {
112  throw RuntimeError(_lineOffset, "Unresolved symbol found when trying to execute");
113  }
114  }
115  executeSingle(instruction->word);
116  } else if (instruction->parsedType == ParsedType::PSEUDO) {
117  executeSinglePesudo(instruction);
118  }
119 }

References mixal::ParsedResult::address, mixal::ParsedResult::evaluate(), mixal::ParsedResult::evaluated(), executeSingle(), executeSinglePesudo(), mixal::ParsedResult::field, mixal::ParsedResult::index, mixal::Expression::literalConstant(), mixal::ParsedResult::parsedType, and mixal::ParsedResult::word.

◆ executeSinglePesudo()

void mixal::Computer::executeSinglePesudo ( ParsedResult *  instruction)

Execute a single pesudo instruction.

Definition at line 315 of file machine.cpp.

315  {
316  switch (instruction->word.operation() + Instructions::PSEUDO) {
317  case Instructions::EQU:
318  executeEQU(instruction);
319  break;
320  case Instructions::ORIG:
321  executeORIG(instruction);
322  break;
323  case Instructions::CON:
324  executeCON(instruction);
325  break;
326  }
327 }

References mixal::ComputerWord::operation(), and mixal::ParsedResult::word.

Referenced by executeSingle().

◆ executeUntilHalt()

void mixal::Computer::executeUntilHalt ( )

Execute instructions until the HLT operation has been met.

Definition at line 88 of file machine.cpp.

88  {
89  while (true) {
90  if (_lineOffset < 0 || NUM_MEMORY <= _lineOffset) {
91  throw RuntimeError(_lineOffset, "Invalid code line: " + std::to_string(_lineOffset));
92  }
93  if (memory[_lineOffset].operation() == Instructions::HLT &&
94  memory[_lineOffset].field() == 2) {
95  ++_lineOffset;
96  break;
97  }
98  executeSingle(memory[_lineOffset]);
99  }
100  waitDevices();
101 }

References executeSingle(), memory, NUM_MEMORY, and waitDevices().

◆ executeUntilSelfLoop()

void mixal::Computer::executeUntilSelfLoop ( )

Execute instructions until there is a self loop.

Definition at line 73 of file machine.cpp.

73  {
74  int32_t lastOffset = _lineOffset;
75  while (true) {
76  if (_lineOffset < 0 || NUM_MEMORY <= _lineOffset) {
77  throw RuntimeError(_lineOffset, "Invalid code line: " + std::to_string(_lineOffset));
78  }
79  executeSingle(memory[_lineOffset]);
80  if (lastOffset == _lineOffset) {
81  break;
82  }
83  lastOffset = _lineOffset;
84  }
85  waitDevices();
86 }

References executeSingle(), memory, NUM_MEMORY, and waitDevices().

◆ getDevice()

IODevice * mixal::Computer::getDevice ( int32_t  index)

Get the device based on the index value.

Definition at line 11 of file machine_io.cpp.

11  {
12  if (devices[index] == nullptr) {
13  switch (index) {
14  case 0: case 1: case 2: case 3:
15  case 4: case 5: case 6: case 7:
16  devices[index] = new IODeviceTape();
17  break;
18  case 8: case 9: case 10: case 11:
19  case 12: case 13: case 14: case 15:
20  devices[index] = new IODeviceDisk();
21  break;
22  case 16:
23  devices[index] = new IODeviceCardReader();
24  break;
25  case 17:
26  devices[index] = new IODeviceCardPunch();
27  break;
28  case 18:
29  devices[index] = new IODeviceLinePrinter();
30  break;
31  case 19:
32  devices[index] = new IODeviceTypewriter();
33  break;
34  case 20:
35  devices[index] = new IODevicePaperTape();
36  break;
37  }
38  }
39  return devices[index];
40 }

References devices.

Referenced by getDeviceWordAt().

◆ getDeviceWordAt()

ComputerWord & mixal::Computer::getDeviceWordAt ( int32_t  device,
int32_t  index 
)

Get a word from a device.

Definition at line 56 of file machine_io.cpp.

56  {
57  return this->getDevice(device)->wordAt(index);
58 }

References getDevice(), and mixal::IODevice::wordAt().

◆ getSingleLineSymbol()

std::string mixal::Computer::getSingleLineSymbol ( )

Get a unique symbol name.

Definition at line 63 of file machine.cpp.

63  {
64  std::string symbolName = getPesudoSymbolname();
65  _constants[symbolName] = AtomicValue(_lineOffset);
66  return symbolName;
67 }

◆ line()

int mixal::Computer::line ( ) const
inline

Get the current executing line of the memory.

Definition at line 63 of file machine.h.

63 { return _lineOffset; }

◆ loadCodes() [1/2]

void mixal::Computer::loadCodes ( const std::string &  codes,
bool  addHalt = true 
)

Parse and load codes to memory.

Definition at line 329 of file machine.cpp.

329  {
330  std::vector<std::string> lines;
331  std::string item;
332  std::stringstream ss(codes);
333  while (std::getline(ss, item, '\n')) {
334  lines.emplace_back(item);
335  }
336  loadCodes(lines, addHalt);
337 }

◆ loadCodes() [2/2]

void mixal::Computer::loadCodes ( const std::vector< std::string > &  codes,
bool  addHalt = true 
)

Parse and load codes to memory.

Definition at line 339 of file machine.cpp.

339  {
340  // Parse and save all the results and intermediate expressions
341  std::vector<ParsedResult> results(codes.size());
342  std::unordered_map<std::string, AtomicValue> evaluated;
343  std::unordered_map<std::string, Expression*> expressions;
344  std::vector<std::tuple<std::string, Expression, Expression>> constants; // (name, address, value)
345  std::string lineBase = getPesudoSymbolname();
346  evaluated[lineBase] = AtomicValue(0);
347  int32_t lineOffset = 0, endIndex = -1;
348  for (size_t codeIndex = 0; codeIndex < codes.size(); ++codeIndex) {
349  auto code = codes[codeIndex];
350  auto& result = results[codeIndex];
351  auto lineSymbol = getPesudoSymbolname();
352  result = Parser::parseLine(code, lineSymbol, true);
353  if (result.parsedType == ParsedType::PSEUDO) {
354  int32_t operation = result.word.operation() + Instructions::PSEUDO;
355  switch (operation) {
356  case Instructions::EQU:
357  expressions[result.rawLocation] = &result.address;
358  break;
359  case Instructions::ORIG:
360  if (result.rawAddress.find('*') == std::string::npos) {
361  if (!result.rawLocation.empty()) {
362  expressions[result.rawLocation] = &result.address;
363  }
364  } else {
365  // When there is a `*` in the address, the location should equal to
366  // the `*` value before the calculation.
367  result.location = Expression::getConstOffsetExpression(lineBase, lineOffset);
368  expressions[result.rawLocation] = &result.location;
369  expressions[lineSymbol] = &result.location;
370  }
371  lineBase = getPesudoSymbolname();
372  expressions[lineBase] = &result.address;
373  lineOffset = 0;
374  break;
375  case Instructions::CON:
376  case Instructions::ALF:
377  if (!result.rawLocation.empty()) {
378  lineSymbol = result.rawLocation;
379  }
380  constants.push_back(std::make_tuple(
381  lineSymbol,
382  Expression::getConstOffsetExpression(lineBase, lineOffset++),
383  result.address));
384  break;
385  case Instructions::END:
386  endIndex = codeIndex;
387  break;
388  }
389  } else if (result.parsedType == ParsedType::INSTRUCTION) {
390  bool usedLineSymbol = !result.rawLocation.empty() ||
391  (!result.rawAddress.empty() && result.address.depends().count(lineSymbol)) ||
392  (!result.rawIndex.empty() && result.index.depends().count(lineSymbol)) ||
393  (!result.rawField.empty() && result.field.depends().count(lineSymbol));
394  result.location = Expression::getConstOffsetExpression(lineBase, lineOffset);
395  if (!result.rawLocation.empty()) {
396  if (!(Atomic::isLocalSymbol(result.rawLocation) && result.rawLocation[1] == 'H')) {
397  expressions[result.rawLocation] = &result.location;
398  }
399  } else if (usedLineSymbol) {
400  result.rawLocation = lineSymbol;
401  }
402  expressions[lineSymbol] = &result.location;
403  ++lineOffset;
404  }
405  }
406  // Replace local symbols
407  std::unordered_map<std::string, std::string> localSymbolMapping;
408  for (auto& result : results) {
409  if (!result.rawLocation.empty() && Atomic::isLocalSymbol(result.rawLocation) && result.rawLocation[1] == 'H') {
410  auto lineSymbol = getPesudoSymbolname();
411  result.rawLocation[1] = 'B';
412  localSymbolMapping[result.rawLocation] = lineSymbol;
413  result.rawLocation[1] = 'H';
414  expressions[lineSymbol] = &result.location;
415  }
416  result.address.replaceSymbol(localSymbolMapping);
417  }
418  for (int i = static_cast<int>(results.size()) - 1; i >= 0; --i) {
419  auto& result = results[i];
420  if (!result.rawLocation.empty() && Atomic::isLocalSymbol(result.rawLocation) && result.rawLocation[1] == 'H') {
421  auto lineSymbol = getPesudoSymbolname();
422  result.rawLocation[1] = 'F';
423  localSymbolMapping[result.rawLocation] = lineSymbol;
424  result.rawLocation[1] = 'H';
425  expressions[lineSymbol] = &result.location;
426  }
427  result.address.replaceSymbol(localSymbolMapping);
428  }
429  // Add halt
430  if (addHalt) {
431  auto lineSymbol = getPesudoSymbolname();
432  auto haltCommand = Parser::parseLine("HLT", lineSymbol, false);
433  constants.push_back(std::make_tuple(
434  lineSymbol,
435  Expression::getConstOffsetExpression(lineBase, lineOffset++),
436  Expression::getConstExpression(AtomicValue(haltCommand.word.value()))));
437  }
438  // Add expressions and literal constants
439  for (auto& result : results) {
440  if (!result.rawAddress.empty()) {
441  if (result.address.literalConstant()) {
442  auto lineSymbol = getPesudoSymbolname();
443  constants.push_back(std::make_tuple(
444  lineSymbol,
445  Expression::getConstOffsetExpression(lineBase, lineOffset++),
446  result.address));
447  result.address = Expression::getConstExpression(lineSymbol);
448  }
449  expressions[getPesudoSymbolname()] = &result.address;
450  }
451  if (!result.rawIndex.empty()) {
452  expressions[getPesudoSymbolname()] = &result.index;
453  }
454  if (!result.rawField.empty()) {
455  expressions[getPesudoSymbolname()] = &result.field;
456  }
457  }
458  if (endIndex != -1) {
459  auto lineSymbol = results[endIndex].rawLocation.empty() ? getPesudoSymbolname() : results[endIndex].rawLocation;
460  constants.push_back(std::make_tuple(
461  lineSymbol,
462  Expression::getConstOffsetExpression(lineBase, lineOffset++),
463  results[endIndex].address));
464  }
465  // Add collected constants to expressions
466  for (auto& it : constants) {
467  expressions[std::get<0>(it)] = &std::get<1>(it);
468  expressions[getPesudoSymbolname()] = &std::get<2>(it);
469  }
470  // Try to solve all the expressions
471  std::unordered_map<std::string, int> dependNums;
472  std::unordered_map<std::string, std::unordered_set<std::string>> solves;
473  std::set<std::pair<int, std::string>> tasks;
474  for (auto& it : expressions) {
475  dependNums[it.first] = static_cast<int>(it.second->depends().size());
476  for (auto& depend : it.second->depends()) {
477  solves[depend].insert(it.first);
478  if (evaluated.find(depend) != evaluated.end()) {
479  --dependNums[it.first];
480  }
481  }
482  tasks.insert({dependNums[it.first], it.first});
483  }
484  while (!tasks.empty()) {
485  auto& symbol = tasks.begin()->second;
486  auto& expression = expressions[symbol];
487  if (tasks.begin()->first != 0 || !expression->evaluate(evaluated)) {
488  std::ostringstream oss;
489  oss << "Unresolved symbol found while trying to calcuate: ";
490  oss << tasks.begin()->second << "=" << *expression;
491  throw RuntimeError(0, oss.str());
492  }
493  evaluated[symbol] = expression->result();
494  tasks.erase({0, symbol});
495  for (auto& solve : solves[symbol]) {
496  tasks.erase({dependNums[solve], solve});
497  tasks.insert({--dependNums[solve], solve});
498  }
499  }
500  // Load constants to memory
501  for (auto& it : constants) {
502  int32_t location = std::get<1>(it).result().value;
503  if (location < 0 || location >= NUM_MEMORY) {
504  throw RuntimeError(location, "Location of the code is invalid: " + std::to_string(location));
505  }
506  memory[location].set(std::get<2>(it).result().value);
507  }
508  // Load results to memory
509  _lineOffset = -1;
510  for (auto& result : results) {
511  if (result.parsedType == ParsedType::INSTRUCTION) {
512  result.evaluate(evaluated);
513  int32_t location = result.location.result().value;
514  if (location < 0 || location >= NUM_MEMORY) {
515  throw RuntimeError(location, "Location of the code is invalid: " + std::to_string(location));
516  }
517  if (_lineOffset == -1) {
518  _lineOffset = location;
519  }
520  memory[location].set(result.word.negative,
521  result.word.address(),
522  result.word.index(),
523  result.word.field(),
524  result.word.operation());
525  }
526  }
527  if (endIndex != -1) {
528  results[endIndex].address.evaluate(evaluated);
529  _lineOffset = results[endIndex].address.result().value;
530  } else if (_lineOffset == -1) {
531  _lineOffset = 0;
532  }
533 }

References mixal::Expression::getConstExpression(), mixal::Expression::getConstOffsetExpression(), mixal::Atomic::isLocalSymbol(), memory, NUM_MEMORY, mixal::Parser::parseLine(), and mixal::ComputerWord::set().

◆ memoryAt() [1/2]

ComputerWord & mixal::Computer::memoryAt ( int16_t  index)

Get a word from the memory.

Definition at line 38 of file machine.cpp.

38  {
39  return memory[index];
40 }

References memory.

◆ memoryAt() [2/2]

const ComputerWord & mixal::Computer::memoryAt ( int16_t  index) const

Get a word from the memory.

Definition at line 34 of file machine.cpp.

34  {
35  return memory[index];
36 }

References memory.

◆ reset()

void mixal::Computer::reset ( )

Reset the machine to zeros.

Definition at line 42 of file machine.cpp.

42  {
43  rA.reset();
44  rX.reset();
45  for (int i = 1; i <= NUM_INDEX_REGISTER; ++i) {
46  rI(i).reset();
47  }
48  rJ.reset();
49  overflow = false;
50  comparison = ComparisonIndicator::EQUAL;
51  for (int i = 0; i < NUM_MEMORY; ++i) {
52  memory[i].reset();
53  }
54  for (size_t i = 0; i < NUM_IO_DEVICE; ++i) {
55  devices[i] = nullptr;
56  }
57  _pesudoVarIndex = 0;
58  _lineOffset = 0;
59  _elapsed = 0;
60  _constants.clear();
61 }

References comparison, devices, memory, NUM_INDEX_REGISTER, NUM_IO_DEVICE, NUM_MEMORY, overflow, rA, mixal::ComputerWord::reset(), mixal::Register2::reset(), rI(), rJ, and rX.

◆ rI()

Register2 & mixal::Computer::rI ( int  index)

Get the index register given the index of the register.

Definition at line 16 of file machine.cpp.

16  {
17  switch (index) {
18  case 1: return rI1;
19  case 2: return rI2;
20  case 3: return rI3;
21  case 4: return rI4;
22  case 5: return rI5;
23  case 6: return rI6;
24  }
25  throw RuntimeError(_lineOffset, "Invalid offset for index register: " + std::to_string(index));
26 }

References rI1.

Referenced by reset().

◆ waitDevice()

void mixal::Computer::waitDevice ( IODevice *  device)

Wait the IO device to be ready.

Definition at line 42 of file machine_io.cpp.

42  {
43  while (!device->ready(this->_elapsed)) {
44  ++this->_elapsed;
45  }
46 }

References mixal::IODevice::ready().

Referenced by waitDevices().

◆ waitDevices()

void mixal::Computer::waitDevices ( )

Wait all IO devices to be ready.

Definition at line 48 of file machine_io.cpp.

48  {
49  for (int i = 0; i < NUM_IO_DEVICE; ++i) {
50  if (devices[i] != nullptr) {
51  waitDevice(devices[i]);
52  }
53  }
54 }

References devices, NUM_IO_DEVICE, and waitDevice().

Referenced by executeUntilHalt(), and executeUntilSelfLoop().

Member Data Documentation

◆ comparison

ComparisonIndicator mixal::Computer::comparison

The result of comparison operations.

Definition at line 36 of file machine.h.

Referenced by reset().

◆ devices

std::vector<IODevice*> mixal::Computer::devices

The IO devices.

Definition at line 39 of file machine.h.

Referenced by getDevice(), reset(), and waitDevices().

◆ memory

ComputerWord mixal::Computer::memory[NUM_MEMORY]

The memory in the machine.

Definition at line 38 of file machine.h.

Referenced by executeSingle(), executeUntilHalt(), executeUntilSelfLoop(), loadCodes(), memoryAt(), and reset().

◆ NUM_INDEX_REGISTER

const int mixal::Computer::NUM_INDEX_REGISTER = 6
static

Number of index registers.

Definition at line 28 of file machine.h.

Referenced by reset().

◆ NUM_IO_DEVICE

const int mixal::Computer::NUM_IO_DEVICE = 21
static

Number of IO devices.

Definition at line 30 of file machine.h.

Referenced by reset(), and waitDevices().

◆ NUM_MEMORY

const int mixal::Computer::NUM_MEMORY = 4000
static

Number of words in memory.

Definition at line 29 of file machine.h.

Referenced by executeUntilHalt(), executeUntilSelfLoop(), loadCodes(), and reset().

◆ overflow

bool mixal::Computer::overflow

Whether overflow has been triggered.

Definition at line 35 of file machine.h.

Referenced by reset().

◆ rA

Register5 mixal::Computer::rA

Accumulator register.

Definition at line 32 of file machine.h.

Referenced by executeSingle(), and reset().

◆ rI1

Register2 mixal::Computer::rI1

< Index register.

Definition at line 33 of file machine.h.

Referenced by rI().

◆ rJ

Register2 mixal::Computer::rJ

Jump address register.

Definition at line 33 of file machine.h.

Referenced by reset().

◆ rX

Register5 mixal::Computer::rX

Extension register.

Definition at line 32 of file machine.h.

Referenced by executeSingle(), and reset().

The documentation for this class was generated from the following files:
mixal::Computer::NUM_INDEX_REGISTER
static const int NUM_INDEX_REGISTER
Definition: machine.h:28
mixal::Computer::waitDevice
void waitDevice(IODevice *device)
Definition: machine_io.cpp:42
mixal::Computer::loadCodes
void loadCodes(const std::string &codes, bool addHalt=true)
Definition: machine.cpp:329
mixal::Computer::executeSingle
void executeSingle()
Definition: machine.cpp:69
mixal::Expression::getConstOffsetExpression
static Expression getConstOffsetExpression(const std::string &symbol, int32_t offset)
Definition: expression.cpp:38
mixal::Computer::rI1
Register2 rI1
Definition: machine.h:33
mixal::Parser::parseLine
static ParsedResult parseLine(const std::string &line, const std::string &lineSymbol, bool hasLocation=true)
Definition: parser.cpp:143
mixal::Computer::NUM_MEMORY
static const int NUM_MEMORY
Definition: machine.h:29
mixal::ComputerWord::reset
void reset()
Definition: memory.cpp:66
mixal::Computer::rX
Register5 rX
Definition: machine.h:32
mixal::Computer::memory
ComputerWord memory[NUM_MEMORY]
Definition: machine.h:38
mixal::IODevice::wordAt
virtual ComputerWord & wordAt(int32_t index)=0
mixal::Computer::comparison
ComparisonIndicator comparison
Definition: machine.h:36
mixal::Computer::waitDevices
void waitDevices()
Definition: machine_io.cpp:48
mixal::Computer::overflow
bool overflow
Definition: machine.h:35
mixal::ComputerWord::set
void set(int32_t value)
Definition: memory.cpp:178
mixal::Computer::executeSinglePesudo
void executeSinglePesudo(ParsedResult *instruction)
Definition: machine.cpp:315
mixal::Instructions::getCost
static int getCost(Instructions::Code code, uint8_t field=0)
Definition: instructions.cpp:2045
mixal::Expression::getConstExpression
static Expression getConstExpression(const AtomicValue &value)
Definition: expression.cpp:23
mixal::Computer::devices
std::vector< IODevice * > devices
Definition: machine.h:39
mixal::Computer::getDevice
IODevice * getDevice(int32_t index)
Definition: machine_io.cpp:11
mixal::Register2::reset
void reset()
Definition: registers.h:44
mixal::Computer::NUM_IO_DEVICE
static const int NUM_IO_DEVICE
Definition: machine.h:30
mixal::Computer::rI
Register2 & rI(int index)
Definition: machine.cpp:16
mixal::Computer::rA
Register5 rA
Definition: machine.h:32
mixal::Atomic::isLocalSymbol
bool isLocalSymbol() const
Definition: atomic.cpp:50
mixal::Computer::rJ
Register2 rJ
Definition: machine.h:33
Generated by doxygen 1.8.20