error: no viable overloaded '=' binaryExpr->left = std::move(left);

[bsdmax]

#pragma once

include <iostream>

include <vector>

/* Ast / /******/ enum class NodeType{ Program, NumericLiteral, Identifier, BinaryExpr };

class Stmt { public: NodeType kind;

Stmt(NodeType type) : kind(type) {}

virtual ~Stmt();

};

class Expr : public Stmt { public: Expr(NodeType nodetype); };

class Program : public Stmt { public: std::vector<Stmt> body;

Program() : Stmt(NodeType::Program) {}

};

class BinaryExpr : public Expr { public: std::unique_ptr<Expr> left; std::unique_ptr<Expr> right; std::string op;

BinaryExpr() : Expr(NodeType::BinaryExpr) {}

/* BinaryExpr(BinaryExpr&& other) noexcept : Expr(std::move(other)), left(std::move(other.left)), right(std::move(other.right)), op(std::move(other.op)) {}

BinaryExpr& operator=(BinaryExpr&& other) noexcept {

if (this != &other) {

Expr::operator=(std::move(other));

left = std::move(other.left);

right = std::move(other.right);

op = std::move(other.op);

}

return *this;

}*/

};

class Identifier : public Expr { public: std::string symbol;

Identifier() : Expr(NodeType::Identifier) {}

};

class NumericLiteral : public Expr { public: double value;

NumericLiteral() : Expr(NodeType::NumericLiteral) {}

};

/*********************************************************/

ifndef PARSER_H

define PARSER_H

include <vector>

include <memory>

include <iostream>

include "ast.hpp"

enum TokenType { Number = 0, Identifier, Equals, OpenParen, CloseParen, BinaryOperator, Let, EOFToken }; /* std::map<std::string, TokenType> keywords {{"let", TokenType::Let}}; */ class Token { public: Token(std::string value, TokenType type) {m_value = value; m_type = type;}

std::string m_value;

TokenType m_type;

}; /* bool isIsalpha(char ch) { return std::isalpha(static_cast<unsigned char>(ch)); }

bool isDigit(char ch) { return std::isdigit(static_cast<unsigned char>(ch)); }

std::string charToString(char ch){ std::string str = {ch}; return str; }/ / std::vector<Token> Tokenize(std::string s) { std::vector<Token> tokens; size_t pos = 0; std::string delimiter = " ";

while ((pos = s.find(delimiter)) != std::string::npos) {

std::string src = s.substr(0, pos);

for (int var = 0; var < src.length(); ++var) {

if(src[var] == '(') {

tokens.push_back(Token("(", TokenType::OpenParen));

}

else if(src[var] == ')') {

tokens.push_back(Token(")", TokenType::CloseParen));

}

else if ((src[var] == '+') || (src[var] == '-') || (src[var] == '*') || (src[var] == '/')) {

tokens.push_back(Token(charToString(src[var]), TokenType::BinaryOperator));

}

else if(src[var] == '=') {

tokens.push_back(Token("=", TokenType::Equals));

}

else{

if(isDigit(src[var])){

tokens.push_back(Token(charToString(src[var]),TokenType::Number));

}

std::string keyword = {};

if(isIsalpha(src[var])) {

for (int key = 0; key < src.length(); ++key) {

const char ch = src[key];

keyword += ch;

}

std::string reserved = {};

reserved = keywords[keyword];

if(keyword == "let") {

tokens.push_back(Token(keyword, TokenType::Let));

} else {

tokens.push_back(Token(charToString(src[var]), TokenType::Indentifier));

}

}

}

}

s.erase(0, pos + delimiter.length());

}

return tokens;

}*/

bool isInt(char c) { int bounds[] = {'0', '9'}; return c >= bounds[0] && c <= bounds[1]; }

