ast.h

Go to the documentation of this file.

#pragma once
 
#include "error.h"
 
#include <vector>
#include <string>
#include <optional>
#include <memory>
#include <ranges>
 
namespace picceler {
 
template <typename T> auto getRawPointers(const std::vector<std::unique_ptr<T>> &vec) {
  return vec | std::views::transform([](const std::unique_ptr<T> &ptr) { return ptr.get(); });
}

class ASTNode {
public:
  ASTNode() : _location() {}
  virtual ~ASTNode() = default;
  ASTNode(Location loc) : _location(loc) {}
 
  ASTNode(const ASTNode &) = delete;
  ASTNode &operator=(const ASTNode &) = delete;
  ASTNode(ASTNode &&) = default;
  ASTNode &operator=(ASTNode &&) = default;
 
  virtual std::string toString() const = 0;
 
  Location location() const { return _location; }
 
private:
  Location _location;
};

 
class ModuleNode : public ASTNode {
public:
  ModuleNode(Location loc) : ASTNode(loc), _statements() {}
 
  auto statements() const { return getRawPointers(_statements); }
 
  void normalizeTopLevelStatements();
 
  bool wrapTopLevelStatementsInMain();
  void addStatement(std::unique_ptr<ASTNode> statement) { _statements.push_back(std::move(statement)); }
 
  std::string toString() const override;
 
private:
  std::vector<std::unique_ptr<ASTNode>> _statements;
};

class FunctionNode : public ASTNode {
public:
  FunctionNode(Location loc, std::string name) : ASTNode(loc), _name(std::move(name)) {}
 
  const std::string &name() const { return _name; }
  const auto &parameters() const { return _parameters; }
  auto body() const { return getRawPointers(_body); }
  const std::optional<std::string> &returnType() const { return _returnType; }
 
  void addParameter(const std::string &paramName, const std::string &paramType) {
    _parameters.emplace_back(paramName, paramType);
  }
 
  void addBodyStatement(std::unique_ptr<ASTNode> statement) { _body.push_back(std::move(statement)); }
 
  void setReturnType(std::string returnType) { _returnType = std::move(returnType); }
 
  std::string toString() const override;
 
private:
  std::string _name;
  std::vector<std::pair<std::string, std::string>> _parameters;
  std::vector<std::unique_ptr<ASTNode>> _body;
  std::optional<std::string> _returnType;
};

class VariableNode : public ASTNode {
public:
  VariableNode(Location loc, std::string name, std::string type = "unspecified")
      : ASTNode(loc), _name(std::move(name)), _type(std::move(type)) {}
 
  const std::string &name() const { return _name; }
  const std::string &type() const { return _type; }
 
  std::string toString() const override;
 
private:
  std::string _name;
  std::string _type;
};

class StringNode : public ASTNode {
public:
  StringNode(Location loc, std::string value) : ASTNode(loc), _value(std::move(value)) {}
 
  const std::string &value() const { return _value; }
 
  std::string toString() const override;
 
private:
  std::string _value;
};

class NumberNode : public ASTNode {
public:
  NumberNode(Location loc, double value) : ASTNode(loc), _value(value) {}
 
  double value() const { return _value; }
 
  std::string toString() const override;
 
private:
  double _value;
};

class AssignmentNode : public ASTNode {
public:
  AssignmentNode(Location loc, std::unique_ptr<VariableNode> lhs, std::unique_ptr<ASTNode> rhs)
      : ASTNode(loc), _lhs(std::move(lhs)), _rhs(std::move(rhs)) {}
 
  VariableNode *lhs() const { return _lhs.get(); }
  ASTNode *rhs() const { return _rhs.get(); }
 
  std::string toString() const override;
 
private:
  std::unique_ptr<VariableNode> _lhs;
  std::unique_ptr<ASTNode> _rhs;
};

class CallNode : public ASTNode {
public:
  CallNode(Location loc, std::string callee) : ASTNode(loc), _callee(std::move(callee)), _arguments() {}
 
