//
// 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.
//
// StatementNode.cc -- Transform from parse data-structures to AST data-structures, usually deleting the parse
//     data-structure after the transformation.
//
// Author           : Rodolfo G. Esteves
// Created On       : Sat May 16 14:59:41 2015
// Last Modified By : Peter A. Buhr
// Last Modified On : Fri Aug 11 11:44:15 2023
// Update Count     : 429
//

#include "StatementNode.h"

#include <cassert>                 // for assert, strict_dynamic_cast, assertf
#include <memory>                  // for unique_ptr
#include <string>                  // for string

#include "AST/Label.hpp"           // for Label
#include "AST/Stmt.hpp"            // for Stmt, AsmStmt, BranchStmt, CaseCla...
#include "Common/SemanticError.h"  // for SemanticError
#include "Common/utility.h"        // for maybeMoveBuild, maybeBuild
#include "DeclarationNode.h"       // for DeclarationNode
#include "ExpressionNode.h"        // for ExpressionNode
#include "parserutility.h"         // for notZeroExpr

class Declaration;

using namespace std;

// Some helpers for cases that really want a single node but check for lists.
static const ast::Stmt * buildMoveSingle( StatementNode * node ) {
	std::vector<ast::ptr<ast::Stmt>> list;
	buildMoveList( node, list );
	assertf( list.size() == 1, "CFA Internal Error: Extra/Missing Nodes" );
	return list.front().release();
}

static const ast::Stmt * buildMoveOptional( StatementNode * node ) {
	std::vector<ast::ptr<ast::Stmt>> list;
	buildMoveList( node, list );
	assertf( list.size() <= 1, "CFA Internal Error: Extra Nodes" );
	return list.empty() ? nullptr : list.front().release();
}

StatementNode::StatementNode( DeclarationNode * decl ) {
	assert( decl );
	DeclarationNode * agg = decl->extractAggregate();
	if ( agg ) {
		StatementNode * nextStmt = new StatementNode(
			new ast::DeclStmt( decl->location, maybeBuild( decl ) ) );
		set_next( nextStmt );
		if ( decl->get_next() ) {
			get_next()->set_next( new StatementNode( dynamic_cast< DeclarationNode * >(decl->get_next()) ) );
			decl->set_next( 0 );
		} // if
	} else {
		if ( decl->get_next() ) {
			set_next( new StatementNode( dynamic_cast< DeclarationNode * >( decl->get_next() ) ) );
			decl->set_next( 0 );
		} // if
		agg = decl;
	} // if
	// Local copy to avoid accessing the pointer after it is moved from.
	CodeLocation declLocation = agg->location;
	stmt.reset( new ast::DeclStmt( declLocation, maybeMoveBuild( agg ) ) );
} // StatementNode::StatementNode

StatementNode * StatementNode::add_label(
		const CodeLocation & location,
		const std::string * name,
		DeclarationNode * attr ) {
	stmt->labels.emplace_back( location,
		*name,
		attr ? std::move( attr->attributes )
			: std::vector<ast::ptr<ast::Attribute>>{} );
	delete attr;
	delete name;
	return this;
}

ClauseNode * ClauseNode::append_last_case( StatementNode * stmt ) {
	ClauseNode * prev = this;
	// find end of list and maintain previous pointer
	for ( ClauseNode * curr = prev; curr != nullptr; curr = (ClauseNode *)curr->get_next() ) {
		ClauseNode * node = strict_dynamic_cast< ClauseNode * >(curr);
		assert( dynamic_cast<ast::CaseClause *>( node->clause.get() ) );
		prev = curr;
	} // for
	ClauseNode * node = dynamic_cast< ClauseNode * >(prev);
	// convert from StatementNode list to Statement list
	std::vector<ast::ptr<ast::Stmt>> stmts;
	buildMoveList( stmt, stmts );
	// splice any new Statements to end of current Statements
	auto caseStmt = strict_dynamic_cast<ast::CaseClause *>( node->clause.get() );
	for ( auto const & newStmt : stmts ) {
		caseStmt->stmts.emplace_back( newStmt );
	}
	stmts.clear();
	return this;
} // ClauseNode::append_last_case