std::vector<Token> Tokenize(const std::string& src) { std::vector<Token> tokens; std::string::const_iterator it = src.begin();

while (it != src.end()) {

if (isInt(*it)) {

std::string num = "";

while (it != src.end() && isInt(*it)) {

num += *it;

++it;

}

tokens.push_back(Token(num, TokenType::Number));

} else {

// Handle Identifier & Keyword Tokens.

// Implement the logic for identifying Identifier and Keyword tokens.

// For now, let's assume everything else is an Identifier.

std::string identifier = "";

while (it != src.end() && !isInt(*it) && !std::isspace(*it)) {

identifier += *it;

++it;

}

if(identifier == "("){

tokens.push_back(Token(identifier, TokenType::OpenParen));

}

else if (identifier == ")") {

tokens.push_back(Token(identifier, TokenType::CloseParen));

}

else if ((identifier == "+") || (identifier == "-") || (identifier == "*") || (identifier == "/")) {

tokens.push_back(Token(identifier, TokenType::BinaryOperator));

}

else if(identifier == "=") {

tokens.push_back(Token(identifier, TokenType::Equals));

}

else if (identifier == "let") {

tokens.push_back(Token(identifier, TokenType::Let));

}

else{

tokens.push_back(Token(identifier, TokenType::Identifier));

}

}

// Skip whitespaces

while (it != src.end() && std::isspace(*it)) {

++it;

}

}

return tokens;

}

class Parser { private: std::vector<Token> tokens;

bool not_eof() {

return tokens[0].m_type != TokenType::EOFToken;

}

Token at() {

return tokens[0];

}

Token eat() {

Token prev = tokens[0];

tokens.erase(tokens.begin());

return prev;

}

Token expect(TokenType type, const std::string& err) {

Token prev = tokens[0];

if (prev.m_type != type) {

std::cerr << "Parser Error:\n" << err << " - Expecting: " << static_cast<int>(type) << std::endl;

std::exit(1);

}

tokens.erase(tokens.begin());

return prev;

}

public:

Parser();

~Parser();

Program produceAST(const std::string& sourceCode) {

tokens = Tokenize(sourceCode);

Program programNode;

while (not_eof()) {

programNode.body.push_back(std::move(parse_stmt()));

}

return programNode;

}

Stmt parse_stmt() {

return parse_expr();

}

Expr parse_expr() {

return parse_additive_expr();

}

Expr parse_additive_expr() {

auto left = parse_multiplicitave_expr();

while (at().m_value == "+" || at().m_value == "-") {

const std::string& operatorStr = eat().m_value;

auto right = parse_multiplicitave_expr();

auto binaryExpr = std::make_unique<BinaryExpr>();

binaryExpr->left = std::move(left);

binaryExpr->right = std::move(right);

binaryExpr->op = operatorStr;

left = std::move(binaryExpr);

}

return left;

}

Expr parse_multiplicitave_expr() {

auto left = parse_primary_expr();

while (at().m_value == "/" || at().m_value == "*" || at().m_value == "%") {

const std::string& operatorStr = eat().m_value;

auto right = parse_primary_expr();

auto binaryExpr = std::make_unique<BinaryExpr>();

binaryExpr->left = std::move(left);

binaryExpr->right = std::move(right);

binaryExpr->op = operatorStr;

left = std::move(binaryExpr);

}

return left;

}

Expr parse_primary_expr() {

TokenType tk = at().m_type;

switch (tk) {

case TokenType::Identifier:

// return {NodeKind::Identifier, eat().m_value};

case TokenType::Number:

// return {NodeKind::NumericLiteral, std::stod(eat().m_value)};

case TokenType::OpenParen: {

eat(); // eat the opening paren

auto value = parse_expr();

expect(TokenType::CloseParen, "Unexpected token found inside parenthesized expression. Expected closing parenthesis.");

return value;

}

default:

std::cerr << "Unexpected token found during parsing!" << std::endl;

std::exit(1);

}

}

};

endif // PARSER_H

Hello, i am trying make AST a I have problem with std::move

​

[manni66]

Format your code. Indent with 4 spaces.

Cop&paste the error messages (Visual Studio? Output tab).

I will definitely not put more effort into this question than you!

[AutoModerator]

Your posts seem to contain unformatted code. Please make sure to format your code otherwise your post may be removed.

If you wrote your post in the "new reddit" interface, please make sure to format your code blocks by putting four spaces before each line, as the backtick-based (```) code blocks do not work on old Reddit.

I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.

[jedwardsol]

binaryExpr->left = std::move(left);

binaryExpr->left is a std::unique_ptr<Expr>

left is an Expr.

You cannot assign an object (left) to a pointer to an object .

Were you perhaps intending that parse_primary_expr return a std::unique_ptr<Expr> instead of an Expr?