1 /**************************************************************
2 *
3 * Licensed to the Apache Software Foundation (ASF) under one
4 * or more contributor license agreements. See the NOTICE file
5 * distributed with this work for additional information
6 * regarding copyright ownership. The ASF licenses this file
7 * to you under the Apache License, Version 2.0 (the
8 * "License"); you may not use this file except in compliance
9 * with the License. You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing,
14 * software distributed under the License is distributed on an
15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16 * KIND, either express or implied. See the License for the
17 * specific language governing permissions and limitations
18 * under the License.
19 *
20 *************************************************************/
21
22
23
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_tools.hxx"
26
27 // global includes
28 #include <stdio.h>
29
30 // local includes
31 #include "bootstrp/mkcreate.hxx"
32 #include "bootstrp/inimgr.hxx"
33 #include "bootstrp/appdef.hxx"
34 #include <tools/geninfo.hxx>
35 #include <tools/iparser.hxx>
36 #include "bootstrp/prj.hxx"
37
38 char const *NoBuildProject[] = {
39 "solenv",
40 "EndOf_NoBuildProject"
41 };
42
43 char const *LimitedPath[] = {
44 "jurt\\com\\sun\\star",
45 "r_tools",
46 "ridljar",
47 "setup2",
48 "connectivity",
49 "EndOf_LimitedPath"
50 };
51
52 //
53 // class SourceDirectory
54 //
55
56 /*****************************************************************************/
SourceDirectory(const ByteString & rDirectoryName,sal_uInt16 nOperatingSystem,SourceDirectory * pParentDirectory)57 SourceDirectory::SourceDirectory( const ByteString &rDirectoryName,
58 sal_uInt16 nOperatingSystem, SourceDirectory *pParentDirectory )
59 /*****************************************************************************/
60 : ByteString( rDirectoryName ),
61 pParent( pParentDirectory ),
62 pSubDirectories( NULL ),
63 nOSType( nOperatingSystem ),
64 nDepth( 0 ),
65 pDependencies( NULL ),
66 pCodedDependencies( NULL ),
67 pCodedIdentifier( NULL )
68 {
69 if ( pParent ) {
70 if ( !pParent->pSubDirectories )
71 pParent->pSubDirectories = new SourceDirectoryList();
72 pParent->pSubDirectories->InsertSorted( this );
73 nDepth = pParent->nDepth + 1;
74 }
75 }
76
77 /*****************************************************************************/
~SourceDirectory()78 SourceDirectory::~SourceDirectory()
79 /*****************************************************************************/
80 {
81 delete pSubDirectories;
82 }
83
84 /*****************************************************************************/
AddCodedDependency(const ByteString & rCodedIdentifier,sal_uInt16 nOperatingSystems)85 CodedDependency *SourceDirectory::AddCodedDependency(
86 const ByteString &rCodedIdentifier, sal_uInt16 nOperatingSystems )
87 /*****************************************************************************/
88 {
89 CodedDependency *pReturn = NULL;
90
91 if ( !pCodedDependencies ) {
92 pCodedDependencies = new SByteStringList();
93 pReturn = new CodedDependency( rCodedIdentifier, nOperatingSystems );
94 pCodedDependencies->PutString(( ByteString * ) pReturn );
95 }
96 else {
97 sal_uIntPtr nPos =
98 pCodedDependencies->IsString( (ByteString *) (& rCodedIdentifier) );
99 if ( nPos == NOT_THERE ) {
100 pReturn =
101 new CodedDependency( rCodedIdentifier, nOperatingSystems );
102 pCodedDependencies->PutString(( ByteString * ) pReturn );
103 }
104 else {
105 pReturn =
106 ( CodedDependency * ) pCodedDependencies->GetObject( nPos );
107 pReturn->TryToMerge( rCodedIdentifier, nOperatingSystems );
108 }
109 }
110 return pReturn;
111 }
112
113 /*****************************************************************************/
AddCodedIdentifier(const ByteString & rCodedIdentifier,sal_uInt16 nOperatingSystems)114 CodedDependency *SourceDirectory::AddCodedIdentifier(
115 const ByteString &rCodedIdentifier, sal_uInt16 nOperatingSystems )
116 /*****************************************************************************/
117 {
118 CodedDependency *pReturn = NULL;
119
120 if ( !pCodedIdentifier ) {
121 pCodedIdentifier = new SByteStringList();
122 pReturn = new CodedDependency( rCodedIdentifier, nOperatingSystems );
123 pCodedIdentifier->PutString(( ByteString * ) pReturn );
124 }
125 else {
126 sal_uIntPtr nPos =
127 pCodedIdentifier->IsString( ( ByteString *) (& rCodedIdentifier) );
128 if ( nPos == NOT_THERE ) {
129 pReturn =
130 new CodedDependency( rCodedIdentifier, nOperatingSystems );
131 pCodedIdentifier->PutString(( ByteString * ) pReturn );
132 }
133 else {
134 pReturn =
135 ( CodedDependency * ) pCodedIdentifier->GetObject( nPos );
136 pReturn->TryToMerge( rCodedIdentifier, nOperatingSystems );
137 }
138 }
139 if ( pParent && pParent->nDepth > 1 )
140 pParent->AddCodedIdentifier( rCodedIdentifier, nOperatingSystems );
141
142 return pReturn;
143 }
144
145 /*****************************************************************************/
GetFullPath()146 ByteString SourceDirectory::GetFullPath()
147 /*****************************************************************************/
148 {
149 ByteString sFullPath;
150 if ( pParent ) {
151 sFullPath = pParent->GetFullPath();
152 sFullPath += ByteString( PATH_SEPARATOR );
153 }
154 sFullPath += *this;
155
156 return sFullPath;
157 }
158
159 /*****************************************************************************/
GetRootDirectory()160 SourceDirectory *SourceDirectory::GetRootDirectory()
161 /*****************************************************************************/
162 {
163 if ( !pParent )
164 return this;
165
166 return pParent->GetRootDirectory();
167 }
168
169 /*****************************************************************************/
GetSubDirectory(const ByteString & rDirectoryPath,sal_uInt16 nOperatingSystem)170 SourceDirectory *SourceDirectory::GetSubDirectory(
171 const ByteString &rDirectoryPath, sal_uInt16 nOperatingSystem )
172 /*****************************************************************************/
173 {
174 ByteString sSearch;
175
176 sal_Bool bSubs = sal_True;
177 sal_uIntPtr nIndex = 0;
178
179 while ( bSubs && ByteString( LimitedPath[ nIndex ]) != "EndOf_LimitedPath" ) {
180 SourceDirectory *pActDir = this;
181 ByteString sLimitation( LimitedPath[ nIndex ]);
182
183 sal_Bool bBreak = sal_False;
184 for ( sal_uIntPtr i = sLimitation.GetTokenCount( '\\' ); i > 0 && !bBreak; i-- ) {
185 if (( !pActDir ) || ( *pActDir != sLimitation.GetToken(( sal_uInt16 )( i - 1 ), '\\' )))
186 bBreak = sal_True;
187 else
188 pActDir = pActDir->pParent;
189 }
190 bSubs = bBreak;
191 nIndex++;
192 }
193
194 if ( !bSubs )
195 {
196 sSearch = rDirectoryPath;
197 }
198 else
199 sSearch = rDirectoryPath.GetToken( 0, PATH_SEPARATOR );
200
201 SourceDirectory *pSubDirectory = NULL;
202
203 if ( pSubDirectories )
204 pSubDirectory = pSubDirectories->Search( sSearch );
205
206 if ( !pSubDirectory )
207 pSubDirectory = new SourceDirectory(
208 sSearch, nOperatingSystem, this );
209
210 pSubDirectory->nOSType |= nOperatingSystem;
211
212 if ( sSearch.Len() == rDirectoryPath.Len())
213 return pSubDirectory;
214
215 ByteString sPath = rDirectoryPath.Copy( sSearch.Len() + 1 );
216
217 return pSubDirectory->GetSubDirectory( sPath, nOperatingSystem );
218 }
219
220 /*****************************************************************************/
GetDirectory(const ByteString & rDirectoryName,sal_uInt16 nOperatingSystem)221 SourceDirectory *SourceDirectory::GetDirectory(
222 const ByteString &rDirectoryName, sal_uInt16 nOperatingSystem )
223 /*****************************************************************************/
224 {
225 ByteString sDirectoryName( rDirectoryName );
226 #ifdef UNX
227 sDirectoryName.SearchAndReplaceAll( "\\", "/" );
228 #endif
229
230 SourceDirectory *pRoot = GetRootDirectory();
231
232 if ( sDirectoryName.Search( *pRoot ) != 0 )
233 return NULL;
234
235 if ( sDirectoryName.Len() == pRoot->Len())
236 return pRoot;
237
238 if ( sDirectoryName.GetChar( pRoot->Len()) == PATH_SEPARATOR ) {
239 ByteString sSub = sDirectoryName.Copy( pRoot->Len() + 1 );
240 return pRoot->GetSubDirectory( sSub, nOperatingSystem );
241 }
242
243 return NULL;
244 }
245
246 /*****************************************************************************/
Insert(const ByteString & rDirectoryName,sal_uInt16 nOperatingSystem)247 SourceDirectory *SourceDirectory::Insert( const ByteString &rDirectoryName,
248 sal_uInt16 nOperatingSystem )
249 /*****************************************************************************/
250 {
251 SourceDirectory *pSubDirectory = NULL;
252 if ( pSubDirectories )
253 pSubDirectory = pSubDirectories->Search( rDirectoryName );
254
255 if ( !pSubDirectory )
256 pSubDirectory = new SourceDirectory(
257 rDirectoryName, nOperatingSystem, this );
258
259 return pSubDirectory;
260 }
261
262 /*****************************************************************************/
ResolvesDependency(CodedDependency * pCodedDependency)263 Dependency *SourceDirectory::ResolvesDependency(
264 CodedDependency *pCodedDependency )
265 /*****************************************************************************/
266 {
267 if ( !pCodedIdentifier )
268 return NULL;
269
270 sal_uIntPtr nPos = pCodedIdentifier->IsString( pCodedDependency );
271 if ( nPos != NOT_THERE ) {
272 CodedDependency *pIdentifier =
273 ( CodedDependency * ) pCodedIdentifier->GetObject( nPos );
274 sal_uInt16 nResult =
275 pIdentifier->GetOperatingSystem() &
276 pCodedDependency->GetOperatingSystem();
277 Dependency *pReturn = new Dependency( *this, nResult );
278 nResult ^= pCodedDependency->GetOperatingSystem();
279 pCodedDependency->SetOperatingSystem( nResult );
280 return pReturn;
281 }
282 return NULL;
283 }
284
285
286 /*****************************************************************************/
ResolveDependencies()287 void SourceDirectory::ResolveDependencies()
288 /*****************************************************************************/
289 {
290 if ( !pSubDirectories )
291 return;
292
293 for ( sal_uIntPtr i = 0; i < pSubDirectories->Count(); i++ ) {
294 SourceDirectory *pActDirectory =
295 ( SourceDirectory * ) pSubDirectories->GetObject( i );
296 if ( pActDirectory->pSubDirectories )
297 pActDirectory->ResolveDependencies();
298
299 if ( pActDirectory->pCodedDependencies ) {
300 while ( pActDirectory->pCodedDependencies->Count())
301 {
302 CodedDependency *pCodedDependency = ( CodedDependency * )
303 pActDirectory->pCodedDependencies->GetObject(( sal_uIntPtr ) 0 );
304
305 for (
306 sal_uIntPtr k = 0;
307 ( k < pSubDirectories->Count()) &&
308 ( pCodedDependency->GetOperatingSystem() != OS_NONE );
309 k++
310 ) {
311 Dependency *pDependency =
312 ((SourceDirectory *) pSubDirectories->GetObject( k ))->
313 ResolvesDependency( pCodedDependency );
314 if ( pDependency )
315 {
316 if ( !pActDirectory->pDependencies )
317 pActDirectory->pDependencies = new SByteStringList();
318 pActDirectory->pDependencies->PutString( pDependency );
319 }
320 }
321 if ( pCodedDependency->GetOperatingSystem()) {
322 if ( !pCodedDependencies )
323 pCodedDependencies = new SByteStringList();
324 pCodedDependencies->PutString( pCodedDependency );
325 }
326 else
327 delete pCodedDependency;
328 pActDirectory->pCodedDependencies->Remove(( sal_uIntPtr ) 0 );
329 }
330 }
331 }
332 }
333
334 /*****************************************************************************/
GetTarget()335 ByteString SourceDirectory::GetTarget()
336 /*****************************************************************************/
337 {
338 ByteString sReturn;
339
340 if ( !pDependencies )
341 return sReturn;
342
343 sal_uIntPtr k = 0;
344 while ( k < pDependencies->Count()) {
345 if ( *this == *pDependencies->GetObject( k ))
346 delete pDependencies->Remove( k );
347 else
348 k++;
349 }
350
351 if ( !pDependencies->Count()) {
352 delete pDependencies;
353 pDependencies = NULL;
354 return sReturn;
355 }
356
357 sal_Bool bDependsOnPlatform = sal_False;
358 for ( sal_uIntPtr i = 0; i < pDependencies->Count(); i++ )
359 if ((( Dependency * ) pDependencies->GetObject( i ))->
360 GetOperatingSystem() != OS_ALL )
361 bDependsOnPlatform = sal_True;
362
363 ByteString sTarget( *this );
364 sTarget.SearchAndReplaceAll( "\\", "$/" );
365 if ( !bDependsOnPlatform ) {
366 sReturn = sTarget;
367 sReturn += " :";
368 for ( sal_uIntPtr i = 0; i < pDependencies->Count(); i++ ) {
369 ByteString sDependency( *pDependencies->GetObject( i ));
370 sDependency.SearchAndReplaceAll( "\\", "$/" );
371 sReturn += " ";
372 sReturn += sDependency;
373 }
374 }
375 else {
376 ByteString sUNX( ".IF \"$(GUI)\" == \"UNX\"\n" );
377 sUNX += sTarget;
378 sUNX += " :";
379 sal_Bool bUNX = sal_False;
380
381 ByteString sWNT( ".IF \"$(GUI)\" == \"WNT\"\n" );
382 sWNT += sTarget;
383 sWNT += " :";
384 sal_Bool bWNT = sal_False;
385
386 ByteString sOS2( ".IF \"$(GUI)\" == \"OS2\"\n" );
387 sOS2 += sTarget;
388 sOS2 += " :";
389 sal_Bool bOS2 = sal_False;
390
391 for ( sal_uIntPtr i = 0; i < pDependencies->Count(); i++ ) {
392 Dependency *pDependency =
393 ( Dependency * ) pDependencies->GetObject( i );
394 ByteString sDependency( *pDependency );
395 sDependency.SearchAndReplaceAll( "\\", "$/" );
396
397 if ( pDependency->GetOperatingSystem() & OS_UNX ) {
398 sUNX += " ";
399 sUNX += sDependency;
400 bUNX = sal_True;
401 }
402 if ( pDependency->GetOperatingSystem() & OS_WIN32 ) {
403 sWNT += " ";
404 sWNT += sDependency;
405 bWNT = sal_True;
406 }
407 if ( pDependency->GetOperatingSystem() & OS_OS2 ) {
408 sOS2 += " ";
409 sOS2 += sDependency;
410 bOS2 = sal_True;
411 }
412 }
413
414 if ( bUNX ) {
415 sReturn += sUNX;
416 sReturn += "\n.ENDIF\n";
417 }
418 if ( bWNT ) {
419 sReturn += sWNT;
420 sReturn += "\n.ENDIF\n";
421 }
422 if ( bOS2 ) {
423 sReturn += sOS2;
424 sReturn += "\n.ENDIF\n";
425 }
426 }
427 sReturn.EraseTrailingChars( '\n' );
428 return sReturn;
429 }
430
431 /*****************************************************************************/
GetSubDirsTarget()432 ByteString SourceDirectory::GetSubDirsTarget()
433 /*****************************************************************************/
434 {
435 ByteString sReturn;
436
437 if ( pSubDirectories ) {
438 sal_Bool bDependsOnPlatform = sal_False;
439 for ( sal_uIntPtr i = 0; i < pSubDirectories->Count(); i++ )
440 if ((( SourceDirectory * ) pSubDirectories->GetObject( i ))->
441 GetOperatingSystems() != OS_ALL )
442 bDependsOnPlatform = sal_True;
443
444 if ( !bDependsOnPlatform ) {
445 sReturn = "RC_SUBDIRS = ";
446
447 for ( sal_uIntPtr i = 0; i < pSubDirectories->Count(); i++ ) {
448 ByteString sSubDirectory( *pSubDirectories->GetObject( i ));
449 sSubDirectory.SearchAndReplaceAll( "\\", "$/" );
450 sReturn += " \\\n\t";
451 sReturn += sSubDirectory;
452 }
453 sReturn += "\n";
454 }
455 else {
456 ByteString sUNX( ".IF \"$(GUI)\" == \"UNX\"\n" );
457 sUNX += "RC_SUBDIRS = ";
458 sal_Bool bUNX = sal_False;
459
460 ByteString sWNT( ".IF \"$(GUI)\" == \"WNT\"\n" );
461 sWNT += "RC_SUBDIRS = ";
462 sal_Bool bWNT = sal_False;
463
464 ByteString sOS2( ".IF \"$(GUI)\" == \"OS2\"\n" );
465 sOS2 += "RC_SUBDIRS = ";
466 sal_Bool bOS2 = sal_False;
467
468 for ( sal_uIntPtr i = 0; i < pSubDirectories->Count(); i++ ) {
469 SourceDirectory *pDirectory =
470 ( SourceDirectory * ) pSubDirectories->GetObject( i );
471 ByteString sDirectory( *pDirectory );
472 sDirectory.SearchAndReplaceAll( "\\", "$/" );
473
474 if ( pDirectory->GetOperatingSystems() & OS_UNX ) {
475 sUNX += " \\\n\t";
476 sUNX += sDirectory;
477 bUNX = sal_True;
478 }
479 if ( pDirectory->GetOperatingSystems() & OS_WIN32 ) {
480 sWNT += " \\\n\t";
481 sWNT += sDirectory;
482 bWNT = sal_True;
483 }
484 if ( pDirectory->GetOperatingSystems() & OS_OS2 ) {
485 sOS2 += " \\\n\t";
486 sOS2 += sDirectory;
487 bOS2 = sal_True;
488 }
489 }
490 if ( bUNX ) {
491 sReturn += sUNX;
492 sReturn += "\n.ENDIF\n";
493 }
494 if ( bWNT ) {
495 sReturn += sWNT;
496 sReturn += "\n.ENDIF\n";
497 }
498 if ( bOS2 ) {
499 sReturn += sOS2;
500 sReturn += "\n.ENDIF\n";
501 }
502 }
503 }
504 return sReturn;
505 }
506
507 /*****************************************************************************/
GetOSType(const ByteString & sDependExt)508 sal_uInt16 SourceDirectory::GetOSType( const ByteString &sDependExt )
509 /*****************************************************************************/
510 {
511 sal_uInt16 nOSType = 0;
512 if ( sDependExt == "" )
513 nOSType |= OS_ALL;
514 else if ( sDependExt == "N" || sDependExt == "W" )
515 nOSType |= OS_WIN32;
516 else if ( sDependExt == "U" )
517 nOSType |= OS_UNX;
518 else if ( sDependExt == "P" )
519 nOSType |= OS_OS2;
520 return nOSType;
521 }
522
523 /*****************************************************************************/
CreateRootDirectory(const ByteString & rRoot,const ByteString & rVersion,sal_Bool bAll)524 SourceDirectory *SourceDirectory::CreateRootDirectory(
525 const ByteString &rRoot, const ByteString &rVersion, sal_Bool bAll )
526 /*****************************************************************************/
527 {
528 IniManager aIniManager;
529 aIniManager.Update();
530
531 ByteString sDefLst( GetDefStandList());
532 ByteString sStandLst( aIniManager.ToLocal( sDefLst ));
533 String s = String( sStandLst, gsl_getSystemTextEncoding());
534 InformationParser aParser;
535 // fprintf( stderr,
536 // "Reading database %s ...\n", sStandLst.GetBuffer());
537 GenericInformationList *pVerList = aParser.Execute(
538 s );
539
540 /*
541 ByteString sPath( rVersion );
542 #ifndef UNX
543 sPath += ByteString( "/settings/solarlist" );
544 #else
545 sPath += ByteString( "/settings/unxsolarlist" );
546 #endif
547 ByteString sSolarList( _SOLARLIST );
548
549 GenericInformation *pInfo = pVerList->GetInfo( sPath, sal_True );
550 if ( pInfo ) {
551 ByteString aIniRoot( GetIniRoot() );
552 DirEntry aIniEntry( String( aIniRoot, RTL_TEXTENCODING_ASCII_US ));
553 aIniEntry += DirEntry( String( pInfo->GetValue(), RTL_TEXTENCODING_ASCII_US )).GetBase( PATH_SEPARATOR );
554 sSolarList = ByteString( aIniEntry.GetFull(), RTL_TEXTENCODING_ASCII_US );
555 }
556
557 sSolarList = aIniManager.ToLocal( sSolarList );
558 fprintf( stderr,
559 "Reading directory information %s ...\n", sSolarList.GetBuffer());
560 */
561
562 ByteString sVersion( rVersion );
563 Star aStar( pVerList, sVersion, sal_True, rRoot.GetBuffer());
564 // fprintf( stderr,
565 // "Creating virtual directory tree ...\n" );
566
567
568 SourceDirectory *pSourceRoot = new SourceDirectory( rRoot, OS_ALL );
569
570 for ( sal_uIntPtr i = 0; i < aStar.Count(); i++ ) {
571 Prj *pPrj = aStar.GetObject( i );
572
573 sal_Bool bBuildable = sal_True;
574 sal_uIntPtr nIndex = 0;
575
576 while ( bBuildable && ByteString( NoBuildProject[ nIndex ]) != "EndOf_NoBuildProject" ) {
577 bBuildable = ( ByteString( NoBuildProject[ nIndex ]) != pPrj->GetProjectName());
578 nIndex ++;
579 }
580
581 if ( bBuildable ) {
582 SourceDirectory *pProject = pSourceRoot->Insert( pPrj->GetProjectName(), OS_ALL );
583
584 SByteStringList *pPrjDependencies = pPrj->GetDependencies( sal_False );
585 if ( pPrjDependencies )
586 for ( sal_uIntPtr x = 0; x < pPrjDependencies->Count(); x++ )
587 pProject->AddCodedDependency( *pPrjDependencies->GetObject( x ), OS_ALL );
588
589 pProject->AddCodedIdentifier( pPrj->GetProjectName(), OS_ALL );
590
591 for ( sal_uIntPtr j = 0; j < pPrj->Count(); j++ ) {
592 CommandData *pData = pPrj->GetObject( j );
593 if ( bAll || ( pData->GetCommandType() == COMMAND_NMAKE )) {
594 ByteString sDirPath( rRoot );
595 sDirPath += ByteString( PATH_SEPARATOR );
596 sDirPath += pData->GetPath();
597 SourceDirectory *pDirectory =
598 pSourceRoot->InsertFull( sDirPath, pData->GetOSType());
599 SByteStringList *pDependencies = pData->GetDependencies();
600 if ( pDependencies ) {
601 for ( sal_uIntPtr k = 0; k < pDependencies->Count(); k++ ) {
602 ByteString sDependency(*pDependencies->GetObject( k ));
603 ByteString sDependExt(sDependency.GetToken( 1, '.' ));
604 sDependExt.ToUpperAscii();
605 pDirectory->AddCodedDependency(
606 sDependency.GetToken( 0, '.' ), GetOSType( sDependExt ));
607 }
608 }
609 ByteString sIdentifier = pData->GetLogFile();
610 ByteString sIdExt = sIdentifier.GetToken( 1, '.' );
611 sIdExt.ToUpperAscii();
612 pDirectory->AddCodedIdentifier( sIdentifier.GetToken( 0, '.' ), GetOSType( sIdExt ));
613 }
614 }
615 }
616 }
617 delete pVerList;
618 return pSourceRoot;
619 }
620
621 /*****************************************************************************/
RemoveDirectoryTreeAndAllDependencies()622 sal_Bool SourceDirectory::RemoveDirectoryTreeAndAllDependencies()
623 /*****************************************************************************/
624 {
625 if ( !pParent )
626 return sal_False;
627
628 SourceDirectoryList *pParentContent = pParent->pSubDirectories;
629 sal_uIntPtr i = 0;
630 while ( i < pParentContent->Count()) {
631 SourceDirectory *pCandidate =
632 ( SourceDirectory * )pParentContent->GetObject( i );
633 if ( pCandidate == this ) {
634 pParentContent->Remove( i );
635 }
636 else {
637 if ( pCandidate->pDependencies ) {
638 sal_uIntPtr nPos = pCandidate->pDependencies->IsString( this );
639 if ( nPos != NOT_THERE )
640 delete pCandidate->pDependencies->Remove( nPos );
641 }
642 i++;
643 }
644 }
645 delete this;
646 return sal_True;
647 }
648
649 /*****************************************************************************/
CreateRecursiveMakefile(sal_Bool bAllChilds)650 sal_Bool SourceDirectory::CreateRecursiveMakefile( sal_Bool bAllChilds )
651 /*****************************************************************************/
652 {
653 if ( !pSubDirectories )
654 return sal_True;
655
656 fprintf( stdout, "%s", GetFullPath().GetBuffer());
657
658 String aTmpStr( GetFullPath(), gsl_getSystemTextEncoding());
659 DirEntry aEntry( aTmpStr );
660 if ( !aEntry.Exists()) {
661 fprintf( stdout, " ... no directory!n" );
662 return sal_False;
663 }
664
665 sal_uIntPtr j = 0;
666 while( j < pSubDirectories->Count()) {
667 String sSubDirectory(
668 (( SourceDirectory * ) pSubDirectories->GetObject( j ))->
669 GetFullPath(),
670 gsl_getSystemTextEncoding()
671 );
672 DirEntry aSubDirectory( sSubDirectory );
673 if ( !aSubDirectory.Exists())
674 (( SourceDirectory * ) pSubDirectories->GetObject( j ))->
675 RemoveDirectoryTreeAndAllDependencies();
676 else
677 j++;
678 }
679
680 DirEntry aRCFile( String( "makefile.rc", gsl_getSystemTextEncoding()));
681 DirEntry aRCEntry( aEntry );
682 aRCEntry += aRCFile;
683
684 DirEntry aMKFile( String( "makefile.mk", gsl_getSystemTextEncoding()));
685 DirEntry aMKEntry( aEntry );
686 aMKEntry += aMKFile;
687
688 sal_Bool bMakefileMk = sal_False;
689 if ( aMKEntry.Exists()) {
690 if ( nDepth == 1 && *this == ByteString( "api" ))
691 fprintf( stdout, " ... makefile.mk exists, ignoring (hack: prj == api)!" );
692 else {
693 fprintf( stdout, " ... makefile.mk exists, including!" );
694 bMakefileMk = sal_True;
695 }
696 }
697
698 SvFileStream aMakefile( aRCEntry.GetFull(), STREAM_STD_WRITE | STREAM_TRUNC );
699 if ( !aMakefile.IsOpen()) {
700 fprintf( stdout, " ... failed!\n" );
701 return sal_False;
702 }
703
704 ByteString sHeader(
705 "#**************************************************************\n"
706 "# \n"
707 "# Licensed to the Apache Software Foundation (ASF) under one\n"
708 "# or more contributor license agreements. See the NOTICE file\n"
709 "# distributed with this work for additional information\n"
710 "# regarding copyright ownership. The ASF licenses this file\n"
711 "# to you under the Apache License, Version 2.0 (the\n"
712 "# "License"); you may not use this file except in compliance\n"
713 "# with the License. You may obtain a copy of the License at\n"
714 "# \n"
715 "# http://www.apache.org/licenses/LICENSE-2.0\n"
716 "# \n"
717 "# Unless required by applicable law or agreed to in writing,\n"
718 "# software distributed under the License is distributed on an\n"
719 "# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n"
720 "# KIND, either express or implied. See the License for the\n"
721 "# specific language governing permissions and limitations\n"
722 "# under the License.\n"
723 "# \n"
724 "#**************************************************************\n"
725 "\n"
726 );
727 if ( !bMakefileMk ) {
728 if ( nDepth == 0 ) {
729 sHeader += ByteString(
730 "\n"
731 "# \n"
732 "# mark this makefile as a recursive one\n"
733 "# \n"
734 "\n"
735 "MAKEFILERC=yes\n"
736 "\n"
737 "# \n"
738 "# implementation of cvs checkout\n"
739 "# \n"
740 "\n"
741 ".IF \"$(checkout)\"==\"\"\n"
742 "all_target: ALLTAR\n"
743 ".ELSE\t# \"$(checkout)\"==\"\"\n"
744 ".IF \"$(checkout)\"==\"true\"\n"
745 "% : $(NULL)\n"
746 "\t_cvs co $@\n"
747 ".ELSE\t# \"$(checkout)\"==\"true\"\n"
748 "% : $(NULL)\n"
749 "\t_cvs co -r$(checkout) $@\n"
750 ".ENDIF\t# \"$(checkout)\"==\"true\"\n"
751 "all_subdirs : $(RC_SUBDIRS)\n"
752 ".ENDIF\t# \"$(checkout)\"==\"\"\n"
753 );
754 }
755 else {
756 sHeader += ByteString(
757 "\n"
758 "# \n"
759 "# mark this makefile as a recursive one\n"
760 "# \n"
761 "\n"
762 "MAKEFILERC=yes\n"
763 );
764 if ( nDepth == 1 )
765 sHeader += ByteString(
766 ".IF \"$(build_deliver)\"==\"true\"\n"
767 "all_target:\t\t\\\n"
768 "\tTG_DELIVER\t\\\n"
769 "\tALLTAR\n"
770 ".ELSE # \"$(build_deliver)\"==\"true\"\n"
771 "all_target: ALLTAR\n"
772 ".ENDIF # \"$(build_deliver)\"==\"true\"\n"
773 );
774 else
775 sHeader += ByteString(
776 "all_target: ALLTAR\n"
777 );
778 }
779 }
780 else {
781 if ( nDepth == 1 )
782 sHeader += ByteString(
783 ".IF \"$(build_deliver)\"==\"true\"\n"
784 "all_target:\t\t\\\n"
785 "\tTG_DELIVER\t\\\n"
786 "\tALLTAR\n"
787 ".ELSE # \"$(build_deliver)\"==\"true\"\n"
788 "all_target: ALLTAR\n"
789 ".ENDIF # \"$(build_deliver)\"==\"true\"\n"
790 );
791 }
792 sHeader += ByteString(
793 "\n"
794 "# \n"
795 "# macro RC_SUBDIRS handles iteration over\n"
796 "# all mandatory sub directories\n"
797 "# \n"
798 );
799
800 aMakefile.WriteLine( sHeader );
801 aMakefile.WriteLine( GetSubDirsTarget());
802
803 if ( nDepth == 0 ) {
804 ByteString sBootstrapTarget(
805 "# \n"
806 "# bootstrap target\n"
807 "# \n\n"
808 "bootstrap .PHONY :\n"
809 "\t@config_office/bootstrap\n\n"
810 );
811 aMakefile.WriteLine( sBootstrapTarget );
812 ByteString sConfigureTarget(
813 "# \n"
814 "# configure target\n"
815 "# \n\n"
816 "configure .PHONY SETDIR=config_office :\n"
817 "\t@configure\n"
818 );
819 aMakefile.WriteLine( sConfigureTarget );
820 }
821 else if ( nDepth == 1 ) {
822 ByteString sDeliverTarget(
823 "# \n"
824 "# deliver target to handle\n"
825 "# project dependencies\n"
826 "# \n\n"
827 "TG_DELIVER : $(RC_SUBDIRS)\n"
828 "\t$(DELIVER)\n"
829 );
830 aMakefile.WriteLine( sDeliverTarget );
831 }
832
833 if ( bMakefileMk ) {
834 ByteString sInclude(
835 "# \n"
836 "# local makefile\n"
837 "# \n"
838 "\n"
839 ".INCLUDE : makefile.mk\n"
840 );
841
842 if ( nDepth != 1 )
843 sInclude += ByteString(
844 "\n"
845 "all_rc_target: ALLTAR\n"
846 );
847
848 aMakefile.WriteLine( sInclude );
849 }
850
851 ByteString sComment(
852 "# \n"
853 "# single directory targets for\n"
854 "# dependency handling between directories\n"
855 "# \n"
856 );
857 aMakefile.WriteLine( sComment );
858
859 for ( sal_uIntPtr i = 0; i < pSubDirectories->Count(); i++ ) {
860 ByteString sTarget(
861 (( SourceDirectory * )pSubDirectories->GetObject( i ))->
862 GetTarget()
863 );
864 if ( sTarget.Len())
865 aMakefile.WriteLine( sTarget );
866 }
867
868 ByteString sFooter(
869 "\n"
870 );
871 if ( !bMakefileMk ) {
872 sFooter += ByteString(
873 "# \n"
874 "# central target makefile\n"
875 "# \n"
876 "\n"
877 );
878 if ( nDepth != 0 ) {
879 sFooter += ByteString(
880 ".INCLUDE : target.mk\n"
881 );
882 }
883 else {
884 sFooter += ByteString(
885 ".IF \"$(checkout)\"==\"\"\n"
886 ".INCLUDE : target.mk\n"
887 ".ENDIF\t#\"$(checkout)\"==\"\"\n"
888 );
889 }
890 }
891 sFooter += ByteString(
892 "\n"
893 "#*************************************************************************\n"
894 );
895 aMakefile.WriteLine( sFooter );
896
897 aMakefile.Close();
898
899 fprintf( stdout, "\n" );
900
901 sal_Bool bSuccess = sal_True;
902 if ( bAllChilds )
903 for ( sal_uIntPtr k = 0; k < pSubDirectories->Count(); k++ )
904 if ( !(( SourceDirectory * ) pSubDirectories->GetObject( k ))->
905 CreateRecursiveMakefile( sal_True ))
906 bSuccess = sal_False;
907
908 return bSuccess;
909 }
910
911 //
912 // class SourceDirectoryList
913 //
914
915 /*****************************************************************************/
~SourceDirectoryList()916 SourceDirectoryList::~SourceDirectoryList()
917 /*****************************************************************************/
918 {
919 for ( sal_uIntPtr i = 0; i < Count(); i++ )
920 delete GetObject( i );
921 }
922
923 /*****************************************************************************/
Search(const ByteString & rDirectoryName)924 SourceDirectory *SourceDirectoryList::Search(
925 const ByteString &rDirectoryName )
926 /*****************************************************************************/
927 {
928 sal_uIntPtr nPos = IsString( ( ByteString * ) (&rDirectoryName) );
929 if ( nPos != LIST_ENTRY_NOTFOUND )
930 return ( SourceDirectory * ) GetObject( nPos );
931
932 return NULL;
933 }
934
935
936