  const std::string &callee() const { return _callee; }
  auto arguments() const { return getRawPointers(_arguments); }
 
  void addArgument(std::unique_ptr<ASTNode> arg) { _arguments.push_back(std::move(arg)); }
 
  std::string toString() const override;
 
private:
  std::string _callee;
  std::vector<std::unique_ptr<ASTNode>> _arguments;
};

 
class KernelNode : public ASTNode {
public:
  KernelNode(Location loc) : ASTNode(loc), _rows() {}
  const std::vector<std::vector<double>> &rows() const { return _rows; }
 
  void addRow(const std::vector<double> &row) { _rows.push_back(row); }
 
  std::string toString() const override;
 
private:
  std::vector<std::vector<double>> _rows;
};

class BinaryOpNode : public ASTNode {
public:
  BinaryOpNode(Location loc, std::string op, std::unique_ptr<ASTNode> lhs, std::unique_ptr<ASTNode> rhs)
      : ASTNode(loc), _op(std::move(op)), _lhs(std::move(lhs)), _rhs(std::move(rhs)) {}
 
  const std::string &op() const { return _op; }
  ASTNode *lhs() const { return _lhs.get(); }
  ASTNode *rhs() const { return _rhs.get(); }
 
  std::string toString() const override;
 
private:
  std::string _op;
  std::unique_ptr<ASTNode> _lhs;
  std::unique_ptr<ASTNode> _rhs;
};

class IfNode : public ASTNode {
public:
  IfNode(Location loc, std::unique_ptr<ASTNode> condition, std::vector<std::unique_ptr<ASTNode>> body,
         std::vector<std::unique_ptr<ASTNode>> elseBody = {})
      : ASTNode(loc), _condition(std::move(condition)), _body(std::move(body)), _elseBody(std::move(elseBody)) {}
 
  ASTNode *condition() const { return _condition.get(); }
  auto body() const { return getRawPointers(_body); }
  auto elseBody() const { return getRawPointers(_elseBody); }
 
  std::string toString() const override;
 
private:
  std::unique_ptr<ASTNode> _condition;
  std::vector<std::unique_ptr<ASTNode>> _body;
  std::vector<std::unique_ptr<ASTNode>> _elseBody;
};

class ForNode : public ASTNode {
public:
  ForNode(Location loc, std::string varName, std::unique_ptr<ASTNode> lowerBound, std::unique_ptr<ASTNode> upperBound,
          std::unique_ptr<ASTNode> step, std::vector<std::unique_ptr<ASTNode>> body)
      : ASTNode(loc), _varName(std::move(varName)), _lowerBound(std::move(lowerBound)),
        _upperBound(std::move(upperBound)), _step(std::move(step)), _body(std::move(body)) {}
 
  const std::string &varName() const { return _varName; }
  ASTNode *lowerBound() const { return _lowerBound.get(); }
  ASTNode *upperBound() const { return _upperBound.get(); }
  ASTNode *step() const { return _step.get(); }
  const std::vector<std::unique_ptr<ASTNode>> &body() const { return _body; }
 
  std::string toString() const override;
 
private:
  std::string _varName;
  std::unique_ptr<ASTNode> _lowerBound;
  std::unique_ptr<ASTNode> _upperBound;
  std::unique_ptr<ASTNode> _step;
  std::vector<std::unique_ptr<ASTNode>> _body;
};

class ReturnNode : public ASTNode {
public:
  ReturnNode(Location loc, std::unique_ptr<ASTNode> returnValue) : ASTNode(loc), _returnValue(std::move(returnValue)) {}
 
  ASTNode *returnValue() const { return _returnValue.get(); }
 
  std::string toString() const override;
 
private:
  std::unique_ptr<ASTNode> _returnValue;
};
 
} // namespace picceler