ast::Stmt * build_expr( CodeLocation const & location, ExpressionNode * ctl ) {
	if ( ast::Expr * e = maybeMoveBuild( ctl ) ) {
		return new ast::ExprStmt( location, e );
	} else {
		return new ast::NullStmt( location );
	}
} // build_expr

static ast::Expr * build_if_control( CondCtl * ctl,
		std::vector<ast::ptr<ast::Stmt>> & inits ) {
	assert( inits.empty() );
	if ( nullptr != ctl->init ) {
		buildMoveList( ctl->init, inits );
	} // if

	ast::Expr * cond = nullptr;
	if ( ctl->condition ) {
		// compare the provided condition against 0
		cond = notZeroExpr( maybeMoveBuild( ctl->condition ) );
	} else {
		for ( ast::ptr<ast::Stmt> & stmt : inits ) {
			// build the && of all of the declared variables compared against 0
			auto declStmt = stmt.strict_as<ast::DeclStmt>();
			auto dwt = declStmt->decl.strict_as<ast::DeclWithType>();
			ast::Expr * nze = notZeroExpr( new ast::VariableExpr( dwt->location, dwt ) );
			cond = cond ? new ast::LogicalExpr( dwt->location, cond, nze, ast::AndExpr ) : nze;
		}
	}
	delete ctl;
	return cond;
} // build_if_control

ast::Stmt * build_if( const CodeLocation & location, CondCtl * ctl, StatementNode * then, StatementNode * else_ ) {
	std::vector<ast::ptr<ast::Stmt>> astinit;						// maybe empty
	ast::Expr * astcond = build_if_control( ctl, astinit ); // ctl deleted, cond/init set

	ast::Stmt const * astthen = buildMoveSingle( then );
	ast::Stmt const * astelse = buildMoveOptional( else_ );

	return new ast::IfStmt( location, astcond, astthen, astelse,
		std::move( astinit )
	);
} // build_if

ast::Stmt * build_switch( const CodeLocation & location, bool isSwitch, ExpressionNode * ctl, ClauseNode * stmt ) {
	std::vector<ast::ptr<ast::CaseClause>> aststmt;
	buildMoveList( stmt, aststmt );
	// If it is not a switch it is a choose statement.
	if ( ! isSwitch ) {
		for ( ast::ptr<ast::CaseClause> & stmt : aststmt ) {
			// Code after "case" is the end of case list.
			if ( !stmt->stmts.empty() ) {
				auto mutStmt = ast::mutate( stmt.get() );
				// I believe the stmts are actually always one block.
				auto stmts = mutStmt->stmts.front().get_and_mutate();
				auto block = strict_dynamic_cast<ast::CompoundStmt *>( stmts );
				block->kids.push_back( new ast::BranchStmt( block->location,
					ast::BranchStmt::Break,
					ast::Label( block->location ) ) );
				stmt = mutStmt;
			} // if
		} // for
	} // if
	// aststmt.size() == 0 for switch (...) {}, i.e., no declaration or statements
	return new ast::SwitchStmt( location,
		maybeMoveBuild( ctl ), std::move( aststmt ) );
} // build_switch

ast::CaseClause * build_case( const CodeLocation & location, ExpressionNode * ctl ) {
	// stmt starts empty and then added to
	auto expr = maybeMoveBuild( ctl );
	return new ast::CaseClause( location, expr, {} );
} // build_case

ast::CaseClause * build_default( const CodeLocation & location ) {
	// stmt starts empty and then added to
	return new ast::CaseClause( location, nullptr, {} );
} // build_default

ast::Stmt * build_while( const CodeLocation & location, CondCtl * ctl, StatementNode * stmt, StatementNode * else_ ) {
	std::vector<ast::ptr<ast::Stmt>> astinit;						// maybe empty
	ast::Expr * astcond = build_if_control( ctl, astinit ); // ctl deleted, cond/init set

	return new ast::WhileDoStmt( location,
		astcond,
		buildMoveSingle( stmt ),
		buildMoveOptional( else_ ),
		std::move( astinit ),
		ast::While
	);
} // build_while

ast::Stmt * build_do_while( const CodeLocation & location, ExpressionNode * ctl, StatementNode * stmt, StatementNode * else_ ) {
	// do-while cannot have declarations in the contitional, so init is always empty
	return new ast::WhileDoStmt( location,
		notZeroExpr( maybeMoveBuild( ctl ) ),
		buildMoveSingle( stmt ),
		buildMoveOptional( else_ ),
		{},
		ast::DoWhile
	);
} // build_do_while

