modulehandler.cpp

ReactOS是一些高手根据Windows XP的内核编写出的类XP。内核实现机理和API函数调用几乎相同。甚至可以兼容XP的程序。喜欢研究系统内核的人可以看一看。

void
MingwModuleHandler::GetSourceFilenames ( string_list& list,
                                         bool includeGeneratedFiles ) const
{
	size_t i;

	const vector<CompilationUnit*>& compilationUnits = module.non_if_data.compilationUnits;
	for ( i = 0; i < compilationUnits.size (); i++ )
	{
		if ( includeGeneratedFiles || !compilationUnits[i]->IsGeneratedFile () )
		{
			FileLocation* sourceFileLocation = GetActualSourceFilename (
				compilationUnits[i]->GetFilename ( backend->intermediateDirectory ) );
			list.push_back ( PassThruCacheDirectory ( sourceFileLocation->filename,
			                                          sourceFileLocation->directory ) );
		}
	}
	// intentionally make a copy so that we can append more work in
	// the middle of processing without having to go recursive
	vector<If*> v = module.non_if_data.ifs;
	for ( i = 0; i < v.size (); i++ )
	{
		size_t j;
		If& rIf = *v[i];
		// check for sub-ifs to add to list
		const vector<If*>& ifs = rIf.data.ifs;
		for ( j = 0; j < ifs.size (); j++ )
			v.push_back ( ifs[j] );
		const vector<CompilationUnit*>& compilationUnits = rIf.data.compilationUnits;
		for ( j = 0; j < compilationUnits.size (); j++ )
		{
			CompilationUnit& compilationUnit = *compilationUnits[j];
			if ( includeGeneratedFiles || !compilationUnit.IsGeneratedFile () )
			{
				FileLocation* sourceFileLocation = GetActualSourceFilename (
					compilationUnit.GetFilename ( backend->intermediateDirectory ) );
				list.push_back ( PassThruCacheDirectory ( sourceFileLocation->filename,
				                                          sourceFileLocation->directory ) );
			}
		}
	}
}

void
MingwModuleHandler::GetSourceFilenamesWithoutGeneratedFiles (
	string_list& list ) const
{
	GetSourceFilenames ( list, false );
}

string
MingwModuleHandler::GetObjectFilename (
	const FileLocation* sourceFileLocation,
	string_list* pclean_files ) const
{
	string sourceFilename = sourceFileLocation->filename;
	Directory* directoryTree;
	string newExtension;
	string extension = GetExtension ( sourceFilename );
	if ( extension == ".rc" || extension == ".RC" )
		newExtension = ".coff";
	else if ( extension == ".spec" || extension == ".SPEC" )
		newExtension = ".stubs.o";
	else if ( extension == ".idl" || extension == ".IDL" )
	{
		if ( module.type == RpcServer )
			newExtension = "_s.o";
		else if ( module.type == RpcClient )
			newExtension = "_c.o";
		else
			newExtension = ".h";
	}
	else
		newExtension = ".o";

	if ( module.type == BootSector )
		directoryTree = backend->outputDirectory;
	else
		directoryTree = backend->intermediateDirectory;

	string obj_file = PassThruCacheDirectory (
		NormalizeFilename ( ReplaceExtension (
			RemoveVariables ( sourceFilename ),
							  newExtension ) ),
			directoryTree );

	if ( pclean_files )
	{
		string_list& clean_files = *pclean_files;
		CLEAN_FILE ( obj_file );
	}
	return obj_file;
}

string
MingwModuleHandler::GetModuleCleanTarget ( const Module& module ) const
{
	return module.name + "_clean";
}

void
MingwModuleHandler::GetReferencedObjectLibraryModuleCleanTargets ( vector<string>& moduleNames ) const
{
	for ( size_t i = 0; i < module.non_if_data.libraries.size (); i++ )
	{
		Library& library = *module.non_if_data.libraries[i];
		if ( library.importedModule->type == ObjectLibrary )
			moduleNames.push_back ( GetModuleCleanTarget ( *library.importedModule ) );
	}
}

void
MingwModuleHandler::GenerateCleanTarget () const
{
	if ( module.type == Alias )
		return;

	fprintf ( fMakefile,
	          ".PHONY: %s_clean\n",
	          module.name.c_str() );
	vector<string> referencedModuleNames;
	GetReferencedObjectLibraryModuleCleanTargets ( referencedModuleNames );
	fprintf ( fMakefile,
	          "%s: %s\n\t-@${rm}",
	          GetModuleCleanTarget ( module ).c_str(),
	          v2s ( referencedModuleNames, 10 ).c_str () );
	for ( size_t i = 0; i < clean_files.size(); i++ )
	{
		if ( 9==((i+1)%10) )
			fprintf ( fMakefile, " 2>$(NUL)\n\t-@${rm}" );
		fprintf ( fMakefile, " %s", clean_files[i].c_str() );
	}
	fprintf ( fMakefile, " 2>$(NUL)\n" );
	fprintf ( fMakefile, "clean: %s_clean\n\n", module.name.c_str() );
}

