mcu/tools/med_mem_check.pl - T800_MD - Gitiles

 #!/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:
 # ---------
 #  med_mem_check.pl
 #
 # Description:
 # ------------
 #  this script is used to do med memory check.
 #
 # Auther:
 # -------
 #  Vincent Cho
 #
 # Note:
 # -----
 #  none.
 #
 # Log:
 # -----
 #  2008/02/19   Create (from MMI_feature_check.pl)
 #

 #BEGIN { push @INC, "pcore/" , 'U:\\00MyPerlLib'}  # add additional library path
 #package XXX;
 use strict;

 #******************************************************************************
 # Global Data
 #******************************************************************************
 my $returnErrorCode = 0;        # return error code or not
 my $genLogTogether = 0;         # gen all logs in the same folder or not

 my $mcuPath = '.';
 my $headerFilename = "med_mem.h";
 my $headerFilepath = 'media\common\include';

 # list the modules which their *.inc will be added into include path
 my @includeMod = ();       # include *.inc

 # additional path for include files
 my @addIncPath = ();

 # additional include files
 my @addIncFiles = ();

 # additional lines
 my @addLines = ();

 # additional features to watch
 my @addFeaturesToWatch = ();

 # remove temp file or not
 my $removeTempFile = 1;

 # also process disabled features or not
 my $alsoProcessDisabledFeatures = 1;

 # compiler
 my $compiler = "armcc";
 my $viaOption = "--via";

 my $macro_on = "__ON__";
 my $macro_off = "__OFF__";
 my $macro_auto = "__AUTO__";

 my $checkMainFilename;
 my $logFilename;

 my %featureList = ();
 my @sortedAllFeatures = ();
 my @defFeatures = ();
 my @undefFeatures = ();
 my %mismatchCFG = ();           # structure: { mismatch-cfg => [0] original config }
                                 #                              [1] result config
 my $allFeatureCount;
 my $defFeatureCount;
 my $undefFeatureCount;
 my $separation = "***********************************************************************";

 #******************************************************************************
 # Export Function
 #******************************************************************************

 #******************************************************************************
 # Internal Data
 #******************************************************************************
 my @fileData = ();
 my $logPath = "";
 my $prjName = "";
 my %ignoredCFG = ();
 my $mismatchCount;

 #******************************************************************************
 # Program Start
 #******************************************************************************

 # get project name from input argument
 if (scalar(@ARGV) == 0)
 {
     my @usage = ();
     push @usage, "Usage: 'med_mem_check.pl <project name> <compiler> <via option> <filename>  <path>'\n\n";
     push @usage, "e.g. 'med_mem_check.pl DRAGONFLY_DEMO armcc --via med_mem.h media\\common\\include'\n\n";
     die join('', @usage);
 }
 else
 {
     ($prjName, $compiler, $viaOption,
         $headerFilename, $headerFilepath) = @ARGV;

     push @addIncPath, $headerFilepath;
 }

 print "\nstart MED Memory check...\n";

 # all logs in the same folder
 if ($genLogTogether)
 {
     $logPath = "$mcuPath\\build";
     $logFilename = "$logPath\\".splitFilename($headerFilename, 0)."$prjName.log";
 }
 # each log in its own project folder
 else
 {
     $logPath = "$mcuPath\\build\\$prjName\\log";
     $logFilename = "$logPath\\".splitFilename($headerFilename, 0).".log";
 }

 # get all feature list
 open(hFile, "<$mcuPath\\$headerFilepath\\$headerFilename") or die "can't open $mcuPath\\$headerFilepath\\$headerFilename";
 @fileData = <hFile>;
 close(hFile);

 print "get feature list from $headerFilename...\n";
 foreach my $line (@fileData)
 {
     my $feature = "";

     # also process marked "//" features or not
     if ($alsoProcessDisabledFeatures)
     {
         if ($line =~ /^([\s]*([\/]{2,})?[\s]*)(#define[\s]+)([\w_]+)([\s]*)/)
         {
             $feature = $4;
         }
     }
     else
     {
         if ($line =~ /^([\s]*)(#define[\s]+)([\w_]+)([\s]*)/)
         {
             $feature = $3;
         }
     }

     # ignore empty one
     if ($feature ne "")
     {
         if ($feature !~ /^CFG_/)
         {
             $featureList{$feature} = "";
         }
         # CFG_XXX
         else
         {
             $ignoredCFG{$feature} = 1;
             #print "ignored CFG [$feature]\n";
         }
     }
 }

 @sortedAllFeatures = sort(keys(%featureList));

 # add additional features to watch
 push @sortedAllFeatures, @addFeaturesToWatch;

 $allFeatureCount = @sortedAllFeatures;

 $checkMainFilename = "~".splitFilename($headerFilename, 0)."_check";

 # generate XXX_check.c
 print "generate feature check file...\n";
 genCheckDotC("$checkMainFilename.c", $headerFilename, \@sortedAllFeatures);

 # validate features
 print "validate features...\n";
 processCheckDotC("-E");

 # check def/undef features in pre-processed file
 print "check def/undef features in pre-processed file...\n";
 checkFeatures("$checkMainFilename.obj", \%featureList, \@sortedAllFeatures, \@defFeatures, \@undefFeatures);
 $defFeatureCount = @defFeatures;
 $undefFeatureCount = @undefFeatures;

 if ($removeTempFile)
 {
     system("del $checkMainFilename.c");
     system("del $checkMainFilename.obj");
 }


 # output results
 genLog($logFilename, \%mismatchCFG, \@defFeatures, \%featureList,
         \@undefFeatures, \@sortedAllFeatures);

 # verify result
 print "\n[$headerFilename]\n";
 print "All feature count = $allFeatureCount\nDefined count = $defFeatureCount\nUndef count = $undefFeatureCount\n";

 print "MED Memory Check - Done\n";

 if ($returnErrorCode && $mismatchCount)
 {
     exit 1;
 }
 exit 0;

 #******************************************************************************
 # Internal Function
 #******************************************************************************

 #******************************************************************************
 # FUNCTION
 #  genCheckDotC
 # DESCRIPTION
 #  xxx
 # PARAMETERS
 #  xxx
 # RETURNS
 #  none
 #******************************************************************************
 sub genCheckDotC()
 {
     my $filename;
     my $headerFilename;
     my @fileData;
     my $pUserData;  # reference to data array

     ($filename, $headerFilename, $pUserData) = @_;

     open(hFile, ">$filename") or die "can't open $filename";

     foreach my $line (@addLines)
     {
         print hFile $line;
     }

     # write header part

     foreach my $inc (@addIncFiles)
     {
         print hFile "#include \"$inc\"\n";
     }

     print hFile "#include \"$headerFilename\"\n\n";

     # write start tag
     print hFile "static void * feature_check[] = {\n";

     foreach my $data (@$pUserData)
     {
         print hFile "(void *)$data,\n";
     }

     # write end tag
     print hFile "(void *)\"END FEATURE LIST\"};\n";

     close(hFile);
 }


 #******************************************************************************
 # FUNCTION
 #  processCheckDotC
 # DESCRIPTION
 #  xxx
 # PARAMETERS
 #  xxx
 # RETURNS
 #  none
 #******************************************************************************
 sub processCheckDotC()
 {
     my $infoFilename = "$mcuPath\\build\\$prjName\\log\\info.log";
     my $defTmpFilename = "$checkMainFilename.def";
     my $incTmpFilename = "$checkMainFilename.inc";
     my $compileOptions;
     my @fileData;
     my $inSection = 0;
     my $incPaths = "";
     my $commonOptions = "";

     my $incFilename;
     my $count = 0;

     ($compileOptions) = @_;

     # read inc from *.inc
     foreach my $mod (@includeMod)
     {
         $incFilename = "$mcuPath\\make\\$mod\\$mod.inc";
         open(hFile, "<$incFilename") or die "can't open $incFilename";
         @fileData = <hFile>;
         close(hFile);

         foreach my $line (@fileData)
         {
             if ($line =~ /(^[^\s]*)([\s]*$)/)
             {
                 $incPaths = "$incPaths\n-I$mcuPath\\$1";
             }
         }
     }

     foreach my $inc (@addIncPath)
     {
         $incPaths = "$incPaths\n-I$mcuPath\\$inc";
     }

     # read common options and common include path from info.log
     open(hFile, "<$infoFilename") or die "can't open $infoFilename";
     @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";
                 $commonOptions = "$commonOptions\n-D$1";
             }
             elsif ($inSection == 2)
             {
                 my $inc = "$1";

                 if ($inc !~ /:/)
                 {
                     $inc = "$mcuPath\\$inc";
                 }
                 #print "$inc\n";
                 $incPaths = "$incPaths\n-I$inc";
             }
         }
         else
         {
             $inSection = 0;
         }
     }
     #print "$commonOptions\n";
     open(hFile, ">$defTmpFilename") or die "can't open $defTmpFilename";
     print hFile "$commonOptions\n";
     close(hFile);

     #print "$incPaths\n";
     open(hFile, ">$incTmpFilename") or die "can't open $incTmpFilename";
     print hFile "$incPaths\n";
     close(hFile);

     open(hFile, ">makeCheck.bat") or die "makeCheck.bat";
     print hFile "\@echo off\n";
     print hFile "\"$compiler\" $checkMainFilename.c -o $checkMainFilename.obj $compileOptions $viaOption $defTmpFilename $viaOption $incTmpFilename\n";
     print hFile "\@echo on\n";
     close(hFile);
     system("makeCheck.bat");
     if ($removeTempFile)
     {
         system("del makeCheck.bat");
         system("del $defTmpFilename");
         system("del $incTmpFilename");
     }

     # post-process *.obj
     open(hFile, "<$checkMainFilename.obj") or die "can't open $checkMainFilename.obj\n";
     @fileData = <hFile>;
     close(hFile);

     # remove multi-CR/LF
     my $tmpStr = join('',@fileData);
     $tmpStr =~ s/\n([\s]+)\n/\n\n/g;
     open(hFile, ">$checkMainFilename.obj") or die "can't open $checkMainFilename.obj\n";
     print hFile $tmpStr;
     close(hFile);
 }


 #******************************************************************************
 # FUNCTION
 #  checkConfig
 # DESCRIPTION
 #  xxx
 # PARAMETERS
 #  xxx
 # RETURNS
 #  none
 #******************************************************************************
 sub checkConfig()
 {
     my $switchFilePathname;
     my $featureHash_ref;
     my $ignoredCFG_ref;
     my $mismatchCFG_ref;

     my @fileData;
     my %cfgHash = ();
     my @cfgList = ();

     ($switchFilePathname, $featureHash_ref, $ignoredCFG_ref,
         $mismatchCFG_ref) = @_;

     open(hFile, "<$switchFilePathname") or die "can't open $switchFilePathname\n";
     @fileData = <hFile>;
     close(hFile);

     # generate cfgHash from featureHash
     while (my ($feature, $value) = each (%{$featureHash_ref}))
     {
         # remove head and tail '_'
         $feature =~ s/(^[_]*)|([_]*$)//g;
         $feature = "CFG_"."$feature";

         $value =~ s/[\s]*//g;             # remove empty
         $value =~ s/(^[\(]*)|([\)]*$)//g; # remove headh '(' and tail ')'

         $cfgHash{$feature} = $value;
     }

     foreach my $line (@fileData)
     {
         # get CFG_XXX
         if ($line =~ /^[\s]*\#define[\s]*(CFG_[\w_]*)[\s]*([^\n\/]*)/)
         {
             my $cfg = $1;
             my $value = $2;
             my $mismatchValue = "";

             $value =~ s/[\s]*//g;             # remove empty
             $value =~ s/(^[\(]*)|([\)]*$)//g; # remove headh '(' and tail ')'

             # only check on/off type (skip auto and value type)
             if (($value =~ /^(($macro_on)|($macro_off))$/) && !(${$ignoredCFG_ref}{$cfg}))
             {
                 if (exists $cfgHash{$cfg})
                 {
                     # cfg = OFF, bug feature is defined
                     if ($value eq $macro_off)
                     {
                         $mismatchValue = $macro_on;
                     }
                     # cfg != feature value
                     elsif ($value ne $cfgHash{$cfg})
                     {
                         $mismatchValue = $cfgHash{$cfg};
                     }
                 }
                 # cfg = ON, but feature is undef
                 elsif ($value eq $macro_on)
                 {
                     $mismatchValue = $macro_off;
                 }

                 if ($mismatchValue ne "")
                 {
                     ${$mismatchCFG_ref}{$cfg}[0] = $value;  # original config
                     ${$mismatchCFG_ref}{$cfg}[1] = $mismatchValue;
                 }
             }
         }
     }

     # return mismatch count
     return (scalar(keys(%{$mismatchCFG_ref})));
 }


 #******************************************************************************
 # FUNCTION
 #  checkFeatures
 # DESCRIPTION
 #  xxx
 # PARAMETERS
 #  xxx
 # RETURNS
 #  none
 #******************************************************************************
 sub checkFeatures()
 {
     my $filename;           # preprocessed object filename
     my $pFeatureList;       # reference to hash of feature list,
                             # after this call, only contains defined features
     my $pSortedAllFeatures; # reference to array of sorted all features
     my $pDefFeatures;       # reference to array of defined features
     my $pUndefFeatures;     # reference to array of undefined features

     my @fileData;
     my $isFeature = 0;
     my $featureIndex;
     my $defFeature;

     ($filename, $pFeatureList, $pSortedAllFeatures,
         $pDefFeatures, $pUndefFeatures) = @_;

     open(hFile, "<$filename") or die "can't open $filename";
     @fileData = <hFile>;
     close(hFile);

     foreach my $line (@fileData)
     {
         if ($isFeature)
         {
             if ($line =~ /(^\(void \*\)[\s]*)([^,]*)([\s]*,$)/)
             {
                 $defFeature = $$pSortedAllFeatures[$featureIndex];

                 if ($2 eq $defFeature)
                 {
                     # undefined symbols ("_XXX_" shows)

                     push @$pUndefFeatures, $2;

                     # remove it from feature list
                     delete $$pFeatureList{$2};

                     #print "[U] $2\n";
                 }
                 else
                 {
                     # process defined symbols

                     push @$pDefFeatures, $defFeature;

                     # update value of feature list
                     $$pFeatureList{$defFeature} = $2;

                     #print "[D] $defFeature = $2\n";
                 }
             }
             # end of feature list
             elsif ($line =~ /"END FEATURE LIST"}/)
             {
                 $isFeature = 0;
             }
             elsif ($line !~ /^[\s]*$/)
             {
                 print "[Not Processed] \"$line\"\n";
             }

             #print "[$featureIndex] $$pSortedAllFeatures[$featureIndex] $line\n";
             $featureIndex++;
         }

         # check if begining of feature list
         if ($line =~ /feature_check\[\]/)
         {
             $isFeature = 1;
             $featureIndex = 0;
         }
     }
 }


 #******************************************************************************
 # FUNCTION
 #  splitFilename
 # DESCRIPTION
 #  xxx
 # PARAMETERS
 #  $filename [IN] - filename
 #  $refSubFilename [OUT] - reference to sub filename, may be NULL
 # RETURNS
 #  main filename
 #******************************************************************************
 sub splitFilename()
 {
     my $filename;
     my $refSubFilename = "";
     my $mainFilename = "";

     ($filename, $refSubFilename) = @_;

     if ($filename =~ /([^\s]*)(\.)([^\.]*$)/)
     {
         #print "$filename [$1][$3]\n";
         $mainFilename = "$1";
         if ($refSubFilename != 0)
         {
             $$refSubFilename = "$3";
         }
     }
     return $mainFilename;
 }


 #******************************************************************************
 # FUNCTION
 #  genLog
 # DESCRIPTION
 #  xxx
 # PARAMETERS
 #  $filename [IN] - log file pathname
 # RETURNS
 #  none
 #******************************************************************************
 sub genLog()
 {
     my $logFilePathname;
     my $mismatchCFG_href;
     my $defFeatures_aref;
     my $featureData_href;
     my $undefFeatures_aref;
     my $sortedAllFeatures_aref;

     my $col1LenMax = 0;
     my $mismatchCount;
     my $allFeatureCount;
     my $defFeatureCount;
     my $undefFeatureCount;

     ($logFilePathname, $mismatchCFG_href, $defFeatures_aref,
         $featureData_href, $undefFeatures_aref, $sortedAllFeatures_aref) = @_;

     open(hLogFile, ">$logFilePathname") or die "can't open $logFilePathname";

     open(hMEDFile, "<~med_mem_info.log") or die "can't open ~med_mem_info.log";

     while(<hMEDFile>){
     print hLogFile $_;
     }


     #$mismatchCount = keys(%{$mismatchCFG_href});
     $allFeatureCount = @$sortedAllFeatures_aref;
     $defFeatureCount = @$defFeatures_aref;
     $undefFeatureCount = @$undefFeatures_aref;

     $col1LenMax = 0;
     foreach my $feature (@$sortedAllFeatures_aref)
     {
         $col1LenMax = length($feature) if (length($feature)>$col1LenMax);
     }

     # result: Defined Features
     print hLogFile "\n$separation\n[MED Scenarios ($defFeatureCount)]\n$separation\n\n";
     foreach my $feature (@$defFeatures_aref)
     {
         print hLogFile sprintf("[D] %-*s%s\n", $col1LenMax+8,
                             $feature, ${$featureData_href}{$feature});
     }
     print hLogFile "\n\n";
     close(hLogFile);
     close(hMEDFile);

     print "log generated at $logFilePathname\n";
 }
	#!/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:
	# ---------
	# med_mem_check.pl
	#
	# Description:
	# ------------
	# this script is used to do med memory check.
	#
	# Auther:
	# -------
	# Vincent Cho
	#
	# Note:
	# -----
	# none.
	#
	# Log:
	# -----
	# 2008/02/19 Create (from MMI_feature_check.pl)
	#

	#BEGIN { push @INC, "pcore/" , 'U:\\00MyPerlLib'} # add additional library path
	#package XXX;
	use strict;

	#******************************************************************************
	# Global Data
	#******************************************************************************
	my $returnErrorCode = 0; # return error code or not
	my $genLogTogether = 0; # gen all logs in the same folder or not

	my $mcuPath = '.';
	my $headerFilename = "med_mem.h";
	my $headerFilepath = 'media\common\include';

	# list the modules which their *.inc will be added into include path
	my @includeMod = (); # include *.inc

	# additional path for include files
	my @addIncPath = ();

	# additional include files
	my @addIncFiles = ();

	# additional lines
	my @addLines = ();

	# additional features to watch
	my @addFeaturesToWatch = ();

	# remove temp file or not
	my $removeTempFile = 1;

	# also process disabled features or not
	my $alsoProcessDisabledFeatures = 1;

	# compiler
	my $compiler = "armcc";
	my $viaOption = "--via";

	my $macro_on = "__ON__";
	my $macro_off = "__OFF__";
	my $macro_auto = "__AUTO__";

	my $checkMainFilename;
	my $logFilename;

	my %featureList = ();
	my @sortedAllFeatures = ();
	my @defFeatures = ();
	my @undefFeatures = ();
	my %mismatchCFG = (); # structure: { mismatch-cfg => [0] original config }
	# [1] result config
	my $allFeatureCount;
	my $defFeatureCount;
	my $undefFeatureCount;
	my $separation = "***********************************************************************";

	#******************************************************************************
	# Export Function
	#******************************************************************************

	#******************************************************************************
	# Internal Data
	#******************************************************************************
	my @fileData = ();
	my $logPath = "";
	my $prjName = "";
	my %ignoredCFG = ();
	my $mismatchCount;

	#******************************************************************************
	# Program Start
	#******************************************************************************

	# get project name from input argument
	if (scalar(@ARGV) == 0)
	{
	my @usage = ();
	push @usage, "Usage: 'med_mem_check.pl <project name> <compiler> <via option> <filename> <path>'\n\n";
	push @usage, "e.g. 'med_mem_check.pl DRAGONFLY_DEMO armcc --via med_mem.h media\\common\\include'\n\n";
	die join('', @usage);
	}
	else
	{
	($prjName, $compiler, $viaOption,
	$headerFilename, $headerFilepath) = @ARGV;

	push @addIncPath, $headerFilepath;
	}

	print "\nstart MED Memory check...\n";

	# all logs in the same folder
	if ($genLogTogether)
	{
	$logPath = "$mcuPath\\build";
	$logFilename = "$logPath\\".splitFilename($headerFilename, 0)."$prjName.log";
	}
	# each log in its own project folder
	else
	{
	$logPath = "$mcuPath\\build\\$prjName\\log";
	$logFilename = "$logPath\\".splitFilename($headerFilename, 0).".log";
	}

	# get all feature list
	open(hFile, "<$mcuPath\\$headerFilepath\\$headerFilename") or die "can't open $mcuPath\\$headerFilepath\\$headerFilename";
	@fileData = <hFile>;
	close(hFile);

	print "get feature list from $headerFilename...\n";
	foreach my $line (@fileData)
	{
	my $feature = "";

	# also process marked "//" features or not
	if ($alsoProcessDisabledFeatures)
	{
	if ($line =~ /^([\s]([\/]{2,})?[\s])(#define[\s]+)([\w_]+)([\s]*)/)
	{
	$feature = $4;
	}
	}
	else
	{
	if ($line =~ /^([\s])(#define[\s]+)([\w_]+)([\s])/)
	{
	$feature = $3;
	}
	}

	# ignore empty one
	if ($feature ne "")
	{
	if ($feature !~ /^CFG_/)
	{
	$featureList{$feature} = "";
	}
	# CFG_XXX
	else
	{
	$ignoredCFG{$feature} = 1;
	#print "ignored CFG [$feature]\n";
	}
	}
	}

	@sortedAllFeatures = sort(keys(%featureList));

	# add additional features to watch
	push @sortedAllFeatures, @addFeaturesToWatch;

	$allFeatureCount = @sortedAllFeatures;

	$checkMainFilename = "~".splitFilename($headerFilename, 0)."_check";

	# generate XXX_check.c
	print "generate feature check file...\n";
	genCheckDotC("$checkMainFilename.c", $headerFilename, \@sortedAllFeatures);

	# validate features
	print "validate features...\n";
	processCheckDotC("-E");

	# check def/undef features in pre-processed file
	print "check def/undef features in pre-processed file...\n";
	checkFeatures("$checkMainFilename.obj", \%featureList, \@sortedAllFeatures, \@defFeatures, \@undefFeatures);
	$defFeatureCount = @defFeatures;
	$undefFeatureCount = @undefFeatures;

	if ($removeTempFile)
	{
	system("del $checkMainFilename.c");
	system("del $checkMainFilename.obj");
	}


	# output results
	genLog($logFilename, \%mismatchCFG, \@defFeatures, \%featureList,
	\@undefFeatures, \@sortedAllFeatures);

	# verify result
	print "\n[$headerFilename]\n";
	print "All feature count = $allFeatureCount\nDefined count = $defFeatureCount\nUndef count = $undefFeatureCount\n";

	print "MED Memory Check - Done\n";

	if ($returnErrorCode && $mismatchCount)
	{
	exit 1;
	}
	exit 0;

	#******************************************************************************
	# Internal Function
	#******************************************************************************

	#******************************************************************************
	# FUNCTION
	# genCheckDotC
	# DESCRIPTION
	# xxx
	# PARAMETERS
	# xxx
	# RETURNS
	# none
	#******************************************************************************
	sub genCheckDotC()
	{
	my $filename;
	my $headerFilename;
	my @fileData;
	my $pUserData; # reference to data array

	($filename, $headerFilename, $pUserData) = @_;

	open(hFile, ">$filename") or die "can't open $filename";

	foreach my $line (@addLines)
	{
	print hFile $line;
	}

	# write header part

	foreach my $inc (@addIncFiles)
	{
	print hFile "#include \"$inc\"\n";
	}

	print hFile "#include \"$headerFilename\"\n\n";

	# write start tag
	print hFile "static void * feature_check[] = {\n";

	foreach my $data (@$pUserData)
	{
	print hFile "(void *)$data,\n";
	}

	# write end tag
	print hFile "(void *)\"END FEATURE LIST\"};\n";

	close(hFile);
	}


	#******************************************************************************
	# FUNCTION
	# processCheckDotC
	# DESCRIPTION
	# xxx
	# PARAMETERS
	# xxx
	# RETURNS
	# none
	#******************************************************************************
	sub processCheckDotC()
	{
	my $infoFilename = "$mcuPath\\build\\$prjName\\log\\info.log";
	my $defTmpFilename = "$checkMainFilename.def";
	my $incTmpFilename = "$checkMainFilename.inc";
	my $compileOptions;
	my @fileData;
	my $inSection = 0;
	my $incPaths = "";
	my $commonOptions = "";

	my $incFilename;
	my $count = 0;

	($compileOptions) = @_;

	# read inc from *.inc
	foreach my $mod (@includeMod)
	{
	$incFilename = "$mcuPath\\make\\$mod\\$mod.inc";
	open(hFile, "<$incFilename") or die "can't open $incFilename";
	@fileData = <hFile>;
	close(hFile);

	foreach my $line (@fileData)
	{
	if ($line =~ /(^[^\s])([\s]$)/)
	{
	$incPaths = "$incPaths\n-I$mcuPath\\$1";
	}
	}
	}

	foreach my $inc (@addIncPath)
	{
	$incPaths = "$incPaths\n-I$mcuPath\\$inc";
	}

	# read common options and common include path from info.log
	open(hFile, "<$infoFilename") or die "can't open $infoFilename";
	@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";
	$commonOptions = "$commonOptions\n-D$1";
	}
	elsif ($inSection == 2)
	{
	my $inc = "$1";

	if ($inc !~ /:/)
	{
	$inc = "$mcuPath\\$inc";
	}
	#print "$inc\n";
	$incPaths = "$incPaths\n-I$inc";
	}
	}
	else
	{
	$inSection = 0;
	}
	}
	#print "$commonOptions\n";
	open(hFile, ">$defTmpFilename") or die "can't open $defTmpFilename";
	print hFile "$commonOptions\n";
	close(hFile);

	#print "$incPaths\n";
	open(hFile, ">$incTmpFilename") or die "can't open $incTmpFilename";
	print hFile "$incPaths\n";
	close(hFile);

	open(hFile, ">makeCheck.bat") or die "makeCheck.bat";
	print hFile "\@echo off\n";
	print hFile "\"$compiler\" $checkMainFilename.c -o $checkMainFilename.obj $compileOptions $viaOption $defTmpFilename $viaOption $incTmpFilename\n";
	print hFile "\@echo on\n";
	close(hFile);
	system("makeCheck.bat");
	if ($removeTempFile)
	{
	system("del makeCheck.bat");
	system("del $defTmpFilename");
	system("del $incTmpFilename");
	}

	# post-process *.obj
	open(hFile, "<$checkMainFilename.obj") or die "can't open $checkMainFilename.obj\n";
	@fileData = <hFile>;
	close(hFile);

	# remove multi-CR/LF
	my $tmpStr = join('',@fileData);
	$tmpStr =~ s/\n([\s]+)\n/\n\n/g;
	open(hFile, ">$checkMainFilename.obj") or die "can't open $checkMainFilename.obj\n";
	print hFile $tmpStr;
	close(hFile);
	}


	#******************************************************************************
	# FUNCTION
	# checkConfig
	# DESCRIPTION
	# xxx
	# PARAMETERS
	# xxx
	# RETURNS
	# none
	#******************************************************************************
	sub checkConfig()
	{
	my $switchFilePathname;
	my $featureHash_ref;
	my $ignoredCFG_ref;
	my $mismatchCFG_ref;

	my @fileData;
	my %cfgHash = ();
	my @cfgList = ();

	($switchFilePathname, $featureHash_ref, $ignoredCFG_ref,
	$mismatchCFG_ref) = @_;

	open(hFile, "<$switchFilePathname") or die "can't open $switchFilePathname\n";
	@fileData = <hFile>;
	close(hFile);

	# generate cfgHash from featureHash
	while (my ($feature, $value) = each (%{$featureHash_ref}))
	{
	# remove head and tail '_'
	$feature =~ s/(^[_])\|([_]$)//g;
	$feature = "CFG_"."$feature";

	$value =~ s/[\s]*//g; # remove empty
	$value =~ s/(^[\(])\|([\)]$)//g; # remove headh '(' and tail ')'

	$cfgHash{$feature} = $value;
	}

	foreach my $line (@fileData)
	{
	# get CFG_XXX
	if ($line =~ /^[\s]\#define[\s](CFG_[\w_])[\s]([^\n\/]*)/)
	{
	my $cfg = $1;
	my $value = $2;
	my $mismatchValue = "";

	$value =~ s/[\s]*//g; # remove empty
	$value =~ s/(^[\(])\|([\)]$)//g; # remove headh '(' and tail ')'

	# only check on/off type (skip auto and value type)
	if (($value =~ /^(($macro_on)\|($macro_off))$/) && !(${$ignoredCFG_ref}{$cfg}))
	{
	if (exists $cfgHash{$cfg})
	{
	# cfg = OFF, bug feature is defined
	if ($value eq $macro_off)
	{
	$mismatchValue = $macro_on;
	}
	# cfg != feature value
	elsif ($value ne $cfgHash{$cfg})
	{
	$mismatchValue = $cfgHash{$cfg};
	}
	}
	# cfg = ON, but feature is undef
	elsif ($value eq $macro_on)
	{
	$mismatchValue = $macro_off;
	}

	if ($mismatchValue ne "")
	{
	${$mismatchCFG_ref}{$cfg}[0] = $value; # original config
	${$mismatchCFG_ref}{$cfg}[1] = $mismatchValue;
	}
	}
	}
	}

	# return mismatch count
	return (scalar(keys(%{$mismatchCFG_ref})));
	}


	#******************************************************************************
	# FUNCTION
	# checkFeatures
	# DESCRIPTION
	# xxx
	# PARAMETERS
	# xxx
	# RETURNS
	# none
	#******************************************************************************
	sub checkFeatures()
	{
	my $filename; # preprocessed object filename
	my $pFeatureList; # reference to hash of feature list,
	# after this call, only contains defined features
	my $pSortedAllFeatures; # reference to array of sorted all features
	my $pDefFeatures; # reference to array of defined features
	my $pUndefFeatures; # reference to array of undefined features

	my @fileData;
	my $isFeature = 0;
	my $featureIndex;
	my $defFeature;

	($filename, $pFeatureList, $pSortedAllFeatures,
	$pDefFeatures, $pUndefFeatures) = @_;

	open(hFile, "<$filename") or die "can't open $filename";
	@fileData = <hFile>;
	close(hFile);

	foreach my $line (@fileData)
	{
	if ($isFeature)
	{
	if ($line =~ /(^\(void \\)[\s])([^,])([\s],$)/)
	{
	$defFeature = $$pSortedAllFeatures[$featureIndex];

	if ($2 eq $defFeature)
	{
	# undefined symbols ("_XXX_" shows)

	push @$pUndefFeatures, $2;

	# remove it from feature list
	delete $$pFeatureList{$2};

	#print "[U] $2\n";
	}
	else
	{
	# process defined symbols

	push @$pDefFeatures, $defFeature;

	# update value of feature list
	$$pFeatureList{$defFeature} = $2;

	#print "[D] $defFeature = $2\n";
	}
	}
	# end of feature list
	elsif ($line =~ /"END FEATURE LIST"}/)
	{
	$isFeature = 0;
	}
	elsif ($line !~ /^[\s]*$/)
	{
	print "[Not Processed] \"$line\"\n";
	}

	#print "[$featureIndex] $$pSortedAllFeatures[$featureIndex] $line\n";
	$featureIndex++;
	}

	# check if begining of feature list
	if ($line =~ /feature_check\[\]/)
	{
	$isFeature = 1;
	$featureIndex = 0;
	}
	}
	}


	#******************************************************************************
	# FUNCTION
	# splitFilename
	# DESCRIPTION
	# xxx
	# PARAMETERS
	# $filename [IN] - filename
	# $refSubFilename [OUT] - reference to sub filename, may be NULL
	# RETURNS
	# main filename
	#******************************************************************************
	sub splitFilename()
	{
	my $filename;
	my $refSubFilename = "";
	my $mainFilename = "";

	($filename, $refSubFilename) = @_;

	if ($filename =~ /([^\s])(\.)([^\.]$)/)
	{
	#print "$filename [$1][$3]\n";
	$mainFilename = "$1";
	if ($refSubFilename != 0)
	{
	$$refSubFilename = "$3";
	}
	}
	return $mainFilename;
	}


	#******************************************************************************
	# FUNCTION
	# genLog
	# DESCRIPTION
	# xxx
	# PARAMETERS
	# $filename [IN] - log file pathname
	# RETURNS
	# none
	#******************************************************************************
	sub genLog()
	{
	my $logFilePathname;
	my $mismatchCFG_href;
	my $defFeatures_aref;
	my $featureData_href;
	my $undefFeatures_aref;
	my $sortedAllFeatures_aref;

	my $col1LenMax = 0;
	my $mismatchCount;
	my $allFeatureCount;
	my $defFeatureCount;
	my $undefFeatureCount;

	($logFilePathname, $mismatchCFG_href, $defFeatures_aref,
	$featureData_href, $undefFeatures_aref, $sortedAllFeatures_aref) = @_;

	open(hLogFile, ">$logFilePathname") or die "can't open $logFilePathname";

	open(hMEDFile, "<~med_mem_info.log") or die "can't open ~med_mem_info.log";

	while(<hMEDFile>){
	print hLogFile $_;
	}


	#$mismatchCount = keys(%{$mismatchCFG_href});
	$allFeatureCount = @$sortedAllFeatures_aref;
	$defFeatureCount = @$defFeatures_aref;
	$undefFeatureCount = @$undefFeatures_aref;

	$col1LenMax = 0;
	foreach my $feature (@$sortedAllFeatures_aref)
	{
	$col1LenMax = length($feature) if (length($feature)>$col1LenMax);
	}

	# result: Defined Features
	print hLogFile "\n$separation\n[MED Scenarios ($defFeatureCount)]\n$separation\n\n";
	foreach my $feature (@$defFeatures_aref)
	{
	print hLogFile sprintf("[D] %-*s%s\n", $col1LenMax+8,
	$feature, ${$featureData_href}{$feature});
	}
	print hLogFile "\n\n";
	close(hLogFile);
	close(hMEDFile);

	print "log generated at $logFilePathname\n";
	}