C++ AST Visitor - Problems to store value of expressions - c++

Question

I'm trying to write a simple script system (for a video game) on which there's no huge complexity tasks, but simple boolean checks & action sets.
I'm a student, but I'm not studying programming, I just do it as a hobby, so I'm learning the basics and recently I felt to write my own parser & interpreter,
but since this is my first approach of AST I do not understand why the result keeps being true instead of false (for the given expressions), also would like to know if it's the best approach for what I am looking for.
You can compile with my source files just fine.
Expression.h
#pragma once
enum OperatorType
{
OPERATOR_EQUALS = 0, // =
OPERATOR_LESSER_THAN, // <
OPERATOR_GREATER_THAN, // >
OPERATOR_LESSER_OR_EQUALS, // <=
OPERATOR_GREATER_OR_EQUALS, // >=
OPERATOR_UNEQUAL, // <>
OPERATOR_MULTIPLY, // *
OPERATOR_SUM, // +
OPERATOR_SUB, // -
};
class Expression;
class ATSVisitor;
class ATSNode
{
public:
virtual void accept(ATSVisitor* visitor) = 0;
};
class ATSRoot
{
public:
Expression* expression;
};
class Expression : public ATSNode
{
public:
~Expression()
{
left = nullptr;
right = nullptr;
}
virtual void accept(ATSVisitor* visitor) = 0;
Expression* left;
Expression* right;
};
class OperationExpression : public Expression
{
public:
OperationExpression() : Expression(){}
virtual void accept(ATSVisitor* visitor);
OperatorType type;
};
class NumberExpression : public Expression
{
public:
NumberExpression() : Expression(){ value = 0; }
virtual void accept(ATSVisitor* visitor);
int value;
};
class ATSVisitor
{
public:
ATSVisitor()
{
Result = false;
}
bool evaluate(ATSRoot* root);
void visit(OperationExpression* expression);
void visit(NumberExpression* expression);
bool Result;
int number;
};
Expression.cpp
#include "expressions.h"
#include <iostream>
void OperationExpression::accept(ATSVisitor* visitor)
{
visitor->visit(this);
}
void NumberExpression::accept(ATSVisitor* visitor)
{
visitor->visit(this);
}
bool ATSVisitor::evaluate(ATSRoot* root)
{
std::cout << "Evaluating ROOT" << std::endl;
bool result = false;
root->expression->accept(this);
result = Result;
return result;
}
void ATSVisitor::visit(OperationExpression* expression)
{
std::cout << "Visitor just visited OPERATIONEXPRESSION: " << expression->type << std::endl;
expression->left->accept(this);
int leftValue = number;
expression->right->accept(this);
int rightValue = number;
switch (expression->type)
{
case OPERATOR_EQUALS:
Result = leftValue == rightValue;
case OPERATOR_GREATER_OR_EQUALS:
Result = leftValue >= rightValue;
case OPERATOR_GREATER_THAN:
Result = leftValue > rightValue;
case OPERATOR_LESSER_OR_EQUALS:
Result = leftValue <= rightValue;
case OPERATOR_LESSER_THAN:
Result = leftValue < rightValue;
case OPERATOR_MULTIPLY:
Result = leftValue * rightValue;
case OPERATOR_SUB:
Result = leftValue - rightValue;
case OPERATOR_SUM:
Result = leftValue + rightValue;
case OPERATOR_UNEQUAL:
Result = leftValue != rightValue;
}
}
void ATSVisitor::visit(NumberExpression* expression)
{
std::cout << "Visitor just visited NUMBEREXPRESSION: " << expression->value << std::endl;
number = expression->value;
}
Main.cpp
#include <iostream>
#include "expressions.h"
int main(int argc, char** argv)
{
ATSVisitor* visitor = new ATSVisitor();
// QuestValue(100)>=10
ATSRoot* root = new ATSRoot();
OperationExpression* operation = new OperationExpression();
operation->type = OPERATOR_GREATER_OR_EQUALS;
NumberExpression* number1 = new NumberExpression();
number1->value = 1;
NumberExpression* number2 = new NumberExpression();
number2->value = 10;
operation->left = number1;
operation->right = number2;
root->expression = operation;
if (!visitor->evaluate(root))
{
std::cout << "\nOperation evaluation FAILED!" << std::endl;
}
else
{
std::cout << "\nOperation evaluation SUCCEED!" << std::endl;
}
std::cout << "Finished" << std::endl;
std::cin.get();
delete root;
delete number1;
delete number2;
delete operation;
return EXIT_SUCCESS;
}
Basically this AST with Visitor pattern is supposed to parse if when my tokenizer parses this script:
1>=10
Will return if it succeeded or not

Answer 1

Your switch statement doesn't do what you think it does.
In C++, as in C, executing a switch statement causes control flow to jump to the appropriate case label. It then executes the remainder of the block, which means that it executes the following case label, and the one following that, unless it hits a break statement.
Needless to say, the normal style is to end every case section with break:
switch (expression->type)
{
case OPERATOR_EQUALS:
Result = leftValue == rightValue;
break;
case OPERATOR_GREATER_OR_EQUALS:
Result = leftValue >= rightValue;
break;
case OPERATOR_GREATER_THAN:
Result = leftValue > rightValue;
break;
case OPERATOR_LESSER_OR_EQUALS:
Result = leftValue <= rightValue;
break;
case OPERATOR_LESSER_THAN:
Result = leftValue < rightValue;
break;
case OPERATOR_MULTIPLY:
Result = leftValue * rightValue;
break;
case OPERATOR_SUB:
Result = leftValue - rightValue;
break;
case OPERATOR_SUM:
Result = leftValue + rightValue;
break;
case OPERATOR_UNEQUAL:
Result = leftValue != rightValue;
break;
}
Otherwise, regardless of what expression->type evaluates to (as long as it evaluates to one of the label expressions), it will eventually execute the final statement, Result = leftValue != rightValue;.