modulehandler.cpp

来自「一个类似windows」· C++ 代码 · 共 2,308 行 · 第 1/5 页

			|| rIf.data.ifs.size() )
		{
			fprintf (
				fMakefile,
				"%s (\"$(%s)\",\"%s\")\n",
				rIf.negated ? "ifneq" : "ifeq",
				rIf.property.c_str(),
				rIf.value.c_str() );
			GenerateObjectMacros (
				"+=",
				rIf.data,
				NULL );
			fprintf ( 
				fMakefile,
				"endif\n\n" );
		}
	}

	vector<CompilationUnit*> sourceCompilationUnits;
	GetModuleSpecificCompilationUnits ( sourceCompilationUnits );
	for ( i = 0; i < sourceCompilationUnits.size (); i++ )
	{
		fprintf (
			fMakefile,
			"%s += %s\n",
			objectsMacro.c_str(),
			GetObjectFilename ( sourceCompilationUnits[i]->GetFilename ( backend->intermediateDirectory ), NULL ).c_str () );
	}
	CleanupCompilationUnitVector ( sourceCompilationUnits );
}

string
MingwModuleHandler::GetPrecompiledHeaderFilename () const
{
	const string& basePchFilename = module.pch->file.name + ".gch";
	return PassThruCacheDirectory ( NormalizeFilename ( basePchFilename ),
	                                backend->intermediateDirectory );
}

void
MingwModuleHandler::GenerateGccCommand (
	const FileLocation* sourceFileLocation,
	const string& extraDependencies,
	const string& cc,
	const string& cflagsMacro )
{
	string sourceFilename = PassThruCacheDirectory ( sourceFileLocation );
	string dependencies = sourceFilename;
	if ( extraDependencies != "" )
		dependencies += " " + extraDependencies;
	if ( module.pch && use_pch )
		dependencies += " " + GetPrecompiledHeaderFilename ();
	
	/* WIDL generated headers may be used */
	vector<string> rpcDependencies;
	GetRpcHeaderDependencies ( rpcDependencies );
	dependencies += " " + v2s ( rpcDependencies, 5 );
	dependencies += " " + NormalizeFilename ( module.xmlbuildFile );

	string objectFilename = GetObjectFilename (
		sourceFileLocation, &clean_files );
	fprintf ( fMakefile,
	          "%s: %s | %s\n",
	          objectFilename.c_str (),
	          dependencies.c_str (),
	          GetDirectory ( objectFilename ).c_str () );
	fprintf ( fMakefile, "\t$(ECHO_CC)\n" );
	fprintf ( fMakefile,
	         "\t%s -c $< -o $@ %s\n",
	         cc.c_str (),
	         cflagsMacro.c_str () );
}

void
MingwModuleHandler::GenerateGccAssemblerCommand (
	const FileLocation* sourceFileLocation,
	const string& cc,
	const string& cflagsMacro )
{
	string sourceFilename = PassThruCacheDirectory ( sourceFileLocation );
	string dependencies = sourceFilename;
	dependencies += " " + NormalizeFilename ( module.xmlbuildFile );
	string objectFilename = GetObjectFilename (
		sourceFileLocation, &clean_files );
	fprintf ( fMakefile,
	          "%s: %s | %s\n",
	          objectFilename.c_str (),
	          dependencies.c_str (),
	          GetDirectory ( objectFilename ).c_str () );
	fprintf ( fMakefile, "\t$(ECHO_GAS)\n" );
	fprintf ( fMakefile,
	          "\t%s -x assembler-with-cpp -c $< -o $@ -D__ASM__ %s\n",
	          cc.c_str (),
	          cflagsMacro.c_str () );
}

void
MingwModuleHandler::GenerateNasmCommand (
	const FileLocation* sourceFileLocation,
	const string& nasmflagsMacro )
{
	string sourceFilename = PassThruCacheDirectory ( sourceFileLocation );
	string dependencies = sourceFilename;
	dependencies += " " + NormalizeFilename ( module.xmlbuildFile );
	string objectFilename = GetObjectFilename (
		sourceFileLocation, &clean_files );
	fprintf ( fMakefile,
	          "%s: %s | %s\n",
	          objectFilename.c_str (),
	          dependencies.c_str (),
	          GetDirectory ( objectFilename ).c_str () );
	fprintf ( fMakefile, "\t$(ECHO_NASM)\n" );
	fprintf ( fMakefile,
	          "\t%s -f win32 $< -o $@ %s\n",
	          "$(Q)${nasm}",
	          nasmflagsMacro.c_str () );
}

