Option to disable compilation units
[reactos.git] / reactos / tools / rbuild / project.cpp
1 /*
2 * Copyright (C) 2005 Casper S. Hornstrup
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
17 */
18 #include "pch.h"
19 #include <assert.h>
20
21 #include "rbuild.h"
22
23 using std::string;
24 using std::vector;
25
26 /* static */ string
27 Environment::GetVariable ( const string& name )
28 {
29 char* value = getenv ( name.c_str () );
30 if ( value != NULL && strlen ( value ) > 0 )
31 return ssprintf ( "%s",
32 value );
33 else
34 return "";
35 }
36
37 /* static */ string
38 Environment::GetEnvironmentVariablePathOrDefault ( const string& name,
39 const string& defaultValue )
40 {
41 const string& environmentVariableValue = Environment::GetVariable ( name );
42 if ( environmentVariableValue.length () > 0 )
43 return NormalizeFilename ( environmentVariableValue );
44 else
45 return defaultValue;
46 }
47
48 /* static */ string
49 Environment::GetIntermediatePath ()
50 {
51 return GetEnvironmentVariablePathOrDefault ( "ROS_INTERMEDIATE",
52 "obj-i386" );
53 }
54
55 /* static */ string
56 Environment::GetOutputPath ()
57 {
58 return GetEnvironmentVariablePathOrDefault ( "ROS_OUTPUT",
59 "output-i386" );
60 }
61
62 /* static */ string
63 Environment::GetInstallPath ()
64 {
65 return GetEnvironmentVariablePathOrDefault ( "ROS_INSTALL",
66 "reactos" );
67 }
68
69 ParseContext::ParseContext ()
70 : ifData (NULL),
71 compilationUnit (NULL)
72 {
73 }
74
75
76 FileLocation::FileLocation ( Directory* directory,
77 std::string filename )
78 : directory (directory),
79 filename (filename)
80 {
81 }
82
83
84 Project::Project ( const Configuration& configuration,
85 const string& filename )
86 : xmlfile (filename),
87 node (NULL),
88 head (NULL),
89 configuration (configuration)
90 {
91 ReadXml();
92 }
93
94 Project::~Project ()
95 {
96 size_t i;
97 for ( i = 0; i < modules.size (); i++ )
98 delete modules[i];
99 for ( i = 0; i < linkerFlags.size (); i++ )
100 delete linkerFlags[i];
101 for ( i = 0; i < cdfiles.size (); i++ )
102 delete cdfiles[i];
103 for ( i = 0; i < installfiles.size (); i++ )
104 delete installfiles[i];
105 delete head;
106 }
107
108 const Property*
109 Project::LookupProperty ( const string& name ) const
110 {
111 for ( size_t i = 0; i < non_if_data.properties.size (); i++ )
112 {
113 const Property* property = non_if_data.properties[i];
114 if ( property->name == name )
115 return property;
116 }
117 return NULL;
118 }
119
120 string
121 Project::ResolveNextProperty ( string& s ) const
122 {
123 size_t i = s.find ( "${" );
124 if ( i == string::npos )
125 i = s.find ( "$(" );
126 if ( i != string::npos )
127 {
128 string endCharacter;
129 if ( s[i + 1] == '{' )
130 endCharacter = "}";
131 else
132 endCharacter = ")";
133 size_t j = s.find ( endCharacter );
134 if ( j != string::npos )
135 {
136 int propertyNameLength = j - i - 2;
137 string propertyName = s.substr ( i + 2, propertyNameLength );
138 const Property* property = LookupProperty ( propertyName );
139 if ( property != NULL )
140 return s.replace ( i, propertyNameLength + 3, property->value );
141 }
142 }
143 return s;
144 }
145
146 string
147 Project::ResolveProperties ( const string& s ) const
148 {
149 string s2 = s;
150 string s3;
151 do
152 {
153 s3 = s2;
154 s2 = ResolveNextProperty ( s3 );
155 } while ( s2 != s3 );
156 return s2;
157 }
158
159 void
160 Project::SetConfigurationOption ( char* s,
161 string name,
162 string* alternativeName )
163 {
164 const Property* property = LookupProperty ( name );
165 if ( property != NULL && property->value.length () > 0 )
166 {
167 s = s + sprintf ( s,
168 "#define %s=%s\n",
169 property->name.c_str (),
170 property->value.c_str () );
171 }
172 else if ( property != NULL )
173 {
174 s = s + sprintf ( s,
175 "#define %s\n",
176 property->name.c_str () );
177 }
178 else if ( alternativeName != NULL )
179 {
180 s = s + sprintf ( s,
181 "#define %s\n",
182 alternativeName->c_str () );
183 }
184 }
185
186 void
187 Project::SetConfigurationOption ( char* s,
188 string name )
189 {
190 SetConfigurationOption ( s, name, NULL );
191 }
192
193 void
194 Project::WriteConfigurationFile ()
195 {
196 char* buf;
197 char* s;
198
199 buf = (char*) malloc ( 10*1024 );
200 if ( buf == NULL )
201 throw OutOfMemoryException ();
202
203 s = buf;
204 s = s + sprintf ( s, "/* Automatically generated. " );
205 s = s + sprintf ( s, "Edit config.xml to change configuration */\n" );
206 s = s + sprintf ( s, "#ifndef __INCLUDE_CONFIG_H\n" );
207 s = s + sprintf ( s, "#define __INCLUDE_CONFIG_H\n" );
208
209 SetConfigurationOption ( s, "ARCH" );
210 SetConfigurationOption ( s, "OPTIMIZED" );
211 SetConfigurationOption ( s, "MP", new string ( "UP" ) );
212 SetConfigurationOption ( s, "ACPI" );
213 SetConfigurationOption ( s, "_3GB" );
214
215 s = s + sprintf ( s, "#endif /* __INCLUDE_CONFIG_H */\n" );
216
217 FileSupportCode::WriteIfChanged ( buf, "include" + sSep + "roscfg.h" );
218
219 free ( buf );
220 }
221
222 void
223 Project::ExecuteInvocations ()
224 {
225 for ( size_t i = 0; i < modules.size (); i++ )
226 modules[i]->InvokeModule ();
227 }
228
229 void
230 Project::ReadXml ()
231 {
232 Path path;
233 head = XMLLoadFile ( xmlfile, path, xmlbuildfiles );
234 node = NULL;
235 for ( size_t i = 0; i < head->subElements.size (); i++ )
236 {
237 if ( head->subElements[i]->name == "project" )
238 {
239 node = head->subElements[i];
240 string path;
241 this->ProcessXML ( path );
242 return;
243 }
244 }
245
246 if (node == NULL)
247 node = head->subElements[0];
248
249 throw InvalidBuildFileException (
250 node->location,
251 "Document contains no 'project' tag." );
252 }
253
254 void
255 Project::ProcessXML ( const string& path )
256 {
257 const XMLAttribute *att;
258 if ( node->name != "project" )
259 throw Exception ( "internal tool error: Project::ProcessXML() called with non-<project> node" );
260
261 att = node->GetAttribute ( "name", false );
262 if ( !att )
263 name = "Unnamed";
264 else
265 name = att->value;
266
267 att = node->GetAttribute ( "makefile", true );
268 assert(att);
269 makefile = att->value;
270
271 size_t i;
272 for ( i = 0; i < node->subElements.size (); i++ )
273 {
274 ParseContext parseContext;
275 ProcessXMLSubElement ( *node->subElements[i], path, parseContext );
276 }
277 for ( i = 0; i < modules.size (); i++ )
278 modules[i]->ProcessXML ();
279 for ( i = 0; i < linkerFlags.size (); i++ )
280 linkerFlags[i]->ProcessXML ();
281 non_if_data.ProcessXML ();
282 for ( i = 0; i < cdfiles.size (); i++ )
283 cdfiles[i]->ProcessXML ();
284 for ( i = 0; i < installfiles.size (); i++ )
285 installfiles[i]->ProcessXML ();
286 }
287
288 void
289 Project::ProcessXMLSubElement ( const XMLElement& e,
290 const string& path,
291 ParseContext& parseContext )
292 {
293 bool subs_invalid = false;
294 string subpath(path);
295 if ( e.name == "module" )
296 {
297 if ( parseContext.ifData )
298 throw InvalidBuildFileException (
299 e.location,
300 "<module> is not a valid sub-element of <if>" );
301 Module* module = new Module ( *this, e, path );
302 if ( LocateModule ( module->name ) )
303 throw InvalidBuildFileException (
304 node->location,
305 "module name conflict: '%s' (originally defined at %s)",
306 module->name.c_str(),
307 module->node.location.c_str() );
308 modules.push_back ( module );
309 return; // defer processing until later
310 }
311 else if ( e.name == "cdfile" )
312 {
313 CDFile* cdfile = new CDFile ( *this, e, path );
314 cdfiles.push_back ( cdfile );
315 subs_invalid = true;
316 }
317 else if ( e.name == "installfile" )
318 {
319 InstallFile* installfile = new InstallFile ( *this, e, path );
320 installfiles.push_back ( installfile );
321 subs_invalid = true;
322 }
323 else if ( e.name == "directory" )
324 {
325 const XMLAttribute* att = e.GetAttribute ( "name", true );
326 assert(att);
327 subpath = GetSubPath ( e.location, path, att->value );
328 }
329 else if ( e.name == "include" )
330 {
331 Include* include = new Include ( *this, &e );
332 if ( parseContext.ifData )
333 parseContext.ifData->data.includes.push_back ( include );
334 else
335 non_if_data.includes.push_back ( include );
336 subs_invalid = true;
337 }
338 else if ( e.name == "define" )
339 {
340 Define* define = new Define ( *this, e );
341 if ( parseContext.ifData )
342 parseContext.ifData->data.defines.push_back ( define );
343 else
344 non_if_data.defines.push_back ( define );
345 subs_invalid = true;
346 }
347 else if ( e.name == "compilerflag" )
348 {
349 CompilerFlag* pCompilerFlag = new CompilerFlag ( *this, e );
350 if ( parseContext.ifData )
351 parseContext.ifData->data.compilerFlags.push_back ( pCompilerFlag );
352 else
353 non_if_data.compilerFlags.push_back ( pCompilerFlag );
354 subs_invalid = true;
355 }
356 else if ( e.name == "linkerflag" )
357 {
358 linkerFlags.push_back ( new LinkerFlag ( *this, e ) );
359 subs_invalid = true;
360 }
361 else if ( e.name == "if" )
362 {
363 If* pOldIf = parseContext.ifData;
364 parseContext.ifData = new If ( e, *this, NULL );
365 if ( pOldIf )
366 pOldIf->data.ifs.push_back ( parseContext.ifData );
367 else
368 non_if_data.ifs.push_back ( parseContext.ifData );
369 subs_invalid = false;
370 }
371 else if ( e.name == "ifnot" )
372 {
373 If* pOldIf = parseContext.ifData;
374 parseContext.ifData = new If ( e, *this, NULL, true );
375 if ( pOldIf )
376 pOldIf->data.ifs.push_back ( parseContext.ifData );
377 else
378 non_if_data.ifs.push_back ( parseContext.ifData );
379 subs_invalid = false;
380 }
381 else if ( e.name == "property" )
382 {
383 Property* property = new Property ( e, *this, NULL );
384 if ( parseContext.ifData )
385 parseContext.ifData->data.properties.push_back ( property );
386 else
387 non_if_data.properties.push_back ( property );
388 }
389 if ( subs_invalid && e.subElements.size() )
390 throw InvalidBuildFileException (
391 e.location,
392 "<%s> cannot have sub-elements",
393 e.name.c_str() );
394 for ( size_t i = 0; i < e.subElements.size (); i++ )
395 ProcessXMLSubElement ( *e.subElements[i], subpath, parseContext );
396 }
397
398 Module*
399 Project::LocateModule ( const string& name )
400 {
401 for ( size_t i = 0; i < modules.size (); i++ )
402 {
403 if (modules[i]->name == name)
404 return modules[i];
405 }
406
407 return NULL;
408 }
409
410 const Module*
411 Project::LocateModule ( const string& name ) const
412 {
413 for ( size_t i = 0; i < modules.size (); i++ )
414 {
415 if ( modules[i]->name == name )
416 return modules[i];
417 }
418
419 return NULL;
420 }
421
422 std::string
423 Project::GetProjectFilename () const
424 {
425 return xmlfile;
426 }