Implement comparison operators
This commit is contained in:
@ -204,7 +204,8 @@ namespace elna::source
|
||||
{
|
||||
return of() == type::identifier
|
||||
|| of() == type::term_operator
|
||||
|| of() == type::factor_operator;
|
||||
|| of() == type::factor_operator
|
||||
|| of() == type::comparison_operator;
|
||||
}
|
||||
|
||||
bool token::is_numeric() const noexcept
|
||||
@ -218,51 +219,53 @@ namespace elna::source
|
||||
switch (this->m_type)
|
||||
{
|
||||
case type::number:
|
||||
return "«number»";
|
||||
return "«number»";
|
||||
case type::boolean:
|
||||
return "«boolean»";
|
||||
return "«boolean»";
|
||||
case type::term_operator:
|
||||
return "«term_operator»";
|
||||
return "«term_operator»";
|
||||
case type::let:
|
||||
return "«const»";
|
||||
return "«const»";
|
||||
case type::identifier:
|
||||
return "«identifier»";
|
||||
return "«identifier»";
|
||||
case type::equals:
|
||||
return "«=»";
|
||||
return "«=»";
|
||||
case type::var:
|
||||
return "«var»";
|
||||
return "«var»";
|
||||
case type::semicolon:
|
||||
return "«;»";
|
||||
return "«;»";
|
||||
case type::left_paren:
|
||||
return "«(»";
|
||||
return "«(»";
|
||||
case type::right_paren:
|
||||
return "«)»";
|
||||
return "«)»";
|
||||
case type::dot:
|
||||
return "«)»";
|
||||
return "«)»";
|
||||
case type::comma:
|
||||
return "«,»";
|
||||
return "«,»";
|
||||
case type::factor_operator:
|
||||
return "«*»";
|
||||
return "«*»";
|
||||
case type::eof:
|
||||
return "«EOF»";
|
||||
return "«EOF»";
|
||||
case type::begin:
|
||||
return "«begin»";
|
||||
return "«begin»";
|
||||
case type::end:
|
||||
return "«end»";
|
||||
return "«end»";
|
||||
case type::assignment:
|
||||
return "«:=»";
|
||||
return "«:=»";
|
||||
case type::colon:
|
||||
return "«:»";
|
||||
return "«:»";
|
||||
case type::when:
|
||||
return "«if»";
|
||||
return "«if»";
|
||||
case type::then:
|
||||
return "«then»";
|
||||
case type::_while:
|
||||
return "«while»";
|
||||
return "«then»";
|
||||
case type::loop:
|
||||
return "«while»";
|
||||
case type::_do:
|
||||
return "«do»";
|
||||
return "«do»";
|
||||
case type::procedure:
|
||||
return "«proc»";
|
||||
return "«proc»";
|
||||
case type::comparison_operator:
|
||||
return "«comparison_operator»";
|
||||
};
|
||||
assert(false);
|
||||
}
|
||||
@ -446,7 +449,7 @@ namespace elna::source
|
||||
}
|
||||
else if (word == "while")
|
||||
{
|
||||
tokens.emplace_back(token::type::_while, iterator.position());
|
||||
tokens.emplace_back(token::type::loop, iterator.position());
|
||||
}
|
||||
else if (word == "do")
|
||||
{
|
||||
@ -477,12 +480,49 @@ namespace elna::source
|
||||
|
||||
tokens.emplace_back(token::type::term_operator, _operator.c_str(), iterator.position());
|
||||
}
|
||||
else if (*iterator == '/' && iterator + 1 != text_end && *(iterator + 1) == '=')
|
||||
{
|
||||
tokens.emplace_back(token::type::comparison_operator, "n", iterator.position());
|
||||
++iterator;
|
||||
}
|
||||
else if (*iterator == '*' || *iterator == '/')
|
||||
{
|
||||
std::string _operator{ *iterator };
|
||||
|
||||
tokens.emplace_back(token::type::factor_operator, _operator.c_str(), iterator.position());
|
||||
}
|
||||
else if (*iterator == '<')
|
||||
{
|
||||
std::string _operator;
|
||||
auto operator_position = iterator.position();
|
||||
|
||||
if (iterator + 1 == text_end || *(iterator + 1) != '=')
|
||||
{
|
||||
_operator.push_back(*iterator);
|
||||
}
|
||||
else
|
||||
{
|
||||
++iterator;
|
||||
_operator.push_back('l');
|
||||
}
|
||||
tokens.emplace_back(token::type::comparison_operator, _operator.c_str(), operator_position);
|
||||
}
|
||||
else if (*iterator == '>')
|
||||
{
|
||||
std::string _operator;
|
||||
auto operator_position = iterator.position();
|
||||
|
||||
if (iterator + 1 == text_end || *(iterator + 1) != '=')
|
||||
{
|
||||
_operator.push_back(*iterator);
|
||||
}
|
||||
else
|
||||
{
|
||||
++iterator;
|
||||
_operator.push_back('g');
|
||||
}
|
||||
tokens.emplace_back(token::type::comparison_operator, _operator.c_str(), operator_position);
|
||||
}
|
||||
else if (*iterator == ':' && iterator + 1 != text_end && *(iterator + 1) == '=')
|
||||
{
|
||||
tokens.emplace_back(token::type::assignment, iterator.position());
|
||||
|
||||
@ -262,6 +262,24 @@ namespace elna::source
|
||||
case '/':
|
||||
this->m_operator = binary_operator::division;
|
||||
break;
|
||||
case '=':
|
||||
this->m_operator = binary_operator::equals;
|
||||
break;
|
||||
case 'n':
|
||||
this->m_operator = binary_operator::not_equals;
|
||||
break;
|
||||
case '<':
|
||||
this->m_operator = binary_operator::less;
|
||||
break;
|
||||
case 'l':
|
||||
this->m_operator = binary_operator::less_equal;
|
||||
break;
|
||||
case '>':
|
||||
this->m_operator = binary_operator::greater;
|
||||
break;
|
||||
case 'g':
|
||||
this->m_operator = binary_operator::greater_equal;
|
||||
break;
|
||||
default:
|
||||
throw std::logic_error("Invalid binary operator");
|
||||
}
|
||||
@ -442,7 +460,7 @@ namespace elna::source
|
||||
{
|
||||
++iterator;
|
||||
|
||||
auto expression = parse_expression();
|
||||
auto expression = parse_condition();
|
||||
|
||||
++iterator;
|
||||
|
||||
@ -489,6 +507,38 @@ namespace elna::source
|
||||
return term;
|
||||
}
|
||||
|
||||
std::unique_ptr<expression> parser::parse_condition()
|
||||
{
|
||||
std::unique_ptr<expression> lhs;
|
||||
|
||||
if ((lhs = parse_expression()) == nullptr)
|
||||
{
|
||||
return lhs;
|
||||
}
|
||||
unsigned char _operator{ 0 };
|
||||
|
||||
if (iterator.current().of() == source::token::type::equals)
|
||||
{
|
||||
_operator = '=';
|
||||
}
|
||||
else if (iterator.current().of() == source::token::type::comparison_operator)
|
||||
{
|
||||
_operator = iterator->identifier()[0];
|
||||
}
|
||||
else
|
||||
{
|
||||
return lhs;
|
||||
}
|
||||
++iterator;
|
||||
auto rhs = parse_expression();
|
||||
|
||||
if (rhs == nullptr)
|
||||
{
|
||||
return nullptr;
|
||||
}
|
||||
return std::make_unique<binary_expression>(std::move(lhs), std::move(rhs), _operator);
|
||||
}
|
||||
|
||||
std::unique_ptr<constant_definition> parser::parse_constant_definition()
|
||||
{
|
||||
auto definition_identifier = iterator.advance(token::type::identifier);
|
||||
@ -595,7 +645,7 @@ namespace elna::source
|
||||
{
|
||||
return parse_if_statement();
|
||||
}
|
||||
else if (iterator.current(token::type::_while))
|
||||
else if (iterator.current(token::type::loop))
|
||||
{
|
||||
return parse_while_statement();
|
||||
}
|
||||
@ -618,7 +668,7 @@ namespace elna::source
|
||||
++iterator;
|
||||
return call;
|
||||
}
|
||||
while ((argument_expression = parse_expression()) != nullptr)
|
||||
while ((argument_expression = parse_condition()) != nullptr)
|
||||
{
|
||||
call->arguments().push_back(std::move(argument_expression));
|
||||
|
||||
@ -674,7 +724,7 @@ namespace elna::source
|
||||
{
|
||||
return nullptr;
|
||||
}
|
||||
auto rvalue = parse_expression();
|
||||
auto rvalue = parse_condition();
|
||||
|
||||
if (rvalue == nullptr)
|
||||
{
|
||||
@ -689,7 +739,7 @@ namespace elna::source
|
||||
{
|
||||
return nullptr;
|
||||
}
|
||||
auto condition = parse_expression();
|
||||
auto condition = parse_condition();
|
||||
|
||||
if (condition == nullptr || !iterator.skip(token::type::then))
|
||||
{
|
||||
@ -706,11 +756,11 @@ namespace elna::source
|
||||
|
||||
std::unique_ptr<while_statement> parser::parse_while_statement()
|
||||
{
|
||||
if (!iterator.skip(token::type::_while))
|
||||
if (!iterator.skip(token::type::loop))
|
||||
{
|
||||
return nullptr;
|
||||
}
|
||||
auto condition = parse_expression();
|
||||
auto condition = parse_condition();
|
||||
|
||||
if (condition == nullptr || !iterator.skip(token::type::_do))
|
||||
{
|
||||
|
||||
Reference in New Issue
Block a user