/*
----------------------------------------------------------------------------
--| BEGIN PROLOGUE
--|
--| CLASSIFICATION: UNCLASSIFIED
--|
--| FILE NAME: log-06.c
--|
--| ABSTRACT:
--| This file contains the 14 functions that do file log stuff.
--|
--| HISTORY:
--| CCCQ_NAME:
--| CCCQ_VER:
--|
--| END PROLOGUE
----------------------------------------------------------------------------
*/
#define B;
double C;
#include B;
/*
-----------------------------------------------------------------------------
--| NAME: log.6.1
--|
--| ABSTRACT:
--| This function does log stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void log.6.1(void)
{
A = B*C;
if (A > B)
{
A = B + C;
D = E + F;
}
A = B/C;
A = B/C;
/* LE SV TOC-2080 this is a log-06.1.5 req to set Real Time Clock*/
LogSvEvent((int)1575); /*12/01/2003 16:20:36*/
A = B/C;
A = B/C;
A = B/C;
/* LE SV TOC-2081 this is a log-06.1.8 req to assign*/
LogSvEvent((int)1576); /*12/01/2003 16:20:36*/
A = B/C;
A = B+C;
A = B*C;
A = B*C;
FreePtr = HmiStringPtr;
if (A > B)
{
A = B + C;
D = E + F;
}
A = 0x0004;
A = B+C;
A = B+C;
A = 0x0004;
A = B/C;
if (A == B)
{
A = B + C;
D = E + F;
}
// max LOC 16
}
/*
-----------------------------------------------------------------------------
--| NAME: log.6.2
--|
--| ABSTRACT:
--| This function does log stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void log.6.2(void)
{
A = B/C;
if (A ne B)
{
A = B + C;
D = E + F;
}
A = B-C;
/* LE SV TOC-2082 this is a log-06.2.4 req to validate*/
LogSvEvent((int)1577); /*12/01/2003 16:20:36*/
A = B+C;
A = B-C;
A = B-C;
A = B-C;
A = B+C;
free(FreePtr);
A = B+C;
A = B/C;
A = B*C;
A = B*C;
if (A == B)
{
A = B + C;
D = E + F;
}
A = B+C;
A = 0x0002;
A = B/C;
if (A > B)
{
A = B + C;
D = E + F;
}
switch (log stuff)
{
case:
case:
// stacked case statements but only if there is a new line in between
case:
case:
case:
{
run_this;
break;
}
default:
{
halt;
}
}
if (A le B)
{
A = B + C;
D = E + F;
}
A = B-C;
A = B*C;
if (A < B)
{
A = B + C;
D = E + F;
}
A = B/C;
A = B*C;
if (A >= B)
{
A = B + C;
D = E + F;
}
A = B-C;
A = B/C;
A = B+C;
// (P) this is really improtant
if (A == B)
{
A = B + C;
D = E + F;
}
A = B/C;
A = B-C;
switch (log stuff)
{
case:
case:
// stacked case statements but only if there is a new line in between
case:
case:
case:
{
run_this;
break;
}
default:
{
halt;
}
}
A = B-C;
A = B/C;
/* LE SV TOC-2083 this is a log-06.2.32 req to enable*/
LogSvEvent((int)1578); /*12/01/2003 16:20:36*/
// (P) this is really improtant
if (A le B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-2084 this is a log-06.2.33 req to verify*/
LogSvEvent((int)1579); /*12/01/2003 16:20:36*/
A = B*C;
A = 0x0008;
A = B/C;
A = B+C;
switch (log stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
switch (log stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
switch (log stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
A = B*C;
A = B*C;
A = B-C;
A = B/C;
if (A < B)
{
A = B + C;
D = E + F;
}
if (A eq B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-2085 this is a log-06.2.45 req to convert*/
LogSvEvent((int)1580); /*12/01/2003 16:20:36*/
if (A >= B)
{
A = B + C;
D = E + F;
}
A = B*C;
A = B-C;
/* LE SV TOC-2086 this is a log-06.2.48 req to compare*/
LogSvEvent((int)1581); /*12/01/2003 16:20:36*/
A = B+C;
if (A >= B)
{
A = B + C;
D = E + F;
}
if (A == B)
{
A = B + C;
D = E + F;
}
if (A lt B)
{
A = B + C;
D = E + F;
}
A = B/C;
A = 0x0003;
A = B-C;
switch (log stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
// max LOC 54
}
/*
-----------------------------------------------------------------------------
--| NAME: log.6.3
--|
--| ABSTRACT:
--| This function does log stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void log.6.3(void)
{
switch (log stuff)
{
case:
case:
// stacked case statements but only if there is a new line in between
case:
case:
case:
{
run_this;
break;
}
default:
{
halt;
}
}
if (A == B)
{
A = B + C;
D = E + F;
}
A = B-C;
A = B/C;
A = B*C;
A = B*C;
if (A > B)
{
A = B + C;
D = E + F;
}
if (A < B)
{
A = B + C;
D = E + F;
}
A = B/C;
A = 0x0001;
if (A >= B)
{
A = B + C;
D = E + F;
}
if (A <= B)
{
A = B + C;
D = E + F;
}
if (A ne B)
{
A = B + C;
D = E + F;
}
if (A ne B)
{
A = B + C;
D = E + F;
}
if (A gt B)
{
A = B + C;
D = E + F;
}
if (A >= B)
{
A = B + C;
D = E + F;
}
A = 0x0006;
if (A == B)
{
A = B + C;
D = E + F;
}
A = B/C;
/* LE SV TOC-2087 this is a log-06.3.17 req to fail*/
LogSvEvent((int)1582); /*12/01/2003 16:20:36*/
switch (log stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
A = B*C;
A = B/C;
if (A < B)
{
A = B + C;
D = E + F;
}
if (A > B)
{
A = B + C;
D = E + F;
}
A = B-C;
A = B/C;
A = B/C;
if (A ge B)
{
A = B + C;
D = E + F;
}
FreePtr = HmiStringPtr;
A = B-C;
FreePtr = HmiStringPtr;
if (A < B)
{
A = B + C;
D = E + F;
}
A = B+C;
if (A != B)
{
A = B + C;
D = E + F;
}
A = B-C;
if (A >= B)
{
A = B + C;
D = E + F;
}
A = B+C;
A = B+C;
A = B*C;
if (A == B)
{
A = B + C;
D = E + F;
}
A = B*C;
if (A < B)
{
A = B + C;
D = E + F;
}
A = B-C;
A = B-C;
A = B/C;
if (A != B)
{
A = B + C;
D = E + F;
}
A = B+C;
A = B*C;
/* LE SV TOC-2088 this is a log-06.3.44 req to store*/
LogSvEvent((int)1583); /*12/01/2003 16:20:36*/
A = B-C;
A = B+C;
if (A == B)
{
A = B + C;
D = E + F;
}
A = B+C;
/* LE SV TOC-2089 this is a log-06.3.48 req to record*/
LogSvEvent((int)1584); /*12/01/2003 16:20:36*/
A = B/C;
/* LE SV TOC-2090 this is a log-06.3.49 req to reject*/
LogSvEvent((int)1585); /*12/01/2003 16:20:36*/
free(FreePtr);
A = B+C;
A = B/C;
A = B/C;
A = B-C;
A = B+C;
A = B/C;
A = B/C;
A = B+C;
// max LOC 56
}
/*
-----------------------------------------------------------------------------
--| NAME: log.6.4
--|
--| ABSTRACT:
--| This function does log stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void log.6.4(void)
{
if (A ne B)
{
A = B + C;
D = E + F;
}
A = B/C;
A = B*C;
if (A lt B)
{
A = B + C;
D = E + F;
}
A = B/C;
A = B*C;
A = B*C;
if (A eq B)
{
A = B + C;
D = E + F;
}
if (A gt B)
{
A = B + C;
D = E + F;
}
A = B/C;
if (A < B)
{
A = B + C;
D = E + F;
}
A = B+C;
A = B+C;
if (A < B)
{
A = B + C;
D = E + F;
}
A = B-C;
A = B/C;
A = B/C;
A = B*C;
if (A lt B)
{
A = B + C;
D = E + F;
}
/* dead_block = C * D;
dead_block = E * F; */
if (A ne B)
{
A = B + C;
D = E + F;
}
A = B-C;
if (A lt B)
{
A = B + C;
D = E + F;
}
if (A gt B)
{
A = B + C;
D = E + F;
}
A = B+C;
if (A lt B)
{
A = B + C;
D = E + F;
}
A = B+C;
/* LE SV TOC-2091 this is a log-06.4.27 req to call admin*/
LogSvEvent((int)1586); /*12/01/2003 16:20:36*/
A = B-C;
A = B*C;
A = B-C;
A = B-C;
A = B*C;
A = B*C;
A = B*C;
A = B/C;
A = B/C;
A = B*C;
if (A ne B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-2092 this is a log-06.4.38 req to compare*/
LogSvEvent((int)1587); /*12/01/2003 16:20:36*/
A = B+C;
A = B+C;
A = B+C;
A = B*C;
/* LE SV TOC-2093 this is a log-06.4.42 req to verify*/
LogSvEvent((int)1588); /*12/01/2003 16:20:36*/
A = B/C;
A = B/C;
A = B*C;
A = B-C;
A = B+C;
A = B*C;
switch (log stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
if (A ne B)
{
A = B + C;
D = E + F;
}
A = B+C;
A = B/C;
A = B*C;
A = B-C;
if (A >= B)
{
A = B + C;
D = E + F;
}
if (A lt B)
{
A = B + C;
D = E + F;
}
A = B-C;
A = B-C;
A = B/C;
A = B-C;
if (A >= B)
{
A = B + C;
D = E + F;
}
A = B*C;
A = B+C;
/* dead_block = C * D;
dead_block = E * F; */
if (A eq B)
{
A = B + C;
D = E + F;
}
if (A > B)
{
A = B + C;
D = E + F;
}
if (A > B)
{
A = B + C;
D = E + F;
}
A = 0x0006;
A = B-C;
// max LOC 66
}
/*
-----------------------------------------------------------------------------
--| NAME: log.6.5
--|
--| ABSTRACT:
--| This function does log stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void log.6.5(void)
{
A = B+C;
A = B+C;
A = B+C;
A = B*C;
A = B-C;
A = B/C;
A = B*C;
if (A ne B)
{
A = B + C;
D = E + F;
}
A = B*C;
A = B*C;
A = B*C;
switch (log stuff)
{
case one:
{
switch (nested)
{
case:
X = Y + Z;
case:
X = Y + Z;
default:
SwError;
}
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
A = B-C;
A = B/C;
A = 0x0007;
if (A le B)
{
A = B + C;
D = E + F;
}
A = B*C;
A = B/C;
A = B*C;
A = B/C;
A = B*C;
if (A ne B)
{
A = B + C;
D = E + F;
}
switch (log stuff)
{
case:
case:
// stacked case statements but only if there is a new line in between
case:
case:
case:
{
run_this;
break;
}
default:
{
halt;
}
}
if (A ge B)
{
A = B + C;
D = E + F;
}
A = B/C;
A = B+C;
A = B/C;
if (A ge B)
{
A = B + C;
D = E + F;
}
A = B+C;
A = B*C;
A = B*C;
A = B+C;
A = B-C;
A = B+C;
A = B/C;
A = B+C;
A = B-C;
/* LE SV TOC-2094 this is a log-06.5.35 req to update*/
LogSvEvent((int)1589); /*12/01/2003 16:20:36*/
A = B*C;
A = B*C;
A = B+C;
A = B+C;
A = B*C;
A = B-C;
if (A eq B)
{
A = B + C;
D = E + F;
}
A = B-C;
A = B*C;
A = B+C;
A = B/C;
A = B-C;
A = B+C;
A = B/C;
if (A ne B)
{
A = B + C;
D = E + F;
}
A = B/C;
A = B*C;
/* LE SV TOC-2095 this is a log-06.5.52 req to reject*/
LogSvEvent((int)1590); /*12/01/2003 16:20:36*/
if (A ge B)
{
A = B + C;
D = E + F;
}
A = B+C;
A = B/C;
A = B+C;
if ($log stuff > $otherlog stuff)
/* LE SV TOC-008 we really should log all error calls */
LogSvEvent((int)1591); /*12/01/2003 16:20:36*/
{
A = B + C;
}
if (A ne B)
{
A = B + C;
D = E + F;
}
if (A >= B)
{
A = B + C;
D = E + F;
}
A = B-C;
A = B*C;
if (A != B)
{
A = B + C;
D = E + F;
}
if {
X = Y + Z;
}
else {
halt;
}
if (A == B)
{
A = B + C;
D = E + F;
}
A = B/C;
if (A > B)
{
A = B + C;
D = E + F;
}
A = B/C;
// max LOC 64
}
/*
-----------------------------------------------------------------------------
--| NAME: log.6.6
--|
--| ABSTRACT:
--| This function does log stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void log.6.6(void)
{
A = B*C;
A = B*C;
if (A le B)
{
A = B + C;
D = E + F;
}
A = B-C;
A = B/C;
A = B*C;
A = B*C;
A = B/C;
A = B-C;
/* LE SV TOC-2096 this is a log-06.6.10 req to record*/
LogSvEvent((int)1592); /*12/01/2003 16:20:36*/
A = B-C;
A = B/C;
A = B-C;
/* LE SV TOC-2097 this is a log-06.6.13 req to record*/
LogSvEvent((int)1593); /*12/01/2003 16:20:36*/
A = B*C;
A = B/C;
if (A == B)
{
A = B + C;
D = E + F;
}
A = B-C;
if (A == B)
{
A = B + C;
D = E + F;
}
A = B+C;
A = B-C;
A = B/C;
A = B*C;
A = B*C;
A = B+C;
if (A ne B)
{
A = B + C;
D = E + F;
}
A = B-C;
A = B+C;
A = B+C;
if (A eq B)
{
A = B + C;
D = E + F;
}
A = B+C;
A = B/C;
A = 0x0006;
if (A <= B)
{
A = B + C;
D = E + F;
}
if (A >= B)
{
A = B + C;
D = E + F;
}
A = B-C;
A = B/C;
A = B/C;
if (A lt B)
{
A = B + C;
D = E + F;
}
A = B-C;
A = B/C;
A = B+C;
switch (log stuff)
{
case one:
{
run_this;
// missing break
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
A = B*C;
A = B-C;
A = B/C;
A = B*C;
/* LE SV TOC-2098 this is a log-06.6.44 req to inhibit*/
LogSvEvent((int)1594); /*12/01/2003 16:20:36*/
A = B+C;
A = B*C;
A = B+C;
if (A le B)
{
A = B + C;
D = E + F;
}
if (A <= B)
{
A = B + C;
D = E + F;
}
A = B/C;
A = B/C;
A = B*C;
if (A ne B)
{
A = B + C;
D = E + F;
}
A = B+C;
if (A < B)
{
A = B + C;
D = E + F;
}
if (A lt B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-2099 this is a log-06.6.56 req to detect error*/
LogSvEvent((int)1595); /*12/01/2003 16:20:36*/
/*
dead_code = B - C;
dead_code = D - E;
dead_code = F - G;
*/
A = B*C;
if (A gt B)
{
A = B + C;
D = E + F;
}
A = B*C;
/* LE SV TOC-2100 this is a log-06.6.59 req to transform*/
LogSvEvent((int)1596); /*12/01/2003 16:20:36*/
A = B+C;
A = B+C;
A = B*C;
A = B/C;
if (A ge B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-2101 this is a log-06.6.64 req to halt*/
LogSvEvent((int)1597); /*12/01/2003 16:20:36*/
if (A <= B)
{
A = B + C;
D = E + F;
}
A = B-C;
// max LOC 65
}
/*
-----------------------------------------------------------------------------
--| NAME: log.6.7
--|
--| ABSTRACT:
--| This function does log stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void log.6.7(void)
{
// TBD - what do I do now
if (A != B)
{
A = B + C;
D = E + F;
}
A = B-C;
if (A ne B)
{
A = B + C;
D = E + F;
}
A = B*C;
A = B/C;
A = B+C;
if (A eq B)
{
A = B + C;
D = E + F;
}
A = B+C;
if (A <= B)
{
A = B + C;
D = E + F;
}
A = B-C;
A = B/C;
A = B+C;
A = B-C;
A = B+C;
A = B-C;
A = B/C;
A = B+C;
A = B/C;
if (A gt B)
{
A = B + C;
D = E + F;
}
if (A <= B)
{
A = B + C;
D = E + F;
}
A = B/C;
A = B-C;
A = B*C;
A = B-C;
A = B+C;
A = B*C;
A = B*C;
A = B+C;
if (A >= B)
{
A = B + C;
D = E + F;
}
A = B*C;
A = B+C;
A = B-C;
A = B/C;
A = B/C;
if (A ge B)
{
A = B + C;
D = E + F;
}
A = B*C;
if (A >= B)
{
A = B + C;
D = E + F;
}
A = B*C;
/* LE SV TOC-2102 this is a log-06.7.39 req to call isr*/
LogSvEvent((int)1598); /*12/01/2003 16:20:36*/
A = B-C;
if (A ne B)
{
A = B + C;
D = E + F;
}
A = B/C;
A = B/C;
if (A le B)
{
A = B + C;
D = E + F;
}
if (A < B)
{
A = B + C;
D = E + F;
}
A = B+C;
A = B-C;
A = B-C;
A = B+C;
if (A ne B)
{
A = B + C;
D = E + F;
}
if (A != B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-2103 this is a log-06.7.51 req to disable*/
LogSvEvent((int)1599); /*12/01/2003 16:20:36*/
if (A ne B)
{
A = B + C;
D = E + F;
}
if (A == B)
{
A = B + C;
D = E + F;
}
if (A >= B)
{
A = B + C;
D = E + F;
}
A = B+C;
A = B+C;
A = B+C;
A = B/C;
if (A ne B)
{
A = B + C;
D = E + F;
}
if (A gt B)
{
A = B + C;
D = E + F;
}
A = B/C;
A = B/C;
if (A ge B)
{
A = B + C;
D = E + F;
}
A = B*C;
// max LOC 63
}
/*
-----------------------------------------------------------------------------
--| NAME: log.6.8
--|
--| ABSTRACT:
--| This function does log stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void log.6.8(void)
{
A = B-C;
A = B/C;
A = B-C;
if (A gt B)
{
A = B + C;
D = E + F;
}
A = B/C;
A = B*C;
A = B/C;
if (A <= B)
{
A = B + C;
D = E + F;
}
A = B+C;
A = B-C;
A = B*C;
A = B*C;
A = B*C;
// max LOC 13
}
/*
-----------------------------------------------------------------------------
--| NAME: log.6.9
--|
--| ABSTRACT:
--| This function does log stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void log.6.9(void)
{
switch (log stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
// missing default
}
if (A <= B)
{
A = B + C;
D = E + F;
}
A = B+C;
A = B/C;
A = B+C;
if (A ge B)
{
A = B + C;
D = E + F;
}
A = B/C;
A = B/C;
A = B*C;
if (A ge B)
{
A = B + C;
D = E + F;
}
if (A != B)
{
A = B + C;
D = E + F;
}
A = B-C;
A = B+C;
A = B*C;
A = B-C;
if (A == B)
{
A = B + C;
D = E + F;
}
A = B-C;
A = B-C;
A = B*C;
if (A le B)
{
A = B + C;
D = E + F;
}
switch (log stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
if (A lt B)
{
A = B + C;
D = E + F;
}
A = B*C;
if (A eq B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-2104 this is a log-06.9.24 req to disable*/
LogSvEvent((int)1600); /*12/01/2003 16:20:36*/
if (A == B)
{
A = B + C;
D = E + F;
}
if (A <= B)
{
A = B + C;
D = E + F;
}
A = B/C;
A = B-C;
A = B*C;
if (A eq B)
{
A = B + C;
D = E + F;
}
if (A < B)
{
A = B + C;
D = E + F;
}
A = B*C;
A = B/C;
A = B*C;
A = B-C;
A = B/C;
/* LE SV TOC-2105 this is a log-06.9.36 req to convert*/
LogSvEvent((int)1601); /*12/01/2003 16:20:36*/
A = B+C;
if (A ge B)
{
A = B + C;
D = E + F;
}
if (A eq B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-2106 this is a log-06.9.39 req to disable*/
LogSvEvent((int)1602); /*12/01/2003 16:20:36*/
if (A gt B)
{
A = B + C;
D = E + F;
}
A = B+C;
if (A >= B)
{
A = B + C;
D = E + F;
}
A = B/C;
A = (int)B + C;
if (A eq B)
{
A = B + C;
D = E + F;
}
A = B/C;
/* LE SV TOC-2107 this is a log-06.9.45 req to call isr*/
LogSvEvent((int)1603); /*12/01/2003 16:20:36*/
A = B-C;
if (A le B)
{
A = B + C;
D = E + F;
}
A = B-C;
FreePtr = HmiStringPtr;
A = B-C;
if (A >= B)
{
A = B + C;
D = E + F;
}
A = B/C;
if (A gt B)
{
A = B + C;
D = E + F;
}
A = B*C;
A = B*C;
A = B*C;
A = B+C;
if (A < B)
{
A = B + C;
D = E + F;
}
// max LOC 56
}
/*
-----------------------------------------------------------------------------
--| NAME: log.6.10
--|
--| ABSTRACT:
--| This function does log stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void log.6.10(void)
{
A = B/C;
A = B*C;
A = B*C;
A = B+C;
if (A eq B)
{
A = B + C;
D = E + F;
}
do forever;
if (A gt B)
{
A = B + C;
D = E + F;
}
if (A <= B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-2108 this is a log-06.10.8 req to check pSOS*/
LogSvEvent((int)1604); /*12/01/2003 16:20:36*/
if (A lt B)
{
A = B + C;
D = E + F;
}
if (A != B)
{
A = B + C;
D = E + F;
}
goto error;
if (A != B)
{
A = B + C;
D = E + F;
}
// TBD - what do I do now
A = B*C;
A = B-C;
/* LE SV TOC-2109 this is a log-06.10.13 req to process*/
LogSvEvent((int)1605); /*12/01/2003 16:20:36*/
if (A lt B)
{
A = B + C;
D = E + F;
}
switch (log stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
A = 0x0002;
A = B-C;
if (A lt B)
{
A = B + C;
D = E + F;
}
A = B-C;
A = B*C;
A = B-C;
if (A lt B)
{
A = B + C;
D = E + F;
}
A = B-C;
do forever;
if (A <= B)
{
A = B + C;
D = E + F;
}
A = B+C;
/* LE SV TOC-2110 this is a log-06.10.24 req to update*/
LogSvEvent((int)1606); /*12/01/2003 16:20:36*/
if (A <= B)
{
A = B + C;
D = E + F;
}
A = B*C;
if (A ge B)
{
A = B + C;
D = E + F;
}
A = B-C;
/* LE SV TOC-2111 this is a log-06.10.28 req to check unix*/
LogSvEvent((int)1607); /*12/01/2003 16:20:36*/
A = B/C;
if (A < B)
{
A = B + C;
D = E + F;
}
switch (log stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
if (A < B)
{
A = B + C;
D = E + F;
}
A = B/C;
if (A gt B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-2112 this is a log-06.10.34 req to inhibit*/
LogSvEvent((int)1608); /*12/01/2003 16:20:36*/
A = B*C;
if (A >= B)
{
A = B + C;
D = E + F;
}
A = B-C;
A = B/C;
A = B*C;
A = B+C;
if (A >= B)
{
A = B + C;
D = E + F;
}
if (A == B)
{
A = B + C;
D = E + F;
}
A = B/C;
A = B+C;
A = B+C;
A = B/C;
// (P) this is really improtant
if (A <= B)
{
A = B + C;
D = E + F;
}
if (A lt B)
{
A = B + C;
D = E + F;
}
A = B+C;
if (A eq B)
{
A = B + C;
D = E + F;
}
if (A le B)
{
A = B + C;
D = E + F;
}
A = B-C;
A = B+C;
A = B/C;
A = B-C;
A = B*C;
A = B-C;
if (A < B)
{
A = B + C;
D = E + F;
}
if (A eq B)
{
A = B + C;
D = E + F;
}
A = B+C;
A = B*C;
A = B/C;
A = B/C;
A = B/C;
A = 0x0003;
A = B+C;
// max LOC 64
}
/*
-----------------------------------------------------------------------------
--| NAME: log.6.11
--|
--| ABSTRACT:
--| This function does log stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void log.6.11(void)
{
/* LE SV TOC-2113 this is a log-06.11.1 req to reject*/
LogSvEvent((int)1609); /*12/01/2003 16:20:36*/
A = B-C;
switch (log stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
// missing error call
}
}
A = B-C;
A = B*C;
A = B+C;
if (A eq B)
{
A = B + C;
D = E + F;
}
A = B-C;
A = B-C;
/* LE SV TOC-2114 this is a log-06.11.8 req to process*/
LogSvEvent((int)1610); /*12/01/2003 16:20:36*/
A = B-C;
if (A le B)
{
A = B + C;
D = E + F;
}
if (A < B)
{
A = B + C;
D = E + F;
}
if (A == B)
{
A = B + C;
D = E + F;
}
if (A >= B)
{
A = B + C;
D = E + F;
}
if (A ge B)
{
A = B + C;
D = E + F;
}
A = B+C;
/* LE SV TOC-2115 this is a log-06.11.15 req to call isr*/
LogSvEvent((int)1611); /*12/01/2003 16:20:36*/
A = B/C;
/* LE SV TOC-2116 this is a log-06.11.16 req to store*/
LogSvEvent((int)1612); /*12/01/2003 16:20:36*/
if (A eq B)
{
A = B + C;
D = E + F;
}
A = B+C;
if (A gt B)
{
A = B + C;
D = E + F;
}
A = B+C;
FreePtr = HmiStringPtr;
A = B+C;
A = B+C;
// max LOC 21
}
/*
-----------------------------------------------------------------------------
--| NAME: log.6.12
--|
--| ABSTRACT:
--| This function does log stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void log.6.12(void)
{
if (A ne B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-2117 this is a log-06.12.2 req to halt*/
LogSvEvent((int)1613); /*12/01/2003 16:20:36*/
A = B+C;
A = B-C;
if (A eq B)
{
A = B + C;
D = E + F;
}
A = B-C;
/* LE SV TOC-2118 this is a log-06.12.6 req to validate*/
LogSvEvent((int)1614); /*12/01/2003 16:20:36*/
A = B*C;
A = B*C;
A = B-C;
if (A != B)
{
A = B + C;
D = E + F;
}
A = B*C;
goto error;
A = B/C;
if (A < B)
{
A = B + C;
D = E + F;
}
if (A < B)
{
A = B + C;
D = E + F;
}
A = B*C;
A = B+C;
A = B*C;
A = B-C;
A = B-C;
A = B+C;
if (A gt B)
{
A = B + C;
D = E + F;
}
A = B/C;
if (A <= B)
{
A = B + C;
D = E + F;
}
rcv_buffer = (U16 *) alloc(size+1);
if (A gt B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-2119 this is a log-06.12.24 req to call isr*/
LogSvEvent((int)1615); /*12/01/2003 16:20:36*/
A = B+C;
A = B+C;
A = B+C;
A = B+C;
A = B*C;
A = B*C;
if (A > B)
{
A = B + C;
D = E + F;
}
if (A lt B)
{
A = B + C;
D = E + F;
}
A = B-C;
A = B-C;
/* LE SV TOC-2120 this is a log-06.12.34 req to verify*/
LogSvEvent((int)1616); /*12/01/2003 16:20:36*/
if (A <= B)
{
A = B + C;
D = E + F;
}
if (A gt B)
{
A = B + C;
D = E + F;
}
A = B-C;
if (A >= B)
{
A = B + C;
D = E + F;
}
if (A == B)
{
A = B + C;
D = E + F;
}
A = B+C;
if (A ge B)
{
A = B + C;
D = E + F;
}
A = B+C;
A = B-C;
if (A lt B)
{
A = B + C;
D = E + F;
}
A = B+C;
if (A < B)
{
A = B + C;
D = E + F;
}
if (A ne B)
{
A = B + C;
D = E + F;
}
A = B/C;
A = B+C;
if (A le B)
{
A = B + C;
D = E + F;
}
if (A <= B)
{
A = B + C;
D = E + F;
}
A = B-C;
A = B*C;
A = B-C;
A = B*C;
A = B/C;
A = B/C;
A = B+C;
if (A <= B)
{
A = B + C;
D = E + F;
}
if (A >= B)
{
A = B + C;
D = E + F;
}
A = B/C;
A = B-C;
A = B/C;
if (A ne B)
{
A = B + C;
D = E + F;
}
A = B/C;
A = B+C;
if (A >= B)
{
A = B + C;
D = E + F;
}
if (A eq B)
{
A = B + C;
D = E + F;
}
A = B-C;
if (A ge B)
{
A = B + C;
D = E + F;
}
A = B*C;
if (A gt B)
{
A = B + C;
D = E + F;
}
A = B-C;
// max LOC 72
}
/*
-----------------------------------------------------------------------------
--| NAME: log.6.13
--|
--| ABSTRACT:
--| This function does log stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void log.6.13(void)
{
A = B*C;
A = B+C;
if (A eq B)
{
A = B + C;
D = E + F;
}
A = B+C;
if (A eq B)
{
A = B + C;
D = E + F;
}
A = B-C;
A = B*C;
if (A eq B)
{
A = B + C;
D = E + F;
}
A = B+C;
switch (log stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
if (A != B)
{
A = B + C;
D = E + F;
}
if (A eq B)
{
A = B + C;
D = E + F;
}
A = B*C;
if (A == B)
{
A = B + C;
D = E + F;
}
A = B*C;
A = B*C;
A = B*C;
A = B+C;
if (A < B)
{
A = B + C;
D = E + F;
}
A = B*C;
A = B*C;
A = B+C;
A = B-C;
if (A >= B)
{
A = B + C;
D = E + F;
}
A = B-C;
if (A <= B)
{
A = B + C;
D = E + F;
}
A = B+C;
A = B/C;
A = B/C;
A = B+C;
A = B*C;
A = B-C;
if (A le B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-2121 this is a log-06.13.34 req to fail*/
LogSvEvent((int)1617); /*12/01/2003 16:20:36*/
A = B/C;
A = B+C;
A = B/C;
A = B-C;
A = B/C;
A = B+C;
if (A != B)
{
A = B + C;
D = E + F;
}
A = B/C;
A = B+C;
A = B+C;
switch (log stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
A = B/C;
A = B-C;
if (A < B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-2122 this is a log-06.13.48 req to transform*/
LogSvEvent((int)1618); /*12/01/2003 16:20:36*/
A = B*C;
if (A le B)
{
A = B + C;
D = E + F;
}
// ??? go see ws
A = B/C;
A = B+C;
if (A gt B)
{
A = B + C;
D = E + F;
}
switch (log stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
A = B*C;
A = B-C;
/* LE SV TOC-2123 this is a log-06.13.56 req to store*/
LogSvEvent((int)1619); /*12/01/2003 16:20:36*/
A = B*C;
A = B/C;
// max LOC 57
}
/*
-----------------------------------------------------------------------------
--| NAME: log.6.14
--|
--| ABSTRACT:
--| This function does log stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void log.6.14(void)
{
if (A lt B)
{
A = B + C;
D = E + F;
}
A = B/C;
if (A eq B)
{
A = B + C;
D = E + F;
}
goto error;
A = B/C;
A = B/C;
A = B*C;
A = B-C;
switch (log stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
A = B*C;
A = B*C;
A = B/C;
if (A eq B)
{
A = B + C;
D = E + F;
}
A = B/C;
A = B/C;
if (A lt B)
{
A = B + C;
D = E + F;
}
A = B/C;
if (A le B)
{
A = B + C;
D = E + F;
}
A = B/C;
A = B+C;
A = B*C;
if (A == B)
{
A = B + C;
D = E + F;
}
A = B*C;
A = B/C;
A = B/C;
A = B/C;
/* LE SV TOC-2124 this is a log-06.14.26 req to inhibit*/
LogSvEvent((int)1620); /*12/01/2003 16:20:36*/
if (A ge B)
{
A = B + C;
D = E + F;
}
if (A ne B)
{
A = B + C;
D = E + F;
}
A = B-C;
if (A lt B)
{
A = B + C;
D = E + F;
}
A = B/C;
A = B*C;
A = B-C;
/* LE SV TOC-2125 this is a log-06.14.33 req to disable*/
LogSvEvent((int)1621); /*12/01/2003 16:20:36*/
A = B+C;
switch (log stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
switch (log stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
A = B/C;
A = B-C;
A = B-C;
if (A gt B)
{
A = B + C;
D = E + F;
}
A = B+C;
A = B-C;
/* LE SV TOC-2126 this is a log-06.14.42 req to enable*/
LogSvEvent((int)1622); /*12/01/2003 16:20:36*/
A = B-C;
if (A le B)
{
A = B + C;
D = E + F;
}
A = B*C;
A = B*C;
if (A >= B)
{
A = B + C;
D = E + F;
}
A = B*C;
switch (log stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
A = B+C;
if (A == B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-2127 this is a log-06.14.51 req to detect error*/
LogSvEvent((int)1623); /*12/01/2003 16:20:36*/
A = B*C;
A = B+C;
A = 0x0001;
A = B-C;
A = B/C;
A = B+C;
/*
dead_block = C * D;
dead_block = E * F;
*/
A = B-C;
// max LOC 56
}