[rbuild] Remove distinction between Iso/IsoRegTest, and LiveIso/LiveIsoRegTest module...
[reactos.git] / reactos / tools / rbuild / backend / mingw / mingw.cpp
1 /*
2 * Copyright (C) 2005 Casper S. Hornstrup
3 * 2006 Christoph von Wittich
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18 */
19 #include "../../pch.h"
20
21 #include "mingw.h"
22 #include <assert.h>
23 #include "modulehandler.h"
24
25 #ifdef _MSC_VER
26 #define popen _popen
27 #define pclose _pclose
28 #endif//_MSC_VER
29
30 using std::string;
31 using std::vector;
32 using std::set;
33 using std::map;
34
35 typedef set<string> set_string;
36
37 const struct ModuleHandlerInformations ModuleHandlerInformations[] = {
38 { HostTrue, "", "", "" }, // BuildTool
39 { HostFalse, "", "", "" }, // StaticLibrary
40 { HostFalse, "", "", "" }, // ObjectLibrary
41 { HostFalse, "", "", "" }, // Kernel
42 { HostFalse, "", "", "" }, // KernelModeDLL
43 { HostFalse, "-D__NTDRIVER__", "", "" }, // KernelModeDriver
44 { HostFalse, "", "", "" }, // NativeDLL
45 { HostFalse, "-D__NTAPP__", "", "" }, // NativeCUI
46 { HostFalse, "", "", "" }, // Win32DLL
47 { HostFalse, "", "", "" }, // Win32OCX
48 { HostFalse, "", "", "" }, // Win32CUI
49 { HostFalse, "", "", "" }, // Win32GUI
50 { HostFalse, "", "", "-nostartfiles -nostdlib" }, // BootLoader
51 { HostFalse, "", "-f bin", "" }, // BootSector
52 { HostFalse, "", "", "" }, // Iso
53 { HostFalse, "", "", "" }, // LiveIso
54 { HostFalse, "", "", "" }, // Test
55 { HostFalse, "", "", "" }, // RpcServer
56 { HostFalse, "", "", "" }, // RpcClient
57 { HostFalse, "", "", "" }, // Alias
58 { HostFalse, "", "", "-nostartfiles -nostdlib" }, // BootProgram
59 { HostFalse, "", "", "" }, // Win32SCR
60 { HostFalse, "", "", "" }, // IdlHeader
61 { HostFalse, "", "", "" }, // IdlInterface
62 { HostFalse, "", "", "" }, // EmbeddedTypeLib
63 { HostFalse, "", "", "" }, // ElfExecutable
64 { HostFalse, "", "", "" }, // RpcProxy
65 { HostTrue, "", "", "" }, // HostStaticLibrary
66 { HostFalse, "", "", "" }, // Cabinet
67 { HostFalse, "", "", "" }, // KeyboardLayout
68 { HostFalse, "", "", "" }, // MessageHeader
69 };
70
71 static std::string mscPath;
72 static std::string mslinkPath;
73
74 string
75 MingwBackend::GetFullPath ( const FileLocation& file ) const
76 {
77 MingwModuleHandler::PassThruCacheDirectory ( &file );
78
79 string directory;
80 switch ( file.directory )
81 {
82 case SourceDirectory:
83 directory = "";
84 break;
85 case IntermediateDirectory:
86 directory = "$(INTERMEDIATE)";
87 break;
88 case OutputDirectory:
89 directory = "$(OUTPUT)";
90 break;
91 case InstallDirectory:
92 directory = "$(INSTALL)";
93 break;
94 case TemporaryDirectory:
95 directory = "$(TEMPORARY)";
96 break;
97 default:
98 throw InvalidOperationException ( __FILE__,
99 __LINE__,
100 "Invalid directory %d.",
101 file.directory );
102 }
103
104 if ( file.relative_path.length () > 0 )
105 {
106 if ( directory.length () > 0 )
107 directory += sSep;
108 directory += file.relative_path;
109 }
110 return directory;
111 }
112
113 string
114 MingwBackend::GetFullName ( const FileLocation& file ) const
115 {
116 string directory;
117 switch ( file.directory )
118 {
119 case SourceDirectory:
120 directory = "";
121 break;
122 case IntermediateDirectory:
123 directory = "$(INTERMEDIATE)";
124 break;
125 case OutputDirectory:
126 directory = "$(OUTPUT)";
127 break;
128 case InstallDirectory:
129 directory = "$(INSTALL)";
130 break;
131 case TemporaryDirectory:
132 directory = "$(TEMPORARY)";
133 break;
134 default:
135 throw InvalidOperationException ( __FILE__,
136 __LINE__,
137 "Invalid directory %d.",
138 file.directory );
139 }
140
141 if ( file.relative_path.length () > 0 )
142 {
143 if ( directory.length () > 0 )
144 directory += sSep;
145 directory += file.relative_path;
146 }
147
148 if ( directory.length () > 0 )
149 directory += sSep;
150
151 return directory + file.name;
152 }
153
154 string
155 v2s ( const Backend* backend, const vector<FileLocation>& files, int wrap_at )
156 {
157 if ( !files.size() )
158 return "";
159 string s;
160 int wrap_count = 0;
161 for ( size_t i = 0; i < files.size(); i++ )
162 {
163 const FileLocation& file = files[i];
164 if ( wrap_at > 0 && wrap_count++ == wrap_at )
165 {
166 s += " \\\n\t\t";
167 wrap_count = 1;
168 }
169 else if ( s.size() )
170 s += " ";
171 s += backend->GetFullName ( file );
172 }
173 return s;
174 }
175
176
177 string
178 v2s ( const string_list& v, int wrap_at )
179 {
180 if ( !v.size() )
181 return "";
182 string s;
183 int wrap_count = 0;
184 for ( size_t i = 0; i < v.size(); i++ )
185 {
186 if ( !v[i].size() )
187 continue;
188 if ( wrap_at > 0 && wrap_count++ == wrap_at )
189 {
190 s += " \\\n\t\t";
191 wrap_count = 1;
192 }
193 else if ( s.size() )
194 s += " ";
195 s += v[i];
196 }
197 return s;
198 }
199
200
201 static class MingwFactory : public Backend::Factory
202 {
203 public:
204 MingwFactory() : Factory ( "mingw", "Minimalist GNU Win32" ) {}
205 Backend* operator() ( Project& project,
206 Configuration& configuration )
207 {
208 return new MingwBackend ( project,
209 configuration );
210 }
211 } factory;
212
213
214 MingwBackend::MingwBackend ( Project& project,
215 Configuration& configuration )
216 : Backend ( project, configuration ),
217 manualBinutilsSetting( false ),
218 intermediateDirectory ( new Directory ( "" ) ),
219 outputDirectory ( new Directory ( "" ) ),
220 installDirectory ( new Directory ( "" ) )
221 {
222 compilerPrefix = "";
223 }
224
225 MingwBackend::~MingwBackend()
226 {
227 delete intermediateDirectory;
228 delete outputDirectory;
229 delete installDirectory;
230 }
231
232 string
233 MingwBackend::AddDirectoryTarget ( const string& directory,
234 Directory* directoryTree )
235 {
236 if ( directory.length () > 0)
237 directoryTree->Add ( directory.c_str() );
238 return directoryTree->name;
239 }
240
241 bool
242 MingwBackend::CanEnablePreCompiledHeaderSupportForModule ( const Module& module )
243 {
244 if ( !configuration.CompilationUnitsEnabled )
245 return true;
246
247 const vector<CompilationUnit*>& compilationUnits = module.non_if_data.compilationUnits;
248 size_t i;
249 for ( i = 0; i < compilationUnits.size (); i++ )
250 {
251 CompilationUnit& compilationUnit = *compilationUnits[i];
252 if ( compilationUnit.GetFiles ().size () != 1 )
253 return false;
254 }
255 return true;
256 }
257
258 void
259 MingwBackend::ProcessModules ()
260 {
261 printf ( "Processing modules..." );
262
263 vector<MingwModuleHandler*> v;
264 size_t i;
265
266 for ( std::map<std::string, Module*>::iterator p = ProjectNode.modules.begin (); p != ProjectNode.modules.end (); ++ p )
267 fprintf ( fMakefile, "%s_TYPE:=%u\n", p->second->name.c_str(), p->second->type );
268
269 for ( std::map<std::string, Module*>::iterator p = ProjectNode.modules.begin (); p != ProjectNode.modules.end (); ++ p )
270 {
271 Module& module = *p->second;
272 if ( !module.enabled )
273 continue;
274 MingwModuleHandler* h = MingwModuleHandler::InstanciateHandler (
275 module,
276 this );
277 h->AddImplicitLibraries ( module );
278 if ( use_pch && CanEnablePreCompiledHeaderSupportForModule ( module ) )
279 h->EnablePreCompiledHeaderSupport ();
280 v.push_back ( h );
281 }
282
283 size_t iend = v.size ();
284
285 for ( i = 0; i < iend; i++ )
286 v[i]->GenerateSourceMacro();
287 for ( i = 0; i < iend; i++ )
288 v[i]->GenerateObjectMacro();
289 fprintf ( fMakefile, "\n" );
290 for ( i = 0; i < iend; i++ )
291 v[i]->GenerateTargetMacro();
292 fprintf ( fMakefile, "\n" );
293
294 GenerateAllTarget ( v );
295 GenerateRegTestsRunTarget ();
296
297 for ( i = 0; i < iend; i++ )
298 v[i]->GenerateOtherMacros();
299
300 for ( i = 0; i < iend; i++ )
301 {
302 MingwModuleHandler& h = *v[i];
303 h.GeneratePreconditionDependencies ();
304 h.Process ();
305 h.GenerateInvocations ();
306 h.GenerateCleanTarget ();
307 h.GenerateInstallTarget ();
308 h.GenerateDependsTarget ();
309 delete v[i];
310 }
311
312 printf ( "done\n" );
313 }
314
315 void
316 MingwBackend::Process ()
317 {
318 if ( configuration.CheckDependenciesForModuleOnly )
319 CheckAutomaticDependenciesForModuleOnly ();
320 else
321 ProcessNormal ();
322 }
323
324 void
325 MingwBackend::CheckAutomaticDependenciesForModuleOnly ()
326 {
327 if ( configuration.Dependencies == AutomaticDependencies )
328 {
329 Module* module = ProjectNode.LocateModule ( configuration.CheckDependenciesForModuleOnlyModule );
330 if ( module == NULL )
331 {
332 printf ( "Module '%s' does not exist\n",
333 configuration.CheckDependenciesForModuleOnlyModule.c_str () );
334 return;
335 }
336
337 printf ( "Checking automatic dependencies for module '%s'...",
338 module->name.c_str () );
339 AutomaticDependency automaticDependency ( ProjectNode );
340 automaticDependency.CheckAutomaticDependenciesForModule ( *module,
341 configuration.Verbose );
342 printf ( "done\n" );
343 }
344 }
345
346 void
347 MingwBackend::ProcessNormal ()
348 {
349 assert(sizeof(ModuleHandlerInformations)/sizeof(ModuleHandlerInformations[0]) == TypeDontCare);
350
351 DetectCompiler ();
352 DetectBinutils ();
353 DetectNetwideAssembler ();
354 DetectPipeSupport ();
355 DetectPCHSupport ();
356 CreateMakefile ();
357 GenerateHeader ();
358 GenerateGlobalVariables ();
359 GenerateXmlBuildFilesMacro ();
360 ProcessModules ();
361 GenerateInstallTarget ();
362 GenerateTestTarget ();
363 GenerateDirectoryTargets ();
364 GenerateDirectories ();
365 GenerateTestSupportCode ();
366 GenerateCompilationUnitSupportCode ();
367 GenerateSysSetup ();
368 GenerateProxyMakefiles ();
369 CheckAutomaticDependencies ();
370 CloseMakefile ();
371 }
372
373 void
374 MingwBackend::CreateMakefile ()
375 {
376 fMakefile = fopen ( ProjectNode.makefile.c_str (), "w" );
377 if ( !fMakefile )
378 throw AccessDeniedException ( ProjectNode.makefile );
379 MingwModuleHandler::SetBackend ( this );
380 MingwModuleHandler::SetMakefile ( fMakefile );
381 }
382
383 void
384 MingwBackend::CloseMakefile () const
385 {
386 if (fMakefile)
387 fclose ( fMakefile );
388 }
389
390 void
391 MingwBackend::GenerateHeader () const
392 {
393 fprintf ( fMakefile, "# THIS FILE IS AUTOMATICALLY GENERATED, EDIT '%s' INSTEAD\n\n",
394 ProjectNode.GetProjectFilename ().c_str () );
395 }
396
397 void
398 MingwBackend::GenerateGlobalProperties (
399 const char* assignmentOperation,
400 const IfableData& data ) const
401 {
402 for ( std::map<std::string, Property*>::const_iterator p = data.properties.begin(); p != data.properties.end(); ++ p )
403 {
404 Property& prop = *p->second;
405
406 if (!prop.isInternal)
407 {
408 fprintf ( fMakefile, "%s := %s\n",
409 prop.name.c_str(),
410 prop.value.c_str() );
411 }
412 }
413 }
414
415 string
416 MingwBackend::GenerateProjectLFLAGS () const
417 {
418 string lflags;
419 for ( size_t i = 0; i < ProjectNode.linkerFlags.size (); i++ )
420 {
421 LinkerFlag& linkerFlag = *ProjectNode.linkerFlags[i];
422 if ( lflags.length () > 0 )
423 lflags += " ";
424 lflags += linkerFlag.flag;
425 }
426 return lflags;
427 }
428
429 void
430 MingwBackend::GenerateGlobalVariables () const
431 {
432 fputs ( "include tools$(SEP)rbuild$(SEP)backend$(SEP)mingw$(SEP)rules.mak\n", fMakefile );
433 fprintf ( fMakefile, "include tools$(SEP)rbuild$(SEP)backend$(SEP)mingw$(SEP)linkers$(SEP)%s.mak\n", ProjectNode.GetLinkerSet ().c_str () );
434 fprintf ( fMakefile, "include tools$(SEP)rbuild$(SEP)backend$(SEP)mingw$(SEP)compilers$(SEP)%s.mak\n", ProjectNode.GetCompilerSet ().c_str () );
435
436 if ( mscPath.length() )
437 fprintf ( fMakefile, "export RBUILD_CL_PATH=%s\n", mscPath.c_str () );
438
439 if ( mslinkPath.length() )
440 fprintf ( fMakefile, "export RBUILD_LINK_PATH=%s\n", mslinkPath.c_str () );
441
442 if ( configuration.Dependencies == FullDependencies )
443 {
444 fprintf ( fMakefile,
445 "ifeq ($(ROS_BUILDDEPS),)\n"
446 "ROS_BUILDDEPS:=%s\n"
447 "endif\n",
448 "full" );
449 }
450
451 fprintf ( fMakefile,
452 "PREFIX := %s\n",
453 compilerPrefix.c_str () );
454 fprintf ( fMakefile,
455 "nasm := $(Q)%s\n",
456 nasmCommand.c_str () );
457
458 GenerateGlobalProperties ( "=", ProjectNode.non_if_data );
459
460 if ( ProjectNode.configuration.Compiler == GnuGcc )
461 {
462 fprintf ( fMakefile, "ifneq ($(OARCH),)\n" );
463 fprintf ( fMakefile, "PROJECT_ASFLAGS += -march=$(OARCH)\n" );
464 fprintf ( fMakefile, "PROJECT_CFLAGS += -march=$(OARCH)\n" );
465 fprintf ( fMakefile, "PROJECT_CXXFLAGS += -march=$(OARCH)\n" );
466 fprintf ( fMakefile, "endif\n" );
467 fprintf ( fMakefile, "ifneq ($(TUNE),)\n" );
468 fprintf ( fMakefile, "PROJECT_CFLAGS += -mtune=$(TUNE)\n" );
469 fprintf ( fMakefile, "PROJECT_CXXFLAGS += -mtune=$(TUNE)\n" );
470 fprintf ( fMakefile, "endif\n" );
471
472 if ( usePipe )
473 {
474 fprintf ( fMakefile, "PROJECT_CFLAGS += -pipe\n" );
475 fprintf ( fMakefile, "PROJECT_CXXFLAGS += -pipe\n" );
476 fprintf ( fMakefile, "PROJECT_ASFLAGS += -pipe\n" );
477 }
478
479 // Would be nice to have our own C++ runtime
480 fputs ( "BUILTIN_CXXINCLUDES+= $(TARGET_CPPFLAGS)\n", fMakefile );
481 }
482
483 // Because RosBE gcc is built to suck
484 fputs ( "BUILTIN_HOST_CINCLUDES+= $(HOST_CFLAGS)\n", fMakefile );
485 fputs ( "BUILTIN_HOST_CPPINCLUDES+= $(HOST_CFLAGS)\n", fMakefile );
486 fputs ( "BUILTIN_HOST_CXXINCLUDES+= $(HOST_CPPFLAGS)\n", fMakefile );
487
488 MingwModuleHandler::GenerateParameters ( "PROJECT", "+=", ProjectNode.non_if_data );
489 MingwModuleHandler::GenerateParameters ( "PROJECT_HOST", "+=", ProjectNode.host_non_if_data );
490
491 // TODO: linker flags
492 fprintf ( fMakefile, "PROJECT_LFLAGS := '$(shell ${TARGET_CC} -print-libgcc-file-name)' %s\n", GenerateProjectLFLAGS ().c_str () );
493 fprintf ( fMakefile, "PROJECT_LPPFLAGS := '$(shell ${TARGET_CPP} -print-file-name=libstdc++.a)' '$(shell ${TARGET_CPP} -print-file-name=libgcc.a)' '$(shell ${TARGET_CPP} -print-file-name=libmingw32.a)' '$(shell ${TARGET_CPP} -print-file-name=libmingwex.a)' '$(shell ${TARGET_CPP} -print-file-name=libcoldname.a)'\n" );
494 /* hack to get libgcc_eh.a, should check mingw version or something */
495 if (Environment::GetArch() == "amd64")
496 {
497 fprintf ( fMakefile, "PROJECT_LPPFLAGS += '$(shell ${TARGET_CPP} -print-file-name=libgcc_eh.a)'\n" );
498 }
499
500 // TODO: use symbolic names for module types
501 for ( size_t i = 0; i < sizeof(ModuleHandlerInformations) / sizeof(ModuleHandlerInformations[0]); ++ i )
502 {
503 if ( ModuleHandlerInformations[i].cflags && ModuleHandlerInformations[i].cflags[0] )
504 {
505 fprintf ( fMakefile,
506 "MODULETYPE%d_%sFLAGS:=%s\n",
507 (int)i,
508 "C",
509 ModuleHandlerInformations[i].cflags );
510 }
511
512 if ( ModuleHandlerInformations[i].cflags && ModuleHandlerInformations[i].cflags[0] )
513 {
514 fprintf ( fMakefile,
515 "MODULETYPE%d_%sFLAGS:=%s\n",
516 (int)i,
517 "CXX",
518 ModuleHandlerInformations[i].cflags );
519 }
520
521 if ( ModuleHandlerInformations[i].nasmflags && ModuleHandlerInformations[i].nasmflags[0] )
522 {
523 fprintf ( fMakefile,
524 "MODULETYPE%d_%sFLAGS:=%s\n",
525 (int)i,
526 "NASM",
527 ModuleHandlerInformations[i].nasmflags );
528 }
529 }
530
531 fprintf ( fMakefile, "\n" );
532 }
533
534 bool
535 MingwBackend::IncludeInAllTarget ( const Module& module ) const
536 {
537 if ( MingwModuleHandler::ReferenceObjects ( module ) )
538 return false;
539 if ( module.type == BootSector )
540 return false;
541 if ( module.type == Iso )
542 return false;
543 if ( module.type == LiveIso )
544 return false;
545 if ( module.type == Test )
546 return false;
547 if ( module.type == Alias )
548 return false;
549 return true;
550 }
551
552 void
553 MingwBackend::GenerateAllTarget ( const vector<MingwModuleHandler*>& handlers ) const
554 {
555 fprintf ( fMakefile, "all:" );
556 int wrap_count = 0;
557 size_t iend = handlers.size ();
558 for ( size_t i = 0; i < iend; i++ )
559 {
560 const Module& module = handlers[i]->module;
561 if ( IncludeInAllTarget ( module ) )
562 {
563 if ( wrap_count++ == 5 )
564 fprintf ( fMakefile, " \\\n\t\t" ), wrap_count = 0;
565 fprintf ( fMakefile,
566 " %s",
567 GetTargetMacro(module).c_str () );
568 }
569 }
570 fprintf ( fMakefile, "\n\t\n\n" );
571 }
572
573 void
574 MingwBackend::GenerateRegTestsRunTarget () const
575 {
576 fprintf ( fMakefile,
577 "REGTESTS_RUN_TARGET = regtests.dll\n" );
578 fprintf ( fMakefile,
579 "$(REGTESTS_RUN_TARGET): $(REGTESTS_TARGET)\n" );
580 fprintf ( fMakefile,
581 "\t$(cp) $(REGTESTS_TARGET) $(REGTESTS_RUN_TARGET)\n" );
582 fprintf ( fMakefile, "\n" );
583 }
584
585 void
586 MingwBackend::GenerateXmlBuildFilesMacro() const
587 {
588 fprintf ( fMakefile,
589 "XMLBUILDFILES = %s \\\n",
590 ProjectNode.GetProjectFilename ().c_str () );
591 string xmlbuildFilenames;
592 int numberOfExistingFiles = 0;
593 struct stat statbuf;
594 time_t SystemTime, lastWriteTime;
595
596 for ( size_t i = 0; i < ProjectNode.xmlbuildfiles.size (); i++ )
597 {
598 XMLInclude& xmlbuildfile = *ProjectNode.xmlbuildfiles[i];
599 if ( !xmlbuildfile.fileExists )
600 continue;
601 numberOfExistingFiles++;
602 if ( xmlbuildFilenames.length () > 0 )
603 xmlbuildFilenames += " ";
604
605 FILE* f = fopen ( xmlbuildfile.topIncludeFilename.c_str (), "rb" );
606 if ( !f )
607 throw FileNotFoundException ( NormalizeFilename ( xmlbuildfile.topIncludeFilename ) );
608
609 if ( fstat ( fileno ( f ), &statbuf ) != 0 )
610 {
611 fclose ( f );
612 throw AccessDeniedException ( NormalizeFilename ( xmlbuildfile.topIncludeFilename ) );
613 }
614
615 lastWriteTime = statbuf.st_mtime;
616 SystemTime = time(NULL);
617
618 if (SystemTime != -1)
619 {
620 if (difftime (lastWriteTime, SystemTime) > 0)
621 throw InvalidDateException ( NormalizeFilename ( xmlbuildfile.topIncludeFilename ) );
622 }
623
624 fclose ( f );
625
626 xmlbuildFilenames += NormalizeFilename ( xmlbuildfile.topIncludeFilename );
627 if ( numberOfExistingFiles % 5 == 4 || i == ProjectNode.xmlbuildfiles.size () - 1 )
628 {
629 fprintf ( fMakefile,
630 "\t%s",
631 xmlbuildFilenames.c_str ());
632 if ( i == ProjectNode.xmlbuildfiles.size () - 1 )
633 {
634 fprintf ( fMakefile, "\n" );
635 }
636 else
637 {
638 fprintf ( fMakefile,
639 " \\\n" );
640 }
641 xmlbuildFilenames.resize ( 0 );
642 }
643 numberOfExistingFiles++;
644 }
645 fprintf ( fMakefile, "\n" );
646 }
647
648 void
649 MingwBackend::GenerateTestSupportCode ()
650 {
651 printf ( "Generating test support code..." );
652 TestSupportCode testSupportCode ( ProjectNode );
653 testSupportCode.GenerateTestSupportCode ( configuration.Verbose );
654 printf ( "done\n" );
655 }
656
657 void
658 MingwBackend::GenerateCompilationUnitSupportCode ()
659 {
660 if ( configuration.CompilationUnitsEnabled )
661 {
662 printf ( "Generating compilation unit support code..." );
663 CompilationUnitSupportCode compilationUnitSupportCode ( ProjectNode );
664 compilationUnitSupportCode.Generate ( configuration.Verbose );
665 printf ( "done\n" );
666 }
667 }
668
669 void
670 MingwBackend::GenerateSysSetup ()
671 {
672 printf ( "Generating syssetup.inf..." );
673 SysSetupGenerator sysSetupGenerator ( ProjectNode );
674 sysSetupGenerator.Generate ();
675 printf ( "done\n" );
676 }
677
678 string
679 MingwBackend::GetProxyMakefileTree () const
680 {
681 if ( configuration.GenerateProxyMakefilesInSourceTree )
682 return "";
683 else
684 return Environment::GetOutputPath ();
685 }
686
687 void
688 MingwBackend::GenerateProxyMakefiles ()
689 {
690 printf ( "Generating proxy makefiles..." );
691 ProxyMakefile proxyMakefile ( ProjectNode );
692 proxyMakefile.GenerateProxyMakefiles ( configuration.Verbose,
693 GetProxyMakefileTree () );
694 printf ( "done\n" );
695 }
696
697 void
698 MingwBackend::CheckAutomaticDependencies ()
699 {
700 if ( configuration.Dependencies == AutomaticDependencies )
701 {
702 printf ( "Checking automatic dependencies..." );
703 AutomaticDependency automaticDependency ( ProjectNode );
704 automaticDependency.CheckAutomaticDependencies ( configuration.Verbose );
705 printf ( "done\n" );
706 }
707 }
708
709 void
710 MingwBackend::GenerateDirectories ()
711 {
712 printf ( "Creating directories..." );
713 intermediateDirectory->GenerateTree ( IntermediateDirectory, configuration.Verbose );
714 outputDirectory->GenerateTree ( OutputDirectory, configuration.Verbose );
715 if ( !configuration.MakeHandlesInstallDirectories )
716 installDirectory->GenerateTree ( InstallDirectory, configuration.Verbose );
717 printf ( "done\n" );
718 }
719
720 bool
721 MingwBackend::TryToDetectThisCompiler ( const string& compiler )
722 {
723 string command = ssprintf (
724 "%s -v 1>%s 2>%s",
725 FixSeparatorForSystemCommand(compiler).c_str (),
726 NUL,
727 NUL );
728 int exitcode = system ( command.c_str () );
729 return (bool) (exitcode == 0);
730 }
731
732 void
733 MingwBackend::DetectCompiler ()
734 {
735 printf ( "Detecting compiler..." );
736
737 bool detectedCompiler = false;
738 bool supportedCompiler = false;
739 string compilerVersion;
740
741 if ( ProjectNode.configuration.Compiler == GnuGcc )
742 {
743 const string& ROS_PREFIXValue = Environment::GetVariable ( "ROS_PREFIX" );
744 if ( ROS_PREFIXValue.length () > 0 )
745 {
746 compilerPrefix = ROS_PREFIXValue;
747 compilerCommand = compilerPrefix + "-gcc";
748 detectedCompiler = TryToDetectThisCompiler ( compilerCommand );
749 }
750 #if defined(WIN32)
751 if ( !detectedCompiler )
752 {
753 compilerPrefix = "";
754 compilerCommand = "gcc";
755 detectedCompiler = TryToDetectThisCompiler ( compilerCommand );
756 }
757 #endif
758 if ( !detectedCompiler )
759 {
760 compilerPrefix = "mingw32";
761 compilerCommand = compilerPrefix + "-gcc";
762 detectedCompiler = TryToDetectThisCompiler ( compilerCommand );
763 }
764
765 if ( detectedCompiler )
766 compilerVersion = GetCompilerVersion ( compilerCommand );
767
768 supportedCompiler = IsSupportedCompilerVersion ( compilerVersion );
769 }
770 else if ( ProjectNode.configuration.Compiler == MicrosoftC )
771 {
772 compilerCommand = "cl";
773 detectedCompiler = DetectMicrosoftCompiler ( compilerVersion, mscPath );
774 supportedCompiler = true; // TODO
775 }
776
777 if ( detectedCompiler )
778 {
779 if ( supportedCompiler )
780 printf ( "detected (%s %s)\n", compilerCommand.c_str (), compilerVersion.c_str() );
781 else
782 {
783 printf ( "detected (%s), but with unsupported version (%s)\n",
784 compilerCommand.c_str (),
785 compilerVersion.c_str () );
786 throw UnsupportedBuildToolException ( compilerCommand, compilerVersion );
787 }
788 }
789 else
790 printf ( "not detected\n" );
791
792 }
793
794 bool
795 MingwBackend::TryToDetectThisNetwideAssembler ( const string& assembler )
796 {
797 string command = ssprintf (
798 "%s -h 1>%s 2>%s",
799 FixSeparatorForSystemCommand(assembler).c_str (),
800 NUL,
801 NUL );
802 int exitcode = system ( command.c_str () );
803 return (bool) (exitcode == 0);
804 }
805
806 string
807 MingwBackend::GetVersionString ( const string& versionCommand )
808 {
809 FILE *fp;
810 int ch, i;
811 size_t newline;
812 char buffer[81];
813
814 fp = popen ( versionCommand.c_str () , "r" );
815 for( i = 0;
816 ( i < 80 ) &&
817 ( feof ( fp ) == 0 &&
818 ( ( ch = fgetc( fp ) ) != -1 ) );
819 i++ )
820 {
821 buffer[i] = (char) ch;
822 }
823 buffer[i] = '\0';
824 pclose ( fp );
825
826 char separators[] = " ()";
827 char *token;
828 char *prevtoken = NULL;
829
830 string version;
831
832 token = strtok ( buffer, separators );
833 while ( token != NULL )
834 {
835 prevtoken = token;
836 version = string( prevtoken );
837 if ( (newline = version.find('\n')) != std::string::npos )
838 version.erase(newline, 1);
839 if ( version.find('.') != std::string::npos )
840 break;
841 token = strtok ( NULL, separators );
842 }
843 return version;
844 }
845
846 string
847 MingwBackend::GetNetwideAssemblerVersion ( const string& nasmCommand )
848 {
849 string versionCommand;
850 if ( nasmCommand.find("yasm") != std::string::npos )
851 {
852 versionCommand = ssprintf ( "%s --version",
853 nasmCommand.c_str (),
854 NUL,
855 NUL );
856 }
857 else
858 {
859 versionCommand = ssprintf ( "%s -v",
860 nasmCommand.c_str (),
861 NUL,
862 NUL );
863 }
864 return GetVersionString( versionCommand );
865 }
866
867 string
868 MingwBackend::GetCompilerVersion ( const string& compilerCommand )
869 {
870 string versionCommand = ssprintf ( "%s --version gcc",
871 compilerCommand.c_str (),
872 NUL,
873 NUL );
874 return GetVersionString( versionCommand );
875 }
876
877 string
878 MingwBackend::GetBinutilsVersion ( const string& binutilsCommand )
879 {
880 string versionCommand = ssprintf ( "%s -v",
881 binutilsCommand.c_str (),
882 NUL,
883 NUL );
884 return GetVersionString( versionCommand );
885 }
886
887 bool
888 MingwBackend::IsSupportedCompilerVersion ( const string& compilerVersion )
889 {
890 if ( strcmp ( compilerVersion.c_str (), "3.4.2") < 0 )
891 return false;
892 else
893 return true;
894 }
895
896 bool
897 MingwBackend::TryToDetectThisBinutils ( const string& binutils )
898 {
899 string command = ssprintf (
900 "%s -v 1>%s 2>%s",
901 FixSeparatorForSystemCommand(binutils).c_str (),
902 NUL,
903 NUL );
904 int exitcode = system ( command.c_str () );
905 return (exitcode == 0);
906 }
907
908 string
909 MingwBackend::GetBinutilsVersionDate ( const string& binutilsCommand )
910 {
911 FILE *fp;
912 int ch, i;
913 char buffer[81];
914
915 string versionCommand = ssprintf ( "%s -v",
916 binutilsCommand.c_str (),
917 NUL,
918 NUL );
919 fp = popen ( versionCommand.c_str () , "r" );
920 for( i = 0;
921 ( i < 80 ) &&
922 ( feof ( fp ) == 0 &&
923 ( ( ch = fgetc( fp ) ) != -1 ) );
924 i++ )
925 {
926 buffer[i] = (char) ch;
927 }
928 buffer[i] = '\0';
929 pclose ( fp );
930
931 char separators[] = " ";
932 char *token;
933 char *prevtoken = NULL;
934
935 token = strtok ( buffer, separators );
936 while ( token != NULL )
937 {
938 prevtoken = token;
939 token = strtok ( NULL, separators );
940 }
941 string version = string ( prevtoken );
942 int lastDigit = version.find_last_not_of ( "\t\r\n" );
943 if ( lastDigit != -1 )
944 return string ( version, 0, lastDigit+1 );
945 else
946 return version;
947 }
948
949 bool
950 MingwBackend::IsSupportedBinutilsVersion ( const string& binutilsVersion )
951 {
952 if ( manualBinutilsSetting ) return true;
953
954 /* linux */
955 if ( binutilsVersion.find('.') != std::string::npos )
956 {
957 /* TODO: blacklist versions on version number instead of date */
958 return true;
959 }
960
961 /*
962 * - Binutils older than 2003/10/01 have broken windres which can't handle
963 * icons with alpha channel.
964 * - Binutils between 2004/09/02 and 2004/10/08 have broken handling of
965 * forward exports in dlltool.
966 */
967 if ( ( ( strcmp ( binutilsVersion.c_str (), "20040902") >= 0 ) &&
968 ( strcmp ( binutilsVersion.c_str (), "20041008") <= 0 ) ) ||
969 ( strcmp ( binutilsVersion.c_str (), "20031001") < 0 ) )
970 return false;
971 else
972 return true;
973 }
974
975 void
976 MingwBackend::DetectBinutils ()
977 {
978 printf ( "Detecting binutils..." );
979
980 bool detectedBinutils = false;
981 bool supportedBinutils = false;
982 string binutilsVersion;
983
984 if ( ProjectNode.configuration.Linker == GnuLd )
985 {
986 const string& ROS_PREFIXValue = Environment::GetVariable ( "ROS_PREFIX" );
987
988 if ( ROS_PREFIXValue.length () > 0 )
989 {
990 binutilsPrefix = ROS_PREFIXValue;
991 binutilsCommand = binutilsPrefix + "-ld";
992 manualBinutilsSetting = true;
993 detectedBinutils = true;
994 }
995 #if defined(WIN32)
996 if ( !detectedBinutils )
997 {
998 binutilsPrefix = "";
999 binutilsCommand = "ld";
1000 detectedBinutils = TryToDetectThisBinutils ( binutilsCommand );
1001 }
1002 #endif
1003 if ( !detectedBinutils )
1004 {
1005 binutilsPrefix = "mingw32";
1006 binutilsCommand = binutilsPrefix + "-ld";
1007 detectedBinutils = TryToDetectThisBinutils ( binutilsCommand );
1008 }
1009 if ( detectedBinutils )
1010 {
1011 binutilsVersion = GetBinutilsVersionDate ( binutilsCommand );
1012 supportedBinutils = IsSupportedBinutilsVersion ( binutilsVersion );
1013 }
1014 }
1015 else if ( ProjectNode.configuration.Linker == MicrosoftLink )
1016 {
1017 compilerCommand = "link";
1018 detectedBinutils = DetectMicrosoftLinker ( binutilsVersion, mslinkPath );
1019 supportedBinutils = true; // TODO
1020 }
1021
1022 if ( detectedBinutils )
1023 {
1024 if ( supportedBinutils )
1025 printf ( "detected (%s %s)\n", binutilsCommand.c_str (), binutilsVersion.c_str() );
1026 else
1027 {
1028 printf ( "detected (%s), but with unsupported version (%s)\n",
1029 binutilsCommand.c_str (),
1030 binutilsVersion.c_str () );
1031 throw UnsupportedBuildToolException ( binutilsCommand, binutilsVersion );
1032 }
1033 }
1034 else
1035 printf ( "not detected\n" );
1036
1037 }
1038
1039 void
1040 MingwBackend::DetectNetwideAssembler ()
1041 {
1042 printf ( "Detecting netwide assembler..." );
1043
1044 nasmCommand = "nasm";
1045 bool detectedNasm = TryToDetectThisNetwideAssembler ( nasmCommand );
1046 #if defined(WIN32)
1047 if ( !detectedNasm )
1048 {
1049 nasmCommand = "nasmw";
1050 detectedNasm = TryToDetectThisNetwideAssembler ( nasmCommand );
1051 }
1052 #endif
1053 if ( !detectedNasm )
1054 {
1055 nasmCommand = "yasm";
1056 detectedNasm = TryToDetectThisNetwideAssembler ( nasmCommand );
1057 }
1058 if ( detectedNasm )
1059 printf ( "detected (%s %s)\n", nasmCommand.c_str (), GetNetwideAssemblerVersion( nasmCommand ).c_str() );
1060 else
1061 printf ( "not detected\n" );
1062 }
1063
1064 void
1065 MingwBackend::DetectPipeSupport ()
1066 {
1067 if ( ProjectNode.configuration.Compiler == GnuGcc )
1068 {
1069 printf ( "Detecting compiler -pipe support..." );
1070
1071 string pipe_detection = "tools" + sSep + "rbuild" + sSep + "backend" + sSep + "mingw" + sSep + "pipe_detection.c";
1072 string pipe_detectionObjectFilename = ReplaceExtension ( pipe_detection,
1073 ".o" );
1074 string command = ssprintf (
1075 "%s -pipe -c %s -o %s 1>%s 2>%s",
1076 FixSeparatorForSystemCommand(compilerCommand).c_str (),
1077 pipe_detection.c_str (),
1078 pipe_detectionObjectFilename.c_str (),
1079 NUL,
1080 NUL );
1081 int exitcode = system ( command.c_str () );
1082 FILE* f = fopen ( pipe_detectionObjectFilename.c_str (), "rb" );
1083 if ( f )
1084 {
1085 usePipe = (exitcode == 0);
1086 fclose ( f );
1087 unlink ( pipe_detectionObjectFilename.c_str () );
1088 }
1089 else
1090 usePipe = false;
1091
1092 if ( usePipe )
1093 printf ( "detected\n" );
1094 else
1095 printf ( "not detected\n" );
1096 }
1097 else
1098 usePipe = false;
1099 }
1100
1101 void
1102 MingwBackend::DetectPCHSupport ()
1103 {
1104 printf ( "Detecting compiler pre-compiled header support..." );
1105
1106 if ( configuration.PrecompiledHeadersEnabled && ProjectNode.configuration.Compiler == GnuGcc )
1107 {
1108 string path = "tools" + sSep + "rbuild" + sSep + "backend" + sSep + "mingw" + sSep + "pch_detection.h";
1109 string cmd = ssprintf (
1110 "%s -c %s 1>%s 2>%s",
1111 FixSeparatorForSystemCommand(compilerCommand).c_str (),
1112 path.c_str (),
1113 NUL,
1114 NUL );
1115 system ( cmd.c_str () );
1116 path += ".gch";
1117
1118 FILE* f = fopen ( path.c_str (), "rb" );
1119 if ( f )
1120 {
1121 use_pch = true;
1122 fclose ( f );
1123 unlink ( path.c_str () );
1124 }
1125 else
1126 use_pch = false;
1127
1128 if ( use_pch )
1129 printf ( "detected\n" );
1130 else
1131 printf ( "not detected\n" );
1132 }
1133 else
1134 {
1135 use_pch = false;
1136 printf ( "disabled\n" );
1137 }
1138 }
1139
1140 void
1141 MingwBackend::GetNonModuleInstallTargetFiles (
1142 vector<FileLocation>& out ) const
1143 {
1144 for ( size_t i = 0; i < ProjectNode.installfiles.size (); i++ )
1145 {
1146 const InstallFile& installfile = *ProjectNode.installfiles[i];
1147 out.push_back ( *installfile.target );
1148 }
1149 }
1150
1151 void
1152 MingwBackend::GetModuleInstallTargetFiles (
1153 vector<FileLocation>& out ) const
1154 {
1155 for ( std::map<std::string, Module*>::const_iterator p = ProjectNode.modules.begin (); p != ProjectNode.modules.end (); ++ p )
1156 {
1157 const Module& module = *p->second;
1158 if ( !module.enabled )
1159 continue;
1160 if ( module.install )
1161 out.push_back ( *module.install );
1162 }
1163 }
1164
1165 void
1166 MingwBackend::GetInstallTargetFiles (
1167 vector<FileLocation>& out ) const
1168 {
1169 GetNonModuleInstallTargetFiles ( out );
1170 GetModuleInstallTargetFiles ( out );
1171 }
1172
1173 void
1174 MingwBackend::OutputInstallTarget ( const FileLocation& source,
1175 const FileLocation& target )
1176 {
1177 fprintf ( fMakefile,
1178 "%s: %s | %s\n",
1179 GetFullName ( target ).c_str (),
1180 GetFullName ( source ).c_str (),
1181 GetFullPath ( target ).c_str () );
1182 fprintf ( fMakefile,
1183 "\t$(ECHO_CP)\n" );
1184 fprintf ( fMakefile,
1185 "\t${cp} %s %s 1>$(NUL)\n",
1186 GetFullName ( source ).c_str (),
1187 GetFullName ( target ).c_str () );
1188 }
1189
1190 void
1191 MingwBackend::OutputNonModuleInstallTargets ()
1192 {
1193 for ( size_t i = 0; i < ProjectNode.installfiles.size (); i++ )
1194 {
1195 const InstallFile& installfile = *ProjectNode.installfiles[i];
1196 OutputInstallTarget ( *installfile.source, *installfile.target );
1197 }
1198 }
1199
1200 const Module&
1201 MingwBackend::GetAliasedModuleOrModule ( const Module& module ) const
1202 {
1203 if ( module.aliasedModuleName.size () > 0 )
1204 {
1205 const Module* aliasedModule = ProjectNode.LocateModule ( module.aliasedModuleName );
1206 assert ( aliasedModule );
1207 return *aliasedModule;
1208 }
1209 else
1210 return module;
1211 }
1212
1213 void
1214 MingwBackend::OutputModuleInstallTargets ()
1215 {
1216 for ( std::map<std::string, Module*>::const_iterator p = ProjectNode.modules.begin (); p != ProjectNode.modules.end (); ++ p )
1217 {
1218 const Module& module = *p->second;
1219 if ( !module.enabled )
1220 continue;
1221 if ( module.install )
1222 {
1223 const Module& aliasedModule = GetAliasedModuleOrModule ( module );
1224 OutputInstallTarget ( *aliasedModule.output, *module.install );
1225 }
1226 }
1227 }
1228
1229 string
1230 MingwBackend::GetRegistrySourceFiles ()
1231 {
1232 return "boot" + sSep + "bootdata" + sSep + "hivecls_" + Environment::GetArch() + ".inf "
1233 "boot" + sSep + "bootdata" + sSep + "hivedef_" + Environment::GetArch() + ".inf "
1234 "boot" + sSep + "bootdata" + sSep + "hiveinst_" + Environment::GetArch() + ".inf "
1235 "boot" + sSep + "bootdata" + sSep + "hivesft_" + Environment::GetArch() + ".inf "
1236 "boot" + sSep + "bootdata" + sSep + "hivesys_" + Environment::GetArch() + ".inf ";
1237 }
1238
1239 string
1240 MingwBackend::GetRegistryTargetFiles ()
1241 {
1242 string system32ConfigDirectory = "system32" + sSep + "config";
1243 FileLocation system32 ( InstallDirectory, system32ConfigDirectory, "" );
1244
1245 vector<FileLocation> registry_files;
1246 registry_files.push_back ( FileLocation ( InstallDirectory, system32ConfigDirectory, "default" ) );
1247 registry_files.push_back ( FileLocation ( InstallDirectory, system32ConfigDirectory, "sam" ) );
1248 registry_files.push_back ( FileLocation ( InstallDirectory, system32ConfigDirectory, "security" ) );
1249 registry_files.push_back ( FileLocation ( InstallDirectory, system32ConfigDirectory, "software" ) );
1250 registry_files.push_back ( FileLocation ( InstallDirectory, system32ConfigDirectory, "system" ) );
1251
1252 return v2s( this, registry_files, 6 );
1253 }
1254
1255 void
1256 MingwBackend::OutputRegistryInstallTarget ()
1257 {
1258 FileLocation system32 ( InstallDirectory, "system32" + sSep + "config", "" );
1259
1260 string registrySourceFiles = GetRegistrySourceFiles ();
1261 string registryTargetFiles = GetRegistryTargetFiles ();
1262 fprintf ( fMakefile,
1263 "install_registry: %s\n",
1264 registryTargetFiles.c_str () );
1265 fprintf ( fMakefile,
1266 "%s: %s %s $(MKHIVE_TARGET)\n",
1267 registryTargetFiles.c_str (),
1268 registrySourceFiles.c_str (),
1269 GetFullPath ( system32 ).c_str () );
1270 fprintf ( fMakefile,
1271 "\t$(ECHO_MKHIVE)\n" );
1272 fprintf ( fMakefile,
1273 "\t$(MKHIVE_TARGET) boot%cbootdata %s $(ARCH) boot%cbootdata%chiveinst_$(ARCH).inf\n",
1274 cSep, GetFullPath ( system32 ).c_str (),
1275 cSep, cSep );
1276 fprintf ( fMakefile,
1277 "\n" );
1278 }
1279
1280 void
1281 MingwBackend::GenerateInstallTarget ()
1282 {
1283 vector<FileLocation> vInstallTargetFiles;
1284 GetInstallTargetFiles ( vInstallTargetFiles );
1285 string installTargetFiles = v2s ( this, vInstallTargetFiles, 5 );
1286 string registryTargetFiles = GetRegistryTargetFiles ();
1287
1288 fprintf ( fMakefile,
1289 "install: %s %s\n",
1290 installTargetFiles.c_str (),
1291 registryTargetFiles.c_str () );
1292 OutputNonModuleInstallTargets ();
1293 OutputModuleInstallTargets ();
1294 OutputRegistryInstallTarget ();
1295 fprintf ( fMakefile,
1296 "\n" );
1297 }
1298
1299 void
1300 MingwBackend::GetModuleTestTargets (
1301 vector<string>& out ) const
1302 {
1303 for ( std::map<std::string, Module*>::const_iterator p = ProjectNode.modules.begin (); p != ProjectNode.modules.end (); ++ p )
1304 {
1305 const Module& module = *p->second;
1306 if ( !module.enabled )
1307 continue;
1308 if ( module.type == Test )
1309 out.push_back ( module.name );
1310 }
1311 }
1312
1313 void
1314 MingwBackend::GenerateTestTarget ()
1315 {
1316 vector<string> vTestTargets;
1317 GetModuleTestTargets ( vTestTargets );
1318 string testTargets = v2s ( vTestTargets, 5 );
1319
1320 fprintf ( fMakefile,
1321 "test: %s\n",
1322 testTargets.c_str () );
1323 fprintf ( fMakefile,
1324 "\n" );
1325 }
1326
1327 void
1328 MingwBackend::GenerateDirectoryTargets ()
1329 {
1330 intermediateDirectory->CreateRule ( fMakefile, "$(INTERMEDIATE)" );
1331 outputDirectory->CreateRule ( fMakefile, "$(OUTPUT)" );
1332 installDirectory->CreateRule ( fMakefile, "$(INSTALL)" );
1333 }