void
MingwModuleHandler::GenerateWindresCommand (
	const FileLocation* sourceFileLocation,
	const string& windresflagsMacro )
{
	string sourceFilename = PassThruCacheDirectory ( sourceFileLocation );
	string dependencies = sourceFilename;
	dependencies += " " + NormalizeFilename ( module.xmlbuildFile );
	string objectFilename = GetObjectFilename ( sourceFileLocation, &clean_files );
	string sourceFilenamePart = ReplaceExtension ( GetFilename ( sourceFilename ), "" );
	string rciFilename = ros_temp + module.name + "." + sourceFilenamePart + ".rci.tmp";
	string resFilename = ros_temp + module.name + "." + sourceFilenamePart + ".res.tmp";
	if ( module.useWRC )
	{
		fprintf ( fMakefile,
		          "%s: %s $(WRC_TARGET) | %s\n",
		          objectFilename.c_str (),
		          dependencies.c_str (),
		          GetDirectory ( objectFilename ).c_str () );
		fprintf ( fMakefile, "\t$(ECHO_WRC)\n" );
		fprintf ( fMakefile,
		         "\t${gcc} -xc -E -DRC_INVOKED ${%s} %s > %s\n",
		         windresflagsMacro.c_str (),
		         sourceFilename.c_str (),
		         rciFilename.c_str () );
		fprintf ( fMakefile,
		         "\t$(Q)$(WRC_TARGET) ${%s} %s %s\n",
		         windresflagsMacro.c_str (),
		         rciFilename.c_str (),
		         resFilename.c_str () );
		fprintf ( fMakefile,
		         "\t-@${rm} %s 2>$(NUL)\n",
		         rciFilename.c_str () );
		fprintf ( fMakefile,
		         "\t${windres} %s -o $@\n",
		         resFilename.c_str () );
		fprintf ( fMakefile,
		         "\t-@${rm} %s 2>$(NUL)\n",
		         resFilename.c_str () );
	}
	else
	{
		fprintf ( fMakefile,
		          "%s: %s $(WRC_TARGET) | %s\n",
		          objectFilename.c_str (),
		          dependencies.c_str (),
		          GetDirectory ( objectFilename ).c_str () );
		fprintf ( fMakefile, "\t$(ECHO_WRC)\n" );
		fprintf ( fMakefile,
		         "\t${windres} $(%s) %s -o $@\n",
		         windresflagsMacro.c_str (),
		         sourceFilename.c_str () );
	}
}

void
MingwModuleHandler::GenerateWinebuildCommands (
	const FileLocation* sourceFileLocation )
{
	string sourceFilename = PassThruCacheDirectory ( sourceFileLocation );
	string dependencies = sourceFilename;
	dependencies += " " + NormalizeFilename ( module.xmlbuildFile );

	string basename = GetBasename ( sourceFilename );
	string def_file = PassThruCacheDirectory (
		basename + ".spec.def",
		backend->intermediateDirectory );
	CLEAN_FILE(def_file);

	string stub_file = PassThruCacheDirectory (
		basename + ".stubs.c",
		backend->intermediateDirectory );
	CLEAN_FILE(stub_file)

	fprintf ( fMakefile,
	          "%s: %s $(WINEBUILD_TARGET) | %s\n",
	          def_file.c_str (),
	          dependencies.c_str (),
	          GetDirectory ( def_file ).c_str () );
	fprintf ( fMakefile, "\t$(ECHO_WINEBLD)\n" );
	fprintf ( fMakefile,
	          "\t%s -o %s --def -E %s\n",
	          "$(Q)$(WINEBUILD_TARGET)",
	          def_file.c_str (),
	          sourceFilename.c_str () );
	fprintf ( fMakefile,
	          "%s: %s $(WINEBUILD_TARGET)\n",
	          stub_file.c_str (),
	          sourceFilename.c_str () );
	fprintf ( fMakefile, "\t$(ECHO_WINEBLD)\n" );
	fprintf ( fMakefile,
	          "\t%s -o %s --pedll %s\n",
	          "$(Q)$(WINEBUILD_TARGET)",
	          stub_file.c_str (),
	          sourceFilename.c_str () );
}

