org.eclipse.efm.symbex/src/printer/OutStream.cpp

/*******************************************************************************
 * Copyright (c) 2016 CEA LIST.
 *
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Created on: 17 déc. 2012
 *
 * Contributors:
 *  Arnault Lapitre (CEA LIST) arnault.lapitre@cea.fr
 *   - Initial API and implementation
 ******************************************************************************/

#include "OutStream.h"

#include <util/avm_assert.h>
#include <util/avm_vfs.h>

#include <sew/Workflow.h>

#include <fml/workflow/WObject.h>


namespace sep
{


/**
 * CONSOLE PROMPT
 */
const std::string & CONSOLE_DEBUG_PROMPT  = "[DBG] ";

const std::string & CONSOLE_SEW_PROMPT    = "[SEW] ";

const std::string & CONSOLE_CONFIG_PROMPT = "[CFG] ";

const std::string & CONSOLE_SYMBEX_PROMPT = "[SBX] ";


////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
// OutStream
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

/**
 * LOAD
 * DISPOSE
 */
void OutStream::load()
{
	_avm_os_log_ = AVM_OS_COUT.OS;

	_avm_os_trace_ = AVM_OS_COUT.OS;

	_avm_os_tdd_ = AVM_OS_COUT.OS;
}

void OutStream::dispose()
{
	// AVM TRACE LOG << ofstream >>
	if( _avm_os_log_ != NULL )
	{
		_avm_os_log_->flush();

		if( (_avm_os_log_ != AVM_OS_COUT.OS) &&
				(_avm_os_log_ != _avm_os_null_) )
		{
//			_avm_os_log->close();
			delete _avm_os_log_;
		}
	}
	_avm_os_log_ = NULL;


	// AVM TRACE DEBUG << ofstream >>
	if( _avm_os_trace_ != NULL )
	{
		_avm_os_trace_->flush();

		if( (_avm_os_trace_ != AVM_OS_COUT.OS) &&
				(_avm_os_trace_ != _avm_os_null_) )
		{
//			_avm_os_trace->close();
			delete _avm_os_trace_;
		}
	}
	_avm_os_trace_ = NULL;


	// AVM TEST DRIVEN DEVELOPMENT << ofstream >>
	if( _avm_os_tdd_ != NULL )
	{
		_avm_os_tdd_->flush();

		if( (_avm_os_tdd_ != AVM_OS_COUT.OS) &&
				(_avm_os_tdd_ != _avm_os_null_) )
		{
//			_avm_os_tdd_->close();
			delete _avm_os_tdd_;
		}
	}
	_avm_os_tdd_ = NULL;


	// AVM NULL << ofstream >>
	if( _avm_os_null_ != NULL )
	{
		delete _avm_os_null_;
	}
}


/**
 * CONFIGURE
 */
/*
// GLOBAL PROPERTY
section PROPERTY
	output#tab = " ";

	fscn#tab = " ";

	line#wrap#width = 80;
	line#wrap#separator = "\n\t";
endsection
*/
bool OutStream::configure(Workflow * aWorkflow)
{
	WObject * seqFORMAT = Query::getWSequenceOrElse(
			aWorkflow->getParameterWObject(), "format", "PROPERTY");

	// GLOBAL INDENT CHAR
	std::string strTab = Query::getRegexWPropertyString(seqFORMAT,
			CONS_WID2("output", "tab"), AVM_OUTPUT_INDENT.CHAR);

	AVM_FSCN_INDENT.CHAR =
			Query::getRegexWPropertyString(
					seqFORMAT, CONS_WID2("fscn", "tab"),
					(strTab != AVM_OUTPUT_INDENT.CHAR) ?
							strTab : AVM_FSCN_INDENT.CHAR);

	AVM_OUTPUT_INDENT.CHAR = strTab;

	/*
	 * DEFAULT_WRAP_DATA
	 */
	if( DEFAULT_WRAP_DATA.configure( seqFORMAT ) )
	{
		//!!NOTHING
	}

	// AVM TRACE LOG << ofstream >>
	if( aWorkflow->hasDeveloperDebugLogFile() )
	{
		_avm_os_log_ = new std::ofstream(
				aWorkflow->getDeveloperDebugLogFileLocation().c_str() );
		if( (_avm_os_log_ == NULL) || _avm_os_log_->fail() )
		{
			_avm_os_log_ = _avm_os_null_;

			AVM_OS_FATAL_ERROR_EXIT
					<< "Failed to open AVM_OS_LOG << "
					<< aWorkflow->getDeveloperDebugLogFileLocation()
					<< " >> file in write mode !!!"
					<< SEND_EXIT;

			return( false );
		}
	}
	else
	{
		_avm_os_log_ = _avm_os_null_;
	}

	AVM_OS_LOG.OS = _avm_os_log_;


	// AVM TRACE DEBUG << ofstream >>
	if( aWorkflow->hasDeveloperDebugTraceFile() )
	{
		_avm_os_trace_ = new std::ofstream(
				aWorkflow->getDeveloperDebugTraceFileLocation().c_str() );
		if( (_avm_os_trace_ == NULL) || _avm_os_trace_->fail() )
		{
			_avm_os_trace_ = _avm_os_null_;

			AVM_OS_FATAL_ERROR_EXIT
					<< "Failed to open AVM_OS_TRACE << "
					<< aWorkflow->getDeveloperDebugTraceFileLocation()
					<< " >> file in write mode !!!"
					<< SEND_EXIT;

			return( false );
		}
	}
	else
	{
		_avm_os_trace_ = _avm_os_null_;
	}

	AVM_OS_TRACE.OS = _avm_os_trace_;


	// AVM TEST DRIVEN DEVELOPMENT << ofstream >>
	if( aWorkflow->hasTddReport() )
	{
		_avm_os_tdd_ = new std::ofstream(
				aWorkflow->getTddReportLocation().c_str() );
		if( (_avm_os_tdd_ == NULL) || _avm_os_tdd_->fail() )
		{
			_avm_os_tdd_ = _avm_os_null_;

			AVM_OS_FATAL_ERROR_EXIT
					<< "Failed to open AVM_OS_TDD << "
					<< aWorkflow->getTddReportLocation()
					<< " >> file in write mode !!!"
					<< SEND_EXIT;

			return( false );
		}
	}
	else
	{
		_avm_os_tdd_ = _avm_os_null_;
	}

	AVM_OS_TDD.OS = _avm_os_tdd_;

	// For ASSERT
	AVM_OS_THROW_EXCEPTION.OS.INDENT = AVM_OUTPUT_INDENT;

	AVM_OS_THROW_ALERT.OS.INDENT = AVM_OUTPUT_INDENT;

	return( true );
}


/**
 * REPEAT
 * COLUMN
 * EMPHASIS
 */
OutStream & OutStream::operator<<(const AvmEMPHASIS & emphasis)
{
	if( emphasis.enableTab ) { ( *OS ) << INDENT.TABS; }
	repeat(emphasis.emph, emphasis.count) << INDENT.EOL;

	std::size_t count = emphasis.count + ( (emphasis.count > 2) ? -2 : 0 );
	// for 2 spaces char --> ' ' emphasis.text ' '

	std::size_t after = 0;
	std::size_t before = 0;

	// emphasis.header
	if( not emphasis.header.empty() )
	{
		if( count > emphasis.header.size() )
		{
			after = (count - emphasis.header.size()) / 2;
			before = count - after - emphasis.header.size();

			if( emphasis.enableTab ) { ( *OS ) << INDENT.TABS; }
			repeat(emphasis.emph, before) << ' ' << emphasis.header << ' ';
			repeat(emphasis.emph, after)  << INDENT.EOL;
		}
		else
		{
			if( emphasis.enableTab ) { ( *OS ) << INDENT.TABS; }
			( *OS ) << emphasis.emph << emphasis.emph
					<< ' ' << emphasis.header << INDENT.EOL;
		}
	}

	// emphasis.body
	if( not emphasis.body.empty() )
	{
		if( count > emphasis.body.size() )
		{
			std::size_t body_after = (count - emphasis.body.size()) / 2;

			std::size_t space = 1;
			bool rightSpace = false;
			if( (after > 0) && (after < body_after) )
			{
				space += body_after - after;

				rightSpace = ( ((emphasis.body.size() + before + after) % 2)
						!= (count % 2) );
			}
			else
			{
				after = body_after;

				before = count - body_after - emphasis.body.size();
			}

			AvmREPEAT< char > center = REPEAT(' ', space);

			if( emphasis.enableTab ) { ( *OS ) << INDENT.TABS; }
			repeat(emphasis.emph, before) << center
					<< emphasis.body << center;
			if( rightSpace ) { ( *OS ) << ' '; }
			repeat(emphasis.emph, after) << INDENT.EOL;
		}
		else
		{
			if( emphasis.enableTab ) { ( *OS ) << INDENT.TABS; }
			( *OS ) << emphasis.emph << emphasis.emph
					<< ' ' << emphasis.body << INDENT.EOL;
		}
	}

	if( emphasis.enableTab ) { ( *OS ) << INDENT.TABS; }
	repeat(emphasis.emph, emphasis.count) << INDENT.EOL << std::flush;

	return( *this );
}


////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
// GLOBAL PRE-DEFINED STREAM
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

/**
 * UTIL VARIABLE
 * AVM_OS_NULL
 */
std::ostream * _avm_os_null_ = new std::ostream(NULL);

NullOutStream AVM_OS_NULL;


/**
 * AVM COUT & CERR & DEBUG
 */
// !!! Due to Initialization order !!!
//OutStream AVM_OS_COUT( std::cout , AVM_SPC_INDENT );
OutStream AVM_OS_COUT( std::cout , ""   , " "  , "\n" );

OutStream AVM_OS_CERR(
		((_AVM_EXEC_MODE_ == AVM_EXEC_SERVER_MODE) ? std::cout : std::cerr),
//		AVM_SPC_INDENT );
		""   , " "  , "\n" );

OutStream AVM_OS_DEBUG( std::cout , ""   , "\t"  , "\n" );

/**
 * AVM LOG & TRACE FILE LOCATION
 */
std::string AVM_LOG_FILE_LOCATION;

std::string AVM_TRACE_FILE_LOCATION;


/**
 * UTIL VARIABLE
 * AVM_OS_LOG
 */
std::ostream * _avm_os_log_ = NULL;

//OutStream AVM_OS_LOG( std::cout , AVM_SPC_INDENT );
OutStream AVM_OS_LOG( std::cout , ""   , " "  , "\n" );


/**
 * UTIL VARIABLE
 * AVM_OS_TRACE
 */
std::ostream * _avm_os_trace_ = NULL;

//OutStream AVM_OS_TRACE( std::cout , AVM_SPC_INDENT );
OutStream AVM_OS_TRACE( std::cout , ""   , " "  , "\n" );


/**
 * UTIL VARIABLE
 * AVM_OS_WARN
 */
WarnOutstreamT AVM_OS_WARN(AVM_OS_CERR, AVM_OS_TRACE);

/**
 * UTIL VARIABLE
 * AVM_OS_INFO
 */
InfoOutstreamT AVM_OS_INFO(AVM_OS_COUT, AVM_OS_TRACE);

/**
 * UTIL VARIABLE
 * AVM_OS_CLOG
 */
InfoOutstreamT AVM_OS_CLOG(AVM_OS_COUT, AVM_OS_LOG);


/**
 * UTIL VARIABLE
 * AVM_OS_TDD
 * for Test Driven Development
 */
std::ostream * _avm_os_tdd_ = NULL;

//OutStream AVM_OS_TDD( std::cout , AVM_TAB_INDENT );
OutStream AVM_OS_TDD( std::cout , ""   , "\t" , "\n" );


} /* namespace sep */