void
MingwModuleHandler::GenerateInstallTarget () const
{
	if ( module.installName.length () == 0 )
		return;
	fprintf ( fMakefile, ".PHONY: %s_install\n", module.name.c_str() );
	string normalizedTargetFilename = MingwModuleHandler::PassThruCacheDirectory (
		NormalizeFilename ( module.installBase + sSep + module.installName ),
		backend->installDirectory );
	fprintf ( fMakefile,
	          "%s_install: %s\n",
	          module.name.c_str (),
	          normalizedTargetFilename.c_str() );
}

void
MingwModuleHandler::GenerateDependsTarget () const
{
	fprintf ( fMakefile,
	          ".PHONY: %s_depends\n",
	          module.name.c_str() );
	fprintf ( fMakefile,
	          "%s_depends: $(RBUILD_TARGET)\n",
	          module.name.c_str () );
	fprintf ( fMakefile,
	          "\t$(ECHO_RBUILD)\n" );
	fprintf ( fMakefile,
	          "\t$(Q)$(RBUILD_TARGET) $(RBUILD_FLAGS) -dm%s mingw\n",
	          module.name.c_str () );
}

string
MingwModuleHandler::GetObjectFilenames ()
{
	const vector<CompilationUnit*>& compilationUnits = module.non_if_data.compilationUnits;
	if ( compilationUnits.size () == 0 )
		return "";

	string objectFilenames ( "" );
	for ( size_t i = 0; i < compilationUnits.size (); i++ )
	{
		if ( objectFilenames.size () > 0 )
			objectFilenames += " ";
		objectFilenames += GetObjectFilename ( compilationUnits[i]->GetFilename ( backend->intermediateDirectory ), NULL );
	}
	return objectFilenames;
}

/* static */ string
MingwModuleHandler::GenerateGccDefineParametersFromVector (
	const vector<Define*>& defines )
{
	string parameters;
	for ( size_t i = 0; i < defines.size (); i++ )
	{
		Define& define = *defines[i];
		if (parameters.length () > 0)
			parameters += " ";
		parameters += "-D";
		parameters += define.name;
		if (define.value.length () > 0)
		{
			parameters += "=";
			parameters += define.value;
		}
	}
	return parameters;
}

string
MingwModuleHandler::GenerateGccDefineParameters () const
{
	string parameters = GenerateGccDefineParametersFromVector ( module.project.non_if_data.defines );
	string s = GenerateGccDefineParametersFromVector ( module.non_if_data.defines );
	if ( s.length () > 0 )
	{
		parameters += " ";
		parameters += s;
	}
	return parameters;
}

string
MingwModuleHandler::ConcatenatePaths (
	const string& path1,
	const string& path2 ) const
{
	if ( ( path1.length () == 0 ) || ( path1 == "." ) || ( path1 == "./" ) )
		return path2;
	if ( path1[path1.length ()] == cSep )
		return path1 + path2;
	else
		return path1 + cSep + path2;
}

/* static */ string
MingwModuleHandler::GenerateGccIncludeParametersFromVector ( const vector<Include*>& includes )
{
	string parameters, path_prefix;
	for ( size_t i = 0; i < includes.size (); i++ )
	{
		Include& include = *includes[i];
		if ( parameters.length () > 0 )
			parameters += " ";
		if ( include.root == "intermediate" )
			path_prefix = "$(INTERMEDIATE)" + sSep;
		else if (include.root == "output" )
			path_prefix = "$(OUTPUT)" + sSep;
		else
			path_prefix = "";

		parameters += "-I" + path_prefix + include.directory;
	}
	return parameters;
}

string
MingwModuleHandler::GenerateGccIncludeParameters () const
{
	string parameters = GenerateGccIncludeParametersFromVector ( module.non_if_data.includes );
	string s = GenerateGccIncludeParametersFromVector ( module.project.non_if_data.includes );
	if ( s.length () > 0 )
	{
		parameters += " ";
		parameters += s;
	}
	return parameters;
}

string
MingwModuleHandler::GenerateCompilerParametersFromVector ( const vector<CompilerFlag*>& compilerFlags ) const
{
	string parameters;
	for ( size_t i = 0; i < compilerFlags.size (); i++ )
	{
		CompilerFlag& compilerFlag = *compilerFlags[i];
		if ( parameters.length () > 0 )
			parameters += " ";
		parameters += compilerFlag.flag;
	}
	return parameters;
}

string
MingwModuleHandler::GenerateLinkerParametersFromVector ( const vector<LinkerFlag*>& linkerFlags ) const
{
	string parameters;
	for ( size_t i = 0; i < linkerFlags.size (); i++ )
	{
		LinkerFlag& linkerFlag = *linkerFlags[i];
		if ( parameters.length () > 0 )
			parameters += " ";
		parameters += linkerFlag.flag;
	}
	return parameters;
}

