## @file BuildEnvXML.pm
# @ingroup userscripts clientscripts
#
# Uses information which is defined in the BuildEnvXML.xml to set up a machine
# specific environment, such as path for compilers.
#
# @todo Document this script.
#
# Copyright (c) 2009 Symbian Foundation Ltd. All rights reserved.
#
package BuildEnvXML;
use strict;
use XML::DOM;
use Cwd;
use Exporter;
our @ISA = qw(Exporter);
our @EXPORT_OK = qw(&getToolEnvironment &getLastErrorMsg &setDbgFile);
my $sToolEnv = "";
my $sLocalDir = cwd();
my $hParser = XML::DOM::Parser->new();
my $sErrorMsg = "";
my $toolSummary = "";
my $execLog = "";
my $dbgfile = "";
sub getToolEnvironment
{
my $sBuildEnvXML = shift;
my (@aCat) = @_;
my $hXMLfile = $hParser->parsefile ($sBuildEnvXML);
my $hNodes = $hXMLfile->getElementsByTagName ("context");
my $hSystemTools, my $hP4Tools, my $hCBRTools, my $sCat, my $nNumNodes;
if ($dbgfile ne "")
{
print "Logging output to file $dbgfile\n";
open DBGFILE, ">>$dbgfile" or die;
}
$sErrorMsg = "";
$sToolEnv = "";
my $nCatDepth = scalar(@aCat);
subTrace("Context Depth: $nCatDepth\n");
my $nLevel = ($nCatDepth-1);
$sCat = $aCat[$nLevel];
$nNumNodes = $hNodes->getLength;
my $hParentNode, my $sParentId;
for (my $nI = 0; $nI < $nNumNodes ; $nI++)
{
my $hNode = $hNodes->item ($nI);
my $hId = $hNode->getAttributeNode ("id");
# Discriminating Stages
subTrace("Context found: \"".$hId->getValue()."\"");
if (uc($hId->getValue()) eq uc($sCat))
{
subTrace("---> requested! analyzing...");
$hParentNode = $hNode->getParentNode;
for (;$nLevel>0;$nLevel--)
{
$sParentId = $hParentNode->getAttributeNode("id")->getValue;
subTrace("...from Parent context= ".$sParentId);
if ($sParentId ne $aCat[$nLevel-1]){ $nLevel =-1;}
$hParentNode = $hParentNode->getParentNode;
};
if (($nLevel>-1)&&($hParentNode->getNodeName ne "context"))
{
$hSystemTools = $hNode->getElementsByTagName ("tool", 0);
$nI = $nNumNodes;
}
}
}
if (!defined $hSystemTools)
{
subTrace("No Stage found for category $sCat !");
subTrace("Program Terminated.");
exit(0);
}
subTrace("");
subTrace("----------------------");
subTrace("Number of $sCat tools: ".$hSystemTools->getLength);
for (my $nI = 0; $nI < $hSystemTools->getLength; $nI++)
{
my $hTool = $hSystemTools->item ($nI);
my $hToolName = $hTool->getAttributeNode ("name");
subTrace("");
subTrace("----------------------");
subTrace("Verifying tool: ".$hToolName->getValue());
my $isToolNotFound = "true";
# Location element
my $hToolLocation = $hTool->getElementsByTagName("location")->item(0);
my $hToolLocationPath, my $hToolLocationStrict;
if (defined $hToolLocation)
{
$hToolLocationPath = $hToolLocation->getAttributeNode("value");
$hToolLocationStrict = $hToolLocation->getAttributeNode("strict");
subTrace("Expected Location: ".$hToolLocationPath->getValue());
}
# Verify element
my $hToolVerifys = $hTool->getElementsByTagName("verify");
my $nNumOfVerifys = $hToolVerifys->getLength;
for (my $nZ = 0; $nZ < $nNumOfVerifys; $nZ++)
{
my $hToolVerify = $hTool->getElementsByTagName("verify")->item($nZ);
my $hToolVerifyVersion = $hToolVerify->getAttributeNode("version");
my $hToolVerifyShowStopper = $hToolVerify->getAttributeNode("showstopper");
subTrace("Expected Version: ".$hToolVerifyVersion->getValue());
subPrint("\nVerifying tool: ".$hToolName->getValue()." (version ".$hToolVerifyVersion->getValue().")\n");
# Tool checks
my $hToolChecks = $hToolVerify->getElementsByTagName("check");
my $nNumOfChecks= $hToolChecks->getLength;
my $nCheckNum;
for (my $nJ = 0; $nJ < $nNumOfChecks; $nJ++)
{
$nCheckNum = $nJ+1;
subTrace("");
subTrace("Check #$nCheckNum:");
subPrint("Check #$nCheckNum");
my $hCheck = $hToolChecks->item($nJ);
my $hCheckCmd = $hCheck->getAttributeNode ("execute");
my $hCheckVar = $hCheck->getAttributeNode ("var");
my $hCheckValues = $hCheck->getAttributeNode ("values");
my $hCheckLog = $hCheck->getAttributeNode ("log");
my $hCheckExclu = $hCheck->getAttributeNode ("exclusive");
my $hCheckName = $hCheck->getAttributeNode ("name");
my $hCheckLocator= $hCheck->getAttributeNode ("locator");
my $hCheckSilent = $hCheck->getAttributeNode ("silent");
my $sCommand, my $sPattern, my $sToolCmd, my $sOut, my $sOutLocal, my $sCheckName;
my $versionFound = "";
my $sMsg = "";
# If Check is exclusive, we will only test this one:
if ($hCheckExclu->getValue() eq "true")
{
$nJ = $nNumOfChecks;
subTrace("This check is exclusive: the remaining checks will not be tested");
}
# Preparing system command to execute
if (defined $hCheckCmd)
{
$sCommand = $hCheckCmd->getValue();
if (defined $hToolLocation)
{
$sToolCmd= $hToolLocationPath->getValue();
$sCommand =~ s/\%location\%/$sToolCmd/g;
}
# Execute the command
subTrace("Check cmd: ".$sCommand."");
$sOut = `$sCommand 2>&1`;
$sOutLocal = $sOut;
# Check if tool cannot be found at expected location
if ($sOut =~/(not\srecognized)|(system\scannot\sfind)/)
{
$sOutLocal = "";
subTrace("Tool cannot be found at location: ".$hToolLocationPath->getValue());
subLogErrorMsg($hToolLocationStrict->getValue(), $hToolName->getValue()." CANNOT BE FOUND IN THE EXPECTED LOCATION: "
.$hToolLocationPath->getValue());
if ($hToolLocationStrict->getValue() eq "true")
{
subTrace("LOCATION STRICT activated, program terminated");
$sMsg .= "[ERROR] wrong location\n";
#return "";
}
else
{
$sMsg .= "[WARNING] wrong location\n";
}
}
else
{
if ((defined $hToolLocation)&&(defined $hCheckCmd))
{
$sCommand =~ /(.*)(\\).*$/i;
my $sTmp = $1;
$sTmp =~ s/^\s+//;
$sTmp =~ s/\s+$//;
$sToolEnv = $sTmp.";".$sToolEnv;
subTrace("Tool path OK.");
subTrace("New appender: \"".$sToolEnv."\"");
}
$isToolNotFound = "false";
}
# Check if tool can be found with the Environment PATH
$sCommand =~ s/.*(\\)(.*)$/\2/i;
subTrace("Try command from ENV PATH: ".$sCommand);
if (!defined $hCheckName)
{
$sCheckName = $sCommand;
}
else
{
$sCheckName = $hCheckName->getValue();
}
subPrint(" [$sCheckName]: ");
$sOut = `$sCommand 2>&1`;
if ($sOut =~/(not\srecognized)|(system\scannot\sfind)/)
{
$sOut = "";
my $type = "ERROR";
if ($isToolNotFound eq "false") {$type = "WARNING";}
subTrace("$type: ".$hToolName->getValue()." CANNOT BE FOUND IN THE SYSTEM PATH");
subLogErrorMsg($isToolNotFound, $hToolName->getValue()." CANNOT BE FOUND IN THE SYSTEM PATH");
$sMsg .= "[$type] NOT FOUND IN SYSTEM PATH\n";
if ($isToolNotFound eq "true") {next;}
#return "";
}
}
else
{ # Check by verifying an env variable
subPrint(" [".$hCheckVar->getValue()."]: ");
$sCommand = "ECHO %".$hCheckVar->getValue()."%";
subTrace("Check var: ".$hCheckVar->getValue());
$sOut = `$sCommand 2>&1`;
$sOut =~ s/^\s*//;
$sOut =~ s/\s*$//;
}
# Log the output if necessary
if ($hCheckLog->getValue() eq "true")
{
subTrace("command: $sCommand");
subTrace("logged output: ");
subLog("Verifying \"".$hToolName->getValue()." [version ".$hToolVerifyVersion->getValue().
"]\" -- check #$nCheckNum:");
subLog("Executing: $sCommand");
subLog($sOut);
}
# Perform the check against given values
if (defined $hCheckValues)
{
my $sOutCopy = $sOut;
my $bResultOk = "false";
$sPattern = $hCheckValues->getValue();
if (defined $hCheckLocator)
{
my $sLocator = $hCheckLocator->getValue();
$sOut =~ s/.*$sLocator.*/\1/msi;
subTrace("Searching in locator: ".$sOut);
$sOutLocal =~ s/.*$sLocator.*/\1/msi;
}
else
{
$sOut =~ s/.*($sPattern).*/\1/smi;
$sOutLocal =~ s/.*($sPattern).*/\1/smi;
}
# Log the current version found
$versionFound = $sOut.$sOutLocal;
if ($sOut eq $sOutLocal)
{
$versionFound = $sOut;
}
elsif (($sOut.$sOutLocal ne $sOut) and ($sOut.$sOutLocal ne $sOutLocal) and ($sOut ne $sOutLocal))
{
$versionFound = "$sOut or $sOutLocal [Value Mismatch]";
}
if ($versionFound eq "") {$versionFound = "not found";}
#$sPattern =~ s/(\\|\/|\.|\*|\[|\]|\(|\)|\$|\{|\})/\\\1/g;
#$sPattern = "($sPattern)";
subTrace("Check against pattern: ".$sPattern);
# Check the Environment Variable
if (defined $hCheckVar)
{
$sOut = $sOutCopy;
my $valueTested = $hCheckVar->getValue();
if ($sOut =~ /%$valueTested%/) {$sOut = "not defined!";}
elsif ( $sOut =~ m/$sPattern/smi )
{
$bResultOk = "true";
if ($hCheckSilent->getValue() eq "true") { $sOut = "ok. ";}
}
$versionFound = "$sOut";
} # Or Check the command executed (for version checking...)
elsif ( ( ( $sOut =~ s/.*($sPattern).*/\1/smi ) and (( $sOutLocal =~ s/.*($sPattern).*/\1/smi ) or ($sOutLocal eq "")) ) ||
( ( $sOutLocal =~ s/.*($sPattern).*/\1/smi ) and ($sOut eq "") ) )
{
$bResultOk = "true";
subTrace("Value OK");
if ($versionFound eq "" || $hCheckSilent->getValue() eq "true") { $versionFound = "ok. ";}
}
elsif (!defined $hCheckLocator)
{
$versionFound = "";
}
# Log the warnings/errors regarding version checking
if ($bResultOk eq "false")
{
if ($versionFound eq "") { $versionFound = "wrong value. ";}
subTrace("ERROR: VALUE CHECK FAILED");
subLogErrorMsg($hToolVerifyShowStopper->getValue(), $hToolName->getValue()." VALUE INCORRECT");
if ($hToolVerifyShowStopper->getValue() eq "true")
{
$sMsg .= "[ERROR] WRONG VALUE\n";
subTrace("SHOWSTOPPER RAISED: program should be terminated");
}
else
{
subTrace("No Showstopper, continuing analysis...");
$sMsg .= "[WARNING] Wrong Value\n";
}
}
}
chomp($versionFound);
&subPrint ("$versionFound\n$sMsg");
&printToolSummary;
&printLog;
}
}
}
close DBGFILE;
return $sToolEnv;
}
sub subTrace
{
my $sString = $_[0];
if ($dbgfile ne "")
{
print DBGFILE "$sString\n";
}
}
sub subPrint
{
my $sString = $_[0];
$toolSummary .= "$sString";
}
sub printToolSummary
{
print $toolSummary."\n";
$toolSummary="";
}
sub subLog
{
my $sString = $_[0];
$execLog .= "[LOG] $sString\n";
if ($dbgfile ne "")
{
print DBGFILE "[LOG] $sString\n";
}
}
sub printLog
{
#print $execLog;
$execLog="";
}
sub subLogErrorMsg
{
my $isError = shift;
my $msg = shift;
my $type = "WARNING";
if ($isError eq "true") {$type = "ERROR";}
$sErrorMsg = $sErrorMsg."\n[$type] ".$msg;
}
sub getLastErrorMsg
{
return $sErrorMsg;
}
sub setDbgFile
{
$dbgfile = shift;
}
1;