string
MingwModuleHandler::GetWidlFlags ( const CompilationUnit& compilationUnit )
{
	return compilationUnit.GetSwitches ();
}

string
MingwModuleHandler::GetRpcServerHeaderFilename ( string basename ) const
{
	return PassThruCacheDirectory ( basename + "_s.h",
	                                backend->intermediateDirectory );
}
		
void
MingwModuleHandler::GenerateWidlCommandsServer (
	const CompilationUnit& compilationUnit,
	const string& widlflagsMacro )
{
	FileLocation* sourceFileLocation = compilationUnit.GetFilename ( backend->intermediateDirectory );
	string filename = sourceFileLocation->filename;
	string dependencies = filename;
	dependencies += " " + NormalizeFilename ( module.xmlbuildFile );

	string basename = GetBasename ( filename );

	string generatedHeaderFilename = GetRpcServerHeaderFilename ( basename );
	CLEAN_FILE(generatedHeaderFilename);

  	string generatedServerFilename = PassThruCacheDirectory (
		basename + "_s.c",
		backend->intermediateDirectory );
	CLEAN_FILE(generatedServerFilename);

	fprintf ( fMakefile,
	          "%s %s: %s $(WIDL_TARGET) | %s\n",
	          generatedServerFilename.c_str (),
	          generatedHeaderFilename.c_str (),
	          dependencies.c_str (),
	          GetDirectory ( generatedServerFilename ).c_str () );
	fprintf ( fMakefile, "\t$(ECHO_WIDL)\n" );
	fprintf ( fMakefile,
	          "\t%s %s %s -h -H %s -s -S %s %s\n",
	          "$(Q)$(WIDL_TARGET)",
	          GetWidlFlags ( compilationUnit ).c_str (),
	          widlflagsMacro.c_str (),
	          generatedHeaderFilename.c_str (),
	          generatedServerFilename.c_str (),
	          filename.c_str () );
}

string
MingwModuleHandler::GetRpcClientHeaderFilename ( string basename ) const
{
	return PassThruCacheDirectory ( basename + "_c.h",
	                                backend->intermediateDirectory );
}

void
MingwModuleHandler::GenerateWidlCommandsClient (
	const CompilationUnit& compilationUnit,
	const string& widlflagsMacro )
{
	FileLocation* sourceFileLocation = compilationUnit.GetFilename ( backend->intermediateDirectory );
	string filename = sourceFileLocation->filename;
	string dependencies = filename;
	dependencies += " " + NormalizeFilename ( module.xmlbuildFile );

	string basename = GetBasename ( filename );

	string generatedHeaderFilename = GetRpcClientHeaderFilename ( basename );
	CLEAN_FILE(generatedHeaderFilename);

  	string generatedClientFilename = PassThruCacheDirectory (
		basename + "_c.c",
		backend->intermediateDirectory );
	CLEAN_FILE(generatedClientFilename);

	fprintf ( fMakefile,
	          "%s %s: %s $(WIDL_TARGET) | %s\n",
	          generatedClientFilename.c_str (),
	          generatedHeaderFilename.c_str (),
	          dependencies.c_str (),
	          GetDirectory ( generatedClientFilename ).c_str () );
	fprintf ( fMakefile, "\t$(ECHO_WIDL)\n" );
	fprintf ( fMakefile,
	          "\t%s %s %s -h -H %s -c -C %s %s\n",
	          "$(Q)$(WIDL_TARGET)",
	          GetWidlFlags ( compilationUnit ).c_str (),
	          widlflagsMacro.c_str (),
	          generatedHeaderFilename.c_str (),
	          generatedClientFilename.c_str (),
	          filename.c_str () );
}

void
MingwModuleHandler::GenerateWidlCommands (
	const CompilationUnit& compilationUnit,
	const string& widlflagsMacro )
{
	if ( module.type == RpcServer )
		GenerateWidlCommandsServer ( compilationUnit,
		                             widlflagsMacro );
	else
		GenerateWidlCommandsClient ( compilationUnit,
		                             widlflagsMacro );
}