string
MingwModuleHandler::GenerateImportLibraryDependenciesFromVector (
	const vector<Library*>& libraries )
{
	string dependencies ( "" );
	int wrap_count = 0;
	for ( size_t i = 0; i < libraries.size (); i++ )
	{
		if ( wrap_count++ == 5 )
			dependencies += " \\\n\t\t", wrap_count = 0;
		else if ( dependencies.size () > 0 )
			dependencies += " ";
		dependencies += GetImportLibraryDependency ( *libraries[i]->importedModule );
	}
	return dependencies;
}

string
MingwModuleHandler::GenerateLinkerParameters () const
{
	return GenerateLinkerParametersFromVector ( module.linkerFlags );
}

void
MingwModuleHandler::GenerateMacro (
	const char* assignmentOperation,
	const string& macro,
	const IfableData& data )
{
	size_t i;
	bool generateAssignment;

	generateAssignment = (use_pch && module.pch != NULL ) || data.includes.size () > 0 || data.defines.size () > 0 || data.compilerFlags.size () > 0;
	if ( generateAssignment )
	{
		fprintf ( fMakefile,
		          "%s %s",
		          macro.c_str(),
		          assignmentOperation );
	}

	if ( use_pch && module.pch != NULL )
	{
		fprintf ( fMakefile,
		          " -I%s",
		          GetDirectory ( GetPrecompiledHeaderFilename () ).c_str () );
	}

	string compilerParameters = GenerateCompilerParametersFromVector ( data.compilerFlags );
	if ( compilerParameters.size () > 0 )
	{
		fprintf (
			fMakefile,
			" %s",
			compilerParameters.c_str () );
	}

	for ( i = 0; i < data.includes.size(); i++ )
	{
		const Include& include = *data.includes[i];
		string includeDirectory, path_prefix;
		if ( include.baseModule != NULL &&
		     ( include.baseModule->type == RpcServer ||
		       include.baseModule->type == RpcClient ||
		       include.baseModule->type == IdlHeader) )
			includeDirectory = PassThruCacheDirectory ( NormalizeFilename ( include.directory ),
			                                            backend->intermediateDirectory );
		else
			includeDirectory = include.directory;

		if ( include.root == "intermediate" )
			path_prefix = "$(INTERMEDIATE)" + sSep;
		else if (include.root == "output" )
			path_prefix = "$(OUTPUT)" + sSep;
		else
			path_prefix = "";

		fprintf (
			fMakefile,
			" -I%s%s",
			path_prefix.c_str(),
			includeDirectory.c_str() );
	}
	for ( i = 0; i < data.defines.size(); i++ )
	{
		Define& d = *data.defines[i];
		fprintf (
			fMakefile,
			" -D%s",
			d.name.c_str() );
		if ( d.value.size() )
			fprintf (
				fMakefile,
				"=%s",
				d.value.c_str() );
	}
	if ( generateAssignment )
	{
		fprintf ( fMakefile, "\n" );
	}
}

void
MingwModuleHandler::GenerateMacros (
	const char* assignmentOperation,
	const IfableData& data,
	const vector<LinkerFlag*>* linkerFlags )
{
	size_t i;

	GenerateMacro ( assignmentOperation,
	                cflagsMacro,
	                data );
	GenerateMacro ( assignmentOperation,
	                windresflagsMacro,
	                data );

	if ( linkerFlags != NULL )
	{
		string linkerParameters = GenerateLinkerParametersFromVector ( *linkerFlags );
		if ( linkerParameters.size () > 0 )
		{
			fprintf (
				fMakefile,
				"%s %s %s\n",
				linkerflagsMacro.c_str (),
				assignmentOperation,
				linkerParameters.c_str() );
		}
	}

	if ( data.libraries.size () > 0 )
	{
		string deps = GenerateImportLibraryDependenciesFromVector ( data.libraries );
		if ( deps.size () > 0 )
		{
			fprintf (
				fMakefile,
				"%s %s %s\n",
				libsMacro.c_str(),
				assignmentOperation,
				deps.c_str() );
		}
	}

	const vector<If*>& ifs = data.ifs;
	for ( i = 0; i < ifs.size(); i++ )
	{
		If& rIf = *ifs[i];
		if ( rIf.data.defines.size()
			|| rIf.data.includes.size()
			|| rIf.data.libraries.size()
			|| rIf.data.compilationUnits.size()
			|| rIf.data.compilerFlags.size()
			|| rIf.data.ifs.size() )
		{
			fprintf (
				fMakefile,
				"%s (\"$(%s)\",\"%s\")\n",
				rIf.negated ? "ifneq" : "ifeq",
				rIf.property.c_str(),