|
599
|
1 |
# Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies).
|
|
|
2 |
# All rights reserved.
|
|
|
3 |
# This component and the accompanying materials are made available
|
|
|
4 |
# under the terms of "Eclipse Public License v1.0"
|
|
|
5 |
# which accompanies this distribution, and is available
|
|
|
6 |
# at the URL "http://www.eclipse.org/legal/epl-v10.html".
|
|
|
7 |
#
|
|
|
8 |
# Initial Contributors:
|
|
|
9 |
# Nokia Corporation - initial contribution.
|
|
|
10 |
#
|
|
|
11 |
# Contributors:
|
|
|
12 |
#
|
|
|
13 |
# Description:
|
|
|
14 |
# Cl_gccxml;
|
|
|
15 |
#
|
|
|
16 |
#
|
|
|
17 |
|
|
|
18 |
package Cl_gccxml;
|
|
|
19 |
|
|
|
20 |
require Exporter;
|
|
|
21 |
@ISA=qw(Exporter);
|
|
|
22 |
@EXPORT=qw(
|
|
|
23 |
PMHelp_Mmp
|
|
|
24 |
PMStartBldList
|
|
|
25 |
PMBld
|
|
|
26 |
PMStartSrcList
|
|
|
27 |
PMStartSrc
|
|
|
28 |
PMSrcDepend
|
|
|
29 |
PMSrcBldDepend
|
|
|
30 |
PMEndSrcBld
|
|
|
31 |
PMEndSrc
|
|
|
32 |
PMEndSrcList
|
|
|
33 |
PMBitMapBld
|
|
|
34 |
PMResrcBld
|
|
|
35 |
|
|
|
36 |
);
|
|
|
37 |
use cl_generic;
|
|
|
38 |
use Genutl;
|
|
|
39 |
use File::Path;
|
|
|
40 |
use Cwd;
|
|
|
41 |
use Pathutl;
|
|
|
42 |
|
|
|
43 |
sub PMHelp_Mmp {
|
|
|
44 |
print "// No additional keywords for this platform\n";
|
|
|
45 |
}
|
|
|
46 |
|
|
|
47 |
# takes an 'expression' to evaluate with $_ bound to each of the
|
|
|
48 |
# remaining args
|
|
|
49 |
sub PrintList
|
|
|
50 |
{
|
|
|
51 |
my $expr = shift @_;
|
|
|
52 |
foreach (@_) {
|
|
|
53 |
my $str = eval($expr);
|
|
|
54 |
&main::Output($str);
|
|
|
55 |
}
|
|
|
56 |
}
|
|
|
57 |
|
|
|
58 |
my $epocroot = $ENV{EPOCROOT};
|
|
|
59 |
$epocroot=~ s-\\$--; # chop trailing \\
|
|
|
60 |
my $Makecmd;
|
|
|
61 |
sub PMStartBldList($) {
|
|
|
62 |
($Makecmd) = @_;
|
|
|
63 |
my $BasicTrgType=&main::BasicTrgType;
|
|
|
64 |
my @BldList=&main::BldList;
|
|
|
65 |
my @ChopSysIncPaths=&main::Path_Chop(&main::SysIncPaths);
|
|
|
66 |
my @ChopUserIncPaths=&main::Path_Chop(&main::UserIncPaths);
|
|
|
67 |
my $RelPath="$epocroot\\EPOC32\\RELEASE";
|
|
|
68 |
my @MacroList=&main::MacroList();
|
|
|
69 |
my $VariantFile=&main::VariantFile();
|
|
|
70 |
my $Trg=&main::Trg;
|
|
|
71 |
my $DPath = &main::Path_RltToWork($epocroot);
|
|
|
72 |
my $DefFile = &main::DefFile;
|
|
|
73 |
my $EABIDefFile = &main::EABIDef;
|
|
|
74 |
my $ExtCompileOption = &main::CompilerOption("GCCXML");
|
|
|
75 |
|
|
|
76 |
&Generic_Header(0,$Makecmd); # define standard things using absolute paths
|
|
|
77 |
|
|
|
78 |
$DefFile="" if(!(-e $DefFile));
|
|
|
79 |
&main::Output(
|
|
|
80 |
"GXPTRGUDEB = $RelPath\\GCCXML\\UDEB\n",
|
|
|
81 |
"GXPTRGUREL = $RelPath\\GCCXML\\UREL\n\n",
|
|
|
82 |
"DEFFILE = $DefFile\n\n",
|
|
|
83 |
"EABIDEFFILE = $EABIDefFile\n\n"
|
|
|
84 |
);
|
|
|
85 |
|
|
|
86 |
&main::Output(
|
|
|
87 |
"INCDIR ="
|
|
|
88 |
);
|
|
|
89 |
|
|
|
90 |
foreach (@ChopUserIncPaths) {
|
|
|
91 |
&main::Output(
|
|
|
92 |
" -I \"$_\""
|
|
|
93 |
);
|
|
|
94 |
}
|
|
|
95 |
|
|
|
96 |
&main::Output(
|
|
|
97 |
" -I- "
|
|
|
98 |
);
|
|
|
99 |
|
|
|
100 |
foreach (@ChopSysIncPaths) {
|
|
|
101 |
&main::Output(
|
|
|
102 |
" -I \"$_\""
|
|
|
103 |
);
|
|
|
104 |
}
|
|
|
105 |
if($VariantFile){
|
|
|
106 |
&main::Output("\\\n -include \"$VariantFile\"");
|
|
|
107 |
}
|
|
|
108 |
&main::Output(
|
|
|
109 |
"\n",
|
|
|
110 |
"\n"
|
|
|
111 |
);
|
|
|
112 |
|
|
|
113 |
&main::Output(
|
|
|
114 |
"GCCFLAGS= -nostdinc -Wall -Wno-ctor-dtor-privacy -Wno-unknown-pragmas -UWIN32 -fshort-wchar -quiet -w $ExtCompileOption\n", # -fsyntax-only
|
|
|
115 |
"\n"
|
|
|
116 |
);
|
|
|
117 |
|
|
|
118 |
&main::Output(
|
|
|
119 |
"GCCDEFS = -D __EABI__ -D __SUPPORT_CPP_EXCEPTIONS__"
|
|
|
120 |
);
|
|
|
121 |
foreach(@MacroList) {
|
|
|
122 |
&main::Output(
|
|
|
123 |
" -D$_"
|
|
|
124 |
);
|
|
|
125 |
}
|
|
|
126 |
&main::Output(
|
|
|
127 |
" \$(USERDEFS)\n",
|
|
|
128 |
"\n"
|
|
|
129 |
);
|
|
|
130 |
|
|
|
131 |
foreach (@BldList) {
|
|
|
132 |
&main::Output(
|
|
|
133 |
"GCC$_ = gccxml_cc1plus -bi"
|
|
|
134 |
);
|
|
|
135 |
if (/REL$/o) {
|
|
|
136 |
&main::Output(
|
|
|
137 |
' -fomit-frame-pointer '
|
|
|
138 |
);
|
|
|
139 |
}
|
|
|
140 |
elsif (/DEB$/o) {
|
|
|
141 |
&main::Output(
|
|
|
142 |
' -g'
|
|
|
143 |
);
|
|
|
144 |
}
|
|
|
145 |
&main::Output(
|
|
|
146 |
' $(GCCFLAGS)'
|
|
|
147 |
);
|
|
|
148 |
foreach (&main::MacroList($_)) {
|
|
|
149 |
&main::Output(
|
|
|
150 |
" -D$_"
|
|
|
151 |
);
|
|
|
152 |
}
|
|
|
153 |
|
|
|
154 |
&main::Output(
|
|
|
155 |
" \$(GCCDEFS)\n"
|
|
|
156 |
);
|
|
|
157 |
}
|
|
|
158 |
&main::Output(
|
|
|
159 |
"\n",
|
|
|
160 |
"\n"
|
|
|
161 |
);
|
|
|
162 |
|
|
|
163 |
&main::Output(
|
|
|
164 |
"LIBRARY:\n",
|
|
|
165 |
"\t\@echo Nothing to do\n"
|
|
|
166 |
);
|
|
|
167 |
|
|
|
168 |
# Resource building is done entirely via cl_generic.pm
|
|
|
169 |
PrintList("\"\nRESOURCE\$_ : MAKEWORK\$_\"", @BldList)
|
|
|
170 |
&main::Output(
|
|
|
171 |
"\n",
|
|
|
172 |
"\n",
|
|
|
173 |
);
|
|
|
174 |
|
|
|
175 |
foreach (@BldList) {
|
|
|
176 |
&main::Output(
|
|
|
177 |
"$_ :"
|
|
|
178 |
);
|
|
|
179 |
|
|
|
180 |
if ($BasicTrgType !~ /IMPLIB/io) {
|
|
|
181 |
my $TrgBase = &main::Path_Split('base',$Trg);
|
|
|
182 |
&main::Output (
|
|
|
183 |
" \\\n\t",
|
|
|
184 |
&Generic_Quote("\$(GXPTRG$_)\\$TrgBase$BasicTrgType.gxp")
|
|
|
185 |
);
|
|
|
186 |
}
|
|
|
187 |
&main::Output(
|
|
|
188 |
"\n",
|
|
|
189 |
"\n"
|
|
|
190 |
);
|
|
|
191 |
}
|
|
|
192 |
}
|
|
|
193 |
|
|
|
194 |
# DumpToFile
|
|
|
195 |
sub DumpMMPToFile
|
|
|
196 |
{
|
|
|
197 |
my $rfiFileList;
|
|
|
198 |
my @rfiFiles;
|
|
|
199 |
if(scalar @_) # if an argument has been passed then it is a reference to the list of .RFI files.
|
|
|
200 |
{
|
|
|
201 |
($rfiFileList) = @_;
|
|
|
202 |
@rfiFiles = @$rfiFileList;
|
|
|
203 |
}
|
|
|
204 |
|
|
|
205 |
my $BldPath=&main::BldPath;
|
|
|
206 |
my $Target = &main::Trg;
|
|
|
207 |
my $TargetBase = &main::Path_Split('Base', $Target);
|
|
|
208 |
my $Gxpurel="$epocroot\\epoc32\\release\\gccxml\\urel";
|
|
|
209 |
my $Gxpudeb="$epocroot\\epoc32\\release\\gccxml\\udeb";
|
|
|
210 |
unless (-d $BldPath) {
|
|
|
211 |
mkpath([$BldPath]);
|
|
|
212 |
}
|
|
|
213 |
unless (-d $Gxpurel) {
|
|
|
214 |
mkpath([$Gxpurel]);
|
|
|
215 |
}
|
|
|
216 |
unless (-d $Gxpudeb) {
|
|
|
217 |
mkpath([$Gxpudeb]);
|
|
|
218 |
}
|
|
|
219 |
$BldPath = (&main::Path_StepDirs($BldPath))[-2];
|
|
|
220 |
use File::Basename;
|
|
|
221 |
my $FileName = basename(&main::MmpFile());
|
|
|
222 |
$FileName = $BldPath.$FileName.".xml";
|
|
|
223 |
open FILE,"> $FileName" or die "Cannot open mmp info dump file $FileName: $!";
|
|
|
224 |
print FILE "<?xml version=\"1.0\"?>\n<mmpInfo>\n";
|
|
|
225 |
|
|
|
226 |
my $Path = &main::RelPath();
|
|
|
227 |
my $MmpFile = &main::MmpFile();
|
|
|
228 |
my $TrgType = &main::TrgType();
|
|
|
229 |
my $TrgPath = &main::TrgPath();
|
|
|
230 |
print FILE "\t<mmp path=\"$MmpFile\"/>\n";
|
|
|
231 |
print FILE "\t<target name=\"$Target\" type=\"$TrgType\" ";
|
|
|
232 |
|
|
|
233 |
if(not $TrgPath eq '')
|
|
|
234 |
{
|
|
|
235 |
print FILE "path=\"$TrgPath\"";
|
|
|
236 |
}
|
|
|
237 |
print FILE "/>\n";
|
|
|
238 |
# insert current working directory
|
|
|
239 |
my $WorkPath = &main::Path_WorkPath();
|
|
|
240 |
print FILE "\t<cwd path=\"$WorkPath\"/>\n";
|
|
|
241 |
|
|
|
242 |
my $ABI = &main::ABI;
|
|
|
243 |
print FILE "\t<abi type=\"$ABI\"/>\n";
|
|
|
244 |
my $LinkAs = &main::LinkAs;
|
|
|
245 |
print FILE "\t<linkAs name=\"$LinkAs\"/>\n";
|
|
|
246 |
my $LinkAsBase = &main::LinkAsBase;
|
|
|
247 |
print FILE "\t<linkAsBase name=\"$LinkAsBase\"/>\n";
|
|
|
248 |
|
|
|
249 |
# Uids
|
|
|
250 |
my @UidList=&main::UidList;
|
|
|
251 |
my $count = 0;
|
|
|
252 |
print FILE "\t<uids";
|
|
|
253 |
foreach my $uid(@UidList)
|
|
|
254 |
{
|
|
|
255 |
print FILE " u$count=\"$uid\"" ;
|
|
|
256 |
$count++;
|
|
|
257 |
}
|
|
|
258 |
print FILE "/>\n";
|
|
|
259 |
|
|
|
260 |
# Versioning
|
|
|
261 |
my %Version = &main::Version;
|
|
|
262 |
print FILE "\t<version";
|
|
|
263 |
foreach my $var (sort keys %Version)
|
|
|
264 |
{
|
|
|
265 |
print FILE " $var=\"$Version{$var}\"";
|
|
|
266 |
}
|
|
|
267 |
print FILE "/>\n";
|
|
|
268 |
|
|
|
269 |
# Capabilities
|
|
|
270 |
my $Capability = &main::Capability;
|
|
|
271 |
print FILE "\t<capability id=\"$Capability\"/>\n";
|
|
|
272 |
|
|
|
273 |
# DefFile
|
|
|
274 |
my $DefFile = &main::DefFile;
|
|
|
275 |
$DefFile="" if(!(-e $DefFile));
|
|
|
276 |
print FILE "\t<defFile path=\"$DefFile\" type=\"GCC\"/>\n";
|
|
|
277 |
|
|
|
278 |
# EABIDefFile
|
|
|
279 |
my $EABIDefFile = &main::EABIDef;
|
|
|
280 |
print FILE "\t<defFile path=\"$EABIDefFile\" type=\"EABI\"/>\n";
|
|
|
281 |
|
|
|
282 |
# Handle All types of libraries
|
|
|
283 |
my $FirstLib = &main::FirstLib;
|
|
|
284 |
my @LibList = &main::LibList;
|
|
|
285 |
my @ASSPLibList = &main::ASSPLibList;
|
|
|
286 |
my @StatLibList = &main::StatLibList;;
|
|
|
287 |
print FILE "\t<libs>\n";
|
|
|
288 |
|
|
|
289 |
#first
|
|
|
290 |
print FILE "\t\t<lib name=\"$FirstLib\" type=\"First\"/>\n";
|
|
|
291 |
|
|
|
292 |
# normal
|
|
|
293 |
foreach my $lib (@LibList)
|
|
|
294 |
{
|
|
|
295 |
print FILE "\t\t<lib name=\"$lib\"/>\n";
|
|
|
296 |
}
|
|
|
297 |
# ASSP Specific
|
|
|
298 |
foreach my $lib (@ASSPLibList)
|
|
|
299 |
{
|
|
|
300 |
print FILE "\t\t<lib name=\"$lib\" type=\"ASSP\"/>\n";
|
|
|
301 |
}
|
|
|
302 |
|
|
|
303 |
# Static Libraries
|
|
|
304 |
foreach my $lib (@StatLibList)
|
|
|
305 |
{
|
|
|
306 |
print FILE "\t\t<lib name=\"$lib\" type=\"Static\"/>\n";
|
|
|
307 |
}
|
|
|
308 |
print FILE "\t</libs>\n";
|
|
|
309 |
|
|
|
310 |
# Resources
|
|
|
311 |
print FILE "\t<resources>\n";
|
|
|
312 |
my $rfiFile;
|
|
|
313 |
foreach $rfiFile (@rfiFiles)
|
|
|
314 |
{
|
|
|
315 |
print FILE "\t\t<resource name=\"$rfiFile\"/>\n";
|
|
|
316 |
}
|
|
|
317 |
print FILE "\t</resources>\n";
|
|
|
318 |
|
|
|
319 |
close FILE;
|
|
|
320 |
}
|
|
|
321 |
|
|
|
322 |
sub PMBld {
|
|
|
323 |
my @ASSPLibList=&main::ASSPLibList;
|
|
|
324 |
my @SrcList=&main::SrcList;
|
|
|
325 |
my $BaseTrg=&main::BaseTrg;
|
|
|
326 |
my $Bld=&main::Bld;
|
|
|
327 |
my $ChopBldPath=&main::Path_Chop(&main::BldPath);
|
|
|
328 |
my $EPOCIncPath=&main::EPOCIncPath;
|
|
|
329 |
my $BasicTrgType=&main::BasicTrgType;
|
|
|
330 |
my $ChopRelPath=&main::Path_Chop(&main::RelPath);
|
|
|
331 |
my $RelPath=&main::RelPath;
|
|
|
332 |
my $Trg=&main::Trg;
|
|
|
333 |
my $TrgType=&main::TrgType;
|
|
|
334 |
my @UidList=&main::UidList;
|
|
|
335 |
# DefFile
|
|
|
336 |
my $DefFile = &main::DefFile;
|
|
|
337 |
# EABIDefFile
|
|
|
338 |
my $EABIDefFile = &main::EABIDef;
|
|
|
339 |
|
|
|
340 |
my $rfiList = GatherResourceInformation();
|
|
|
341 |
my @RfiFiles = @$rfiList;
|
|
|
342 |
|
|
|
343 |
|
|
|
344 |
|
|
|
345 |
DumpMMPToFile(\@RfiFiles);
|
|
|
346 |
|
|
|
347 |
# REAL TARGETS
|
|
|
348 |
#-------------
|
|
|
349 |
&main::Output(
|
|
|
350 |
"# REAL TARGET - BUILD VARIANT $Bld\n",
|
|
|
351 |
"\n"
|
|
|
352 |
);
|
|
|
353 |
|
|
|
354 |
&main::Output(
|
|
|
355 |
"WHAT$Bld : WHATGENERIC\n",
|
|
|
356 |
"\n",
|
|
|
357 |
"CLEAN$Bld : CLEANBUILD$Bld CLEANRELEASE$Bld\n",
|
|
|
358 |
"\n",
|
|
|
359 |
"CLEANBUILD$Bld : \n",
|
|
|
360 |
"\t\@perl -S ermdir.pl \"\$(EPOCBLD$Bld)\"\n",
|
|
|
361 |
"\n",
|
|
|
362 |
"CLEANRELEASE$Bld : CLEANGENERIC\n",
|
|
|
363 |
"\n"
|
|
|
364 |
);
|
|
|
365 |
my @releaseables;
|
|
|
366 |
&Generic_WhatCleanTargets($Bld, "WHAT$Bld", "CLEANRELEASE$Bld", @releaseables);
|
|
|
367 |
&Generic_MakeWorkDir("MAKEWORK$Bld",$ChopBldPath);
|
|
|
368 |
&Generic_MakeWorkDir("MAKEWORK$Bld",$ChopRelPath);
|
|
|
369 |
&Generic_Releaseables;
|
|
|
370 |
|
|
|
371 |
&main::Output(
|
|
|
372 |
"\n",
|
|
|
373 |
"\n"
|
|
|
374 |
);
|
|
|
375 |
|
|
|
376 |
# XML Stuff
|
|
|
377 |
&main::Output(
|
|
|
378 |
&Generic_Quote("\$(GXPTRG$Bld)\\$BaseTrg$BasicTrgType.gxp"), " : ",
|
|
|
379 |
&Generic_Quote("\$(EPOCBLD$Bld)\\$BaseTrg$BasicTrgType.gxp"),
|
|
|
380 |
"\n\tcopy \"\$(EPOCBLD$Bld)\\$BaseTrg$BasicTrgType.gxp\" \"\$@\""
|
|
|
381 |
);
|
|
|
382 |
|
|
|
383 |
&main::Output(
|
|
|
384 |
"\n",
|
|
|
385 |
"\n"
|
|
|
386 |
);
|
|
|
387 |
|
|
|
388 |
# TARGET *.GXP
|
|
|
389 |
#------------
|
|
|
390 |
if (scalar @SrcList >150) {
|
|
|
391 |
# deal with very long lists by splitting them into 150 file pieces, which allows
|
|
|
392 |
# about 200 bytes per filename if the underlying max size is 32K
|
|
|
393 |
#
|
|
|
394 |
|
|
|
395 |
my $counter1=150; # i.e. trigger new variable immediately
|
|
|
396 |
my $counter2=0;
|
|
|
397 |
my @objvarlist=();
|
|
|
398 |
foreach (@SrcList) {
|
|
|
399 |
if ($counter1==150) {
|
|
|
400 |
$counter1=0;
|
|
|
401 |
$counter2++;
|
|
|
402 |
my $objvar = "OBJECTS$Bld$counter2";
|
|
|
403 |
push @objvarlist, " \$($objvar)";
|
|
|
404 |
&main::Output(
|
|
|
405 |
"\n",
|
|
|
406 |
"$objvar="
|
|
|
407 |
);
|
|
|
408 |
}
|
|
|
409 |
my $BaseSrc = &main::Path_Split('Base', $_);
|
|
|
410 |
my $Ext = &main::Path_Split('Ext', $_);
|
|
|
411 |
$BaseSrc.='_' if (lc($Ext) eq '.cia');
|
|
|
412 |
&main::Output(
|
|
|
413 |
" \\\n\t", &Generic_Quote("\$(EPOCBLD$Bld)\\$BaseSrc.xml")
|
|
|
414 |
);
|
|
|
415 |
$counter1++;
|
|
|
416 |
}
|
|
|
417 |
use File::Basename;
|
|
|
418 |
my $FileName = basename(&main::MmpFile()).".xml";
|
|
|
419 |
&main::Output(
|
|
|
420 |
" \\\n\t\$(EPOCBLD)\\$FileName",
|
|
|
421 |
"\n",
|
|
|
422 |
"\n",
|
|
|
423 |
&Generic_Quote("\$(EPOCBLD$Bld)\\$BaseTrg$BasicTrgType.gxp"), " : ", @objvarlist,"\n",
|
|
|
424 |
"\tif exist \"\$\@\" del \"\$\@\"\n"
|
|
|
425 |
);
|
|
|
426 |
foreach (@objvarlist) {
|
|
|
427 |
&main::Output(
|
|
|
428 |
"\tzip -j \$\@$_\n"
|
|
|
429 |
);
|
|
|
430 |
}
|
|
|
431 |
&main::Output(
|
|
|
432 |
"\tif exist \$(EABIDEFFILE) zip -j \$\@ \$(EABIDEFFILE)\n",
|
|
|
433 |
"\n\n"
|
|
|
434 |
);
|
|
|
435 |
} else {
|
|
|
436 |
# shorter lists remain unchanged
|
|
|
437 |
#
|
|
|
438 |
&main::Output(
|
|
|
439 |
"OBJECTS$Bld="
|
|
|
440 |
);
|
|
|
441 |
use File::Basename;
|
|
|
442 |
my $FileName = basename(&main::MmpFile()).".xml";
|
|
|
443 |
|
|
|
444 |
&main::Output("\$(EPOCBLD)\\$FileName");
|
|
|
445 |
foreach (@SrcList) {
|
|
|
446 |
my $BaseSource = &main::Path_Split('Base', $_);
|
|
|
447 |
my $Ext = &main::Path_Split('Ext', $_);
|
|
|
448 |
$BaseSource.='_' if (lc($Ext) eq '.cia');
|
|
|
449 |
&main::Output(
|
|
|
450 |
" \\\n\t", &Generic_Quote("\$(EPOCBLD$Bld)\\$BaseSource.xml")
|
|
|
451 |
);
|
|
|
452 |
}
|
|
|
453 |
|
|
|
454 |
&main::Output(
|
|
|
455 |
"\n",
|
|
|
456 |
"\n"
|
|
|
457 |
);
|
|
|
458 |
|
|
|
459 |
&main::Output("RESOURCEINFO$Bld=");
|
|
|
460 |
foreach (@RfiFiles)
|
|
|
461 |
{
|
|
|
462 |
&main::Output(" \\\n\t\$(EPOCBLD)\\$_");
|
|
|
463 |
}
|
|
|
464 |
&main::Output("\n\n");
|
|
|
465 |
|
|
|
466 |
&main::Output(
|
|
|
467 |
|
|
|
468 |
&Generic_Quote("\$(EPOCBLD$Bld)\\$BaseTrg$BasicTrgType.gxp"), " : \$(OBJECTS$Bld) \$(EABIDEFFILE) \$(RESOURCEINFO$Bld)\n",
|
|
|
469 |
|
|
|
470 |
"\tif exist \"\$\@\" del \"\$\@\"\n",
|
|
|
471 |
"\tzip -j \$\@ \$^ \$(EABIDEFFILE) \$(RESOURCEINFO$Bld)\n",
|
|
|
472 |
"\n\n"
|
|
|
473 |
);
|
|
|
474 |
}
|
|
|
475 |
}
|
|
|
476 |
|
|
|
477 |
|
|
|
478 |
sub PMStartSrcList {
|
|
|
479 |
|
|
|
480 |
&main::Output(
|
|
|
481 |
"# SOURCES\n",
|
|
|
482 |
"\n"
|
|
|
483 |
);
|
|
|
484 |
}
|
|
|
485 |
|
|
|
486 |
sub PMBitMapBld {
|
|
|
487 |
&Generic_BitMapBld;
|
|
|
488 |
}
|
|
|
489 |
|
|
|
490 |
sub PMResrcBld {
|
|
|
491 |
&Generic_ResrcBld;
|
|
|
492 |
}
|
|
|
493 |
|
|
|
494 |
sub PMStartSrc {
|
|
|
495 |
my $Src=&main::Src;
|
|
|
496 |
|
|
|
497 |
&main::Output(
|
|
|
498 |
"# Source $Src\n",
|
|
|
499 |
"\n"
|
|
|
500 |
);
|
|
|
501 |
}
|
|
|
502 |
|
|
|
503 |
sub PMSrcDepend {
|
|
|
504 |
my @BldList=&main::BldList;
|
|
|
505 |
my @DepList=&main::DepList;
|
|
|
506 |
my $BaseSrc=&main::BaseSrc;
|
|
|
507 |
my $ExtSrc=&main::ExtSrc;
|
|
|
508 |
my $cia = (lc($ExtSrc) eq '.cia') ? "_" : "";
|
|
|
509 |
|
|
|
510 |
return if (@DepList == 0);
|
|
|
511 |
|
|
|
512 |
foreach (@BldList) {
|
|
|
513 |
&main::Output(
|
|
|
514 |
&Generic_Quote("\$(EPOCBLD$_)\\$BaseSrc$cia.lis"), " ",
|
|
|
515 |
&Generic_Quote("\$(EPOCBLD$_)\\$BaseSrc$cia.xml"), " \\\n",
|
|
|
516 |
);
|
|
|
517 |
}
|
|
|
518 |
&main::Output(
|
|
|
519 |
":"
|
|
|
520 |
);
|
|
|
521 |
foreach (@DepList) {
|
|
|
522 |
&main::Output(
|
|
|
523 |
" \\\n\t", &Generic_Quote($_)
|
|
|
524 |
);
|
|
|
525 |
}
|
|
|
526 |
&main::Output(
|
|
|
527 |
"\n",
|
|
|
528 |
"\n"
|
|
|
529 |
);
|
|
|
530 |
}
|
|
|
531 |
|
|
|
532 |
sub PMSrcBldDepend {
|
|
|
533 |
my $Bld=&main::Bld;
|
|
|
534 |
my @DepList=&main::DepList;
|
|
|
535 |
my $BaseSrc=&main::BaseSrc;
|
|
|
536 |
my $ExtSrc=&main::ExtSrc;
|
|
|
537 |
my $cia = (lc($ExtSrc) eq '.cia') ? "_" : "";
|
|
|
538 |
|
|
|
539 |
return if (@DepList == 0);
|
|
|
540 |
|
|
|
541 |
&main::Output(
|
|
|
542 |
&Generic_Quote("\$(EPOCBLD$Bld)\\$BaseSrc$cia.lis"), " ",
|
|
|
543 |
&Generic_Quote("\$(EPOCBLD$Bld)\\$BaseSrc$cia.xml"), " :",
|
|
|
544 |
);
|
|
|
545 |
foreach (@DepList) {
|
|
|
546 |
&main::Output(
|
|
|
547 |
" \\\n\t", &Generic_Quote($_)
|
|
|
548 |
);
|
|
|
549 |
}
|
|
|
550 |
&main::Output(
|
|
|
551 |
"\n",
|
|
|
552 |
"\n"
|
|
|
553 |
);
|
|
|
554 |
}
|
|
|
555 |
|
|
|
556 |
my %sources;
|
|
|
557 |
|
|
|
558 |
sub PMEndSrcBld {
|
|
|
559 |
my $ABI=&main::ABI;
|
|
|
560 |
my $BaseSrc=&main::BaseSrc;
|
|
|
561 |
my $Bld=&main::Bld;
|
|
|
562 |
my $Src=ucfirst lc &main::Src;
|
|
|
563 |
my $SrcPath=&main::SrcPath;
|
|
|
564 |
my $Ext = &main::Path_Split('Ext', $Src);
|
|
|
565 |
my $Cia = (lc($Ext) eq '.cia') ? 1 : 0;
|
|
|
566 |
|
|
|
567 |
my $ChopSrcPath=&main::Path_Chop($SrcPath);
|
|
|
568 |
|
|
|
569 |
# add source path, source file and build type to hashmap.
|
|
|
570 |
$sources{$SrcPath}{$Src}{$Bld}=1;
|
|
|
571 |
|
|
|
572 |
# Use GCC trick to get assembler source files preprocessed with CPP
|
|
|
573 |
$Src =~ s/\.s$/.S/i;
|
|
|
574 |
|
|
|
575 |
if ($Cia) {
|
|
|
576 |
&main::Output(
|
|
|
577 |
&Generic_Quote("\$(EPOCBLD$Bld)\\$BaseSrc\_.xml"), " : ",
|
|
|
578 |
&Generic_Quote("$SrcPath$Src"), "\n",
|
|
|
579 |
"\t\$(GCC$Bld) -D__CIA__ -I \"$ChopSrcPath\" \$(INCDIR) -fxml=\$\@ -o nul \"$ChopSrcPath\\$Src\"\n",
|
|
|
580 |
"\n",
|
|
|
581 |
);
|
|
|
582 |
} else {
|
|
|
583 |
&main::Output(
|
|
|
584 |
&Generic_Quote("\$(EPOCBLD$Bld)\\$BaseSrc.xml"), " : ",
|
|
|
585 |
&Generic_Quote("$SrcPath$Src"), "\n",
|
|
|
586 |
"\t\$(GCC$Bld) -I \"$ChopSrcPath\" \$(INCDIR) -fxml=\$\@ -o nul \"$ChopSrcPath\\$Src\"\n",
|
|
|
587 |
"\n",
|
|
|
588 |
);
|
|
|
589 |
}
|
|
|
590 |
|
|
|
591 |
#Keep the staus of the dependency-generation-flag was enabled or disabled.
|
|
|
592 |
my $Deps_Stat = &main::Deps_GetNoDependencies();
|
|
|
593 |
if($Deps_Stat){
|
|
|
594 |
#If the no-dependency-generation-flag turned on, turn it off temporarily, so that we can get
|
|
|
595 |
#the dependencies.
|
|
|
596 |
&main::Deps_SetNoDependenciesStatus(0);
|
|
|
597 |
}
|
|
|
598 |
# Code to print the log file includeheaders.txt
|
|
|
599 |
my $IncFileName = "$epocroot\\epoc32\\release\\gccxml\\includeheaders.txt";
|
|
|
600 |
open INC_FILE,">> $IncFileName" or die "Cannot open file $IncFileName";
|
|
|
601 |
|
|
|
602 |
#Get the dependencies for the current source file.
|
|
|
603 |
my @DepList=&main::Deps_GenDependsL("$SrcPath$Src");
|
|
|
604 |
foreach(@DepList) {
|
|
|
605 |
print INC_FILE "$_\n";
|
|
|
606 |
}
|
|
|
607 |
close INC_FILE;
|
|
|
608 |
|
|
|
609 |
#Set the dependency-generation-flag to its original state so that, it doesn't affect the other target
|
|
|
610 |
#builds.
|
|
|
611 |
&main::Deps_SetNoDependenciesStatus($Deps_Stat);
|
|
|
612 |
|
|
|
613 |
# Code to print the existance of the file in logs
|
|
|
614 |
my $neededfile="$epocroot\\epoc32\\release\\gccxml\\includeheaders.txt";
|
|
|
615 |
if (!-e $neededfile)
|
|
|
616 |
{
|
|
|
617 |
print "!!! File $epocroot\\epoc32\\release\\gccxml\\includeheaders.txt does not exist\n";
|
|
|
618 |
}
|
|
|
619 |
}
|
|
|
620 |
|
|
|
621 |
sub PMEndSrc {
|
|
|
622 |
&main::Output(
|
|
|
623 |
"\n",
|
|
|
624 |
"\n"
|
|
|
625 |
);
|
|
|
626 |
}
|
|
|
627 |
|
|
|
628 |
sub PMEndSrcList {
|
|
|
629 |
my $BldPath=&main::BldPath;
|
|
|
630 |
my $Target = &main::Trg;
|
|
|
631 |
my $TargetBase = &main::Path_Split('Base', $Target);
|
|
|
632 |
use File::Basename;
|
|
|
633 |
my $FileName = basename(&main::MmpFile());
|
|
|
634 |
$FileName = $BldPath.$FileName.".xml";
|
|
|
635 |
open FILE,">> $FileName" or die "Cannot open mmp info dump file $FileName: $!";
|
|
|
636 |
my $path;
|
|
|
637 |
foreach $path (keys %sources)
|
|
|
638 |
{
|
|
|
639 |
my %thing = %{$sources{$path}}; # {"UREL"};
|
|
|
640 |
my $file;
|
|
|
641 |
foreach $file (keys %thing)
|
|
|
642 |
{
|
|
|
643 |
if( defined $thing{$file}{"UREL"})
|
|
|
644 |
{
|
|
|
645 |
if( defined $thing{$file}{"UDEB"} )
|
|
|
646 |
{
|
|
|
647 |
print FILE "\t<sourceFile name=\"$file\" path=\"$path\"/>\n";
|
|
|
648 |
}
|
|
|
649 |
else
|
|
|
650 |
{
|
|
|
651 |
print FILE "\t<sourceFile name=\"$file\" path=\"$path\" type=\"UREL\"/>\n";
|
|
|
652 |
}
|
|
|
653 |
}
|
|
|
654 |
else
|
|
|
655 |
{
|
|
|
656 |
if(defined $thing{$file}{"UDEB"})
|
|
|
657 |
{
|
|
|
658 |
print FILE "\t<sourceFile name=\"$file\" path=\"$path\" type=\"UDEB\"/>\n";
|
|
|
659 |
}
|
|
|
660 |
else
|
|
|
661 |
{
|
|
|
662 |
die "Should Never Get HERE!";
|
|
|
663 |
}
|
|
|
664 |
}
|
|
|
665 |
|
|
|
666 |
}
|
|
|
667 |
}
|
|
|
668 |
|
|
|
669 |
|
|
|
670 |
|
|
|
671 |
my $BldInfDir=&Path_WorkPath;
|
|
|
672 |
my $PrjBldDir=$E32env::Data{BldPath};
|
|
|
673 |
$PrjBldDir=~s-^(.*)\\-$1-o;
|
|
|
674 |
$PrjBldDir.=$BldInfDir;
|
|
|
675 |
$PrjBldDir=~m-(.*)\\-o; # remove backslash because some old versions of perl can't cope
|
|
|
676 |
|
|
|
677 |
|
|
|
678 |
### the export call is like this
|
|
|
679 |
my $lCmd = "make -r -f \"${PrjBldDir}EXPORT.make\" WHAT";
|
|
|
680 |
my @lExportDump = split(/\n/,`$lCmd`);
|
|
|
681 |
foreach my $lLine (@lExportDump) {
|
|
|
682 |
$lLine =~ s/"//g;
|
|
|
683 |
chomp($lLine);
|
|
|
684 |
if($lLine =~ /.*\.h/i) {
|
|
|
685 |
print FILE "\t<export name=\"$lLine\"/>\n";
|
|
|
686 |
}
|
|
|
687 |
}
|
|
|
688 |
|
|
|
689 |
print FILE "</mmpInfo>\n\n";
|
|
|
690 |
close FILE;
|
|
|
691 |
|
|
|
692 |
|
|
|
693 |
|
|
|
694 |
&Generic_End;
|
|
|
695 |
}
|
|
|
696 |
|
|
|
697 |
|
|
|
698 |
sub GetRelDir
|
|
|
699 |
{
|
|
|
700 |
my ($fileName) = @_;
|
|
|
701 |
$fileName = CleanPath($fileName); # make sure that /'s are use rather than \ or \\
|
|
|
702 |
if($fileName!~m-\/-) # no directory, just a file name, so return ./
|
|
|
703 |
{
|
|
|
704 |
return "./";
|
|
|
705 |
}
|
|
|
706 |
elsif($fileName=~m-^(.*\/)[^\/]+$-) # return directory
|
|
|
707 |
{
|
|
|
708 |
return $1;
|
|
|
709 |
}
|
|
|
710 |
else # don't know how could get here
|
|
|
711 |
{
|
|
|
712 |
return "./";
|
|
|
713 |
}
|
|
|
714 |
}
|
|
|
715 |
|
|
|
716 |
|
|
|
717 |
sub SearchMmpFile
|
|
|
718 |
{
|
|
|
719 |
my @rfiFiles;
|
|
|
720 |
my @SystemIncludes = &main::SysIncPaths;
|
|
|
721 |
my @UserIncludes = &main::UserIncPaths;
|
|
|
722 |
my $ResourceStruct = &main::ResourceStructRef;
|
|
|
723 |
|
|
|
724 |
foreach my $ResourceStructure (@$ResourceStruct)
|
|
|
725 |
{
|
|
|
726 |
push @rfiFiles, AnalyseResourceFile($$ResourceStructure{Source}, \@SystemIncludes, \@UserIncludes);
|
|
|
727 |
}
|
|
|
728 |
return \@rfiFiles;
|
|
|
729 |
}
|
|
|
730 |
|
|
|
731 |
sub AnalyseResourceFile
|
|
|
732 |
{ # when get to here $rssFile should be fully qualified relative to mmp file location (i.e. base: .../name.rss)
|
|
|
733 |
my ($rssFile, $systemIncludeList, $userIncludeList) = @_;
|
|
|
734 |
my @resourceRelatedFiles = ($rssFile);
|
|
|
735 |
my $baseFile = 0; #flag to indicate whether this is the base file which the rfi file is named after
|
|
|
736 |
my $rssItem;
|
|
|
737 |
my $containerFile;
|
|
|
738 |
foreach $rssItem (@resourceRelatedFiles) #@resourceRelatedFiles is added to during this foreach loop as included files are found
|
|
|
739 |
{
|
|
|
740 |
$rssItem = CleanPath($rssItem);
|
|
|
741 |
if( ! ($baseFile) )
|
|
|
742 |
{
|
|
|
743 |
$baseFile = 1; # set to non-zero so that setting up the rfi file is only done once
|
|
|
744 |
if($rssItem =~m-\/-)
|
|
|
745 |
{
|
|
|
746 |
if($rssItem =~m-^\S*\/([^\/]+)$-) # just extracts file name
|
|
|
747 |
{
|
|
|
748 |
$containerFile = $1 . ".rfi";
|
|
|
749 |
}
|
|
|
750 |
}
|
|
|
751 |
else
|
|
|
752 |
{
|
|
|
753 |
$containerFile = $rssItem . ".rfi";
|
|
|
754 |
}
|
|
|
755 |
open CONTAINER, ">$containerFile";
|
|
|
756 |
}
|
|
|
757 |
OutputHeader($rssItem);
|
|
|
758 |
my $resourceFiles = ReadFile($rssItem, \@resourceRelatedFiles, $systemIncludeList, $userIncludeList);
|
|
|
759 |
@resourceRelatedFiles = @$resourceFiles;
|
|
|
760 |
}
|
|
|
761 |
close CONTAINER;
|
|
|
762 |
return $containerFile;
|
|
|
763 |
}
|
|
|
764 |
|
|
|
765 |
sub CheckForInclude
|
|
|
766 |
{ # check whether the passed line from the resource type file is a #include line, if it is then store it to be added to the rfi file
|
|
|
767 |
my ($line, $dir, $resourceFiles, $systemIncludeList, $userIncludeList) = @_;
|
|
|
768 |
my @resourceFiles = @$resourceFiles;
|
|
|
769 |
if($line =~ /^\s*\#include\s+([\<\"])(\S+)([\>\"])(\s+\/\/.*)?/)
|
|
|
770 |
{
|
|
|
771 |
if( ($1 eq "\"") and ($3 eq "\"") )
|
|
|
772 |
{
|
|
|
773 |
my $possibleAddition = SearchDirectories($2, "quoted", $dir, $systemIncludeList, $userIncludeList);
|
|
|
774 |
if($possibleAddition ne "")
|
|
|
775 |
{
|
|
|
776 |
push @resourceFiles, $possibleAddition;
|
|
|
777 |
}
|
|
|
778 |
}
|
|
|
779 |
elsif( ($1 eq "\<") and ($3 eq "\>") )
|
|
|
780 |
{
|
|
|
781 |
my $possibleAddition = SearchDirectories($2, "angle", $dir, $systemIncludeList, $userIncludeList);
|
|
|
782 |
if($possibleAddition ne "")
|
|
|
783 |
{
|
|
|
784 |
push @resourceFiles, $possibleAddition;
|
|
|
785 |
}
|
|
|
786 |
}
|
|
|
787 |
}
|
|
|
788 |
return \@resourceFiles;
|
|
|
789 |
}
|
|
|
790 |
|
|
|
791 |
sub ReadFile
|
|
|
792 |
{ # copy the passed file into the rfi file and check it for included files
|
|
|
793 |
my ($fileName, $resourceFiles, $systemIncludeList, $userIncludeList) = @_;
|
|
|
794 |
my $dir = GetRelDir($fileName);
|
|
|
795 |
|
|
|
796 |
open RESOURCE, $fileName or die "Can't open file $fileName from " . cwd() . "\n";
|
|
|
797 |
my $line;
|
|
|
798 |
foreach $line (<RESOURCE>)
|
|
|
799 |
{
|
|
|
800 |
print CONTAINER $line;
|
|
|
801 |
$resourceFiles = CheckForInclude($line, $dir, $resourceFiles, $systemIncludeList, $userIncludeList);
|
|
|
802 |
}
|
|
|
803 |
close RESOURCE;
|
|
|
804 |
return $resourceFiles;
|
|
|
805 |
}
|
|
|
806 |
|
|
|
807 |
sub OutputHeader
|
|
|
808 |
{
|
|
|
809 |
my ($fileName) = @_;
|
|
|
810 |
print CONTAINER "\n\n/* GXP ***********************\n";
|
|
|
811 |
if($fileName =~m-\/-)
|
|
|
812 |
{ # remove path as only want to store file name
|
|
|
813 |
if($fileName =~m-^\S*\/([^\/]+)$-)
|
|
|
814 |
{
|
|
|
815 |
print CONTAINER " * $1\n";
|
|
|
816 |
}
|
|
|
817 |
}
|
|
|
818 |
else
|
|
|
819 |
{
|
|
|
820 |
print CONTAINER " * $fileName\n";
|
|
|
821 |
}
|
|
|
822 |
print CONTAINER " ****************************/\n\n";
|
|
|
823 |
}
|
|
|
824 |
|
|
|
825 |
|
|
|
826 |
sub RecordSystemIncludes
|
|
|
827 |
{
|
|
|
828 |
my ($line) = @_;
|
|
|
829 |
my @terms = split(/ /, $line);
|
|
|
830 |
my $term;
|
|
|
831 |
my @systemIncludes = ();
|
|
|
832 |
foreach $term (@terms)
|
|
|
833 |
{
|
|
|
834 |
if($term!~m/\/\//) # if term is not the start of a c++ style comment
|
|
|
835 |
{
|
|
|
836 |
push @systemIncludes, $term;
|
|
|
837 |
}
|
|
|
838 |
else
|
|
|
839 |
{
|
|
|
840 |
last;
|
|
|
841 |
}
|
|
|
842 |
}
|
|
|
843 |
return \@systemIncludes;
|
|
|
844 |
}
|
|
|
845 |
|
|
|
846 |
sub RecordUserIncludes
|
|
|
847 |
{
|
|
|
848 |
my ($line) = @_;
|
|
|
849 |
my @terms = split(/ /, $line);
|
|
|
850 |
my $term;
|
|
|
851 |
my @userIncludes = ();
|
|
|
852 |
foreach $term (@terms)
|
|
|
853 |
{
|
|
|
854 |
if($term!~m/\/\//) # if term is not the start of a c++ style comment
|
|
|
855 |
{
|
|
|
856 |
push @userIncludes, $term;
|
|
|
857 |
}
|
|
|
858 |
else
|
|
|
859 |
{
|
|
|
860 |
last;
|
|
|
861 |
}
|
|
|
862 |
}
|
|
|
863 |
return \@userIncludes;
|
|
|
864 |
}
|
|
|
865 |
|
|
|
866 |
sub CleanPath # change \ and \\ in path to /
|
|
|
867 |
{
|
|
|
868 |
my ($fileName) = @_;
|
|
|
869 |
$fileName =~ s-\\\\-\/-og;
|
|
|
870 |
$fileName =~ s-\\-\/-og;
|
|
|
871 |
return $fileName;
|
|
|
872 |
}
|
|
|
873 |
|
|
|
874 |
sub RecordSourcePath
|
|
|
875 |
{
|
|
|
876 |
my ($line) = @_;
|
|
|
877 |
my $sourcePath;
|
|
|
878 |
if($line=~/^(\S+)/) # in case of comments at end of line
|
|
|
879 |
{
|
|
|
880 |
$sourcePath = $1;
|
|
|
881 |
$sourcePath = CleanPath($sourcePath);
|
|
|
882 |
if($sourcePath !~ m/\/$/)
|
|
|
883 |
{
|
|
|
884 |
$sourcePath .= "\/";
|
|
|
885 |
}
|
|
|
886 |
}
|
|
|
887 |
return $sourcePath;
|
|
|
888 |
}
|
|
|
889 |
|
|
|
890 |
sub SearchDirectories
|
|
|
891 |
{
|
|
|
892 |
my ($fileName, $includeType, $base, $systemIncludeList, $userIncludeList) = @_;
|
|
|
893 |
my @systemIncludes = @$systemIncludeList;
|
|
|
894 |
my @userIncludes = @$userIncludeList;
|
|
|
895 |
|
|
|
896 |
$fileName = CleanPath($fileName);
|
|
|
897 |
|
|
|
898 |
if(-e $base.$fileName)
|
|
|
899 |
{
|
|
|
900 |
return $base.$fileName;
|
|
|
901 |
}
|
|
|
902 |
if($includeType eq "quoted")
|
|
|
903 |
{
|
|
|
904 |
# search through the user includes and return dir + file name if found
|
|
|
905 |
my $directory;
|
|
|
906 |
foreach $directory (@userIncludes)
|
|
|
907 |
{
|
|
|
908 |
my $qualifiedFileName = $directory . "/" . $fileName;
|
|
|
909 |
if(-e $qualifiedFileName)
|
|
|
910 |
{
|
|
|
911 |
return $qualifiedFileName;
|
|
|
912 |
}
|
|
|
913 |
}
|
|
|
914 |
}
|
|
|
915 |
|
|
|
916 |
# search through the system includes
|
|
|
917 |
my $directory;
|
|
|
918 |
foreach $directory (@systemIncludes)
|
|
|
919 |
{
|
|
|
920 |
my $qualifiedFileName = $directory . "/" . $fileName;
|
|
|
921 |
if(-e $qualifiedFileName)
|
|
|
922 |
{
|
|
|
923 |
return $qualifiedFileName;
|
|
|
924 |
}
|
|
|
925 |
}
|
|
|
926 |
return "";
|
|
|
927 |
}
|
|
|
928 |
|
|
|
929 |
|
|
|
930 |
sub GatherResourceInformation
|
|
|
931 |
{
|
|
|
932 |
my $BldPath=&main::BldPath;
|
|
|
933 |
unless (-d $BldPath) {
|
|
|
934 |
mkpath([$BldPath]);
|
|
|
935 |
}
|
|
|
936 |
$BldPath = (&main::Path_StepDirs($BldPath))[-2];
|
|
|
937 |
my $bldInfDirectory = cwd(); # store current directory so can return to it later
|
|
|
938 |
my $MmpFile = &main::MmpFile();
|
|
|
939 |
$MmpFile = CleanPath($MmpFile);
|
|
|
940 |
my $MmpFileDir = "./";
|
|
|
941 |
my $MmpFileName = $MmpFile;
|
|
|
942 |
if($MmpFile=~m-\/-)
|
|
|
943 |
{
|
|
|
944 |
if($MmpFile=~m-^(.*)\/([^\/]*)$-)
|
|
|
945 |
{
|
|
|
946 |
$MmpFileDir = $1;
|
|
|
947 |
$MmpFileName = $2;
|
|
|
948 |
}
|
|
|
949 |
}
|
|
|
950 |
chdir($MmpFileDir) or die "Error: Could not change to MMP file directory: $MmpFileDir\n";
|
|
|
951 |
|
|
|
952 |
my $rfiFileList = &SearchMmpFile; # analyse the mmp file for resource files
|
|
|
953 |
|
|
|
954 |
my @RfiFiles = @$rfiFileList;
|
|
|
955 |
foreach (@RfiFiles) # copy the rfi files to the BldPath and delete them from temporary locations
|
|
|
956 |
{
|
|
|
957 |
system("copy \"$_\" \"$BldPath$_\"");
|
|
|
958 |
unlink $_;
|
|
|
959 |
}
|
|
|
960 |
chdir($bldInfDirectory); # return to the orignial directory
|
|
|
961 |
|
|
|
962 |
return \@RfiFiles; # return list of rfi files to be added to .mmp.xml file
|
|
|
963 |
}
|
|
|
964 |
1;
|