| #!/usr/bin/perl | |
| # | |
| # Copyright Statement: | |
| # -------------------- | |
| # This software is protected by Copyright and the information contained | |
| # herein is confidential. The software may not be copied and the information | |
| # contained herein may not be used or disclosed except with the written | |
| # permission of MediaTek Inc. (C) 2005 | |
| # | |
| # BY OPENING THIS FILE, BUYER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES | |
| # THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE") | |
| # RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO BUYER ON | |
| # AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES, | |
| # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF | |
| # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT. | |
| # NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE | |
| # SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR | |
| # SUPPLIED WITH THE MEDIATEK SOFTWARE, AND BUYER AGREES TO LOOK ONLY TO SUCH | |
| # THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. MEDIATEK SHALL ALSO | |
| # NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE RELEASES MADE TO BUYER'S | |
| # SPECIFICATION OR TO CONFORM TO A PARTICULAR STANDARD OR OPEN FORUM. | |
| # | |
| # BUYER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND CUMULATIVE | |
| # LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE, | |
| # AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE, | |
| # OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY BUYER TO | |
| # MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE. | |
| # | |
| # THE TRANSACTION CONTEMPLATED HEREUNDER SHALL BE CONSTRUED IN ACCORDANCE | |
| # WITH THE LAWS OF THE STATE OF CALIFORNIA, USA, EXCLUDING ITS CONFLICT OF | |
| # LAWS PRINCIPLES. ANY DISPUTES, CONTROVERSIES OR CLAIMS ARISING THEREOF AND | |
| # RELATED THERETO SHALL BE SETTLED BY ARBITRATION IN SAN FRANCISCO, CA, UNDER | |
| # THE RULES OF THE INTERNATIONAL CHAMBER OF COMMERCE (ICC). | |
| # | |
| # | |
| #***************************************************************************** | |
| # | |
| # Filename: | |
| # --------- | |
| # hExpand.pl | |
| # | |
| # Description: | |
| # ------------ | |
| # this script is used to expand files included by #include. | |
| # | |
| # Auther: | |
| # ------- | |
| # Shinn Lin | |
| # | |
| # Note: | |
| # ----- | |
| # | |
| # Log: | |
| # ----- | |
| # 2008/06/30 Create. | |
| # 2010/01/29 Correct header exclusion (all filename to lower case) | |
| # | |
| #BEGIN { push @INC, "pcore/" , 'U:\\00MyPerlLib'} # add additional library path | |
| #package XXX; | |
| use strict; | |
| #****************************************************************************** | |
| # Global Data | |
| #****************************************************************************** | |
| my $lineRedirect = 1; # add '#line' in expanded file to redirect warning/error msg | |
| my $g_removeTempFile = 1; | |
| # these two only work when $lineRedirect = 0 | |
| my $removeCommentOrNot = 1; # for correct #line redirect, should disable this | |
| my $removeConsecutiveEmpty = 0; # no much size difference | |
| my $g_nodeThreshold = 40; | |
| my @targetFileList = (); | |
| my $g_prjName = ''; | |
| my $g_mcuPath = "."; | |
| my $g_outputPath = "."; | |
| my $logFilename = "hExpand.log"; | |
| my $logPath = "."; | |
| my $logFileHandle; | |
| my $valSuccess = 0; | |
| my $valAlreadyIncluded = 1; | |
| my $valFileNotFound = 2; | |
| my $valRecursiveInclude = 3; | |
| my $valOthers = 4; | |
| my $idxPath = 1; | |
| my $idxAlwaysInc = 2; | |
| my $idxIncluded = 3; | |
| my %g_incInfo = (); # { filename => [1] path | |
| # [2] always include or not | |
| # [3] included or not} | |
| my @g_incPath = (); | |
| my %g_targetFileHash = (); | |
| my @nonExpandList = ("ps_trace.h"); | |
| my %g_nonExpandList = (); | |
| my @incDeeps = (); | |
| my %incTreeHash = (); | |
| my $g_totalIncCount = 0; | |
| my $g_forceNotExpand = 0; # if set to 1, force NOT to expand #include | |
| my $foundFileList = {}; # found list | |
| my $notFoundFileList = {}; # not found list | |
| #****************************************************************************** | |
| # Export Function | |
| #****************************************************************************** | |
| #****************************************************************************** | |
| # Internal Data | |
| #****************************************************************************** | |
| #****************************************************************************** | |
| # Program Start | |
| #****************************************************************************** | |
| if (@ARGV) | |
| { | |
| ($g_mcuPath, $g_outputPath, $g_prjName, @targetFileList) = @ARGV; | |
| } | |
| else | |
| { | |
| die "\nUsage: 'hExpand.pl <mcu path> <output path> <prj name> <target filename>'\n". | |
| " e.g. hExpand.pl \\server\\w08.20\\mcu \\server\\w08.20\\mcu\\expandOutput superman29v31_demo mmi_include.h\n"; | |
| } | |
| open($logFileHandle, ">$logPath\\$logFilename") or die "can't open $logPath\\$logFilename!\n"; | |
| printBoth("\n[start hExpand]\n\n"); | |
| &timeCheck(); | |
| # prepare non-expand list | |
| foreach my $file (@nonExpandList) | |
| { | |
| $g_nonExpandList{lc $file} = 1; | |
| } | |
| my @incMods = ("plutommi", "kal"); | |
| &readCompileInfo(\@incMods, \@g_incPath, 0); | |
| $g_targetFileHash{$_} = 1 foreach (@targetFileList); | |
| foreach my $targetFile (@targetFileList) | |
| { | |
| printLog("[$targetFile]\n"); | |
| my @resultData = (); | |
| @incDeeps = (); | |
| %incTreeHash = (); | |
| $g_totalIncCount = 0; | |
| %g_incInfo = (); | |
| my $fileHandle; | |
| my $outputFile = "$g_outputPath\\$targetFile"; | |
| open($fileHandle, ">$outputFile"); | |
| # copy original header file to output folder | |
| copyOriginalHeader($targetFile); | |
| # add compile option for MoDIS | |
| print $fileHandle "#ifdef WIN32\n"; | |
| print $fileHandle "#include \"_".$targetFile."\"\n"; | |
| print $fileHandle "#else\n"; | |
| my $nodeCount = 0; | |
| &expandInc($fileHandle, $targetFile, 0, \$nodeCount); | |
| #&findMismatchIf(\@resultData); | |
| # end of compile option for MoDIS | |
| print $fileHandle "#endif /* WIN32 */\n\n"; | |
| close($fileHandle); | |
| printBoth("\n[hExpand.pl] $outputFile generated!\n\n"); | |
| &timeCheck(); | |
| } | |
| close($logFileHandle); # log file | |
| exit 0; | |
| #****************************************************************************** | |
| # Internal Function | |
| #****************************************************************************** | |
| #****************************************************************************** | |
| # FUNCTION | |
| # copyOriginalHeader | |
| # DESCRIPTION | |
| # xxx | |
| # PARAMETERS | |
| # xxx | |
| # RETURNS | |
| # xxx | |
| #****************************************************************************** | |
| sub copyOriginalHeader() | |
| { | |
| my ($incFile) = @_; | |
| my $incPath = &searchIncPath($incFile, \@g_incPath); | |
| open(hFile, "<$incPath\\$incFile") or die "can't open $incPath\\$incFile\n"; | |
| my @fileData = <hFile>; | |
| close(hFile); | |
| open(hFile, ">$g_outputPath\\_".$incFile) or die "can't open $g_outputPath\\_".$incFile."\n"; | |
| # add redirect info | |
| my $incPrintPathName = "$incPath\\$incFile"; | |
| $incPrintPathName =~ s/\\/\\\\/g; | |
| print hFile "#line 0 \"$incPrintPathName\"\n" if ($lineRedirect); | |
| print hFile join('', @fileData); | |
| close(hFile); | |
| } | |
| #****************************************************************************** | |
| # FUNCTION | |
| # expandInc | |
| # DESCRIPTION | |
| # xxx | |
| # PARAMETERS | |
| # xxx | |
| # RETURNS | |
| # 0: success, 1: already included, 2: file not found, 3: recursive include | |
| #****************************************************************************** | |
| sub expandInc() | |
| { | |
| my ($fileHandle, $incFile, $alwaysExpand, $nodeCount_ref) = @_; | |
| $incFile = lc $incFile; | |
| my $incPath = ""; | |
| my @fileData = (); | |
| my $printStr; | |
| printLog("[$incFile] check if include required\n"); | |
| if (!(defined $g_incInfo{$incFile})) | |
| { | |
| # get path for every file's 1st entry | |
| $incPath = &searchIncPath($incFile, \@g_incPath); | |
| if ($incPath eq "") | |
| { | |
| printLog("[Warning] can't find path for $incFile\n"); | |
| return $valFileNotFound; | |
| } | |
| $g_incInfo{$incFile}[$idxPath] = $incPath; | |
| # check for include condition | |
| open(hFile, "<$incPath\\$incFile") or die "can't open $incPath\\$incFile\n"; | |
| @fileData = <hFile>; | |
| close(hFile); | |
| $g_incInfo{$incFile}[$idxIncluded] = 0; | |
| if (&getIncWrapper(\@fileData) eq "") | |
| { | |
| $g_incInfo{$incFile}[$idxAlwaysInc] = 1; | |
| } | |
| else | |
| { | |
| $g_incInfo{$incFile}[$idxAlwaysInc] = 0; | |
| } | |
| printLog("[$incFile] ifAlwaysInc = ".$g_incInfo{$incFile}[$idxAlwaysInc]."\n"); | |
| } | |
| else | |
| { | |
| # just return if this inc is already included | |
| return $valAlreadyIncluded if ($g_incInfo{$incFile}[$idxIncluded]); | |
| $incPath = $g_incInfo{$incFile}[$idxPath]; | |
| } | |
| if (defined $incTreeHash{$incFile}) | |
| { | |
| printLog("[Warning] recursive include!\n"); | |
| return $valRecursiveInclude; | |
| } | |
| $printStr = "//[hExpand.pl][$incFile] expanded (".join('->', @incDeeps)."->)\n"; | |
| printLog($printStr); | |
| #print $fileHandle $printStr; | |
| $g_totalIncCount++; | |
| printBoth("[$g_totalIncCount][$incFile] included\n"); | |
| # mark as included if appropriate | |
| $g_incInfo{$incFile}[$idxIncluded] = 1 if (!$alwaysExpand); | |
| printLog("//[hExpand.pl][$incFile][alwaysExpand] = $alwaysExpand, [included] = ".$g_incInfo{$incFile}[$idxIncluded]."\n"); | |
| if (scalar(@fileData) == 0) | |
| { | |
| open(hFile, "<$incPath\\$incFile") or die "can't open $incPath\\$incFile\n"; | |
| @fileData = <hFile>; | |
| close(hFile); | |
| } | |
| my @incOrderList = (); | |
| if (!$lineRedirect) | |
| { | |
| @fileData = &removeComment(\@fileData) if ($removeCommentOrNot); | |
| @fileData = &removeConsecutiveEmpty(\@fileData) if ($removeConsecutiveEmpty); | |
| } | |
| else | |
| { | |
| # find inc order first | |
| my @tmpData = &removeComment(\@fileData); | |
| foreach my $line (@tmpData) | |
| { | |
| if ($line =~ /^[\s]*\#include[\s]+([<\"])[\s]*([\w\.]+)[\s]*\1/) | |
| { | |
| push @incOrderList, lc $2; | |
| } | |
| } | |
| } | |
| # add line redirect | |
| my $incPrintPathName = "$incPath\\$incFile"; | |
| $incPrintPathName =~ s/\\/\\\\/g; | |
| print $fileHandle "#line 1 \"$incPrintPathName\"\n" if ($lineRedirect); | |
| my $iMax = $#fileData; | |
| my $conditionalInclude = 0; | |
| my $ifDeeps = 0; | |
| my $nodeMax = 0; # max node counts | |
| for (my $i=0; $i<=$iMax; $i++) | |
| { | |
| my $line = $fileData[$i]; | |
| if ($line =~ /^[\s]*\#include[\s]+([<\"])[\s]*([\w\.]+)[\s]*\1/) | |
| { | |
| my $inc = lc $2; | |
| # make sure we get correct #include (not in comments) | |
| if ($lineRedirect) | |
| { | |
| if ($inc ne $incOrderList[0]) | |
| { | |
| print $fileHandle $line; | |
| next; | |
| } | |
| else | |
| { | |
| shift @incOrderList; # remove from list | |
| } | |
| } | |
| # bypass all target files, since we'll expand them one by one | |
| if ((defined $g_targetFileHash{$inc}) || $g_forceNotExpand || (defined $g_nonExpandList{$inc})) | |
| { | |
| printLog("[$inc] not to include"); | |
| print $fileHandle $line; | |
| next; | |
| } | |
| printLog("[$inc] found\n"); | |
| push @incDeeps, $incFile; | |
| $incTreeHash{$incFile} = 1; | |
| my $nodeCount = 0; | |
| my $res = expandInc($fileHandle, $inc, ($alwaysExpand || $conditionalInclude), \$nodeCount); | |
| my $tmpLine = ""; | |
| #if ($conditionalInclude && !$alwaysExpand) | |
| { | |
| # get tree node counts | |
| printLog("//[hExpand.pl][$inc]\t[nodes = $nodeCount]\t[".join('->', @incDeeps)."]\n"); | |
| } | |
| pop @incDeeps; | |
| delete $incTreeHash{$incFile}; | |
| if ($res == $valSuccess) | |
| { | |
| # do nothing | |
| $nodeMax = $nodeCount if ($nodeCount > $nodeMax); | |
| ($$nodeCount_ref) += 1 + $nodeCount; # calculate tree-node count | |
| $tmpLine = "#line ".($i+1)." \"$incPrintPathName\"\n" if ($lineRedirect); | |
| } | |
| elsif ($res == $valAlreadyIncluded) | |
| { | |
| $printStr = "//[hExpand.pl][$inc] already included (".join('->', @incDeeps).")\n"; | |
| #print $fileHandle $printStr; | |
| printLog($printStr); | |
| $tmpLine = "//$line" if ($lineRedirect); | |
| } | |
| elsif ($res == $valFileNotFound) | |
| { | |
| $printStr = "//[hExpand.pl][$inc] file not found\n"; | |
| #print $fileHandle $printStr; | |
| printLog($printStr); | |
| $tmpLine = $line; # file not found, keep #include "xxx" | |
| } | |
| elsif ($res == $valRecursiveInclude) | |
| { | |
| $printStr = "//[hExpand.pl][$inc] recursive include (".join('->', @incDeeps).")\n"; | |
| #print $fileHandle $printStr; | |
| printLog($printStr); | |
| $tmpLine = "//$line" if ($lineRedirect); | |
| } | |
| print $fileHandle $tmpLine; | |
| } | |
| else | |
| { | |
| if ($line =~ /^[\s]*\#ifndef[\s]+([\w]+)/) | |
| { | |
| $ifDeeps++; | |
| my $wrapper = $1; | |
| if ((defined $fileData[$i+1]) && ($fileData[$i+1] =~ /^[\s]*\#define[\s]+$wrapper[^\w]+/) && | |
| ($wrapper =~ /_h[_]*$/i)) | |
| { | |
| printLog("//[hExpand.pl][wrapper] $wrapper\n"); | |
| } | |
| else | |
| { | |
| $conditionalInclude = $ifDeeps if ($conditionalInclude == 0); | |
| } | |
| } | |
| elsif ($line =~ /^[\s]*\#if/) | |
| { | |
| $ifDeeps++; | |
| $conditionalInclude = $ifDeeps if ($conditionalInclude == 0); | |
| } | |
| elsif ($line =~ /^[\s]*\#endif/) | |
| { | |
| if ($conditionalInclude == $ifDeeps) | |
| { | |
| $conditionalInclude = 0; | |
| } | |
| $ifDeeps--; | |
| } | |
| elsif ($line =~ /<hExpand[\s]+noExpand[\s]*>/i) | |
| { | |
| $g_forceNotExpand = 1; | |
| } | |
| elsif ($line =~ /<\/hExpand>/i) | |
| { | |
| $g_forceNotExpand = 0; | |
| } | |
| print $fileHandle $line; | |
| } | |
| } | |
| if (($$nodeCount_ref - $nodeMax) >= $g_nodeThreshold) | |
| { | |
| printLog("//[hExpand.pl][$incFile][diff lt node threshold]\t[$$nodeCount_ref][$nodeMax][".($$nodeCount_ref - $nodeMax)."]\n"); | |
| } | |
| print $fileHandle "\n"; | |
| return $valSuccess; | |
| } | |
| #****************************************************************************** | |
| # FUNCTION | |
| # getIncWrapper | |
| # DESCRIPTION | |
| # xxx | |
| # PARAMETERS | |
| # xxx | |
| # RETURNS | |
| # xxx | |
| #****************************************************************************** | |
| sub getIncWrapper() | |
| { | |
| my ($fileData_aref) = @_; | |
| my @tmpData = &removeComment($fileData_aref); | |
| # remove beginning '#include' | |
| my $iMax = $#tmpData; | |
| for (my $i=0; $i<=$iMax; $i++) | |
| { | |
| my $line = $tmpData[$i]; | |
| if ($line =~ /^[\s]*\#include/) | |
| { | |
| } | |
| elsif ($line =~ /^[\s]*$/) | |
| { | |
| # skip empty lines | |
| } | |
| elsif ($line =~ /^[\s]*\#if/) | |
| { | |
| @tmpData = @tmpData[$i..$iMax]; | |
| last; | |
| } | |
| } | |
| my $str = join('', @tmpData); | |
| if ($str =~ /^[\s]*\#ifndef[\s]+([\w]+).*?\#endif[\s]*$/s) | |
| { | |
| # print "[$1] inc wrapper\n"; | |
| return $1; | |
| } | |
| return ""; | |
| } | |
| #****************************************************************************** | |
| # FUNCTION | |
| # removeComment | |
| # DESCRIPTION | |
| # xxx | |
| # PARAMETERS | |
| # xxx | |
| # RETURNS | |
| # xxx | |
| #****************************************************************************** | |
| sub removeComment() | |
| { | |
| my ($fileData_aref) = @_; | |
| my @outData = (); | |
| # remove '//' | |
| foreach my $line (@{$fileData_aref}) | |
| { | |
| push @outData, $line if ($line !~ /^[\s]*\/\//); | |
| } | |
| my $tmpStr = join('', @outData); | |
| $tmpStr =~ s/(?<!\\)\/\*.*?\*\///sg; | |
| @outData = split("\n", $tmpStr); | |
| @outData = map {$_."\n"} @outData; | |
| return @outData; | |
| } | |
| #****************************************************************************** | |
| # FUNCTION | |
| # removeConsecutiveEmpty | |
| # DESCRIPTION | |
| # xxx | |
| # PARAMETERS | |
| # xxx | |
| # RETURNS | |
| # xxx | |
| #****************************************************************************** | |
| sub removeConsecutiveEmpty() | |
| { | |
| my ($fileData_aref) = @_; | |
| my $tmpStr = join('', @{$fileData_aref}); | |
| $tmpStr =~ s/\n{3,}/\n\n/sg; | |
| my @outData = split("\n", $tmpStr); | |
| @outData = map {$_."\n"} @outData; | |
| return @outData; | |
| } | |
| #****************************************************************************** | |
| # FUNCTION | |
| # searchIncPath | |
| # DESCRIPTION | |
| # xxx | |
| # PARAMETERS | |
| # xxx | |
| # RETURNS | |
| # xxx | |
| #****************************************************************************** | |
| sub searchIncPath() | |
| { | |
| my ($incFile, $incPath_aref) = @_; | |
| if (defined $notFoundFileList->{$incFile}) | |
| { | |
| return ""; | |
| } | |
| my $incPath = $foundFileList->{$incFile}; | |
| if (defined $incPath) | |
| { | |
| return $incPath if (-e "$incPath\\$incFile") | |
| } | |
| foreach my $incPath (@{$incPath_aref}) | |
| { | |
| my $filepath = "$incPath\\$incFile"; | |
| if (-e $filepath) | |
| { | |
| $foundFileList->{$incFile} = $incPath; | |
| return $incPath; | |
| } | |
| } | |
| $notFoundFileList->{$incFile} = 1; | |
| return ""; | |
| } | |
| #****************************************************************************** | |
| # FUNCTION | |
| # readCompileInfo | |
| # DESCRIPTION | |
| # xxx | |
| # PARAMETERS | |
| # xxx | |
| # RETURNS | |
| # xxx | |
| #****************************************************************************** | |
| sub readCompileInfo() | |
| { | |
| my ($incMod_aref, $incPath_aref, $def_aref) = @_; | |
| if ($g_prjName eq "") | |
| { | |
| push @{$incPath_aref}, "."; # no project specified, just put current dir to inc path | |
| print "[Warning] no compile info!\n"; | |
| return; | |
| } | |
| my $infoFilename = "$g_mcuPath\\build\\$g_prjName\\log\\info.log"; | |
| my %defHash = (); | |
| my %incHash = (); | |
| my $inSection; | |
| if ($incPath_aref || $def_aref) | |
| { | |
| # read common options and common include path from info.log | |
| open(hFile, "<$infoFilename") or die "can't open $infoFilename"; | |
| my @fileData = <hFile>; | |
| close(hFile); | |
| foreach my $line (@fileData) | |
| { | |
| if ($line =~ /\[ COMMON OPTION \]/) | |
| { | |
| $inSection = 1; | |
| next; | |
| } | |
| elsif ($line =~ /\[ COMMON INCLUDE PATH \]/) | |
| { | |
| $inSection = 2; | |
| next; | |
| } | |
| if ($line =~ /(^[^\[][^\s]*)/) | |
| { | |
| if ($inSection == 1) | |
| { | |
| #print "$1\n"; | |
| if ($def_aref && !(defined $defHash{$1})) | |
| { | |
| push @{$def_aref}, $1; | |
| $defHash{$1} = 1; | |
| } | |
| } | |
| elsif ($inSection == 2) | |
| { | |
| my $incPath = "$1"; | |
| if ($incPath !~ /:/) | |
| { | |
| $incPath = "$g_mcuPath\\$incPath"; | |
| } | |
| #print "$incPath\n"; | |
| if ($incPath_aref && !(defined $incHash{$incPath})) | |
| { | |
| push @{$incPath_aref}, $incPath; | |
| $incHash{$incPath} = 1; | |
| } | |
| } | |
| } | |
| else | |
| { | |
| $inSection = 0; | |
| } | |
| } | |
| } | |
| # read inc from *.inc | |
| if ($incPath_aref) | |
| { | |
| foreach my $myMod (@{$incMod_aref}) | |
| { | |
| my @incFiles = (); | |
| if (&getFileList("$g_mcuPath\\make\\$myMod\\*.inc", 1, \@incFiles) > 0) | |
| { | |
| foreach my $incFilename (@incFiles) | |
| { | |
| open(hFile, "<$incFilename") or die "can't open $incFilename"; | |
| my @fileData = <hFile>; | |
| close(hFile); | |
| foreach my $line (@fileData) | |
| { | |
| if ($line =~ /(^[^\s]+)([\s]*$)/) | |
| { | |
| my $incPath = "$g_mcuPath\\$1"; | |
| #$incPaths = "$incPaths\n-I$g_mcuPath\\$1"; | |
| if (!(defined $incHash{$incPath})) | |
| { | |
| push @{$incPath_aref}, $incPath; | |
| $incHash{$incPath} = 1; | |
| } | |
| } | |
| } | |
| } | |
| } | |
| else | |
| { | |
| print "[Warning] can't find *.inc for $myMod\n"; | |
| } | |
| } | |
| } | |
| # read macro from *.def | |
| if ($def_aref) | |
| { | |
| foreach my $myMod (@{$incMod_aref}) | |
| { | |
| my @defFiles = (); | |
| if (&getFileList("$g_mcuPath\\make\\$myMod\\*.def", 1, \@defFiles) > 0) | |
| { | |
| foreach my $defFilename (@defFiles) | |
| { | |
| open(hFile, "<$defFilename") or die "can't open $defFilename"; | |
| my @fileData = <hFile>; | |
| close(hFile); | |
| foreach my $line (@fileData) | |
| { | |
| if ($line =~ /(^[^\s]+)([\s]*$)/) | |
| { | |
| #$commonOptions = "$commonOptions\n-D$1"; | |
| if (!(defined $defHash{$1})) | |
| { | |
| push @{$def_aref}, $1; | |
| $defHash{$1} = 1; | |
| } | |
| } | |
| } | |
| } | |
| } | |
| else | |
| { | |
| print "[Warning] can't find *.def for $myMod\n"; | |
| } | |
| } | |
| } | |
| } | |
| #****************************************************************************** | |
| # FUNCTION | |
| # getFileList | |
| # DESCRIPTION | |
| # get file/path list for given search string | |
| # PARAMETERS | |
| # xxx | |
| # RETURNS | |
| # xxx | |
| #****************************************************************************** | |
| sub getFileList() | |
| { | |
| my $rootDir; | |
| my $incSubDir; # include sub dir (1) or not (0) | |
| my $fileList_ref; | |
| ($rootDir, $incSubDir, $fileList_ref) = @_; | |
| my @fileData = (); | |
| # get file list | |
| my $tmpFilename = "~tmpFile.lst"; | |
| my $dirStr = "$rootDir /b"; | |
| $dirStr .= " /s" if ($incSubDir); | |
| system("dir ".$dirStr." > $tmpFilename"); | |
| open(hFile, "<$tmpFilename") or die "[ERROR] can't open $tmpFilename\n"; | |
| @fileData = <hFile>; | |
| close(hFile); | |
| system("del $tmpFilename") if ($g_removeTempFile); | |
| foreach my $line (@fileData) | |
| { | |
| my $name = $line; | |
| push @{$fileList_ref}, $name if ($name !~ /^[\s]*$/); | |
| #print "$name"; | |
| } | |
| return scalar(@{$fileList_ref}); | |
| } | |
| #****************************************************************************** | |
| # FUNCTION | |
| # timeCheck | |
| # DESCRIPTION | |
| # print current time (in sec.) and time-difference to previous check if exists | |
| # PARAMETERS | |
| # none | |
| # RETURNS | |
| # current time and time difference if exists (both in sec.) | |
| #****************************************************************************** | |
| my @timePrev = (); | |
| sub timeCheck() | |
| { | |
| my @timeCurr = localtime(time); | |
| printBoth("[Time: ".&timeInSec(\@timeCurr)." sec."); | |
| if (@timePrev > 0) # previous-time exists | |
| { | |
| printBoth("(Diff = ".&timeDiffInSec(\@timeCurr, \@timePrev).")"); | |
| } | |
| printBoth("]\n"); | |
| @timePrev = @timeCurr; | |
| } | |
| #****************************************************************************** | |
| # FUNCTION | |
| # timeDiffInSec | |
| # DESCRIPTION | |
| # get time difference in sec. | |
| # PARAMETERS | |
| # para 1 - reference to time1 in localtime array format | |
| # para 2 - reference to time2 in localtime array format | |
| # RETURNS | |
| # time difference in sec. | |
| #****************************************************************************** | |
| sub timeDiffInSec() | |
| { | |
| my $time1; | |
| my $time2; | |
| my $timeDiff; | |
| ($time1, $time2) = @_; | |
| $timeDiff = timeInSec($time1) - timeInSec($time2); | |
| if ($timeDiff < 0) | |
| { | |
| return (-$timeDiff); | |
| } | |
| return $timeDiff; | |
| } | |
| #****************************************************************************** | |
| # FUNCTION | |
| # timeInSec | |
| # DESCRIPTION | |
| # time in sec. | |
| # PARAMETERS | |
| # para - time in localtime array format | |
| # RETURNS | |
| # time in sec. | |
| #****************************************************************************** | |
| sub timeInSec() | |
| { | |
| my @daysInMon = (31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31); | |
| my $sec = $_[0][0]; | |
| my $min = $_[0][1]; | |
| my $hour = $_[0][2]; | |
| my $day = $_[0][3]; | |
| my $mon = $_[0][4]+1; | |
| my $year = $_[0][5]; | |
| my $timeInSec; | |
| if (isLeapYear($year+1900)) | |
| { | |
| $daysInMon[1] = 29; | |
| $timeInSec = (((($year*366+$mon*$daysInMon[$mon-1]+$day)*24 + $hour)*60 + $min)*60 + $sec); | |
| } | |
| else | |
| { | |
| $timeInSec = (((($year*365+$mon*$daysInMon[$mon-1]+$day)*24 + $hour)*60 + $min)*60 + $sec); | |
| } | |
| return $timeInSec; | |
| } | |
| #****************************************************************************** | |
| # FUNCTION | |
| # isLeapYear | |
| # DESCRIPTION | |
| # is input year leap-year | |
| # PARAMETERS | |
| # year | |
| # RETURNS | |
| # leap-year or not | |
| #****************************************************************************** | |
| sub isLeapYear() | |
| { | |
| my $year = $_[0]; | |
| if (($year%4 == 0) && ($year%100 != 0)) | |
| { | |
| return 1; | |
| } | |
| return 0; | |
| } | |
| sub findMismatchIf() | |
| { | |
| my ($data_aref) = @_; | |
| my $nestNum = 0; | |
| my %nestHash = (); | |
| printLog("\n[findMismatchIf]\n"); | |
| foreach my $line (@{$data_aref}) | |
| { | |
| if ($line =~ /^[\s]*\#if/) | |
| { | |
| $nestNum++; | |
| $nestHash{$nestNum} = $line; | |
| #printLog("[$nestNum][+] $line"); | |
| printLog("$line"); | |
| } | |
| elsif ($line =~ /^[\s]*\#endif/) | |
| { | |
| #printLog("[$nestNum][-] $nestHash{$nestNum}"); | |
| delete $nestHash{$nestNum}; | |
| $nestNum--; | |
| } | |
| } | |
| my @nestIdx = sort keys(%nestHash); | |
| foreach my $idx (@nestIdx) | |
| { | |
| printLog("[$idx] $nestHash{$idx}\n"); | |
| } | |
| } | |
| sub printBoth() | |
| { | |
| my ($str) = @_; | |
| print $str; | |
| print $logFileHandle $str; | |
| } | |
| sub printLog() | |
| { | |
| my ($str) = @_; | |
| print $logFileHandle $str; | |
| } | |
| sub trim() | |
| { | |
| my ($str) = @_; | |
| $str =~ s/(^\s*)|(\s*$)//g; | |
| return $str; | |
| } |