-#ifndef MINGW_MODULEHANDLER_H\r
-#define MINGW_MODULEHANDLER_H\r
-\r
-#include "../backend.h"\r
-#include "mingw.h"\r
-\r
-class MingwBackend;\r
-\r
-extern std::string\r
-GetTargetMacro ( const Module&, bool with_dollar = true );\r
-\r
-extern std::string\r
-PrefixFilename (\r
- const std::string& filename,\r
- const std::string& prefix );\r
-\r
-class MingwModuleHandler\r
-{\r
-public:\r
- MingwModuleHandler ( const Module& module_ );\r
- virtual ~MingwModuleHandler();\r
-\r
- static void SetBackend ( MingwBackend* backend_ );\r
- static void SetMakefile ( FILE* f );\r
- static void SetUsePch ( bool use_pch );\r
-\r
- static std::string PassThruCacheDirectory (\r
- const std::string &f,\r
- Directory* directoryTree );\r
-\r
- static std::string GetTargetFilename (\r
- const Module& module,\r
- string_list* pclean_files );\r
-\r
- static std::string\r
- GetImportLibraryFilename (\r
- const Module& module,\r
- string_list* pclean_files );\r
-\r
- std::string GetModuleTargets ( const Module& module );\r
- void GetObjectsVector ( const IfableData& data,\r
- std::vector<std::string>& objectFiles ) const;\r
- void GenerateObjectMacro();\r
- void GenerateTargetMacro();\r
- void GenerateOtherMacros();\r
-\r
- static MingwModuleHandler* InstanciateHandler ( const Module& module_,\r
- MingwBackend* backend_ );\r
- virtual HostType DefaultHost() = 0;\r
- void GeneratePreconditionDependencies ();\r
- virtual void Process () = 0;\r
- virtual std::string TypeSpecificCFlags() { return ""; }\r
- virtual std::string TypeSpecificNasmFlags() { return ""; }\r
- virtual std::string TypeSpecificLinkerFlags() { return ""; }\r
- void GenerateInvocations () const;\r
- void GenerateCleanTarget () const;\r
- static bool ReferenceObjects ( const Module& module );\r
-protected:\r
- std::string GetWorkingDirectory () const;\r
- std::string GetBasename ( const std::string& filename ) const;\r
- std::string GetActualSourceFilename ( const std::string& filename ) const;\r
- std::string GetModuleArchiveFilename () const;\r
- bool IsGeneratedFile ( const File& file ) const;\r
- std::string GetImportLibraryDependency ( const Module& importedModule );\r
- void GetTargets ( const Module& dependencyModule,\r
- string_list& targets );\r
- void GetModuleDependencies ( string_list& dependencies );\r
- std::string GetAllDependencies () const;\r
- void GetSourceFilenames ( string_list& list, bool includeGeneratedFiles = true ) const;\r
- void GetSourceFilenamesWithoutGeneratedFiles ( string_list& list ) const;\r
- std::string GetObjectFilename ( const std::string& sourceFilename,\r
- string_list* pclean_files ) const;\r
-\r
- std::string GetObjectFilenames ();\r
- \r
- std::string GetPreconditionDependenciesName () const;\r
- std::string GetCFlagsMacro () const;\r
- static std::string GetObjectsMacro ( const Module& );\r
- std::string GetLinkingDependenciesMacro () const;\r
- std::string GetLibsMacro () const;\r
- std::string GetLinkerMacro () const;\r
- void GenerateCleanObjectsAsYouGoCode () const;\r
- void GenerateLinkerCommand ( const std::string& dependencies,\r
- const std::string& linker,\r
- const std::string& linkerParameters,\r
- const std::string& objectsMacro,\r
- const std::string& libsMacro );\r
- void GeneratePhonyTarget() const;\r
- void GenerateRules ();\r
- void GenerateImportLibraryTargetIfNeeded ();\r
- void GetDefinitionDependencies ( string_list& dependencies ) const;\r
- std::string GetLinkingDependencies () const;\r
- static MingwBackend* backend;\r
- static FILE* fMakefile;\r
- static bool use_pch;\r
-private:\r
- std::string ConcatenatePaths ( const std::string& path1,\r
- const std::string& path2 ) const;\r
- std::string GenerateGccDefineParametersFromVector ( const std::vector<Define*>& defines ) const;\r
- std::string GenerateGccDefineParameters () const;\r
- std::string GenerateGccIncludeParametersFromVector ( const std::vector<Include*>& includes ) const;\r
- std::string GenerateCompilerParametersFromVector ( const std::vector<CompilerFlag*>& compilerFlags ) const;\r
- std::string GenerateLinkerParametersFromVector ( const std::vector<LinkerFlag*>& linkerFlags ) const;\r
- std::string GenerateImportLibraryDependenciesFromVector ( const std::vector<Library*>& libraries );\r
- std::string GenerateLinkerParameters () const;\r
- void GenerateMacro ( const char* assignmentOperation,\r
- const std::string& macro,\r
- const IfableData& data,\r
- const std::vector<CompilerFlag*>* compilerFlags );\r
- void GenerateMacros ( const char* op,\r
- const IfableData& data,\r
- const std::vector<CompilerFlag*>* compilerFlags,\r
- const std::vector<LinkerFlag*>* linkerFlags );\r
- void GenerateObjectMacros ( const char* assignmentOperation,\r
- const IfableData& data,\r
- const std::vector<CompilerFlag*>* compilerFlags,\r
- const std::vector<LinkerFlag*>* linkerFlags );\r
- std::string GenerateGccIncludeParameters () const;\r
- std::string GenerateGccParameters () const;\r
- std::string GenerateNasmParameters () const;\r
- void GenerateGccCommand ( const std::string& sourceFilename,\r
- const std::string& cc,\r
- const std::string& cflagsMacro );\r
- void GenerateGccAssemblerCommand ( const std::string& sourceFilename,\r
- const std::string& cc,\r
- const std::string& cflagsMacro );\r
- void GenerateNasmCommand ( const std::string& sourceFilename,\r
- const std::string& nasmflagsMacro );\r
- void GenerateWindresCommand ( const std::string& sourceFilename,\r
- const std::string& windresflagsMacro );\r
- void GenerateWinebuildCommands ( const std::string& sourceFilename );\r
- std::string GetWidlFlags ( const File& file );\r
- void GenerateWidlCommandsServer (\r
- const File& file,\r
- const std::string& widlflagsMacro );\r
- void GenerateWidlCommandsClient (\r
- const File& file,\r
- const std::string& widlflagsMacro );\r
- void GenerateWidlCommands ( const File& file,\r
- const std::string& widlflagsMacro );\r
- void GenerateCommands ( const File& file,\r
- const std::string& cc,\r
- const std::string& cppc,\r
- const std::string& cflagsMacro,\r
- const std::string& nasmflagsMacro,\r
- const std::string& windresflagsMacro,\r
- const std::string& widlflagsMacro );\r
- void GenerateObjectFileTargets ( const IfableData& data,\r
- const std::string& cc,\r
- const std::string& cppc,\r
- const std::string& cflagsMacro,\r
- const std::string& nasmflagsMacro,\r
- const std::string& windresflagsMacro,\r
- const std::string& widlflagsMacro );\r
- void GenerateObjectFileTargets ( const std::string& cc,\r
- const std::string& cppc,\r
- const std::string& cflagsMacro,\r
- const std::string& nasmflagsMacro,\r
- const std::string& windresflagsMacro,\r
- const std::string& widlflagsMacro );\r
- std::string GenerateArchiveTarget ( const std::string& ar,\r
- const std::string& objs_macro ) const;\r
- void GetSpecObjectDependencies ( string_list& dependencies,\r
- const std::string& filename ) const;\r
- void GetWidlObjectDependencies ( string_list& dependencies,\r
- const std::string& filename ) const;\r
- void GetDefaultDependencies ( string_list& dependencies ) const;\r
- void GetInvocationDependencies ( const Module& module, string_list& dependencies );\r
- bool IsWineModule () const;\r
- std::string GetDefinitionFilename () const;\r
- static std::string RemoveVariables ( std::string path);\r
- void GenerateBuildMapCode ();\r
- void GenerateBuildNonSymbolStrippedCode ();\r
-public:\r
- const Module& module;\r
- string_list clean_files;\r
- std::string cflagsMacro;\r
- std::string nasmflagsMacro;\r
- std::string windresflagsMacro;\r
- std::string widlflagsMacro;\r
- std::string linkerflagsMacro;\r
- std::string objectsMacro;\r
- std::string libsMacro;\r
- std::string linkDepsMacro;\r
-};\r
-\r
-\r
-class MingwBuildToolModuleHandler : public MingwModuleHandler\r
-{\r
-public:\r
- MingwBuildToolModuleHandler ( const Module& module );\r
- virtual HostType DefaultHost() { return HostTrue; }\r
- virtual void Process ();\r
-private:\r
- void GenerateBuildToolModuleTarget ();\r
-};\r
-\r
-\r
-class MingwKernelModuleHandler : public MingwModuleHandler\r
-{\r
-public:\r
- MingwKernelModuleHandler ( const Module& module );\r
- virtual HostType DefaultHost() { return HostFalse; }\r
- virtual void Process ();\r
- std::string TypeSpecificCFlags() { return "-D_SEH_NO_NATIVE_NLG"; }\r
-private:\r
- void GenerateKernelModuleTarget ();\r
-};\r
-\r
-\r
-class MingwStaticLibraryModuleHandler : public MingwModuleHandler\r
-{\r
-public:\r
- MingwStaticLibraryModuleHandler ( const Module& module );\r
- virtual HostType DefaultHost() { return HostFalse; }\r
- virtual void Process ();\r
-private:\r
- void GenerateStaticLibraryModuleTarget ();\r
-};\r
-\r
-\r
-class MingwObjectLibraryModuleHandler : public MingwModuleHandler\r
-{\r
-public:\r
- MingwObjectLibraryModuleHandler ( const Module& module );\r
- virtual HostType DefaultHost() { return HostFalse; }\r
- virtual void Process ();\r
-private:\r
- void GenerateObjectLibraryModuleTarget ();\r
-};\r
-\r
-\r
-class MingwKernelModeDLLModuleHandler : public MingwModuleHandler\r
-{\r
-public:\r
- MingwKernelModeDLLModuleHandler ( const Module& module );\r
- virtual HostType DefaultHost() { return HostFalse; }\r
- virtual void Process ();\r
- std::string TypeSpecificCFlags() { return "-D_SEH_NO_NATIVE_NLG"; }\r
- std::string TypeSpecificLinkerFlags() { return "-nostartfiles -nostdlib"; }\r
-private:\r
- void GenerateKernelModeDLLModuleTarget ();\r
-};\r
-\r
-\r
-class MingwKernelModeDriverModuleHandler : public MingwModuleHandler\r
-{\r
-public:\r
- MingwKernelModeDriverModuleHandler ( const Module& module );\r
- virtual HostType DefaultHost() { return HostFalse; }\r
- virtual void Process ();\r
- std::string TypeSpecificCFlags() { return "-D__NTDRIVER__ -D_SEH_NO_NATIVE_NLG"; }\r
- std::string TypeSpecificLinkerFlags() { return "-nostartfiles -nostdlib"; }\r
-private:\r
- void GenerateKernelModeDriverModuleTarget ();\r
-};\r
-\r
-\r
-class MingwNativeDLLModuleHandler : public MingwModuleHandler\r
-{\r
-public:\r
- MingwNativeDLLModuleHandler ( const Module& module );\r
- virtual HostType DefaultHost() { return HostFalse; }\r
- virtual void Process ();\r
- std::string TypeSpecificCFlags() { return "-D_SEH_NO_NATIVE_NLG"; }\r
- std::string TypeSpecificLinkerFlags() { return "-nostartfiles -nostdlib"; }\r
-private:\r
- void GenerateNativeDLLModuleTarget ();\r
-};\r
-\r
-\r
-class MingwNativeCUIModuleHandler : public MingwModuleHandler\r
-{\r
-public:\r
- MingwNativeCUIModuleHandler ( const Module& module );\r
- virtual HostType DefaultHost() { return HostFalse; }\r
- virtual void Process ();\r
- std::string TypeSpecificCFlags() { return "-D__NTAPP__ -D_SEH_NO_NATIVE_NLG"; }\r
- std::string TypeSpecificLinkerFlags() { return "-nostartfiles -nostdlib"; }\r
-private:\r
- void GenerateNativeCUIModuleTarget ();\r
-};\r
-\r
-\r
-class MingwWin32DLLModuleHandler : public MingwModuleHandler\r
-{\r
-public:\r
- MingwWin32DLLModuleHandler ( const Module& module );\r
- virtual HostType DefaultHost() { return HostFalse; }\r
- virtual void Process ();\r
-private:\r
- void GenerateExtractWineDLLResourcesTarget ();\r
- void GenerateWin32DLLModuleTarget ();\r
-};\r
-\r
-\r
-class MingwWin32CUIModuleHandler : public MingwModuleHandler\r
-{\r
-public:\r
- MingwWin32CUIModuleHandler ( const Module& module );\r
- virtual HostType DefaultHost() { return HostFalse; }\r
- virtual void Process ();\r
-private:\r
- void GenerateWin32CUIModuleTarget ();\r
-};\r
-\r
-\r
-class MingwWin32GUIModuleHandler : public MingwModuleHandler\r
-{\r
-public:\r
- MingwWin32GUIModuleHandler ( const Module& module );\r
- virtual HostType DefaultHost() { return HostFalse; }\r
- virtual void Process ();\r
-private:\r
- void GenerateWin32GUIModuleTarget ();\r
-};\r
-\r
-\r
-class MingwBootLoaderModuleHandler : public MingwModuleHandler\r
-{\r
-public:\r
- MingwBootLoaderModuleHandler ( const Module& module );\r
- virtual HostType DefaultHost() { return HostFalse; }\r
- virtual void Process ();\r
- std::string TypeSpecificLinkerFlags() { return "-nostartfiles -nostdlib"; }\r
-private:\r
- void GenerateBootLoaderModuleTarget ();\r
-};\r
-\r
-\r
-class MingwBootSectorModuleHandler : public MingwModuleHandler\r
-{\r
-public:\r
- MingwBootSectorModuleHandler ( const Module& module );\r
- virtual HostType DefaultHost() { return HostFalse; }\r
- virtual void Process ();\r
- std::string TypeSpecificNasmFlags() { return "-f bin"; }\r
-private:\r
- void GenerateBootSectorModuleTarget ();\r
-};\r
-\r
-\r
-class MingwIsoModuleHandler : public MingwModuleHandler\r
-{\r
-public:\r
- MingwIsoModuleHandler ( const Module& module );\r
- virtual HostType DefaultHost() { return HostFalse; }\r
- virtual void Process ();\r
-private:\r
- void GenerateIsoModuleTarget ();\r
- std::string GetBootstrapCdDirectories ( const std::string& bootcdDirectory );\r
- std::string GetNonModuleCdDirectories ( const std::string& bootcdDirectory );\r
- std::string GetCdDirectories ( const std::string& bootcdDirectory );\r
- void GetBootstrapCdFiles ( std::vector<std::string>& out ) const;\r
- void GetNonModuleCdFiles ( std::vector<std::string>& out ) const;\r
- void GetCdFiles ( std::vector<std::string>& out ) const;\r
- void OutputBootstrapfileCopyCommands ( const std::string& bootcdDirectory );\r
- void OutputCdfileCopyCommands ( const std::string& bootcdDirectory );\r
-};\r
-\r
-\r
-class MingwLiveIsoModuleHandler : public MingwModuleHandler\r
-{\r
-public:\r
- MingwLiveIsoModuleHandler ( const Module& module );\r
- virtual HostType DefaultHost() { return HostFalse; }\r
- virtual void Process ();\r
-private:\r
- void GenerateLiveIsoModuleTarget ();\r
- void CreateDirectory ( const std::string& directory );\r
- void OutputCopyCommand ( const std::string& sourceFilename,\r
- const std::string& targetFilename,\r
- const std::string& targetDirectory );\r
- void OutputModuleCopyCommands ( std::string& livecdDirectory,\r
- std::string& livecdReactos );\r
- void OutputNonModuleCopyCommands ( std::string& livecdDirectory,\r
- std::string& livecdReactos );\r
- void OutputProfilesDirectoryCommands ( std::string& livecdDirectory );\r
- void OutputLoaderCommands ( std::string& livecdDirectory );\r
- void OutputRegistryCommands ( std::string& livecdDirectory );\r
-};\r
-\r
-\r
-class MingwTestModuleHandler : public MingwModuleHandler\r
-{\r
-public:\r
- MingwTestModuleHandler ( const Module& module );\r
- virtual HostType DefaultHost() { return HostFalse; }\r
- virtual void Process ();\r
-private:\r
- void GenerateTestModuleTarget ();\r
-};\r
-\r
-\r
-class MingwRpcServerModuleHandler : public MingwModuleHandler\r
-{\r
-public:\r
- MingwRpcServerModuleHandler ( const Module& module );\r
- virtual HostType DefaultHost() { return HostFalse; }\r
- virtual void Process ();\r
-};\r
-\r
-\r
-class MingwRpcClientModuleHandler : public MingwModuleHandler\r
-{\r
-public:\r
- MingwRpcClientModuleHandler ( const Module& module );\r
- virtual HostType DefaultHost() { return HostFalse; }\r
- virtual void Process ();\r
-};\r
-\r
-#endif /* MINGW_MODULEHANDLER_H */\r
+/*
+ * Copyright (C) 2005 Casper S. Hornstrup
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+#ifndef MINGW_MODULEHANDLER_H
+#define MINGW_MODULEHANDLER_H
+
+#include "../backend.h"
+#include "mingw.h"
+
+class MingwBackend;
+class Rule;
+
+extern std::string
+GetTargetMacro ( const Module&, bool with_dollar = true );
+
+extern std::string
+PrefixFilename (
+ const std::string& filename,
+ const std::string& prefix );
+
+class MingwModuleHandler
+{
+public:
+ MingwModuleHandler ( const Module& module_ );
+ virtual ~MingwModuleHandler();
+
+ static void SetBackend ( MingwBackend* backend_ );
+ static void SetMakefile ( FILE* f );
+ void EnablePreCompiledHeaderSupport ();
+
+ static const FileLocation* PassThruCacheDirectory (const FileLocation* fileLocation );
+
+ static const FileLocation* GetTargetFilename (
+ const Module& module,
+ string_list* pclean_files );
+
+ static const FileLocation* GetImportLibraryFilename (
+ const Module& module,
+ string_list* pclean_files );
+
+ static std::string GenerateGccDefineParametersFromVector ( const std::vector<Define*>& defines, std::set<std::string> &used_defs );
+ static std::string GenerateGccIncludeParametersFromVector ( const std::vector<Include*>& includes );
+
+ std::string GetModuleTargets ( const Module& module );
+ void GetObjectsVector ( const IfableData& data,
+ std::vector<FileLocation>& objectFiles ) const;
+ void GenerateSourceMacro();
+ void GenerateObjectMacro();
+ void GenerateTargetMacro();
+ void GenerateOtherMacros();
+
+ static MingwModuleHandler* InstanciateHandler ( const Module& module_,
+ MingwBackend* backend_ );
+ virtual HostType DefaultHost() = 0;
+ void GeneratePreconditionDependencies ();
+ virtual void Process () = 0;
+ virtual std::string TypeSpecificCFlags() { return ""; }
+ virtual std::string TypeSpecificNasmFlags() { return ""; }
+ virtual std::string TypeSpecificLinkerFlags() { return ""; }
+ void GenerateInvocations () const;
+ void GenerateCleanTarget () const;
+ void GenerateInstallTarget () const;
+ void GenerateDependsTarget () const;
+ static bool ReferenceObjects ( const Module& module );
+ virtual void AddImplicitLibraries ( Module& module ) { return; }
+
+ void OutputCopyCommand ( const FileLocation& source,
+ const FileLocation& destination );
+protected:
+ virtual void GetModuleSpecificCompilationUnits ( std::vector<CompilationUnit*>& compilationUnits );
+ std::string GetWorkingDirectory () const;
+ std::string GetBasename ( const std::string& filename ) const;
+ const FileLocation* GetActualSourceFilename ( const FileLocation* file ) const;
+ std::string GetExtraDependencies ( const FileLocation *file ) const;
+ std::string GetCompilationUnitDependencies ( const CompilationUnit& compilationUnit ) const;
+ const FileLocation* GetModuleArchiveFilename () const;
+ bool IsGeneratedFile ( const File& file ) const;
+ std::string GetImportLibraryDependency ( const Module& importedModule );
+ void GetTargets ( const Module& dependencyModule,
+ string_list& targets );
+ void GetModuleDependencies ( string_list& dependencies );
+ std::string GetAllDependencies () const;
+ void GetSourceFilenames ( std::vector<FileLocation>& list,
+ bool includeGeneratedFiles ) const;
+ void GetSourceFilenamesWithoutGeneratedFiles ( std::vector<FileLocation>& list ) const;
+ const FileLocation* GetObjectFilename ( const FileLocation* sourceFile,
+ const Module& module ) const;
+
+ std::string GetObjectFilenames ();
+
+ std::string GetPreconditionDependenciesName () const;
+ std::string GetCFlagsMacro () const;
+ static std::string GetObjectsMacro ( const Module& );
+ std::string GetLinkingDependenciesMacro () const;
+ std::string GetLibsMacro () const;
+ std::string GetLinkerMacro () const;
+ void GenerateCleanObjectsAsYouGoCode () const;
+ void GenerateRunRsymCode () const;
+ void GenerateRunStripCode () const;
+ void GenerateLinkerCommand ( const std::string& dependencies,
+ const std::string& linkerParameters,
+ const std::string& pefixupParameters );
+ void GeneratePhonyTarget() const;
+ void GenerateBuildMapCode ( const FileLocation *mapTarget = NULL );
+ void GenerateRules ();
+ void GenerateImportLibraryTargetIfNeeded ();
+ void GetDefinitionDependencies ( std::vector<FileLocation>& dependencies ) const;
+ std::string GetLinkingDependencies () const;
+ static MingwBackend* backend;
+ static FILE* fMakefile;
+ bool use_pch;
+private:
+ std::string ConcatenatePaths ( const std::string& path1,
+ const std::string& path2 ) const;
+ std::string GenerateGccDefineParameters () const;
+ std::string GenerateCompilerParametersFromVector ( const std::vector<CompilerFlag*>& compilerFlags, const CompilerType type ) const;
+ std::string GenerateLinkerParametersFromVector ( const std::vector<LinkerFlag*>& linkerFlags ) const;
+ std::string GenerateImportLibraryDependenciesFromVector ( const std::vector<Library*>& libraries );
+ std::string GenerateLinkerParameters () const;
+ void GenerateMacro ( const char* assignmentOperation,
+ const std::string& macro,
+ const IfableData& data,
+ std::set<const Define *>* used_defs,
+ bool generatingCompilerMacro );
+ void GenerateMacros ( const char* op,
+ const IfableData& data,
+ const std::vector<LinkerFlag*>* linkerFlags,
+ std::set<const Define *>& used_defs );
+ void GenerateSourceMacros ( const char* assignmentOperation,
+ const IfableData& data );
+ void GenerateObjectMacros ( const char* assignmentOperation,
+ const IfableData& data );
+ std::string GenerateGccIncludeParameters () const;
+ std::string GenerateGccParameters () const;
+ std::string GenerateNasmParameters () const;
+ const FileLocation* GetPrecompiledHeaderFilename () const;
+ void GenerateGccCommand ( const FileLocation* sourceFile,
+ const Rule *rule,
+ const std::string& extraDependencies );
+ void GenerateCommands ( const CompilationUnit& compilationUnit,
+ const std::string& extraDependencies );
+ void GenerateObjectFileTargets ( const IfableData& data );
+ void GenerateObjectFileTargets ();
+ const FileLocation* GenerateArchiveTarget ();
+ void GetMcObjectDependencies ( std::vector<FileLocation>& dependencies,
+ const FileLocation *file ) const;
+ void GetSpecObjectDependencies ( std::vector<FileLocation>& dependencies,
+ const FileLocation *file ) const;
+ void GetWidlObjectDependencies ( std::vector<FileLocation>& dependencies,
+ const FileLocation *file ) const;
+ void GetDefaultDependencies ( string_list& dependencies ) const;
+ void GetInvocationDependencies ( const Module& module, string_list& dependencies );
+ bool IsWineModule () const;
+ const FileLocation* GetDefinitionFilename () const;
+ void GenerateBuildNonSymbolStrippedCode ();
+ void CleanupCompilationUnitVector ( std::vector<CompilationUnit*>& compilationUnits );
+ void GetRpcHeaderDependencies ( std::vector<FileLocation>& dependencies ) const;
+ void GetMcHeaderDependencies ( std::vector<FileLocation>& dependencies ) const;
+ static std::string GetPropertyValue ( const Module& module, const std::string& name );
+ const FileLocation* GetRpcServerHeaderFilename ( const FileLocation *base ) const;
+ const FileLocation* GetRpcClientHeaderFilename ( const FileLocation *base ) const;
+ const FileLocation* GetRpcProxyHeaderFilename ( const FileLocation *base ) const;
+ const FileLocation* GetIdlHeaderFilename ( const FileLocation *base ) const;
+ const FileLocation* GetMcHeaderFilename ( const FileLocation *base ) const;
+ std::string GetModuleCleanTarget ( const Module& module ) const;
+ void GetReferencedObjectLibraryModuleCleanTargets ( std::vector<std::string>& moduleNames ) const;
+public:
+ const Module& module;
+ string_list clean_files;
+ std::string cflagsMacro;
+ std::string nasmflagsMacro;
+ std::string windresflagsMacro;
+ std::string widlflagsMacro;
+ std::string linkerflagsMacro;
+ std::string sourcesMacro;
+ std::string objectsMacro;
+ std::string libsMacro;
+ std::string linkDepsMacro;
+};
+
+
+class MingwBuildToolModuleHandler : public MingwModuleHandler
+{
+public:
+ MingwBuildToolModuleHandler ( const Module& module );
+ virtual HostType DefaultHost() { return HostTrue; }
+ virtual void Process ();
+private:
+ void GenerateBuildToolModuleTarget ();
+};
+
+
+class MingwKernelModuleHandler : public MingwModuleHandler
+{
+public:
+ MingwKernelModuleHandler ( const Module& module );
+ virtual HostType DefaultHost() { return HostFalse; }
+ virtual void Process ();
+private:
+ void GenerateKernelModuleTarget ();
+};
+
+
+class MingwStaticLibraryModuleHandler : public MingwModuleHandler
+{
+public:
+ MingwStaticLibraryModuleHandler ( const Module& module );
+ virtual HostType DefaultHost() { return HostFalse; }
+ virtual void Process ();
+private:
+ void GenerateStaticLibraryModuleTarget ();
+};
+
+
+class MingwHostStaticLibraryModuleHandler : public MingwModuleHandler
+{
+public:
+ MingwHostStaticLibraryModuleHandler ( const Module& module );
+ virtual HostType DefaultHost() { return HostTrue; }
+ virtual void Process ();
+private:
+ void GenerateHostStaticLibraryModuleTarget ();
+};
+
+
+class MingwObjectLibraryModuleHandler : public MingwModuleHandler
+{
+public:
+ MingwObjectLibraryModuleHandler ( const Module& module );
+ virtual HostType DefaultHost() { return HostFalse; }
+ virtual void Process ();
+private:
+ void GenerateObjectLibraryModuleTarget ();
+};
+
+
+class MingwKernelModeDLLModuleHandler : public MingwModuleHandler
+{
+public:
+ MingwKernelModeDLLModuleHandler ( const Module& module );
+ virtual HostType DefaultHost() { return HostFalse; }
+ virtual void Process ();
+ std::string TypeSpecificLinkerFlags() { return "-nostartfiles -nostdlib"; }
+ void AddImplicitLibraries ( Module& module );
+private:
+ void GenerateKernelModeDLLModuleTarget ();
+};
+
+
+class MingwKernelModeDriverModuleHandler : public MingwModuleHandler
+{
+public:
+ MingwKernelModeDriverModuleHandler ( const Module& module );
+ virtual HostType DefaultHost() { return HostFalse; }
+ virtual void Process ();
+ std::string TypeSpecificCFlags() { return "-D__NTDRIVER__"; }
+ std::string TypeSpecificLinkerFlags() { return "-nostartfiles -nostdlib"; }
+ void AddImplicitLibraries ( Module& module );
+private:
+ void GenerateKernelModeDriverModuleTarget ();
+};
+
+
+class MingwNativeDLLModuleHandler : public MingwModuleHandler
+{
+public:
+ MingwNativeDLLModuleHandler ( const Module& module );
+ virtual HostType DefaultHost() { return HostFalse; }
+ virtual void Process ();
+ std::string TypeSpecificLinkerFlags() { return "-nostartfiles -nostdlib"; }
+ void AddImplicitLibraries ( Module& module );
+private:
+ void GenerateNativeDLLModuleTarget ();
+};
+
+
+class MingwNativeCUIModuleHandler : public MingwModuleHandler
+{
+public:
+ MingwNativeCUIModuleHandler ( const Module& module );
+ virtual HostType DefaultHost() { return HostFalse; }
+ virtual void Process ();
+ std::string TypeSpecificCFlags() { return "-D__NTAPP__"; }
+ std::string TypeSpecificLinkerFlags() { return "-nostartfiles -nostdlib"; }
+ void AddImplicitLibraries ( Module& module );
+private:
+ void GenerateNativeCUIModuleTarget ();
+};
+
+
+class MingwWin32DLLModuleHandler : public MingwModuleHandler
+{
+public:
+ MingwWin32DLLModuleHandler ( const Module& module );
+ virtual HostType DefaultHost() { return HostFalse; }
+ virtual void Process ();
+ std::string TypeSpecificLinkerFlags() { return module.cplusplus ? "-nostartfiles -lgcc" : "-nostartfiles -nostdlib -lgcc"; }
+ void AddImplicitLibraries ( Module& module );
+private:
+ void GenerateWin32DLLModuleTarget ();
+};
+
+
+class MingwWin32OCXModuleHandler : public MingwModuleHandler
+{
+public:
+ MingwWin32OCXModuleHandler ( const Module& module );
+ virtual HostType DefaultHost() { return HostFalse; }
+ virtual void Process ();
+ std::string TypeSpecificLinkerFlags() { return module.cplusplus ? "-nostartfiles -lgcc" : "-nostartfiles -nostdlib -lgcc"; }
+ void AddImplicitLibraries ( Module& module );
+private:
+ void GenerateWin32OCXModuleTarget ();
+};
+
+
+class MingwWin32CUIModuleHandler : public MingwModuleHandler
+{
+public:
+ MingwWin32CUIModuleHandler ( const Module& module );
+ virtual HostType DefaultHost() { return HostFalse; }
+ virtual void Process ();
+ std::string TypeSpecificLinkerFlags() { return module.cplusplus ? "-nostartfiles -lgcc" : "-nostartfiles -nostdlib -lgcc"; }
+ void AddImplicitLibraries ( Module& module );
+private:
+ void GenerateWin32CUIModuleTarget ();
+};
+
+
+class MingwWin32GUIModuleHandler : public MingwModuleHandler
+{
+public:
+ MingwWin32GUIModuleHandler ( const Module& module );
+ virtual HostType DefaultHost() { return HostFalse; }
+ virtual void Process ();
+ std::string TypeSpecificLinkerFlags() { return module.cplusplus ? "-nostartfiles -lgcc" : "-nostartfiles -nostdlib -lgcc"; }
+ void AddImplicitLibraries ( Module& module );
+private:
+ void GenerateWin32GUIModuleTarget ();
+};
+
+
+class MingwBootLoaderModuleHandler : public MingwModuleHandler
+{
+public:
+ MingwBootLoaderModuleHandler ( const Module& module );
+ virtual HostType DefaultHost() { return HostFalse; }
+ virtual void Process ();
+ std::string TypeSpecificLinkerFlags() { return "-nostartfiles -nostdlib"; }
+private:
+ void GenerateBootLoaderModuleTarget ();
+};
+
+
+class MingwBootSectorModuleHandler : public MingwModuleHandler
+{
+public:
+ MingwBootSectorModuleHandler ( const Module& module );
+ virtual HostType DefaultHost() { return HostFalse; }
+ virtual void Process ();
+ std::string TypeSpecificNasmFlags() { return "-f bin"; }
+private:
+ void GenerateBootSectorModuleTarget ();
+};
+
+
+class MingwBootProgramModuleHandler : public MingwModuleHandler
+{
+public:
+ MingwBootProgramModuleHandler ( const Module& module );
+ virtual HostType DefaultHost() { return HostFalse; }
+ virtual void Process ();
+ std::string GetProgTextAddrMacro ();
+ std::string TypeSpecificLinkerFlags() { return "-nostartfiles -nostdlib"; }
+private:
+ void GenerateBootProgramModuleTarget ();
+};
+
+
+class MingwIsoModuleHandler : public MingwModuleHandler
+{
+public:
+ MingwIsoModuleHandler ( const Module& module );
+ virtual HostType DefaultHost() { return HostFalse; }
+ virtual void Process ();
+private:
+ void GenerateIsoModuleTarget ();
+ void GetBootstrapCdDirectories ( std::vector<FileLocation>& out, const std::string& bootcdDirectory );
+ void GetNonModuleCdDirectories ( std::vector<FileLocation>& out, const std::string& bootcdDirectory );
+ void GetCdDirectories ( std::vector<FileLocation>& out, const std::string& bootcdDirectory );
+ void GetBootstrapCdFiles ( std::vector<FileLocation>& out ) const;
+ void GetNonModuleCdFiles ( std::vector<FileLocation>& out ) const;
+ void GetCdFiles ( std::vector<FileLocation>& out ) const;
+ void OutputBootstrapfileCopyCommands ( const std::string& bootcdDirectory );
+ void OutputCdfileCopyCommands ( const std::string& bootcdDirectory );
+};
+
+
+class MingwLiveIsoModuleHandler : public MingwModuleHandler
+{
+public:
+ MingwLiveIsoModuleHandler ( const Module& module );
+ virtual HostType DefaultHost() { return HostFalse; }
+ virtual void Process ();
+private:
+ void GenerateLiveIsoModuleTarget ();
+ void CreateDirectory ( const std::string& directory );
+ void OutputModuleCopyCommands ( std::string& livecdDirectory,
+ std::string& livecdReactos );
+ void OutputNonModuleCopyCommands ( std::string& livecdDirectory,
+ std::string& livecdReactos );
+ void OutputProfilesDirectoryCommands ( std::string& livecdDirectory );
+ void OutputLoaderCommands ( std::string& livecdDirectory );
+ void OutputRegistryCommands ( std::string& livecdDirectory );
+};
+
+
+class MingwTestModuleHandler : public MingwModuleHandler
+{
+public:
+ MingwTestModuleHandler ( const Module& module );
+ virtual HostType DefaultHost() { return HostFalse; }
+ virtual void Process ();
+ std::string TypeSpecificLinkerFlags() { return "-nostartfiles -nostdlib"; }
+protected:
+ virtual void GetModuleSpecificCompilationUnits ( std::vector<CompilationUnit*>& compilationUnits );
+private:
+ void GenerateTestModuleTarget ();
+};
+
+
+class MingwRpcServerModuleHandler : public MingwModuleHandler
+{
+public:
+ MingwRpcServerModuleHandler ( const Module& module );
+ virtual HostType DefaultHost() { return HostFalse; }
+ virtual void Process ();
+};
+
+
+class MingwRpcClientModuleHandler : public MingwModuleHandler
+{
+public:
+ MingwRpcClientModuleHandler ( const Module& module );
+ virtual HostType DefaultHost() { return HostFalse; }
+ virtual void Process ();
+};
+
+
+class MingwRpcProxyModuleHandler : public MingwModuleHandler
+{
+public:
+ MingwRpcProxyModuleHandler ( const Module& module );
+ virtual HostType DefaultHost() { return HostFalse; }
+ virtual void Process ();
+};
+
+
+class MingwAliasModuleHandler : public MingwModuleHandler
+{
+public:
+ MingwAliasModuleHandler ( const Module& module );
+ virtual HostType DefaultHost() { return HostFalse; }
+ virtual void Process ();
+};
+
+class MingwIdlHeaderModuleHandler : public MingwModuleHandler
+{
+public:
+ MingwIdlHeaderModuleHandler ( const Module& module );
+ virtual HostType DefaultHost() { return HostFalse; }
+ virtual void Process ();
+};
+
+class MingwCabinetModuleHandler : public MingwModuleHandler
+{
+public:
+ MingwCabinetModuleHandler ( const Module& module );
+ virtual HostType DefaultHost() { return HostFalse; }
+ virtual void Process ();
+};
+
+class MingwEmbeddedTypeLibModuleHandler : public MingwModuleHandler
+{
+public:
+ MingwEmbeddedTypeLibModuleHandler ( const Module& module );
+ virtual HostType DefaultHost() { return HostFalse; }
+ virtual void Process ();
+};
+
+class MingwElfExecutableModuleHandler : public MingwModuleHandler
+{
+public:
+ MingwElfExecutableModuleHandler ( const Module& module );
+ virtual HostType DefaultHost() { return HostFalse; }
+ virtual void Process ();
+};
+
+#endif /* MINGW_MODULEHANDLER_H */
projects / reactos.git / blobdiff