/*
----------------------------------------------------------------------------
--| BEGIN PROLOGUE
--|
--| CLASSIFICATION: UNCLASSIFIED
--|
--| FILE NAME: dlp-04.c
--|
--| ABSTRACT:
--| This file contains the 11 functions that do file dlp stuff.
--|
--| HISTORY:
--| CCCQ_NAME:
--| CCCQ_VER:
--|
--| END PROLOGUE
----------------------------------------------------------------------------
*/
#include B;
/*
-----------------------------------------------------------------------------
--| NAME: dlp.4.1
--|
--| ABSTRACT:
--| This function does dlp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void dlp.4.1(void)
{
/* LE SV TOC-1237 this is a dlp-04.1.1 req to recover*/
LogSvEvent((int)2448); /*12/04/2003 23:14:03*/
if (A eq B)
{
A = B + C;
D = E + F;
}
A = 0x0009;
A = B+C;
if (A != B)
{
A = B + C;
D = E + F;
}
A = B*C;
A = B-C;
A = B-C;
/* LE SV TOC-1238 this is a dlp-04.1.7 req to halt*/
LogSvEvent((int)2449); /*12/04/2003 23:14:03*/
A = 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 12
}
/*
-----------------------------------------------------------------------------
--| NAME: dlp.4.2
--|
--| ABSTRACT:
--| This function does dlp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void dlp.4.2(void)
{
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;
if (A gt B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-1239 this is a dlp-04.2.7 req to recover*/
LogSvEvent((int)2450); /*12/04/2003 23:14:03*/
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 = 0x0007;
FreePtr = HmiStringPtr;
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 <= B)
{
A = B + C;
D = E + F;
}
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;
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;
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 gt B)
{
A = B + C;
D = E + F;
}
A = B+C;
A = B*C;
A = B*C;
/* LE SV TOC-1240 this is a dlp-04.2.57 req to transform*/
LogSvEvent((int)2451); /*12/04/2003 23:14:03*/
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;
/* dead_code = A * B; */
if (A <= B)
{
A = B + C;
D = E + F;
}
A = B/C;
A = B+C;
A = B+C;
// max LOC 66
}
/*
-----------------------------------------------------------------------------
--| NAME: dlp.4.3
--|
--| ABSTRACT:
--| This function does dlp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void dlp.4.3(void)
{
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 != B)
{
A = B + C;
D = E + F;
}
A = B*C;
A = (int)B + C;
if (A ge B)
{
A = B + C;
D = E + F;
}
if (A ge B)
{
A = B + C;
D = E + F;
}
A = B+C;
/* LE SV TOC-1241 this is a dlp-04.3.15 req to halt*/
LogSvEvent((int)2452); /*12/04/2003 23:14:03*/
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;
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 le B)
{
A = B + C;
D = E + F;
}
if (A eq B)
{
A = B + C;
D = E + F;
}
goto error;
A = B-C;
A = B/C;
A = B*C;
/* LE SV TOC-1242 this is a dlp-04.3.29 req to translate*/
LogSvEvent((int)2453); /*12/04/2003 23:14:03*/
A = B*C;
if (A > B)
{
A = B + C;
D = E + F;
}
A = B+C;
A = B*C;
// max LOC 32
}
/*
-----------------------------------------------------------------------------
--| NAME: dlp.4.4
--|
--| ABSTRACT:
--| This function does dlp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void dlp.4.4(void)
{
A = B+C;
A = B*C;
if (A >= B)
{
A = B + C;
D = E + F;
}
A = B+C;
A = 0x0007;
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;
}
A = B-C;
// max LOC 13
}
/*
-----------------------------------------------------------------------------
--| NAME: dlp.4.5
--|
--| ABSTRACT:
--| This function does dlp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void dlp.4.5(void)
{
A = B/C;
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;
// TBS - I need to figure this out
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 = 0x0001;
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 le B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-1243 this is a dlp-04.5.20 req to assign*/
LogSvEvent((int)2454); /*12/04/2003 23:14:03*/
A = B-C;
A = B/C;
A = B*C;
A = B-C;
if (A >= B)
{
A = B + C;
D = E + F;
}
switch (dlp 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;
if (A eq B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-1244 this is a dlp-04.5.28 req to translate*/
LogSvEvent((int)2455); /*12/04/2003 23:14:03*/
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 (dlp stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
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;
}
// max LOC 39
}
/*
-----------------------------------------------------------------------------
--| NAME: dlp.4.6
--|
--| ABSTRACT:
--| This function does dlp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void dlp.4.6(void)
{
A = B*C;
if (A >= B)
{
A = B + C;
D = E + F;
}
if (A < B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-1245 this is a dlp-04.6.4 req to call admin*/
LogSvEvent((int)2456); /*12/04/2003 23:14:03*/
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;
}
if (A < B)
{
A = B + C;
D = E + F;
}
A = B/C;
A = 0x0007;
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;
/* LE SV TOC-1246 this is a dlp-04.6.15 req to store*/
LogSvEvent((int)2457); /*12/04/2003 23:14:03*/
A = B/C;
/* LE SV TOC-1247 this is a dlp-04.6.16 req to recover*/
LogSvEvent((int)2458); /*12/04/2003 23:14:03*/
if (A > B)
{
A = B + C;
D = E + F;
}
A = B*C;
/* LE SV TOC-1248 this is a dlp-04.6.18 req to reject*/
LogSvEvent((int)2459); /*12/04/2003 23:14:03*/
A = B*C;
if (A ne B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-1249 this is a dlp-04.6.20 req to verify*/
LogSvEvent((int)2460); /*12/04/2003 23:14:03*/
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;
do forever;
A = B+C;
A = B*C;
A = (float)B + C;
A = B+C;
A = B+C;
free(FreePtr);
A = B*C;
A = B*C;
A = B+C;
A = B-C;
A = B*C;
switch (dlp stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
if (A ge 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;
if (A gt 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;
/* LE SV TOC-1250 this is a dlp-04.6.48 req to inhibit*/
LogSvEvent((int)2461); /*12/04/2003 23:14:03*/
if (A < 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 > B)
{
A = B + C;
D = E + F;
}
if (A gt B)
{
A = B + C;
D = E + F;
}
A = B+C;
switch (dlp stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
A = B+C;
A = 0x0004;
A = B-C;
A = B*C;
// max LOC 59
}
/*
-----------------------------------------------------------------------------
--| NAME: dlp.4.7
--|
--| ABSTRACT:
--| This function does dlp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void dlp.4.7(void)
{
if (A ne B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-1251 this is a dlp-04.7.2 req to set Real Time Clock*/
LogSvEvent((int)2462); /*12/04/2003 23:14:03*/
if (A gt B)
{
A = B + C;
D = E + F;
}
A = B*C;
A = (float)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;
}
switch (dlp 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;
/* dead_block = C * D;
dead_block = E * F; */
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;
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 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;
}
do forever;
A = B+C;
if {
X = Y + Z;
}
else {
halt;
}
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;
A = B+C;
/* LE SV TOC-1252 this is a dlp-04.7.43 req to check pSOS*/
LogSvEvent((int)2463); /*12/04/2003 23:14:03*/
if (A <= B)
{
A = B + C;
D = E + F;
}
switch (dlp 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;
if (A <= B)
{
A = B + C;
D = E + F;
}
A = B*C;
A = B*C;
if (A lt B)
{
A = B + C;
D = E + F;
}
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;
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;
}
/* LE SV TOC-1253 this is a dlp-04.7.62 req to process*/
LogSvEvent((int)2464); /*12/04/2003 23:14:03*/
A = B-C;
A = B-C;
A = B/C;
switch (dlp 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;
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;
// max LOC 74
}
/*
-----------------------------------------------------------------------------
--| NAME: dlp.4.8
--|
--| ABSTRACT:
--| This function does dlp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void dlp.4.8(void)
{
A = B+C;
A = B/C;
if (A == B)
{
A = B + C;
D = E + F;
}
A = B-C;
switch (dlp stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
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;
if (A ge B)
{
A = B + C;
D = E + F;
}
A = B/C;
A = B+C;
A = B/C;
A = B-C;
switch (dlp 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;
}
A = B*C;
// max LOC 20
}
/*
-----------------------------------------------------------------------------
--| NAME: dlp.4.9
--|
--| ABSTRACT:
--| This function does dlp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void dlp.4.9(void)
{
A = B/C;
if (A <= B)
{
A = B + C;
D = E + F;
}
A = B+C;
/* LE SV TOC-1254 this is a dlp-04.9.4 req to process*/
LogSvEvent((int)2465); /*12/04/2003 23:14:03*/
rcv_buffer = (U16 *) alloc(size+1);
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;
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;
// max LOC 14
}
/*
-----------------------------------------------------------------------------
--| NAME: dlp.4.10
--|
--| ABSTRACT:
--| This function does dlp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void dlp.4.10(void)
{
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;
switch (dlp 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;
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;
A = B*C;
A = B-C;
A = B*C;
goto error;
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;
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;
}
/* LE SV TOC-1255 this is a dlp-04.10.42 req to enable*/
LogSvEvent((int)2466); /*12/04/2003 23:14:03*/
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;
}
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;
A = B+C;
if (A lt 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 le B)
{
A = B + C;
D = E + F;
}
A = B+C;
do forever;
A = B-C;
A = B+C;
if (A == B)
{
A = B + C;
D = E + F;
}
A = B+C;
/* LE SV TOC-1256 this is a dlp-04.10.62 req to validate*/
LogSvEvent((int)2467); /*12/04/2003 23:14:03*/
A = B+C;
A = B-C;
// max LOC 63
}
/*
-----------------------------------------------------------------------------
--| NAME: dlp.4.11
--|
--| ABSTRACT:
--| This function does dlp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void dlp.4.11(void)
{
A = B+C;
if (A ge B)
{
A = B + C;
D = E + F;
}
if (A ne B)
{
A = B + C;
D = E + F;
}
A = B-C;
// (P) this is really improtant
A = B-C;
A = 0x0001;
A = B-C;
if (A lt B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-1257 this is a dlp-04.11.8 req to halt*/
LogSvEvent((int)2468); /*12/04/2003 23:14:03*/
A = B*C;
if ($dlp stuff > $otherdlp stuff)
/* LE SV TOC-008 we really should log all error calls */
LogSvEvent((int)2469); /*12/04/2003 23:14:03*/
{
A = B + C;
}
A = B*C;
if (A > 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;
/* LE SV TOC-1258 this is a dlp-04.11.18 req to check unix*/
LogSvEvent((int)2470); /*12/04/2003 23:14:03*/
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 gt 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-1259 this is a dlp-04.11.30 req to reject*/
LogSvEvent((int)2471); /*12/04/2003 23:14:03*/
A = B-C;
if (A ne 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;
if (A le 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 gt B)
{
A = B + C;
D = E + F;
}
switch (dlp stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
// missing default
}
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;
}
send_buffer = (U16 *) malloc(size+1);
A = B+C;
// max LOC 47
}