//
// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
//
// The contents of this file are covered under the licence agreement in the
// file "LICENCE" distributed with Cforall.
//
// Stmt.hpp --
//
// Author           : Aaron B. Moss
// Created On       : Wed May  8 13:00:00 2019
// Last Modified By : Andrew Beach
// Last Modified On : Wed Apr  5 10:34:00 2023
// Update Count     : 37
//

#pragma once

#include <list>
#include <utility>										// for move
#include <vector>

#include "Label.hpp"
#include "Node.hpp"										// for node, ptr
#include "ParseNode.hpp"
#include "Visitor.hpp"
#include "Common/CodeLocation.hpp"

// Must be included in *all* AST classes; should be #undef'd at the end of the file
#define MUTATE_FRIEND													\
	template<typename node_t> friend node_t * mutate(const node_t * node); \
	template<typename node_t> friend node_t * shallowCopy(const node_t * node);

namespace ast {
class Expr;

// Base statement node
class Stmt : public ParseNode {
  public:
	std::vector<Label> labels;

	Stmt( const CodeLocation & loc, const std::vector<Label> && labels = {} )
		: ParseNode(loc), labels(std::move(labels)) {}

	Stmt(const Stmt & o) : ParseNode(o), labels(o.labels) {}

	const Stmt * accept( Visitor & v ) const override = 0;
  private:
	Stmt * clone() const override = 0;
	MUTATE_FRIEND
};

// Base statement component node (only serves to group them).
class StmtClause : public ParseNode {
  public:
	// This is for non-statements that still belong with the statements,
	// but are not statements, usually some sort of clause. Often these can
	// (and should) be folded into the approprate parent node, but if they
	// cannot be, they are sub-types of this type, for organization.

	StmtClause( const CodeLocation & loc )
		: ParseNode(loc) {}

  private:
	StmtClause * clone() const override = 0;
	MUTATE_FRIEND
};

// Compound statement: { ... }
class CompoundStmt final : public Stmt {
  public:
	std::list<ptr<Stmt>> kids;

	CompoundStmt(const CodeLocation & loc, const std::list<ptr<Stmt>> && ks = {}, const std::vector<Label> && labels = {} )
		: Stmt(loc, std::move(labels)), kids(std::move(ks)) {}

	CompoundStmt( const CompoundStmt & o );
	CompoundStmt( CompoundStmt && o ) = default;

	void push_back( const Stmt * s ) { kids.emplace_back( s ); }
	void push_front( const Stmt * s ) { kids.emplace_front( s ); }

	const CompoundStmt * accept( Visitor & v ) const override { return v.visit( this ); }
  private:
	CompoundStmt * clone() const override { return new CompoundStmt{ *this }; }
	MUTATE_FRIEND
};

// Empty statment: ;
class NullStmt final : public Stmt {
  public:
	NullStmt( const CodeLocation & loc, const std::vector<Label> && labels = {} )
		: Stmt(loc, std::move(labels)) {}

	const NullStmt * accept( Visitor & v ) const override { return v.visit( this ); }
  private:
	NullStmt * clone() const override { return new NullStmt{ *this }; }
	MUTATE_FRIEND
};

// Expression wrapped by statement
class ExprStmt final : public Stmt {
  public:
	ptr<Expr> expr;

	ExprStmt( const CodeLocation & loc, const Expr* e, const std::vector<Label> && labels = {} )
		: Stmt(loc, std::move(labels)), expr(e) {}

	const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
  private:
	ExprStmt * clone() const override { return new ExprStmt{ *this }; }
	MUTATE_FRIEND
};

// Assembly statement: asm ... ( "..." : ... )
class AsmStmt final : public Stmt {
  public:
	bool isVolatile;
	ptr<Expr> instruction;
	std::vector<ptr<Expr>> output, input;
	std::vector<ptr<ConstantExpr>> clobber;
	std::vector<Label> gotoLabels;

	AsmStmt( const CodeLocation & loc, bool isVolatile, const Expr * instruction,
			 const std::vector<ptr<Expr>> && output, const std::vector<ptr<Expr>> && input,
			 const std::vector<ptr<ConstantExpr>> && clobber, const std::vector<Label> && gotoLabels,
			 const std::vector<Label> && labels = {})
		: Stmt(loc, std::move(labels)), isVolatile(isVolatile), instruction(instruction),
		  output(std::move(output)), input(std::move(input)), clobber(std::move(clobber)),
		  gotoLabels(std::move(gotoLabels)) {}