ast::Stmt * build_for( const CodeLocation & location, ForCtrl * forctl, StatementNode * stmt, StatementNode * else_ ) {
	std::vector<ast::ptr<ast::Stmt>> astinit;						// maybe empty
	buildMoveList( forctl->init, astinit );

	ast::Expr * astcond = nullptr;						// maybe empty
	astcond = notZeroExpr( maybeMoveBuild( forctl->condition ) );

	ast::Expr * astincr = nullptr;						// maybe empty
	astincr = maybeMoveBuild( forctl->change );
	delete forctl;

	return new ast::ForStmt( location,
		std::move( astinit ),
		astcond,
		astincr,
		buildMoveSingle( stmt ),
		buildMoveOptional( else_ )
	);
} // build_for

ast::Stmt * build_branch( const CodeLocation & location, ast::BranchStmt::Kind kind ) {
	return new ast::BranchStmt( location,
		kind,
		ast::Label( location )
	);
} // build_branch

ast::Stmt * build_branch( const CodeLocation & location, string * identifier, ast::BranchStmt::Kind kind ) {
	ast::Stmt * ret = new ast::BranchStmt( location,
		kind,
		ast::Label( location, *identifier )
	);
	delete identifier; 									// allocated by lexer
	return ret;
} // build_branch

ast::Stmt * build_computedgoto( ExpressionNode * ctl ) {
	ast::Expr * expr = maybeMoveBuild( ctl );
	return new ast::BranchStmt( expr->location, expr );
} // build_computedgoto

ast::Stmt * build_return( const CodeLocation & location, ExpressionNode * ctl ) {
	std::vector<ast::ptr<ast::Expr>> exps;
	buildMoveList( ctl, exps );
	return new ast::ReturnStmt( location,
		exps.size() > 0 ? exps.back().release() : nullptr
	);
} // build_return

static ast::Stmt * build_throw_stmt(
		const CodeLocation & location,
		ExpressionNode * ctl,
		ast::ExceptionKind kind ) {
	std::vector<ast::ptr<ast::Expr>> exps;
	buildMoveList( ctl, exps );
	assertf( exps.size() < 2, "CFA internal error: leaking memory" );
	return new ast::ThrowStmt( location,
		kind,
		!exps.empty() ? exps.back().release() : nullptr,
		(ast::Expr *)nullptr
	);
}

ast::Stmt * build_throw( const CodeLocation & loc, ExpressionNode * ctl ) {
	return build_throw_stmt( loc, ctl, ast::Terminate );
} // build_throw

ast::Stmt * build_resume( const CodeLocation & loc, ExpressionNode * ctl ) {
	return build_throw_stmt( loc, ctl, ast::Resume );
} // build_resume

ast::Stmt * build_resume_at( ExpressionNode * ctl, ExpressionNode * target ) {
	(void)ctl;
	(void)target;
	assertf( false, "resume at (non-local throw) is not yet supported," );
} // build_resume_at

ast::Stmt * build_try( const CodeLocation & location, StatementNode * try_, ClauseNode * catch_, ClauseNode * finally_ ) {
	std::vector<ast::ptr<ast::CatchClause>> aststmt;
	buildMoveList( catch_, aststmt );
	ast::CompoundStmt * tryBlock = strict_dynamic_cast<ast::CompoundStmt *>( maybeMoveBuild( try_ ) );
	ast::FinallyClause * finallyBlock = nullptr;
	if ( finally_ ) {
		finallyBlock = dynamic_cast<ast::FinallyClause *>( finally_->clause.release() );
	}
	return new ast::TryStmt( location,
		tryBlock,
		std::move( aststmt ),
		finallyBlock
	);
} // build_try

ast::CatchClause * build_catch( const CodeLocation & location, ast::ExceptionKind kind, DeclarationNode * decl, ExpressionNode * cond, StatementNode * body ) {
	return new ast::CatchClause( location,
		kind,
		maybeMoveBuild( decl ),
		maybeMoveBuild( cond ),
		buildMoveSingle( body )
	);
} // build_catch

