1 /*

     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  Class representing a project.

    15 *

    16 */

    17 

    18 

    19 #include "../inc/CATProject.h"

    20 #include "../inc/CATModule2.h"

    21 #include "../inc/CATParseTraceFile.h"

    22 #include "../inc/CATDatParser.h"

    23 

    24 // ----------------------------------------------------------------------------

    25 // CATProject::CATProject()

    26 // ----------------------------------------------------------------------------

    27 CATProject::CATProject()

    28 {

    29 	LOG_FUNC_ENTRY("CATProject::CATProject");

    30 

    31 	m_bUninstrumented = true;

    32 

    33 	// Use windows api to acquire current directory info.

    34 	GetCurrentDirectory( MAX_LINE_LENGTH, m_cCurrentDir );

    35 

    36 	m_eBuildSystem = SBS_V1;

    37 	m_eBuildType = UDEB;

    38 	m_eLoggingMode = XTI;

    39 	m_eMode = NOT_DEFINED;

    40 	

    41 	m_iLoggingLevel = 3;

    42 	

    43 	m_pAnalyzer = 0;

    44 

    45 	m_sBinaryTarget = "";

    46 	m_sBuildCommand = "";

    47 	m_sDataFile = "";

    48 	m_sDataFileOutput = "";

    49 	m_sDataFileTemp = "";

    50 	m_sEpocRoot = "\\";

    51 	m_sMakeFile = "";

    52 	m_sPlatform = "";

    53 	m_sS60FileName = "";

    54 	m_sTargetModule = "";

    55 	m_sVariant = "";

    56 

    57 	m_vRomSymbolFiles.clear();

    58 	m_vModules.clear();

    59 	m_vStaticLibraries.clear();

    60 	m_vTargetModules.clear();

    61 	m_vUnsupportedModules.clear();

    62 }

    63 

    64 // ----------------------------------------------------------------------------

    65 // CATProject::~CATProject()

    66 // ----------------------------------------------------------------------------

    67 CATProject::~CATProject()

    68 {

    69 	LOG_FUNC_ENTRY("CATProject::~CATProject");

    70 

    71 	CleanModuleVectors();

    72 

    73 	// Delete analyzer

    74 	if ( m_pAnalyzer )

    75 		delete m_pAnalyzer;

    76 

    77 	// Temporary datafile

    78 	if ( !m_sDataFileTemp.empty() )

    79 	{

    80 		if ( FileExists( m_sDataFileTemp.c_str() ) )

    81 			FileDelete( m_sDataFileTemp, false );

    82 	}

    83 }

    84 

    85 bool CATProject::SetArguments( ARGUMENTS& arguments )

    86 {

    87 	LOG_FUNC_ENTRY("CATProject::SetArguments");

    88 	bool bRet = true;

    89 

    90 	//Project mode.

    91 	if( arguments.eHookSwitch == HOOK_INTERNAL )

    92 	{

    93 		SetMode( CATProject::COMPILE );

    94 		SetLoggingMode( CATProject::S60 );

    95 	}

    96 	else if ( arguments.eHookSwitch == HOOK_EXTERNAL )

    97 	{

    98 		SetMode( CATProject::COMPILE );

    99 		SetLoggingMode( CATProject::XTI );

   100 	}

   101 	else if ( arguments.eHookSwitch == HOOK_EXTERNAL_FAST )

   102 	{

   103 		SetMode( CATProject::COMPILE );

   104 		SetLoggingMode( CATProject::XTI_FAST );

   105 	}

   106 	/* Extension*/

   107 	else if ( arguments.eHookSwitch == HOOK_EXTENSION_INTERNAL )

   108 	{

   109 		SetMode( CATProject::INSTRUMENT );

   110 		SetLoggingMode( CATProject::S60 );

   111 	}

   112 	else if ( arguments.eHookSwitch == HOOK_EXTENSION_EXTERNAL )

   113 	{

   114 		SetMode( CATProject::INSTRUMENT );

   115 		SetLoggingMode( CATProject::XTI );

   116 	}

   117 	else if ( arguments.eHookSwitch == HOOK_EXTENSION_EXTERNAL_FAST )

   118 	{

   119 		SetMode( CATProject::INSTRUMENT );

   120 		SetLoggingMode( CATProject::XTI_FAST );

   121 	}

   122 	else if ( arguments.eHookSwitch == HOOK_EXTENSION_UNINSTRUMENT )

   123 	{

   124 		SetMode( CATProject::UNINSTRUMENT );

   125 	}

   126 	else if ( arguments.eHookSwitch == HOOK_EXTENSION_FAILED )

   127 	{

   128 		SetMode( CATProject::UNINSTRUMENT_FAILED );

   129 	}

   130 	//Return if uninstrumenting because no other arguments are set.

   131     if ( GetMode() == CATProject::UNINSTRUMENT

   132 		|| GetMode() == CATProject::UNINSTRUMENT_FAILED )

   133 	{

   134 		return bRet;

   135 	}

   136 

   137 	// No build / instrument.

   138 	if ( arguments.HOOK.bNoBuild )

   139 		SetMode( CATProject::INSTRUMENT_CONSOLE );

   140 

   141 	// Call stack sizes

   142 	SetAllocCallStackSize( arguments.HOOK.iAllocCallStackSize );

   143 	SetFreeCallStackSize( arguments.HOOK.iFreeCallStackSize );

   144 

   145 	//Build system.

   146 	if ( arguments.HOOK.iBuildSystem == 1 )

   147 		SetBuildSystem( CATProject::SBS_V1 );

   148 	else if ( arguments.HOOK.iBuildSystem == 2 )

   149 		SetBuildSystem( CATProject::SBS_V2 );

   150 

   151 	//Platform.

   152 	if ( !_stricmp( arguments.HOOK.sPlatform.c_str(), "armv5" ) )

   153 		SetPlatform( arguments.HOOK.sPlatform );

   154 	else if ( !_stricmp( arguments.HOOK.sPlatform.c_str(), "gcce" ) )

   155 		SetPlatform( arguments.HOOK.sPlatform );

   156 	else if ( !_stricmp( arguments.HOOK.sPlatform.c_str(), "winscw" ) )

   157 		SetPlatform( arguments.HOOK.sPlatform );

   158 	else

   159 	{

   160 		LOG_STRING( "Error, no supported platform specified (armv5/gcce/winscw).");

   161 		bRet = false;

   162 	}

   163 

   164 	//BuildType.

   165 	if ( !_stricmp( arguments.HOOK.sBuildType.c_str(), "urel" ) )

   166 		SetBuildType( CATProject::UREL );

   167 	else if ( !_stricmp( arguments.HOOK.sBuildType.c_str(), "udeb" ) )

   168 		SetBuildType( CATProject::UDEB );

   169 	else

   170 	{

   171 		LOG_STRING( "Error, no build type specified.");

   172 		bRet = false;

   173 	}

   174 

   175 	//Internal data file.

   176 	if ( arguments.HOOK.bDataFileName )

   177 		SetS60FileName( arguments.HOOK.sDataFileName );

   178 

   179 	//Build command.

   180 	if ( arguments.HOOK.sBuildCmd.empty() && ( 

   181 		GetMode() == CATProject::COMPILE ||

   182 		GetMode() == CATProject::INSTRUMENT ||

   183 		GetMode() == CATProject::INSTRUMENT_CONSOLE

   184 		))

   185 	{

   186 		cout << AT_MSG << "Error, no build command specified." << endl;

   187 		bRet = false;

   188 	}

   189 

   190 	SetBuildCommand( arguments.HOOK.sBuildCmd );

   191 

   192 	//Variant.

   193 	SetVariant( arguments.HOOK.sFeatureVariant );

   194 

   195 	//Target programs.

   196 	SetTargetModules( arguments.HOOK.vTargetPrograms );

   197 

   198 	return bRet;

   199 }

   200 

   201 void CATProject::CleanModuleVectors()

   202 {

   203 	LOG_FUNC_ENTRY("CATProject::CleanModuleVectors");

   204 	// delete modules from vector.

   205 	for( size_t i = 0; i < m_vModules.size()  ; i++ )

   206 		delete m_vModules[i];

   207 	m_vModules.clear();

   208 	

   209 	// Delete modules from vector (unsupported).

   210 	for( size_t i = 0; i < m_vUnsupportedModules.size()  ; i++ )

   211 		delete m_vUnsupportedModules[i];

   212 	m_vUnsupportedModules.clear();

   213 

   214 	// Delete modules from static library vector.

   215 	for( size_t i = 0; i < m_vStaticLibraries.size() ; i++ )

   216 		delete m_vStaticLibraries[i];

   217 	m_vStaticLibraries.clear();

   218 }

   219 // ----------------------------------------------------------------------------

   220 // CATProject::Run

   221 // ----------------------------------------------------------------------------

   222 int CATProject::Run()

   223 {

   224 	LOG_FUNC_ENTRY("CATProject::Run");

   225 	int iReturnCode = 0;

   226 	switch( m_eMode )

   227 	{

   228 	case COMPILE:

   229 		// Run compile

   230 		iReturnCode = RunCompile();

   231 		if ( iReturnCode == AT_RETURN_CODE::READ_MAKEFILE_ERROR

   232 			|| iReturnCode == AT_RETURN_CODE::KERNEL_SIDE_MODULE_ERROR

   233 			|| iReturnCode == AT_RETURN_CODE::INVALID_MMP_DEFINED )

   234 		{

   235 			DeleteTemporaryDirs();

   236 			DirDelete( AT_TEMP_DIR, true );

   237 		}

   238 		else

   239 		{

   240 			DisplayCompileSummary();

   241 			DisplayBuildSummary();

   242 		}

   243 		break;

   244 	case CLEAN:

   245 		iReturnCode = RunClean();

   246 		break;

   247 	case ANALYZE:

   248 		iReturnCode = RunAnalyze();

   249 		break;

   250 	case INSTRUMENT:

   251 		iReturnCode = RunInstrument();

   252 		break;

   253 	case INSTRUMENT_CONSOLE:

   254 		iReturnCode = RunInstrumentConsole();

   255 		if ( iReturnCode == AT_RETURN_CODE::READ_MAKEFILE_ERROR

   256 			|| iReturnCode == AT_RETURN_CODE::KERNEL_SIDE_MODULE_ERROR )

   257 		{

   258 			DeleteTemporaryDirs();

   259 			DirDelete( AT_TEMP_DIR, true );

   260 		}

   261 		else

   262 		{

   263 			DisplayBuildSummary();

   264 		}

   265 		break;

   266 	case UNINSTRUMENT:

   267 		iReturnCode = RunUninstrument();

   268 		// Show summary

   269 		DisplayCompileSummary();

   270 		DisplayBuildSummary();

   271 		break;

   272 	case UNINSTRUMENT_CONSOLE:

   273 		iReturnCode = RunUninstrumentConsole();

   274 		// Show summary

   275 		DisplayCompileSummary();

   276 		DisplayBuildSummary();

   277 		break;

   278 	case UNINSTRUMENT_FAILED:

   279 		iReturnCode = RunUninstrumentFailed();

   280 		// Display message

   281 		cout << AT_MSG << "Build aborted, because project contains compile error(s)."

   282 			<< endl;

   283 		break;

   284 	default:

   285 		cout << AT_MSG << "Error, mode not supported / implemented." << endl;

   286 		break;

   287 	}

   288 	// Error messages

   289 	switch( iReturnCode )

   290 	{

   291 		case AT_RETURN_CODE::MAKEFILE_ERROR:

   292 			cout << AT_MSG << "Error, creating/reading makefiles." << endl;

   293 			break;

   294 		case AT_RETURN_CODE::COMPILE_ERROR:

   295 			cout << AT_MSG << "Error, compiling project." << endl;

   296 			break;

   297 		case AT_RETURN_CODE::UNKNOWN:

   298 			cout << AT_MSG << "Error, unknown." << endl;

   299 			break;

   300 		case AT_RETURN_CODE::WRONG_DATA_FILE_VERSION:

   301 			cout << AT_MSG << "unable to analyze the data file.\n";

   302 			cout << AT_MSG << "wrong data file version.\n";

   303 			break;

   304 		case AT_RETURN_CODE::INVALID_DATA_FILE:

   305 			cout << AT_MSG << "Error, invalid datafile." << endl;

   306 			break;

   307 		case AT_RETURN_CODE::RELEASABLES_ERROR:

   308 			cout << AT_MSG << "Error, copying releasable(s)." << endl;

   309 			break;

   310 		case AT_RETURN_CODE::RESTORE_MODULES_ERROR:

   311 			cout << AT_MSG << "Error, restoring mmp file(s)." << endl;

   312 			break;

   313 		case AT_RETURN_CODE::CREATING_TEMP_CPP_ERROR:

   314 			cout << AT_MSG << "Error, creating temporary cpp file(s)." << endl;

   315 			break;

   316 		case AT_RETURN_CODE::CLEANING_TEMP_ERROR:

   317 			cout << AT_MSG << "Error, cleaning temporary dir(s)." << endl;

   318 			break;

   319 		case AT_RETURN_CODE::READ_MAKEFILE_ERROR:

   320 			cout << AT_MSG << "Error, reading makefile." << endl;

   321 			break;

   322 		case AT_RETURN_CODE::MODIFY_MODULES_ERROR:

   323 			cout << AT_MSG << "Error, modifying mmp file(s)." << endl;

   324 			break;

   325 		case AT_RETURN_CODE::INVALID_MMP_DEFINED:

   326 			break;

   327 		case AT_RETURN_CODE::WRITE_ATTRIBUTES_ERROR:

   328 			cout << AT_MSG << "Error, writing attributes." << endl;

   329 			break;

   330 		case AT_RETURN_CODE::READ_ATTRIBUTES_ERROR:

   331 			cout << AT_MSG << "Error, reading project configuration. Instrument project again." << endl;

   332 			break;

   333 		case AT_RETURN_CODE::EMPTY_DATA_FILE:

   334 			cout << AT_MSG << "Error, no data to be analyzed." << endl;

   335 			break;

   336 		case AT_RETURN_CODE::NO_SUPPORTED_MODULES_ERROR:

   337 			cout << AT_MSG << "Error, no modules found with supported target type." << endl;

   338 			break;

   339 		case AT_RETURN_CODE::KERNEL_SIDE_MODULE_ERROR:

   340 			cout << AT_MSG << "Error, kernel side component found component. Build/instrument aborted." << endl;

   341 			break;

   342 	}	

   343 	return iReturnCode;

   344 }

   345 // ----------------------------------------------------------------------------

   346 // CATProject::RunRecoveryAndExit()

   347 // Restore modules quick and exit. Used when user wants to kill/end process.

   348 // ----------------------------------------------------------------------------

   349 int CATProject::RunRecoveryAndExit()

   350 {

   351 	LOG_FUNC_ENTRY("CATProject::RunRecoveryAndExit");

   352 	cout << AT_MSG << "Error, user requested exit." << endl;

   353 	VerifyAndRecoverModules();

   354 	DeleteTemporaryDirs();

   355 	DirDelete( AT_TEMP_DIR, true );

   356 	cout << AT_MSG << "Exit." << endl;

   357 	return AT_RETURN_CODE::USER_ISSUED_EXIT;

   358 }

   359 

   360 // ----------------------------------------------------------------------------

   361 // CATProject::IsUninstrumented()

   362 // Reads projects configuration file if it exists. 

   363 // Return false in case the data contains information that project is

   364 // uninstrumented. Otherwise returns always true.

   365 // ----------------------------------------------------------------------------

   366 bool CATProject::IsUninstrumented()

   367 {

   368 	LOG_FUNC_ENTRY("CATProject::IsUninstrumented");

   369 	string sCfgFile( AT_TEMP_DIR );

   370 	sCfgFile.append( "\\" );

   371 	sCfgFile.append( AT_PROJECT_ATTRIBUTES_FILE_NAME );

   372 	if ( ! FileExists( sCfgFile.c_str() ) )

   373 		return true;

   374 	if( !ReadAttributes() )

   375 	{

   376 		LOG_STRING( "Error, reading project.cfg file." );

   377 		return false;

   378 	}

   379 	return m_bUninstrumented;

   380 }

   381 

   382 // ----------------------------------------------------------------------------

   383 // CATProject::RunCompile()

   384 // Helper functions to run different modes.

   385 // ----------------------------------------------------------------------------

   386 int CATProject::RunCompile()

   387 {

   388 	LOG_FUNC_ENTRY("CATProject::RunCompile");

   389 	// Store attributes

   390 	if( ! MakeTempDirIfNotExist() )

   391 		return AT_RETURN_CODE::WRITE_ATTRIBUTES_ERROR;

   392 	if ( ! WriteAttributes() )

   393 		return AT_RETURN_CODE::WRITE_ATTRIBUTES_ERROR;

   394 	// Create makefile

   395 	if ( ! CreateMakeFile() )

   396 		return AT_RETURN_CODE::MAKEFILE_ERROR;

   397 	// Read makefile to get project attributes

   398 	if ( ! ReadMakeFile() )

   399 		return AT_RETURN_CODE::READ_MAKEFILE_ERROR;

   400 	// Filter unsupported

   401 	FilterModules();

   402 	// Check that we have some "valid" modules to hook

   403 	if ( m_vModules.size() == 0 &&(  m_vUnsupportedModules.size() > 0 || m_vStaticLibraries.size() > 0 ) )

   404 		return AT_RETURN_CODE::NO_SUPPORTED_MODULES_ERROR;

   405 	// Check is possible target module defined in project

   406 	if ( ! IsTargetModuleInProject() )

   407 		return AT_RETURN_CODE::INVALID_MMP_DEFINED;

   408 	// Clean temporary dirs of modules

   409 	if ( ! CleanTemporaryDirs() )

   410 		return AT_RETURN_CODE::CLEANING_TEMP_ERROR;

   411 	// Create temporary cpps for modulse

   412 	if (! CreateTemporaryCpps() )

   413 		return AT_RETURN_CODE::CREATING_TEMP_CPP_ERROR;

   414 	// Hook modules

   415 	if (! ModifyModules() )

   416 		return AT_RETURN_CODE::MODIFY_MODULES_ERROR;

   417 	// Compile all

   418 	// Return code

   419 	int iRetCode = AT_RETURN_CODE::OK;

   420 	// Compile

   421 	if ( ! Compile() )

   422 		iRetCode = AT_RETURN_CODE::COMPILE_ERROR;

   423 	// Listings

   424 	if (! CreateListings() )

   425 		iRetCode = AT_RETURN_CODE::COMPILE_ERROR;

   426 	// Releasables

   427 	if (! CopyReleasables() )

   428 		iRetCode = AT_RETURN_CODE::RELEASABLES_ERROR;

   429 	// Restore "unhook" modules

   430 	if (! RestoreModules() )

   431 		iRetCode = AT_RETURN_CODE::RESTORE_MODULES_ERROR;

   432 	// Return error code OK

   433 	return iRetCode;

   434 }

   435 

   436 int CATProject::RunClean()

   437 {

   438 	LOG_FUNC_ENTRY("CATProject::RunClean");

   439 	int iRetCode = AT_RETURN_CODE::OK;

   440 	bool bNothingFound = true;

   441 	// Read attributes.

   442 	if (  ReadAttributes() )

   443 	{

   444 		bNothingFound = false;

   445 		if ( m_eBuildSystem == SBS_V1 )

   446 			InitSbs1MakeFileWithPathToTemp();

   447 		// Read makefile to get project attributes

   448 		if( ReadMakeFile() )

   449 		{

   450 			// Filter unsupported

   451 			FilterModules();

   452 			// Restore modules to make sure no changes left

   453 			if( VerifyAndRecoverModules() )

   454 			{

   455 				// Run reallyclean

   456 				switch ( m_eBuildSystem )

   457 				{

   458 				case SBS_V1:

   459 					RunReallyCleanSbs1();

   460 					break;

   461 				case SBS_V2:

   462 					RunReallyCleanSbs2();

   463 					break;

   464 				default:

   465 					break;

   466 				}

   467 				// Delete temporary dirs of modules

   468 				if(! DeleteTemporaryDirs() )

   469 				{

   470 					

   471 				}

   472 			}

   473 			else

   474 			{

   475 				

   476 			}

   477 		}

   478 	}

   479 	// Projects

   480 	if ( ! DirDelete( AT_TEMP_DIR, true ) )

   481 	{

   482 

   483 	}

   484 	else

   485 		bNothingFound = false;

   486 

   487 	if ( bNothingFound )

   488 		cout << AT_MSG << "Nothing found to clean." << endl;

   489 	else

   490 		cout << AT_MSG << "Cleaning done." << endl;

   491 	return iRetCode;

   492 }

   493 

   494 int CATProject::RunAnalyze()

   495 {

   496 	LOG_FUNC_ENTRY("CATProject::RunAnalyze");

   497 

   498 	// Parse data file if it is trace.

   499 	if ( !IsDataFile( m_sDataFile ) )

   500 	{

   501 		m_sDataFileTemp.clear();

   502 		m_sDataFileTemp.append( m_sDataFile );

   503 		m_sDataFileTemp.append( ".atool" );

   504 		cout << AT_MSG << "Parsing trace file..." << endl;

   505 		CATParseTraceFile Parser;

   506 		if ( ! Parser.StartParse( m_sDataFile.c_str(), m_sDataFileTemp.c_str() ) )

   507 		{

   508 			return AT_RETURN_CODE::EMPTY_DATA_FILE;

   509 		}

   510 		m_sDataFile = m_sDataFileTemp;

   511 	}

   512 

   513 	// Init makefile member for this run mode.

   514 	if ( m_eBuildSystem == SBS_V1 )

   515 		InitSbs1MakeFileWithPathToTemp();

   516 	// Read makefile to get project attributes

   517     if( ! ReadMakeFile() )

   518 	{

   519 		cout << AT_MSG << "Error, cannot find project build with AnalyzeTool." << endl;

   520 	}

   521 	else

   522 		FilterModules();

   523 

   524 	#ifndef ADDR2LINE

   525 	// Initialize modules locating code lines.

   526 	for( size_t i = 0 ; i < m_vModules.size() ; i++ )

   527 	{

   528 		m_vModules.at(i)->InitializeAddressToLine();

   529 	}

   530 	#endif

   531 

   532 	// Create analyzer

   533 	m_pAnalyzer = new CATDatParser( &m_vModules );

   534 

   535 	// Pass some info from project if it "exists" to analyzer.

   536 	if ( m_vModules.size() > 0 )

   537 	{

   538 		// Pass platform.

   539 		m_pAnalyzer->SetProjectPlatform( m_sPlatform );

   540 		// Pass build type.

   541 		m_pAnalyzer->SetProjectBuildType( m_eBuildType );

   542 	}

   543 	

   544 	// Set file.

   545 	m_pAnalyzer->SetInputFile( m_sDataFile );

   546 

   547 	// Set rom symbol file.

   548 	m_pAnalyzer->SetRomSymbolFiles( m_vRomSymbolFiles );

   549 

   550 	// Set output file if specified

   551 	if ( ! m_sDataFileOutput.empty() )

   552 	{

   553 		m_pAnalyzer->SetOutputFile( m_sDataFileOutput );

   554 	}

   555 	// Set log level

   556 	m_pAnalyzer->SetLogLevel( m_iLoggingLevel );

   557 

   558 	// Analyze

   559 	return m_pAnalyzer->Analyze();

   560 }

   561 

   562 int CATProject::RunInstrument()

   563 {

   564 	LOG_FUNC_ENTRY("CATProject::RunInstrument");

   565 	// Store attributes

   566 	if( ! MakeTempDirIfNotExist() )

   567 		return AT_RETURN_CODE::WRITE_ATTRIBUTES_ERROR;

   568 	if ( ! WriteAttributes() )

   569 		return AT_RETURN_CODE::WRITE_ATTRIBUTES_ERROR;

   570 	if ( m_eBuildSystem == SBS_V1 )

   571 	{

   572 		// Initialize level 1 make file member.

   573 		if ( ! InitSbs1MakeFileWithPath() )

   574 			return AT_RETURN_CODE::MAKEFILE_ERROR;

   575 		// Copy it to temporary folder.

   576 		CopyMakeFileSbs1ToTemporaryFolder();

   577 		// Run export.

   578 		if( ! RunExportSbs1() )

   579 			return AT_RETURN_CODE::MAKEFILE_ERROR;

   580 		// Create level 2 makefiles.

   581 		if ( ! CreateMakeFileSbs1Level2() )

   582 			return AT_RETURN_CODE::MAKEFILE_ERROR;

   583 	}

   584 	else if ( m_eBuildSystem == SBS_V2 )

   585 	{

   586 		// Create makefile only when using SBS v.2

   587 		if ( ! CreateMakeFile() )

   588 			return AT_RETURN_CODE::MAKEFILE_ERROR;

   589 	}

   590 	else

   591 	{

   592 		return AT_RETURN_CODE::UNKNOWN;

   593 	}

   594 	// Read makefile to get project attributes

   595 	if ( ! ReadMakeFile() )

   596 		return AT_RETURN_CODE::READ_MAKEFILE_ERROR;

   597 	// Filter unsupported

   598 	FilterModules();

   599 	// Check that we have some "valid" modules to hook

   600 	if ( m_vModules.size() == 0 &&(  m_vUnsupportedModules.size() > 0 || m_vStaticLibraries.size() > 0 ) )

   601 		return AT_RETURN_CODE::NO_SUPPORTED_MODULES_ERROR;

   602 

   603 	// Clean temporary dirs of modules

   604 	if ( ! CleanTemporaryDirs() )

   605 		return AT_RETURN_CODE::CLEANING_TEMP_ERROR;

   606 	// Create temporary cpps for modulse

   607 	if (! CreateTemporaryCpps() )

   608 		return AT_RETURN_CODE::CREATING_TEMP_CPP_ERROR;

   609 	// Hook modules

   610 	if (! ModifyModules() )

   611 		return AT_RETURN_CODE::MODIFY_MODULES_ERROR;

   612 	return AT_RETURN_CODE::OK;

   613 }

   614 

   615 int CATProject::RunInstrumentConsole()

   616 {

   617 	LOG_FUNC_ENTRY("CATProject::RunInstrumentConsole");

   618 	if( ! MakeTempDirIfNotExist() )

   619 		return AT_RETURN_CODE::UNKNOWN;

   620 	// Store attributes

   621 	m_bUninstrumented = false;

   622 	if ( ! WriteAttributes() )

   623 		return AT_RETURN_CODE::WRITE_ATTRIBUTES_ERROR;

   624 	// Create makefile

   625 	if ( ! CreateMakeFile() )

   626 		return AT_RETURN_CODE::MAKEFILE_ERROR;

   627 	// Read makefile to get project attributes

   628 	if ( ! ReadMakeFile() )

   629 		return AT_RETURN_CODE::READ_MAKEFILE_ERROR;

   630 	// Filter unsupported

   631 	FilterModules();

   632 	// Check that we have some "valid" modules to hook

   633 	if ( m_vModules.size() == 0 &&(  m_vUnsupportedModules.size() > 0 || m_vStaticLibraries.size() > 0 ) )

   634 		return AT_RETURN_CODE::NO_SUPPORTED_MODULES_ERROR;

   635 

   636 	// Clean temporary dirs of modules

   637 	if ( ! CleanTemporaryDirs() )

   638 		return AT_RETURN_CODE::CLEANING_TEMP_ERROR;

   639 	// Create temporary cpps for modulse

   640 	if (! CreateTemporaryCpps() )

   641 		return AT_RETURN_CODE::CREATING_TEMP_CPP_ERROR;

   642 	// Hook modules

   643 	if (! ModifyModules() )

   644 		return AT_RETURN_CODE::MODIFY_MODULES_ERROR;	

   645 	return AT_RETURN_CODE::OK;

   646 }

   647 

   648 int CATProject::RunUninstrument()

   649 {

   650 	LOG_FUNC_ENTRY("CATProject::RunUninstrument");

   651 	// Read attributes.

   652 	if ( ! ReadAttributes() )

   653 		return AT_RETURN_CODE::READ_ATTRIBUTES_ERROR;

   654 	// Init makefile member for this run mode.

   655 	if ( m_eBuildSystem == SBS_V1 )

   656 		InitSbs1MakeFileWithPathToTemp();

   657 	// Read makefile to get project attributes

   658 	if ( ! ReadMakeFile() )

   659 		return AT_RETURN_CODE::READ_MAKEFILE_ERROR;

   660 	// Filter unsupported

   661 	FilterModules();

   662 	// Check that we have some "valid" modules to hook

   663 	if ( m_vModules.size() == 0 &&(  m_vUnsupportedModules.size() > 0 || m_vStaticLibraries.size() > 0 ) )

   664 		return AT_RETURN_CODE::NO_SUPPORTED_MODULES_ERROR;

   665 	// Create lst files

   666     if (! CreateListings() )

   667 		return AT_RETURN_CODE::COMPILE_ERROR;

   668 	// Copy releasables of modules

   669 	if (! CopyReleasables() )

   670 		return AT_RETURN_CODE::RELEASABLES_ERROR;

   671 	// Restore "unhook" modules

   672 	if (! RestoreModules() )

   673 		return AT_RETURN_CODE::RESTORE_MODULES_ERROR;

   674 	// Return error code OK

   675 	return AT_RETURN_CODE::OK;

   676 }

   677 

   678 int CATProject::RunUninstrumentConsole()

   679 {

   680 	LOG_FUNC_ENTRY("CATProject::RunUninstrumentConsole");

   681 	int iErrorCode = AT_RETURN_CODE::OK;

   682 	// Read attributes

   683 	if ( ReadAttributes() )

   684 	{

   685 		// Init makefile member for this run mode.

   686 		if ( m_eBuildSystem == SBS_V1 )

   687 			InitSbs1MakeFileWithPathToTemp();

   688 		// Read makefile to get project attributes

   689 		if( ReadMakeFile() )

   690 		{

   691 			// Filter unsupported

   692 			FilterModules();

   693 			// Create lst files

   694 			CreateListings();

   695 			if (! CopyReleasables() )

   696 				iErrorCode = AT_RETURN_CODE::RELEASABLES_ERROR;

   697 		}

   698 		else

   699 			iErrorCode = AT_RETURN_CODE::READ_MAKEFILE_ERROR;

   700 		// Change state to uninstrumented and write status

   701 		m_bUninstrumented = true;

   702 		if ( ! WriteAttributes() )

   703 			iErrorCode = AT_RETURN_CODE::WRITE_ATTRIBUTES_ERROR;

   704 	}

   705 	else

   706 	{

   707 		iErrorCode = AT_RETURN_CODE::READ_ATTRIBUTES_ERROR;

   708 	}

   709 	return iErrorCode;

   710 }

   711 

   712 int CATProject::RunUninstrumentFailed()

   713 {

   714 	LOG_FUNC_ENTRY("CATProject::RunUninstrumentFailed");

   715 	// Read attributes.

   716 	if ( ! ReadAttributes() )

   717 		return AT_RETURN_CODE::READ_ATTRIBUTES_ERROR;

   718 	// Init makefile member for this run mode.

   719 	if ( m_eBuildSystem == SBS_V1 )

   720 		InitSbs1MakeFileWithPathToTemp();

   721 	// Read makefile to get project attributes

   722 	if( ReadMakeFile() )

   723 	{

   724 		// Filter modules

   725 		FilterModules();

   726 		// Restore modules to make sure no changes left

   727 		if( RestoreModules() )

   728 		{

   729 			// Delete temporary dirs of modules

   730 			if(! DeleteTemporaryDirs() )

   731 			{

   732 

   733 			}

   734 

   735 		}

   736 		else

   737 		{

   738 

   739 		}

   740 	}

   741 	else

   742 	{

   743 

   744 	}

   745 	// Projects

   746 	if ( ! DirDelete( AT_TEMP_DIR, true ) )

   747 	{

   748 

   749 	}

   750 	return AT_RETURN_CODE::OK;

   751 }

   752 

   753 // ----------------------------------------------------------------------------

   754 // Main Functions

   755 // ----------------------------------------------------------------------------

   756 void CATProject::DisplayCompileSummary()

   757 {

   758 	LOG_FUNC_ENTRY("CATProject::DisplayCompileSummary");

   759 	cout << AT_BUILD_SUMMARY_HEADER;

   760 	// Supported modules

   761 	for( size_t i = 0; i < m_vModules.size(); i++ )

   762 	{

   763 		// Successful

   764 		if ( m_vModules.at(i)->GetErrors().empty() )

   765 		{

   766 			// Create build complete file for Carbide xtension

   767 			m_vModules.at(i)->CreateBuildCompleteFile();

   768 			cout << AT_BUILD_SUMMARY_INSTRUMENTED_BUILD_COMPLETE

   769 				<< GetPathOrFileName( true, m_vModules.at(i)->GetMmpFile() )

   770 				<< endl

   771 				<< AT_BUILD_SUMMARY_TARGET

   772 				<< m_vModules.at(i)->GetBinaryName()

   773 				<< endl;

   774 			// Datafiles

   775 			// Use module data file name if project's data file not defined.

   776 			if ( m_eLoggingMode == CATProject::S60 

   777 				&& m_vModules.at(i)->GetTargetType().compare("exe") == 0 )

   778 			{

   779 				if ( m_sS60FileName.empty() )

   780 					cout << AT_BUILD_SUMMARY_DATA_FILE_NAME

   781 						<< m_vModules.at(i)->GetS60FileName()

   782 						<< endl;

   783 				else

   784 					cout << AT_BUILD_SUMMARY_DATA_FILE_NAME

   785 					<< m_sS60FileName

   786 					<< endl;

   787 			}

   788 		}

   789 		else

   790 		{

   791 			// Failed

   792 			cout << AT_BUILD_SUMMARY_FAILED

   793 				<< GetPathOrFileName( true, m_vModules.at(i)->GetMmpFile() )

   794 				<< endl

   795 				<< AT_BUILD_SUMMARY_TARGET

   796 				<< m_vModules.at(i)->GetBinaryName()

   797 				<< endl;

   798 			// Print errors.

   799 			cout << AT_BUILD_SUMMARY_ERRORS

   800 				<< m_vModules.at(i)->GetErrors()

   801 				<< endl;

   802 		}

   803 	}

   804 

   805 	// Static libraries

   806 	for( size_t i = 0; i < m_vStaticLibraries.size(); i++ )

   807 	{

   808 		if ( m_vStaticLibraries.at(i)->GetErrors().empty() )

   809 		{

   810 			cout << AT_BUILD_SUMMARY_NORMAL_BUILD_COMPLETE

   811 				<< GetPathOrFileName( true, m_vStaticLibraries.at(i)->GetMmpFile())

   812 				<< endl

   813 				<< AT_BUILD_SUMMARY_TARGET

   814 				<< m_vStaticLibraries.at(i)->GetBinaryName()

   815 				<< endl

   816 				<< AT_BUILD_SUMMARY_STATIC_LIBRARY

   817 				<< endl;

   818 				

   819 		}

   820 		else

   821 		{

   822 			// Failed

   823 			cout << AT_BUILD_SUMMARY_FAILED

   824 				<< GetPathOrFileName( true, m_vStaticLibraries.at(i)->GetMmpFile() )

   825 				<< endl

   826 				<< AT_BUILD_SUMMARY_TARGET

   827 				<< m_vStaticLibraries.at(i)->GetBinaryName()

   828 				<< endl;

   829 			// Print errors.

   830 			cout << AT_BUILD_SUMMARY_ERRORS

   831 				<< m_vStaticLibraries.at(i)->GetErrors()

   832 				<< endl;

   833 		}

   834 	}

   835 

   836 	// Unsupported modules

   837 	for( size_t i = 0; i < m_vUnsupportedModules.size(); i++ )

   838 	{

   839 		cout << AT_BUILD_SUMMARY_NORMAL_BUILD_COMPLETE

   840 			<< GetPathOrFileName( true, m_vUnsupportedModules.at(i)->GetMmpFile() )

   841 			<< endl

   842 			<< AT_BUILD_SUMMARY_TARGET

   843 			<< m_vUnsupportedModules.at(i)->GetBinaryName()

   844 			<< endl;

   845 		cout << m_vUnsupportedModules.at(i)->GetCompileInfoText() << endl;

   846 	}

   847 }

   848 

   849 void CATProject::DisplayBuildSummary( void )

   850 {

   851 	LOG_FUNC_ENTRY("CATProject::DisplayBuildSummary");

   852 	cout << endl;

   853 	// Build information

   854 	cout << AT_BUILD_SUMMARY_BUILD_TYPE << GetBuildTypeString() << endl;

   855 	// Platform

   856 	cout << AT_BUILD_SUMMARY_BUILD_PLATFORM << m_sPlatform << endl;

   857 	// Possible variant

   858 	if ( ! m_sVariant.empty() )

   859 		cout << AT_BUILD_SUMMARY_BUILD_VARIANT << m_sVariant << endl;

   860 	// Logging mode

   861 	cout << AT_BUILD_SUMMARY_LOGGING_MODE;

   862 	if ( m_eLoggingMode == S60 )

   863 		cout  << AT_BUILD_SUMMARY_S60;

   864 	else if ( m_eLoggingMode == XTI )

   865 		cout << AT_BUILD_SUMMARY_XTI;

   866 	else if ( m_eLoggingMode == XTI_FAST )

   867 		cout << AT_BUILD_SUMMARY_XTI_FAST;

   868 	cout << endl;

   869 	// Call stack sizes

   870 	cout << AT_BUILD_SUMMARY_ALLOC_CALL_STACK_SIZE

   871 		<< m_iAllocCallStackSize

   872 		<< endl;

   873 	cout << AT_BUILD_SUMMARY_FREE_CALL_STACK_SIZE

   874 		<< m_iFreeCallStackSize

   875 		<< endl;

   876 }

   877 

   878 bool CATProject::CreateMakeFile()

   879 {

   880 	switch ( m_eBuildSystem )

   881 	{

   882 	case SBS_V1:

   883 		if( ! CreateMakeFileSbs1() )

   884 			return false;

   885 		// Copy main make file.

   886 		if( ! CopyMakeFileSbs1ToTemporaryFolder() )

   887 			return false;

   888 		// Run Reallyclean.

   889 		if( ! RunReallyCleanSbs1() )

   890 			return false;

   891 		// Run export.

   892 		if( ! RunExportSbs1() )

   893 			return false;

   894 		// Create level 2 makefiles.

   895 		if( ! CreateMakeFileSbs1Level2() )

   896 			return false;

   897 		return true;

   898 	case SBS_V2:

   899 		return CreateMakeFileSbs2();

   900 	default:

   901 		return false;

   902 	}

   903 }

   904 

   905 bool CATProject::CreateMakeFileSbs1()

   906 {

   907 	LOG_FUNC_ENTRY("CATProject::CreateMakeFileSbs1");

   908 

   909 	// If variant defined check does it exist.

   910 	if( ! m_sVariant.empty() )

   911 	{

   912 		if ( ! CheckVariant( m_sEpocRoot, m_sVariant ) )

   913 		{

   914 			cout << INVALID_VARIANT_ERROR;

   915 			if ( IsDefaultVariant( m_sEpocRoot ) )

   916 			{

   917 				m_sVariant = "default";

   918 				cout << USING_DEFAULT_VARIANT_MESSAGE;

   919 				if ( ! WriteAttributes() )

   920 					return false;

   921 			}

   922 			else

   923 			{

   924 				cout << NO_DEFAULT_VARIANT_ERROR;

   925 				return false;

   926 			}

   927 		}

   928 	}

   929 

   930 	// Create level 1 make file.

   931 	string sCmd( "bldmake bldfiles " );

   932 	sCmd.append( m_sPlatform );

   933 	cout << AT_MSG_SYSTEM_CALL << sCmd << endl;

   934 	(void)system( sCmd.c_str() );

   935 	return InitSbs1MakeFileWithPath();

   936 }

   937 

   938 bool CATProject::CopyMakeFileSbs1ToTemporaryFolder()

   939 {

   940 	LOG_FUNC_ENTRY("CATProject::CopyMakeFileSbs1ToTemporaryFolder");

   941 	// Check that temporary dir exists if not create it.

   942 	if ( ! MakeTempDirIfNotExist() )

   943 		return false;

   944 	// Copy makefile to temporary directory

   945 	string sMakeFileInTemp( AT_TEMP_DIR );

   946 	sMakeFileInTemp.append( "\\" );

   947 	sMakeFileInTemp.append( AT_LEVEL_1_MAKEFILE_NAME );

   948 	if ( ! FileCopyToPath( m_sMakeFile, sMakeFileInTemp ) )

   949 		return false;

   950 	return true;

   951 

   952 }

   953 

   954 bool CATProject::RunReallyCleanSbs1()

   955 {

   956 	LOG_FUNC_ENTRY("CATProject::RunReallyCleanSbs1");

   957 	// Check that abld.bat has been made.

   958 	if ( ! FileExists( "abld.bat" ) )

   959 		return false;

   960 	// Run reallyclean.

   961 	string sCmd( "abld reallyclean ");

   962 	sCmd.append( m_sPlatform );

   963 	if ( ! m_sVariant.empty() )

   964 	{

   965 		sCmd.append( "." );

   966 		sCmd.append( m_sVariant );

   967 	}

   968 	sCmd.append( " " );

   969 	sCmd.append( GetBuildTypeString() );

   970 	if ( m_vTargetModules.size() > 1 )

   971 	{

   972 		RunAbldCommandToAllTargets( sCmd );

   973 	}

   974 	else

   975 	{

   976 		AddTargetModuleIfDefined( sCmd );

   977 		cout << AT_MSG_SYSTEM_CALL << sCmd << endl;

   978 		(void) system( sCmd.c_str() );

   979 	}

   980 	return true;

   981 }

   982 

   983 bool CATProject::RunReallyCleanSbs2()

   984 {

   985 	LOG_FUNC_ENTRY("CATProject::RunReallyCleanSbs2");

   986 	string sCmd("");

   987 	if ( m_sBuildCommand.empty() )

   988 	{

   989 		// If no build command defined (not found in project.cfg).

   990 		sCmd.append( RAPTOR_CMD_BASE );;

   991 		sCmd.append( m_sPlatform );

   992 		sCmd.append( "_" );

   993 		sCmd.append( GetBuildTypeString() );

   994 		if ( ! m_sVariant.empty() )

   995 		{

   996 			sCmd.append( "." );

   997 			sCmd.append( m_sVariant );

   998 		}

   999 		sCmd.append( RAPTOR_REALLYCLEAN_LOG );

  1000 		AddTargetModuleIfDefined( sCmd );

  1001 		sCmd.append( " REALLYCLEAN" );

  1002 	}

  1003 	else

  1004 	{

  1005 		// When build command set use it.

  1006 		sCmd.append( m_sBuildCommand );

  1007 		sCmd.append( RAPTOR_REALLYCLEAN_LOG );

  1008 		sCmd.append( " REALLYCLEAN" );

  1009 	}

  1010 	cout << AT_MSG_SYSTEM_CALL << sCmd << endl;

  1011 	int iRet = (int)system( sCmd.c_str() );

  1012 	if ( iRet == 0 )

  1013 		return true;

  1014 	return false;

  1015 }

  1016 

  1017 bool CATProject::RunExportSbs1()

  1018 {

  1019 	LOG_FUNC_ENTRY("CATProject::RunExportSbs1");

  1020 	// Run export.

  1021 	cout << AT_MSG_SYSTEM_CALL << "abld export" << endl;

  1022 	(void) system( "abld export" );

  1023 	return true;

  1024 }

  1025 

  1026 bool CATProject::CreateMakeFileSbs1Level2()

  1027 {

  1028 	LOG_FUNC_ENTRY("CATProject::CreateMakeFileSbs1Level2");

  1029 	// Create level 2 makefiles.

  1030 	string sCmd( "abld makefile ");

  1031 	sCmd.append( m_sPlatform );

  1032 	if ( ! m_sVariant.empty() )

  1033 	{

  1034 		sCmd.append( "." );

  1035 		sCmd.append( m_sVariant );

  1036 	}

  1037 		// Check if multiple targets defined and sbs 1.

  1038 	if ( m_vTargetModules.size() > 1 )

  1039 	{

  1040 		RunAbldCommandToAllTargets( sCmd );

  1041 	}

  1042 	else

  1043 	{

  1044 		AddTargetModuleIfDefined( sCmd );

  1045 		cout << AT_MSG_SYSTEM_CALL << sCmd << endl;

  1046 		(void) system( sCmd.c_str() );

  1047 	}

  1048 	return true;

  1049 }

  1050 

  1051 bool CATProject::CreateMakeFileSbs2()

  1052 {

  1053 	LOG_FUNC_ENTRY("CATProject::CreateMakeFileSbs2");

  1054 	// Delete build directory if it exists before creating new makefiles.

  1055 	if ( DirectoryExists( "atool_temp\\build" ) )

  1056 		DirDelete( "atool_temp\\build", true );

  1057 	// Create command to create makefiles.

  1058 	string sCmd( m_sBuildCommand );

  1059 	sCmd.append( " " );

  1060 	sCmd.append( RAPTOR_MAKEFILE_SWITCH );

  1061 	sCmd.append( " " );

  1062 	sCmd.append( RAPTOR_NOBUILD_SWITCH );

  1063 	cout << AT_MSG_SYSTEM_CALL << sCmd << endl;

  1064 	int iRet = (int)system( sCmd.c_str() );

  1065 	if ( iRet == 0 )

  1066 		return true;

  1067 	return false;

  1068 }

  1069 

  1070 bool CATProject::ReadMakeFile()

  1071 {

  1072 	// Clean modules before reading.

  1073 	CleanModuleVectors();

  1074 	if ( m_eBuildSystem == SBS_V1 )

  1075 	{

  1076 		// Read level 1 makefile which contains module name and makefiles.

  1077 		if( ! ReadMakeFileSbs1Level1() )

  1078 			return false;

  1079 		// Read level 2 makefiles.

  1080 		vector<CATModule2*>::iterator it;

  1081 		// If we are compiling or etc... we need to create temporary directories.

  1082 		if ( m_eMode == COMPILE || m_eMode == INSTRUMENT || m_eMode == INSTRUMENT_CONSOLE )

  1083 		{

  1084 			// Read make makefiles from /epoc32/build... and create temporary directory.

  1085 			bool bLevel2 = true;

  1086 			for( it = m_vModules.begin(); it != m_vModules.end() ; it ++ )

  1087 			{

  1088 				if( ! (*it)->CreateTemporaryDirectory() )

  1089 					return false;

  1090 				if( ! (*it)->ReadMakeFile() )

  1091 				{

  1092 					bLevel2 = false;

  1093 					break;

  1094 				}

  1095 			}

  1096 			// If failed reading modules from level 2 makefiles.

  1097 			if ( ! bLevel2 )

  1098 			{

  1099 				// Clean modules.

  1100 				CleanModuleVectors();

  1101 				// Try use default variant if it exists.

  1102 				if ( CheckVariant( m_sEpocRoot, "default" ) )

  1103 				{

  1104 					m_sVariant = "default";

  1105 					cout << USING_DEFAULT_VARIANT_MESSAGE;

  1106 					if ( ! WriteAttributes() )

  1107 						return false;

  1108 					if ( ! InitSbs1MakeFileWithPath() )

  1109 						return false;

  1110 					if ( ! ReadMakeFileSbs1Level1() )

  1111 						return false;

  1112 					for( it = m_vModules.begin(); it != m_vModules.end() ; it ++ )

  1113 					{

  1114 						if( ! (*it)->CreateTemporaryDirectory() )

  1115 							return false;

  1116 						if( ! (*it)->ReadMakeFile() )

  1117 							return false;

  1118 					}

  1119 

  1120 				}

  1121 			}

  1122 		}

  1123 		else

  1124 		{

  1125 			// Read make files from temporary directories.

  1126 			for( it = m_vModules.begin(); it != m_vModules.end() ; it ++ )

  1127 			{

  1128 				if ( ! (*it)->ReadMakeFileFromTemp() )

  1129 					return false;

  1130 			}

  1131 		}

  1132 		return true;

  1133 	}

  1134 	else if ( m_eBuildSystem == SBS_V2 )

  1135 	{