	const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
  private:
	AsmStmt * clone() const override { return new AsmStmt{ *this }; }
	MUTATE_FRIEND
};

// C-preprocessor directive: #...
class DirectiveStmt final : public Stmt {
  public:
	std::string directive;

	DirectiveStmt( const CodeLocation & loc, const std::string & directive,
				   std::vector<Label> && labels = {} )
		: Stmt(loc, std::move(labels)), directive(directive) {}

	const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
  private:
	DirectiveStmt * clone() const override { return new DirectiveStmt{ *this }; }
	MUTATE_FRIEND
};

// If statement: if (...) ... else ...
class IfStmt final : public Stmt {
  public:
	ptr<Expr> cond;
	ptr<Stmt> then;
	ptr<Stmt> else_;
	std::vector<ptr<Stmt>> inits;

	IfStmt( const CodeLocation & loc, const Expr * cond, const Stmt * then,
			const Stmt * else_ = nullptr, const std::vector<ptr<Stmt>> && inits = {},
			const std::vector<Label> && labels = {} )
		: Stmt(loc, std::move(labels)), cond(cond), then(then), else_(else_),
		  inits(std::move(inits)) {}

	const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
  private:
	IfStmt * clone() const override { return new IfStmt{ *this }; }
	MUTATE_FRIEND
};

// Switch or choose statement: switch (...) { ... }
class SwitchStmt final : public Stmt {
  public:
	ptr<Expr> cond;
	std::vector<ptr<CaseClause>> cases;

	SwitchStmt( const CodeLocation & loc, const Expr * cond,
				const std::vector<ptr<CaseClause>> && cases,
				const std::vector<Label> && labels = {} )
		: Stmt(loc, std::move(labels)), cond(cond), cases(std::move(cases)) {}

	const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
  private:
	SwitchStmt * clone() const override { return new SwitchStmt{ *this }; }
	MUTATE_FRIEND
};

// Case label: case ...: or default:
class CaseClause final : public StmtClause {
  public:
	// Null for the default label.
	ptr<Expr> cond;
	std::vector<ptr<Stmt>> stmts;

	CaseClause( const CodeLocation & loc, const Expr * cond, const std::vector<ptr<Stmt>> && stmts )
		: StmtClause(loc), cond(cond), stmts(std::move(stmts)) {}

	bool isDefault() const { return !cond; }

	const CaseClause * accept( Visitor & v ) const override { return v.visit( this ); }
  private:
	CaseClause * clone() const override { return new CaseClause{ *this }; }
	MUTATE_FRIEND
};

// A while loop or a do-while loop:
enum WhileDoKind { While, DoWhile };

// While loop: while (...) ... else ... or do ... while (...) else ...;
class WhileDoStmt final : public Stmt {
  public:
	ptr<Expr> cond;
	ptr<Stmt> body;
	ptr<Stmt> else_;
	std::vector<ptr<Stmt>> inits;
	WhileDoKind isDoWhile;

	WhileDoStmt( const CodeLocation & loc, const Expr * cond, const Stmt * body,
				 const std::vector<ptr<Stmt>> && inits, WhileDoKind isDoWhile = While, const std::vector<Label> && labels = {} )
		: Stmt(loc, std::move(labels)), cond(cond), body(body), else_(nullptr), inits(std::move(inits)), isDoWhile(isDoWhile) {}

	WhileDoStmt( const CodeLocation & loc, const Expr * cond, const Stmt * body, const Stmt * else_,
				 const std::vector<ptr<Stmt>> && inits, WhileDoKind isDoWhile = While, const std::vector<Label> && labels = {} )
		: Stmt(loc, std::move(labels)), cond(cond), body(body), else_(else_), inits(std::move(inits)), isDoWhile(isDoWhile) {}

	const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
  private:
	WhileDoStmt * clone() const override { return new WhileDoStmt{ *this }; }
	MUTATE_FRIEND
};

// For loop: for (... ; ... ; ...) ... else ...
class ForStmt final : public Stmt {
  public:
	std::vector<ptr<Stmt>> inits;
	ptr<Expr> cond;
	ptr<Expr> inc;
	ptr<Expr> range_over;
	bool is_inc;
	ptr<Stmt> body;
	ptr<Stmt> else_;