ast::FinallyClause * build_finally( const CodeLocation & location, StatementNode * stmt ) {
	return new ast::FinallyClause( location,
		strict_dynamic_cast<const ast::CompoundStmt *>(
			buildMoveSingle( stmt )
		)
	);
} // build_finally

ast::SuspendStmt * build_suspend( const CodeLocation & location, StatementNode * then, ast::SuspendStmt::Kind kind ) {
	return new ast::SuspendStmt( location,
		strict_dynamic_cast<const ast::CompoundStmt *, nullptr>(
			buildMoveOptional( then )
		),
		kind
	);
} // build_suspend

ast::WaitForStmt * build_waitfor( const CodeLocation & location, ast::WaitForStmt * existing, ExpressionNode * when, ExpressionNode * targetExpr, StatementNode * stmt ) {
	auto clause = new ast::WaitForClause( location );
	clause->target = maybeBuild( targetExpr );
	clause->stmt = maybeMoveBuild( stmt );
	clause->when_cond = notZeroExpr( maybeMoveBuild( when ) );

	ExpressionNode * next = dynamic_cast<ExpressionNode *>( targetExpr->get_next() );
	targetExpr->set_next( nullptr );
	buildMoveList( next, clause->target_args );

	delete targetExpr;

	existing->clauses.insert( existing->clauses.begin(), clause );

	return existing;
} // build_waitfor

ast::WaitForStmt * build_waitfor_else( const CodeLocation & location, ast::WaitForStmt * existing, ExpressionNode * when, StatementNode * stmt ) {
	existing->else_stmt = maybeMoveBuild( stmt );
	existing->else_cond = notZeroExpr( maybeMoveBuild( when ) );

	(void)location;
	return existing;
} // build_waitfor_else

ast::WaitForStmt * build_waitfor_timeout( const CodeLocation & location, ast::WaitForStmt * existing, ExpressionNode * when, ExpressionNode * timeout, StatementNode * stmt ) {
	existing->timeout_time = maybeMoveBuild( timeout );
	existing->timeout_stmt = maybeMoveBuild( stmt );
	existing->timeout_cond = notZeroExpr( maybeMoveBuild( when ) );

	(void)location;
	return existing;
} // build_waitfor_timeout

ast::WaitUntilStmt::ClauseNode * build_waituntil_clause( const CodeLocation & loc, ExpressionNode * when, ExpressionNode * targetExpr, StatementNode * stmt ) {
	ast::WhenClause * clause = new ast::WhenClause( loc );
	clause->when_cond = notZeroExpr( maybeMoveBuild( when ) );
	clause->stmt = maybeMoveBuild( stmt );
	clause->target = maybeMoveBuild( targetExpr );
	return new ast::WaitUntilStmt::ClauseNode( clause );
}
ast::WaitUntilStmt::ClauseNode * build_waituntil_else( const CodeLocation & loc, ExpressionNode * when, StatementNode * stmt ) {
	ast::WhenClause * clause = new ast::WhenClause( loc );
	clause->when_cond = notZeroExpr( maybeMoveBuild( when ) );
	clause->stmt = maybeMoveBuild( stmt );
	return new ast::WaitUntilStmt::ClauseNode( ast::WaitUntilStmt::ClauseNode::Op::ELSE, clause );
}

