/*
----------------------------------------------------------------------------
--| BEGIN PROLOGUE
--|
--| CLASSIFICATION: UNCLASSIFIED
--|
--| FILE NAME: stp-01.c
--|
--| ABSTRACT:
--| This file contains the 14 functions that do file stp stuff.
--|
--| HISTORY:
--| CCCQ_NAME:
--| CCCQ_VER:
--|
--| END PROLOGUE
----------------------------------------------------------------------------
*/
#include D;
#define A;
char D;
#define A;
/*
-----------------------------------------------------------------------------
--| NAME: stp.1.1
--|
--| ABSTRACT:
--| This function does stp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void stp.1.1(void)
{
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 ge B)
{
A = B + C;
D = E + F;
}
if (A != 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;
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;
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;
}
A = B+C;
A = B+C;
if (A == B)
{
A = B + C;
D = E + F;
}
// TBD - what do I do now
A = B-C;
A = B+C;
A = B-C;
/* LE SV TOC-2801 this is a stp-01.1.28 req to store*/
LogSvEvent((int)1919); /*12/01/2003 17:21:26*/
if (A eq B)
{
A = B + C;
D = E + F;
}
A = B/C;
A = B-C;
A = B-C;
/* LE SV TOC-2802 this is a stp-01.1.32 req to fail*/
LogSvEvent((int)1920); /*12/01/2003 17:21:26*/
send_buffer = (U16 *) malloc(size+1);
if (A >= B)
{
A = B + C;
D = E + F;
}
if (A ge B)
{
A = B + C;
D = E + F;
}
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;
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;
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;
if (A <= B)
{
A = B + C;
D = E + F;
}
A = B-C;
/* LE SV TOC-2803 this is a stp-01.1.51 req to compare*/
LogSvEvent((int)1921); /*12/01/2003 17:21:26*/
if (A le B)
{
A = B + C;
D = E + F;
}
if (A == B)
{
A = B + C;
D = E + F;
}
A = 0x0009;
A = B/C;
A = B/C;
A = B/C;
switch (stp stuff)
{
case one:
{
run_this;
// missing 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;
rcv_buffer = (U16 *) alloc(size+1);
A = B*C;
A = B*C;
A = B+C;
if (A == B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-2804 this is a stp-01.1.64 req to enable*/
LogSvEvent((int)1922); /*12/01/2003 17:21:26*/
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;
switch (stp stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
/* LE SV TOC-2805 this is a stp-01.1.71 req to compare*/
LogSvEvent((int)1923); /*12/01/2003 17:21:26*/
if (A gt B)
{
A = B + C;
D = E + F;
}
if (A eq B)
{
A = B + C;
D = E + F;
}
A = B*C;
A = B*C;
/* LE SV TOC-2806 this is a stp-01.1.75 req to disable*/
LogSvEvent((int)1924); /*12/01/2003 17:21:26*/
if (A ne B)
{
A = B + C;
D = E + F;
}
A = B-C;
A = 0x0003;
A = B/C;
if (A lt B)
{
A = B + C;
D = E + F;
}
A = B-C;
A = B*C;
// max LOC 80
}
/*
-----------------------------------------------------------------------------
--| NAME: stp.1.2
--|
--| ABSTRACT:
--| This function does stp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void stp.1.2(void)
{
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;
}
}
/* LE SV TOC-2807 this is a stp-01.2.6 req to audit*/
LogSvEvent((int)1925); /*12/01/2003 17:21:26*/
A = B/C;
if (A >= B)
{
A = B + C;
D = E + F;
}
/* dead_block = C * D;
dead_block = E * F; */
if (A ge 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;
if (A <= B)
{
A = B + C;
D = E + F;
}
A = 0x0004;
A = B/C;
if (A ge 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 = (long)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;
}
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;
}
/* LE SV TOC-2808 this is a stp-01.2.28 req to inhibit*/
LogSvEvent((int)1926); /*12/01/2003 17:21:26*/
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-2809 this is a stp-01.2.36 req to increment*/
LogSvEvent((int)1927); /*12/01/2003 17:21:26*/
A = B+C;
A = B*C;
A = B*C;
A = B*C;
A = B/C;
// ??? go see ws
A = B*C;
A = B-C;
if (A == B)
{
A = B + C;
D = E + F;
}
A = B/C;
/* LE SV TOC-2810 this is a stp-01.2.45 req to process*/
LogSvEvent((int)1928); /*12/01/2003 17:21:26*/
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;
}
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;
}
if (A ge B)
{
A = B + C;
D = E + F;
}
if (A ge B)
{
A = B + C;
D = E + F;
}
A = B+C;
if (A > B)
{
A = B + C;
D = E + F;
}
goto error;
A = B-C;
if (A < B)
{
A = B + C;
D = E + F;
}
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;
}
}
if (A > B)
{
A = B + C;
D = E + F;
}
A = B-C;
if ($stp stuff > $otherstp stuff)
/* LE SV TOC-008 we really should log all error calls */
LogSvEvent((int)1929); /*12/01/2003 17:21:26*/
{
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;
A = B+C;
A = B+C;
A = 0x0003;
A = B/C;
A = B/C;
A = B/C;
A = B-C;
/* LE SV TOC-2811 this is a stp-01.2.75 req to enable*/
LogSvEvent((int)1930); /*12/01/2003 17:21:26*/
if (A eq 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;
}
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;
if (A le B)
{
A = B + C;
D = E + F;
}
A = B*C;
if (A lt B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-2812 this is a stp-01.2.88 req to store*/
LogSvEvent((int)1931); /*12/01/2003 17:21:26*/
A = B*C;
A = B+C;
A = B*C;
A = B/C;
A = B/C;
A = B*C;
A = B-C;
/* LE SV TOC-2813 this is a stp-01.2.95 req to assign*/
LogSvEvent((int)1932); /*12/01/2003 17:21:26*/
A = B/C;
A = B/C;
// max LOC 96
}
/*
-----------------------------------------------------------------------------
--| NAME: stp.1.3
--|
--| ABSTRACT:
--| This function does stp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void stp.1.3(void)
{
if (A gt 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 eq B)
{
A = B + C;
D = E + F;
}
A = B-C;
A = B*C;
A = B/C;
/* LE SV TOC-2814 this is a stp-01.3.10 req to audit*/
LogSvEvent((int)1933); /*12/01/2003 17:21:26*/
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 le B)
{
A = B + C;
D = E + F;
}
A = B-C;
/* LE SV TOC-2815 this is a stp-01.3.20 req to process*/
LogSvEvent((int)1934); /*12/01/2003 17:21:26*/
if (A != B)
{
A = B + C;
D = E + F;
}
if (A gt B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-2816 this is a stp-01.3.22 req to compare*/
LogSvEvent((int)1935); /*12/01/2003 17:21:26*/
A = B/C;
A = B*C;
A = B/C;
A = B-C;
A = B/C;
/* LE SV TOC-2817 this is a stp-01.3.27 req to store*/
LogSvEvent((int)1936); /*12/01/2003 17:21:26*/
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;
A = B-C;
A = B*C;
A = B-C;
switch (stp stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
// missing default
}
A = B-C;
A = B-C;
switch (stp stuff)
{
case one:
{
run_this;
// missing break
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
if (A > B)
{
A = B + C;
D = E + F;
}
A = B/C;
/* LE SV TOC-2818 this is a stp-01.3.38 req to process*/
LogSvEvent((int)1937); /*12/01/2003 17:21:26*/
// ??? go see ws
A = B+C;
if (A gt B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-2819 this is a stp-01.3.40 req to detect error*/
LogSvEvent((int)1938); /*12/01/2003 17:21:26*/
A = B*C;
A = 0x0008;
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;
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;
}
/* LE SV TOC-2820 this is a stp-01.3.51 req to detect error*/
LogSvEvent((int)1939); /*12/01/2003 17:21:26*/
A = B*C;
/* LE SV TOC-2821 this is a stp-01.3.52 req to reject*/
LogSvEvent((int)1940); /*12/01/2003 17:21:26*/
A = B/C;
/* LE SV TOC-2822 this is a stp-01.3.53 req to recover*/
LogSvEvent((int)1941); /*12/01/2003 17:21:26*/
A = B+C;
if (A gt B)
{
A = B + C;
D = E + F;
}
A = B*C;
if (A le B)
{
A = B + C;
D = E + F;
}
A = B*C;
if (A eq B)
{
A = B + C;
D = E + F;
}
A = B/C;
// max LOC 59
}
/*
-----------------------------------------------------------------------------
--| NAME: stp.1.4
--|
--| ABSTRACT:
--| This function does stp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void stp.1.4(void)
{
A = B+C;
A = B/C;
A = B*C;
A = B/C;
A = B-C;
A = B-C;
/* LE SV TOC-2823 this is a stp-01.4.7 req to disable*/
LogSvEvent((int)1942); /*12/01/2003 17:21:26*/
A = B-C;
A = B+C;
#ifdef LAZY
// this is not nice
A = B + C;
A = B + C;
#endif
if (A lt 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;
/*
dead_code = B - C;
dead_code = D - E;
dead_code = F - G;
*/
if (A lt 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;
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;
}
/* LE SV TOC-2824 this is a stp-01.4.25 req to fail*/
LogSvEvent((int)1943); /*12/01/2003 17:21:26*/
if (A >= B)
{
A = B + C;
D = E + F;
}
A = B+C;
if (A ne B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-2825 this is a stp-01.4.28 req to call admin*/
LogSvEvent((int)1944); /*12/01/2003 17:21:26*/
if (A eq 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;
A = B/C;
A = B-C;
if (A != B)
{
A = B + C;
D = E + F;
}
do forever;
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 eq 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;
}
if (A ge B)
{
A = B + C;
D = E + F;
}
rcv_buffer = (U16 *) alloc(size+1);
A = B*C;
A = B/C;
A = B-C;
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;
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 ($stp stuff > $otherstp stuff)
/* LE SV TOC-008 we really should log all error calls */
LogSvEvent((int)1945); /*12/01/2003 17:21:26*/
{
A = B + C;
}
A = B/C;
A = B+C;
A = B/C;
switch (stp stuff)
{
case one:
{
run_this;
// missing break
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
A = B*C;
A = B*C;
if (A lt B)
{
A = B + C;
D = E + F;
}
A = B-C;
// max LOC 67
}
/*
-----------------------------------------------------------------------------
--| NAME: stp.1.5
--|
--| ABSTRACT:
--| This function does stp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void stp.1.5(void)
{
if (A ne 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;
goto error;
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;
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 = 0x0004;
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 = 0x0004;
A = B-C;
A = B*C;
A = B+C;
A = B-C;
A = B-C;
A = B/C;
A = B-C;
// max LOC 35
}
/*
-----------------------------------------------------------------------------
--| NAME: stp.1.6
--|
--| ABSTRACT:
--| This function does stp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void stp.1.6(void)
{
/* LE SV TOC-2826 this is a stp-01.6.1 req to call isr*/
LogSvEvent((int)1946); /*12/01/2003 17:21:26*/
A = B*C;
A = B/C;
A = B-C;
/* LE SV TOC-2827 this is a stp-01.6.4 req to reject*/
LogSvEvent((int)1947); /*12/01/2003 17:21:26*/
if (A ne B)
{
A = B + C;
D = E + F;
}
if (A > B)
{
A = B + C;
D = E + F;
}
if (A eq B)
{
A = B + C;
D = E + F;
}
A = 0x0009;
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 lt 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;
}
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;
}
}
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 = 0x0003;
A = B+C;
A = B+C;
send_buffer = (U16 *) malloc(size+1);
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 eq B)
{
A = B + C;
D = E + F;
}
if (A ne B)
{
A = B + C;
D = E + F;
}
A = B-C;
if (A <= B)
{
A = B + C;
D = E + F;
}
// max LOC 47
}
/*
-----------------------------------------------------------------------------
--| NAME: stp.1.7
--|
--| ABSTRACT:
--| This function does stp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void stp.1.7(void)
{
A = B-C;
A = B+C;
send_buffer = (U16 *) malloc(size+1);
A = B*C;
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 <= 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 ($stp stuff > $otherstp stuff)
/* LE SV TOC-008 we really should log all error calls */
LogSvEvent((int)1948); /*12/01/2003 17:21:26*/
{
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;
/* LE SV TOC-2828 this is a stp-01.7.21 req to increment*/
LogSvEvent((int)1949); /*12/01/2003 17:21:26*/
A = B-C;
// max LOC 21
}
/*
-----------------------------------------------------------------------------
--| NAME: stp.1.8
--|
--| ABSTRACT:
--| This function does stp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void stp.1.8(void)
{
if (A le B)
{
A = B + C;
D = E + F;
}
A = B-C;
switch (stp 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;
/* LE SV TOC-2829 this is a stp-01.8.4 req to verify*/
LogSvEvent((int)1950); /*12/01/2003 17:21:26*/
A = B/C;
if (A != B)
{
A = B + C;
D = E + F;
}
A = B-C;
A = B*C;
/* LE SV TOC-2830 this is a stp-01.8.8 req to transform*/
LogSvEvent((int)1951); /*12/01/2003 17:21:26*/
A = B-C;
if ($stp stuff > $otherstp stuff)
/* LE SV TOC-008 we really should log all error calls */
LogSvEvent((int)1952); /*12/01/2003 17:21:26*/
{
A = B + C;
}
A = B+C;
A = B*C;
A = B*C;
/* LE SV TOC-2831 this is a stp-01.8.12 req to validate*/
LogSvEvent((int)1953); /*12/01/2003 17:21:26*/
if (A != B)
{
A = B + C;
D = E + F;
}
if (A le B)
{
A = B + C;
D = E + F;
}
A = B/C;
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;
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;
}
}
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;
if (A > B)
{
A = B + C;
D = E + F;
}
A = B/C;
A = B/C;
// max LOC 37
}
/*
-----------------------------------------------------------------------------
--| NAME: stp.1.9
--|
--| ABSTRACT:
--| This function does stp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void stp.1.9(void)
{
goto error;
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;
A = B-C;
A = B/C;
A = B-C;
#ifdef LAZY
// this is not nice
A = B + C;
A = B + C;
#endif
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;
}
// max LOC 18
}
/*
-----------------------------------------------------------------------------
--| NAME: stp.1.10
--|
--| ABSTRACT:
--| This function does stp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void stp.1.10(void)
{
A = B+C;
A = B*C;
A = B+C;
A = B-C;
A = B+C;
A = B-C;
A = B*C;
/* LE SV TOC-2832 this is a stp-01.10.8 req to detect error*/
LogSvEvent((int)1954); /*12/01/2003 17:21:26*/
A = B-C;
A = B+C;
A = B/C;
A = B+C;
A = 0x0006;
A = B+C;
A = B/C;
A = B-C;
send_buffer = (U16 *) malloc(size+1);
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;
/* LE SV TOC-2833 this is a stp-01.10.22 req to set Real Time Clock*/
LogSvEvent((int)1955); /*12/01/2003 17:21:26*/
if (A gt B)
{
A = B + C;
D = E + F;
}
if (A == B)
{
A = B + C;
D = E + F;
}
A = B*C;
/* LE SV TOC-2834 this is a stp-01.10.25 req to enable*/
LogSvEvent((int)1956); /*12/01/2003 17:21:26*/
A = B/C;
if (A < B)
{
A = B + C;
D = E + F;
}
A = B-C;
A = B/C;
A = 0x0004;
A = B-C;
A = B+C;
if (A <= B)
{
A = B + C;
D = E + F;
}
A = B*C;
A = B-C;
/* LE SV TOC-2835 this is a stp-01.10.34 req to audit*/
LogSvEvent((int)1957); /*12/01/2003 17:21:26*/
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;
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 eq B)
{
A = B + C;
D = E + F;
}
A = 0x0006;
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 lt 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;
A = B-C;
// max LOC 54
}
/*
-----------------------------------------------------------------------------
--| NAME: stp.1.11
--|
--| ABSTRACT:
--| This function does stp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void stp.1.11(void)
{
A = (int)B + C;
A = B+C;
A = B/C;
A = B/C;
A = B-C;
if (A >= B)
{
A = B + C;
D = E + F;
}
// max LOC 5
}
/*
-----------------------------------------------------------------------------
--| NAME: stp.1.12
--|
--| ABSTRACT:
--| This function does stp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void stp.1.12(void)
{
A = B-C;
switch (stp stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
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 eq B)
{
A = B + C;
D = E + F;
}
A = B*C;
/* LE SV TOC-2836 this is a stp-01.12.10 req to validate*/
LogSvEvent((int)1958); /*12/01/2003 17:21:26*/
A = B-C;
A = B/C;
A = B*C;
A = B*C;
A = B*C;
A = 0x0002;
A = B/C;
A = B+C;
A = B*C;
A = B/C;
/* LE SV TOC-2837 this is a stp-01.12.19 req to reject*/
LogSvEvent((int)1959); /*12/01/2003 17:21:26*/
if (A gt 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;
if (A gt B)
{
A = B + C;
D = E + F;
}
A = B/C;
/* LE SV TOC-2838 this is a stp-01.12.28 req to fail*/
LogSvEvent((int)1960); /*12/01/2003 17:21:26*/
A = B-C;
A = B*C;
A = B/C;
A = B-C;
A = B-C;
A = 0x0008;
A = B-C;
if (A ne B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-2839 this is a stp-01.12.35 req to verify*/
LogSvEvent((int)1961); /*12/01/2003 17:21:26*/
if (A >= B)
{
A = B + C;
D = E + F;
}
A = (float)B + C;
A = B+C;
A = B/C;
/* LE SV TOC-2840 this is a stp-01.12.38 req to set RTC*/
LogSvEvent((int)1962); /*12/01/2003 17:21:26*/
if (A >= B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-2841 this is a stp-01.12.39 req to increment*/
LogSvEvent((int)1963); /*12/01/2003 17:21:26*/
A = B*C;
A = B-C;
// max LOC 40
}
/*
-----------------------------------------------------------------------------
--| NAME: stp.1.13
--|
--| ABSTRACT:
--| This function does stp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void stp.1.13(void)
{
A = B-C;
/* LE SV TOC-2842 this is a stp-01.13.2 req to set RTC*/
LogSvEvent((int)1964); /*12/01/2003 17:21:26*/
A = B*C;
A = B*C;
if (A >= 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;
if (A le 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;
}
A = B+C;
A = B-C;
if (A ge B)
{
A = B + C;
D = E + F;
}
if (A eq 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;
}
/*
dead_block = C * D;
dead_block = E * F;
*/
A = B+C;
// max LOC 23
}
/*
-----------------------------------------------------------------------------
--| NAME: stp.1.14
--|
--| ABSTRACT:
--| This function does stp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void stp.1.14(void)
{
/*
dead_block = C * D;
dead_block = E * F;
*/
A = B-C;
A = B/C;
/* LE SV TOC-2843 this is a stp-01.14.3 req to disable*/
LogSvEvent((int)1965); /*12/01/2003 17:21:26*/
A = B-C;
/*
dead_code = B - C;
dead_code = D - E;
dead_code = F - G;
*/
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;
}
if {
X = Y + Z;
}
else {
halt;
}
if (A > B)
{
A = B + C;
D = E + F;
}
A = B/C;
/* LE SV TOC-2844 this is a stp-01.14.10 req to call isr*/
LogSvEvent((int)1966); /*12/01/2003 17:21:26*/
switch (stp stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
// max LOC 10
}