	ForStmt( const CodeLocation & loc, const std::vector<ptr<Stmt>> && inits, const Expr * cond,
			 const Expr * inc, const Stmt * body, const std::vector<Label> && label = {} )
		: Stmt(loc, std::move(label)), inits(std::move(inits)), cond(cond), inc(inc),
			range_over(nullptr), body(body), else_(nullptr) {}

	ForStmt( const CodeLocation & loc, const std::vector<ptr<Stmt>> && inits, const Expr * cond,
			 const Expr * inc, const Stmt * body, const Stmt * else_, const std::vector<Label> && labels = {} )
		: Stmt(loc, std::move(labels)), inits(std::move(inits)), cond(cond), inc(inc),
			range_over(nullptr), body(body), else_(else_) {}

	ForStmt( const CodeLocation & loc, const std::vector<ptr<Stmt>> && inits, const Expr * range_over, bool is_inc,
			 const Stmt * body, const Stmt * else_ )
		: Stmt(loc, std::move(labels)), inits(std::move(inits)), range_over(range_over), is_inc(is_inc), 
		body(body), else_(else_) {}

	const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
  private:
	ForStmt * clone() const override { return new ForStmt{ *this }; }
	MUTATE_FRIEND
};

// Branch control flow statement: goto ... or break or continue or fallthru
class BranchStmt final : public Stmt {
  public:
	enum Kind { Goto, Break, Continue, FallThrough, FallThroughDefault };
	static constexpr size_t kindEnd = 1 + (size_t)FallThroughDefault;

	const Label originalTarget;
	Label target;
	ptr<Expr> computedTarget;
	Kind kind;

	BranchStmt( const CodeLocation & loc, Kind kind, Label target, const std::vector<Label> && labels = {} );
	BranchStmt( const CodeLocation & loc, const Expr * computedTarget, const std::vector<Label> && labels = {} )
		: Stmt(loc, std::move(labels)), originalTarget(loc), target(loc), computedTarget(computedTarget), kind(Goto) {}

	const char * kindName() const { return kindNames[kind]; }

	const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
  private:
	BranchStmt * clone() const override { return new BranchStmt{ *this }; }
	MUTATE_FRIEND

	static const char * kindNames[kindEnd];
};

// Return statement: return ...
class ReturnStmt final : public Stmt {
  public:
	ptr<Expr> expr;

	ReturnStmt( const CodeLocation & loc, const Expr * expr, const std::vector<Label> && labels = {} )
		: Stmt(loc, std::move(labels)), expr(expr) {}

	const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
  private:
	ReturnStmt * clone() const override { return new ReturnStmt{ *this }; }
	MUTATE_FRIEND
};

// Kind of exception
enum ExceptionKind { Terminate, Resume };

// Throw statement: throw ...
class ThrowStmt final : public Stmt {
  public:
	ptr<Expr> expr;
	ptr<Expr> target;
	ExceptionKind kind;

	ThrowStmt( const CodeLocation & loc, ExceptionKind kind, const Expr * expr,
			   const Expr * target, const std::vector<Label> && labels = {} )
		: Stmt(loc, std::move(labels)), expr(expr), target(target), kind(kind) {}

	const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
  private:
	ThrowStmt * clone() const override { return new ThrowStmt{ *this }; }
	MUTATE_FRIEND
};

// Try statement: try { ... } ...
class TryStmt final : public Stmt {
  public:
	ptr<CompoundStmt> body;
	std::vector<ptr<CatchClause>> handlers;
	ptr<FinallyClause> finally;

	TryStmt( const CodeLocation & loc, const CompoundStmt * body,
			 const std::vector<ptr<CatchClause>> && handlers, const FinallyClause * finally,
			 const std::vector<Label> && labels = {} )
		: Stmt(loc, std::move(labels)), body(body), handlers(std::move(handlers)), finally(finally) {}

	const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
  private:
	TryStmt * clone() const override { return new TryStmt{ *this }; }
	MUTATE_FRIEND
};

// Catch clause of try statement
class CatchClause final : public StmtClause {
  public:
	ptr<Decl> decl;
	ptr<Expr> cond;
	ptr<Stmt> body;
	ExceptionKind kind;

