MIXAL
machine.cpp
1 #include <iostream>
2 #include <set>
3 #include <tuple>
4 #include <sstream>
5 #include <cassert>
6 #include "machine.h"
7 #include "parser.h"
8 
9 namespace mixal {
10 
11 Computer::Computer() : 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() {}
15 
16 Register2& Computer::rI(int index) {
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 }
27 
28 Computer::~Computer() {
29  for (size_t i = 0; i < devices.size(); ++i) {
30  delete devices[i];
31  }
32 }
33 
34 const ComputerWord& Computer::memoryAt(int16_t index) const {
35  return memory[index];
36 }
37 
38 ComputerWord& Computer::memoryAt(int16_t index) {
39  return memory[index];
40 }
41 
42 void Computer::reset() {
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 }
62 
63 std::string Computer::getSingleLineSymbol() {
64  std::string symbolName = getPesudoSymbolname();
65  _constants[symbolName] = AtomicValue(_lineOffset);
66  return symbolName;
67 }
68 
69 void Computer::executeSingle() {
70  executeSingle(memory[_lineOffset]);
71 }
72 
73 void Computer::executeUntilSelfLoop() {
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 }
87 
88 void Computer::executeUntilHalt() {
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 }
102 
103 void Computer::executeSingle(ParsedResult* instruction) {
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 }
120 
121 void Computer::executeSingle(const InstructionWord& instruction) {
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 }
314 
315 void Computer::executeSinglePesudo(ParsedResult* instruction) {
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 }
328 
329 void Computer::loadCodes(const std::string& codes, bool addHalt) {
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 }
338 
339 void Computer::loadCodes(const std::vector<std::string>& codes, bool addHalt) {
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 }
534 
535 std::string Computer::getPesudoSymbolname() {
536  return "#" + std::to_string(_pesudoVarIndex++);
537 }
538 
539 int32_t Computer::getIndexedAddress(const InstructionWord& instruction, bool checkRange) {
540  int32_t offset = 0;
541  if (instruction.index() != 0) {
542  auto& rIi = rI(instruction.index());
543  offset = static_cast<int32_t>(rIi.value());
544  }
545  int32_t address = static_cast<int32_t>(instruction.addressValue()) + offset;
546  if (checkRange && !(0 <= address && address < NUM_MEMORY)) {
547  throw RuntimeError(_lineOffset, "Invalid address in instruction '" + instruction.getBytesString() +
548  "': " + std::to_string(address));
549  }
550  return address;
551 }
552 
553 void Computer::copyToRegister5(const InstructionWord& instruction, const ComputerWord& word, Register5* reg) {
554  int32_t start = instruction.field() / 8;
555  int32_t stop = instruction.field() % 8;
556  reg->reset();
557  if (start > stop || stop > 5) {
558  throw RuntimeError(_lineOffset, "Invalid field value: ("
559  + std::to_string(start) + ":" + std::to_string(stop) + ")");
560  }
561  if (start == 0) {
562  reg->negative = word.negative;
563  ++start;
564  }
565  for (int32_t i = stop, j = 5; i >= start; --i, --j) {
566  reg->set(j, word[i]);
567  }
568 }
569 
570 void Computer::copyFromRegister5(const InstructionWord& instruction, const Register5& reg, ComputerWord* word) {
571  int32_t start = instruction.field() / 8;
572  int32_t stop = instruction.field() % 8;
573  if (start > stop || stop > 5) {
574  throw RuntimeError(_lineOffset, "Invalid field value: ("
575  + std::to_string(start) + ":" + std::to_string(stop) + ")");
576  }
577  if (start == 0) {
578  word->negative = reg.negative;
579  ++start;
580  }
581  for (int32_t i = stop, j = 5; i >= start; --i, --j) {
582  word->set(i, reg[j]);
583  }
584 }
585 
586 void Computer::copyToRegister2(const InstructionWord& instruction, const ComputerWord& word, Register2* reg) {
587  int32_t start = instruction.field() / 8;
588  int32_t stop = instruction.field() % 8;
589  if (start > stop || stop > 5) {
590  throw RuntimeError(_lineOffset, "Invalid field value: ("
591  + std::to_string(start) + ":" + std::to_string(stop) + ")");
592  }
593  reg->reset();
594  if (start == 0) {
595  reg->negative = word.negative;
596  ++start;
597  }
598  for (int32_t i = stop, j = 2; i >= start && j > 0; --i, --j) {
599  reg->set(j, word[i]);
600  }
601 }
602 
608 int32_t Computer::checkRange(int32_t value, int bytes) {
609  int32_t range = 1 << (6 * bytes);
610  if (std::abs(value) >= range) {
611  if (bytes == 5) {
612  overflow = true;
613  }
614  value %= range;
615  }
616  return value;
617 }
618 
619 uint8_t Computer::getAX(int index) const {
620  assert(1 <= index && index <= 10);
621  return index <= 5 ? rA[index] : rX[index - 5];
622 }
623 
624 void Computer::setAX(int index, uint8_t value) {
625  assert(1 <= index && index <= 10);
626  if (index <= 5) {
627  rA[index] = value;
628  } else {
629  rX[index - 5] = value;
630  }
631 }
632 
633 }; // namespace mixal
mixal::Computer::NUM_INDEX_REGISTER
static const int NUM_INDEX_REGISTER
Definition: machine.h:28
mixal::Computer::Computer
Computer()
Definition: machine.cpp:11
mixal::Computer::loadCodes
void loadCodes(const std::string &codes, bool addHalt=true)
Definition: machine.cpp:329
mixal::ComparisonIndicator
ComparisonIndicator
Definition: flags.h:14
mixal::Computer::reset
void reset()
Definition: machine.cpp:42
mixal::Computer::executeSingle
void executeSingle()
Definition: machine.cpp:69
mixal::ComputerWord
Definition: memory.h:25
mixal::Expression::getConstOffsetExpression
static Expression getConstOffsetExpression(const std::string &symbol, int32_t offset)
Definition: expression.cpp:38
mixal::ParsedResult::field
Expression field
Definition: parser.h:43
mixal::Computer::rI1
Register2 rI1
Definition: machine.h:33
mixal::ComputerWord::field
uint8_t field() const
Definition: memory.h:147
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::ParsedResult::word
ComputerWord word
Definition: parser.h:44
mixal::ComputerWord::reset
void reset()
Definition: memory.cpp:66
mixal::Computer::rX
Register5 rX
Definition: machine.h:32
mixal::Computer::getSingleLineSymbol
std::string getSingleLineSymbol()
Definition: machine.cpp:63
mixal::Computer::memory
ComputerWord memory[NUM_MEMORY]
Definition: machine.h:38
mixal::Computer::memoryAt
const ComputerWord & memoryAt(int16_t index) const
Definition: machine.cpp:34
mixal::Computer::executeUntilHalt
void executeUntilHalt()
Definition: machine.cpp:88
mixal::Computer::comparison
ComparisonIndicator comparison
Definition: machine.h:36
machine.h
The virtual machine.
mixal::Computer::executeUntilSelfLoop
void executeUntilSelfLoop()
Definition: machine.cpp:73
mixal::Computer::waitDevices
void waitDevices()
Definition: machine_io.cpp:48
mixal::Computer::overflow
bool overflow
Definition: machine.h:35
mixal::Register2
Definition: registers.h:23
mixal::ComputerWord::set
void set(int32_t value)
Definition: memory.cpp:178
mixal::ParsedResult::index
Expression index
Definition: parser.h:41
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::ParsedResult
Definition: parser.h:32
mixal::Computer::devices
std::vector< IODevice * > devices
Definition: machine.h:39
mixal::ParsedResult::evaluated
bool evaluated() const
Definition: parser.cpp:99
mixal::Expression::literalConstant
bool literalConstant() const
Definition: expression.h:149
mixal::ParsedResult::evaluate
bool evaluate(const std::unordered_map< std::string, AtomicValue > &constants)
Definition: parser.cpp:45
parser.h
Parse one line of code.
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::ComputerWord::operation
uint8_t operation() const
Definition: memory.h:153
mixal::AtomicValue
Definition: expression.h:75
mixal::Computer::rI
Register2 & rI(int index)
Definition: machine.cpp:16
mixal::Computer::rA
Register5 rA
Definition: machine.h:32
mixal::RuntimeError
Definition: errors.h:51
mixal::Atomic::isLocalSymbol
bool isLocalSymbol() const
Definition: atomic.cpp:50
mixal::ParsedResult::parsedType
ParsedType parsedType
Definition: parser.h:34
mixal::Computer::rJ
Register2 rJ
Definition: machine.h:33
mixal::ParsedResult::address
Expression address
Definition: parser.h:39
Generated by doxygen 1.8.20