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

Static Public Member Functions

static ParsedResult parseLine (const std::string &line, const std::string &lineSymbol, bool hasLocation=true)
 

Detailed Description

Definition at line 74 of file parser.h.

Member Function Documentation

◆ parseLine()

ParsedResult mixal::Parser::parseLine ( const std::string &  line,
const std::string &  lineSymbol,
bool  hasLocation = true 
)
static

Parse one line of code.

Parameters
lineThe code.
lineSymbol
See also
mixal::Expression
Parameters
hasLocationWhether the code should have the location part.

Definition at line 143 of file parser.cpp.

143  {
144  const char END_CHAR = '#';
145  const int INIT_INDEX = -1;
146  ParsedResult result;
147  result.word.setField(5); // For most of the operations, the default field value is (0:5) = 5.
148  result.parsedType = ParsedType::INSTRUCTION;
149  auto state = hasLocation ? ParseState::START : ParseState::BEFORE_OP;
150  int locationStart = INIT_INDEX,
151  operationStart = INIT_INDEX,
152  addressStart = INIT_INDEX,
153  indexStart = INIT_INDEX,
154  fieldStart = INIT_INDEX,
155  commentStart = INIT_INDEX,
156  defaultField = INIT_INDEX;
157  std::unordered_map<std::string, AtomicValue> emptyDict;
158  for (int i = 0; i <= static_cast<int>(line.size()); ++i) {
159  char ch = i < static_cast<int>(line.size()) ? line[i] : END_CHAR;
160  switch (state) {
161  case ParseState::START:
162  if (ch == ' ') {
163  // This line does not have the location name.
164  state = ParseState::BEFORE_OP;
165  } else if (ch == '*') {
166  // This line only contains comments.
167  state = ParseState::COMMENT;
168  result.parsedType = ParsedType::EMPTY;
169  commentStart = i;
170  } else if (ch == END_CHAR) {
171  state = ParseState::END;
172  result.parsedType = ParsedType::EMPTY;
173  } else if (isalnum(ch)) {
174  // A valid character in location.
175  state = ParseState::LOC;
176  locationStart = i;
177  } else {
178  throw ParseError(i, "Unexpected character encountered while parsing location: " + std::string(1, ch));
179  }
180  break;
181 
182  case ParseState::LOC:
183  if (ch == ' ') {
184  state = ParseState::BEFORE_OP;
185  result.rawLocation = line.substr(locationStart, i - locationStart);
186  } else if (!isalnum(ch)) {
187  throw ParseError(i, "Unexpected character encountered while parsing location: " + std::string(1, ch));
188  }
189  break;
190 
191  case ParseState::BEFORE_OP:
192  if (ch == ' ') {
193  continue;
194  } else if (ch == END_CHAR) {
195  if (locationStart != INIT_INDEX) {
196  throw ParseError(i, "No operation found after location");
197  }
198  state = ParseState::END;
199  result.parsedType = ParsedType::EMPTY;
200  } else if (isalnum(ch)) {
201  state = ParseState::OP;
202  operationStart = i;
203  } else {
204  throw ParseError(i, "Unexpected character encountered while finding operation: " + std::string(1, ch));
205  }
206  break;
207 
208  case ParseState::OP:
209  if (ch == ' ' || ch == END_CHAR) {
210  result.operation = line.substr(operationStart, i - operationStart);
211  int32_t operation = static_cast<int>(Instructions::getInstructionCode(result.operation));
212  if (ch == ' ') {
213  if (Instructions::hasArguments(static_cast<Instructions::Code>(operation))) {
214  state = ParseState::BEFORE_ADDRESS;
215  } else {
216  state = ParseState::BEFORE_COMMENT;
217  }
218  } else {
219  state = ParseState::END;
220  }
221  if (operation == Instructions::INVALID) {
222  throw ParseError(i, "Unknown operation: " + result.operation);
223  } else if (operation <= Instructions::LAST) {
224  result.word.setOperation(static_cast<uint8_t>(operation));
225  defaultField = Instructions::getDefaultField(result.operation);
226  } else {
227  result.parsedType = ParsedType::PSEUDO;
228  result.word.setOperation(static_cast<uint8_t>(operation - Instructions::PSEUDO));
229  if (operation == Instructions::ALF) {
230  // The "address" in ALF starts exactly two characters after the operation.
231  result.rawAddress = " ";
232  ++i;
233  for (int shift = 0; shift < 5 && i < static_cast<int>(line.size()); ++shift) {
234  result.rawAddress[shift] = line[++i];
235  }
236  int32_t charsValue = ComputerWord(result.rawAddress).value();
237  result.address = Expression::getConstExpression(AtomicValue(charsValue));
238  if (i < static_cast<int>(line.size())) {
239  state = ParseState::BEFORE_COMMENT;
240  } else {
241  state = ParseState::END;
242  }
243  }
244  }
245  } else if (!isalnum(ch)) {
246  throw ParseError(i, "Unexpected character encountered while parsing operation: " + std::string(1, ch));
247  }
248  break;
249 
250  case ParseState::BEFORE_ADDRESS:
251  if (ch == ' ') {
252  continue;
253  } else if (ch == END_CHAR) {
254  state = ParseState::END;
255  } else if (Expression::isValidFirst(ch)) {
256  state = ParseState::ADDRESS;
257  addressStart = i;
258  } else {
259  throw ParseError(i, "Unexpected character encountered while finding address: " + std::string(1, ch));
260  }
261  break;
262 
263  case ParseState::ADDRESS:
264  if (ch == ' ' || ch == ',' || ch == '(' || ch == END_CHAR) {
265  if (ch == ' ') {
266  state = ParseState::BEFORE_COMMENT;
267  } else if (ch == ',') {
268  state = ParseState::BEFORE_INDEX;
269  } else if (ch == '(') {
270  state = ParseState::FIELD_OPEN;
271  } else {
272  state = ParseState::END;
273  }
274  result.rawAddress = line.substr(addressStart, i - addressStart);
275  try {
276  result.address.parse(result.rawAddress, lineSymbol);
277  } catch (const ExpressionError& e) {
278  throw ParseError(addressStart + e.index(), e.what());
279  }
280  result.evaluateAddress(emptyDict);
281  } else if (!Expression::isValidChar(ch)) {
282  throw ParseError(i, "Unexpected character encountered while parsing address: " + std::string(1, ch));
283  }
284  break;
285 
286  case ParseState::BEFORE_INDEX:
287  if (Expression::isValidFirst(ch)) {
288  state = ParseState::INDEX;
289  indexStart = i;
290  } else if (ch == END_CHAR) {
291  throw ParseError(i, "No index found after comma");
292  } else {
293  throw ParseError(i, "Unexpected character encountered while finding index: " + std::string(1, ch));
294  }
295  break;
296 
297  case ParseState::INDEX:
298  if (ch == ' ' || ch == '(' || ch == END_CHAR) {
299  if (ch == ' ') {
300  state = ParseState::BEFORE_COMMENT;
301  } else if (ch == '(') {
302  state = ParseState::FIELD_OPEN;
303  } else {
304  state = ParseState::END;
305  }
306  result.rawIndex = line.substr(indexStart, i - indexStart);
307  try {
308  result.index.parse(result.rawIndex, lineSymbol);
309  } catch (const ExpressionError& e) {
310  throw ParseError(addressStart + e.index(), e.what());
311  }
312  result.evaluateIndex(emptyDict);
313  } else if (!Expression::isValidChar(ch)) {
314  throw ParseError(i, "Unexpected character encountered while parsing index: " + std::string(1, ch));
315  }
316  break;
317 
318  case ParseState::FIELD_OPEN:
319  if (Expression::isValidFirst(ch)) {
320  state = ParseState::FIELD;
321  fieldStart = i;
322  } else {
323  throw ParseError(i, "Unexpected character encountered "
324  "while parsing modification: " + std::string(1, ch));
325  }
326  break;
327 
328  case ParseState::FIELD:
329  if (ch == ')') {
330  state = ParseState::FIELD_CLOSE;
331  result.rawField = line.substr(fieldStart, i - fieldStart);
332  try {
333  result.field.parse(result.rawField, lineSymbol);
334  } catch (const ExpressionError& e) {
335  throw ParseError(addressStart + e.index(), e.what());
336  }
337  result.evaluateField(emptyDict);
338  } else if (!Expression::isValidChar(ch)) {
339  throw ParseError(i, "Unexpected character encountered while parsing index: " + std::string(1, ch));
340  }
341  break;
342 
343  case ParseState::FIELD_CLOSE:
344  if (ch == ' ' || ch == END_CHAR) {
345  if (ch == ' ') {
346  state = ParseState::BEFORE_COMMENT;
347  } else {
348  state = ParseState::END;
349  }
350  } else {
351  throw ParseError(i, "Unexpected character encountered while parsing field: " + std::string(1, ch));
352  }
353  break;
354 
355  case ParseState::BEFORE_COMMENT:
356  if (ch == END_CHAR) {
357  state = ParseState::END;
358  } else if (ch != ' ') {
359  state = ParseState::COMMENT;
360  commentStart = i;
361  }
362  break;
363 
364  case ParseState::COMMENT:
365  if (ch == END_CHAR) {
366  state = ParseState::END;
367  result.comment = line.substr(commentStart, i - commentStart);
368  }
369  break;
370 
371  case ParseState::END:
372  break;
373  }
374  }
375  if (result.rawField.empty()) {
376  if (result.word.operation() == Instructions::MOVE) {
377  // The default field value for MOVE is 1, but it is not mandatory.
378  defaultField = 1;
379  } else if (result.word.operation() == Instructions::NOP) {
380  // The whole word is `+0`, but it is not mandatory.
381  defaultField = 0;
382  }
383  }
384  if (defaultField >= 0) {
385  result.word.setField(defaultField);
386  }
387  assert(state == ParseState::END);
388  return result;
389 }

