1375 lines
43 KiB
C++
1375 lines
43 KiB
C++
#include "comdel_parser.h"
|
|
|
|
#include "poly.h"
|
|
#include "tokens_type.h"
|
|
|
|
#include <utility>
|
|
#include <algorithm>
|
|
#include <fstream>
|
|
#include <sstream>
|
|
|
|
ComdelParser::ComdelParser(std::vector<Token> tokens)
|
|
: tokens(std::move(tokens)), position(0) {}
|
|
|
|
// Tries to consume a token, returns an error otherwise.
|
|
// Unlike the regular consume() call this should be used
|
|
// when a missing token means a syntax error.
|
|
#define RETURN_IF_NOT_TOKEN(tokenType) \
|
|
do { \
|
|
if (!consume(tokenType)) { \
|
|
return unexpected(); \
|
|
} \
|
|
} while (0)
|
|
|
|
|
|
// Checks if the current token matches the argument.
|
|
// Otherwise, adds the token to the list of expected tokens (used in
|
|
// error message).
|
|
bool ComdelParser::check(TokenType tokenType) {
|
|
if (current().type == tokenType)
|
|
return true;
|
|
|
|
expectedTokens.insert(tokenType);
|
|
return false;
|
|
}
|
|
|
|
Token &ComdelParser::current() {
|
|
return tokens[position];
|
|
}
|
|
|
|
// attempts to consume a token and returns whether it's successful
|
|
bool ComdelParser::consume(TokenType tokenType) {
|
|
bool exists = check(tokenType);
|
|
if (exists) {
|
|
bump();
|
|
}
|
|
return exists;
|
|
}
|
|
|
|
#define ATLAS_ASSERT_FAIL(x) \
|
|
do{}while(0)
|
|
|
|
void ComdelParser::bump() {
|
|
if (tokens[position].type != TokenType::END_OF_FILE) {
|
|
++position;
|
|
} else {
|
|
ATLAS_ASSERT_FAIL("Internal parser error, called bump after EOF");
|
|
}
|
|
expectedTokens.clear();
|
|
}
|
|
|
|
// Generates an "unexpected token" error that also
|
|
// includes a list of valid alternatives based on the contents
|
|
// of the expectedTokens vector
|
|
//
|
|
// e.g. "expected one of: ',', ')', found 'c'"
|
|
// when parsing "func(a, b c);"
|
|
PError ComdelParser::unexpected() {
|
|
std::stringstream ss;
|
|
ss << "Found: `" << current().text << "`. ";
|
|
|
|
ss << "Expected";
|
|
if (expectedTokens.size() > 1) {
|
|
ss << " one of: ";
|
|
} else {
|
|
ss << ": ";
|
|
}
|
|
uint token_counter = 0;
|
|
for (auto &type: expectedTokens) {
|
|
if (type == TokenType::IDENTIFIER ||
|
|
type == TokenType::NUMBER ||
|
|
type == TokenType::STRING ||
|
|
type == TokenType::COLOR) {
|
|
ss << tokenTypeToString(type);
|
|
} else {
|
|
ss << "`" << tokenTypeToString(type) << "`";
|
|
}
|
|
++token_counter;
|
|
if (token_counter < expectedTokens.size())
|
|
ss << ", ";
|
|
else
|
|
ss << ".";
|
|
}
|
|
return {{current().span, ss.str()}};
|
|
}
|
|
|
|
// Parses a list of 'nodes' separated by 'separator'. Parsed nodes
|
|
// are returned in a vector. A list can be empty which will give
|
|
// an empty vector.
|
|
//
|
|
// The list is enclosed in 'openDelim' and 'closeDelim'.
|
|
//
|
|
// 'openDelim' and 'separator' are optional (could be nullopt).
|
|
//
|
|
// 'closeDelim' is mandatory, and it will be consumed.
|
|
//
|
|
// Function 'parse_f' should only parseLibrary a single node of type T.
|
|
//
|
|
// Parameter allowTrailing==true means that the list should end with
|
|
// 'separator' and otherwise the list should end with 'node'. This
|
|
// parameter is false in every call-site!
|
|
template<typename T>
|
|
PResult<std::vector<T>>
|
|
ComdelParser::parseList(std::optional<TokenType> openDelim,
|
|
TokenType closeDelim,
|
|
std::optional<TokenType> separator,
|
|
bool allowTrailing,
|
|
const std::function<PResult<T>()> &parse_f) {
|
|
std::vector<T> vec;
|
|
|
|
if (openDelim) {
|
|
RETURN_IF_NOT_TOKEN(*openDelim);
|
|
}
|
|
|
|
bool first = true;
|
|
while (true) {
|
|
if (consume(closeDelim)) {
|
|
break;
|
|
}
|
|
if (!first && separator) {
|
|
RETURN_IF_NOT_TOKEN(*separator);
|
|
if (allowTrailing && consume(closeDelim)) {
|
|
break;
|
|
}
|
|
}
|
|
first = false;
|
|
auto item = parse_f();
|
|
RETURN_IF_ERR(item);
|
|
vec.push_back(*item);
|
|
}
|
|
|
|
return vec;
|
|
}
|
|
|
|
void ComdelParser::skipUntilNextKeyword() {
|
|
int depth = 0;
|
|
bool enteredBlock = false;
|
|
|
|
while (true) {
|
|
if (is_keyword(current().type) && (!enteredBlock || (enteredBlock && depth == 0))) {
|
|
break;
|
|
}
|
|
|
|
if (check(TokenType::LBRACE)) {
|
|
enteredBlock = true;
|
|
depth++;
|
|
} else if (check(TokenType::RBRACE)) {
|
|
if (depth == 0) {
|
|
break;
|
|
}
|
|
depth--;
|
|
} else if (check(TokenType::END_OF_FILE)) {
|
|
break;
|
|
}
|
|
bump();
|
|
}
|
|
}
|
|
|
|
const std::vector<SourceError> &ComdelParser::getErrors() {
|
|
return errors;
|
|
}
|
|
|
|
Span &ComdelParser::getPreviousSpan() {
|
|
static Span span;
|
|
if (position == 0) {
|
|
return span;
|
|
} else {
|
|
return tokens[position].span;
|
|
}
|
|
}
|
|
|
|
// See comment for Spanner
|
|
Spanner ComdelParser::getSpanner() {
|
|
return {current().span, getPreviousSpan()};
|
|
}
|
|
|
|
// utility for reading strings
|
|
#define ASSIGN_OR_SET_ERR(var, presult) \
|
|
do { \
|
|
auto&& assign_or_return_if_err_temp_ = (presult); \
|
|
if (!assign_or_return_if_err_temp_) { \
|
|
err = PError(assign_or_return_if_err_temp_.error()); \
|
|
} else { \
|
|
(var) = *assign_or_return_if_err_temp_; \
|
|
} \
|
|
} while (0)
|
|
|
|
// utility for reading strings
|
|
#define APPEND_OR_SET_ERR(var, presult) \
|
|
do { \
|
|
auto&& assign_or_return_if_err_temp_ = (presult); \
|
|
if (!assign_or_return_if_err_temp_) { \
|
|
err = PError(assign_or_return_if_err_temp_.error()); \
|
|
} else { \
|
|
(var).push_back(*assign_or_return_if_err_temp_); \
|
|
} \
|
|
} while (0)
|
|
|
|
// utility for reading strings
|
|
#define APPEND_OR_RETURN_IF_ERR(var, presult) \
|
|
do { \
|
|
auto&& assign_or_return_if_err_temp_ = (presult); \
|
|
if (!assign_or_return_if_err_temp_) { \
|
|
return PError(assign_or_return_if_err_temp_.error()); \
|
|
} else { \
|
|
(var).push_back(*assign_or_return_if_err_temp_); \
|
|
} \
|
|
} while (0)
|
|
|
|
|
|
/****************************************************************************
|
|
*
|
|
* F U N C T I O N S O F R E C U R S I V E D E S C E N T P A R S E R
|
|
*
|
|
****************************************************************************/
|
|
|
|
std::optional<LibraryNode> ComdelParser::parseLibrary() {
|
|
|
|
auto spanner = getSpanner();
|
|
LibraryNode library{};
|
|
|
|
while (!check(TokenType::END_OF_FILE)) {
|
|
PResult<poly<AstNode>> err;
|
|
if (check(TokenType::KW_NAME)) {
|
|
bump();
|
|
ASSIGN_OR_SET_ERR(library.name, parseString());
|
|
} else if (check(TokenType::KW_HEADER)) {
|
|
bump();
|
|
ASSIGN_OR_SET_ERR(library.header, parseString());
|
|
} else if (check(TokenType::KW_COMPONENT_HEADER)) {
|
|
bump();
|
|
ASSIGN_OR_SET_ERR(library.componentHeader, parseString());
|
|
} else if (check(TokenType::KW_DIRECTORY)) {
|
|
bump();
|
|
ASSIGN_OR_SET_ERR(library.componentDirectory, parseString());
|
|
} else if (check(TokenType::KW_INFO)) {
|
|
bump();
|
|
ASSIGN_OR_SET_ERR(library.libraryInfo, parseString());
|
|
} else if (check(TokenType::KW_ADDRESS)) {
|
|
APPEND_OR_SET_ERR(library.addressSpaces, parseAddress());
|
|
} else if (check(TokenType::KW_COMPONENT)) {
|
|
APPEND_OR_SET_ERR(library.components, parseComponent());
|
|
} else if (check(TokenType::KW_BUS)) {
|
|
APPEND_OR_SET_ERR(library.buses, parseBus());
|
|
} else if (check(TokenType::KW_CONNECTION)) {
|
|
APPEND_OR_SET_ERR(library.connections, parseConnection());
|
|
} else if (check(TokenType::KW_MESSAGES)) {
|
|
bump();
|
|
ASSIGN_OR_SET_ERR(library.messages, parseList<PropertyNode>(TokenType::LBRACE,
|
|
TokenType::RBRACE,
|
|
std::nullopt,
|
|
false,
|
|
[this] { return parseProperty(TokenType::STRING);
|
|
}
|
|
));
|
|
if (!err.has_value()) {
|
|
skipUntilNextKeyword();
|
|
bump();
|
|
}
|
|
} else {
|
|
err = unexpected();
|
|
bump();
|
|
}
|
|
if (!err.has_value()) {
|
|
errors.push_back(err.error());
|
|
skipUntilNextKeyword();
|
|
}
|
|
}
|
|
|
|
if (!errors.empty())
|
|
return std::nullopt;
|
|
|
|
return spanner(library);
|
|
}
|
|
|
|
/****************************************************************************
|
|
*
|
|
* StringNode := "\"" + CONTENT + "\""
|
|
*
|
|
****************************************************************************/
|
|
PResult<StringNode> ComdelParser::parseString() {
|
|
auto spanner = getSpanner();
|
|
if (check(TokenType::STRING)) {
|
|
StringNode node;
|
|
node.value = current().text;
|
|
node.span = current().span;
|
|
bump();
|
|
return spanner(node);
|
|
}
|
|
return unexpected();
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
*
|
|
* ColorNode := #RRGGBB[AA]
|
|
*
|
|
****************************************************************************/
|
|
PResult<ColorNode> ComdelParser::parseColor() {
|
|
auto spanner = getSpanner();
|
|
if (check(TokenType::COLOR)) {
|
|
ColorNode node{current().text};
|
|
node.span = current().span;
|
|
bump();
|
|
return spanner(node);
|
|
}
|
|
return unexpected();
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
*
|
|
* IdentifierNode := IDENTIFIER
|
|
*
|
|
****************************************************************************/
|
|
PResult<IdentifierNode> ComdelParser::parseIdentifier() {
|
|
auto spanner = getSpanner();
|
|
if (check(TokenType::IDENTIFIER)) {
|
|
IdentifierNode node;
|
|
node.value = current().text;
|
|
node.span = current().span;
|
|
bump();
|
|
return spanner(node);
|
|
}
|
|
return unexpected();
|
|
}
|
|
|
|
/****************************************************************************
|
|
*
|
|
* NumberNode := ('0x' | '0b'){0,1}[0-9]*
|
|
*
|
|
****************************************************************************/
|
|
PResult<NumberNode> ComdelParser::parseNumber() {
|
|
auto spanner = getSpanner();
|
|
if (check(TokenType::NUMBER)) {
|
|
NumberNode node{current().text};
|
|
node.span = current().span;
|
|
bump();
|
|
return spanner(node);
|
|
}
|
|
return unexpected();
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
*
|
|
* CountNode := "@size (" + NumberNode + "," + NumberNode + ")"
|
|
*
|
|
****************************************************************************/
|
|
PResult<CountNode> ComdelParser::parseCount() {
|
|
auto spanner = getSpanner();
|
|
RETURN_IF_NOT_TOKEN(TokenType::KW_COUNT);
|
|
|
|
RETURN_IF_NOT_TOKEN(TokenType::LPAREN);
|
|
auto first = parseNumber();
|
|
if (!first.has_value()) {
|
|
return PError(first.error());
|
|
}
|
|
RETURN_IF_NOT_TOKEN(TokenType::COMMA);
|
|
auto second = parseNumber();
|
|
if (!second.has_value()) {
|
|
return PError(second.error());
|
|
}
|
|
RETURN_IF_NOT_TOKEN(TokenType::RPAREN);
|
|
|
|
return spanner(CountNode{first.value(), second.value()});
|
|
}
|
|
|
|
/****************************************************************************
|
|
*
|
|
* PropertyNode := key: value;
|
|
*
|
|
****************************************************************************/
|
|
PResult<PropertyNode> ComdelParser::parseProperty(std::optional<TokenType> valueType = std::nullopt) {
|
|
auto spanner = getSpanner();
|
|
IdentifierNode key;
|
|
ASSIGN_OR_RETURN_IF_ERR(key, parseIdentifier());
|
|
|
|
RETURN_IF_NOT_TOKEN(TokenType::COLON);
|
|
|
|
if (valueType.has_value()) {
|
|
if (valueType == TokenType::BOOL_TYPE) {
|
|
if (!(check(TokenType::TRUE) || check(TokenType::FALSE))) {
|
|
return unexpected();
|
|
}
|
|
} else if (!check(*valueType)) {
|
|
return unexpected();
|
|
}
|
|
}
|
|
ValueNode value;
|
|
ASSIGN_OR_RETURN_IF_ERR(value, parseValue());
|
|
|
|
RETURN_IF_NOT_TOKEN(TokenType::SEMICOLON);
|
|
|
|
PropertyNode node;
|
|
node.key = key;
|
|
node.value = value;
|
|
|
|
return spanner(node);
|
|
}
|
|
|
|
/****************************************************************************
|
|
*
|
|
* AddressSpaceNode := "@address" + IDENTIFIER "(" + NUMBER + "," + NUMBER + ")"
|
|
*
|
|
****************************************************************************/
|
|
PResult<AddressSpaceNode> ComdelParser::parseAddress() {
|
|
auto spanner = getSpanner();
|
|
|
|
AddressSpaceNode addressSpace{};
|
|
|
|
RETURN_IF_NOT_TOKEN(TokenType::KW_ADDRESS);
|
|
|
|
ASSIGN_OR_RETURN_IF_ERR(addressSpace.name, parseIdentifier());
|
|
RETURN_IF_NOT_TOKEN(TokenType::LPAREN);
|
|
ASSIGN_OR_RETURN_IF_ERR(addressSpace.start, parseNumber());
|
|
RETURN_IF_NOT_TOKEN(TokenType::COMMA);
|
|
ASSIGN_OR_RETURN_IF_ERR(addressSpace.end, parseNumber());
|
|
RETURN_IF_NOT_TOKEN(TokenType::RPAREN);
|
|
|
|
return spanner(addressSpace);
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
*
|
|
* ComponentNode := "@component" + IDENTIFIER + ("processor" | "memory") { COMPONENT_BLOCK }
|
|
*
|
|
****************************************************************************/
|
|
PResult<ComponentNode> ComdelParser::parseComponent() {
|
|
auto spanner = getSpanner();
|
|
|
|
ComponentNode component{};
|
|
|
|
RETURN_IF_NOT_TOKEN(TokenType::KW_COMPONENT);
|
|
|
|
ASSIGN_OR_RETURN_IF_ERR(component.name, parseIdentifier());
|
|
ASSIGN_OR_RETURN_IF_ERR(component.type, parseComponentType());
|
|
|
|
RETURN_IF_NOT_TOKEN(TokenType::LBRACE);
|
|
|
|
while (!check(TokenType::RBRACE)) {
|
|
PResult<poly<AstNode>> err;
|
|
if (check(TokenType::KW_INSTANCE_NAME)) {
|
|
bump();
|
|
ASSIGN_OR_SET_ERR(component.instanceName, parseIdentifier());
|
|
} else if (check(TokenType::KW_TOOLTIP)) {
|
|
bump();
|
|
ASSIGN_OR_SET_ERR(component.tooltip, parseString());
|
|
} else if (check(TokenType::KW_SOURCE)) {
|
|
bump();
|
|
ASSIGN_OR_SET_ERR(component.source, parseString());
|
|
} else if (check(TokenType::KW_COUNT)) {
|
|
ASSIGN_OR_SET_ERR(component.count, parseCount());
|
|
} else if (check(TokenType::KW_DISPLAY)) {
|
|
ASSIGN_OR_SET_ERR(component.display, parseDisplay());
|
|
} else if (check(TokenType::KW_PIN)) {
|
|
APPEND_OR_SET_ERR(component.pins, parsePin());
|
|
} else if (check(TokenType::KW_ATTRIBUTE)) {
|
|
APPEND_OR_SET_ERR(component.attributes, parseAttribute());
|
|
} else if (check(TokenType::KW_RULE)) {
|
|
APPEND_OR_SET_ERR(component.rules, parseRule());
|
|
} else {
|
|
err = unexpected();
|
|
bump();
|
|
}
|
|
if (!err.has_value()) {
|
|
errors.push_back(err.error());
|
|
skipUntilNextKeyword();
|
|
if (check(TokenType::END_OF_FILE)) {
|
|
return PError({Span(spanner.lo), "Reached EOF"});
|
|
}
|
|
}
|
|
}
|
|
|
|
RETURN_IF_NOT_TOKEN(TokenType::RBRACE);
|
|
|
|
return spanner(component);
|
|
}
|
|
|
|
PResult<EnumNode<ComponentNode::ComponentType>> ComdelParser::parseComponentType() {
|
|
EnumNode<ComponentNode::ComponentType> type;
|
|
|
|
auto spanner = getSpanner();
|
|
|
|
if (check(TokenType::CT_PROCESSOR)) {
|
|
bump();
|
|
type = EnumNode(ComponentNode::PROCESSOR);
|
|
} else if (check(TokenType::CT_MEMORY)) {
|
|
bump();
|
|
type = EnumNode(ComponentNode::MEMORY);
|
|
} else {
|
|
type = EnumNode(ComponentNode::OTHER);
|
|
}
|
|
return spanner(type);
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
*
|
|
* DisplayNode := "@display {" + (DISPLAY_ITEM)* + "}"
|
|
*
|
|
****************************************************************************/
|
|
PResult<DisplayNode> ComdelParser::parseDisplay() {
|
|
auto spanner = getSpanner();
|
|
|
|
RETURN_IF_NOT_TOKEN(TokenType::KW_DISPLAY);
|
|
DisplayNode display;
|
|
RETURN_IF_NOT_TOKEN(TokenType::LBRACE);
|
|
while (!check(TokenType::RBRACE)) {
|
|
PResult<DisplayItemNode> item;
|
|
item = parseDisplayItem();
|
|
RETURN_IF_ERR(item);
|
|
display.items.push_back(*item);
|
|
}
|
|
RETURN_IF_NOT_TOKEN(TokenType::RBRACE);
|
|
return spanner(display);
|
|
}
|
|
|
|
/****************************************************************************
|
|
*
|
|
* DisplayItemNode := "TYPE {(KEY + ":" + VALUE + ";")*}
|
|
*
|
|
****************************************************************************/
|
|
PResult<DisplayItemNode> ComdelParser::parseDisplayItem() {
|
|
auto spanner = getSpanner();
|
|
DisplayItemNode displayItem;
|
|
ASSIGN_OR_RETURN_IF_ERR(displayItem.type, parseIdentifier());
|
|
|
|
RETURN_IF_NOT_TOKEN(TokenType::LBRACE);
|
|
|
|
while (!check(TokenType::RBRACE)) {
|
|
PResult<PropertyNode> item{parseProperty()};
|
|
RETURN_IF_ERR(item);
|
|
displayItem.values.push_back(*item);
|
|
}
|
|
RETURN_IF_NOT_TOKEN(TokenType::RBRACE);
|
|
return spanner(displayItem);
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
*
|
|
* BusNode := "@bus " + NAME + TYPE + "{" + POPUP + "}"
|
|
*
|
|
****************************************************************************/
|
|
PResult<BusNode> ComdelParser::parseBus() {
|
|
auto spanner = getSpanner();
|
|
BusNode bus;
|
|
|
|
RETURN_IF_NOT_TOKEN(TokenType::KW_BUS);
|
|
|
|
ASSIGN_OR_RETURN_IF_ERR(bus.name, parseIdentifier());
|
|
ASSIGN_OR_RETURN_IF_ERR(bus.type, parseBusType());
|
|
|
|
RETURN_IF_NOT_TOKEN(TokenType::LBRACE);
|
|
|
|
while (!check(TokenType::RBRACE)) {
|
|
PResult<poly<AstNode>> err;
|
|
if (check(TokenType::KW_TOOLTIP)) {
|
|
bump();
|
|
ASSIGN_OR_SET_ERR(bus.tooltip, parseString());
|
|
} else if (check(TokenType::KW_INSTANCE_NAME)) {
|
|
bump();
|
|
ASSIGN_OR_SET_ERR(bus.instanceName, parseIdentifier());
|
|
} else if (check(TokenType::KW_COUNT)) {
|
|
ASSIGN_OR_SET_ERR(bus.count, parseCount());
|
|
} else if (check(TokenType::KW_DISPLAY)) {
|
|
ASSIGN_OR_SET_ERR(bus.display, parseDisplay());
|
|
} else if (check(TokenType::KW_WIRES)) {
|
|
bump();
|
|
if(consume(TokenType::LBRACE)) {
|
|
while (check(TokenType::IDENTIFIER)) {
|
|
APPEND_OR_RETURN_IF_ERR(bus.wires, parseWire());
|
|
|
|
if (check(TokenType::COMMA)) {
|
|
RETURN_IF_NOT_TOKEN(TokenType::COMMA);
|
|
}
|
|
}
|
|
} else {
|
|
err = unexpected();
|
|
}
|
|
if(!consume(TokenType::RBRACE)) {
|
|
err = unexpected();
|
|
}
|
|
} else {
|
|
err = unexpected();
|
|
bump();
|
|
}
|
|
if (!err.has_value()) {
|
|
errors.push_back(err.error());
|
|
skipUntilNextKeyword();
|
|
if (check(TokenType::END_OF_FILE)) {
|
|
return PError({Span(spanner.lo), "Reached EOF"});
|
|
}
|
|
}
|
|
}
|
|
|
|
RETURN_IF_NOT_TOKEN(TokenType::RBRACE);
|
|
|
|
return spanner(bus);
|
|
}
|
|
|
|
PResult<EnumNode<BusNode::BusType>> ComdelParser::parseBusType() {
|
|
PResult<EnumNode<BusNode::BusType>> type;
|
|
|
|
if (check(TokenType::IDENTIFIER)) {
|
|
auto tokenType = parseIdentifier();
|
|
if (tokenType.value().value == "automatic") {
|
|
type = EnumNode(BusNode::AUTOMATIC);
|
|
} else if (tokenType.value().value == "regular") {
|
|
type = EnumNode(BusNode::REGULAR);
|
|
} else if (tokenType.value().value == "singleAutomatic") {
|
|
type = EnumNode(BusNode::SINGLE_AUTOMATIC);
|
|
} else {
|
|
type = PError(SourceError{current().span, "expected 'automatic', 'singleAutomatic' or 'regular'"});
|
|
}
|
|
} else {
|
|
type = PError(SourceError{current().span, "expected 'automatic', 'singleAutomatic' or 'regular'"});
|
|
}
|
|
return type;
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
*
|
|
* WireNode := NAME(<SIZE>){0,1} TYPE [hidden | terminated_with (#number | null)])*
|
|
*
|
|
****************************************************************************/
|
|
PResult<WireNode> ComdelParser::parseWire() {
|
|
auto spanner = getSpanner();
|
|
WireNode wire;
|
|
|
|
ASSIGN_OR_RETURN_IF_ERR(wire.name, parseIdentifier());
|
|
|
|
if (check(TokenType::LT)) {
|
|
RETURN_IF_NOT_TOKEN(TokenType::LT);
|
|
ASSIGN_OR_RETURN_IF_ERR(wire.size, parseNumber());
|
|
RETURN_IF_NOT_TOKEN(TokenType::GT);
|
|
} else {
|
|
wire.size.value = 1;
|
|
}
|
|
|
|
// default
|
|
wire.type = EnumNode(WireNode::WIRE);
|
|
|
|
if (check(TokenType::WIRE_DEFAULT)) {
|
|
bump();
|
|
wire.type = EnumNode(WireNode::WIRE);
|
|
} else if (check(TokenType::WIRE_AND)) {
|
|
bump();
|
|
wire.type = EnumNode(WireNode::WIRED_AND);
|
|
} else if (check(TokenType::WIRE_OR)) {
|
|
bump();
|
|
wire.type = EnumNode(WireNode::WIRED_OR);
|
|
} else if (check(TokenType::R_WIRE)) {
|
|
bump();
|
|
wire.type = EnumNode(WireNode::R_WIRE);
|
|
}
|
|
|
|
while (true) {
|
|
if (check(TokenType::HIDDEN)) {
|
|
bump();
|
|
wire.hidden = true;
|
|
} else if (check(TokenType::TERMINATE_WITH)) {
|
|
bump();
|
|
wire.hasTerminateWith = true;
|
|
if (check(TokenType::NIL)) {
|
|
bump();
|
|
wire.terminateWith = ValueNode::ofNull();
|
|
} else if (check(TokenType::NUMBER)) {
|
|
auto number = parseNumber();
|
|
wire.terminateWith = ValueNode::ofInt(number->value);
|
|
} else {
|
|
auto token = current();
|
|
return PError(SourceError{token.span, "unexpected token"});
|
|
}
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
return spanner(wire);
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
*
|
|
* PinNode := "@pin" NAME TYPE "{"
|
|
"@tooltip" MESSAGE
|
|
"@connection" TYPE "(" MESSAGE ")"
|
|
DisplayNode
|
|
}
|
|
*
|
|
****************************************************************************/
|
|
PResult<PinNode> ComdelParser::parsePin() {
|
|
auto spanner = getSpanner();
|
|
|
|
RETURN_IF_NOT_TOKEN(TokenType::KW_PIN);
|
|
PinNode pin{};
|
|
|
|
ASSIGN_OR_RETURN_IF_ERR(pin.name, parseIdentifier());
|
|
|
|
if (check(TokenType::PIN_IN)) {
|
|
bump();
|
|
pin.type = EnumNode(PinNode::IN);
|
|
} else if (check(TokenType::PIN_OUT)) {
|
|
bump();
|
|
pin.type = EnumNode(PinNode::OUT);
|
|
} else if (check(TokenType::PIN_IN_OUT)) {
|
|
bump();
|
|
pin.type = EnumNode(PinNode::IN_OUT);
|
|
} else {
|
|
return unexpected();
|
|
}
|
|
|
|
RETURN_IF_NOT_TOKEN(TokenType::LBRACE);
|
|
|
|
while (!check(TokenType::RBRACE)) {
|
|
PResult<poly<AstNode>> err;
|
|
if (check(TokenType::KW_TOOLTIP)) {
|
|
bump();
|
|
ASSIGN_OR_SET_ERR(pin.tooltip, parseString());
|
|
} else if (check(TokenType::KW_DISPLAY)) {
|
|
ASSIGN_OR_SET_ERR(pin.display, parseDisplay());
|
|
} else if (check(TokenType::KW_CONNECTION)) {
|
|
ASSIGN_OR_SET_ERR(pin.connection, parsePinConnection());
|
|
} else if (check(TokenType::KW_WIRES)) {
|
|
bump();
|
|
auto wires = parseList<ValueNode>(TokenType::LBRACE,
|
|
TokenType::RBRACE,
|
|
TokenType::COMMA,
|
|
false,
|
|
[this] { return parseConnectionWire(); });
|
|
RETURN_IF_ERR(wires);
|
|
pin.wires = *wires;
|
|
} else {
|
|
err = unexpected();
|
|
bump();
|
|
}
|
|
if (!err.has_value()) {
|
|
errors.push_back(err.error());
|
|
skipUntilNextKeyword();
|
|
if (check(TokenType::END_OF_FILE)) {
|
|
return PError({Span(spanner.lo), "Reached EOF"});
|
|
}
|
|
}
|
|
}
|
|
|
|
RETURN_IF_NOT_TOKEN(TokenType::RBRACE);
|
|
|
|
return spanner(pin);
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
*
|
|
* PinConnectionNode := "@connection " + ("check_only" | "automatically") + "(" + MESSAGE + ")"
|
|
*
|
|
****************************************************************************/
|
|
PResult<PinConnectionNode> ComdelParser::parsePinConnection() {
|
|
auto spanner = getSpanner();
|
|
PinConnectionNode connection{};
|
|
|
|
RETURN_IF_NOT_TOKEN(TokenType::KW_CONNECTION);
|
|
|
|
ASSIGN_OR_RETURN_IF_ERR(connection.type, parseConnectionType());
|
|
|
|
RETURN_IF_NOT_TOKEN(TokenType::LPAREN);
|
|
ASSIGN_OR_RETURN_IF_ERR(connection.message, parseString());
|
|
RETURN_IF_NOT_TOKEN(TokenType::RPAREN);
|
|
|
|
return spanner(connection);
|
|
}
|
|
|
|
PResult<EnumNode<PinConnectionNode::ConnectionType>> ComdelParser::parseConnectionType() {
|
|
auto spanner = getSpanner();
|
|
|
|
EnumNode<PinConnectionNode::ConnectionType> type;
|
|
|
|
if (check(TokenType::IDENTIFIER)) {
|
|
auto identifier = parseIdentifier();
|
|
if (identifier.value().value == "required") {
|
|
type = EnumNode(PinConnectionNode::REQUIRED);
|
|
} else if (identifier.value().value == "optional") {
|
|
type = EnumNode(PinConnectionNode::OPTIONAL);
|
|
} else {
|
|
return PError(SourceError{current().span, "expected connection type 'required' or 'optional'"});
|
|
}
|
|
} else {
|
|
return PError(SourceError{current().span, "expected connection type 'required' or 'optional'"});
|
|
}
|
|
|
|
return spanner(type);
|
|
}
|
|
|
|
/****************************************************************************
|
|
*
|
|
* AttributeNode := "@attribute " + NAME + TYPE ("default" + VALUE){0,1} ("{" POPUP "}"){0,1}
|
|
*
|
|
****************************************************************************/
|
|
PResult<AttributeNode> ComdelParser::parseAttribute() {
|
|
auto spanner = getSpanner();
|
|
AttributeNode attribute;
|
|
|
|
RETURN_IF_NOT_TOKEN(TokenType::KW_ATTRIBUTE);
|
|
|
|
if (check(TokenType::IDENTIFIER)) {
|
|
ASSIGN_OR_RETURN_IF_ERR(attribute.name, parseIdentifier());
|
|
} else {
|
|
return unexpected();
|
|
}
|
|
|
|
if (check(TokenType::INT_TYPE)) {
|
|
attribute.type = ValueNode::INT;
|
|
} else if (check(TokenType::STRING_TYPE)) {
|
|
attribute.type = ValueNode::STRING;
|
|
} else if (check(TokenType::BOOL_TYPE)) {
|
|
attribute.type = ValueNode::BOOL;
|
|
} else if (check(TokenType::WIRE_TYPE)) {
|
|
attribute.type = ValueNode::WIRE;
|
|
} else {
|
|
return unexpected();
|
|
}
|
|
bump();
|
|
|
|
RETURN_IF_NOT_TOKEN(TokenType::DEFAULT);
|
|
|
|
if (attribute.type == ValueNode::BOOL) {
|
|
if (check(TokenType::TRUE)) {
|
|
bump();
|
|
attribute.defaultValue = ValueNode::ofBool(true);
|
|
} else if (check(TokenType::FALSE)) {
|
|
bump();
|
|
attribute.defaultValue = ValueNode::ofBool(false);
|
|
} else {
|
|
return unexpected();
|
|
}
|
|
} else if (attribute.type == ValueNode::INT) {
|
|
if (check(TokenType::NUMBER)) {
|
|
auto number = parseNumber();
|
|
attribute.defaultValue = ValueNode::ofInt(number->value);
|
|
} else {
|
|
return unexpected();
|
|
}
|
|
} else if (attribute.type == ValueNode::STRING) {
|
|
if (check(TokenType::STRING)) {
|
|
auto string = parseString();
|
|
attribute.defaultValue = ValueNode::ofString(string->asString());
|
|
} else {
|
|
return unexpected();
|
|
}
|
|
} else if (attribute.type == ValueNode::IDENTIFIER) {
|
|
if (check(TokenType::IDENTIFIER)) {
|
|
auto identifier = parseIdentifier();
|
|
attribute.defaultValue = ValueNode::ofIdentifier(identifier->value);
|
|
} else {
|
|
return unexpected();
|
|
}
|
|
} else if (attribute.type == ValueNode::MEMORY) {
|
|
if (check(TokenType::IDENTIFIER)) {
|
|
auto identifier = parseIdentifier();
|
|
attribute.defaultValue = ValueNode::ofMemory(identifier->value);
|
|
} else if (check(TokenType::NIL)) {
|
|
bump();
|
|
attribute.defaultValue = ValueNode::ofMemory(std::nullopt);
|
|
} else {
|
|
return unexpected();
|
|
}
|
|
} else if (attribute.type == ValueNode::WIRE) {
|
|
if (check(TokenType::IDENTIFIER)) {
|
|
auto identifier = parseIdentifier();
|
|
attribute.defaultValue = ValueNode::ofWire(identifier->value);
|
|
} else if (check(TokenType::NIL)) {
|
|
bump();
|
|
attribute.defaultValue = ValueNode::ofWire(std::nullopt);
|
|
} else {
|
|
return unexpected();
|
|
}
|
|
}
|
|
|
|
if (check(TokenType::LBRACE)) {
|
|
RETURN_IF_NOT_TOKEN(TokenType::LBRACE);
|
|
PopupNode popup;
|
|
|
|
if (!check(TokenType::KW_POPUP)) {
|
|
return unexpected();
|
|
}
|
|
|
|
ASSIGN_OR_RETURN_IF_ERR(popup, parsePopup());
|
|
attribute.popup = std::optional<PopupNode>(popup);
|
|
RETURN_IF_NOT_TOKEN(TokenType::RBRACE);
|
|
}
|
|
|
|
return spanner(attribute);
|
|
}
|
|
|
|
/****************************************************************************
|
|
*
|
|
* Enumeration
|
|
*
|
|
****************************************************************************/
|
|
PResult<EnumerationNode> ComdelParser::parseEnumeration() {
|
|
auto spanner = getSpanner();
|
|
StringNode key;
|
|
|
|
ASSIGN_OR_RETURN_IF_ERR(key, parseString());
|
|
RETURN_IF_NOT_TOKEN(TokenType::EQUALS);
|
|
|
|
ValueNode value;
|
|
ASSIGN_OR_RETURN_IF_ERR(value, parseValue());
|
|
|
|
EnumerationNode node;
|
|
node.key = key;
|
|
node.value = value;
|
|
|
|
return spanner(node);
|
|
}
|
|
|
|
/****************************************************************************
|
|
*
|
|
* PopupNode := "@popup " + ("automatic" | "on_demand") { POPUP BODY }
|
|
*
|
|
****************************************************************************/
|
|
PResult<PopupNode> ComdelParser::parsePopup() {
|
|
auto spanner = getSpanner();
|
|
PopupNode popup;
|
|
|
|
RETURN_IF_NOT_TOKEN(TokenType::KW_POPUP);
|
|
|
|
if (check(TokenType::IDENTIFIER)) {
|
|
auto identifier = parseIdentifier();
|
|
if (identifier.value().value == "automatic") {
|
|
popup.type = EnumNode(PopupNode::AUTOMATIC);
|
|
} else if (identifier.value().value == "on_demand") {
|
|
popup.type = EnumNode(PopupNode::ON_DEMAND);
|
|
} else {
|
|
return PError(SourceError{current().span, "expected type 'automatic', 'on_demand'"});
|
|
}
|
|
} else {
|
|
popup.type = EnumNode(PopupNode::ON_DEMAND);
|
|
}
|
|
|
|
RETURN_IF_NOT_TOKEN(TokenType::LBRACE);
|
|
|
|
while (!check(TokenType::RBRACE)) {
|
|
PResult<poly<AstNode>> err;
|
|
if (check(TokenType::KW_TITLE)) {
|
|
bump();
|
|
ASSIGN_OR_SET_ERR(popup.title, parseString());
|
|
} else if (check(TokenType::KW_TEXT)) {
|
|
bump();
|
|
ASSIGN_OR_SET_ERR(popup.text, parseString());
|
|
} else if (check(TokenType::KW_RULE)) {
|
|
APPEND_OR_SET_ERR(popup.rules, parseRule());
|
|
} else if (check(TokenType::KW_ENUMERATED)) {
|
|
bump();
|
|
popup.enumerated = true;
|
|
ASSIGN_OR_SET_ERR(popup.enumeration,
|
|
parseList<EnumerationNode>(
|
|
TokenType::LBRACE,
|
|
TokenType::RBRACE,
|
|
TokenType::COMMA,
|
|
true,
|
|
[this] { return parseEnumeration(); }
|
|
)
|
|
);
|
|
} else {
|
|
err = unexpected();
|
|
bump();
|
|
}
|
|
if (!err.has_value()) {
|
|
errors.push_back(err.error());
|
|
skipUntilNextKeyword();
|
|
if (check(TokenType::END_OF_FILE)) {
|
|
return PError({Span(spanner.lo), "Reached EOF"});
|
|
}
|
|
}
|
|
}
|
|
|
|
RETURN_IF_NOT_TOKEN(TokenType::RBRACE);
|
|
|
|
return spanner(popup);
|
|
}
|
|
|
|
/****************************************************************************
|
|
*
|
|
* ConnectionNode := "@connection (" + COMPONENT + "." + PIN + "," + BUS [ + "," + COMPONENT2 + "." + "PIN2"] + ") {" + CONNECTION + "}"
|
|
*
|
|
****************************************************************************/
|
|
PResult<ConnectionNode> ComdelParser::parseConnection() {
|
|
auto spanner = getSpanner();
|
|
ConnectionNode connection;
|
|
|
|
RETURN_IF_NOT_TOKEN(TokenType::KW_CONNECTION);
|
|
|
|
RETURN_IF_NOT_TOKEN(TokenType::LPAREN);
|
|
ASSIGN_OR_RETURN_IF_ERR(connection.first.component, parseIdentifier());
|
|
RETURN_IF_NOT_TOKEN(TokenType::DOT);
|
|
ASSIGN_OR_RETURN_IF_ERR(connection.first.pin, parseIdentifier());
|
|
RETURN_IF_NOT_TOKEN(TokenType::COMMA);
|
|
ASSIGN_OR_RETURN_IF_ERR(connection.bus, parseIdentifier());
|
|
|
|
if (check(TokenType::COMMA)) {
|
|
auto conn = ConnectionComponentNode{};
|
|
RETURN_IF_NOT_TOKEN(TokenType::COMMA);
|
|
ASSIGN_OR_RETURN_IF_ERR(conn.component, parseIdentifier());
|
|
RETURN_IF_NOT_TOKEN(TokenType::DOT);
|
|
ASSIGN_OR_RETURN_IF_ERR(conn.pin, parseIdentifier());
|
|
connection.second = conn;
|
|
}
|
|
|
|
RETURN_IF_NOT_TOKEN(TokenType::RPAREN);
|
|
|
|
RETURN_IF_NOT_TOKEN(TokenType::LBRACE);
|
|
|
|
int wireCount = 0;
|
|
|
|
while (!check(TokenType::RBRACE)) {
|
|
PResult<poly<AstNode>> err;
|
|
if (check(TokenType::KW_ATTRIBUTE)) {
|
|
APPEND_OR_RETURN_IF_ERR(connection.attributes, parseAttribute());
|
|
} else if (check(TokenType::KW_WIRES)) {
|
|
bump();
|
|
auto wires = parseList<ValueNode>(TokenType::LBRACE, TokenType::RBRACE, TokenType::COMMA, false,
|
|
[this] { return parseConnectionWire(); });
|
|
RETURN_IF_ERR(wires);
|
|
if (wireCount == 0) {
|
|
connection.firstWires = *wires;
|
|
} else if (wireCount == 1 && connection.second.has_value()) {
|
|
connection.secondWires = *wires;
|
|
} else {
|
|
return unexpected();
|
|
}
|
|
wireCount++;
|
|
} else {
|
|
err = unexpected();
|
|
bump();
|
|
}
|
|
if (!err.has_value()) {
|
|
errors.push_back(err.error());
|
|
skipUntilNextKeyword();
|
|
if (check(TokenType::END_OF_FILE)) {
|
|
return PError({Span(spanner.lo), "Reached EOF"});
|
|
}
|
|
}
|
|
}
|
|
|
|
RETURN_IF_NOT_TOKEN(TokenType::RBRACE);
|
|
|
|
return spanner(connection);
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
*
|
|
* RuleNode := "@rule {" + if-else statements + "}"
|
|
*
|
|
****************************************************************************/
|
|
PResult<RuleNode> ComdelParser::parseRule() {
|
|
auto spanner = getSpanner();
|
|
RuleNode rule;
|
|
|
|
RETURN_IF_NOT_TOKEN(TokenType::KW_RULE);
|
|
|
|
RETURN_IF_NOT_TOKEN(TokenType::LBRACE);
|
|
|
|
while (!check(TokenType::RBRACE)) {
|
|
APPEND_OR_RETURN_IF_ERR(rule.statements, parseIfStatement());
|
|
if (check(TokenType::RBRACE)) {
|
|
break;
|
|
}
|
|
RETURN_IF_NOT_TOKEN(TokenType::ELSE);
|
|
}
|
|
|
|
RETURN_IF_NOT_TOKEN(TokenType::RBRACE);
|
|
|
|
return spanner(rule);
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
*
|
|
* IfStatement := "if(!function(params...)) { error(MESSAGE) | warning(MESSAGE) }
|
|
*
|
|
****************************************************************************/
|
|
PResult<IfStatementNode> ComdelParser::parseIfStatement() {
|
|
auto spanner = getSpanner();
|
|
IfStatementNode ifStatement;
|
|
|
|
RETURN_IF_NOT_TOKEN(TokenType::IF);
|
|
|
|
RETURN_IF_NOT_TOKEN(TokenType::LPAREN);
|
|
|
|
if (check(TokenType::NOT)) {
|
|
ifStatement.condition.negated = true;
|
|
bump();
|
|
} else {
|
|
ifStatement.condition.negated = false;
|
|
}
|
|
|
|
ASSIGN_OR_RETURN_IF_ERR(ifStatement.condition.functionName, parseIdentifier());
|
|
|
|
ASSIGN_OR_RETURN_IF_ERR(ifStatement.condition.params, parseList<ValueNode>(TokenType::LPAREN,
|
|
TokenType::RPAREN,
|
|
TokenType::COMMA,
|
|
false,
|
|
[this] { return parseValue(); }
|
|
));
|
|
|
|
RETURN_IF_NOT_TOKEN(TokenType::RPAREN);
|
|
|
|
RETURN_IF_NOT_TOKEN(TokenType::LBRACE);
|
|
|
|
if (check(TokenType::ERROR)) {
|
|
ifStatement.action.type = EnumNode(ActionNode::ERROR);
|
|
} else if (check(TokenType::WARNING)) {
|
|
ifStatement.action.type = EnumNode(ActionNode::WARNING);
|
|
} else {
|
|
return unexpected();
|
|
}
|
|
bump();
|
|
|
|
RETURN_IF_NOT_TOKEN(TokenType::LPAREN);
|
|
ASSIGN_OR_RETURN_IF_ERR(ifStatement.action.message, parseString());
|
|
RETURN_IF_NOT_TOKEN(TokenType::RPAREN);
|
|
|
|
RETURN_IF_NOT_TOKEN(TokenType::RBRACE);
|
|
|
|
|
|
return spanner(ifStatement);
|
|
}
|
|
|
|
PResult<ValueNode> ComdelParser::parseValue() {
|
|
auto spanner = getSpanner();
|
|
ValueNode value;
|
|
|
|
if (check(TokenType::IDENTIFIER)) {
|
|
value = ValueNode::ofIdentifier(parseIdentifier()->value);
|
|
} else if (check(TokenType::STRING)) {
|
|
value = ValueNode::ofString(parseString()->asString());
|
|
} else if (check(TokenType::NUMBER)) {
|
|
value = ValueNode::ofInt(parseNumber()->value);
|
|
} else if (check(TokenType::TRUE)) {
|
|
bump();
|
|
value = ValueNode::ofBool(true);
|
|
} else if (check(TokenType::FALSE)) {
|
|
bump();
|
|
value = ValueNode::ofBool(false);
|
|
} else if (check(TokenType::NIL)) {
|
|
bump();
|
|
value = ValueNode::ofNull();
|
|
} else if(check(TokenType::COLOR)) {
|
|
value = ValueNode::ofColor(parseColor()->color);
|
|
} else {
|
|
return unexpected();
|
|
}
|
|
|
|
return spanner(value);
|
|
}
|
|
|
|
std::optional<SchemaNode> ComdelParser::parseSchema() {
|
|
auto spanner = getSpanner();
|
|
SchemaNode schema{};
|
|
|
|
if (check(TokenType::KW_SOURCE)) {
|
|
bump();
|
|
if (check(TokenType::STRING)) {
|
|
auto source = parseString();
|
|
schema.source = *source;
|
|
} else {
|
|
errors.emplace_back(current().span, "expected `@source`");
|
|
return std::nullopt;
|
|
}
|
|
} else {
|
|
errors.emplace_back(current().span, "expected `@source`");
|
|
return std::nullopt;
|
|
}
|
|
|
|
if (!check(TokenType::KW_SCHEMA)) {
|
|
errors.emplace_back(current().span, "expected `@schema`");
|
|
return std::nullopt;
|
|
}
|
|
bump();
|
|
if (!check(TokenType::LBRACE)) {
|
|
errors.emplace_back(current().span, "expected `{`");
|
|
return std::nullopt;
|
|
}
|
|
bump();
|
|
|
|
while (!check(TokenType::RBRACE)) {
|
|
PResult<poly<AstNode>> err;
|
|
if (check(TokenType::KW_INSTANCE)) {
|
|
APPEND_OR_SET_ERR(schema.instances, parseInstance());
|
|
} else if (check(TokenType::KW_CONNECTION)) {
|
|
APPEND_OR_SET_ERR(schema.connections, parseConnectionInstance());
|
|
} else {
|
|
err = unexpected();
|
|
bump();
|
|
}
|
|
if (!err.has_value()) {
|
|
errors.push_back(err.error());
|
|
skipUntilNextKeyword();
|
|
if (check(TokenType::END_OF_FILE)) {
|
|
errors.emplace_back(current().span, "expected `}` reached EOF");
|
|
return std::nullopt;
|
|
}
|
|
}
|
|
}
|
|
if (!check(TokenType::RBRACE)) {
|
|
errors.emplace_back(current().span, "expected `}`");
|
|
return std::nullopt;
|
|
} else {
|
|
bump();
|
|
}
|
|
|
|
if (!check(TokenType::END_OF_FILE)) {
|
|
errors.emplace_back(current().span, "expected `EOF`");
|
|
}
|
|
|
|
if (!errors.empty())
|
|
return std::nullopt;
|
|
|
|
return spanner(schema);
|
|
}
|
|
|
|
/****************************************************************************
|
|
*
|
|
* CountNode := "@position (" + NumberNode + "," + NumberNode + ")"
|
|
*
|
|
****************************************************************************/
|
|
PResult<CountNode> ComdelParser::parsePosition() {
|
|
auto spanner = getSpanner();
|
|
RETURN_IF_NOT_TOKEN(TokenType::KW_POSITION);
|
|
|
|
RETURN_IF_NOT_TOKEN(TokenType::LPAREN);
|
|
auto first = parseNumber();
|
|
if (!first.has_value()) {
|
|
return PError(first.error());
|
|
}
|
|
RETURN_IF_NOT_TOKEN(TokenType::COMMA);
|
|
auto second = parseNumber();
|
|
if (!second.has_value()) {
|
|
return PError(second.error());
|
|
}
|
|
RETURN_IF_NOT_TOKEN(TokenType::RPAREN);
|
|
|
|
return spanner(CountNode{first.value(), second.value()});
|
|
}
|
|
|
|
PResult<InstanceNode> ComdelParser::parseInstance() {
|
|
auto spanner = getSpanner();
|
|
RETURN_IF_NOT_TOKEN(TokenType::KW_INSTANCE);
|
|
|
|
InstanceNode instance;
|
|
|
|
ASSIGN_OR_RETURN_IF_ERR(instance.name, parseIdentifier());
|
|
ASSIGN_OR_RETURN_IF_ERR(instance.component, parseIdentifier());
|
|
|
|
RETURN_IF_NOT_TOKEN(TokenType::LBRACE);
|
|
|
|
while (!check(TokenType::RBRACE)) {
|
|
PResult<poly<AstNode>> err;
|
|
if (check(TokenType::KW_POSITION)) {
|
|
ASSIGN_OR_SET_ERR(instance.position, parsePosition());
|
|
} else if (check(TokenType::KW_ATTRIBUTE)) {
|
|
APPEND_OR_SET_ERR(instance.attributes, parseInstanceAttribute());
|
|
} else if (check(TokenType::KW_SIZE)) {
|
|
bump();
|
|
auto number = parseNumber();
|
|
RETURN_IF_ERR(number);
|
|
instance.size = *number;
|
|
} else {
|
|
err = unexpected();
|
|
bump();
|
|
}
|
|
if (!err.has_value()) {
|
|
errors.push_back(err.error());
|
|
skipUntilNextKeyword();
|
|
if (check(TokenType::END_OF_FILE)) {
|
|
return PError({Span(spanner.lo), "Reached EOF"});
|
|
}
|
|
}
|
|
}
|
|
|
|
RETURN_IF_NOT_TOKEN(TokenType::RBRACE);
|
|
|
|
return spanner(instance);
|
|
}
|
|
|
|
PResult<InstanceAttributeNode> ComdelParser::parseInstanceAttribute() {
|
|
auto spanner = getSpanner();
|
|
RETURN_IF_NOT_TOKEN(TokenType::KW_ATTRIBUTE);
|
|
InstanceAttributeNode attribute;
|
|
|
|
ASSIGN_OR_RETURN_IF_ERR(attribute.name, parseIdentifier());
|
|
ASSIGN_OR_RETURN_IF_ERR(attribute.value, parseValue());
|
|
|
|
return spanner(attribute);
|
|
}
|
|
|
|
PResult<ConnectionInstanceNode> ComdelParser::parseConnectionInstance() {
|
|
auto spanner = getSpanner();
|
|
RETURN_IF_NOT_TOKEN(TokenType::KW_CONNECTION);
|
|
|
|
ConnectionInstanceNode connection;
|
|
|
|
RETURN_IF_NOT_TOKEN(TokenType::LPAREN);
|
|
ASSIGN_OR_RETURN_IF_ERR(connection.first.instance, parseIdentifier());
|
|
RETURN_IF_NOT_TOKEN(TokenType::DOT);
|
|
ASSIGN_OR_RETURN_IF_ERR(connection.first.pin, parseIdentifier());
|
|
RETURN_IF_NOT_TOKEN(TokenType::COMMA);
|
|
ASSIGN_OR_RETURN_IF_ERR(connection.bus, parseIdentifier());
|
|
|
|
if (check(TokenType::COMMA)) {
|
|
bump();
|
|
ConnectionComponentInstance second;
|
|
ASSIGN_OR_RETURN_IF_ERR(second.instance, parseIdentifier());
|
|
RETURN_IF_NOT_TOKEN(TokenType::DOT);
|
|
ASSIGN_OR_RETURN_IF_ERR(second.pin, parseIdentifier());
|
|
connection.second = second;
|
|
}
|
|
|
|
RETURN_IF_NOT_TOKEN(TokenType::RPAREN);
|
|
|
|
RETURN_IF_NOT_TOKEN(TokenType::LBRACE);
|
|
|
|
while (!check(TokenType::RBRACE)) {
|
|
PResult<poly<AstNode>> err;
|
|
if (check(TokenType::KW_ATTRIBUTE)) {
|
|
APPEND_OR_SET_ERR(connection.attributes, parseInstanceAttribute());
|
|
} else {
|
|
err = unexpected();
|
|
bump();
|
|
}
|
|
if (!err.has_value()) {
|
|
errors.push_back(err.error());
|
|
skipUntilNextKeyword();
|
|
if (check(TokenType::END_OF_FILE)) {
|
|
return PError({Span(spanner.lo), "Reached EOF"});
|
|
}
|
|
}
|
|
}
|
|
|
|
RETURN_IF_NOT_TOKEN(TokenType::RBRACE);
|
|
|
|
return spanner(connection);
|
|
}
|
|
|
|
PResult<ValueNode> ComdelParser::parseConnectionWire() {
|
|
auto spanner = getSpanner();
|
|
if (check(TokenType::NUMBER)) {
|
|
return spanner(ValueNode::ofInt(parseNumber()->value));
|
|
} else if (check(TokenType::NIL)) {
|
|
bump();
|
|
return spanner(ValueNode::ofNull());
|
|
} else if (check(TokenType::STRING)) {
|
|
return spanner(ValueNode::ofString(parseString()->asString()));
|
|
} else if (check(TokenType::IDENTIFIER)) {
|
|
return spanner(ValueNode::ofIdentifier(parseIdentifier()->value));
|
|
} else {
|
|
return unexpected();
|
|
}
|
|
}
|
|
|