1 # Copyright (c) 2009 Symbian Foundation Ltd |
|
2 # This component and the accompanying materials are made available |
|
3 # under the terms of the License "Eclipse Public License v1.0" |
|
4 # which accompanies this distribution, and is available |
|
5 # at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
6 # |
|
7 # Initial Contributors: |
|
8 # Symbian Foundation Ltd - initial contribution. |
|
9 # |
|
10 # Contributors: |
|
11 # Arnaud Lenoir |
|
12 # |
|
13 # Description: |
|
14 # Task 243 - Generate FCLs details between 2 PDKs to be included as part of the release notes |
|
15 |
|
16 # Here is the location for the naming convention for the PDKs: http://developer.symbian.org/wiki/index.php/Build_and_Integration |
|
17 |
|
18 # |
|
19 # Configuration data and constants for the script |
|
20 # |
|
21 print "\n"; |
|
22 my $default_pdk_loc='\\\\bishare\\releases\\'; |
|
23 print "default_pdk_loc=$default_pdk_loc\n"; |
|
24 |
|
25 # Nb of arguments to be passed to the script to work. If that need to change, just modify nb_arg_to_pass! |
|
26 my $nb_arg_to_pass=2; |
|
27 print "nb_arg_to_pass=$nb_arg_to_pass\n"; |
|
28 |
|
29 # Name of the file that contains the data we need to extract for this script |
|
30 my $build_bom_zip_file_to_extract="build_BOM\.zip"; |
|
31 my $build_logs_zip_file_to_extract="build_logs\.zip"; |
|
32 |
|
33 # Name of the file we need to work on to extract the data necessary for the Release Notes from build_BOM.zip |
|
34 my $name_of_file_to_compare="build-info\.xml"; |
|
35 |
|
36 # File used to extract path and component name for a package from build_logs.zip |
|
37 my $pckg_extraction_data_file_name = "PkgComponentAnalysisSummary\.csv"; |
|
38 |
|
39 |
|
40 # When using the script as part of the build system, we don't have access to the zip files yet, therefore we need to have a look for the file directly |
|
41 # This is working only when using pdkloc2 only. In any other cases we are not bothered!!!!! |
|
42 my $bom_dir="BOM"; |
|
43 my $analysis_dir="analysis"; |
|
44 |
|
45 # Pattern used to search for PDKs |
|
46 my $pdk_start_pattern="PDK_"; |
|
47 |
|
48 # Pattern used to extract info from the xml file |
|
49 my $starting_pattern_for_xml_extraction="<name>Sources</name>"; |
|
50 my $ending_pattern_for_xml_extraction="</project>"; |
|
51 # Pattern to extract data from the line in the file |
|
52 # Branch type. If not a branch type, we are not interested |
|
53 my $branch_type_extraction_pattern="(MCL|FCL)"; |
|
54 |
|
55 my $mcl_cste="MCL"; |
|
56 my $fcl_cste="FCL"; |
|
57 |
|
58 # package name |
|
59 #/imgeditor/#:86a88f39b644</baseline> |
|
60 # # is used to define the changeset number for mercurial. |
|
61 # Therefore if we have a look what is before "/#", we should always find the package name!! |
|
62 my $package_extraction_pattern = "([^/]+)/?#"; |
|
63 |
|
64 # When that "boolean value is set to 1 or true, then the line we read in the file can be search for the information we want to extract |
|
65 # If $starting_pattern_for_xml_extraction true, then set extraction_from_xml_is_allowed to true/1 |
|
66 # If $ending_pattern_for_xml_extraction false, then reset extraction_from_xml_is_allowed to false/0 |
|
67 # $ending_pattern_for_xml_extraction is called several times in the program, but this is not a problem as we don't set it to false/0 and therefore do nothing! |
|
68 my $extraction_from_xml_is_allowed=0; |
|
69 |
|
70 # Temporary location used to do the work |
|
71 my $working_drive="c:"; |
|
72 my $working_directory="temp"; |
|
73 my $working_sub_directory="fcl_extraction"; |
|
74 my $working_pdk1_directory="pdk1"; |
|
75 my $working_pdk2_directory="pdk2"; |
|
76 |
|
77 # Name of the file that we are creating to hold the information necessary for the Release Notes |
|
78 my $name_of_file_to_publish="releaseNotes.wiki.txt"; |
|
79 #Location for that file |
|
80 # This values need to be overwritten!!! |
|
81 my $location_of_file_to_publish="c:\\temp"; |
|
82 my $path_to_file_to_publish="$location_of_file_to_publish\\$name_of_file_to_publish"; |
|
83 |
|
84 # |
|
85 # End configuration data for the script |
|
86 # |
|
87 |
|
88 |
|
89 # Get parameters passed to the script. Save only the 2 first parameters as we need only 2 parameters for the script |
|
90 print "\n"; |
|
91 my $nb_arg_passed = scalar(@ARGV); |
|
92 print "nb_arg_passed=$nb_arg_passed\n"; # Find out the number of arguement passed |
|
93 print "@ARGV\n\n"; |
|
94 # Needs to be done here, otherwise lost if try to recover them later on. Why? |
|
95 my $arg1_passed = $ARGV[0]; |
|
96 my $arg2_passed = $ARGV[1]; |
|
97 print "arg1_passed= $arg1_passed \t arg2_passed=$arg2_passed\n"; |
|
98 |
|
99 # if enter help as unique argument, then we will launch the help becaue we only pass one argument. |
|
100 if ($nb_arg_passed != $nb_arg_to_pass) |
|
101 { |
|
102 helpme(); |
|
103 } |
|
104 |
|
105 # Modules necessary to run this script |
|
106 use Getopt::Long; |
|
107 use strict; |
|
108 |
|
109 |
|
110 # Arguments / Data used for the script |
|
111 my $pdknb1 = ''; |
|
112 my $pdknb2 = ''; |
|
113 my $pdkloc1 = ''; |
|
114 my $pdkloc2 = ''; |
|
115 my $pdkname1 = ''; |
|
116 my $pdkname2 = ''; |
|
117 |
|
118 my $help = 0; |
|
119 |
|
120 GetOptions(( |
|
121 'pdknb1=s' => \$pdknb1, |
|
122 'pdknb2=s' => \$pdknb2, |
|
123 'pdkname1=s' => \$pdkname1, |
|
124 'pdkname2=s' => \$pdkname2, |
|
125 'pdkloc1=s' => \$pdkloc1, |
|
126 'pdkloc2=s' => \$pdkloc2, |
|
127 'help!' => \$help # Not working |
|
128 )); |
|
129 |
|
130 print "\pdknb1=$pdknb1\n"; |
|
131 print "\pdknb2=$pdknb2\n"; |
|
132 print "\pdkname1=$pdkname1\n"; |
|
133 print "\pdkname2=$pdkname2\n"; |
|
134 print "\pdkloc1=$pdkloc1\n"; |
|
135 print "\pdkloc2=$pdkloc2\n"; |
|
136 print "\help=$help\n"; |
|
137 |
|
138 my $count_arg=0; # Caculate the number of arguments we need for the script to work and that we know are correct (help doesn't count) |
|
139 |
|
140 # First PDK to check |
|
141 my $pdk_path1=""; |
|
142 my $pdk_complete_name1=0; |
|
143 my $pdk_complete_path1=0; |
|
144 my $pdk_path1_now_in_use=0; |
|
145 my $pdk_values_to_search1=""; # Not necessary |
|
146 my $pdk_path1_exist=0; |
|
147 my $pdk_zip1_exit=0; # Not necessary |
|
148 my $pdk1_correct_name_to_use=""; |
|
149 my $loc1_contains_the_zip_file_we_need=0; |
|
150 |
|
151 # Second PDK to check |
|
152 my $pdk_path2=""; |
|
153 my $pdk_complete_name2=0; |
|
154 my $pdk_complete_path2=0; |
|
155 my $pdk_path2_now_in_use=0; |
|
156 my $pdk_values_to_search2=""; # Not necessary |
|
157 my $pdk_path2_exist=0; |
|
158 my $pdk_zip2_exist=0; # Not necessary |
|
159 my $pdk2_correct_name_to_use=""; |
|
160 my $loc2_contains_the_zip_file_we_need=0; # Used to indicate that we have found the build_BOM.zip file |
|
161 my $loc2_contains_the_xml_csv_files_we_need=0; # Used to indicate that we have found the build-info.xml and PkgComponentAnalysisSummary.csv |
|
162 my $nb_of_xml_csv_files_we_need=2; # Used to define the number of files we need to have a look at when we are not looking for zip files. |
|
163 my $nb_of_zip_files_we_need=2; # Used to define the number of files we need to have a look at when we are looking for zip files. |
|
164 |
|
165 # Default directory management |
|
166 my @directories_list_default_location=(); |
|
167 my $nb_dir_in_default_loc; |
|
168 my @pdk_dir_list_in_default_location=(); |
|
169 my $nb_pdks_in_default_loc=0; |
|
170 my @pdks_with_valid_zip_in_default_loc=(); |
|
171 my $nb_pdks_with_valid_zip_in_default_loc=0; |
|
172 my @find_pdk_for_corresponding_nb1=(); |
|
173 my $nb_of_pdk_for_corresponding_nb1=0; |
|
174 my @find_pdk_for_corresponding_nb2=(); |
|
175 my $nb_of_pdk_for_corresponding_nb2=0; |
|
176 my @find_pdk_for_corresponding_name1=(); |
|
177 my $nb_of_pdk_for_corresponding_name1=0; |
|
178 my @find_pdk_for_corresponding_name2=(); |
|
179 my $nb_of_pdk_for_corresponding_name2=0; |
|
180 my @read_files_in_loc=(); |
|
181 |
|
182 # Data / statistics to be displayed in the release notes |
|
183 # We consider that pdk1 is the old version and pdk2 is the new version. |
|
184 # Note that for the moment, the scripts is not able to make sure that the old version of the pdk is set as pdk1 and the new version of the pdk is set as pdk2!!!!! |
|
185 # Can be done for pdknb and pdkname but not for pdkloc as for the moment, no way to find out the pdk version from the build-info.xmL!!!! |
|
186 # Totals |
|
187 my $total_packages_pdk1=0; # Nb of packages included in the pdk1 |
|
188 my $total_packages_pdk2=0; # Nb of packages included in the pdk2 |
|
189 my $total_packages_added=0; # Nb of packages added in the pdk2 |
|
190 my $total_packages_removed=0; # Nb of packages removed from the pdk2 |
|
191 my $total_new_fcl=0; # Nb of packages that are now on fcl in pdk2 (means were mcl in pdk1 and are now fcl in pdk2) |
|
192 my $total_no_more_fcl=0; # Nb of packages that are no more on fcl in pdk2 (means were fcl in pdk1 and are now mcl in pdk2) |
|
193 my $total_still_fcl=0; # Nb of packages that are still on fcl in pdk2 (means were fcl in pdk1 and are still fcl in pdk2) |
|
194 my $total_very_good_mcl=0; # Nb of packages that are very good on mcl in pdk1 and pdk2 (means were on mcl in pdk1 and are still mcl in pdk2) |
|
195 # Tables |
|
196 my @pdk1_sorting_table; # Table for pdk1 that is used to sort out and compare the 2 pdks |
|
197 my @pdk2_sorting_table; # Table for pdk2 that is used to sort out and compare the 2 pdks |
|
198 my @packages_added_table; # Table that contains the packages that have been added to pdk2 |
|
199 my @packages_removed_table; # Table that contains the packages that have been deleted from pdk2 |
|
200 my @new_fcl_table; # Table containing the packages that are now on fcl in pdk2 (means were mcl in pdk1 and are now fcl in pdk2) |
|
201 my @no_more_fcl_table; # Table containing the packages that are no more on fcl in pdk2 (means were fcl in pdk1 and are now mcl in pdk2) |
|
202 my @still_fcl_table; # Table containing the packages that are still on fcl in pdk2 (means were fcl in pdk1 and are still fcl in pdk2) |
|
203 my @very_good_mcl_table; # Table containing the packages that are very good on mcl in pdk1 and pdk2 (means were on mcl in pdk1 and are still mcl in pdk2) |
|
204 my %pckg_path_name_array; # Table containing the path for each packages |
|
205 my %pckg_name_array; # Table containing the real meaning name for each packages, not the name of the package in the directory structure |
|
206 |
|
207 # Check that we have only 2 values for the PDKs. If not 2, then not good! |
|
208 |
|
209 |
|
210 # Script code start here! |
|
211 if($pdknb1) |
|
212 { |
|
213 $count_arg++; |
|
214 |
|
215 # Get data for first pdk used for the comparison |
|
216 $pdk_path1 = $default_pdk_loc; |
|
217 $pdk_complete_name1=1; |
|
218 $pdk_complete_path1=1; |
|
219 $pdk_path1_now_in_use=1; |
|
220 $pdk_values_to_search1=$pdknb1; # Not necessary |
|
221 } |
|
222 if($pdknb2) |
|
223 { |
|
224 $count_arg++; |
|
225 |
|
226 # Get data for first pdk used for the comparison |
|
227 $pdk_path2 = $default_pdk_loc; |
|
228 $pdk_complete_name2=1; |
|
229 $pdk_complete_path2=1; |
|
230 $pdk_path2_now_in_use=1; |
|
231 $pdk_values_to_search2=$pdknb2; # Not necessary |
|
232 } |
|
233 if($pdkname1) |
|
234 { |
|
235 $count_arg++; |
|
236 |
|
237 if(!$pdk_path1_now_in_use) |
|
238 { |
|
239 # Get data for first pdk used for the comparison |
|
240 $pdk_path1 = $default_pdk_loc; |
|
241 $pdk_complete_path1=1; |
|
242 $pdk_path1_now_in_use=1; |
|
243 $pdk_values_to_search1=$pdkname1; # Not necessary |
|
244 } |
|
245 else |
|
246 { |
|
247 print "You are a bad boy!!!!, you can't enter 2 parameters ending with the same number like pdknb1 and pdkname1! Start again with the right parameters!\n"; |
|
248 exit(0); |
|
249 } |
|
250 } |
|
251 if($pdkname2) |
|
252 { |
|
253 $count_arg++; |
|
254 |
|
255 if(!$pdk_path2_now_in_use) |
|
256 { |
|
257 # Get data for first pdk used for the comparison |
|
258 $pdk_path2 = $default_pdk_loc; |
|
259 $pdk_complete_path2=1; |
|
260 $pdk_path2_now_in_use=1; |
|
261 $pdk_values_to_search2=$pdkname2; # Not necessary |
|
262 } |
|
263 else |
|
264 { |
|
265 print "You are a bad boy!!!!, you can't enter 2 parameters ending with the same number like pdknb2 and pdkname2! Start again with the right parameters!\n"; |
|
266 exit(0); |
|
267 } |
|
268 } |
|
269 if($pdkloc1) |
|
270 { |
|
271 $count_arg++; |
|
272 |
|
273 if(!$pdk_path1_now_in_use) |
|
274 { |
|
275 # Get data for first pdk used for the comparison |
|
276 $pdk_path1 = $pdkloc1; |
|
277 $pdk_path1_now_in_use=1; |
|
278 } |
|
279 else |
|
280 { |
|
281 print "You are a bad boy!!!!, you can't enter 2 parameters ending with the same number like pdknb1 and pdkloc1! Start again with the right parameters!\n"; |
|
282 exit(0); |
|
283 } |
|
284 } |
|
285 |
|
286 if($pdkloc2) |
|
287 { |
|
288 $count_arg++; |
|
289 |
|
290 if(!$pdk_path2_now_in_use) |
|
291 { |
|
292 # Get data for first pdk used for the comparison |
|
293 $pdk_path2 = $pdkloc2; |
|
294 $pdk_path2_now_in_use=1; |
|
295 } |
|
296 else |
|
297 { |
|
298 print "You are a bad boy!!!!, you can't enter 2 parameters ending with the same number like pdknb2 and pdkloc2! Start again with the right parameters!\n"; |
|
299 exit(0); |
|
300 } |
|
301 } |
|
302 |
|
303 print "count_arg=$count_arg\n"; |
|
304 |
|
305 |
|
306 # If no parameters entered or help selected, display help |
|
307 if ($count_arg != $nb_arg_to_pass) |
|
308 { |
|
309 #$help = 1; |
|
310 helpme(); |
|
311 print"\nThe script accepts $nb_arg_to_pass parameters only!\n\n"; |
|
312 } |
|
313 |
|
314 |
|
315 # |
|
316 # If we reach this point, this means that we have the right numbers of arguments passed to the script. |
|
317 # |
|
318 print "\nWe are on the right path!!!!\n"; |
|
319 |
|
320 print "pdk_path1=$pdk_path1\n"; |
|
321 print "pdk_complete_name1=$pdk_complete_name1\n"; |
|
322 print "pdk_complete_path1=$pdk_complete_path1\n"; |
|
323 print "pdk_values_to_search1=$pdk_values_to_search1\n"; # Not necessary |
|
324 print "\n"; |
|
325 print "pdk_path2=$pdk_path2\n"; |
|
326 print "pdk_complete_name2=$pdk_complete_name2\n"; |
|
327 print "pdk_complete_path2=$pdk_complete_path2\n"; |
|
328 print "pdk_values_to_search2=$pdk_values_to_search2\n"; # Not necessary |
|
329 print "\n\n"; |
|
330 |
|
331 # Get directory listing of all directories in the default location $default_pdk_loc |
|
332 extract_dir_default_loc(); |
|
333 extract_pdk_in_default_loc(); |
|
334 extract_pdk_with_valid_zip_in_default_loc(); |
|
335 |
|
336 # Compose path if necessary. |
|
337 print "\n"; |
|
338 |
|
339 my $find_val=0; |
|
340 |
|
341 if ($pdk_complete_path1) |
|
342 { |
|
343 if ($pdk_complete_name1) |
|
344 { |
|
345 print "We have the PDK number, we need to define if possible the PDK name and therefore the path to the PDK\n"; |
|
346 # Have a look in the default directory if there is a PDK with that number. If none or more than one with the same id, returns the list of PDKs with that same number |
|
347 foreach $find_val (@pdks_with_valid_zip_in_default_loc) |
|
348 { |
|
349 #print $find_val, "\n"; |
|
350 if($find_val =~ /$pdknb1/i) |
|
351 { |
|
352 $find_pdk_for_corresponding_nb1[$nb_of_pdk_for_corresponding_nb1++]=$find_val; |
|
353 } |
|
354 } |
|
355 print "Table find_pdk_for_corresponding_nb1 is:\n"; |
|
356 display_array_one_line_at_the_time(@find_pdk_for_corresponding_nb1); |
|
357 |
|
358 if($nb_of_pdk_for_corresponding_nb1==1) |
|
359 { |
|
360 print "There is only $nb_of_pdk_for_corresponding_nb1 PDK with the name corresponding to the PDK number given, we can keep going!\n"; |
|
361 } |
|
362 else |
|
363 { |
|
364 print "There is $nb_of_pdk_for_corresponding_nb1 PDKs with the same name, please select one in the list above and run the perl script again with the right PDK name\n"; |
|
365 exit(0); |
|
366 } |
|
367 |
|
368 #extract PDK name if only one |
|
369 $pdk1_correct_name_to_use = $find_pdk_for_corresponding_nb1[0]; |
|
370 $pdk_path1 .= $find_pdk_for_corresponding_nb1[0]; |
|
371 print "pdknb1 = $pdknb1\n"; |
|
372 } |
|
373 else |
|
374 { |
|
375 print "We have the PDK Name therefore we can define the path to the PDK\n"; |
|
376 |
|
377 # Have a look in the default directory if there is a PDK with that number. If none or more than one with the same id, returns the list of PDKs with that same number |
|
378 foreach $find_val (@pdks_with_valid_zip_in_default_loc) |
|
379 { |
|
380 #print $find_val, "\n"; |
|
381 if($find_val =~ /$pdkname1/i) |
|
382 { |
|
383 $find_pdk_for_corresponding_name1[$nb_of_pdk_for_corresponding_name1++]=$find_val; |
|
384 } |
|
385 } |
|
386 print "Table find_pdk_for_corresponding_name1 is: \n"; |
|
387 display_array_one_line_at_the_time(@find_pdk_for_corresponding_name1); |
|
388 |
|
389 if($nb_of_pdk_for_corresponding_name1==1) |
|
390 { |
|
391 print "There is only $nb_of_pdk_for_corresponding_name1 PDK with the name corresponding to the PDK name given, we can keep going!\n"; |
|
392 } |
|
393 else |
|
394 { |
|
395 print "There is $nb_of_pdk_for_corresponding_name1 PDKs with the same name, please select one in the list above and run the perl script again with the right PDK name\n"; |
|
396 } |
|
397 |
|
398 #extract PDK name if only one |
|
399 print "pdkname1 = $pdkname1\n"; |
|
400 $pdk1_correct_name_to_use = $pdkname1; |
|
401 $pdk_path1 .= $pdkname1; |
|
402 } |
|
403 print "The PDK used is: $pdk1_correct_name_to_use\n"; |
|
404 print "pdk_path1 = $pdk_path1\n"; |
|
405 } |
|
406 |
|
407 $find_val=0; |
|
408 |
|
409 if ($pdk_complete_path2) |
|
410 { |
|
411 if ($pdk_complete_name2) |
|
412 { |
|
413 print "We have the PDK number, we need to define if possible the PDK name and therefore the path to the PDK\n"; |
|
414 # Have a look in the default directory if there is a PDK with that number. If none or more than one with the same id, returns the list of PDKs with that same number |
|
415 foreach $find_val (@pdks_with_valid_zip_in_default_loc) |
|
416 { |
|
417 #print $find_val, "\n"; |
|
418 if($find_val =~ /$pdknb2/i) |
|
419 { |
|
420 $find_pdk_for_corresponding_nb2[$nb_of_pdk_for_corresponding_nb2++]=$find_val; |
|
421 } |
|
422 } |
|
423 print "Table find_pdk_for_corresponding_nb is:\n"; |
|
424 display_array_one_line_at_the_time(@find_pdk_for_corresponding_nb2); |
|
425 |
|
426 if($nb_of_pdk_for_corresponding_nb2==1) |
|
427 { |
|
428 print "There is only $nb_of_pdk_for_corresponding_nb2 PDK with the name corresponding to the PDK number given, we can keep going!\n"; |
|
429 } |
|
430 else |
|
431 { |
|
432 print "There is $nb_of_pdk_for_corresponding_nb2 PDKs with the same name, please select one in the list above and run the perl script again with the right PDK name\n"; |
|
433 exit(0); |
|
434 } |
|
435 |
|
436 #extract PDK name if only one |
|
437 $pdk2_correct_name_to_use = $find_pdk_for_corresponding_nb2[0]; |
|
438 $pdk_path2 .= $find_pdk_for_corresponding_nb2[0]; |
|
439 print "pdknb2 = $pdknb2\n"; |
|
440 } |
|
441 else |
|
442 { |
|
443 print "We have the PDK Name therefore we can define the path to the PDK\n"; |
|
444 |
|
445 # Have a look in the default directory if there is a PDK with that number. If none or more than one with the same id, returns the list of PDKs with that same number |
|
446 foreach $find_val (@pdks_with_valid_zip_in_default_loc) |
|
447 { |
|
448 #print $find_val, "\n"; |
|
449 if($find_val =~ /$pdkname2/i) |
|
450 { |
|
451 $find_pdk_for_corresponding_name2[$nb_of_pdk_for_corresponding_name2++]=$find_val; |
|
452 } |
|
453 } |
|
454 print "Table find_pdk_for_corresponding_name2 is:\n"; |
|
455 display_array_one_line_at_the_time(@find_pdk_for_corresponding_name2); |
|
456 |
|
457 if($nb_of_pdk_for_corresponding_name2==1) |
|
458 { |
|
459 print "There is only $nb_of_pdk_for_corresponding_name2 PDK with the name corresponding to the PDK name given, we can keep going!\n"; |
|
460 } |
|
461 else |
|
462 { |
|
463 print "There is $nb_of_pdk_for_corresponding_name2 PDKs with the same name, please select one in the list above and run the perl script again with the right PDK name\n"; |
|
464 } |
|
465 |
|
466 #extract PDK name if only one |
|
467 print "pdkname2 = $pdkname2\n"; |
|
468 $pdk2_correct_name_to_use = $pdkname2; |
|
469 $pdk_path2 .= $pdkname2; |
|
470 } |
|
471 print "The PDK used is: $pdk2_correct_name_to_use\n"; |
|
472 print "pdk_path2 = $pdk_path2\n"; |
|
473 } |
|
474 |
|
475 # Find out if the locations are correct or not. We just need to make sure that the location contains the build_BOM.zip, if it's the case, then bingo! If not, exit the program. |
|
476 my $loc_var; |
|
477 |
|
478 if($pdkloc1) |
|
479 { |
|
480 # Get the list of file in the location choosen. |
|
481 opendir(LOC1_DIR, $pdkloc1); |
|
482 @read_files_in_loc = readdir(LOC1_DIR); |
|
483 close(LOC1_DIR); |
|
484 |
|
485 #print "List of files in the directory: @read_files_in_loc\n"; |
|
486 |
|
487 foreach $loc_var (@read_files_in_loc) |
|
488 { |
|
489 if($loc_var =~ /$build_bom_zip_file_to_extract$/) |
|
490 { |
|
491 print "We found the file: $loc_var\n"; |
|
492 |
|
493 $pdk1_correct_name_to_use = "PDK1"; |
|
494 $pdk_path1 = $pdkloc1; |
|
495 |
|
496 print "The PDK used is: $pdk1_correct_name_to_use\n"; |
|
497 print "pdk_path1 = $pdk_path1\n"; |
|
498 $loc1_contains_the_zip_file_we_need=1; |
|
499 |
|
500 # As we have found the file, we can probably break! |
|
501 } |
|
502 } |
|
503 if(!$loc1_contains_the_zip_file_we_need) |
|
504 { |
|
505 print "We can't find the file $build_bom_zip_file_to_extract in the location $pdkloc2 and therefore we can't go any further!!\n"; |
|
506 exit(0); |
|
507 } |
|
508 } |
|
509 print "\n"; |
|
510 |
|
511 if($pdkloc2) |
|
512 { |
|
513 # Have a look at the zip files in the location choosen. |
|
514 opendir(LOC2_DIR, $pdkloc2); |
|
515 @read_files_in_loc = readdir(LOC2_DIR); # Need to have a look at the sub directories too!!!!!! |
|
516 close(LOC2_DIR); |
|
517 print "List of files in the directory: @read_files_in_loc\n"; |
|
518 |
|
519 foreach $loc_var (@read_files_in_loc) |
|
520 { |
|
521 # Have a look for build_bom.zip and build_logs.zip |
|
522 if( ($loc_var =~ /$build_bom_zip_file_to_extract$/) || ($loc_var =~ /$build_logs_zip_file_to_extract$/) ) |
|
523 { |
|
524 print "We found the file: $loc_var\n"; |
|
525 $loc2_contains_the_zip_file_we_need++; |
|
526 } |
|
527 } |
|
528 |
|
529 if(!$loc2_contains_the_zip_file_we_need) # If we have the zip file, no need to have a look for the csv and xml files! |
|
530 { |
|
531 my $local_var_path; |
|
532 |
|
533 print "We are checking for xml file\n"; |
|
534 $local_var_path = "$pdkloc2\\$bom_dir"; |
|
535 print "local_var_path = $local_var_path\n"; |
|
536 |
|
537 opendir(LOCBOM_DIR, $local_var_path); |
|
538 @read_files_in_loc = readdir(LOCBOM_DIR); |
|
539 close(LOCBOM_DIR); |
|
540 |
|
541 print "List of files in the directory: @read_files_in_loc\n"; |
|
542 |
|
543 foreach $loc_var (@read_files_in_loc) |
|
544 { |
|
545 if($loc_var =~ /$name_of_file_to_compare$/) |
|
546 { |
|
547 print "We are in the case of the build and instead of looking for zip files, we need to have a look for $name_of_file_to_compare\n"; |
|
548 |
|
549 print "We found the file: $loc_var\n"; |
|
550 |
|
551 $loc2_contains_the_xml_csv_files_we_need++; |
|
552 } |
|
553 } |
|
554 |
|
555 print "We are checking for csv file\n"; |
|
556 $local_var_path = "$pdkloc2\\$analysis_dir"; |
|
557 print "local_var_path = $local_var_path\n"; |
|
558 |
|
559 opendir(LOCANALYSIS_DIR, $local_var_path); |
|
560 @read_files_in_loc = readdir(LOCANALYSIS_DIR); |
|
561 close(LOCANALYSIS_DIR); |
|
562 |
|
563 print "List of files in the directory: @read_files_in_loc\n"; |
|
564 |
|
565 foreach $loc_var (@read_files_in_loc) |
|
566 { |
|
567 if($loc_var =~ /$pckg_extraction_data_file_name$/) |
|
568 { |
|
569 print "We are in the case of the build and instead of looking for zip files, we need to have a look for $pckg_extraction_data_file_name\n"; |
|
570 |
|
571 print "We found the file: $loc_var\n"; |
|
572 |
|
573 $loc2_contains_the_xml_csv_files_we_need++; |
|
574 } |
|
575 } |
|
576 } |
|
577 if(($loc2_contains_the_zip_file_we_need==$nb_of_zip_files_we_need) || ($loc2_contains_the_xml_csv_files_we_need==$nb_of_xml_csv_files_we_need)) |
|
578 { |
|
579 $pdk2_correct_name_to_use = "PDK2"; |
|
580 $pdk_path2 = $pdkloc2; |
|
581 |
|
582 print "The PDK used is: $pdk2_correct_name_to_use\n"; |
|
583 print "pdk_path2 = $pdk_path2\n"; |
|
584 |
|
585 if($loc2_contains_the_xml_csv_files_we_need==$nb_of_xml_csv_files_we_need) |
|
586 { |
|
587 $location_of_file_to_publish=$pdkloc2; |
|
588 $path_to_file_to_publish="$location_of_file_to_publish\\$name_of_file_to_publish"; |
|
589 print "location_of_file_to_publish=$location_of_file_to_publish\n"; |
|
590 print "path_to_file_to_publish=$path_to_file_to_publish\n"; |
|
591 } |
|
592 } |
|
593 else |
|
594 { |
|
595 if($loc2_contains_the_xml_csv_files_we_need<=$nb_of_xml_csv_files_we_need) |
|
596 { |
|
597 print "We can't find the files $name_of_file_to_compare and\/or $pckg_extraction_data_file_name in the location $pdkloc2 and therefore we can't go any further!!\n"; |
|
598 } |
|
599 else |
|
600 { |
|
601 print "We can't find the files $build_bom_zip_file_to_extract in the location $pdkloc2 and therefore we can't go any further!!\n"; |
|
602 } |
|
603 exit(0); |
|
604 } |
|
605 } |
|
606 |
|
607 print "\n"; |
|
608 print "If we are here, this means that both $build_bom_zip_file_to_extract have been found and we can start the real work to compare the 2 files to extract what we need!\n"; |
|
609 print "This is the value for the path we are looking at for pdk_path1: $pdk_path1\n"; |
|
610 print "This is the value for the path we are looking at for pdk_path2: $pdk_path2\n"; |
|
611 |
|
612 # When we are at this point, we know we have 2 build_BOM.zip files that we can compare them!!!! |
|
613 |
|
614 my $system_cmd = ""; |
|
615 |
|
616 my $working_dir="$working_drive\\$working_directory\\$working_sub_directory"; |
|
617 my $working_dir1="$working_drive\\$working_directory\\$working_sub_directory\\$working_pdk1_directory"; |
|
618 my $working_dir2="$working_drive\\$working_directory\\$working_sub_directory\\$working_pdk2_directory"; |
|
619 |
|
620 # 1st step is to extract the 2 zip files to allow us to have access to build-info.xml |
|
621 |
|
622 # Extract just one file from the zip file using "7z e -r -oOutput_Directory" |
|
623 #7z e -r build_BOM.zip build-info.xml |
|
624 # Where 7z is the unzip program |
|
625 # Where e is for extraction of a file |
|
626 # Where -r is for recursive to make sure we have a look in the subdirectories |
|
627 # Where -oOutput_Directory is the directory where we want the files to be unzipped |
|
628 # |
|
629 # Where $working_sub_directory is the directory where we will be carry the work to be done for the script. |
|
630 # Where $working_pdk1_directory is the subdirectory destination for the PDK1 |
|
631 # Where $build_bom_zip_file_to_extract is the name of the zip file (in our case: build_BOM.zip) |
|
632 # Where $pdk_path1 is the place where the zip file to unzip is |
|
633 # where $name_of_file_to_compare is the name of the file we want to extract from the zip file (in our case: build-info.xml) |
|
634 # Example: 7z e -r -oc:\temp\fcl_extraction\pdk1 C:\temp\Task243Test\PDK_1\build_BOM.zip build-info.xml |
|
635 |
|
636 # Extract file from 1st PDK |
|
637 $system_cmd = "7z e -r -o$working_dir1 $pdk_path1\\$build_bom_zip_file_to_extract $name_of_file_to_compare"; |
|
638 print "Exec: $system_cmd\n"; |
|
639 system($system_cmd); |
|
640 |
|
641 print "\n"; |
|
642 |
|
643 # Extract the information contained in PkgComponentAnalysisSummary.csv for path a nd package name used by PDK1. |
|
644 $system_cmd = "7z e -r -o$working_dir1 $pdk_path1\\$build_logs_zip_file_to_extract $pckg_extraction_data_file_name"; |
|
645 print "Exec: $system_cmd\n"; |
|
646 system($system_cmd); |
|
647 |
|
648 print "\n"; |
|
649 |
|
650 # Extract file from 2nd PDK |
|
651 if($loc2_contains_the_xml_csv_files_we_need==$nb_of_xml_csv_files_we_need) |
|
652 { |
|
653 my $local_file_path; |
|
654 print "We are copying the files $name_of_file_to_compare and $pckg_extraction_data_file_name from $pdk_path2 to $working_dir2\n"; |
|
655 |
|
656 print "Create directory $working_dir2\n"; |
|
657 $system_cmd = "mkdir $working_dir2"; |
|
658 print "Exec: $system_cmd\n"; |
|
659 system($system_cmd); |
|
660 |
|
661 print "We are going to copy $name_of_file_to_compare to $working_dir2\n"; |
|
662 $local_file_path = "$pdk_path2\\$bom_dir\\$name_of_file_to_compare"; |
|
663 $system_cmd = "xcopy $local_file_path $working_dir2 \/F"; |
|
664 print "Exec: $system_cmd\n"; |
|
665 system($system_cmd); |
|
666 |
|
667 print "\n"; |
|
668 |
|
669 # Extract the information contained in PkgComponentAnalysisSummary.csv for path and package name used by PDK1. |
|
670 print "We are going to copy $pckg_extraction_data_file_name to $working_dir2\n"; |
|
671 $local_file_path = "$pdk_path2\\$analysis_dir\\$pckg_extraction_data_file_name"; |
|
672 $system_cmd = "xcopy $local_file_path $working_dir2 \/F"; |
|
673 print "Exec: $system_cmd\n"; |
|
674 system($system_cmd); |
|
675 } |
|
676 else |
|
677 { |
|
678 print "We are looking for zip files, then we extract them\n"; |
|
679 $system_cmd = "7z e -r -o$working_dir2 $pdk_path2\\$build_bom_zip_file_to_extract $name_of_file_to_compare"; |
|
680 print "Exec: $system_cmd\n"; |
|
681 system($system_cmd); |
|
682 |
|
683 print "\n"; |
|
684 |
|
685 # Extract the information contained in PkgComponentAnalysisSummary.csv for path and package name used by PDK1. |
|
686 $system_cmd = "7z e -r -o$working_dir2 $pdk_path2\\$build_logs_zip_file_to_extract $pckg_extraction_data_file_name"; |
|
687 print "Exec: $system_cmd\n"; |
|
688 system($system_cmd); |
|
689 } |
|
690 |
|
691 # 2nd step is to extract the information we need from the 2 files build-info.xml |
|
692 |
|
693 # Create 2 hash arrays that will contain the name of the package as key and the value associated as MCL or FCL |
|
694 my %build_info_xml1; |
|
695 my %build_info_xml2; |
|
696 my @sorting_build_info_xml1; |
|
697 my @sorting_build_info_xml2; |
|
698 |
|
699 #my @display_hash_array; |
|
700 my $key; |
|
701 # Define the path for the files to work on |
|
702 my $path_to_pdk1_file_to_work_on="$working_dir1\\$name_of_file_to_compare"; |
|
703 my $path_to_pdk2_file_to_work_on="$working_dir2\\$name_of_file_to_compare"; |
|
704 |
|
705 print "\n"; |
|
706 |
|
707 my $count_packages=0; |
|
708 my @not_sorted_table; |
|
709 |
|
710 # Keep only what we need and keep it safe somewhere. |
|
711 # pdk1 |
|
712 %build_info_xml1 = extract_packages_and_branch_type_from_file($path_to_pdk1_file_to_work_on); |
|
713 |
|
714 print "%build_info_xml1:\n"; |
|
715 # Define the number of packages for pdk1 |
|
716 $total_packages_pdk1 = keys %build_info_xml1; |
|
717 print "\nThere is $total_packages_pdk1 packages for $pdk1_correct_name_to_use\n"; |
|
718 |
|
719 # 3rd a) step is to sort out the 2 files / table |
|
720 # Sort out the tables to facilitate the checking of the different packages |
|
721 @not_sorted_table = keys %build_info_xml1; |
|
722 |
|
723 #print "\nnot_sorted_table:\n @not_sorted_table\n"; |
|
724 |
|
725 # ascendant alphabetical sort |
|
726 @pdk1_sorting_table = sort { lc($a) cmp lc($b) } @not_sorted_table; |
|
727 |
|
728 #print "\npdk1_sorting_table :\n @pdk1_sorting_table\n"; |
|
729 |
|
730 print "\n"; |
|
731 |
|
732 # pdk2 |
|
733 %build_info_xml2 = extract_packages_and_branch_type_from_file($path_to_pdk2_file_to_work_on); |
|
734 print "%build_info_xml2:\n"; |
|
735 # Define the number of packages for pdk2 |
|
736 $total_packages_pdk2 = keys %build_info_xml2; |
|
737 print "\nThere is $total_packages_pdk2 packages for $pdk2_correct_name_to_use\n"; |
|
738 |
|
739 # 3rd b) step is to sort out the 2 files / table |
|
740 # Sort out the tables to facilitate the checking of the different packages |
|
741 @not_sorted_table = keys %build_info_xml2; |
|
742 |
|
743 #print "\nnot_sorted_table:\n @not_sorted_table\n"; |
|
744 |
|
745 # ascendant alphabetical sort |
|
746 @pdk2_sorting_table = sort { lc($a) cmp lc($b) } @not_sorted_table; |
|
747 |
|
748 #print "\npdk2_sorting_table :\n @pdk2_sorting_table\n"; |
|
749 |
|
750 print "\n"; |
|
751 |
|
752 # 4th step is to compare both data and export it to a file or something similar that is good for media wiki. |
|
753 # Compare both files to find out the difference between each packages FCL, MCL, added or deleted packages |
|
754 |
|
755 my $tab_counter1=0; |
|
756 my $tab_counter2=0; |
|
757 my $compare_2_tables; |
|
758 my $value_package_pdk1; |
|
759 my $value_package_pdk2; |
|
760 |
|
761 while (($tab_counter1 < $total_packages_pdk1) && ($tab_counter2 < $total_packages_pdk2)) # or should it be || |
|
762 { |
|
763 #print "tab_counter1=$tab_counter1, total_packages_pdk1=$total_packages_pdk1\ntab_counter2=$tab_counter2, total_packages_pdk2=$total_packages_pdk2\n"; |
|
764 #print "packages in pdk1 is $pdk1_sorting_table[$tab_counter1] and in pdk2 is $pdk2_sorting_table[$tab_counter2]\n"; |
|
765 |
|
766 # $a cmp $b |
|
767 # if $a > $b value returned is 1 |
|
768 # if $a = $b value returned is 0 |
|
769 # if $a < $b value returned is -1 |
|
770 |
|
771 $compare_2_tables = ( $pdk1_sorting_table[$tab_counter1] cmp $pdk2_sorting_table[$tab_counter2] ); |
|
772 #print "compare_2_tables=$compare_2_tables\n"; |
|
773 |
|
774 if(!$compare_2_tables) # Compare if the the packages in the tables(index) are the same or not, if $compare_2_tables=0, then equal |
|
775 { |
|
776 #print "the package is the same in pdk1_sorting_table and pdk2_sorting_table\n"; |
|
777 |
|
778 $value_package_pdk1 = $build_info_xml1{$pdk1_sorting_table[$tab_counter1]}; |
|
779 $value_package_pdk2 = $build_info_xml2{$pdk2_sorting_table[$tab_counter2]}; |
|
780 #print "value_package_pdk1=$value_package_pdk1\n"; |
|
781 #print "value_package_pdk2=$value_package_pdk2\n"; |
|
782 |
|
783 if(($value_package_pdk1 eq $mcl_cste) && ($value_package_pdk2 eq $fcl_cste)) |
|
784 { |
|
785 #print "the package was MCL and is now FCL - NEW\n"; |
|
786 $new_fcl_table[$total_new_fcl++] = $pdk1_sorting_table[$tab_counter1]; |
|
787 } |
|
788 else |
|
789 { |
|
790 if(($value_package_pdk1 eq $fcl_cste) && ($value_package_pdk2 eq $mcl_cste)) |
|
791 { |
|
792 #print "the package was FCL and is now MCL - NO MORE\n"; |
|
793 $no_more_fcl_table[$total_no_more_fcl++] = $pdk1_sorting_table[$tab_counter1]; |
|
794 } |
|
795 else |
|
796 { |
|
797 if(($value_package_pdk1 eq $fcl_cste) && ($value_package_pdk2 eq $fcl_cste)) |
|
798 { |
|
799 #print "the package was FCL and is still FCL - STILL\n"; |
|
800 $still_fcl_table[$total_still_fcl++] = $pdk1_sorting_table[$tab_counter1]; |
|
801 } |
|
802 else |
|
803 { |
|
804 #print "the package was MCL and is still MCL - VERY GOOD\n"; |
|
805 $very_good_mcl_table[$total_very_good_mcl++] = $pdk1_sorting_table[$tab_counter1]; |
|
806 } |
|
807 } |
|
808 } |
|
809 $tab_counter1++; |
|
810 $tab_counter2++; |
|
811 } |
|
812 else |
|
813 { |
|
814 # The values are not the same, therefore it must be an added or deleted package |
|
815 if($compare_2_tables<0) # If $compare_2_tables=-1, then pdk1 is smaller than pdk2, which means that it has been deleted from pdk2 |
|
816 { |
|
817 #print "the package $pdk1_sorting_table[$tab_counter1] has been deleted from pdk2\n"; |
|
818 $packages_removed_table[$total_packages_removed++]=$pdk1_sorting_table[$tab_counter1++]; |
|
819 } |
|
820 else |
|
821 { |
|
822 # If $compare_2_tables=1, then pdk1 is bigger than pdk2, which means that it has been added to pdk2 |
|
823 #print "the package $pdk2_sorting_table[$tab_counter2] has been added to pdk2\n"; |
|
824 $packages_added_table[$total_packages_added++]=$pdk2_sorting_table[$tab_counter2++]; |
|
825 } |
|
826 } |
|
827 } |
|
828 |
|
829 # Build list of files path and name based on csv file generated by the build system (analysis part) |
|
830 extract_package_detail("$working_dir2\\$pckg_extraction_data_file_name"); |
|
831 extract_package_detail("$working_dir1\\$pckg_extraction_data_file_name"); |
|
832 |
|
833 print "\nPrint all the values related to our calculations\n"; |
|
834 print "total_packages_pdk1=$total_packages_pdk1\n"; |
|
835 print "total_packages_pdk2=$total_packages_pdk2\n"; |
|
836 print "\n"; |
|
837 print "total_packages_added=$total_packages_added\n"; |
|
838 print "packages_added_table=\n"; |
|
839 #display_array_one_line_at_the_time(@packages_added_table); |
|
840 print "\n"; |
|
841 print "total_packages_removed=$total_packages_removed\n"; |
|
842 print "packages_removed_table=\n"; |
|
843 #display_array_one_line_at_the_time(@packages_removed_table); |
|
844 print "\n"; |
|
845 print "total_new_fcl=$total_new_fcl\n"; |
|
846 print "new_fcl_table=\n"; |
|
847 #display_array_one_line_at_the_time(@new_fcl_table); |
|
848 print "\n"; |
|
849 print "total_no_more_fcl=$total_no_more_fcl\n"; |
|
850 print "no_more_fcl_table=\n"; |
|
851 #display_array_one_line_at_the_time(@no_more_fcl_table); |
|
852 print "\n"; |
|
853 print "total_still_fcl=$total_still_fcl\n"; |
|
854 print "still_fcl_table=\n"; |
|
855 #display_array_one_line_at_the_time(@still_fcl_table); |
|
856 print "\n"; |
|
857 print "total_very_good_mcl=$total_very_good_mcl\n"; |
|
858 print "very_good_mcl_table=\n"; |
|
859 #display_array_one_line_at_the_time(@very_good_mcl_table); |
|
860 print "\n"; |
|
861 # Checking that the packages have been assigned properly. |
|
862 # !!!! Need to verify the formula. Not sure that is correct!!!!!! |
|
863 print "Verification for the total packages between the 2 pdks\n"; |
|
864 print "Formula used is: total_packages_pdk2 = total_packages_pdk1 + total_packages_added - total_packages_removed\n"; |
|
865 print "$total_packages_pdk2 = $total_packages_pdk1 + $total_packages_added - $total_packages_removed\n"; |
|
866 print "\n"; |
|
867 print "Formula used is: total_packages_pdk1 = total_very_good_mcl + total_new_fcl + total_no_more_fcl + total_still_fcl= total\n"; |
|
868 print "$total_packages_pdk1 = $total_very_good_mcl + $total_new_fcl + $total_no_more_fcl + $total_still_fcl = ", ($total_very_good_mcl + $total_new_fcl + $total_no_more_fcl + $total_still_fcl), "\n"; |
|
869 print "\n"; |
|
870 print "Formula used is: total_packages_pdk2 = total_very_good_mcl + total_new_fcl + total_no_more_fcl + total_still_fcl + total_packages_added = total\n"; |
|
871 print "$total_packages_pdk2 = $total_very_good_mcl + $total_new_fcl + $total_no_more_fcl + $total_still_fcl + $total_packages_added - $total_packages_removed= ", ($total_very_good_mcl + $total_new_fcl + $total_no_more_fcl + $total_still_fcl + $total_packages_added - $total_packages_removed), "\n"; |
|
872 print "\n"; |
|
873 |
|
874 # 5th step is to create a txt file ready to be used for the release notes in a media wiki format. |
|
875 open(FCLCOMPARISONFILE, ">$path_to_file_to_publish"); # !!!!! First time we are accessing the file, therefore create it or replace it, AFTR THAT WE NEED TO APPEND IT ONLY!!!!! |
|
876 |
|
877 my $val; |
|
878 |
|
879 # Enter the beginning of the section for general information about the pdk and it's predecessor. |
|
880 print FCLCOMPARISONFILE <<"EOT"; |
|
881 == Packages == |
|
882 |
|
883 This section is about general information on the packages included in the platform. |
|
884 |
|
885 This is an analysis between '''$pdk2_correct_name_to_use''' and '''$pdk1_correct_name_to_use''' |
|
886 |
|
887 EOT |
|
888 |
|
889 |
|
890 print FCLCOMPARISONFILE "Number total of packages in $pdk1_correct_name_to_use is: '''$total_packages_pdk1'''\n\n"; |
|
891 print FCLCOMPARISONFILE "Number total of packages in $pdk2_correct_name_to_use is: '''$total_packages_pdk2'''\n\n"; |
|
892 |
|
893 print FCLCOMPARISONFILE "=== Packages added ===\n\n"; |
|
894 print FCLCOMPARISONFILE "Number total of packages added in $pdk2_correct_name_to_use is: '''$total_packages_added'''\n\n"; |
|
895 foreach $val (@packages_added_table) |
|
896 { |
|
897 if($pckg_name_array{$val}) |
|
898 { |
|
899 print FCLCOMPARISONFILE "''' $pckg_name_array{$val} ($pckg_path_name_array{$val}) '''\n\n"; |
|
900 } |
|
901 else |
|
902 { |
|
903 print FCLCOMPARISONFILE "''' $val ($pckg_path_name_array{$val}) '''\n\n"; |
|
904 } |
|
905 } |
|
906 |
|
907 print FCLCOMPARISONFILE "=== Packages removed ===\n\n"; |
|
908 print FCLCOMPARISONFILE "''' Number total of packages removed in $pdk2_correct_name_to_use is: $total_packages_removed'''\n\n"; |
|
909 foreach $val (@packages_removed_table) |
|
910 { |
|
911 if($pckg_name_array{$val}) |
|
912 { |
|
913 print FCLCOMPARISONFILE "''' $pckg_name_array{$val} ($pckg_path_name_array{$val}) '''\n\n"; |
|
914 } |
|
915 else |
|
916 { |
|
917 print FCLCOMPARISONFILE "''' $val ($pckg_path_name_array{$val}) '''\n\n"; |
|
918 } |
|
919 } |
|
920 |
|
921 # Enter the beginning of the section for the FCL |
|
922 print FCLCOMPARISONFILE <<"EOT"; |
|
923 == FCLs == |
|
924 |
|
925 '''$pdk2_correct_name_to_use''' was built using the FCL versions of the packages listed below: for each one we list the changes in the FCL which are not in the MCL. |
|
926 |
|
927 The previous PDK also involved some FCLs, so we indicate which problems are now fixed in the MCL, and which FCLs are new to this build. |
|
928 |
|
929 Cloning the source from Mercurial is made more awkward by using a mixture of MCLs and FCLs, but we provide a tool to help - see [[How_to_build_the_Platform#Automatic_Mercurial_Clone]] for details. |
|
930 |
|
931 EOT |
|
932 |
|
933 # Packages that were on MCL and that are now on FCL |
|
934 foreach $val (@new_fcl_table) |
|
935 { |
|
936 if($pckg_name_array{$val}) |
|
937 { |
|
938 print FCLCOMPARISONFILE "=== $pckg_name_array{$val} ($pckg_path_name_array{$val}) -- NEW ===\n\n"; |
|
939 # TO DO!!!! |
|
940 # Needs to be recovered from Mercurial. How???? |
|
941 #[http://developer.symbian.org/bugs/show_bug.cgi?id=156 Bug 156]: Add a missing bld.inf, to renable compilation of the package |
|
942 #[http://developer.symbian.org/bugs/show_bug.cgi?id=197 Bug 197]: PSAlgorithmInternalCRKeys.h is missing |
|
943 } |
|
944 else |
|
945 { |
|
946 print FCLCOMPARISONFILE "=== $val ($pckg_path_name_array{$val}) -- NEW ===\n\n"; |
|
947 } |
|
948 } |
|
949 |
|
950 # Packages that were on FCL and that are now on FCL |
|
951 foreach $val (@still_fcl_table) |
|
952 { |
|
953 if($pckg_name_array{$val}) |
|
954 { |
|
955 print FCLCOMPARISONFILE "=== $pckg_name_array{$val} ($pckg_path_name_array{$val}) ===\n\n"; |
|
956 } |
|
957 else |
|
958 { |
|
959 print FCLCOMPARISONFILE "=== $val ($pckg_path_name_array{$val}) ===\n\n"; |
|
960 } |
|
961 } |
|
962 |
|
963 print FCLCOMPARISONFILE "=== FCLs used in $pdk1_correct_name_to_use but not needed in $pdk2_correct_name_to_use ===\n\n"; |
|
964 |
|
965 foreach $val (@no_more_fcl_table) |
|
966 { |
|
967 if($pckg_name_array{$val}) |
|
968 { |
|
969 print FCLCOMPARISONFILE "''' $pckg_name_array{$val} ($pckg_path_name_array{$val}) '''\n\n"; |
|
970 } |
|
971 else |
|
972 { |
|
973 print FCLCOMPARISONFILE "''' $val ($pckg_path_name_array{$val}) '''\n\n"; |
|
974 } |
|
975 } |
|
976 |
|
977 # Packages were on MCL and they are still on MCL. |
|
978 foreach $val (@very_good_mcl_table) |
|
979 { |
|
980 #print "Value for package $val is: $pckg_name_array{$val}\n"; |
|
981 if($pckg_name_array{$val}) |
|
982 { |
|
983 #print "There is a real name for the package: ($pckg_name_array{$val})\n"; |
|
984 #print FCLCOMPARISONFILE "=== $pckg_name_array{$val} ($pckg_path_name_array{$val}) -- VERY GOOD ===\n"; |
|
985 } |
|
986 else |
|
987 { |
|
988 #print "There is not a real name for the package: ($pckg_name_array{$val})\n"; |
|
989 #print FCLCOMPARISONFILE "=== $val ($pckg_path_name_array{$val}) -- VERY GOOD ===\n"; |
|
990 } |
|
991 } |
|
992 |
|
993 close(FCLCOMPARISONFILE); |
|
994 |
|
995 #print "Path for each packages:\n"; |
|
996 #display_hash_array_one_line_at_the_time(%pckg_path_name_array); |
|
997 #print "\n"; |
|
998 #print "Real name for each packages:\n"; |
|
999 #display_hash_array_one_line_at_the_time(%pckg_name_array); |
|
1000 #print "\n"; |
|
1001 #print "Branch type for each packages:\n"; |
|
1002 #display_hash_array_one_line_at_the_time(%build_info_xml2); |
|
1003 #print "\n"; |
|
1004 |
|
1005 # Used to verify the differences between build_info.xml and PkgComponentAnalysisSummary.csv because not the same number of packages. |
|
1006 #print "Packages list from build-info.xml:\n"; |
|
1007 #my @local_array_key_extraction; |
|
1008 #my @local_array_key_extraction_sorted; |
|
1009 #@local_array_key_extraction = keys (%build_info_xml2); |
|
1010 #@local_array_key_extraction_sorted = sort { lc($a) cmp lc($b) } @local_array_key_extraction; |
|
1011 #display_array_one_line_at_the_time(@local_array_key_extraction_sorted); |
|
1012 #print "\n"; |
|
1013 #print "Packages list from csv file:\n"; |
|
1014 #my @local_array_key_extraction; |
|
1015 #my @local_array_key_extraction_sorted; |
|
1016 #@local_array_key_extraction = keys (%pckg_name_array); |
|
1017 #@local_array_key_extraction_sorted = sort { lc($a) cmp lc($b) } @local_array_key_extraction; |
|
1018 #display_array_one_line_at_the_time(@local_array_key_extraction_sorted); |
|
1019 |
|
1020 |
|
1021 # 6th step is to export that txt file the appropriate location. |
|
1022 # That could be the location from where we launched the script! |
|
1023 print "\nYou will find the file with all the information you need for the releases note, here: $path_to_file_to_publish\n\n"; |
|
1024 |
|
1025 # Cleanup the mess!!! |
|
1026 #pause_script(); # Temporary until script is finished!!!!!! |
|
1027 |
|
1028 $system_cmd = "rmdir /S /Q $working_dir"; |
|
1029 print "Exec: $system_cmd\n"; |
|
1030 system($system_cmd); |
|
1031 |
|
1032 exit(0); |
|
1033 ## |
|
1034 ### End of the program!!! |
|
1035 ## |
|
1036 |
|
1037 |
|
1038 # |
|
1039 # Functions section!!!!! |
|
1040 # |
|
1041 |
|
1042 |
|
1043 # If no parameters entered or help selected, display help |
|
1044 sub helpme |
|
1045 { |
|
1046 print "\nfct: helpme\n"; |
|
1047 |
|
1048 print "Generate FCLs details between 2 PDKs to be included as part of the release notes\n"; |
|
1049 print "Default location for PDKs is: $default_pdk_loc\n"; |
|
1050 print "Usage: perl fcls4releasenotes.pl --input_data1=x --input_data2=y\n"; |
|
1051 print "Where input_data1 and input_data2 could be pdknb1 or pdknb2 or pdkloc1 or pdkloc2 or pdkname1 or pdkname2\n"; |
|
1052 print "Where pdknb is the PDK number, for example 2.0.e\n"; |
|
1053 print "Where pdkloc is the root location where your file $build_bom_zip_file_to_extract is. For ex: \\\\bishare\\releases\\PDK_2.0.e\\ or c:\\temp\\myPDK\\\n"; |
|
1054 print "Where pdkname is the full name of the PDK, like for ex PDK_candidate_2.0.d_flat\n"; |
|
1055 print "\nNotes:\n"; |
|
1056 print "\tParameter names with 1 at the end (pdknb1, pdkname1, pdkloc1) are set for the oldest PDK to use (PDK1)\n"; |
|
1057 print "\tParameter names with 2 at the end (pdknb2, pdkname2, pdkloc2) are set for the newest PDK to use (PDK2)\n"; |
|
1058 print "\tIf you try to use for example pdknb2 and pdkname2 or pdkloc1 and pdknb1 the result is not guaranted to be correct!!!! as one will be set as PDK1 and the other as PDK2, but which order????\n"; |
|
1059 print "\tThe difference is done as follow PDK2 - PDK1\n"; |
|
1060 print "\n"; |
|
1061 print "\nTypical command lines from script location:\n"; |
|
1062 print "\t<perl fcls4releasenotes.pl --pdknb1=2.0.e --pdkloc2=c:\\temp\\myPDK\\>\n"; |
|
1063 print "\t<perl fcls4releasenotes.pl --pdkname1=PDK_2.0.e --pdknb2=2.0.e>\n"; |
|
1064 print "\t<perl fcls4releasenotes.pl --pdknb2=2.0.d --pdknb1=2.0.e>\n"; |
|
1065 print "\t<perl fcls4releasenotes.pl help>\n"; |
|
1066 #print "\t<perl fcls4releasenotes.pl validpdks>\n"; |
|
1067 |
|
1068 list_pdks_at_default_location(); |
|
1069 |
|
1070 exit(0); |
|
1071 } |
|
1072 # End section related to help |
|
1073 |
|
1074 # Extract list of PDKs that are in the default location. |
|
1075 sub list_pdks_at_default_location |
|
1076 { |
|
1077 print "\nfct: list_pdks_at_default_location\n"; |
|
1078 |
|
1079 # Do a dir of the default location |
|
1080 print "List of directories in the default location $default_pdk_loc\n"; |
|
1081 extract_dir_default_loc(); |
|
1082 |
|
1083 # Extract all the PDKs that have the pattern PDK_ |
|
1084 print "All available PDKS in the default location $default_pdk_loc that have the pattern $pdk_start_pattern\n"; |
|
1085 extract_pdk_in_default_loc(); |
|
1086 |
|
1087 # Extract all the PDKs that have the file build_BOM.zip |
|
1088 print "All available PDKS in the default location $default_pdk_loc that contains the zip file $build_bom_zip_file_to_extract\n"; |
|
1089 extract_pdk_with_valid_zip_in_default_loc(); |
|
1090 |
|
1091 } |
|
1092 |
|
1093 # Generates list of directories in the default location used for the storage of the PDKs |
|
1094 sub extract_dir_default_loc |
|
1095 { |
|
1096 print "\nfct: extract_dir_default_loc\n"; |
|
1097 |
|
1098 # Get the list of directories in the default location |
|
1099 opendir(DEFAULT_DIR, $default_pdk_loc); |
|
1100 @directories_list_default_location = readdir(DEFAULT_DIR); |
|
1101 close(DEFAULT_DIR); |
|
1102 |
|
1103 $nb_dir_in_default_loc = scalar(@directories_list_default_location); |
|
1104 |
|
1105 print "nb_dir_in_default_loc=$nb_dir_in_default_loc\n"; |
|
1106 #display_array_one_line_at_the_time(@directories_list_default_location); |
|
1107 } |
|
1108 |
|
1109 # Establish the list of directories that are an actual PDK |
|
1110 sub extract_pdk_in_default_loc |
|
1111 { |
|
1112 print "\nfct: extract_pdk_in_default_loc\n"; |
|
1113 |
|
1114 my $var; |
|
1115 $nb_pdks_in_default_loc=0; |
|
1116 print "pdk_start_pattern = $pdk_start_pattern\n"; |
|
1117 |
|
1118 foreach $var (@directories_list_default_location) |
|
1119 { |
|
1120 if($var =~ /^$pdk_start_pattern+/) |
|
1121 { |
|
1122 #print "$var\n"; |
|
1123 $pdk_dir_list_in_default_location[$nb_pdks_in_default_loc++] = $var; |
|
1124 } |
|
1125 #else |
|
1126 #{ |
|
1127 #print "Not a PDK!!!!\n"; |
|
1128 #} |
|
1129 } |
|
1130 print "There is $nb_pdks_in_default_loc PDKs in the default location $default_pdk_loc\n"; |
|
1131 |
|
1132 print "This is the list of PDKs that are in the default location $default_pdk_loc\n"; |
|
1133 #display_array_one_line_at_the_time(@pdk_dir_list_in_default_location); |
|
1134 } |
|
1135 |
|
1136 # Establish the list of PDK directories with a valid zip file to do the test |
|
1137 sub extract_pdk_with_valid_zip_in_default_loc |
|
1138 { |
|
1139 print "\nfct: extract_pdk_with_valid_zip_in_default_loc\n"; |
|
1140 |
|
1141 my $var1; |
|
1142 my $var2; |
|
1143 my $path_to_find_zip = ""; |
|
1144 my @read_pdk_directory=(); |
|
1145 |
|
1146 $nb_pdks_with_valid_zip_in_default_loc=0; |
|
1147 |
|
1148 print "build_bom_zip_file_to_extract=$build_bom_zip_file_to_extract\n"; |
|
1149 |
|
1150 foreach $var1 (@pdk_dir_list_in_default_location) |
|
1151 { |
|
1152 $path_to_find_zip=$default_pdk_loc; |
|
1153 |
|
1154 $path_to_find_zip .= $var1; |
|
1155 #print "path_to_find_zip=$path_to_find_zip\n"; |
|
1156 |
|
1157 # Get the list of directories in the default location |
|
1158 opendir(PDK_DIR, $path_to_find_zip); |
|
1159 @read_pdk_directory = readdir(PDK_DIR); |
|
1160 close(PDK_DIR); |
|
1161 |
|
1162 foreach $var2 (@read_pdk_directory) |
|
1163 { |
|
1164 if($var2 =~ /$build_bom_zip_file_to_extract$/) |
|
1165 { |
|
1166 #print "$var2\n"; |
|
1167 $pdks_with_valid_zip_in_default_loc[$nb_pdks_with_valid_zip_in_default_loc++] = $var1; |
|
1168 } |
|
1169 #else |
|
1170 #{ |
|
1171 #print "Doesn't contain $build_bom_zip_file_to_extract!!!!\n"; |
|
1172 #} |
|
1173 } |
|
1174 } |
|
1175 print "There is $nb_pdks_with_valid_zip_in_default_loc PDKs with a valid $build_bom_zip_file_to_extract zip in the default location $default_pdk_loc\n"; |
|
1176 |
|
1177 print "This is the list of PDKs that have a zip file called $build_bom_zip_file_to_extract in the default location $default_pdk_loc\n"; |
|
1178 display_array_one_line_at_the_time(@pdks_with_valid_zip_in_default_loc); |
|
1179 } |
|
1180 |
|
1181 # Function created to pause the script to allow analysis and debug of the script. |
|
1182 # Will require the user to press enter to carry on the execution of the script. |
|
1183 sub pause_script |
|
1184 { |
|
1185 print "\nfct: pause_script\n"; |
|
1186 my $local_system_cmd = "pause"; |
|
1187 print "Exec: $local_system_cmd\n"; |
|
1188 system($local_system_cmd); |
|
1189 } |
|
1190 |
|
1191 |
|
1192 # This function is used to extract the name of the package and the type |
|
1193 sub extract_packages_and_branch_type_from_file |
|
1194 { |
|
1195 # 1 Parameters passed, the path to the file to be viewed |
|
1196 my ($file_to_work_on) = @_; |
|
1197 |
|
1198 print "\nfct: extract_packages_and_branch_type_from_file\n"; |
|
1199 |
|
1200 print "$file_to_work_on\n"; |
|
1201 |
|
1202 my %local_hash_array; |
|
1203 #my @local_hash_array; |
|
1204 my $local_key; |
|
1205 |
|
1206 my $package=""; |
|
1207 my $type_of_branch=""; |
|
1208 |
|
1209 #@hash_array_to_display = %local_hash_array; |
|
1210 #print "%local_hash_array before starting = @hash_array_to_display\n"; |
|
1211 |
|
1212 # Open file |
|
1213 open(FILETOWORKON , $file_to_work_on); |
|
1214 |
|
1215 # Extract data from file |
|
1216 my @local_array = <FILETOWORKON>; |
|
1217 #print "local_array= @local_array\n"; |
|
1218 |
|
1219 # Close file |
|
1220 close(FILETOWORKON); |
|
1221 |
|
1222 |
|
1223 my $extracted_line; |
|
1224 |
|
1225 # Go line by line |
|
1226 foreach $extracted_line (@local_array) |
|
1227 { |
|
1228 #print "\nextracted_line is: $extracted_line"; # no need to add \\n as it's part of the line displayed. |
|
1229 |
|
1230 if ($extracted_line =~ /$starting_pattern_for_xml_extraction/) |
|
1231 { |
|
1232 #print "The line extracted is our starting pattern $starting_pattern_for_xml_extraction\n"; |
|
1233 $extraction_from_xml_is_allowed=1; |
|
1234 } |
|
1235 else |
|
1236 { |
|
1237 if ($extracted_line =~ /$ending_pattern_for_xml_extraction/) |
|
1238 { |
|
1239 #print "The line extracted is our ending pattern $ending_pattern_for_xml_extraction\n"; |
|
1240 $extraction_from_xml_is_allowed=0; |
|
1241 } |
|
1242 } |
|
1243 #print "extraction_from_xml_is_allowed=$extraction_from_xml_is_allowed\n"; |
|
1244 |
|
1245 if($extraction_from_xml_is_allowed) |
|
1246 { |
|
1247 #print "We are looking to extract the package and branch type from the line extracted\n"; |
|
1248 |
|
1249 # Decode the line |
|
1250 |
|
1251 # Decode the branch type |
|
1252 if($extracted_line =~ /$branch_type_extraction_pattern/) |
|
1253 { |
|
1254 $type_of_branch=$1; |
|
1255 |
|
1256 # Decode the package because there is a branch type in the line extracted! |
|
1257 if ($extracted_line =~ m,$package_extraction_pattern,) |
|
1258 { |
|
1259 $package=$1; |
|
1260 } |
|
1261 #print "package is $package and type_of_branch is $type_of_branch\n"; |
|
1262 $local_hash_array{$package}=$type_of_branch; |
|
1263 |
|
1264 } |
|
1265 else |
|
1266 { |
|
1267 #print "The extracted line doesn't contain $look_for_mcl or $look_for_fcl, therefore we need to skip it!\n"; |
|
1268 } |
|
1269 } |
|
1270 } |
|
1271 |
|
1272 # Check the contain of the hash array to make sure that we have extracted the data as expected. To check against the actual file. |
|
1273 |
|
1274 # Option 1: Display all in one line |
|
1275 #@hash_array_to_display = %local_hash_array; |
|
1276 # Print "%local_hash_array when extraction is finished = @hash_array_to_display\n"; |
|
1277 |
|
1278 # Option 2: Print 1 key with 1 value by line |
|
1279 #foreach $local_key (keys(%local_hash_array)) |
|
1280 #{ |
|
1281 # print "$local_key = $local_hash_array{$local_key}\n"; |
|
1282 #} |
|
1283 |
|
1284 # Return hash array containing all the packages and branch type associated |
|
1285 return (%local_hash_array); |
|
1286 } |
|
1287 |
|
1288 # Function used to extract all the data from the csv file about the different packages (name, path and real name) |
|
1289 sub extract_package_detail |
|
1290 { |
|
1291 # 1 Parameters passed, the path to the file to be viewed |
|
1292 my ($file_to_work_on) = @_; |
|
1293 |
|
1294 print "\nfct: extract_package_detail\n"; |
|
1295 |
|
1296 print "$file_to_work_on\n"; |
|
1297 |
|
1298 my @local_array; |
|
1299 |
|
1300 # Open file |
|
1301 open(FILETOWORKON , $file_to_work_on); |
|
1302 |
|
1303 # Extract data from file |
|
1304 my @local_array = <FILETOWORKON>; |
|
1305 #print "build_bom_local_array= @build_bom_local_array\n"; |
|
1306 |
|
1307 # Close file |
|
1308 close(FILETOWORKON); |
|
1309 |
|
1310 my $extracted_line; |
|
1311 |
|
1312 # Create a table with the path for each package using a hash array |
|
1313 my $pckg_name_extraction_pattern = "^sf\/[\\w]*\/([\\w]*)"; |
|
1314 my $pckg_path_extraction_pattern = "^(sf[\W\w]*[^,]+),"; |
|
1315 my $pckg_real_name_extraction_pattern = ",[\\s]+([\\w\\s]*),[\\s]+[\\w\\s]*\$"; |
|
1316 my $pckg_name=""; |
|
1317 my $pckg_path=""; |
|
1318 my $pckg_real_name=""; |
|
1319 |
|
1320 #Typical lines to decode |
|
1321 #sf/app/helps,SFL,sf/app/helps/symhelp/helpmodel/group/bld.inf,OK, Help Apps, Help |
|
1322 #sf/app/java,SFL,sf/app/java/java_plat/group/bld.inf,OK, , |
|
1323 #sf/app/helps,SFL,sf/app/helps/symhelp/helpmodel/group/bld.inf,OK, Help Apps, Help |
|
1324 #sf/app/helps, |
|
1325 #SFL, |
|
1326 #sf/app/helps/symhelp/helpmodel/group/bld.inf, |
|
1327 #OK, |
|
1328 # Help Apps, |
|
1329 # Help |
|
1330 |
|
1331 #sf/app/java,SFL,sf/app/java/java_plat/group/bld.inf,OK, , |
|
1332 #sf/app/java, |
|
1333 #SFL, |
|
1334 #sf/app/java/java_plat/group/bld.inf, |
|
1335 #OK, |
|
1336 # , |
|
1337 # |
|
1338 |
|
1339 # Go line by line |
|
1340 |
|
1341 foreach $extracted_line (@local_array) |
|
1342 { |
|
1343 #print "\nextracted_line is: $extracted_line"; # no need to add \\n as it's part of the line displayed. |
|
1344 |
|
1345 if($extracted_line =~ m;$pckg_name_extraction_pattern;) |
|
1346 { |
|
1347 $pckg_name = $1; |
|
1348 #print "Pckg name is: $pckg_name\n"; |
|
1349 |
|
1350 #print "Is $pckg_name already exist in the hash array?: $pckg_path_name_array{$pckg_name}\n"; |
|
1351 |
|
1352 if(!$pckg_path_name_array{$pckg_name}) # Check if package is not already in the table to avoid duplicates |
|
1353 { |
|
1354 #print "$pckg_name is not in the hash array, we need to add it\n"; |
|
1355 if($extracted_line =~ m;$pckg_path_extraction_pattern;) |
|
1356 { |
|
1357 $pckg_path = $1; |
|
1358 #print "Pckg path is: $pckg_path\n"; |
|
1359 } |
|
1360 if($extracted_line =~ m;$pckg_real_name_extraction_pattern;) |
|
1361 { |
|
1362 $pckg_real_name = $1; |
|
1363 #print "Pckg real name is: $pckg_real_name\n"; |
|
1364 } |
|
1365 # fill the tables |
|
1366 $pckg_path_name_array{$pckg_name} = $pckg_path; |
|
1367 $pckg_name_array{$pckg_name} = $pckg_real_name; |
|
1368 } |
|
1369 } |
|
1370 } |
|
1371 |
|
1372 my $local_value=""; |
|
1373 my @local_array_sorted; |
|
1374 |
|
1375 @local_array=keys (%pckg_path_name_array); |
|
1376 @local_array_sorted = sort { lc($a) cmp lc($b) } @local_array; |
|
1377 |
|
1378 # print "\n"; |
|
1379 # my $counter_to_remove=0; |
|
1380 # foreach $local_value (@local_array_sorted) |
|
1381 # { |
|
1382 #print "$counter_to_remove: The path for package $local_value is: $pckg_path_name_array{$local_value}\n"; |
|
1383 #print "$counter_to_remove:The real name for package $local_value is: $pckg_name_array{$local_value}\n"; |
|
1384 #print "$counter_to_remove: local_array_sorted[$counter_to_remove]:$local_array_sorted[$counter_to_remove]\n"; |
|
1385 #print "$local_array_sorted[$counter_to_remove]\n"; |
|
1386 #$counter_to_remove++; |
|
1387 # } |
|
1388 } |
|
1389 |
|
1390 # Function used to display one line at the time for an array |
|
1391 sub display_array_one_line_at_the_time |
|
1392 { |
|
1393 my (@table_to_display_one_line_at_the_time) = @_; |
|
1394 |
|
1395 #print "\nfct: display_array_one_line_at_the_time\n"; # Not displayed because you could think that is part of the table. As well it's easier to copy the name of the table and the contain wihtout the need to remove something. |
|
1396 |
|
1397 my $line_to_display; |
|
1398 |
|
1399 foreach $line_to_display (@table_to_display_one_line_at_the_time) |
|
1400 { |
|
1401 print "$line_to_display\n"; |
|
1402 } |
|
1403 } |
|
1404 |
|
1405 # Function used to display one line at the time for an hash array |
|
1406 sub display_hash_array_one_line_at_the_time |
|
1407 { |
|
1408 my (%hash_array_to_display_one_line_at_the_time) = @_; |
|
1409 |
|
1410 my @local_keys_array; |
|
1411 my @local_keys_array_sorted; |
|
1412 |
|
1413 #print "\nfct: display_hash_array_one_line_at_the_time\n"; # Not displayed because you could think that is part of the table. As well it's easier to copy the name of the table and the contain wihtout the need to remove something. |
|
1414 |
|
1415 my $line_to_display; |
|
1416 |
|
1417 @local_keys_array = keys (%hash_array_to_display_one_line_at_the_time); |
|
1418 @local_keys_array_sorted = sort { lc($a) cmp lc($b) } @local_keys_array; |
|
1419 |
|
1420 foreach $line_to_display (@local_keys_array_sorted) |
|
1421 { |
|
1422 print "$line_to_display = $hash_array_to_display_one_line_at_the_time{$line_to_display}\n"; |
|
1423 } |
|
1424 } |
|
1425 |
|
1426 # PDKs with build_bom.zip file in the default PDKs location 14-09-2009 |
|
1427 #Z:\Releases\PDK_2.0.e |
|
1428 #Z:\Releases\PDK_candidate_2.0.d_flat |
|
1429 #Z:\Releases\PDK_candidate_2.0e_FCL_27.78 |
|