void
MingwModuleHandler::GenerateCommands (
	const CompilationUnit& compilationUnit,
	const string& cc,
	const string& cppc,
	const string& cflagsMacro,
	const string& nasmflagsMacro,
	const string& windresflagsMacro,
	const string& widlflagsMacro )
{
	FileLocation* sourceFileLocation = compilationUnit.GetFilename ( backend->intermediateDirectory );
	string filename = sourceFileLocation->filename;
	string extension = GetExtension ( filename );
	if ( extension == ".c" || extension == ".C" )
	{
		GenerateGccCommand ( sourceFileLocation,
		                     GetCompilationUnitDependencies ( compilationUnit ),
		                     cc,
		                     cflagsMacro );
		return;
	}
	else if ( extension == ".cc" || extension == ".CC" ||
	          extension == ".cpp" || extension == ".CPP" ||
	          extension == ".cxx" || extension == ".CXX" )
	{
		GenerateGccCommand ( sourceFileLocation,
		                     GetCompilationUnitDependencies ( compilationUnit ),
		                     cppc,
		                     cflagsMacro );
		return;
	}
	else if ( extension == ".s" || extension == ".S" )
	{
		GenerateGccAssemblerCommand ( sourceFileLocation,
		                              cc,
		                              cflagsMacro );
		return;
	}
	else if ( extension == ".asm" || extension == ".ASM" )
	{
		GenerateNasmCommand ( sourceFileLocation,
		                      nasmflagsMacro );
		return;
	}
	else if ( extension == ".rc" || extension == ".RC" )
	{
		GenerateWindresCommand ( sourceFileLocation,
		                         windresflagsMacro );
		return;
	}
	else if ( extension == ".spec" || extension == ".SPEC" )
	{
		GenerateWinebuildCommands ( sourceFileLocation );
		GenerateGccCommand ( GetActualSourceFilename ( sourceFileLocation ),
		                     "",
		                     cc,
		                     cflagsMacro );
		return;
	}
	else if ( extension == ".idl" || extension == ".IDL" )
	{
		GenerateWidlCommands ( compilationUnit,
		                       widlflagsMacro );
		GenerateGccCommand ( GetActualSourceFilename ( sourceFileLocation ),
		                     GetExtraDependencies ( filename ),
		                     cc,
		                     cflagsMacro );
		return;
	}

	throw InvalidOperationException ( __FILE__,
	                                  __LINE__,
	                                  "Unsupported filename extension '%s' in file '%s'",
	                                  extension.c_str (),
	                                  filename.c_str () );
}

void
MingwModuleHandler::GenerateBuildMapCode ( const char *mapTarget )
{
	fprintf ( fMakefile,
	          "ifeq ($(ROS_BUILDMAP),full)\n" );

	string mapFilename = PassThruCacheDirectory (
		GetBasename ( module.GetPath () ) + ".map",
		backend->outputDirectory );
	CLEAN_FILE ( mapFilename );
	
	fprintf ( fMakefile,
	          "\t$(ECHO_OBJDUMP)\n" );
	fprintf ( fMakefile,
	          "\t$(Q)${objdump} -d -S %s > %s\n",
			  mapTarget ? mapTarget :  "$@",
	          mapFilename.c_str () );

	fprintf ( fMakefile,
	          "else\n" );
	fprintf ( fMakefile,
	          "ifeq ($(ROS_BUILDMAP),yes)\n" );

	fprintf ( fMakefile,
	          "\t$(ECHO_NM)\n" );
	fprintf ( fMakefile,
	          "\t$(Q)${nm} --numeric-sort %s > %s\n",
			  mapTarget ? mapTarget :  "$@",
	          mapFilename.c_str () );

	fprintf ( fMakefile,
	          "endif\n" );

	fprintf ( fMakefile,
	          "endif\n" );
}

void
MingwModuleHandler::GenerateBuildNonSymbolStrippedCode ()
{
	fprintf ( fMakefile,
	          "ifeq ($(ROS_BUILDNOSTRIP),yes)\n" );

	string filename = module.GetPath ();
	string outputFilename = PassThruCacheDirectory (
		filename,
		backend->outputDirectory );
	string nostripFilename = PassThruCacheDirectory (
		GetBasename ( filename ) + ".nostrip" + GetExtension ( filename ),
		backend->outputDirectory );
	CLEAN_FILE ( nostripFilename );
	
	fprintf ( fMakefile,
	          "\t$(ECHO_CP)\n" );
	fprintf ( fMakefile,
			  "\t${cp} %s %s 1>$(NUL)\n",
			  outputFilename.c_str (),
	          nostripFilename.c_str () );
	
	fprintf ( fMakefile,
	          "endif\n" );
}