#
# perl module with subroutines used as part of compact model QA (runQaTests.pl)
#
#
# Rel Date Who Comments
# ==== ========== ============= ========
# 1.4 Colin McAndrew Q added as AC output option
# Unused AC simulations skipped
# 1.2 06/30/06 Colin McAndrew Floating node support added
# Noise simulation added
# Other general cleanup
# 1.0 04/13/06 Colin McAndrew Initial version
#
package modelQa;
#use strict; # hirearchical read cannot be done while "strict refs" is in use
#
# This subroutine processes the generic (not test specific) setup information.
# It sets the information in global variables.
#
sub processSetup {
my(@Setup)=@_;
my(@Field,$pin,$temperature);
undef(%main::isLinearScale);
undef(%main::isAreaScale);
undef(%main::DefaultTemperature);
$main::doMfactorTest=0;
$main::doScaleTest =0;
$main::doShrinkTest =0;
$main::doPinFlipTest=0;
$main::doPNFlipTest =0;
@main::Pin=();
foreach (@Setup) {
@Field=split(/[\s,]+/,$_);
if (s/^keyLetter\s+//i) {
if ($_ !~ /^[a-zA-Z]$/) {
die("ERROR: bad keyLetter specification, stopped");
}
$main::keyLetter=$_;
next;
}
if (s/^verilogaFile\s+//i) {
$main::verilogaFile=$_;
if (! -f $main::verilogaFile) {
die("ERROR: cannot find file $main::verilogaFile, stopped");
}
next;
}
if (s/^(pins|terminals)\s+//i) {
push(@main::Pin,@Field[1..$#Field]);
foreach $pin (@main::Pin) {
$main::isPin{$pin}=1;
if ($pin !~ /^[a-zA-Z][a-zA-Z0-9]*$/) { # underscores are not allowed
die("ERROR: bad pin name specification $pin, stopped");
}
}
next;
}
if (/^symmetric(Pins|Terminals)/i) {
if ($#Field != 2) {
die("ERROR: bad symmetricPins specification, stopped");
}
$main::isSymmetryPin{$Field[1]}=1;
$main::isSymmetryPin{$Field[2]}=1;
$main::flipPin{$Field[1]}=$Field[2];
$main::flipPin{$Field[2]}=$Field[1];
$main::doPinFlipTest=1;
next;
}
if (s/^pTypeSelectionArguments\s+//i) {
s/\s*=\s*/=/g;
$main::pTypeSelectionArguments=$_;
next;
}
if (s/^(nType|type|model)SelectionArguments\s+//i) {
s/\s*=\s*/=/g;
$main::nTypeSelectionArguments=$_;
next;
}
if (/^checkPolarity/i) {
if ($#Field<1 || ($Field[1] !~ /^[yn01]/i)) {
die("ERROR: bad checkPolarity specification, stopped");
}
if ($Field[1] =~ /^[y1]/i) {
$main::doPNFlipTest=1;
} else {
$main::doPNFlipTest=0;
}
next;
}
if (/^scaleParameters/i) {
foreach (@Field[1..$#Field]) {
if (/^m$/i) {$main::doMfactorTest=1}
if (/^scale$/i) {$main::doScaleTest =1}
if (/^shrink$/i) {$main::doShrinkTest =1}
}
next;
}
if (/^linearScale/i) {
foreach (@Field[1..$#Field]) {
$main::isLinearScale{$_}=1;
}
next;
}
if (/^areaScale/i) {
foreach (@Field[1..$#Field]) {
$main::isAreaScale{$_}=1;
}
next;
}
if (/^temperature/i) {
push(@main::DefaultTemperature,@Field[1..$#Field]);
next;
}
if (/^float/i) {
foreach (@Field[1..$#Field]) {
$main::isGeneralFloatingPin{$_}=1;
}
next;
}
die("ERROR: unknown setup directive $Field[0], stopped");
}
if ($#main::Pin < 1) {
die("ERROR: there must be two or more device pins, stopped");
}
foreach $pin (keys(%main::isSymmetryPin)) {
if (!$main::isPin{$pin}) {
die("ERROR: symmetry pin $pin is not a specified device pin, stopped");
}
}
foreach $pin (keys(%main::isGeneralFloatingPin)) {
if (!$main::isPin{$pin}) {
die("ERROR: floating pin $pin is not a specified device pin, stopped");
}
}
unless (@main::DefaultTemperature) {
@main::DefaultTemperature=(27);
}
foreach $temperature (@main::DefaultTemperature) {
if ($temperature!~/^$main::number$/) {
die("ERROR: bad temperature value specified, stopped");
}
}
if ($main::simulatorName =~ /mica|ads/i && defined($main::verilogaFile)) {
$main::keyLetter="a";
}
if ($main::simulatorName =~ /hspice/i && defined($main::verilogaFile)) {
$main::keyLetter="X";
}
if ($main::simulatorName =~ /spectre/i && !defined($main::keyLetter)) {
$main::keyLetter="x";
}
if (!defined($main::keyLetter)) {
die("ERROR: no keyLetter specified, stopped");
}
# if (!defined($main::nTypeSelectionArguments)) {
# die("ERROR: no model selection arguments specified, stopped");
#}
@main::Variants=("standard");
if ($main::doPinFlipTest&&$main::doPNFlipTest) {
push(@main::Variants,"Flip_N");
push(@main::Variants,"noFlip_P");
push(@main::Variants,"Flip_P");
if (!defined($main::pTypeSelectionArguments)) {
die("ERROR: no pType model selection arguments specified, stopped");
}
} elsif ($main::doPinFlipTest) {
push(@main::Variants,"Flip_N");
} elsif ($main::doPNFlipTest) {
push(@main::Variants,"noFlip_P");
if (!defined($main::pTypeSelectionArguments)) {
die("ERROR: no pType model selection arguments specified, stopped");
}
}
if ($main::doShrinkTest ) {push(@main::Variants,"shrink")}
if ($main::doScaleTest ) {push(@main::Variants,"scale")}
if ($main::doMfactorTest) {push(@main::Variants,"m")}
}
#
# This subroutine processes test specific setup information.
# It sets the information in global variables.
#
sub processTestSpec {
my(@Spec)=@_;
my($i,$arg,$temperature,$bias,$pin,@Field,$oneOverTwoPi,$name,$value,%isAnalysisPin,%AlreadyHave,%IndexFor);
$main::outputDc=0;$main::outputAc=0;$main::outputNoise=0;
undef($main::biasSweepPin);undef($main::biasSweepSpec);undef(@main::BiasSweepList);
undef($main::biasListPin);undef($main::biasListSpec);
undef($main::frequencySpec);
undef($main::Temperature);
@main::InstanceParameters=();
@main::Outputs=();
@main::ModelParameters=();
@main::TestVariants=@main::Variants;
undef(%main::BiasFor);
if (%main::isGeneralFloatingPin) {
%main::isFloatingPin=%main::isGeneralFloatingPin;
} else {
undef(%main::isFloatingPin);
}
undef(%isAnalysisPin);
undef(@main::Temperature);
undef(%main::referencePinFor);
foreach $pin (@main::Pin) {
$main::needAcStimulusFor{$pin}=0;
}
foreach (@Spec) {
if (s/^output[s]?\s+//i) {
s/\(/ /g;s/\)//g;
@Field=split(/[\s,]+/,$_);
for ($i=0;$i<=$#Field;++$i) {
if ($Field[$i] =~ /^[IV]$/) {
$main::outputDc=1;
++$i;
if (!$main::isPin{$Field[$i]}) {
die("ERROR: pin $Field[$i] listed for DC output is not a specified pin, stopped");
}
push(@main::Outputs,$Field[$i]);
}
if ($Field[$i] =~ /^[CGQ]$/) {
$main::outputAc=1;
push(@main::Outputs,lc($Field[$i]));
++$i;
if (!$main::isPin{$Field[$i]}) {
die("ERROR: pin $Field[$i] listed for AC output is not a specified pin, stopped");
}
$main::Outputs[$#main::Outputs].=" $Field[$i]";
$isAnalysisPin{$Field[$i]}=1;
++$i;
if (!$main::isPin{$Field[$i]}) {
die("ERROR: pin $Field[$i] listed for AC output is not a specified pin, stopped");
}
$main::Outputs[$#main::Outputs].=" $Field[$i]";
$main::needAcStimulusFor{$Field[$i]}=1;
$isAnalysisPin{$Field[$i]}=1;
}
if ($Field[$i] =~ /^N$/) {
my($noi1,$noi2);
$main::outputNoise=1;
++$i;
$noi1 = $Field[$i];
$isAnalysisPin{$noi1}=1;
if (!$main::isPin{$noi1}) {
die("ERROR: pin $noi1 listed for noise output is not a specified pin, stopped");
}
if ($#main::Outputs==0) {
die("ERROR: can only specify one pin for noise output, stopped");
}
push(@main::Outputs,$noi1);
++$i;
if ($i <= $#Field) {
$noi2 = $Field[$i];
$isAnalysisPin{$noi2}=1;
if (!$main::isPin{$noi2}) {
die("ERROR: pin $noi2 listed for noise output is not a specified pin, stopped");
}
$main::outputNoise=2;
push(@main::Outputs,$noi2);
}
}
}
next;
}
if (/^biases\s+/i) {
s/V\s*\(\s*/V(/;s/\s*\)/)/;
s/V\(([a-zA-Z0-9]+),([a-zA-Z0-9]+)\)/V($1_$2)/; # convert V(n1,n2) to V(n1_n2)
@Field=split(/[\s,]+/,$_);
for ($i=1;$i<=$#Field;++$i) {
if ($Field[$i] !~ /=/) {
die("ERROR: biases specifications must be V(pin)=number, stopped");
}
$Field[$i]=~s/V\s*\(\s*//;$Field[$i]=~s/\s*\)//;
($pin,$bias)=split("=",$Field[$i]);
if ($bias !~ /^$main::number$/) {
die("ERROR: biases specifications must be V(pin)=number, stopped");
}
if ($pin =~ s/_([a-zA-Z0-9]+)$//) { # this a V(n1,n2) pin (not ground) referenced bias
$main::referencePinFor{$pin}=$1;
}
$main::BiasFor{$pin}=$bias;
}
next;
}
if (s/^(biasSweep|sweepBias)\s+//i) {
if (defined($main::biasSweepSpec)) {
die("ERROR: can only have one biasSweep specification, stopped");
}
s/V\s*\(\s*//i;s/\s*\)//;
@Field=split(/[=,\s]+/,$_);
if ($#Field!=3) {
die("ERROR: biasSweep specification must be V(pin)=start,stop,step, stopped");
}
$main::biasSweepPin=$Field[0];
if (($Field[1] !~ /^$main::number$/) || ($Field[2] !~ /^$main::number$/) || ($Field[3] !~ /^$main::number$/)) {
die("ERROR: biasSweep start,stop,step must be numbers, stopped");
}
if ($Field[1] == $Field[2]) {
die("ERROR: biasSweep start and stop must be different, stopped");
}
if ($Field[3] == 0.0) {
die("ERROR: biasStep must be non-zero, stopped");
}
@main::BiasSweepList=();
if ($Field[2] > $Field[1]) {
$Field[3]=abs($Field[3]);
for ($bias=$Field[1];$bias<=$Field[2]+0.1*$Field[3];$bias+=$Field[3]) {
push(@main::BiasSweepList,$bias);
}
} else {
$Field[3]=-1.0*abs($Field[3]);
for ($bias=$Field[1];$bias>=$Field[2]+0.1*$Field[3];$bias+=$Field[3]) {
push(@main::BiasSweepList,$bias);
}
}
$main::biasSweepSpec=join(" ",@Field[1..3]);
$main::BiasFor{$main::biasSweepPin}=$Field[1];
next;
}
if (s/^(biasList|listBias)\s+//i) {
if (defined($main::biasListSpec)) {
die("ERROR: can only have one biasList specification, stopped");
}
s/V\s*\(\s*//i;s/\s*\)//;
@Field=split(/[=,\s]+/,$_);
if ($#Field < 2) {
die("ERROR: biasList specification must be V(pin)=val1,val2,..., stopped");
}
$main::biasListPin=$Field[0];
for ($i=1;$i<=$#Field;++$i) {
if ($Field[$i] !~ /^$main::number$/) {
die("ERROR: biasList values must be numbers, stopped");
}
}
$main::biasListSpec=join(" ",@Field[1..$#Field]);
$main::BiasFor{$main::biasListPin}=$Field[1];
next;
}
if (s/^verilogAfile\s+//i) {
$main::verilogaFile=$_;
if (! -f $main::verilogaFile) {
die("ERROR: cannot find file $main::verilogaFile, stopped");
}
next;
}
if (s/^(pins|terminals)\s+//i) {
foreach $pin (@main::Pin) {
$main::isPin{$pin}=0;
}
@main::Pin = split(/[\s,]+/,$_);
foreach $pin (@main::Pin) {
$main::isPin{$pin}=1;
if ($pin !~ /^[a-zA-Z][a-zA-Z0-9]*$/) { # underscores are not allowed
die("ERROR: bad pin name specification $pin, stopped");
}
}
next;
}
if (s/^instanceParameters\s+//i) {
foreach $arg (split(/\s+/,$_)) {
if ($arg !~ /.=./) {
die("ERROR: instance parameters must be name=value pairs, stopped");
}
($name,$value)=split(/=/,$arg);
$value=~s/\(//;$value=~s/\)//; # get rid of possible parens
if ($value !~ /^$main::number$/) {
die("ERROR: instance parameter value in $arg is not a number, stopped");
}
push(@main::InstanceParameters,$arg);
}
next;
}
if (s/^modelParameters\s+//i) {
foreach $arg (split(/\s+/,$_)) {
$arg_file = $main::srcdir . $arg;
if ($arg !~ /.=./ && ! -r $arg_file) {
die("ERROR: model parameters must be name=value pairs or a file name, stopped");
}
if (-r $arg_file) {
if (!open(IF,"$arg_file")) {
die("ERROR: cannot open file $arg_file, stopped");
}
while (<IF>) {
chomp;s/\s*=\s*/=/g;
s/^\+\s*//;s/^\s+//;s/\s+$//;
($name,$value)=split(/=/,$_);
$value=~s/\(//;$value=~s/\)//; # get rid of possible parens
if ($value !~ /^$main::number$/) {
die("ERROR: model parameter value in $_ is not a number, stopped");
}
if (!defined($AlreadyHave{$name})) {
push(@main::ModelParameters,"$name=$value");
$AlreadyHave{$name}=1;
$IndexFor{$name}=$#main::ModelParameters;
} else {
if ($AlreadyHave{$name} == 1 && $main::printWarnings) {
printf("WARNING: parameter $name defined more than once, last value specified will be used\n");
}
$AlreadyHave{$name}=2;
$main::ModelParameters[$IndexFor{$name}]="$name=$value";
}
}
close(IF);
} else {
($name,$value)=split(/=/,$arg);
$value=~s/\(//;$value=~s/\)//; # get rid of possible parens
if ($value !~ /^$main::number$/) {
die("ERROR: model parameter value in $arg is not a number, stopped");
}
if (!defined($AlreadyHave{$name})) {
push(@main::ModelParameters,"$name=$value");
$AlreadyHave{$name}=1;
$IndexFor{$name}=$#main::ModelParameters;
} else {
if ($AlreadyHave{$name} == 1 && $main::printWarnings) {
printf("WARNING: parameter $name defined more than once, last value specified will be used\n");
}
$AlreadyHave{$name}=2;
$main::ModelParameters[$IndexFor{$name}]="$name=$value";
}
}
}
next;
}
if (s/^freq[uency]*\s+//i) {
if (!/^(lin|oct|dec)\s+(\d+)\s+($main::number)\s+($main::number)$/) {
die("ERROR: bad frequency sweep specification, stopped");
}
$main::fType=$1;$main::fSteps=$2;$main::fMin=$3;$main::fMax=$4;
$main::frequencySpec=$_;
next;
}
if (s/^temperature\s+//i) {
push(@main::Temperature,split(/[,\s]+/,$_));
foreach $temperature (@main::Temperature) {
if ($temperature !~ /^$main::number$/) {
die("ERROR: bad temperature value specified, stopped");
}
}
next;
}
if (s/^float[ingpinode]*\s+//i) {
@Field=split(/[\s,]+/,$_);
if ($#Field < 0) {
die("ERROR: bad floating pin specification, stopped");
}
foreach (@Field) {
if (!$main::isPin{$_}) {
die("ERROR: floating pin $_ is not a specified device pin, stopped");
}
$main::isFloatingPin{$_}=1;
}
next;
}
if (/^symmetric(Pins|Terminals)/i) {
@Field=split(/[\s,]+/,$_);
if ($#Field == 2) {
die("ERROR: cannot add symmetric pin specification per test, stopped");
} else {
@main::TestVariants=();
foreach $variant (@main::Variants) {
if ($variant ne "Flip_N" && $variant ne "Flip_P") {
push(@main::TestVariants,$variant);
}
}
}
next;
}
die("ERROR: unknown test directive\n$_\nstopped");
}
unless (@main::Temperature) {
@main::Temperature=@main::DefaultTemperature;
}
if (abs($main::outputDc+$main::outputAc+($main::outputNoise>0)-1) > 0.001) {
die("ERROR: outputs specified must be one of DC, AC or noise, stopped");
}
if ($main::outputDc && !defined($main::biasSweepSpec)) {
die("ERROR: no bias sweep spec defined for DC testing, stopped");
}
if ($main::outputNoise && !defined($main::frequencySpec)) { # default for noise is f=1
$main::frequencySpec="lin 1 1 1";
$main::fType="lin";$main::fSteps=1;$main::fMin=1;$main::fMax=1;
}
if ($main::outputAc && !defined($main::frequencySpec)) { # default for AC is omega=1
$oneOverTwoPi=1.0/(8.0*atan2(1.0,1.0));
$main::frequencySpec="lin 1 $oneOverTwoPi $oneOverTwoPi";
$main::fType="lin";$main::fSteps=1;$main::fMin=$oneOverTwoPi;$main::fMax=$oneOverTwoPi;
}
if ($main::outputAc && ($main::frequencySpec eq "lin") && ($main::simulatorName =~ /hspice|ads/i)) {
# AC spec is number of points, not number of steps, for hspice and ads
++$main::fSteps if ($main::fMin != $main::fMax);
$main::frequencySpec="$main::fType $main::fSteps $main::fMin $main::fMax";
}
foreach $pin (@main::Pin) {
if (!defined($main::BiasFor{$pin}) && !defined($main::isFloatingPin{$pin})) {
die("ERROR: a bias must be specified for all non-floating pins, stopped");
}
if ($main::isSymmetryPin{$pin} && $main::isFloatingPin{$pin}) {
die("ERROR: a floating pin cannot be specified as a symmetry pin, stopped");
}
if ($isAnalysisPin{$pin} && $main::isFloatingPin{$pin} && !main::outputNoise) {
die("ERROR: a floating pin can only have its voltage measured in DC analyses, stopped");
}
}
if (!defined($main::biasListPin)) { # if not specified make a dummy bias list, to simplify processing later
$main::biasListPin="dummyPinNameThatIsNeverUsed";
$main::biasListSpec="0";
} elsif (defined($main::isFloatingPin{$main::biasListPin})) {
die("ERROR: a bias list cannot be specified for a floating pin, stopped");
}
if (!defined($main::biasSweepPin)) { # if not specified make a dummy bias sweep, to simplify processing later
if($main::biasListPin eq $main::Pin[0]) {
$main::biasSweepPin=$main::Pin[1];
} else {
$main::biasSweepPin=$main::Pin[0];
}
if (!defined($main::BiasFor{$main::biasSweepPin})) {
$main::biasSweepSpec="0 0 0";
@main::BiasSweepList="vin";
} else {
$main::biasSweepSpec="$main::BiasFor{$main::biasSweepPin} $main::BiasFor{$main::biasSweepPin} 0";
@main::BiasSweepList=($main::BiasFor{$main::biasSweepPin});
}
} elsif (defined($main::isFloatingPin{$main::biasSweepPin})) {
die("ERROR: a bias sweep cannot be specified for a floating pin, stopped");
}
}
#
# This subroutine reads in a test specification file.
# It cleans up the syntax by getting rid of comments
# and continutation lines, processing conditionals,
# and splitting up the contents of the file into
# global specifications and individual test specifications.
#
# On call:
# $main::qaSpecFile must be set to the name of the file that
# contains the qaSpec information
# On return:
# @main::Setup contains general, test-nonspecific information
# @main::Test contains a list of the test defined in the qaSpec file
# %main::TestSpec contains each test specification, hash keys are @main::Test elements
#
sub readQaSpecFile {
my(@File,@RawFile,@Field);
@RawFile=&readHierarchicalFile($main::qaSpecFile);
foreach (@RawFile) {
s%\s*//.*%%; # eliminate C++ style comments
s/^\s+//;s/\s+$//; # eliminate leading and trailing white space
next if (/^$/); # ignore blank lines
s/\s*=\s*/=/g; # eliminate space around "=" in name=value pairs
if (/^\+/) { # process a continuation line
s/^\+\s*//; # eliminate continuation "+" and any following whitespace
$File[$#File]=~s/\s*\\$//; # get rid of possible additional continuation on previous line
$File[$#File].=" $_"; # add to previous line
next;
}
if (($#File >= 0) && ($File[$#File] =~ /\\$/)) { # add to previous line if that had an end-of-line continuation
$File[$#File]=~s/\s*\\$//;
$File[$#File].=" $_";
} else {
push(@File,$_);
}
}
@File=&processIfdefs(\%main::Defined,@File); # process ifdef's to get conditional-free qaSpec
@main::Test=();@main::Setup=();
foreach (@File) { # process the qaSpec
if (/^test(name)?\s+/i) {
@Field=split;
if ($#Field < 1) {
die("ERROR: no test name specified for a test directive, stopped");
}
push(@main::Test,$Field[1]);
@{$main::TestSpec{$main::Test[$#main::Test]}}=();
next;
}
if ($#main::Test >= 0) {
push(@{$main::TestSpec{$main::Test[$#main::Test]}},$_);
} else {
push(@main::Setup,$_);
}
}
}
sub readHierarchicalFile {
my($fileName,$hierarchyLevel)=@_;
my(@File,$FH,$includeFileName);
if (!defined($hierarchyLevel)) {
$hierarchyLevel=0;
}
$FH="file".$hierarchyLevel;
if (!open($FH,$fileName)) {
die("ERROR: cannot open file $fileName, stopped");
}
@File=();
while (<$FH>) {
chomp;
if (/^\s*\`include\s+/) {
($includeFileName=$')=~s/"//g;
++$hierarchyLevel;
push(@File,&readHierarchicalFile($includeFileName,$hierarchyLevel));
--$hierarchyLevel;
} else {
push(@File,$_);
}
}
close($FH);
return(@File);
}
#
# This subroutine processes the `ifdef statements (recursively, so nested `ifdef's are handled)
# and returns the test specification with the appropriate blocks included and excluded.
# Note that the simulator name is defined, so that
# simulator specific directives are automatically included.
#
sub processIfdefs {
my($defRef,@Input)=@_;
my(%Defined,$i,$block,@Field,$start,$middle,$end,$ifdefLevel,$maxIfdefLevel);
my(@Insert);
%Defined=%$defRef;
for ($i=0;$i<=$#Input;++$i) {
if ($Input[$i] =~ /^`(define|undef)/) {
@Field=split(/\s+/,$Input[$i]);
if ($#Field > 0) {
if ($Input[$i] =~ /^`define/) {
$Defined{$Field[1]}=1;
} else {
$Defined{$Field[1]}=0;
}
}
splice(@Input,$i,1);
--$i;
next;
}
if ($Input[$i] =~ /^`ifdef\s+/) {
$start=$i;
$ifdefLevel=1;$maxIfdefLevel=1;
undef($middle);
for ($end=$start+1;$end<=$#Input;++$end) {
if ($Input[$end] =~ /^`ifdef/) {
++$ifdefLevel;
if ($ifdefLevel > $maxIfdefLevel) {$maxIfdefLevel=$ifdefLevel}
}
if ($Input[$end] =~ /^`end/) {--$ifdefLevel}
if ($Input[$end] =~ /^`else/ && $ifdefLevel == 1) {$middle=$end}
last if ($ifdefLevel == 0);
}
if (($end > $#Input) && ($ifdefLevel > 0)) {
die("ERROR: `ifdef not terminated, stopped");
}
($block=$Input[$i])=~s/^`ifdef\s+//;
if ($maxIfdefLevel > 1) {
if (!defined($middle)) {$middle=$end}
@Insert=();
if ($Defined{$block}) {
if ($start+1 <= $middle-1) {
@Insert=&processIfdefs(\%Defined,@Input[$start+1..$middle-1]);
}
} else {
if ($middle+1 <= $end-1) {
@Insert=&processIfdefs(\%Defined,@Input[$middle+1..$end-1]);
}
}
splice(@Input,$start,$end-$start+1,@Insert);
} else {
if (!defined($middle)) {$middle=$end}
@Insert=();
if ($Defined{$block}) {
if ($start+1 <= $middle-1) {
@Insert=@Input[$start+1..$middle-1]
}
} else {
if ($middle+1 <= $end-1) {
@Insert=@Input[$middle+1..$end-1];
}
}
splice(@Input,$start,$end-$start+1,@Insert);
}
--$i;
next;
}
if ($Input[$i] =~ /^`/) {die("ERROR: bad directive\n$Input[$i]\nstopped")}
}
return(@Input);
}
sub unScale {
#
# call: $Result=&unScale($Scalar);
#
# If $Scalar is a SPICE-like scaled number then $Result is the value
# of that number, else $Result is just $Scalar.
#
my($String)=@_;
my($Result);
$Result=$String;
if ($String =~ /^([+-]?[0-9]+[.]?[0-9]*|[+-]?[.][0-9]+)T/i) {
$Result=$1*1e12;
} elsif ($String =~ /^([+-]?[0-9]+[.]?[0-9]*|[+-]?[.][0-9]+)G/i) {
$Result=$1*1e9;
} elsif ($String =~ /^([+-]?[0-9]+[.]?[0-9]*|[+-]?[.][0-9]+)(M|meg|x)/) {
$Result=$1*1e6;
} elsif ($String =~ /^([+-]?[0-9]+[.]?[0-9]*|[+-]?[.][0-9]+)K/i) {
$Result=$1*1e3;
} elsif ($String =~ /^([+-]?[0-9]+[.]?[0-9]*|[+-]?[.][0-9]+)m/) {
$Result=$1*1e-3;
} if ($String =~ /^([+-]?[0-9]+[.]?[0-9]*|[+-]?[.][0-9]+)u/) {
$Result=$1*1e-6;
} elsif ($String =~ /^([+-]?[0-9]+[.]?[0-9]*|[+-]?[.][0-9]+)n/) {
$Result=$1*1e-9;
} elsif ($String =~ /^([+-]?[0-9]+[.]?[0-9]*|[+-]?[.][0-9]+)p/) {
$Result=$1*1e-12;
} elsif ($String =~ /^([+-]?[0-9]+[.]?[0-9]*|[+-]?[.][0-9]+)f/) {
$Result=$1*1e-15;
} elsif ($String =~ /^([+-]?[0-9]+[.]?[0-9]*|[+-]?[.][0-9]+)a/) {
$Result=$1*1e-18;
}
return($Result);
}
sub platform {
#
# This subroutines returns a string that includes the processor
# type, OS name, and OS version. This string is used as one level
# of the directory hierarchy for storing test results, because
# simulation results can vary with processor and OS.
#
# The UNIX uname command is used to get the appropriate information.
# If the system appears to be Windows, then the perl Config module
# information is used instead. However this information is generated
# as part of the Perl build, and so may not relate to the machine
# on which it is being run.
#
use Config;
my($osName,$osVer,$archName)=($modelQa::Config{osname},$modelQa::Config{osvers},$modelQa::Config{archname});
my($platform);
if ($osName !~ /win/i) {
open(UNAME,"uname -p|") or die("ERROR: cannot determine processore and OS information, stopped");
chomp($archName=<UNAME>);close(UNAME);
if ($archName eq "unknown") {
open(UNAME,"uname -m|");chomp($archName=<UNAME>);close(UNAME);
}
open(UNAME,"uname -s|");chomp($osName=<UNAME>);close(UNAME);
open(UNAME,"uname -r|");chomp($osVer =<UNAME>);close(UNAME);
}
$platform = "${archName}_${osName}_${osVer}";
$platform =~ s/\s+/-/g;
$platform =~ s|[()/]||g;
return($platform);
}
1;