	CatchClause( const CodeLocation & loc, ExceptionKind kind, const Decl * decl, const Expr * cond,
			const Stmt * body )
		: StmtClause(loc), decl(decl), cond(cond), body(body), kind(kind) {}

	const CatchClause * accept( Visitor & v ) const override { return v.visit( this ); }
  private:
	CatchClause * clone() const override { return new CatchClause{ *this }; }
	MUTATE_FRIEND
};

// Finally clause of try statement
class FinallyClause final : public StmtClause {
  public:
	ptr<CompoundStmt> body;

	FinallyClause( const CodeLocation & loc, const CompoundStmt * body )
		: StmtClause(loc), body(body) {}

	const FinallyClause * accept( Visitor & v ) const override { return v.visit( this ); }
  private:
	FinallyClause * clone() const override { return new FinallyClause{ *this }; }
	MUTATE_FRIEND
};

// Suspend statement
class SuspendStmt final : public Stmt {
  public:
	ptr<CompoundStmt> then;
	enum Kind { None, Coroutine, Generator } kind = None;

	SuspendStmt( const CodeLocation & loc, const CompoundStmt * then, Kind kind, const std::vector<Label> && labels = {} )
		: Stmt(loc, std::move(labels)), then(then), kind(kind) {}

	const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
  private:
	SuspendStmt * clone() const override { return new SuspendStmt{ *this }; }
	MUTATE_FRIEND
};

// Base class of WaitFor/WaitUntil statements
// form: KEYWORD(...) ... timeout(...) ... else ...
class WaitStmt : public Stmt {
  public:
	ptr<Expr> timeout_time;
	ptr<Stmt> timeout_stmt;
	ptr<Expr> timeout_cond;
	ptr<Stmt> else_stmt;
	ptr<Expr> else_cond;

	WaitStmt( const CodeLocation & loc, const std::vector<Label> && labels = {} )
		: Stmt(loc, std::move(labels)) {}

  private:
	WaitStmt * clone() const override = 0;
	MUTATE_FRIEND
};

// Base class for WaitFor/WaitUntil clauses
// form: when( when_cond ) KEYWORD( target ) stmt
class WhenClause : public StmtClause {
  public:
	ptr<Expr> target;
	ptr<Stmt> stmt;
	ptr<Expr> when_cond;

	WhenClause( const CodeLocation & loc )
		: StmtClause( loc ) {}

	const WhenClause * accept( Visitor & v ) const override { return v.visit( this ); }
  private:
	WhenClause * clone() const override { return new WhenClause{ *this }; }
	MUTATE_FRIEND
};

// Waitfor statement: when (...) waitfor (... , ...) ... timeout(...) ... else ...
class WaitForStmt final : public WaitStmt {
  public:
	std::vector<ptr<WaitForClause>> clauses;

	WaitForStmt( const CodeLocation & loc, const std::vector<Label> && labels = {} )
		: WaitStmt(loc, std::move(labels)) {}

	const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
  private:
	WaitForStmt * clone() const override { return new WaitForStmt{ *this }; }
	MUTATE_FRIEND
};

// Clause in a waitfor statement: waitfor (..., ...) ...
class WaitForClause final : public WhenClause {
  public:
	std::vector<ptr<Expr>> target_args;

	WaitForClause( const CodeLocation & loc )
		: WhenClause( loc ) {}

	const WaitForClause * accept( Visitor & v ) const override { return v.visit( this ); }
  private:
	WaitForClause * clone() const override { return new WaitForClause{ *this }; }
	MUTATE_FRIEND
};

// waituntil statement: when (...) waituntil (...) ... timeout(...) ... else ...
class WaitUntilStmt final : public WaitStmt {
  public:
	// Non-ast node used during compilation to store data needed to generate predicates
	//    and set initial status values for clauses
	// Used to create a tree corresponding to the structure of the clauses in a WaitUntil
	struct ClauseNode {
		enum Op { AND, OR, LEFT_OR, LEAF, ELSE, TIMEOUT } op; // operation/type tag
		// LEFT_OR used with TIMEOUT/ELSE to indicate that we ignore right hand side after parsing

