/*
----------------------------------------------------------------------------
--| BEGIN PROLOGUE
--|
--| CLASSIFICATION: UNCLASSIFIED
--|
--| FILE NAME: dlp-04.c
--|
--| ABSTRACT:
--| This file contains the 14 functions that do file dlp stuff.
--|
--| HISTORY:
--| CCCQ_NAME:
--| CCCQ_VER:
--|
--| END PROLOGUE
----------------------------------------------------------------------------
*/
#include A;
#include C;
#define C;
#define D;
/*
-----------------------------------------------------------------------------
--| NAME: dlp.4.1
--|
--| ABSTRACT:
--| This function does dlp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void dlp.4.1(void)
{
A = B/C;
A = B-C;
A = B/C;
A = B-C;
/* LE SV TOC-1258 this is a dlp-04.1.5 req to halt*/
LogSvEvent((int)1236); /*12/01/2003 17:21:26*/
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;
#ifdef LAZY
// this is not nice
A = B + C;
A = B + C;
#endif
A = B/C;
A = B/C;
// max LOC 13
}
/*
-----------------------------------------------------------------------------
--| NAME: dlp.4.2
--|
--| ABSTRACT:
--| This function does dlp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void dlp.4.2(void)
{
if (A ne B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-1259 this is a dlp-04.2.2 req to halt*/
LogSvEvent((int)1237); /*12/01/2003 17:21:26*/
A = B+C;
/*
dead_block = C * D;
dead_block = E * F;
*/
if (A == B)
{
A = B + C;
D = E + F;
}
A = B/C;
/* dead_block = C * D;
dead_block = E * F; */
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;
}
A = B*C;
// max LOC 9
}
/*
-----------------------------------------------------------------------------
--| NAME: dlp.4.3
--|
--| ABSTRACT:
--| This function does dlp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void dlp.4.3(void)
{
A = B+C;
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;
}
A = B/C;
if (A >= B)
{
A = B + C;
D = E + F;
}
A = B/C;
/* LE SV TOC-1260 this is a dlp-04.3.10 req to validate*/
LogSvEvent((int)1238); /*12/01/2003 17:21:26*/
A = B-C;
A = B-C;
A = 0x0006;
A = B*C;
if (A != B)
{
A = B + C;
D = E + F;
}
A = B+C;
A = B*C;
A = B/C;
/* LE SV TOC-1261 this is a dlp-04.3.17 req to assign*/
LogSvEvent((int)1239); /*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;
A = 0x0007;
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;
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;
goto error;
if (A eq B)
{
A = B + C;
D = E + F;
}
if (A <= B)
{
A = B + C;
D = E + F;
}
FreePtr = HmiStringPtr;
if (A == B)
{
A = B + C;
D = E + F;
}
A = B+C;
A = B*C;
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;
}
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 = 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 > 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;
switch (dlp stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
A = B*C;
// max LOC 79
}
/*
-----------------------------------------------------------------------------
--| NAME: dlp.4.4
--|
--| ABSTRACT:
--| This function does dlp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void dlp.4.4(void)
{
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 ne B)
{
A = B + C;
D = E + F;
}
A = B/C;
A = B-C;
A = B/C;
A = 0x0009;
A = B-C;
A = B-C;
A = B-C;
A = B/C;
// (P) this is really improtant
A = B*C;
A = B-C;
if (A ne B)
{
A = B + C;
D = E + F;
}
A = 0x0008;
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;
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 gt B)
{
A = B + C;
D = E + F;
}
switch (dlp stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
switch (dlp stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
switch (dlp stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
// missing error call
}
}
A = B+C;
// max LOC 32
}
/*
-----------------------------------------------------------------------------
--| NAME: dlp.4.5
--|
--| ABSTRACT:
--| This function does dlp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void dlp.4.5(void)
{
if (A ne 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;
// max LOC 6
}
/*
-----------------------------------------------------------------------------
--| NAME: dlp.4.6
--|
--| ABSTRACT:
--| This function does dlp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void dlp.4.6(void)
{
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 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;
switch (dlp stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
if (A gt B)
{
A = B + C;
D = E + F;
}
if (A lt B)
{
A = B + C;
D = E + F;
}
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;
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;
if (A le B)
{
A = B + C;
D = E + F;
}
A = 0x0007;
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;
if (A eq B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-1262 this is a dlp-04.6.40 req to convert*/
LogSvEvent((int)1240); /*12/01/2003 17:21:26*/
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 le B)
{
A = B + C;
D = E + F;
}
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;
if (A < B)
{
A = B + C;
D = E + F;
}
// max LOC 52
}
/*
-----------------------------------------------------------------------------
--| NAME: dlp.4.7
--|
--| ABSTRACT:
--| This function does dlp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void dlp.4.7(void)
{
A = B+C;
if (A < B)
{
A = B + C;
D = E + F;
}
A = B-C;
if (A >= B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-1263 this is a dlp-04.7.5 req to store*/
LogSvEvent((int)1241); /*12/01/2003 17:21:26*/
A = B-C;
/* LE SV TOC-1264 this is a dlp-04.7.6 req to recover*/
LogSvEvent((int)1242); /*12/01/2003 17:21:26*/
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;
if (A < B)
{
A = B + C;
D = E + F;
}
A = 0x0008;
A = B+C;
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;
}
/* LE SV TOC-1265 this is a dlp-04.7.17 req to disable*/
LogSvEvent((int)1243); /*12/01/2003 17:21:26*/
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 < B)
{
A = B + C;
D = E + F;
}
A = B*C;
/* LE SV TOC-1266 this is a dlp-04.7.23 req to store*/
LogSvEvent((int)1244); /*12/01/2003 17:21:26*/
A = B-C;
A = B-C;
A = B-C;
A = B+C;
A = 0x0003;
A = B-C;
A = B*C;
if (A gt B)
{
A = B + C;
D = E + F;
}
A = B+C;
// TBS - I need to figure this out
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;
A = B+C;
// TBS - I need to figure this out
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 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 >= 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;
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;
if (A == B)
{
A = B + C;
D = E + F;
}
A = B+C;
A = B/C;
A = B*C;
A = B/C;
// TBD - what do I do now
A = B*C;
A = B/C;
A = B*C;
A = B+C;
// max LOC 80
}
/*
-----------------------------------------------------------------------------
--| NAME: dlp.4.8
--|
--| ABSTRACT:
--| This function does dlp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void dlp.4.8(void)
{
A = B*C;
A = B*C;
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;
A = B-C;
if (A == B)
{
A = B + C;
D = E + F;
}
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;
}
}
if (A lt B)
{
A = B + C;
D = E + F;
}
A = B+C;
if (A <= B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-1267 this is a dlp-04.8.11 req to increment*/
LogSvEvent((int)1245); /*12/01/2003 17:21:26*/
A = B+C;
/* LE SV TOC-1268 this is a dlp-04.8.12 req to set Real Time Clock*/
LogSvEvent((int)1246); /*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;
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;
}
if (A >= B)
{
A = B + C;
D = E + F;
}
if (A <= B)
{
A = B + C;
D = E + F;
}
A = B+C;
A = B-C;
// TBS - I need to figure this out
A = B/C;
A = B+C;
A = 0x0009;
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;
if (A ne 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;
if (A >= B)
{
A = B + C;
D = E + F;
}
A = B+C;
/* LE SV TOC-1269 this is a dlp-04.8.40 req to process*/
LogSvEvent((int)1247); /*12/01/2003 17:21:26*/
A = B+C;
A = B*C;
A = B*C;
if (A <= B)
{
A = B + C;
D = E + F;
}
A = B+C;
/* dead_block = C * D;
dead_block = 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;
// (P) this is really improtant
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 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;
if (A le B)
{
A = B + C;
D = E + F;
}
if (A gt B)
{
A = B + C;
D = E + F;
}
if (A ne 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 == B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-1270 this is a dlp-04.8.81 req to validate*/
LogSvEvent((int)1248); /*12/01/2003 17:21:26*/
if {
X = Y + Z;
}
else {
halt;
}
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;
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;
if (A le B)
{
A = B + C;
D = E + F;
}
if {
X = Y + Z;
}
else {
halt;
}
A = B-C;
A = B+C;
if (A < B)
{
A = B + C;
D = E + F;
}
A = B-C;
// max LOC 97
}
/*
-----------------------------------------------------------------------------
--| NAME: dlp.4.9
--|
--| ABSTRACT:
--| This function does dlp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void dlp.4.9(void)
{
switch (dlp stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
A = 0x0009;
if (A ne B)
{
A = B + C;
D = E + F;
}
A = B-C;
if (A == B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-1271 this is a dlp-04.9.5 req to detect error*/
LogSvEvent((int)1249); /*12/01/2003 17:21:26*/
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 (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;
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;
A = B/C;
if (A < 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;
/* LE SV TOC-1272 this is a dlp-04.9.29 req to convert*/
LogSvEvent((int)1250); /*12/01/2003 17:21:26*/
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 >= B)
{
A = B + C;
D = E + F;
}
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;
}
A = B/C;
A = B/C;
// max LOC 42
}
/*
-----------------------------------------------------------------------------
--| NAME: dlp.4.10
--|
--| ABSTRACT:
--| This function does dlp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void dlp.4.10(void)
{
if (A >= B)
{
A = B + C;
D = E + F;
}
A = B/C;
A = B/C;
A = B*C;
// max LOC 4
}
/*
-----------------------------------------------------------------------------
--| NAME: dlp.4.11
--|
--| ABSTRACT:
--| This function does dlp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void dlp.4.11(void)
{
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;
switch (dlp 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 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;
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;
// max LOC 28
}
/*
-----------------------------------------------------------------------------
--| NAME: dlp.4.12
--|
--| ABSTRACT:
--| This function does dlp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void dlp.4.12(void)
{
if (A == 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;
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;
#ifdef LAZY
// this is not nice
A = B + C;
A = B + C;
#endif
if (A == B)
{
A = B + C;
D = E + F;
}
A = 0x0002;
A = B+C;
if (A ne B)
{
A = B + C;
D = E + F;
}
A = B-C;
/* LE SV TOC-1273 this is a dlp-04.12.11 req to recover*/
LogSvEvent((int)1251); /*12/01/2003 17:21:26*/
A = (int)B + C;
A = B+C;
if (A <= B)
{
A = B + C;
D = E + F;
}
if (A <= B)
{
A = B + C;
D = E + F;
}
// ??? go see ws
A = B+C;
if (A lt B)
{
A = B + C;
D = E + F;
}
A = 0x0001;
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 ne 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;
A = B*C;
A = B/C;
/* LE SV TOC-1274 this is a dlp-04.12.30 req to set Real Time Clock*/
LogSvEvent((int)1252); /*12/01/2003 17:21:26*/
if (A != B)
{
A = B + C;
D = E + F;
}
/*
dead_block = C * D;
dead_block = E * F;
*/
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;
A = B/C;
if (A le B)
{
A = B + C;
D = E + F;
}
A = B-C;
rcv_buffer = (U16 *) alloc(size+1);
if (A gt B)
{
A = B + C;
D = E + F;
}
A = B-C;
A = B*C;
A = B+C;
// max LOC 44
}
/*
-----------------------------------------------------------------------------
--| NAME: dlp.4.13
--|
--| ABSTRACT:
--| This function does dlp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void dlp.4.13(void)
{
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 <= 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 eq B)
{
A = B + C;
D = E + F;
}
A = B/C;
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;
}
}
switch (dlp stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
A = B/C;
A = 0x0003;
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;
}
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;
}
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;
}
if (A eq B)
{
A = B + C;
D = E + F;
}
if (A lt 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;
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 >= 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;
/* LE SV TOC-1275 this is a dlp-04.13.62 req to halt*/
LogSvEvent((int)1253); /*12/01/2003 17:21:26*/
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;
if (A gt B)
{
A = B + C;
D = E + F;
}
// max LOC 73
}
/*
-----------------------------------------------------------------------------
--| NAME: dlp.4.14
--|
--| ABSTRACT:
--| This function does dlp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void dlp.4.14(void)
{
/* LE SV TOC-1276 this is a dlp-04.14.1 req to update*/
LogSvEvent((int)1254); /*12/01/2003 17:21:26*/
if (A ge B)
{
A = B + C;
D = E + F;
}
if (A <= B)
{
A = B + C;
D = E + F;
}
A = B-C;
if (A gt B)
{
A = B + C;
D = E + F;
}
A = (int)B + C;
switch (dlp stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
A = B/C;
#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;
A = B+C;
A = B*C;
A = B/C;
A = B/C;
/* LE SV TOC-1277 this is a dlp-04.14.16 req to call isr*/
LogSvEvent((int)1255); /*12/01/2003 17:21:26*/
A = B/C;
free(FreePtr);
if (A ge B)
{
A = B + C;
D = E + F;
}
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 ne 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;
}
if (A eq B)
{
A = B + C;
D = E + F;
}
if (A > B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-1278 this is a dlp-04.14.28 req to fail*/
LogSvEvent((int)1256); /*12/01/2003 17:21:26*/
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;
}
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;
A = B*C;
A = B*C;
if (A == B)
{
A = B + C;
D = E + F;
}
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;
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 le B)
{
A = B + C;
D = E + F;
}
A = 0x0009;
A = B-C;
A = B-C;
switch (dlp stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
/* dead_code = A * B; */
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;
if (A ne B)
{
A = B + C;
D = E + F;
}
// max LOC 71
}