Sync with trunk r43123
[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)'\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& TARGET_CCValue = Environment::GetVariable ( "TARGET_CC" );
744 const string& ROS_PREFIXValue = Environment::GetVariable ( "ROS_PREFIX" );
745
746 if ( TARGET_CCValue.length () > 0 )
747 {
748 compilerPrefix = "";
749 compilerCommand = TARGET_CCValue;
750 detectedCompiler = TryToDetectThisCompiler ( compilerCommand );
751 }
752
753 if ( !detectedCompiler )
754 {
755 if ( ROS_PREFIXValue.length () > 0 )
756 {
757 compilerPrefix = ROS_PREFIXValue;
758 compilerCommand = compilerPrefix + "-gcc";
759 detectedCompiler = TryToDetectThisCompiler ( compilerCommand );
760 }
761 }
762 #if defined(WIN32)
763 if ( !detectedCompiler )
764 {
765 compilerPrefix = "";
766 compilerCommand = "gcc";
767 detectedCompiler = TryToDetectThisCompiler ( compilerCommand );
768 }
769 #endif
770 if ( !detectedCompiler )
771 {
772 compilerPrefix = "mingw32";
773 compilerCommand = compilerPrefix + "-gcc";
774 detectedCompiler = TryToDetectThisCompiler ( compilerCommand );
775 }
776
777 if ( detectedCompiler )
778 compilerVersion = GetCompilerVersion ( compilerCommand );
779
780 supportedCompiler = IsSupportedCompilerVersion ( compilerVersion );
781 }
782 else if ( ProjectNode.configuration.Compiler == MicrosoftC )
783 {
784 compilerCommand = "cl";
785 detectedCompiler = DetectMicrosoftCompiler ( compilerVersion, mscPath );
786 supportedCompiler = true; // TODO
787 }
788
789 if ( detectedCompiler )
790 {
791 if ( supportedCompiler )
792 printf ( "detected (%s %s)\n", compilerCommand.c_str (), compilerVersion.c_str() );
793 else
794 {
795 printf ( "detected (%s), but with unsupported version (%s)\n",
796 compilerCommand.c_str (),
797 compilerVersion.c_str () );
798 throw UnsupportedBuildToolException ( compilerCommand, compilerVersion );
799 }
800 }
801 else
802 printf ( "not detected\n" );
803
804 }
805
806 bool
807 MingwBackend::TryToDetectThisNetwideAssembler ( const string& assembler )
808 {
809 string command = ssprintf (
810 "%s -h 1>%s 2>%s",
811 FixSeparatorForSystemCommand(assembler).c_str (),
812 NUL,
813 NUL );
814 int exitcode = system ( command.c_str () );
815 return (bool) (exitcode == 0);
816 }
817
818 string
819 MingwBackend::GetVersionString ( const string& versionCommand )
820 {
821 FILE *fp;
822 int ch, i;
823 size_t newline;
824 char buffer[81];
825
826 fp = popen ( versionCommand.c_str () , "r" );
827 for( i = 0;
828 ( i < 80 ) &&
829 ( feof ( fp ) == 0 &&
830 ( ( ch = fgetc( fp ) ) != -1 ) );
831 i++ )
832 {
833 buffer[i] = (char) ch;
834 }
835 buffer[i] = '\0';
836 pclose ( fp );
837
838 char separators[] = " ()";
839 char *token;
840 char *prevtoken = NULL;
841
842 string version;
843
844 token = strtok ( buffer, separators );
845 while ( token != NULL )
846 {
847 prevtoken = token;
848 version = string( prevtoken );
849 if ( (newline = version.find('\n')) != std::string::npos )
850 version.erase(newline, 1);
851 if ( version.find('.') != std::string::npos )
852 break;
853 token = strtok ( NULL, separators );
854 }
855 return version;
856 }
857
858 string
859 MingwBackend::GetNetwideAssemblerVersion ( const string& nasmCommand )
860 {
861 string versionCommand;
862 if ( nasmCommand.find("yasm") != std::string::npos )
863 {
864 versionCommand = ssprintf ( "%s --version",
865 nasmCommand.c_str (),
866 NUL,
867 NUL );
868 }
869 else
870 {
871 versionCommand = ssprintf ( "%s -v",
872 nasmCommand.c_str (),
873 NUL,
874 NUL );
875 }
876 return GetVersionString( versionCommand );
877 }
878
879 string
880 MingwBackend::GetCompilerVersion ( const string& compilerCommand )
881 {
882 string versionCommand = ssprintf ( "%s --version gcc",
883 compilerCommand.c_str (),
884 NUL,
885 NUL );
886 return GetVersionString( versionCommand );
887 }
888
889 string
890 MingwBackend::GetBinutilsVersion ( const string& binutilsCommand )
891 {
892 string versionCommand = ssprintf ( "%s -v",
893 binutilsCommand.c_str (),
894 NUL,
895 NUL );
896 return GetVersionString( versionCommand );
897 }
898
899 bool
900 MingwBackend::IsSupportedCompilerVersion ( const string& compilerVersion )
901 {
902 if ( strcmp ( compilerVersion.c_str (), "3.4.2") < 0 )
903 return false;
904 else
905 return true;
906 }
907
908 bool
909 MingwBackend::TryToDetectThisBinutils ( const string& binutils )
910 {
911 string command = ssprintf (
912 "%s -v 1>%s 2>%s",
913 FixSeparatorForSystemCommand(binutils).c_str (),
914 NUL,
915 NUL );
916 int exitcode = system ( command.c_str () );
917 return (exitcode == 0);
918 }
919
920 string
921 MingwBackend::GetBinutilsVersionDate ( const string& binutilsCommand )
922 {
923 FILE *fp;
924 int ch, i;
925 char buffer[81];
926
927 string versionCommand = ssprintf ( "%s -v",
928 binutilsCommand.c_str (),
929 NUL,
930 NUL );
931 fp = popen ( versionCommand.c_str () , "r" );
932 for( i = 0;
933 ( i < 80 ) &&
934 ( feof ( fp ) == 0 &&
935 ( ( ch = fgetc( fp ) ) != -1 ) );
936 i++ )
937 {
938 buffer[i] = (char) ch;
939 }
940 buffer[i] = '\0';
941 pclose ( fp );
942
943 char separators[] = " ";
944 char *token;
945 char *prevtoken = NULL;
946
947 token = strtok ( buffer, separators );
948 while ( token != NULL )
949 {
950 prevtoken = token;
951 token = strtok ( NULL, separators );
952 }
953 string version = string ( prevtoken );
954 int lastDigit = version.find_last_not_of ( "\t\r\n" );
955 if ( lastDigit != -1 )
956 return string ( version, 0, lastDigit+1 );
957 else
958 return version;
959 }
960
961 bool
962 MingwBackend::IsSupportedBinutilsVersion ( const string& binutilsVersion )
963 {
964 if ( manualBinutilsSetting ) return true;
965
966 /* linux */
967 if ( binutilsVersion.find('.') != std::string::npos )
968 {
969 /* TODO: blacklist versions on version number instead of date */
970 return true;
971 }
972
973 /*
974 * - Binutils older than 2003/10/01 have broken windres which can't handle
975 * icons with alpha channel.
976 * - Binutils between 2004/09/02 and 2004/10/08 have broken handling of
977 * forward exports in dlltool.
978 */
979 if ( ( ( strcmp ( binutilsVersion.c_str (), "20040902") >= 0 ) &&
980 ( strcmp ( binutilsVersion.c_str (), "20041008") <= 0 ) ) ||
981 ( strcmp ( binutilsVersion.c_str (), "20031001") < 0 ) )
982 return false;
983 else
984 return true;
985 }
986
987 void
988 MingwBackend::DetectBinutils ()
989 {
990 printf ( "Detecting binutils..." );
991
992 bool detectedBinutils = false;
993 bool supportedBinutils = false;
994 string binutilsVersion;
995
996 if ( ProjectNode.configuration.Linker == GnuLd )
997 {
998 const string& ROS_PREFIXValue = Environment::GetVariable ( "ROS_PREFIX" );
999
1000 if ( ROS_PREFIXValue.length () > 0 )
1001 {
1002 binutilsPrefix = ROS_PREFIXValue;
1003 binutilsCommand = binutilsPrefix + "-ld";
1004 manualBinutilsSetting = true;
1005 detectedBinutils = true;
1006 }
1007 #if defined(WIN32)
1008 if ( !detectedBinutils )
1009 {
1010 binutilsPrefix = "";
1011 binutilsCommand = "ld";
1012 detectedBinutils = TryToDetectThisBinutils ( binutilsCommand );
1013 }
1014 #endif
1015 if ( !detectedBinutils )
1016 {
1017 binutilsPrefix = "mingw32";
1018 binutilsCommand = binutilsPrefix + "-ld";
1019 detectedBinutils = TryToDetectThisBinutils ( binutilsCommand );
1020 }
1021 if ( detectedBinutils )
1022 {
1023 binutilsVersion = GetBinutilsVersionDate ( binutilsCommand );
1024 supportedBinutils = IsSupportedBinutilsVersion ( binutilsVersion );
1025 }
1026 }
1027 else if ( ProjectNode.configuration.Linker == MicrosoftLink )
1028 {
1029 compilerCommand = "link";
1030 detectedBinutils = DetectMicrosoftLinker ( binutilsVersion, mslinkPath );
1031 supportedBinutils = true; // TODO
1032 }
1033
1034 if ( detectedBinutils )
1035 {
1036 if ( supportedBinutils )
1037 printf ( "detected (%s %s)\n", binutilsCommand.c_str (), binutilsVersion.c_str() );
1038 else
1039 {
1040 printf ( "detected (%s), but with unsupported version (%s)\n",
1041 binutilsCommand.c_str (),
1042 binutilsVersion.c_str () );
1043 throw UnsupportedBuildToolException ( binutilsCommand, binutilsVersion );
1044 }
1045 }
1046 else
1047 printf ( "not detected\n" );
1048
1049 }
1050
1051 void
1052 MingwBackend::DetectNetwideAssembler ()
1053 {
1054 printf ( "Detecting netwide assembler..." );
1055
1056 nasmCommand = "nasm";
1057 bool detectedNasm = TryToDetectThisNetwideAssembler ( nasmCommand );
1058 #if defined(WIN32)
1059 if ( !detectedNasm )
1060 {
1061 nasmCommand = "nasmw";
1062 detectedNasm = TryToDetectThisNetwideAssembler ( nasmCommand );
1063 }
1064 #endif
1065 if ( !detectedNasm )
1066 {
1067 nasmCommand = "yasm";
1068 detectedNasm = TryToDetectThisNetwideAssembler ( nasmCommand );
1069 }
1070 if ( detectedNasm )
1071 printf ( "detected (%s %s)\n", nasmCommand.c_str (), GetNetwideAssemblerVersion( nasmCommand ).c_str() );
1072 else
1073 printf ( "not detected\n" );
1074 }
1075
1076 void
1077 MingwBackend::DetectPipeSupport ()
1078 {
1079 if ( ProjectNode.configuration.Compiler == GnuGcc )
1080 {
1081 printf ( "Detecting compiler -pipe support..." );
1082
1083 string pipe_detection = "tools" + sSep + "rbuild" + sSep + "backend" + sSep + "mingw" + sSep + "pipe_detection.c";
1084 string pipe_detectionObjectFilename = ReplaceExtension ( pipe_detection,
1085 ".o" );
1086 string command = ssprintf (
1087 "%s -pipe -c %s -o %s 1>%s 2>%s",
1088 FixSeparatorForSystemCommand(compilerCommand).c_str (),
1089 pipe_detection.c_str (),
1090 pipe_detectionObjectFilename.c_str (),
1091 NUL,
1092 NUL );
1093 int exitcode = system ( command.c_str () );
1094 FILE* f = fopen ( pipe_detectionObjectFilename.c_str (), "rb" );
1095 if ( f )
1096 {
1097 usePipe = (exitcode == 0);
1098 fclose ( f );
1099 unlink ( pipe_detectionObjectFilename.c_str () );
1100 }
1101 else
1102 usePipe = false;
1103
1104 if ( usePipe )
1105 printf ( "detected\n" );
1106 else
1107 printf ( "not detected\n" );
1108 }
1109 else
1110 usePipe = false;
1111 }
1112
1113 void
1114 MingwBackend::DetectPCHSupport ()
1115 {
1116 printf ( "Detecting compiler pre-compiled header support..." );
1117
1118 if ( configuration.PrecompiledHeadersEnabled && ProjectNode.configuration.Compiler == GnuGcc )
1119 {
1120 string path = "tools" + sSep + "rbuild" + sSep + "backend" + sSep + "mingw" + sSep + "pch_detection.h";
1121 string cmd = ssprintf (
1122 "%s -c %s 1>%s 2>%s",
1123 FixSeparatorForSystemCommand(compilerCommand).c_str (),
1124 path.c_str (),
1125 NUL,
1126 NUL );
1127 system ( cmd.c_str () );
1128 path += ".gch";
1129
1130 FILE* f = fopen ( path.c_str (), "rb" );
1131 if ( f )
1132 {
1133 use_pch = true;
1134 fclose ( f );
1135 unlink ( path.c_str () );
1136 }
1137 else
1138 use_pch = false;
1139
1140 if ( use_pch )
1141 printf ( "detected\n" );
1142 else
1143 printf ( "not detected\n" );
1144 }
1145 else
1146 {
1147 use_pch = false;
1148 printf ( "disabled\n" );
1149 }
1150 }
1151
1152 void
1153 MingwBackend::GetNonModuleInstallTargetFiles (
1154 vector<FileLocation>& out ) const
1155 {
1156 for ( size_t i = 0; i < ProjectNode.installfiles.size (); i++ )
1157 {
1158 const InstallFile& installfile = *ProjectNode.installfiles[i];
1159 out.push_back ( *installfile.target );
1160 }
1161 }
1162
1163 void
1164 MingwBackend::GetModuleInstallTargetFiles (
1165 vector<FileLocation>& out ) const
1166 {
1167 for ( std::map<std::string, Module*>::const_iterator p = ProjectNode.modules.begin (); p != ProjectNode.modules.end (); ++ p )
1168 {
1169 const Module& module = *p->second;
1170 if ( !module.enabled )
1171 continue;
1172 if ( module.install )
1173 out.push_back ( *module.install );
1174 }
1175 }
1176
1177 void
1178 MingwBackend::GetInstallTargetFiles (
1179 vector<FileLocation>& out ) const
1180 {
1181 GetNonModuleInstallTargetFiles ( out );
1182 GetModuleInstallTargetFiles ( out );
1183 }
1184
1185 void
1186 MingwBackend::OutputInstallTarget ( const FileLocation& source,
1187 const FileLocation& target )
1188 {
1189 fprintf ( fMakefile,
1190 "%s: %s | %s\n",
1191 GetFullName ( target ).c_str (),
1192 GetFullName ( source ).c_str (),
1193 GetFullPath ( target ).c_str () );
1194 fprintf ( fMakefile,
1195 "\t$(ECHO_CP)\n" );
1196 fprintf ( fMakefile,
1197 "\t${cp} %s %s 1>$(NUL)\n",
1198 GetFullName ( source ).c_str (),
1199 GetFullName ( target ).c_str () );
1200 }
1201
1202 void
1203 MingwBackend::OutputNonModuleInstallTargets ()
1204 {
1205 for ( size_t i = 0; i < ProjectNode.installfiles.size (); i++ )
1206 {
1207 const InstallFile& installfile = *ProjectNode.installfiles[i];
1208 OutputInstallTarget ( *installfile.source, *installfile.target );
1209 }
1210 }
1211
1212 const Module&
1213 MingwBackend::GetAliasedModuleOrModule ( const Module& module ) const
1214 {
1215 if ( module.aliasedModuleName.size () > 0 )
1216 {
1217 const Module* aliasedModule = ProjectNode.LocateModule ( module.aliasedModuleName );
1218 assert ( aliasedModule );
1219 return *aliasedModule;
1220 }
1221 else
1222 return module;
1223 }
1224
1225 void
1226 MingwBackend::OutputModuleInstallTargets ()
1227 {
1228 for ( std::map<std::string, Module*>::const_iterator p = ProjectNode.modules.begin (); p != ProjectNode.modules.end (); ++ p )
1229 {
1230 const Module& module = *p->second;
1231 if ( !module.enabled )
1232 continue;
1233 if ( module.install )
1234 {
1235 const Module& aliasedModule = GetAliasedModuleOrModule ( module );
1236 OutputInstallTarget ( *aliasedModule.output, *module.install );
1237 }
1238 }
1239 }
1240
1241 string
1242 MingwBackend::GetRegistrySourceFiles ()
1243 {
1244 return "boot" + sSep + "bootdata" + sSep + "hivecls_" + Environment::GetArch() + ".inf "
1245 "boot" + sSep + "bootdata" + sSep + "hivedef_" + Environment::GetArch() + ".inf "
1246 "boot" + sSep + "bootdata" + sSep + "hiveinst_" + Environment::GetArch() + ".inf "
1247 "boot" + sSep + "bootdata" + sSep + "hivesft_" + Environment::GetArch() + ".inf "
1248 "boot" + sSep + "bootdata" + sSep + "hivesys_" + Environment::GetArch() + ".inf ";
1249 }
1250
1251 string
1252 MingwBackend::GetRegistryTargetFiles ()
1253 {
1254 string system32ConfigDirectory = "system32" + sSep + "config";
1255 FileLocation system32 ( InstallDirectory, system32ConfigDirectory, "" );
1256
1257 vector<FileLocation> registry_files;
1258 registry_files.push_back ( FileLocation ( InstallDirectory, system32ConfigDirectory, "default" ) );
1259 registry_files.push_back ( FileLocation ( InstallDirectory, system32ConfigDirectory, "sam" ) );
1260 registry_files.push_back ( FileLocation ( InstallDirectory, system32ConfigDirectory, "security" ) );
1261 registry_files.push_back ( FileLocation ( InstallDirectory, system32ConfigDirectory, "software" ) );
1262 registry_files.push_back ( FileLocation ( InstallDirectory, system32ConfigDirectory, "system" ) );
1263
1264 return v2s( this, registry_files, 6 );
1265 }
1266
1267 void
1268 MingwBackend::OutputRegistryInstallTarget ()
1269 {
1270 FileLocation system32 ( InstallDirectory, "system32" + sSep + "config", "" );
1271
1272 string registrySourceFiles = GetRegistrySourceFiles ();
1273 string registryTargetFiles = GetRegistryTargetFiles ();
1274 fprintf ( fMakefile,
1275 "install_registry: %s\n",
1276 registryTargetFiles.c_str () );
1277 fprintf ( fMakefile,
1278 "%s: %s %s $(MKHIVE_TARGET)\n",
1279 registryTargetFiles.c_str (),
1280 registrySourceFiles.c_str (),
1281 GetFullPath ( system32 ).c_str () );
1282 fprintf ( fMakefile,
1283 "\t$(ECHO_MKHIVE)\n" );
1284 fprintf ( fMakefile,
1285 "\t$(MKHIVE_TARGET) boot%cbootdata %s $(ARCH) boot%cbootdata%chiveinst_$(ARCH).inf\n",
1286 cSep, GetFullPath ( system32 ).c_str (),
1287 cSep, cSep );
1288 fprintf ( fMakefile,
1289 "\n" );
1290 }
1291
1292 void
1293 MingwBackend::GenerateInstallTarget ()
1294 {
1295 vector<FileLocation> vInstallTargetFiles;
1296 GetInstallTargetFiles ( vInstallTargetFiles );
1297 string installTargetFiles = v2s ( this, vInstallTargetFiles, 5 );
1298 string registryTargetFiles = GetRegistryTargetFiles ();
1299
1300 fprintf ( fMakefile,
1301 "install: %s %s\n",
1302 installTargetFiles.c_str (),
1303 registryTargetFiles.c_str () );
1304 OutputNonModuleInstallTargets ();
1305 OutputModuleInstallTargets ();
1306 OutputRegistryInstallTarget ();
1307 fprintf ( fMakefile,
1308 "\n" );
1309 }
1310
1311 void
1312 MingwBackend::GetModuleTestTargets (
1313 vector<string>& out ) const
1314 {
1315 for ( std::map<std::string, Module*>::const_iterator p = ProjectNode.modules.begin (); p != ProjectNode.modules.end (); ++ p )
1316 {
1317 const Module& module = *p->second;
1318 if ( !module.enabled )
1319 continue;
1320 if ( module.type == Test )
1321 out.push_back ( module.name );
1322 }
1323 }
1324
1325 void
1326 MingwBackend::GenerateTestTarget ()
1327 {
1328 vector<string> vTestTargets;
1329 GetModuleTestTargets ( vTestTargets );
1330 string testTargets = v2s ( vTestTargets, 5 );
1331
1332 fprintf ( fMakefile,
1333 "test: %s\n",
1334 testTargets.c_str () );
1335 fprintf ( fMakefile,
1336 "\n" );
1337 }
1338
1339 void
1340 MingwBackend::GenerateDirectoryTargets ()
1341 {
1342 intermediateDirectory->CreateRule ( fMakefile, "$(INTERMEDIATE)" );
1343 outputDirectory->CreateRule ( fMakefile, "$(OUTPUT)" );
1344 installDirectory->CreateRule ( fMakefile, "$(INSTALL)" );
1345 }