2377 lines
78 KiB
C++
2377 lines
78 KiB
C++
// This file is distributed under the BSD License.
|
|
// See "license.txt" for details.
|
|
// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
|
|
// Copyright 2009-2016, Jason Turner (jason@emptycrate.com)
|
|
// http://www.chaiscript.com
|
|
|
|
#ifndef CHAISCRIPT_PARSER_HPP_
|
|
#define CHAISCRIPT_PARSER_HPP_
|
|
|
|
#include <exception>
|
|
#include <iostream>
|
|
#include <memory>
|
|
#include <sstream>
|
|
#include <string>
|
|
#include <vector>
|
|
#include <cctype>
|
|
#include <cstring>
|
|
|
|
|
|
|
|
#include "../dispatchkit/boxed_value.hpp"
|
|
#include "chaiscript_common.hpp"
|
|
|
|
|
|
#if defined(CHAISCRIPT_MSVC) && defined(max) && defined(min)
|
|
#define CHAISCRIPT_PUSHED_MIN_MAX
|
|
#pragma push_macro("max") // Why Microsoft? why? This is worse than bad
|
|
#undef max
|
|
#pragma push_macro("min")
|
|
#undef min
|
|
#endif
|
|
|
|
|
|
namespace chaiscript
|
|
{
|
|
/// \brief Classes and functions used during the parsing process.
|
|
namespace parser
|
|
{
|
|
/// \brief Classes and functions internal to the parsing process. Not supported for the end user.
|
|
namespace detail
|
|
{
|
|
enum Alphabet
|
|
{ symbol_alphabet = 0
|
|
, keyword_alphabet
|
|
, int_alphabet
|
|
, float_alphabet
|
|
, x_alphabet
|
|
, hex_alphabet
|
|
, b_alphabet
|
|
, bin_alphabet
|
|
, id_alphabet
|
|
, white_alphabet
|
|
, int_suffix_alphabet
|
|
, float_suffix_alphabet
|
|
, max_alphabet
|
|
, lengthof_alphabet = 256
|
|
};
|
|
}
|
|
|
|
class ChaiScript_Parser {
|
|
|
|
static std::array<std::array<bool, detail::lengthof_alphabet>, detail::max_alphabet> build_alphabet()
|
|
{
|
|
std::array<std::array<bool, detail::lengthof_alphabet>, detail::max_alphabet> alphabet;
|
|
|
|
for (auto &alpha : alphabet) {
|
|
alpha.fill(false);
|
|
}
|
|
|
|
alphabet[detail::symbol_alphabet][static_cast<size_t>('?')]=true;
|
|
alphabet[detail::symbol_alphabet][static_cast<size_t>('+')]=true;
|
|
alphabet[detail::symbol_alphabet][static_cast<size_t>('-')]=true;
|
|
alphabet[detail::symbol_alphabet][static_cast<size_t>('*')]=true;
|
|
alphabet[detail::symbol_alphabet][static_cast<size_t>('/')]=true;
|
|
alphabet[detail::symbol_alphabet][static_cast<size_t>('|')]=true;
|
|
alphabet[detail::symbol_alphabet][static_cast<size_t>('&')]=true;
|
|
alphabet[detail::symbol_alphabet][static_cast<size_t>('^')]=true;
|
|
alphabet[detail::symbol_alphabet][static_cast<size_t>('=')]=true;
|
|
alphabet[detail::symbol_alphabet][static_cast<size_t>('.')]=true;
|
|
alphabet[detail::symbol_alphabet][static_cast<size_t>('<')]=true;
|
|
alphabet[detail::symbol_alphabet][static_cast<size_t>('>')]=true;
|
|
|
|
for ( size_t c = 'a' ; c <= 'z' ; ++c ) { alphabet[detail::keyword_alphabet][c]=true; }
|
|
for ( size_t c = 'A' ; c <= 'Z' ; ++c ) { alphabet[detail::keyword_alphabet][c]=true; }
|
|
for ( size_t c = '0' ; c <= '9' ; ++c ) { alphabet[detail::keyword_alphabet][c]=true; }
|
|
alphabet[detail::keyword_alphabet][static_cast<size_t>('_')]=true;
|
|
|
|
for ( size_t c = '0' ; c <= '9' ; ++c ) { alphabet[detail::int_alphabet][c]=true; }
|
|
for ( size_t c = '0' ; c <= '9' ; ++c ) { alphabet[detail::float_alphabet][c]=true; }
|
|
alphabet[detail::float_alphabet][static_cast<size_t>('.')]=true;
|
|
|
|
for ( size_t c = '0' ; c <= '9' ; ++c ) { alphabet[detail::hex_alphabet][c]=true; }
|
|
for ( size_t c = 'a' ; c <= 'f' ; ++c ) { alphabet[detail::hex_alphabet][c]=true; }
|
|
for ( size_t c = 'A' ; c <= 'F' ; ++c ) { alphabet[detail::hex_alphabet][c]=true; }
|
|
|
|
alphabet[detail::x_alphabet][static_cast<size_t>('x')]=true;
|
|
alphabet[detail::x_alphabet][static_cast<size_t>('X')]=true;
|
|
|
|
for ( size_t c = '0' ; c <= '1' ; ++c ) { alphabet[detail::bin_alphabet][c]=true; }
|
|
alphabet[detail::b_alphabet][static_cast<size_t>('b')]=true;
|
|
alphabet[detail::b_alphabet][static_cast<size_t>('B')]=true;
|
|
|
|
for ( size_t c = 'a' ; c <= 'z' ; ++c ) { alphabet[detail::id_alphabet][c]=true; }
|
|
for ( size_t c = 'A' ; c <= 'Z' ; ++c ) { alphabet[detail::id_alphabet][c]=true; }
|
|
alphabet[detail::id_alphabet][static_cast<size_t>('_')] = true;
|
|
|
|
alphabet[detail::white_alphabet][static_cast<size_t>(' ')]=true;
|
|
alphabet[detail::white_alphabet][static_cast<size_t>('\t')]=true;
|
|
|
|
alphabet[detail::int_suffix_alphabet][static_cast<size_t>('l')] = true;
|
|
alphabet[detail::int_suffix_alphabet][static_cast<size_t>('L')] = true;
|
|
alphabet[detail::int_suffix_alphabet][static_cast<size_t>('u')] = true;
|
|
alphabet[detail::int_suffix_alphabet][static_cast<size_t>('U')] = true;
|
|
|
|
alphabet[detail::float_suffix_alphabet][static_cast<size_t>('l')] = true;
|
|
alphabet[detail::float_suffix_alphabet][static_cast<size_t>('L')] = true;
|
|
alphabet[detail::float_suffix_alphabet][static_cast<size_t>('f')] = true;
|
|
alphabet[detail::float_suffix_alphabet][static_cast<size_t>('F')] = true;
|
|
|
|
return alphabet;
|
|
}
|
|
|
|
static const std::array<std::array<bool, detail::lengthof_alphabet>, detail::max_alphabet> &create_alphabet()
|
|
{
|
|
static const auto alpha = build_alphabet();
|
|
return alpha;
|
|
}
|
|
|
|
|
|
static const std::vector<std::vector<std::string>> &create_operator_matches() {
|
|
static const std::vector<std::vector<std::string>> operator_matches {
|
|
{"?"},
|
|
{"||"},
|
|
{"&&"},
|
|
{"|"},
|
|
{"^"},
|
|
{"&"},
|
|
{"==", "!="},
|
|
{"<", "<=", ">", ">="},
|
|
{"<<", ">>"},
|
|
//We share precedence here but then separate them later
|
|
{"+", "-"},
|
|
{"*", "/", "%"}
|
|
};
|
|
|
|
return operator_matches;
|
|
}
|
|
|
|
|
|
static const std::array<Operator_Precidence, 11> &create_operators() {
|
|
static const std::array<Operator_Precidence, 11> operators = { {
|
|
Operator_Precidence::Ternary_Cond,
|
|
Operator_Precidence::Logical_Or,
|
|
Operator_Precidence::Logical_And,
|
|
Operator_Precidence::Bitwise_Or,
|
|
Operator_Precidence::Bitwise_Xor,
|
|
Operator_Precidence::Bitwise_And,
|
|
Operator_Precidence::Equality,
|
|
Operator_Precidence::Comparison,
|
|
Operator_Precidence::Shift,
|
|
Operator_Precidence::Addition,
|
|
Operator_Precidence::Multiplication
|
|
} };
|
|
return operators;
|
|
}
|
|
|
|
static constexpr const char * const m_multiline_comment_begin = "/*";
|
|
static constexpr const char * const m_multiline_comment_end = "*/";
|
|
static constexpr const char * const m_singleline_comment = "//";
|
|
static constexpr const char * const m_annotation = "#";
|
|
|
|
const std::array<std::array<bool, detail::lengthof_alphabet>, detail::max_alphabet> &m_alphabet = create_alphabet();
|
|
const std::vector<std::vector<std::string>> &m_operator_matches = create_operator_matches();
|
|
const std::array<Operator_Precidence, 11> &m_operators = create_operators();
|
|
|
|
std::shared_ptr<std::string> m_filename;
|
|
std::vector<AST_NodePtr> m_match_stack;
|
|
|
|
|
|
struct Position
|
|
{
|
|
Position() = default;
|
|
|
|
Position(std::string::const_iterator t_pos, std::string::const_iterator t_end)
|
|
: line(1), col(1), m_pos(std::move(t_pos)), m_end(std::move(t_end)), m_last_col(1)
|
|
{
|
|
}
|
|
|
|
static std::string str(const Position &t_begin, const Position &t_end) {
|
|
return std::string(t_begin.m_pos, t_end.m_pos);
|
|
}
|
|
|
|
Position &operator++() {
|
|
if (m_pos != m_end) {
|
|
if (*m_pos == '\n') {
|
|
++line;
|
|
m_last_col = col;
|
|
col = 1;
|
|
} else {
|
|
++col;
|
|
}
|
|
|
|
++m_pos;
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
Position &operator--() {
|
|
--m_pos;
|
|
if (*m_pos == '\n') {
|
|
--line;
|
|
col = m_last_col;
|
|
} else {
|
|
--col;
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
Position &operator+=(size_t t_distance) {
|
|
*this = (*this) + t_distance;
|
|
return *this;
|
|
}
|
|
|
|
Position operator+(size_t t_distance) const {
|
|
Position ret(*this);
|
|
for (size_t i = 0; i < t_distance; ++i) {
|
|
++ret;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
Position &operator-=(size_t t_distance) {
|
|
*this = (*this) - t_distance;
|
|
return *this;
|
|
}
|
|
|
|
Position operator-(size_t t_distance) const {
|
|
Position ret(*this);
|
|
for (size_t i = 0; i < t_distance; ++i) {
|
|
--ret;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
bool operator==(const Position &t_rhs) const {
|
|
return m_pos == t_rhs.m_pos;
|
|
}
|
|
|
|
bool operator!=(const Position &t_rhs) const {
|
|
return m_pos != t_rhs.m_pos;
|
|
}
|
|
|
|
bool has_more() const {
|
|
return m_pos != m_end;
|
|
}
|
|
|
|
size_t remaining() const {
|
|
return static_cast<size_t>(std::distance(m_pos, m_end));
|
|
}
|
|
|
|
char operator*() const {
|
|
if (m_pos == m_end) {
|
|
return '\0';
|
|
} else {
|
|
return *m_pos;
|
|
}
|
|
}
|
|
|
|
int line = -1;
|
|
int col = -1;
|
|
|
|
private:
|
|
std::string::const_iterator m_pos;
|
|
std::string::const_iterator m_end;
|
|
int m_last_col = -1;
|
|
};
|
|
|
|
Position m_position;
|
|
|
|
public:
|
|
ChaiScript_Parser()
|
|
{
|
|
m_match_stack.reserve(2);
|
|
}
|
|
|
|
ChaiScript_Parser(const ChaiScript_Parser &) = delete;
|
|
ChaiScript_Parser &operator=(const ChaiScript_Parser &) = delete;
|
|
|
|
|
|
/// test a char in an m_alphabet
|
|
bool char_in_alphabet(char c, detail::Alphabet a) const { return m_alphabet[a][static_cast<uint8_t>(c)]; }
|
|
|
|
/// Prints the parsed ast_nodes as a tree
|
|
void debug_print(AST_NodePtr t, std::string prepend = "") const {
|
|
std::cout << prepend << "(" << ast_node_type_to_string(t->identifier) << ") " << t->text << " : " << t->start().line << ", " << t->start().column << '\n';
|
|
for (unsigned int j = 0; j < t->children.size(); ++j) {
|
|
debug_print(t->children[j], prepend + " ");
|
|
}
|
|
}
|
|
|
|
/// Returns the front-most AST node
|
|
AST_NodePtr ast() const {
|
|
if (m_match_stack.empty()) throw exception::eval_error("Attempted to access AST of failed parse.");
|
|
return m_match_stack.front();
|
|
}
|
|
|
|
|
|
static void optimize_returns(AST_NodePtr &p)
|
|
{
|
|
for (auto &c : p->children)
|
|
{
|
|
if (c->identifier == AST_Node_Type::Def && c->children.size() > 0) {
|
|
auto &last_child = c->children.back();
|
|
if (last_child->identifier == AST_Node_Type::Block) {
|
|
auto &block_last_child = last_child->children.back();
|
|
if (block_last_child->identifier == AST_Node_Type::Return) {
|
|
if (block_last_child->children.size() == 1) {
|
|
block_last_child = block_last_child->children[0];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
optimize_returns(c);
|
|
}
|
|
}
|
|
|
|
|
|
AST_NodePtr optimized_ast(bool t_optimize_returns = true) {
|
|
AST_NodePtr p = ast();
|
|
if (t_optimize_returns) { optimize_returns(p); }
|
|
return p;
|
|
}
|
|
|
|
|
|
/// Helper function that collects ast_nodes from a starting position to the top of the stack into a new AST node
|
|
template<typename NodeType>
|
|
void build_match(size_t t_match_start, std::string t_text = "") {
|
|
bool is_deep = false;
|
|
|
|
Parse_Location filepos = [&]()->Parse_Location{
|
|
//so we want to take everything to the right of this and make them children
|
|
if (t_match_start != m_match_stack.size()) {
|
|
is_deep = true;
|
|
return Parse_Location(
|
|
m_filename,
|
|
m_match_stack[t_match_start]->location.start.line,
|
|
m_match_stack[t_match_start]->location.start.column,
|
|
m_position.line,
|
|
m_position.col
|
|
);
|
|
} else {
|
|
return Parse_Location(
|
|
m_filename,
|
|
m_position.line,
|
|
m_position.col,
|
|
m_position.line,
|
|
m_position.col
|
|
);
|
|
}
|
|
}();
|
|
|
|
std::vector<AST_NodePtr> new_children;
|
|
|
|
if (is_deep) {
|
|
new_children.assign(std::make_move_iterator(m_match_stack.begin() + static_cast<int>(t_match_start)),
|
|
std::make_move_iterator(m_match_stack.end()));
|
|
m_match_stack.erase(m_match_stack.begin() + static_cast<int>(t_match_start), m_match_stack.end());
|
|
}
|
|
|
|
/// \todo fix the fact that a successful match that captured no ast_nodes doesn't have any real start position
|
|
m_match_stack.push_back(
|
|
chaiscript::make_shared<chaiscript::AST_Node, NodeType>(
|
|
std::move(t_text),
|
|
std::move(filepos),
|
|
std::move(new_children)));
|
|
}
|
|
|
|
|
|
/// Skips any multi-line or single-line comment
|
|
bool SkipComment() {
|
|
if (Symbol_(m_multiline_comment_begin)) {
|
|
while (m_position.has_more()) {
|
|
if (Symbol_(m_multiline_comment_end)) {
|
|
break;
|
|
} else if (!Eol_()) {
|
|
++m_position;
|
|
}
|
|
}
|
|
return true;
|
|
} else if (Symbol_(m_singleline_comment)) {
|
|
while (m_position.has_more()) {
|
|
if (Symbol_("\r\n")) {
|
|
m_position -= 2;
|
|
break;
|
|
} else if (Char_('\n')) {
|
|
--m_position;
|
|
break;
|
|
} else {
|
|
++m_position;
|
|
}
|
|
}
|
|
return true;
|
|
} else if (Symbol_(m_annotation)) {
|
|
while (m_position.has_more()) {
|
|
if (Symbol_("\r\n")) {
|
|
m_position -= 2;
|
|
break;
|
|
} else if (Char_('\n')) {
|
|
--m_position;
|
|
break;
|
|
} else {
|
|
++m_position;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
/// Skips ChaiScript whitespace, which means space and tab, but not cr/lf
|
|
/// jespada: Modified SkipWS to skip optionally CR ('\n') and/or LF+CR ("\r\n")
|
|
bool SkipWS(bool skip_cr=false) {
|
|
bool retval = false;
|
|
|
|
while (m_position.has_more()) {
|
|
auto end_line = (*m_position != 0) && ((*m_position == '\n') || (*m_position == '\r' && *(m_position+1) == '\n'));
|
|
|
|
if ( char_in_alphabet(*m_position,detail::white_alphabet) || (skip_cr && end_line)) {
|
|
|
|
if(end_line) {
|
|
if(*m_position == '\r') {
|
|
// discards lf
|
|
++m_position;
|
|
}
|
|
}
|
|
|
|
++m_position;
|
|
|
|
retval = true;
|
|
}
|
|
else if (SkipComment()) {
|
|
retval = true;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
return retval;
|
|
}
|
|
|
|
/// Reads the optional exponent (scientific notation) and suffix for a Float
|
|
bool read_exponent_and_suffix() {
|
|
// Support a form of scientific notation: 1e-5, 35.5E+8, 0.01e19
|
|
if (m_position.has_more() && (std::tolower(*m_position) == 'e')) {
|
|
++m_position;
|
|
if (m_position.has_more() && ((*m_position == '-') || (*m_position == '+'))) {
|
|
++m_position;
|
|
}
|
|
auto exponent_pos = m_position;
|
|
while (m_position.has_more() && char_in_alphabet(*m_position,detail::int_alphabet) ) {
|
|
++m_position;
|
|
}
|
|
if (m_position == exponent_pos) {
|
|
// Require at least one digit after the exponent
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Parse optional float suffix
|
|
while (m_position.has_more() && char_in_alphabet(*m_position, detail::float_suffix_alphabet))
|
|
{
|
|
++m_position;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
/// Reads a floating point value from input, without skipping initial whitespace
|
|
bool Float_() {
|
|
if (m_position.has_more() && char_in_alphabet(*m_position,detail::float_alphabet) ) {
|
|
while (m_position.has_more() && char_in_alphabet(*m_position,detail::int_alphabet) ) {
|
|
++m_position;
|
|
}
|
|
|
|
if (m_position.has_more() && (std::tolower(*m_position) == 'e')) {
|
|
// The exponent is valid even without any decimal in the Float (1e8, 3e-15)
|
|
return read_exponent_and_suffix();
|
|
}
|
|
else if (m_position.has_more() && (*m_position == '.')) {
|
|
++m_position;
|
|
if (m_position.has_more() && char_in_alphabet(*m_position,detail::int_alphabet)) {
|
|
while (m_position.has_more() && char_in_alphabet(*m_position,detail::int_alphabet) ) {
|
|
++m_position;
|
|
}
|
|
|
|
// After any decimal digits, support an optional exponent (3.7e3)
|
|
return read_exponent_and_suffix();
|
|
} else {
|
|
--m_position;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/// Reads a hex value from input, without skipping initial whitespace
|
|
bool Hex_() {
|
|
if (m_position.has_more() && (*m_position == '0')) {
|
|
++m_position;
|
|
|
|
if (m_position.has_more() && char_in_alphabet(*m_position, detail::x_alphabet) ) {
|
|
++m_position;
|
|
if (m_position.has_more() && char_in_alphabet(*m_position, detail::hex_alphabet)) {
|
|
while (m_position.has_more() && char_in_alphabet(*m_position, detail::hex_alphabet) ) {
|
|
++m_position;
|
|
}
|
|
while (m_position.has_more() && char_in_alphabet(*m_position, detail::int_suffix_alphabet))
|
|
{
|
|
++m_position;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
else {
|
|
--m_position;
|
|
}
|
|
}
|
|
else {
|
|
--m_position;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/// Reads an integer suffix
|
|
void IntSuffix_() {
|
|
while (m_position.has_more() && char_in_alphabet(*m_position, detail::int_suffix_alphabet))
|
|
{
|
|
++m_position;
|
|
}
|
|
}
|
|
|
|
/// Reads a binary value from input, without skipping initial whitespace
|
|
bool Binary_() {
|
|
if (m_position.has_more() && (*m_position == '0')) {
|
|
++m_position;
|
|
|
|
if (m_position.has_more() && char_in_alphabet(*m_position, detail::b_alphabet) ) {
|
|
++m_position;
|
|
if (m_position.has_more() && char_in_alphabet(*m_position, detail::bin_alphabet) ) {
|
|
while (m_position.has_more() && char_in_alphabet(*m_position, detail::bin_alphabet) ) {
|
|
++m_position;
|
|
}
|
|
return true;
|
|
} else {
|
|
--m_position;
|
|
}
|
|
} else {
|
|
--m_position;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/// Parses a floating point value and returns a Boxed_Value representation of it
|
|
static Boxed_Value buildFloat(const std::string &t_val)
|
|
{
|
|
bool float_ = false;
|
|
bool long_ = false;
|
|
|
|
auto i = t_val.size();
|
|
|
|
for (; i > 0; --i)
|
|
{
|
|
char val = t_val[i-1];
|
|
|
|
if (val == 'f' || val == 'F')
|
|
{
|
|
float_ = true;
|
|
} else if (val == 'l' || val == 'L') {
|
|
long_ = true;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (float_)
|
|
{
|
|
return const_var(parse_num<float>(t_val.substr(0,i)));
|
|
} else if (long_) {
|
|
return const_var(parse_num<long double>(t_val.substr(0,i)));
|
|
} else {
|
|
return const_var(parse_num<double>(t_val.substr(0,i)));
|
|
}
|
|
}
|
|
|
|
|
|
|
|
static Boxed_Value buildInt(const int base, const std::string &t_val, const bool prefixed)
|
|
{
|
|
bool unsigned_ = false;
|
|
bool long_ = false;
|
|
bool longlong_ = false;
|
|
|
|
auto i = t_val.size();
|
|
|
|
for (; i > 0; --i)
|
|
{
|
|
const char val = t_val[i-1];
|
|
|
|
if (val == 'u' || val == 'U')
|
|
{
|
|
unsigned_ = true;
|
|
} else if (val == 'l' || val == 'L') {
|
|
if (long_)
|
|
{
|
|
longlong_ = true;
|
|
}
|
|
|
|
long_ = true;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
const auto val = prefixed?std::string(t_val.begin()+2,t_val.end()):t_val;
|
|
|
|
#ifdef __GNUC__
|
|
#pragma GCC diagnostic push
|
|
#pragma GCC diagnostic ignored "-Wsign-compare"
|
|
|
|
#ifdef CHAISCRIPT_CLANG
|
|
#pragma GCC diagnostic ignored "-Wtautological-compare"
|
|
#endif
|
|
|
|
#endif
|
|
|
|
try {
|
|
auto u = std::stoll(val,nullptr,base);
|
|
|
|
|
|
if (!unsigned_ && !long_ && u >= std::numeric_limits<int>::min() && u <= std::numeric_limits<int>::max()) {
|
|
return const_var(static_cast<int>(u));
|
|
} else if ((unsigned_ || base != 10) && !long_ && u >= std::numeric_limits<unsigned int>::min() && u <= std::numeric_limits<unsigned int>::max()) {
|
|
return const_var(static_cast<unsigned int>(u));
|
|
} else if (!unsigned_ && !longlong_ && u >= std::numeric_limits<long>::min() && u <= std::numeric_limits<long>::max()) {
|
|
return const_var(static_cast<long>(u));
|
|
} else if ((unsigned_ || base != 10) && !longlong_ && u >= std::numeric_limits<unsigned long>::min() && u <= std::numeric_limits<unsigned long>::max()) {
|
|
return const_var(static_cast<unsigned long>(u));
|
|
} else if (!unsigned_ && u >= std::numeric_limits<long long>::min() && u <= std::numeric_limits<long long>::max()) {
|
|
return const_var(static_cast<long long>(u));
|
|
} else {
|
|
return const_var(static_cast<unsigned long long>(u));
|
|
}
|
|
|
|
} catch (const std::out_of_range &) {
|
|
// too big to be signed
|
|
try {
|
|
auto u = std::stoull(val,nullptr,base);
|
|
|
|
if (u >= std::numeric_limits<unsigned long>::min() && u <= std::numeric_limits<unsigned long>::max()) {
|
|
return const_var(static_cast<unsigned long>(u));
|
|
} else {
|
|
return const_var(static_cast<unsigned long long>(u));
|
|
}
|
|
} catch (const std::out_of_range &) {
|
|
// it's just simply too big
|
|
return const_var(std::numeric_limits<long long>::max());
|
|
}
|
|
}
|
|
|
|
#ifdef __GNUC__
|
|
#pragma GCC diagnostic pop
|
|
#endif
|
|
|
|
}
|
|
|
|
template<typename T, typename ... Param>
|
|
std::shared_ptr<AST_Node> make_node(std::string t_match, const int t_prev_line, const int t_prev_col, Param && ...param)
|
|
{
|
|
return chaiscript::make_shared<AST_Node, T>(std::move(t_match), Parse_Location(m_filename, t_prev_line, t_prev_col, m_position.line, m_position.col), std::forward<Param>(param)...);
|
|
}
|
|
|
|
/// Reads a number from the input, detecting if it's an integer or floating point
|
|
bool Num(const bool t_capture = false) {
|
|
SkipWS();
|
|
|
|
if (!t_capture) {
|
|
return Hex_() || Float_();
|
|
} else {
|
|
const auto start = m_position;
|
|
if (m_position.has_more() && char_in_alphabet(*m_position, detail::float_alphabet) ) {
|
|
try {
|
|
if (Hex_()) {
|
|
auto match = Position::str(start, m_position);
|
|
auto bv = buildInt(16, match, true);
|
|
m_match_stack.emplace_back(make_node<eval::Constant_AST_Node>(std::move(match), start.line, start.col, std::move(bv)));
|
|
return true;
|
|
}
|
|
|
|
if (Binary_()) {
|
|
auto match = Position::str(start, m_position);
|
|
auto bv = buildInt(2, match, true);
|
|
m_match_stack.push_back(make_node<eval::Constant_AST_Node>(std::move(match), start.line, start.col, std::move(bv)));
|
|
return true;
|
|
}
|
|
if (Float_()) {
|
|
auto match = Position::str(start, m_position);
|
|
auto bv = buildFloat(match);
|
|
m_match_stack.push_back(make_node<eval::Constant_AST_Node>(std::move(match), start.line, start.col, std::move(bv)));
|
|
return true;
|
|
}
|
|
else {
|
|
IntSuffix_();
|
|
auto match = Position::str(start, m_position);
|
|
if (!match.empty() && (match[0] == '0')) {
|
|
auto bv = buildInt(8, match, false);
|
|
m_match_stack.push_back(make_node<eval::Constant_AST_Node>(std::move(match), start.line, start.col, std::move(bv)));
|
|
}
|
|
else if (!match.empty()) {
|
|
auto bv = buildInt(10, match, false);
|
|
m_match_stack.push_back(make_node<eval::Constant_AST_Node>(std::move(match), start.line, start.col, std::move(bv)));
|
|
} else {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
} catch (const std::invalid_argument &) {
|
|
// error parsing number passed in to buildFloat/buildInt
|
|
return false;
|
|
}
|
|
}
|
|
else {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Reads an identifier from input which conforms to C's identifier naming conventions, without skipping initial whitespace
|
|
bool Id_() {
|
|
if (m_position.has_more() && char_in_alphabet(*m_position, detail::id_alphabet)) {
|
|
while (m_position.has_more() && char_in_alphabet(*m_position, detail::keyword_alphabet) ) {
|
|
++m_position;
|
|
}
|
|
|
|
return true;
|
|
} else if (m_position.has_more() && (*m_position == '`')) {
|
|
++m_position;
|
|
const auto start = m_position;
|
|
|
|
while (m_position.has_more() && (*m_position != '`')) {
|
|
if (Eol()) {
|
|
throw exception::eval_error("Carriage return in identifier literal", File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
else {
|
|
++m_position;
|
|
}
|
|
}
|
|
|
|
if (start == m_position) {
|
|
throw exception::eval_error("Missing contents of identifier literal", File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
else if (!m_position.has_more()) {
|
|
throw exception::eval_error("Incomplete identifier literal", File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
|
|
++m_position;
|
|
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/// Reads (and potentially captures) an identifier from input
|
|
bool Id() {
|
|
SkipWS();
|
|
|
|
const auto start = m_position;
|
|
if (Id_()) {
|
|
|
|
const auto text = Position::str(start, m_position);
|
|
if (text == "true") {
|
|
m_match_stack.push_back(make_node<eval::Constant_AST_Node>(text, start.line, start.col, const_var(true)));
|
|
} else if (text == "false") {
|
|
m_match_stack.push_back(make_node<eval::Constant_AST_Node>(text, start.line, start.col, const_var(false)));
|
|
} else if (text == "Infinity") {
|
|
m_match_stack.push_back(make_node<eval::Constant_AST_Node>(text, start.line, start.col,
|
|
const_var(std::numeric_limits<double>::infinity())));
|
|
} else if (text == "NaN") {
|
|
m_match_stack.push_back(make_node<eval::Constant_AST_Node>(text, start.line, start.col,
|
|
const_var(std::numeric_limits<double>::quiet_NaN())));
|
|
} else if (text == "_") {
|
|
m_match_stack.push_back(make_node<eval::Constant_AST_Node>(text, start.line, start.col,
|
|
Boxed_Value(std::make_shared<dispatch::Placeholder_Object>())));
|
|
} else {
|
|
m_match_stack.push_back(make_node<eval::Id_AST_Node>(
|
|
[&]()->std::string{
|
|
if (*start == '`') {
|
|
// 'escaped' literal, like an operator name
|
|
return Position::str(start+1, m_position-1);
|
|
} else {
|
|
return text;
|
|
}
|
|
}(),
|
|
start.line, start.col));
|
|
}
|
|
|
|
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/// Reads an argument from input
|
|
bool Arg(const bool t_type_allowed = true) {
|
|
const auto prev_stack_top = m_match_stack.size();
|
|
SkipWS();
|
|
|
|
if (!Id()) {
|
|
return false;
|
|
}
|
|
|
|
SkipWS();
|
|
|
|
if (t_type_allowed) {
|
|
Id();
|
|
}
|
|
|
|
build_match<eval::Arg_AST_Node>(prev_stack_top);
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
/// Reads a quoted string from input, without skipping initial whitespace
|
|
bool Quoted_String_() {
|
|
if (m_position.has_more() && (*m_position == '\"')) {
|
|
char prev_char = *m_position;
|
|
++m_position;
|
|
|
|
int in_interpolation = 0;
|
|
bool in_quote = false;
|
|
|
|
while (m_position.has_more() && ((*m_position != '\"') || ((*m_position == '\"') && (in_interpolation > 0)) || ((*m_position == '\"') && (prev_char == '\\')))) {
|
|
|
|
if (!Eol_()) {
|
|
if (prev_char == '$' && *m_position == '{') {
|
|
++in_interpolation;
|
|
} else if (prev_char != '\\' && *m_position == '"') {
|
|
in_quote = !in_quote;
|
|
} else if (*m_position == '}' && !in_quote) {
|
|
--in_interpolation;
|
|
}
|
|
|
|
if (prev_char == '\\') {
|
|
prev_char = 0;
|
|
} else {
|
|
prev_char = *m_position;
|
|
}
|
|
++m_position;
|
|
}
|
|
}
|
|
|
|
if (m_position.has_more()) {
|
|
++m_position;
|
|
} else {
|
|
throw exception::eval_error("Unclosed quoted string", File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
template<typename string_type>
|
|
struct Char_Parser
|
|
{
|
|
string_type &match;
|
|
typedef typename string_type::value_type char_type;
|
|
bool is_escaped = false;
|
|
bool is_interpolated = false;
|
|
bool saw_interpolation_marker = false;
|
|
bool is_octal = false;
|
|
bool is_hex = false;
|
|
const bool interpolation_allowed;
|
|
|
|
string_type octal_matches;
|
|
string_type hex_matches;
|
|
|
|
Char_Parser(string_type &t_match, const bool t_interpolation_allowed)
|
|
: match(t_match),
|
|
interpolation_allowed(t_interpolation_allowed)
|
|
{
|
|
}
|
|
|
|
Char_Parser &operator=(const Char_Parser &) = delete;
|
|
|
|
~Char_Parser(){
|
|
if (is_octal) {
|
|
process_octal();
|
|
}
|
|
|
|
if (is_hex) {
|
|
process_hex();
|
|
}
|
|
}
|
|
|
|
void process_hex()
|
|
{
|
|
auto val = stoll(hex_matches, 0, 16);
|
|
match.push_back(char_type(val));
|
|
hex_matches.clear();
|
|
is_escaped = false;
|
|
is_hex = false;
|
|
}
|
|
|
|
|
|
void process_octal()
|
|
{
|
|
auto val = stoll(octal_matches, 0, 8);
|
|
match.push_back(char_type(val));
|
|
octal_matches.clear();
|
|
is_escaped = false;
|
|
is_octal = false;
|
|
}
|
|
|
|
void parse(const char_type t_char, const int line, const int col, const std::string &filename) {
|
|
const bool is_octal_char = t_char >= '0' && t_char <= '7';
|
|
|
|
if (is_octal) {
|
|
if (is_octal_char) {
|
|
octal_matches.push_back(t_char);
|
|
|
|
if (octal_matches.size() == 3) {
|
|
process_octal();
|
|
}
|
|
return;
|
|
} else {
|
|
process_octal();
|
|
}
|
|
} else if (is_hex) {
|
|
const bool is_hex_char = (t_char >= '0' && t_char <= '9')
|
|
|| (t_char >= 'a' && t_char <= 'f')
|
|
|| (t_char >= 'A' && t_char <= 'F');
|
|
|
|
if (is_hex_char) {
|
|
hex_matches.push_back(t_char);
|
|
|
|
if (hex_matches.size() == 2*sizeof(char_type)) {
|
|
// This rule differs from the C/C++ standard, but ChaiScript
|
|
// does not offer the same workaround options, and having
|
|
// hexadecimal sequences longer than can fit into the char
|
|
// type is undefined behavior anyway.
|
|
process_hex();
|
|
}
|
|
return;
|
|
} else {
|
|
process_hex();
|
|
}
|
|
}
|
|
|
|
if (t_char == '\\') {
|
|
if (is_escaped) {
|
|
match.push_back('\\');
|
|
is_escaped = false;
|
|
} else {
|
|
is_escaped = true;
|
|
}
|
|
} else {
|
|
if (is_escaped) {
|
|
if (is_octal_char) {
|
|
is_octal = true;
|
|
octal_matches.push_back(t_char);
|
|
} else if (t_char == 'x') {
|
|
is_hex = true;
|
|
} else {
|
|
switch (t_char) {
|
|
case ('\'') : match.push_back('\''); break;
|
|
case ('\"') : match.push_back('\"'); break;
|
|
case ('?') : match.push_back('?'); break;
|
|
case ('a') : match.push_back('\a'); break;
|
|
case ('b') : match.push_back('\b'); break;
|
|
case ('f') : match.push_back('\f'); break;
|
|
case ('n') : match.push_back('\n'); break;
|
|
case ('r') : match.push_back('\r'); break;
|
|
case ('t') : match.push_back('\t'); break;
|
|
case ('v') : match.push_back('\v'); break;
|
|
case ('$') : match.push_back('$'); break;
|
|
default: throw exception::eval_error("Unknown escaped sequence in string", File_Position(line, col), filename);
|
|
}
|
|
is_escaped = false;
|
|
}
|
|
} else if (interpolation_allowed && t_char == '$') {
|
|
saw_interpolation_marker = true;
|
|
} else {
|
|
match.push_back(t_char);
|
|
}
|
|
}
|
|
}
|
|
|
|
};
|
|
|
|
|
|
/// Reads (and potentially captures) a quoted string from input. Translates escaped sequences.
|
|
bool Quoted_String(const bool t_capture = false) {
|
|
SkipWS();
|
|
|
|
if (!t_capture) {
|
|
return Quoted_String_();
|
|
} else {
|
|
const auto start = m_position;
|
|
|
|
if (Quoted_String_()) {
|
|
std::string match;
|
|
const auto prev_stack_top = m_match_stack.size();
|
|
|
|
bool is_interpolated = [&]()->bool {
|
|
Char_Parser<std::string> cparser(match, true);
|
|
|
|
|
|
auto s = start + 1, end = m_position - 1;
|
|
|
|
while (s != end) {
|
|
if (cparser.saw_interpolation_marker) {
|
|
if (*s == '{') {
|
|
//We've found an interpolation point
|
|
|
|
m_match_stack.push_back(make_node<eval::Constant_AST_Node>(match, start.line, start.col, const_var(match)));
|
|
|
|
if (cparser.is_interpolated) {
|
|
//If we've seen previous interpolation, add on instead of making a new one
|
|
build_match<eval::Binary_Operator_AST_Node>(prev_stack_top, "+");
|
|
}
|
|
|
|
//We've finished with the part of the string up to this point, so clear it
|
|
match.clear();
|
|
|
|
std::string eval_match;
|
|
|
|
++s;
|
|
while ((s != end) && (*s != '}')) {
|
|
eval_match.push_back(*s);
|
|
++s;
|
|
}
|
|
|
|
if (*s == '}') {
|
|
cparser.is_interpolated = true;
|
|
++s;
|
|
|
|
const auto tostr_stack_top = m_match_stack.size();
|
|
|
|
m_match_stack.push_back(make_node<eval::Id_AST_Node>("to_string", start.line, start.col));
|
|
|
|
const auto ev_stack_top = m_match_stack.size();
|
|
|
|
try {
|
|
ChaiScript_Parser parser;
|
|
parser.parse(eval_match, "instr eval");
|
|
m_match_stack.push_back(parser.ast());
|
|
} catch (const exception::eval_error &e) {
|
|
throw exception::eval_error(e.what(), File_Position(start.line, start.col), *m_filename);
|
|
}
|
|
|
|
build_match<eval::Arg_List_AST_Node>(ev_stack_top);
|
|
build_match<eval::Fun_Call_AST_Node>(tostr_stack_top);
|
|
build_match<eval::Binary_Operator_AST_Node>(prev_stack_top, "+");
|
|
} else {
|
|
throw exception::eval_error("Unclosed in-string eval", File_Position(start.line, start.col), *m_filename);
|
|
}
|
|
} else {
|
|
match.push_back('$');
|
|
}
|
|
cparser.saw_interpolation_marker = false;
|
|
} else {
|
|
cparser.parse(*s, start.line, start.col, *m_filename);
|
|
++s;
|
|
}
|
|
}
|
|
|
|
return cparser.is_interpolated;
|
|
}();
|
|
|
|
m_match_stack.push_back(make_node<eval::Constant_AST_Node>(match, start.line, start.col, const_var(match)));
|
|
|
|
if (is_interpolated) {
|
|
build_match<eval::Binary_Operator_AST_Node>(prev_stack_top, "+");
|
|
}
|
|
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Reads a character group from input, without skipping initial whitespace
|
|
bool Single_Quoted_String_() {
|
|
bool retval = false;
|
|
if (m_position.has_more() && (*m_position == '\'')) {
|
|
retval = true;
|
|
char prev_char = *m_position;
|
|
++m_position;
|
|
|
|
while (m_position.has_more() && ((*m_position != '\'') || ((*m_position == '\'') && (prev_char == '\\')))) {
|
|
if (!Eol_()) {
|
|
if (prev_char == '\\') {
|
|
prev_char = 0;
|
|
} else {
|
|
prev_char = *m_position;
|
|
}
|
|
++m_position;
|
|
}
|
|
}
|
|
|
|
if (m_position.has_more()) {
|
|
++m_position;
|
|
} else {
|
|
throw exception::eval_error("Unclosed single-quoted string", File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
}
|
|
return retval;
|
|
}
|
|
|
|
/// Reads (and potentially captures) a char group from input. Translates escaped sequences.
|
|
bool Single_Quoted_String(const bool t_capture = false) {
|
|
SkipWS();
|
|
|
|
if (!t_capture) {
|
|
return Single_Quoted_String_();
|
|
} else {
|
|
const auto start = m_position;
|
|
if (Single_Quoted_String_()) {
|
|
std::string match;
|
|
|
|
{
|
|
// scope for cparser destructor
|
|
Char_Parser<std::string> cparser(match, false);
|
|
|
|
for (auto s = start + 1, end = m_position - 1; s != end; ++s) {
|
|
cparser.parse(*s, start.line, start.col, *m_filename);
|
|
}
|
|
}
|
|
|
|
if (match.size() != 1) {
|
|
throw exception::eval_error("Single-quoted strings must be 1 character long", File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
|
|
m_match_stack.push_back(make_node<eval::Constant_AST_Node>(match, start.line, start.col, const_var(char(match.at(0)))));
|
|
return true;
|
|
}
|
|
else {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Reads a char from input if it matches the parameter, without skipping initial whitespace
|
|
bool Char_(const char c) {
|
|
if (m_position.has_more() && (*m_position == c)) {
|
|
++m_position;
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/// Reads (and potentially captures) a char from input if it matches the parameter
|
|
bool Char(const char t_c) {
|
|
SkipWS();
|
|
return Char_(t_c);
|
|
}
|
|
|
|
/// Reads a string from input if it matches the parameter, without skipping initial whitespace
|
|
bool Keyword_(const char *t_s) {
|
|
const auto len = strlen(t_s);
|
|
|
|
if (m_position.remaining() >= len) {
|
|
auto tmp = m_position;
|
|
for (size_t i = 0; tmp.has_more() && i < len; ++i) {
|
|
if (*tmp != t_s[i]) {
|
|
return false;
|
|
}
|
|
++tmp;
|
|
}
|
|
m_position = tmp;
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/// Reads (and potentially captures) a string from input if it matches the parameter
|
|
bool Keyword(const char *t_s) {
|
|
SkipWS();
|
|
const auto start = m_position;
|
|
bool retval = Keyword_(t_s);
|
|
// ignore substring matches
|
|
if ( retval && m_position.has_more() && char_in_alphabet(*m_position, detail::keyword_alphabet) ) {
|
|
m_position = start;
|
|
retval = false;
|
|
}
|
|
|
|
return retval;
|
|
}
|
|
|
|
/// Reads a symbol group from input if it matches the parameter, without skipping initial whitespace
|
|
bool Symbol_(const char *t_s) {
|
|
const auto len = strlen(t_s);
|
|
|
|
if (m_position.remaining() >= len) {
|
|
auto tmp = m_position;
|
|
for (size_t i = 0; m_position.has_more() && i < len; ++i) {
|
|
if (*tmp != t_s[i]) {
|
|
return false;
|
|
}
|
|
++tmp;
|
|
}
|
|
m_position = tmp;
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool is_operator(const std::string &t_s) const {
|
|
return std::any_of(m_operator_matches.begin(), m_operator_matches.end(),
|
|
[t_s](const std::vector<std::string> &opers) {
|
|
return std::any_of(opers.begin(), opers.end(),
|
|
[t_s](const std::string &s) {
|
|
return s == t_s;
|
|
});
|
|
});
|
|
}
|
|
|
|
/// Reads (and potentially captures) a symbol group from input if it matches the parameter
|
|
bool Symbol(const char *t_s, const bool t_disallow_prevention=false) {
|
|
SkipWS();
|
|
const auto start = m_position;
|
|
bool retval = Symbol_(t_s);
|
|
|
|
// ignore substring matches
|
|
if (retval && m_position.has_more() && (t_disallow_prevention == false) && char_in_alphabet(*m_position,detail::symbol_alphabet)) {
|
|
if (*m_position != '=' && is_operator(Position::str(start, m_position)) && !is_operator(Position::str(start, m_position+1))) {
|
|
// don't throw this away, it's a good match and the next is not
|
|
} else {
|
|
m_position = start;
|
|
retval = false;
|
|
}
|
|
}
|
|
|
|
return retval;
|
|
}
|
|
|
|
/// Reads an end-of-line group from input, without skipping initial whitespace
|
|
bool Eol_(const bool t_eos = false) {
|
|
bool retval = false;
|
|
|
|
if (m_position.has_more() && (Symbol_("\r\n") || Char_('\n'))) {
|
|
retval = true;
|
|
//++m_position.line;
|
|
m_position.col = 1;
|
|
} else if (m_position.has_more() && !t_eos && Char_(';')) {
|
|
retval = true;
|
|
}
|
|
|
|
return retval;
|
|
}
|
|
|
|
/// Reads until the end of the current statement
|
|
bool Eos() {
|
|
SkipWS();
|
|
|
|
return Eol_(true);
|
|
}
|
|
|
|
/// Reads (and potentially captures) an end-of-line group from input
|
|
bool Eol() {
|
|
SkipWS();
|
|
|
|
return Eol_();
|
|
}
|
|
|
|
/// Reads a comma-separated list of values from input. Id's only, no types allowed
|
|
bool Id_Arg_List() {
|
|
SkipWS(true);
|
|
bool retval = false;
|
|
|
|
const auto prev_stack_top = m_match_stack.size();
|
|
|
|
if (Arg(false)) {
|
|
retval = true;
|
|
while (Eol()) {}
|
|
|
|
while (Char(',')) {
|
|
while (Eol()) {}
|
|
if (!Arg(false)) {
|
|
throw exception::eval_error("Unexpected value in parameter list", File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
}
|
|
}
|
|
build_match<eval::Arg_List_AST_Node>(prev_stack_top);
|
|
|
|
SkipWS(true);
|
|
|
|
return retval;
|
|
}
|
|
|
|
/// Reads a comma-separated list of values from input, for function declarations
|
|
bool Decl_Arg_List() {
|
|
SkipWS(true);
|
|
bool retval = false;
|
|
|
|
const auto prev_stack_top = m_match_stack.size();
|
|
|
|
if (Arg()) {
|
|
retval = true;
|
|
while (Eol()) {}
|
|
|
|
while (Char(',')) {
|
|
while (Eol()) {}
|
|
if (!Arg()) {
|
|
throw exception::eval_error("Unexpected value in parameter list", File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
}
|
|
}
|
|
build_match<eval::Arg_List_AST_Node>(prev_stack_top);
|
|
|
|
SkipWS(true);
|
|
|
|
return retval;
|
|
}
|
|
|
|
|
|
/// Reads a comma-separated list of values from input
|
|
bool Arg_List() {
|
|
SkipWS(true);
|
|
bool retval = false;
|
|
|
|
const auto prev_stack_top = m_match_stack.size();
|
|
|
|
if (Equation()) {
|
|
retval = true;
|
|
while (Eol()) {}
|
|
while (Char(',')) {
|
|
while (Eol()) {}
|
|
if (!Equation()) {
|
|
throw exception::eval_error("Unexpected value in parameter list", File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
}
|
|
}
|
|
|
|
build_match<eval::Arg_List_AST_Node>(prev_stack_top);
|
|
|
|
SkipWS(true);
|
|
|
|
return retval;
|
|
}
|
|
|
|
/// Reads possible special container values, including ranges and map_pairs
|
|
bool Container_Arg_List() {
|
|
bool retval = false;
|
|
SkipWS(true);
|
|
|
|
const auto prev_stack_top = m_match_stack.size();
|
|
|
|
if (Value_Range()) {
|
|
retval = true;
|
|
build_match<eval::Arg_List_AST_Node>(prev_stack_top);
|
|
} else if (Map_Pair()) {
|
|
retval = true;
|
|
while (Eol()) {}
|
|
while (Char(',')) {
|
|
while (Eol()) {}
|
|
if (!Map_Pair()) {
|
|
throw exception::eval_error("Unexpected value in container", File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
}
|
|
build_match<eval::Arg_List_AST_Node>(prev_stack_top);
|
|
} else if (Operator()) {
|
|
retval = true;
|
|
while (Eol()) {}
|
|
while (Char(',')) {
|
|
while (Eol()) {}
|
|
if (!Operator()) {
|
|
throw exception::eval_error("Unexpected value in container", File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
}
|
|
build_match<eval::Arg_List_AST_Node>(prev_stack_top);
|
|
}
|
|
|
|
SkipWS(true);
|
|
|
|
return retval;
|
|
}
|
|
|
|
/// Reads a lambda (anonymous function) from input
|
|
bool Lambda() {
|
|
bool retval = false;
|
|
|
|
const auto prev_stack_top = m_match_stack.size();
|
|
|
|
if (Keyword("fun")) {
|
|
retval = true;
|
|
|
|
if (Char('[')) {
|
|
Id_Arg_List();
|
|
if (!Char(']')) {
|
|
throw exception::eval_error("Incomplete anonymous function bind", File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
} else {
|
|
// make sure we always have the same number of nodes
|
|
build_match<eval::Arg_List_AST_Node>(prev_stack_top);
|
|
}
|
|
|
|
if (Char('(')) {
|
|
Decl_Arg_List();
|
|
if (!Char(')')) {
|
|
throw exception::eval_error("Incomplete anonymous function", File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
} else {
|
|
throw exception::eval_error("Incomplete anonymous function", File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
|
|
|
|
while (Eol()) {}
|
|
|
|
if (!Block()) {
|
|
throw exception::eval_error("Incomplete anonymous function", File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
|
|
build_match<eval::Lambda_AST_Node>(prev_stack_top);
|
|
}
|
|
|
|
return retval;
|
|
}
|
|
|
|
/// Reads a function definition from input
|
|
bool Def(const bool t_class_context = false) {
|
|
bool retval = false;
|
|
|
|
const auto prev_stack_top = m_match_stack.size();
|
|
|
|
if (Keyword("def")) {
|
|
retval = true;
|
|
|
|
if (!Id()) {
|
|
throw exception::eval_error("Missing function name in definition", File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
|
|
bool is_method = false;
|
|
|
|
if (Symbol("::")) {
|
|
//We're now a method
|
|
is_method = true;
|
|
|
|
if (!Id()) {
|
|
throw exception::eval_error("Missing method name in definition", File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
}
|
|
|
|
if (Char('(')) {
|
|
Decl_Arg_List();
|
|
if (!Char(')')) {
|
|
throw exception::eval_error("Incomplete function definition", File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
}
|
|
|
|
while (Eos()) {}
|
|
|
|
if (Char(':')) {
|
|
if (!Operator()) {
|
|
throw exception::eval_error("Missing guard expression for function", File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
}
|
|
|
|
while (Eol()) {}
|
|
if (!Block()) {
|
|
throw exception::eval_error("Incomplete function definition", File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
|
|
if (is_method || t_class_context) {
|
|
build_match<eval::Method_AST_Node>(prev_stack_top);
|
|
} else {
|
|
build_match<eval::Def_AST_Node>(prev_stack_top);
|
|
}
|
|
|
|
}
|
|
|
|
return retval;
|
|
}
|
|
|
|
/// Reads a function definition from input
|
|
bool Try() {
|
|
bool retval = false;
|
|
|
|
const auto prev_stack_top = m_match_stack.size();
|
|
|
|
if (Keyword("try")) {
|
|
retval = true;
|
|
|
|
while (Eol()) {}
|
|
|
|
if (!Block()) {
|
|
throw exception::eval_error("Incomplete 'try' block", File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
|
|
bool has_matches = true;
|
|
while (has_matches) {
|
|
while (Eol()) {}
|
|
has_matches = false;
|
|
if (Keyword("catch")) {
|
|
const auto catch_stack_top = m_match_stack.size();
|
|
if (Char('(')) {
|
|
if (!(Arg() && Char(')'))) {
|
|
throw exception::eval_error("Incomplete 'catch' expression", File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
if (Char(':')) {
|
|
if (!Operator()) {
|
|
throw exception::eval_error("Missing guard expression for catch", File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
}
|
|
}
|
|
|
|
while (Eol()) {}
|
|
|
|
if (!Block()) {
|
|
throw exception::eval_error("Incomplete 'catch' block", File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
build_match<eval::Catch_AST_Node>(catch_stack_top);
|
|
has_matches = true;
|
|
}
|
|
}
|
|
while (Eol()) {}
|
|
if (Keyword("finally")) {
|
|
const auto finally_stack_top = m_match_stack.size();
|
|
|
|
while (Eol()) {}
|
|
|
|
if (!Block()) {
|
|
throw exception::eval_error("Incomplete 'finally' block", File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
build_match<eval::Finally_AST_Node>(finally_stack_top);
|
|
}
|
|
|
|
build_match<eval::Try_AST_Node>(prev_stack_top);
|
|
}
|
|
|
|
return retval;
|
|
}
|
|
|
|
/// Reads an if/else if/else block from input
|
|
bool If() {
|
|
bool retval = false;
|
|
|
|
const auto prev_stack_top = m_match_stack.size();
|
|
|
|
if (Keyword("if")) {
|
|
retval = true;
|
|
|
|
if (!Char('(')) {
|
|
throw exception::eval_error("Incomplete 'if' expression", File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
|
|
if (!(Operator() && Char(')'))) {
|
|
throw exception::eval_error("Incomplete 'if' expression", File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
|
|
while (Eol()) {}
|
|
|
|
if (!Block()) {
|
|
throw exception::eval_error("Incomplete 'if' block", File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
|
|
bool has_matches = true;
|
|
while (has_matches) {
|
|
while (Eol()) {}
|
|
has_matches = false;
|
|
if (Keyword("else")) {
|
|
if (If()) {
|
|
has_matches = true;
|
|
} else {
|
|
while (Eol()) {}
|
|
|
|
if (!Block()) {
|
|
throw exception::eval_error("Incomplete 'else' block", File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
has_matches = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
build_match<eval::If_AST_Node>(prev_stack_top);
|
|
}
|
|
|
|
return retval;
|
|
}
|
|
|
|
/// Reads a class block from input
|
|
bool Class() {
|
|
bool retval = false;
|
|
|
|
size_t prev_stack_top = m_match_stack.size();
|
|
|
|
if (Keyword("class")) {
|
|
retval = true;
|
|
|
|
if (!Id()) {
|
|
throw exception::eval_error("Missing class name in definition", File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
|
|
|
|
while (Eol()) {}
|
|
|
|
if (!Class_Block()) {
|
|
throw exception::eval_error("Incomplete 'class' block", File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
|
|
build_match<eval::Class_AST_Node>(prev_stack_top);
|
|
}
|
|
|
|
return retval;
|
|
}
|
|
|
|
|
|
/// Reads a while block from input
|
|
bool While() {
|
|
bool retval = false;
|
|
|
|
const auto prev_stack_top = m_match_stack.size();
|
|
|
|
if (Keyword("while")) {
|
|
retval = true;
|
|
|
|
if (!Char('(')) {
|
|
throw exception::eval_error("Incomplete 'while' expression", File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
|
|
if (!(Operator() && Char(')'))) {
|
|
throw exception::eval_error("Incomplete 'while' expression", File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
|
|
while (Eol()) {}
|
|
|
|
if (!Block()) {
|
|
throw exception::eval_error("Incomplete 'while' block", File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
|
|
build_match<eval::While_AST_Node>(prev_stack_top);
|
|
}
|
|
|
|
return retval;
|
|
}
|
|
|
|
|
|
/// Reads the C-style for conditions from input
|
|
bool For_Guards() {
|
|
if (!(Equation() && Eol()))
|
|
{
|
|
if (!Eol())
|
|
{
|
|
throw exception::eval_error("'for' loop initial statment missing", File_Position(m_position.line, m_position.col), *m_filename);
|
|
} else {
|
|
m_match_stack.push_back(chaiscript::make_shared<AST_Node, eval::Noop_AST_Node>());
|
|
}
|
|
}
|
|
|
|
if (!(Equation() && Eol()))
|
|
{
|
|
if (!Eol())
|
|
{
|
|
throw exception::eval_error("'for' loop condition missing", File_Position(m_position.line, m_position.col), *m_filename);
|
|
} else {
|
|
m_match_stack.push_back(chaiscript::make_shared<AST_Node, eval::Noop_AST_Node>());
|
|
}
|
|
}
|
|
|
|
if (!Equation())
|
|
{
|
|
m_match_stack.push_back(chaiscript::make_shared<AST_Node, eval::Noop_AST_Node>());
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/// Reads a for block from input
|
|
bool For() {
|
|
bool retval = false;
|
|
|
|
const auto prev_stack_top = m_match_stack.size();
|
|
|
|
if (Keyword("for")) {
|
|
retval = true;
|
|
|
|
if (!Char('(')) {
|
|
throw exception::eval_error("Incomplete 'for' expression", File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
|
|
if (!(For_Guards() && Char(')'))) {
|
|
throw exception::eval_error("Incomplete 'for' expression", File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
|
|
while (Eol()) {}
|
|
|
|
if (!Block()) {
|
|
throw exception::eval_error("Incomplete 'for' block", File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
|
|
build_match<eval::For_AST_Node>(prev_stack_top);
|
|
}
|
|
|
|
return retval;
|
|
}
|
|
|
|
/// Reads a case block from input
|
|
bool Case() {
|
|
bool retval = false;
|
|
|
|
const auto prev_stack_top = m_match_stack.size();
|
|
|
|
if (Keyword("case")) {
|
|
retval = true;
|
|
|
|
if (!Char('(')) {
|
|
throw exception::eval_error("Incomplete 'case' expression", File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
|
|
if (!(Operator() && Char(')'))) {
|
|
throw exception::eval_error("Incomplete 'case' expression", File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
|
|
while (Eol()) {}
|
|
|
|
if (!Block()) {
|
|
throw exception::eval_error("Incomplete 'case' block", File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
|
|
build_match<eval::Case_AST_Node>(prev_stack_top);
|
|
} else if (Keyword("default")) {
|
|
retval = true;
|
|
|
|
while (Eol()) {}
|
|
|
|
if (!Block()) {
|
|
throw exception::eval_error("Incomplete 'default' block", File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
|
|
build_match<eval::Default_AST_Node>(prev_stack_top);
|
|
}
|
|
|
|
return retval;
|
|
}
|
|
|
|
|
|
/// Reads a switch statement from input
|
|
bool Switch() {
|
|
const auto prev_stack_top = m_match_stack.size();
|
|
|
|
if (Keyword("switch")) {
|
|
|
|
if (!Char('(')) {
|
|
throw exception::eval_error("Incomplete 'switch' expression", File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
|
|
if (!(Operator() && Char(')'))) {
|
|
throw exception::eval_error("Incomplete 'switch' expression", File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
|
|
while (Eol()) {}
|
|
|
|
if (Char('{')) {
|
|
while (Eol()) {}
|
|
|
|
while (Case()) {
|
|
while (Eol()) { } // eat
|
|
}
|
|
|
|
while (Eol()) { } // eat
|
|
|
|
if (!Char('}')) {
|
|
throw exception::eval_error("Incomplete block", File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
}
|
|
else {
|
|
throw exception::eval_error("Incomplete block", File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
|
|
build_match<eval::Switch_AST_Node>(prev_stack_top);
|
|
return true;
|
|
|
|
} else {
|
|
return false;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
/// Reads a curly-brace C-style class block from input
|
|
bool Class_Block() {
|
|
bool retval = false;
|
|
|
|
const auto prev_stack_top = m_match_stack.size();
|
|
|
|
if (Char('{')) {
|
|
retval = true;
|
|
|
|
Class_Statements();
|
|
if (!Char('}')) {
|
|
throw exception::eval_error("Incomplete class block", File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
|
|
if (m_match_stack.size() == prev_stack_top) {
|
|
m_match_stack.push_back(chaiscript::make_shared<AST_Node, eval::Noop_AST_Node>());
|
|
}
|
|
|
|
build_match<eval::Block_AST_Node>(prev_stack_top);
|
|
}
|
|
|
|
return retval;
|
|
}
|
|
|
|
/// Reads a curly-brace C-style block from input
|
|
bool Block() {
|
|
bool retval = false;
|
|
|
|
const auto prev_stack_top = m_match_stack.size();
|
|
|
|
if (Char('{')) {
|
|
retval = true;
|
|
|
|
Statements();
|
|
if (!Char('}')) {
|
|
throw exception::eval_error("Incomplete block", File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
|
|
if (m_match_stack.size() == prev_stack_top) {
|
|
m_match_stack.push_back(chaiscript::make_shared<AST_Node, eval::Noop_AST_Node>());
|
|
}
|
|
|
|
build_match<eval::Block_AST_Node>(prev_stack_top);
|
|
}
|
|
|
|
return retval;
|
|
}
|
|
|
|
/// Reads a return statement from input
|
|
bool Return() {
|
|
const auto prev_stack_top = m_match_stack.size();
|
|
|
|
if (Keyword("return")) {
|
|
Operator();
|
|
build_match<eval::Return_AST_Node>(prev_stack_top);
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/// Reads a break statement from input
|
|
bool Break() {
|
|
const auto prev_stack_top = m_match_stack.size();
|
|
|
|
if (Keyword("break")) {
|
|
build_match<eval::Break_AST_Node>(prev_stack_top);
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/// Reads a continue statement from input
|
|
bool Continue() {
|
|
const auto prev_stack_top = m_match_stack.size();
|
|
|
|
if (Keyword("continue")) {
|
|
build_match<eval::Continue_AST_Node>(prev_stack_top);
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/// Reads a dot expression(member access), then proceeds to check if it's a function or array call
|
|
bool Dot_Fun_Array() {
|
|
bool retval = false;
|
|
|
|
const auto prev_stack_top = m_match_stack.size();
|
|
if (Lambda() || Num(true) || Quoted_String(true) || Single_Quoted_String(true) ||
|
|
Paren_Expression() || Inline_Container() || Id())
|
|
{
|
|
retval = true;
|
|
bool has_more = true;
|
|
|
|
while (has_more) {
|
|
has_more = false;
|
|
|
|
if (Char('(')) {
|
|
has_more = true;
|
|
|
|
Arg_List();
|
|
if (!Char(')')) {
|
|
throw exception::eval_error("Incomplete function call", File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
|
|
build_match<eval::Fun_Call_AST_Node>(prev_stack_top);
|
|
/// \todo Work around for method calls until we have a better solution
|
|
if (!m_match_stack.back()->children.empty()) {
|
|
if (m_match_stack.back()->children[0]->identifier == AST_Node_Type::Dot_Access) {
|
|
if (m_match_stack.empty()) throw exception::eval_error("Incomplete dot access fun call", File_Position(m_position.line, m_position.col), *m_filename);
|
|
if (m_match_stack.back()->children.empty()) throw exception::eval_error("Incomplete dot access fun call", File_Position(m_position.line, m_position.col), *m_filename);
|
|
AST_NodePtr dot_access = m_match_stack.back()->children[0];
|
|
AST_NodePtr func_call = m_match_stack.back();
|
|
m_match_stack.pop_back();
|
|
func_call->children.erase(func_call->children.begin());
|
|
if (dot_access->children.empty()) throw exception::eval_error("Incomplete dot access fun call", File_Position(m_position.line, m_position.col), *m_filename);
|
|
func_call->children.insert(func_call->children.begin(), dot_access->children.back());
|
|
dot_access->children.pop_back();
|
|
dot_access->children.push_back(std::move(func_call));
|
|
if (dot_access->children.size() != 2) throw exception::eval_error("Incomplete dot access fun call", File_Position(m_position.line, m_position.col), *m_filename);
|
|
m_match_stack.push_back(std::move(dot_access));
|
|
}
|
|
}
|
|
} else if (Char('[')) {
|
|
has_more = true;
|
|
|
|
if (!(Operator() && Char(']'))) {
|
|
throw exception::eval_error("Incomplete array access", File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
|
|
build_match<eval::Array_Call_AST_Node>(prev_stack_top);
|
|
}
|
|
else if (Symbol(".")) {
|
|
has_more = true;
|
|
if (!(Id())) {
|
|
throw exception::eval_error("Incomplete dot access fun call", File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
|
|
if ( std::distance(m_match_stack.begin() + static_cast<int>(prev_stack_top), m_match_stack.end()) != 2) {
|
|
throw exception::eval_error("Incomplete dot access fun call", File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
build_match<eval::Dot_Access_AST_Node>(prev_stack_top);
|
|
}
|
|
}
|
|
}
|
|
|
|
return retval;
|
|
}
|
|
|
|
/// Reads a variable declaration from input
|
|
bool Var_Decl(const bool t_class_context = false) {
|
|
bool retval = false;
|
|
|
|
const auto prev_stack_top = m_match_stack.size();
|
|
|
|
if (t_class_context && (Keyword("attr") || Keyword("auto") || Keyword("var"))) {
|
|
retval = true;
|
|
|
|
if (!Id()) {
|
|
throw exception::eval_error("Incomplete attribute declaration", File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
|
|
build_match<eval::Attr_Decl_AST_Node>(prev_stack_top);
|
|
} else if (Keyword("auto") || Keyword("var") ) {
|
|
retval = true;
|
|
|
|
if (Reference()) {
|
|
// we built a reference node - continue
|
|
} else if (Id()) {
|
|
build_match<eval::Var_Decl_AST_Node>(prev_stack_top);
|
|
} else {
|
|
throw exception::eval_error("Incomplete variable declaration", File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
|
|
} else if (Keyword("GLOBAL") || Keyword("global")) {
|
|
retval = true;
|
|
|
|
if (!(Reference() || Id())) {
|
|
throw exception::eval_error("Incomplete global declaration", File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
|
|
build_match<eval::Global_Decl_AST_Node>(prev_stack_top);
|
|
} else if (Keyword("attr")) {
|
|
retval = true;
|
|
|
|
if (!Id()) {
|
|
throw exception::eval_error("Incomplete attribute declaration", File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
if (!Symbol("::")) {
|
|
throw exception::eval_error("Incomplete attribute declaration", File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
if (!Id()) {
|
|
throw exception::eval_error("Missing attribute name in definition", File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
|
|
|
|
build_match<eval::Attr_Decl_AST_Node>(prev_stack_top);
|
|
}
|
|
|
|
return retval;
|
|
}
|
|
|
|
/// Reads an expression surrounded by parentheses from input
|
|
bool Paren_Expression() {
|
|
if (Char('(')) {
|
|
if (!Operator()) {
|
|
throw exception::eval_error("Incomplete expression", File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
if (!Char(')')) {
|
|
throw exception::eval_error("Missing closing parenthesis ')'", File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/// Reads, and identifies, a short-form container initialization from input
|
|
bool Inline_Container() {
|
|
const auto prev_stack_top = m_match_stack.size();
|
|
|
|
if (Char('[')) {
|
|
Container_Arg_List();
|
|
|
|
if (!Char(']')) {
|
|
throw exception::eval_error("Missing closing square bracket ']' in container initializer", File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
if ((prev_stack_top != m_match_stack.size()) && (m_match_stack.back()->children.size() > 0)) {
|
|
if (m_match_stack.back()->children[0]->identifier == AST_Node_Type::Value_Range) {
|
|
build_match<eval::Inline_Range_AST_Node>(prev_stack_top);
|
|
}
|
|
else if (m_match_stack.back()->children[0]->identifier == AST_Node_Type::Map_Pair) {
|
|
build_match<eval::Inline_Map_AST_Node>(prev_stack_top);
|
|
}
|
|
else {
|
|
build_match<eval::Inline_Array_AST_Node>(prev_stack_top);
|
|
}
|
|
}
|
|
else {
|
|
build_match<eval::Inline_Array_AST_Node>(prev_stack_top);
|
|
}
|
|
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/// Parses a variable specified with a & aka reference
|
|
bool Reference() {
|
|
const auto prev_stack_top = m_match_stack.size();
|
|
|
|
if (Symbol("&")) {
|
|
if (!Id()) {
|
|
throw exception::eval_error("Incomplete '&' expression", File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
|
|
build_match<eval::Reference_AST_Node>(prev_stack_top);
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/// Reads a unary prefixed expression from input
|
|
bool Prefix() {
|
|
const auto prev_stack_top = m_match_stack.size();
|
|
const std::vector<std::string> prefix_opers{"++", "--", "-", "+", "!", "~", "&"};
|
|
|
|
for (const auto &oper : prefix_opers)
|
|
{
|
|
bool is_char = oper.size() == 1;
|
|
if ((is_char && Char(oper[0])) || (!is_char && Symbol(oper.c_str())))
|
|
{
|
|
if (!Operator(m_operators.size()-1)) {
|
|
throw exception::eval_error("Incomplete prefix '" + oper + "' expression", File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
|
|
build_match<eval::Prefix_AST_Node>(prev_stack_top, oper);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/// Parses any of a group of 'value' style ast_node groups from input
|
|
bool Value() {
|
|
return Var_Decl() || Dot_Fun_Array() || Prefix();
|
|
}
|
|
|
|
bool Operator_Helper(const size_t t_precedence, std::string &oper) {
|
|
for (auto & elem : m_operator_matches[t_precedence]) {
|
|
if (Symbol(elem.c_str())) {
|
|
oper = elem;
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool Operator(const size_t t_precedence = 0) {
|
|
bool retval = false;
|
|
const auto prev_stack_top = m_match_stack.size();
|
|
|
|
if (t_precedence < m_operators.size()) {
|
|
if (Operator(t_precedence+1)) {
|
|
retval = true;
|
|
std::string oper;
|
|
while (Operator_Helper(t_precedence, oper)) {
|
|
while (Eol()) {}
|
|
if (!Operator(t_precedence+1)) {
|
|
throw exception::eval_error("Incomplete '" + oper + "' expression",
|
|
File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
|
|
switch (m_operators[t_precedence]) {
|
|
case(Operator_Precidence::Ternary_Cond) :
|
|
if (Symbol(":")) {
|
|
if (!Operator(t_precedence+1)) {
|
|
throw exception::eval_error("Incomplete '" + oper + "' expression",
|
|
File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
build_match<eval::Ternary_Cond_AST_Node>(prev_stack_top);
|
|
}
|
|
else {
|
|
throw exception::eval_error("Incomplete '" + oper + "' expression",
|
|
File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
break;
|
|
|
|
case(Operator_Precidence::Addition) :
|
|
case(Operator_Precidence::Multiplication) :
|
|
case(Operator_Precidence::Shift) :
|
|
case(Operator_Precidence::Equality) :
|
|
case(Operator_Precidence::Bitwise_And) :
|
|
case(Operator_Precidence::Bitwise_Xor) :
|
|
case(Operator_Precidence::Bitwise_Or) :
|
|
case(Operator_Precidence::Comparison) :
|
|
{
|
|
bool folded = false;
|
|
const auto size = m_match_stack.size();
|
|
|
|
try {
|
|
if (m_match_stack[size - 1]->identifier == AST_Node_Type::Constant
|
|
&& m_match_stack[size - 2]->identifier == AST_Node_Type::Constant) {
|
|
const auto parsed = Operators::to_operator(oper);
|
|
if (parsed != Operators::Opers::invalid) {
|
|
const auto lhs = std::dynamic_pointer_cast<eval::Constant_AST_Node>(m_match_stack[size-2])->m_value;
|
|
const auto rhs = std::dynamic_pointer_cast<eval::Constant_AST_Node>(m_match_stack[size-1])->m_value;
|
|
if (lhs.get_type_info().is_arithmetic() && rhs.get_type_info().is_arithmetic()) {
|
|
const auto val = Boxed_Number::do_oper(parsed, lhs, rhs);
|
|
const auto start = m_match_stack[size-2]->location;
|
|
const auto match = m_match_stack[size-2]->text + " " + oper + " " + m_match_stack[size-1]->text;
|
|
m_match_stack.resize(size-2);
|
|
m_match_stack.push_back(
|
|
make_node<eval::Constant_AST_Node>(std::move(match), start.start.line, start.start.column, std::move(val)));
|
|
folded = true;
|
|
}
|
|
}
|
|
}
|
|
} catch (const std::exception &) {
|
|
//failure to fold
|
|
}
|
|
|
|
if (!folded) {
|
|
build_match<eval::Binary_Operator_AST_Node>(prev_stack_top, oper);
|
|
}
|
|
}
|
|
|
|
break;
|
|
|
|
case(Operator_Precidence::Logical_And) :
|
|
build_match<eval::Logical_And_AST_Node>(prev_stack_top, oper);
|
|
break;
|
|
case(Operator_Precidence::Logical_Or) :
|
|
build_match<eval::Logical_Or_AST_Node>(prev_stack_top, oper);
|
|
break;
|
|
|
|
default:
|
|
throw exception::eval_error("Internal error: unhandled ast_node", File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
return Value();
|
|
}
|
|
|
|
return retval;
|
|
}
|
|
|
|
/// Reads a pair of values used to create a map initialization from input
|
|
bool Map_Pair() {
|
|
bool retval = false;
|
|
|
|
const auto prev_stack_top = m_match_stack.size();
|
|
const auto prev_pos = m_position;
|
|
|
|
if (Operator()) {
|
|
if (Symbol(":")) {
|
|
retval = true;
|
|
if (!Operator()) {
|
|
throw exception::eval_error("Incomplete map pair", File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
|
|
build_match<eval::Map_Pair_AST_Node>(prev_stack_top);
|
|
}
|
|
else {
|
|
m_position = prev_pos;
|
|
while (prev_stack_top != m_match_stack.size()) {
|
|
m_match_stack.pop_back();
|
|
}
|
|
}
|
|
}
|
|
|
|
return retval;
|
|
}
|
|
|
|
/// Reads a pair of values used to create a range initialization from input
|
|
bool Value_Range() {
|
|
bool retval = false;
|
|
|
|
const auto prev_stack_top = m_match_stack.size();
|
|
const auto prev_pos = m_position;
|
|
|
|
if (Operator()) {
|
|
if (Symbol("..")) {
|
|
retval = true;
|
|
if (!Operator()) {
|
|
throw exception::eval_error("Incomplete value range", File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
|
|
build_match<eval::Value_Range_AST_Node>(prev_stack_top);
|
|
}
|
|
else {
|
|
m_position = prev_pos;
|
|
while (prev_stack_top != m_match_stack.size()) {
|
|
m_match_stack.pop_back();
|
|
}
|
|
}
|
|
}
|
|
|
|
return retval;
|
|
}
|
|
|
|
/// Parses a string of binary equation operators
|
|
bool Equation() {
|
|
const auto prev_stack_top = m_match_stack.size();
|
|
|
|
if (Operator()) {
|
|
for (const auto sym : {"=", ":=", "+=", "-=", "*=", "/=", "%=", "<<=", ">>=", "&=", "^=", "|="})
|
|
{
|
|
if (Symbol(sym, true)) {
|
|
SkipWS(true);
|
|
if (!Equation()) {
|
|
throw exception::eval_error("Incomplete equation", File_Position(m_position.line, m_position.col), *m_filename);
|
|
}
|
|
|
|
build_match<eval::Equation_AST_Node>(prev_stack_top, sym);
|
|
return true;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/// Parses statements allowed inside of a class block
|
|
bool Class_Statements() {
|
|
bool retval = false;
|
|
|
|
bool has_more = true;
|
|
bool saw_eol = true;
|
|
|
|
while (has_more) {
|
|
const auto start = m_position;
|
|
if (Def(true) || Var_Decl(true)) {
|
|
if (!saw_eol) {
|
|
throw exception::eval_error("Two function definitions missing line separator", File_Position(start.line, start.col), *m_filename);
|
|
}
|
|
has_more = true;
|
|
retval = true;
|
|
saw_eol = true;
|
|
} else if (Eol()) {
|
|
has_more = true;
|
|
retval = true;
|
|
saw_eol = true;
|
|
} else {
|
|
has_more = false;
|
|
}
|
|
}
|
|
|
|
return retval;
|
|
}
|
|
|
|
/// Top level parser, starts parsing of all known parses
|
|
bool Statements() {
|
|
bool retval = false;
|
|
|
|
bool has_more = true;
|
|
bool saw_eol = true;
|
|
|
|
while (has_more) {
|
|
const auto start = m_position;
|
|
if (Def() || Try() || If() || While() || Class() || For() || Switch()) {
|
|
if (!saw_eol) {
|
|
throw exception::eval_error("Two function definitions missing line separator", File_Position(start.line, start.col), *m_filename);
|
|
}
|
|
has_more = true;
|
|
retval = true;
|
|
saw_eol = true;
|
|
}
|
|
else if (Return() || Break() || Continue() || Equation()) {
|
|
if (!saw_eol) {
|
|
throw exception::eval_error("Two expressions missing line separator", File_Position(start.line, start.col), *m_filename);
|
|
}
|
|
has_more = true;
|
|
retval = true;
|
|
saw_eol = false;
|
|
}
|
|
else if (Block() || Eol()) {
|
|
has_more = true;
|
|
retval = true;
|
|
saw_eol = true;
|
|
}
|
|
else {
|
|
has_more = false;
|
|
}
|
|
}
|
|
|
|
return retval;
|
|
}
|
|
|
|
/// Parses the given input string, tagging parsed ast_nodes with the given m_filename.
|
|
bool parse(const std::string &t_input, std::string t_fname) {
|
|
m_position = Position(t_input.begin(), t_input.end());
|
|
m_filename = std::make_shared<std::string>(std::move(t_fname));
|
|
|
|
if ((t_input.size() > 1) && (t_input[0] == '#') && (t_input[1] == '!')) {
|
|
while (m_position.has_more() && (!Eol())) {
|
|
++m_position;
|
|
}
|
|
/// \todo respect // -*- coding: utf-8 -*- on line 1 or 2 see: http://evanjones.ca/python-utf8.html)
|
|
}
|
|
|
|
if (Statements()) {
|
|
if (m_position.has_more()) {
|
|
throw exception::eval_error("Unparsed input", File_Position(m_position.line, m_position.col), t_fname);
|
|
} else {
|
|
build_match<eval::File_AST_Node>(0);
|
|
//debug_print(ast());
|
|
return true;
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
};
|
|
}
|
|
}
|
|
|
|
|
|
#if defined(CHAISCRIPT_MSVC) && defined(CHAISCRIPT_PUSHED_MIN_MAX)
|
|
#undef CHAISCRIPT_PUSHED_MIN_MAX
|
|
#pragma pop_macro("min")
|
|
#pragma pop_macro("max")
|
|
#endif
|
|
|
|
|
|
#endif /* CHAISCRIPT_PARSER_HPP_ */
|
|
|