SingleStatement.cpp

#include <ast/statements/SingleStatement.h>
#include <ast/Option.h>
#include <ast/Param.h>

namespace cli {

SingleStatement::SingleStatement ( std::string name, ext::vector < std::unique_ptr < Param > > params, ext::vector < std::unique_ptr < Option > > options ) : m_name ( name ), m_params ( std::move ( params ) ), m_options ( std::move ( options ) ) {
	for ( const std::unique_ptr < Option > & option : m_options ) {
		option->eval ( * this );
	}
}

std::shared_ptr < abstraction::OperationAbstraction > SingleStatement::translateAndEval ( const std::shared_ptr < abstraction::OperationAbstraction > & prev, Environment & environment ) const {
	ext::vector < std::shared_ptr < abstraction::OperationAbstraction > > params;
	for ( const std::unique_ptr < Param > & param : m_params ) {
		params.push_back ( param->translateAndEval ( prev, environment ) );
	}

	ext::vector < ext::type_index > paramTypes;
	for ( const std::shared_ptr < abstraction::OperationAbstraction > & param : params ) {
		paramTypes.push_back ( param->getReturnType ( ) );
	}

	bool downcast = false;
	bool normalize = false;

	std::shared_ptr < abstraction::OperationAbstraction > algo = abstraction::Registry::getAlgorithmAbstraction ( m_name, paramTypes, downcast, normalize );

	unsigned i = 0;
	for ( const std::shared_ptr < abstraction::OperationAbstraction > & param : params ) {
		if ( ! algo->attachInput ( param, i ) )
			throw exception::CommonException ( "Can't connect param at " + ext::to_string ( i ) + " of algorithm " + m_name + " with result of type " + param->getReturnType ( ) + "." );
		i++;
	}

	if ( ! algo->eval ( ) )
		throw exception::CommonException ( "Eval of algorithm " + m_name + " failed." );

	if ( downcast ) {
		std::shared_ptr < abstraction::OperationAbstraction > downcaster = abstraction::Registry::getDowncastAbstraction ( algo->getRuntimeReturnType ( ), algo->getReturnType ( ) );
		downcaster->attachInput ( algo, 0 );
		downcaster->eval ( );

		algo = downcaster;
	}

	if ( normalize ) {
		std::shared_ptr < abstraction::OperationAbstraction > normalized = abstraction::Registry::getNormalizeAbstraction ( algo->getReturnType ( ) );
		normalized->attachInput ( algo, 0 );
		normalized->eval ( );

		algo = normalized;
	}

	return algo;
}

} /* namespace cli */