ast::WaitUntilStmt * build_waituntil_stmt( const CodeLocation & loc, ast::WaitUntilStmt::ClauseNode * root ) {
	ast::WaitUntilStmt * retStmt = new ast::WaitUntilStmt( loc );
	retStmt->predicateTree = root;

	// iterative tree traversal
	std::vector<ast::WaitUntilStmt::ClauseNode *> nodeStack; // stack needed for iterative traversal
	ast::WaitUntilStmt::ClauseNode * currNode = nullptr;
	ast::WaitUntilStmt::ClauseNode * lastInternalNode = nullptr;
	ast::WaitUntilStmt::ClauseNode * cleanup = nullptr; // used to cleanup removed else/timeout
	nodeStack.push_back(root);

	do {
		currNode = nodeStack.back();
		nodeStack.pop_back(); // remove node since it will be processed

		switch (currNode->op) {
		case ast::WaitUntilStmt::ClauseNode::LEAF:
			retStmt->clauses.push_back(currNode->leaf);
			break;
		case ast::WaitUntilStmt::ClauseNode::ELSE:
			retStmt->else_stmt = currNode->leaf->stmt
				? ast::deepCopy( currNode->leaf->stmt )
				: nullptr;
			retStmt->else_cond = currNode->leaf->when_cond
				? ast::deepCopy( currNode->leaf->when_cond )
				: nullptr;

			delete currNode->leaf;
			break;
		case ast::WaitUntilStmt::ClauseNode::TIMEOUT:
			retStmt->timeout_time = currNode->leaf->target
				? ast::deepCopy( currNode->leaf->target )
				: nullptr;
			retStmt->timeout_stmt = currNode->leaf->stmt
				? ast::deepCopy( currNode->leaf->stmt )
				: nullptr;
			retStmt->timeout_cond = currNode->leaf->when_cond
				? ast::deepCopy( currNode->leaf->when_cond )
				: nullptr;

			delete currNode->leaf;
			break;
		default:
			nodeStack.push_back( currNode->right ); // process right after left
			nodeStack.push_back( currNode->left );

			// Cut else/timeout out of the tree
			if ( currNode->op == ast::WaitUntilStmt::ClauseNode::LEFT_OR ) {
				if ( lastInternalNode )
					lastInternalNode->right = currNode->left;
				else // if not set then root is LEFT_OR
					retStmt->predicateTree = currNode->left;

				currNode->left = nullptr;
				cleanup = currNode;
			}

			lastInternalNode = currNode;
			break;
		}
	} while ( !nodeStack.empty() );

	if ( cleanup ) delete cleanup;

	return retStmt;
}

ast::Stmt * build_with( const CodeLocation & location, ExpressionNode * exprs, StatementNode * stmt ) {
	std::vector<ast::ptr<ast::Expr>> e;
	buildMoveList( exprs, e );
	ast::Stmt * s = maybeMoveBuild( stmt );
	return new ast::DeclStmt( location, new ast::WithStmt( location, std::move( e ), s ) );
} // build_with

ast::Stmt * build_compound( const CodeLocation & location, StatementNode * first ) {
	auto cs = new ast::CompoundStmt( location );
	buildMoveList( first, cs->kids );
	return cs;
} // build_compound

// A single statement in a control structure is always converted to a compound statement so subsequent generated code
// can be placed within this compound statement. Otherwise, code generation has to constantly check for a single
// statement and wrap it into a compound statement to insert additional code. Hence, all control structures have a
// conical form for code generation.
StatementNode * maybe_build_compound( const CodeLocation & location, StatementNode * first ) {
	// Optimization: if the control-structure statement is a compound statement, do not wrap it.
	// e.g., if (...) {...} do not wrap the existing compound statement.
	if ( !dynamic_cast<ast::CompoundStmt *>( first->stmt.get() ) ) { // unique_ptr
		return new StatementNode( build_compound( location, first ) );
	} // if
	return first;
} // maybe_build_compound

// Question
ast::Stmt * build_asm( const CodeLocation & location, bool is_volatile, ExpressionNode * instruction, ExpressionNode * output, ExpressionNode * input, ExpressionNode * clobber, LabelNode * gotolabels ) {
	std::vector<ast::ptr<ast::Expr>> out, in;
	std::vector<ast::ptr<ast::ConstantExpr>> clob;

	buildMoveList( output, out );
	buildMoveList( input, in );
	buildMoveList( clobber, clob );
	return new ast::AsmStmt( location,
		is_volatile,
		maybeMoveBuild( instruction ),
		std::move( out ),
		std::move( in ),
		std::move( clob ),
		gotolabels ? gotolabels->labels : std::vector<ast::Label>()
	);
} // build_asm

ast::Stmt * build_directive( const CodeLocation & location, string * directive ) {
	auto stmt = new ast::DirectiveStmt( location, *directive );
	delete directive;
	return stmt;
} // build_directive

ast::Stmt * build_mutex( const CodeLocation & location, ExpressionNode * exprs, StatementNode * stmt ) {
	std::vector<ast::ptr<ast::Expr>> expList;
	buildMoveList( exprs, expList );
	ast::Stmt * body = maybeMoveBuild( stmt );
	return new ast::MutexStmt( location, body, std::move( expList ) );
} // build_mutex

// Local Variables: //
// tab-width: 4 //
// mode: c++ //
// compile-command: "make install" //
// End: //
