Skip to content

Commit

Permalink
fix: Fixed memory leaks from AST and Parser
Browse files Browse the repository at this point in the history
  • Loading branch information
@alinalihassan
alinalihassan committed Sep 8, 2022
1 parent 62c7dfd commit a029292
Show file tree
Hide file tree
Showing 3 changed files with 105 additions and 40 deletions.
140 changes: 101 additions & 39 deletions src/liblesma/AST/AST.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -53,7 +53,6 @@ namespace lesma {
public:
Literal(llvm::SMRange Loc, std::string value, TokenType type) : Expression(Loc), value(std::move(value)),
type(type) {}

~Literal() override = default;

[[nodiscard]] [[maybe_unused]] std::string getValue() const { return value; }
Expand All @@ -76,7 +75,10 @@ namespace lesma {
public:
explicit Compound(llvm::SMRange Loc) : Statement(Loc) {}
explicit Compound(llvm::SMRange Loc, std::vector<Statement *> children) : Statement(Loc), children(std::move(children)) {}
~Compound() override = default;
~Compound() override {
for (auto stmt: children)
delete stmt;
}

[[nodiscard]] [[maybe_unused]] std::vector<Statement *> getChildren() const { return children; }

Expand Down Expand Up @@ -112,7 +114,13 @@ namespace lesma {
Type(llvm::SMRange Loc, std::string name, TokenType type) : Expression(Loc), name(std::move(name)), type(type), elementType(nullptr), ret(nullptr) {}
Type(llvm::SMRange Loc, std::string name, TokenType type, Type *elementType) : Expression(Loc), name(std::move(name)), type(type), elementType(elementType), ret(nullptr) {}
Type(llvm::SMRange Loc, std::string name, TokenType type, std::vector<Type *> params, Type *ret) : Expression(Loc), name(std::move(name)), type(type), elementType(nullptr), params(std::move(params)), ret(ret) {}
~Type() override = default;
~Type() override {
for (auto param: params)
delete param;

delete ret;
delete elementType;
}

[[nodiscard]] [[maybe_unused]] std::string getName() const { return name; }
[[nodiscard]] [[maybe_unused]] TokenType getType() const { return type; }
Expand Down Expand Up @@ -193,7 +201,13 @@ namespace lesma {

public:
VarDecl(llvm::SMRange Loc, Literal *var, std::optional<Type *> type, std::optional<Expression *> expr, bool readonly) : Statement(Loc), var(var), type(type), expr(expr), mutable_(readonly) {}
~VarDecl() override = default;
~VarDecl() override {
delete var;
if (type.has_value())
delete type.value();
if (expr.has_value())
delete expr.value();
}

[[nodiscard]] [[maybe_unused]] Literal *getIdentifier() const { return var; }
[[nodiscard]] [[maybe_unused]] std::optional<Type *> getType() const { return type; }
Expand All @@ -219,12 +233,14 @@ namespace lesma {

public:
If(llvm::SMRange Loc, std::vector<Expression *> conds, std::vector<Compound *> blocks) : Statement(Loc),
conds(std::move(
conds)),
blocks(std::move(
blocks)) {}

~If() override = default;
conds(std::move(conds)),
blocks(std::move(blocks)) {}
~If() override {
for (auto cond: conds)
delete cond;
for (auto block: blocks)
delete block;
}

[[nodiscard]] [[maybe_unused]] std::vector<Expression *> getConds() const { return conds; }
[[nodiscard]] [[maybe_unused]] std::vector<Compound *> getBlocks() const { return blocks; }
Expand Down Expand Up @@ -252,7 +268,13 @@ namespace lesma {

public:
While(llvm::SMRange Loc, Expression *cond, Compound *block) : Statement(Loc), cond(cond), block(block) {}
~While() override = default;
~While() override {
for (auto stmt: block->getChildren())
delete stmt;

delete cond;
delete block;
}

[[nodiscard]] [[maybe_unused]] Expression *getCond() const { return cond; }
[[nodiscard]] [[maybe_unused]] Compound *getBlock() const { return block; }
Expand All @@ -271,11 +293,19 @@ namespace lesma {
}
};

struct Parameter {
class Parameter {
public:
std::string name;
Type *type;
bool optional = false;
Expression *default_val = nullptr;
bool optional;
Expression *default_val;

Parameter(std::string name, Type *type, bool optional = false, Expression *default_val = nullptr) : name(name), type(type), optional(optional), default_val(default_val) {}

~Parameter() {
delete type;
delete default_val;
}
};

class FuncDecl : public Statement {
Expand All @@ -290,8 +320,13 @@ namespace lesma {
FuncDecl(llvm::SMRange Loc, std::string name, Type *return_type,
std::vector<Parameter *> parameters, Compound *body, bool varargs, bool exported) : Statement(Loc), name(std::move(name)), return_type(return_type), parameters(std::move(parameters)),
body(body), varargs(varargs), exported(exported) {}
~FuncDecl() override {
for (auto param: parameters)
delete param;

~FuncDecl() override = default;
delete return_type;
delete body;
}

[[nodiscard]] [[maybe_unused]] std::string getName() const { return name; }
[[nodiscard]] [[maybe_unused]] Type *getReturnType() const { return return_type; }
Expand Down Expand Up @@ -332,7 +367,12 @@ namespace lesma {
ExternFuncDecl(llvm::SMRange Loc, std::string name, Type *return_type,
std::vector<Parameter *> parameters, bool varargs, bool exported) : Statement(Loc), name(std::move(name)), return_type(return_type), parameters(std::move(parameters)), varargs(varargs), exported(exported) {}

~ExternFuncDecl() override = default;
~ExternFuncDecl() override {
for (auto param: parameters)
delete param;

delete return_type;
}

[[nodiscard]] [[maybe_unused]] std::string getName() const { return name; }
[[nodiscard]] [[maybe_unused]] Type *getReturnType() const { return return_type; }
Expand Down Expand Up @@ -366,8 +406,10 @@ namespace lesma {

public:
FuncCall(llvm::SMRange Loc, std::string name, std::vector<Expression *> arguments) : Expression(Loc), name(std::move(name)), arguments(std::move(arguments)) {}

~FuncCall() override = default;
~FuncCall() override {
for (auto arg: arguments)
delete arg;
}

[[nodiscard]] [[maybe_unused]] std::string getName() const { return name; }
[[nodiscard]] [[maybe_unused]] std::vector<Expression *> getArguments() const { return arguments; }
Expand All @@ -390,8 +432,10 @@ namespace lesma {

public:
Assignment(llvm::SMRange Loc, Expression *lhs, TokenType op, Expression *rhs) : Statement(Loc), lhs(lhs), op(op), rhs(rhs) {}

~Assignment() override = default;
~Assignment() override {
delete lhs;
delete rhs;
}

[[nodiscard]] [[maybe_unused]] Expression *getLeftHandSide() const { return lhs; }
[[nodiscard]] [[maybe_unused]] TokenType getOperator() const { return op; }
Expand All @@ -415,7 +459,9 @@ namespace lesma {

public:
ExpressionStatement(llvm::SMRange Loc, Expression *expr) : Statement(Loc), expr(expr) {}
~ExpressionStatement() override = default;
~ExpressionStatement() override {
delete expr;
}

[[nodiscard]] [[maybe_unused]] Expression *getExpression() const { return expr; }

Expand All @@ -436,10 +482,11 @@ namespace lesma {
Expression *right;

public:
BinaryOp(llvm::SMRange Loc, Expression *left, TokenType op, Expression *right) : Expression(Loc), left(left),
op(op), right(right) {}

~BinaryOp() override = default;
BinaryOp(llvm::SMRange Loc, Expression *left, TokenType op, Expression *right) : Expression(Loc), left(left), op(op), right(right) {}
~BinaryOp() override {
delete left;
delete right;
}

[[nodiscard]] [[maybe_unused]] Expression *getLeft() const { return left; }
[[nodiscard]] [[maybe_unused]] TokenType getOperator() const { return op; }
Expand All @@ -456,10 +503,11 @@ namespace lesma {
Type *right;

public:
IsOp(llvm::SMRange Loc, Expression *left, TokenType op, Type *right) : Expression(Loc), left(left),
op(op), right(right) {}

~IsOp() override = default;
IsOp(llvm::SMRange Loc, Expression *left, TokenType op, Type *right) : Expression(Loc), left(left), op(op), right(right) {}
~IsOp() override {
delete left;
delete right;
}

[[nodiscard]] [[maybe_unused]] Expression *getLeft() const { return left; }
[[nodiscard]] [[maybe_unused]] TokenType getOperator() const { return op; }
Expand All @@ -476,8 +524,10 @@ namespace lesma {

public:
CastOp(llvm::SMRange Loc, Expression *expr, Type *type) : Expression(Loc), expr(expr), type(type) {}

~CastOp() override = default;
~CastOp() override {
delete expr;
delete type;
}

[[nodiscard]] [[maybe_unused]] Expression *getExpression() const { return expr; }
[[nodiscard]] [[maybe_unused]] Type *getType() const { return type; }
Expand All @@ -493,7 +543,9 @@ namespace lesma {

public:
UnaryOp(llvm::SMRange Loc, TokenType op, Expression *expr) : Expression(Loc), op(op), expr(expr) {}
~UnaryOp() override = default;
~UnaryOp() override {
delete expr;
}

[[nodiscard]] [[maybe_unused]] TokenType getOperator() const { return op; }
[[nodiscard]] [[maybe_unused]] Expression *getExpression() const { return expr; }
Expand All @@ -509,10 +561,11 @@ namespace lesma {
Expression *right;

public:
DotOp(llvm::SMRange Loc, Expression *left, TokenType op, Expression *right) : Expression(Loc), left(left),
op(op), right(right) {}

~DotOp() override = default;
DotOp(llvm::SMRange Loc, Expression *left, TokenType op, Expression *right) : Expression(Loc), left(left), op(op), right(right) {}
~DotOp() override {
delete left;
delete right;
}

[[nodiscard]] [[maybe_unused]] Expression *getLeft() const { return left; }
[[nodiscard]] [[maybe_unused]] TokenType getOperator() const { return op; }
Expand Down Expand Up @@ -568,7 +621,9 @@ namespace lesma {

public:
Return(llvm::SMRange Loc, Expression *value) : Statement(Loc), value(value) {}
~Return() override = default;
~Return() override {
delete value;
}

[[nodiscard]] [[maybe_unused]] Expression *getValue() const { return value; }

Expand All @@ -588,7 +643,9 @@ namespace lesma {

public:
Defer(llvm::SMRange Loc, Statement *stmt) : Statement(Loc), stmt(stmt) {}
~Defer() override = default;
~Defer() override {
delete stmt;
}

[[nodiscard]] [[maybe_unused]] Statement *getStatement() const { return stmt; }

Expand All @@ -611,7 +668,12 @@ namespace lesma {

public:
Class(llvm::SMRange Loc, std::string identifier, std::vector<VarDecl *> fields, std::vector<FuncDecl *> methods, bool exported) : Statement(Loc), identifier(std::move(identifier)), fields(std::move(fields)), methods(std::move(methods)), exported(exported){};
~Class() override = default;
~Class() override {
for (auto field: fields)
delete field;
for (auto method: methods)
delete method;
}

[[nodiscard]] [[maybe_unused]] std::string getIdentifier() const { return identifier; }
[[nodiscard]] [[maybe_unused]] std::vector<VarDecl *> getFields() const { return fields; }
Expand Down
2 changes: 1 addition & 1 deletion src/liblesma/Frontend/Parser.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -480,7 +480,7 @@ Statement *Parser::ParseFunctionDeclaration() {
auto param_ident = Consume(TokenType::IDENTIFIER);
Consume(TokenType::COLON);
auto type = ParseType();
parameters.emplace_back(new Parameter{param_ident->lexeme, type});
parameters.emplace_back(new Parameter(param_ident->lexeme, type));
}

if (!Check(TokenType::RIGHT_PAREN) && !Check(TokenType::RIGHT_PAREN, 1))
Expand Down
3 changes: 3 additions & 0 deletions src/liblesma/Frontend/Parser.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -15,6 +15,9 @@ namespace lesma {
class Parser {
public:
explicit Parser(std::vector<Token *> tokens) : tokens(std::move(tokens)), index(0), tree(nullptr) {}
~Parser() {
delete tree;
}

void Parse();

Expand Down

0 comments on commit a029292

Please sign in to comment.