		ClauseNode * left;
		ClauseNode * right;
		WhenClause * leaf;  // only set if this node is a leaf (points into vector of clauses)

		bool ambiguousWhen; // used to paint nodes of predicate tree based on when() clauses
		bool whenState;     // used to track if when_cond is toggled on or off for generating init values
		bool childOfAnd;      // true on leaf nodes that are children of AND, false otherwise

		ClauseNode( Op op, ClauseNode * left, ClauseNode * right )
			: op(op), left(left), right(right), leaf(nullptr),
			ambiguousWhen(false), whenState(true), childOfAnd(false) {}
		ClauseNode( Op op, WhenClause * leaf )
			: op(op), left(nullptr), right(nullptr), leaf(leaf),
			ambiguousWhen(false), whenState(true), childOfAnd(false) {}
		ClauseNode( WhenClause * leaf ) : ClauseNode(LEAF, leaf) {}

		~ClauseNode() {
			if ( left ) delete left;
			if ( right ) delete right;
		}
	};

	std::vector<ptr<WhenClause>> clauses;
	ClauseNode * predicateTree;

	WaitUntilStmt( const CodeLocation & loc, const std::vector<Label> && labels = {} )
		: WaitStmt(loc, std::move(labels)) {}

	~WaitUntilStmt() { delete predicateTree; }

	const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
  private:
	WaitUntilStmt * clone() const override { return new WaitUntilStmt{ *this }; }
	MUTATE_FRIEND
};

// Any declaration in a (compound) statement.
class DeclStmt final : public Stmt {
  public:
	ptr<Decl> decl;

	DeclStmt( const CodeLocation & loc, const Decl * decl, const std::vector<Label> && labels = {} )
		: Stmt(loc, std::move(labels)), decl(decl) {}

	const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
  private:
	DeclStmt * clone() const override { return new DeclStmt{ *this }; }
	MUTATE_FRIEND
};

// Represents an implicit application of a constructor or destructor.
class ImplicitCtorDtorStmt final : public Stmt {
  public:
	ptr<Stmt> callStmt;

	ImplicitCtorDtorStmt( const CodeLocation & loc, const Stmt * callStmt,
						  std::vector<Label> && labels = {} )
		: Stmt(loc, std::move(labels)), callStmt(callStmt) {}

	const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
  private:
	ImplicitCtorDtorStmt * clone() const override { return new ImplicitCtorDtorStmt{ *this }; }
	MUTATE_FRIEND
};

// Mutex Statement
class MutexStmt final : public Stmt {
  public:
	ptr<Stmt> stmt;
	std::vector<ptr<Expr>> mutexObjs;

	MutexStmt( const CodeLocation & loc, const Stmt * stmt,
			   const std::vector<ptr<Expr>> && mutexes, const std::vector<Label> && labels = {} )
		: Stmt(loc, std::move(labels)), stmt(stmt), mutexObjs(std::move(mutexes)) {}

	const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
  private:
	MutexStmt * clone() const override { return new MutexStmt{ *this }; }
	MUTATE_FRIEND
};

// Corun Statement
class CorunStmt final : public Stmt {
  public:
	ptr<Stmt> stmt;

	CorunStmt( const CodeLocation & loc, const Stmt * stmt, const std::vector<Label> && labels = {} )
		: Stmt(loc, std::move(labels)), stmt(stmt) {}

	const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
  private:
	CorunStmt * clone() const override { return new CorunStmt{ *this }; }
	MUTATE_FRIEND
};

// Corun Statement
class CoforStmt final : public Stmt {
  public:
	std::vector<ptr<Stmt>> inits;
	ptr<Expr> cond;
	ptr<Expr> inc;
	ptr<Stmt> body;

	CoforStmt( const CodeLocation & loc, const std::vector<ptr<Stmt>> && inits, const Expr * cond,
			 const Expr * inc, const Stmt * body, const std::vector<Label> && label = {} )
		: Stmt(loc, std::move(label)), inits(std::move(inits)), cond(cond), inc(inc), body(body) {}

	const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
  private:
	CoforStmt * clone() const override { return new CoforStmt{ *this }; }
	MUTATE_FRIEND
};

} // namespace ast

#undef MUTATE_FRIEND

// Local Variables: //
// mode: c++ //
// End: //