References mixal::ParsedResult::address, mixal::ParsedResult::comment, mixal::ParsedResult::field, mixal::Expression::getConstExpression(), mixal::Instructions::getDefaultField(), mixal::Instructions::getInstructionCode(), mixal::Instructions::hasArguments(), mixal::ExpressionError::index(), mixal::ParsedResult::index, mixal::Expression::isValidChar(), mixal::Expression::isValidFirst(), mixal::ComputerWord::operation(), mixal::ParsedResult::operation, mixal::Expression::parse(), mixal::ParsedResult::parsedType, mixal::ParsedResult::rawAddress, mixal::ParsedResult::rawField, mixal::ParsedResult::rawIndex, mixal::ParsedResult::rawLocation, mixal::ComputerWord::setField(), mixal::ComputerWord::setOperation(), mixal::ComputerWord::value(), mixal::ExpressionError::what(), and mixal::ParsedResult::word.

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

The documentation for this class was generated from the following files:
mixal::Expression::isValidFirst
static bool isValidFirst(char ch)
Definition: expression.cpp:46
mixal::Expression::isValidChar
static bool isValidChar(char ch)
Definition: expression.cpp:50
mixal::Instructions::getDefaultField
static int getDefaultField(const std::string &name)
Definition: instructions.cpp:1222
mixal::Expression::getConstExpression
static Expression getConstExpression(const AtomicValue &value)
Definition: expression.cpp:23
mixal::Instructions::hasArguments
static bool hasArguments(Instructions::Code code)
Definition: instructions.cpp:5
mixal::Instructions::getInstructionCode
static Instructions::Code getInstructionCode(const std::string &name)
Definition: instructions.cpp:9
Generated by doxygen 1.8.20