/*
----------------------------------------------------------------------------
--| BEGIN PROLOGUE
--|
--| CLASSIFICATION: UNCLASSIFIED
--|
--| FILE NAME: stp-02.c
--|
--| ABSTRACT:
--| This file contains the 12 functions that do file stp stuff.
--|
--| HISTORY:
--| CCCQ_NAME:
--| CCCQ_VER:
--|
--| END PROLOGUE
----------------------------------------------------------------------------
*/
#define D;
#include D;
#define C;
#include C;
#include D;
int A;
#define D;
double C;
#define B;
/*
-----------------------------------------------------------------------------
--| NAME: stp.2.1
--|
--| ABSTRACT:
--| This function does stp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void stp.2.1(void)
{
switch (stp 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;
if (A > B)
{
A = B + C;
D = E + F;
}
if (A <= B)
{
A = B + C;
D = E + F;
}
switch (stp 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;
A = B/C;
A = B/C;
if (A eq B)
{
A = B + C;
D = E + F;
}
// max LOC 9
}
/*
-----------------------------------------------------------------------------
--| NAME: stp.2.2
--|
--| ABSTRACT:
--| This function does stp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void stp.2.2(void)
{
if (A lt B)
{
A = B + C;
D = E + F;
}
A = B+C;
if (A lt 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 = B-C;
A = B*C;
/*
dead_block = C * D;
dead_block = 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;
A = B/C;
A = B+C;
switch (stp stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
if (A >= B)
{
A = B + C;
D = E + F;
}
if {
X = Y + Z;
}
else {
halt;
}
if (A eq B)
{
A = B + C;
D = E + F;
}
A = B+C;
A = B/C;
if (A le 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;
switch (stp 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;
}
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;
if (A >= B)
{
A = B + C;
D = E + F;
}
A = B-C;
A = B-C;
FreePtr = HmiStringPtr;
if (A > B)
{
A = B + C;
D = E + F;
}
A = B/C;
/* dead_code = B + C;
dead_code = D + E;
dead_code = F + G; */
A = B*C;
// max LOC 42
}
/*
-----------------------------------------------------------------------------
--| NAME: stp.2.3
--|
--| ABSTRACT:
--| This function does stp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void stp.2.3(void)
{
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 = 0x0003;
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;
}
A = B-C;
A = B/C;
A = B+C;
A = B-C;
A = B/C;
A = (float)B + C;
if (A eq B)
{
A = B + C;
D = E + F;
}
A = B*C;
A = B-C;
/* LE SV TOC-2845 this is a stp-02.3.24 req to call isr*/
LogSvEvent((int)1947); /*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;
}
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;
if (A eq B)
{
A = B + C;
D = E + F;
}
A = B+C;
A = B-C;
if (A > B)
{
A = B + C;
D = E + F;
}
A = 0x0002;
A = B+C;
A = B/C;
if (A eq B)
{
A = B + C;
D = E + F;
}
// max LOC 42
}
/*
-----------------------------------------------------------------------------
--| NAME: stp.2.4
--|
--| ABSTRACT:
--| This function does stp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void stp.2.4(void)
{
switch (stp 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;
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;
/* dead_block = C * D;
dead_block = 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;
if (A ge B)
{
A = B + C;
D = E + F;
}
#ifdef LAZY
// this is not nice
A = B + C;
A = B + C;
#endif
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;
A = B-C;
/*
dead_block = C * D;
dead_block = E * F;
*/
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;
// max LOC 30
}
/*
-----------------------------------------------------------------------------
--| NAME: stp.2.5
--|
--| ABSTRACT:
--| This function does stp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void stp.2.5(void)
{
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;
switch (stp stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
// missing error call
}
}
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;
}
if (A >= B)
{
A = B + C;
D = E + F;
}
if (A lt B)
{
A = B + C;
D = E + F;
}
A = 0x0004;
A = B*C;
A = B+C;
A = B-C;
A = B+C;
A = B+C;
if (A lt B)
{
A = B + C;
D = E + F;
}
if (A == 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;
}
if (A <= B)
{
A = B + C;
D = E + F;
}
switch (stp 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;
A = B-C;
A = 0x0003;
switch (stp 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 > 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 ge B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-2846 this is a stp-02.5.47 req to set Real Time Clock*/
LogSvEvent((int)1948); /*12/01/2003 16:20:36*/
A = B/C;
if (A lt B)
{
A = B + C;
D = E + F;
}
A = B-C;
// max LOC 49
}
/*
-----------------------------------------------------------------------------
--| NAME: stp.2.6
--|
--| ABSTRACT:
--| This function does stp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void stp.2.6(void)
{
A = B/C;
A = B*C;
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;
}
A = B*C;
if (A ge B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-2847 this is a stp-02.6.8 req to audit*/
LogSvEvent((int)1949); /*12/01/2003 16:20:36*/
if (A == B)
{
A = B + C;
D = E + F;
}
if (A lt B)
{
A = B + C;
D = E + F;
}
A = B/C;
if (A >= B)
{
A = B + C;
D = E + F;
}
A = 0x0006;
A = B/C;
if (A ne B)
{
A = B + C;
D = E + F;
}
A = B*C;
A = B/C;
A = B-C;
A = B*C;
if (A le B)
{
A = B + C;
D = E + F;
}
A = B/C;
// max LOC 19
}
/*
-----------------------------------------------------------------------------
--| NAME: stp.2.7
--|
--| ABSTRACT:
--| This function does stp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void stp.2.7(void)
{
A = B/C;
if (A < B)
{
A = B + C;
D = E + F;
}
if (A ne B)
{
A = B + C;
D = E + F;
}
if (A lt B)
{
A = B + C;
D = E + F;
}
A = B-C;
if (A > B)
{
A = B + C;
D = E + F;
}
A = B+C;
switch (stp stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
A = B*C;
if (A ge B)
{
A = B + C;
D = E + F;
}
A = B-C;
A = B*C;
/* LE SV TOC-2848 this is a stp-02.7.13 req to call admin*/
LogSvEvent((int)1950); /*12/01/2003 16:20:36*/
if (A != B)
{
A = B + C;
D = E + F;
}
A = B*C;
send_buffer = (U16 *) malloc(size+1);
A = B*C;
if (A le 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 gt B)
{
A = B + C;
D = E + F;
}
if (A ge 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;
/* LE SV TOC-2849 this is a stp-02.7.28 req to translate*/
LogSvEvent((int)1951); /*12/01/2003 16:20:36*/
A = B/C;
if (A lt 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;
/* LE SV TOC-2850 this is a stp-02.7.38 req to call isr*/
LogSvEvent((int)1952); /*12/01/2003 16:20:36*/
if (A > B)
{
A = B + C;
D = E + F;
}
A = B/C;
if (A != B)
{
A = B + C;
D = E + F;
}
switch (stp stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
// missing default
}
A = B-C;
A = B-C;
A = B+C;
A = B/C;
A = B+C;
A = B*C;
switch (stp 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;
A = B+C;
A = B/C;
if (A lt B)
{
A = B + C;
D = E + F;
}
if (A ge 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;
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;
}
A = B-C;
A = B-C;
A = B-C;
A = B-C;
if (A <= B)
{
A = B + C;
D = E + F;
}
A = B/C;
// max LOC 75
}
/*
-----------------------------------------------------------------------------
--| NAME: stp.2.8
--|
--| ABSTRACT:
--| This function does stp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void stp.2.8(void)
{
/* LE SV TOC-2851 this is a stp-02.8.1 req to enable*/
LogSvEvent((int)1953); /*12/01/2003 16:20:36*/
A = B*C;
A = B*C;
A = B*C;
A = B*C;
// TBS - I need to figure this out
if (A ge B)
{
A = B + C;
D = E + F;
}
A = B/C;
/* LE SV TOC-2852 this is a stp-02.8.7 req to enable*/
LogSvEvent((int)1954); /*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;
switch (stp stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
if (A gt 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;
A = B/C;
/* LE SV TOC-2853 this is a stp-02.8.22 req to compare*/
LogSvEvent((int)1955); /*12/01/2003 16:20:36*/
A = B*C;
switch (stp stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
if (A == B)
{
A = B + C;
D = E + F;
}
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;
}
A = B+C;
A = B*C;
switch (stp stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
if (A ne B)
{
A = B + C;
D = E + F;
}
A = 0x0003;
if (A eq B)
{
A = B + C;
D = E + F;
}
A = B-C;
A = B+C;
// max LOC 37
}
/*
-----------------------------------------------------------------------------
--| NAME: stp.2.9
--|
--| ABSTRACT:
--| This function does stp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void stp.2.9(void)
{
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;
if (A > 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;
A = B-C;
A = 0x0004;
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 == B)
{
A = B + C;
D = E + F;
}
A = B+C;
A = B+C;
goto error;
A = B*C;
A = B-C;
A = 0x0007;
if (A gt B)
{
A = B + C;
D = E + F;
}
if (A ge B)
{
A = B + C;
D = E + F;
}
A = B-C;
if (A ge B)
{
A = B + C;
D = E + F;
}
if (A ne B)
{
A = B + C;
D = E + F;
}
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;
/* LE SV TOC-2854 this is a stp-02.9.35 req to halt*/
LogSvEvent((int)1956); /*12/01/2003 16:20:36*/
if (A ge B)
{
A = B + C;
D = E + F;
}
A = B-C;
if (A le B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-2855 this is a stp-02.9.38 req to enable*/
LogSvEvent((int)1957); /*12/01/2003 16:20:36*/
A = B-C;
A = B-C;
A = 0x0003;
A = B+C;
// max LOC 40
}
/*
-----------------------------------------------------------------------------
--| NAME: stp.2.10
--|
--| ABSTRACT:
--| This function does stp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void stp.2.10(void)
{
if (A <= B)
{
A = B + C;
D = E + F;
}
A = B*C;
if (A ge B)
{
A = B + C;
D = E + F;
}
switch (stp stuff)
{
case one:
{
run_this;
// missing break
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
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;
A = B+C;
A = B-C;
switch (stp 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;
}
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;
if (A < B)
{
A = B + C;
D = E + F;
}
A = B-C;
A = B+C;
// max LOC 27
}
/*
-----------------------------------------------------------------------------
--| NAME: stp.2.11
--|
--| ABSTRACT:
--| This function does stp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void stp.2.11(void)
{
if (A lt B)
{
A = B + C;
D = E + F;
}
A = B*C;
A = B/C;
A = B*C;
/* dead_code = A * B; */
A = B*C;
/* dead_code = A * B; */
A = B*C;
A = B+C;
A = B-C;
A = B-C;
A = B-C;
/* LE SV TOC-2856 this is a stp-02.11.11 req to store*/
LogSvEvent((int)1958); /*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 le 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;
}
A = B+C;
A = B+C;
A = B/C;
A = B-C;
/*
dead_block = C * D;
dead_block = E * F;
*/
A = B+C;
A = B-C;
A = B/C;
if (A eq B)
{
A = B + C;
D = E + F;
}
if (A lt 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;
A = B-C;
if (A > B)
{
A = B + C;
D = E + F;
}
if (A <= B)
{
A = B + C;
D = E + F;
}
A = B/C;
/* LE SV TOC-2857 this is a stp-02.11.37 req to update*/
LogSvEvent((int)1959); /*12/01/2003 16:20:36*/
A = B-C;
A = B-C;
A = B*C;
A = B*C;
A = B-C;
// max LOC 41
}
/*
-----------------------------------------------------------------------------
--| NAME: stp.2.12
--|
--| ABSTRACT:
--| This function does stp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void stp.2.12(void)
{
A = B+C;
A = B+C;
A = B+C;
if (A < B)
{
A = B + C;
D = E + F;
}
if (A gt 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;
}
A = B/C;
A = B+C;
goto error;
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;
A = B-C;
A = B-C;
/* LE SV TOC-2858 this is a stp-02.12.20 req to set Real Time Clock*/
LogSvEvent((int)1960); /*12/01/2003 16:20:36*/
A = B/C;
A = B-C;
if (A < B)
{
A = B + C;
D = E + F;
}
if (A gt B)
{
A = B + C;
D = E + F;
}
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 ge 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 ge B)
{
A = B + C;
D = E + F;
}
A = B-C;
/* LE SV TOC-2859 this is a stp-02.12.39 req to convert*/
LogSvEvent((int)1961); /*12/01/2003 16:20:36*/
A = B+C;
A = B+C;
A = B/C;
send_buffer = (U16 *) malloc(size+1);
if (A < B)
{
A = B + C;
D = E + F;
}
A = B-C;
A = B*C;
A = B+C;
A = B-C;
switch (stp stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
/* dead_block = C * D;
dead_block = E * F; */
A = B-C;
if (A gt B)
{
A = B + C;
D = E + F;
}
A = (float)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;
}
switch (stp 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 lt B)
{
A = B + C;
D = E + F;
}
// max LOC 57
}