/*
----------------------------------------------------------------------------
--| BEGIN PROLOGUE
--|
--| CLASSIFICATION: UNCLASSIFIED
--|
--| FILE NAME: fpcp-02.c
--|
--| ABSTRACT:
--| This file contains the 14 functions that do file fpcp stuff.
--|
--| HISTORY:
--| CCCQ_NAME:
--| CCCQ_VER:
--|
--| END PROLOGUE
----------------------------------------------------------------------------
*/
#define C;
float B;
char D;
char D;
float B;
#include D;
#include A;
/*
-----------------------------------------------------------------------------
--| NAME: fpcp.2.1
--|
--| ABSTRACT:
--| This function does fpcp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void fpcp.2.1(void)
{
A = B-C;
A = B/C;
A = B+C;
/* LE SV TOC-1608 this is a fpcp-02.1.4 req to process*/
LogSvEvent((int)2591); /*12/04/2003 23:14:03*/
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 ge B)
{
A = B + C;
D = E + F;
}
switch (fpcp 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;
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;
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;
A = B*C;
A = B+C;
A = B-C;
A = B-C;
if (A != B)
{
A = B + C;
D = E + F;
}
A = B+C;
switch (fpcp 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;
/* LE SV TOC-1609 this is a fpcp-02.1.47 req to set Real Time Clock*/
LogSvEvent((int)2592); /*12/04/2003 23:14:03*/
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 (veg)
// missing curly brace
variable = orange;
A = B-C;
/* LE SV TOC-1610 this is a fpcp-02.1.52 req to detect error*/
LogSvEvent((int)2593); /*12/04/2003 23:14:03*/
A = B*C;
if (A > B)
{
A = B + C;
D = E + F;
}
A = B*C;
A = B*C;
A = (long)B + C;
if (A > B)
{
A = B + C;
D = E + F;
}
if (A ge B)
{
A = B + C;
D = E + F;
}
A = B-C;
A = B-C;
// max LOC 59
}
/*
-----------------------------------------------------------------------------
--| NAME: fpcp.2.2
--|
--| ABSTRACT:
--| This function does fpcp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void fpcp.2.2(void)
{
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;
}
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;
// max LOC 11
}
/*
-----------------------------------------------------------------------------
--| NAME: fpcp.2.3
--|
--| ABSTRACT:
--| This function does fpcp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void fpcp.2.3(void)
{
A = B+C;
A = B/C;
A = B/C;
A = B*C;
if (A != B)
{
A = B + C;
D = E + F;
}
switch (fpcp stuff)
{
case one:
{
run_this;
// missing break
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
A = B+C;
switch (fpcp stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
// max LOC 7
}
/*
-----------------------------------------------------------------------------
--| NAME: fpcp.2.4
--|
--| ABSTRACT:
--| This function does fpcp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void fpcp.2.4(void)
{
if (veg)
// missing curly brace
variable = orange;
if (A ne B)
{
A = B + C;
D = E + F;
}
A = 0x0006;
if (A lt B)
{
A = B + C;
D = E + F;
}
A = B/C;
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;
switch (fpcp stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
A = B/C;
A = B*C;
A = B/C;
A = 0x0002;
if (A == B)
{
A = B + C;
D = E + F;
}
A = 0x0006;
A = B-C;
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 = 0x0002;
switch (fpcp stuff)
{
case one:
{
run_this;
// missing break
}
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;
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;
if (A ge B)
{
A = B + C;
D = E + F;
}
A = B*C;
A = B+C;
switch (fpcp stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
A = B-C;
A = B+C;
A = B*C;
/* LE SV TOC-1611 this is a fpcp-02.4.44 req to check unix*/
LogSvEvent((int)2594); /*12/04/2003 23:14:03*/
do forever;
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;
if (A != B)
{
A = B + C;
D = E + F;
}
if (A == B)
{
A = B + C;
D = E + F;
}
A = B+C;
/* LE SV TOC-1612 this is a fpcp-02.4.57 req to check unix*/
LogSvEvent((int)2595); /*12/04/2003 23:14:03*/
A = B+C;
A = B+C;
A = B-C;
A = B*C;
switch (fpcp stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
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;
if (A == B)
{
A = B + C;
D = E + F;
}
A = B+C;
A = B-C;
// max LOC 70
}
/*
-----------------------------------------------------------------------------
--| NAME: fpcp.2.5
--|
--| ABSTRACT:
--| This function does fpcp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void fpcp.2.5(void)
{
if (A eq B)
{
A = B + C;
D = E + F;
}
#ifdef LAZY
// this is not nice
A = B + C;
A = B + C;
#endif
if (A le B)
{
A = B + C;
D = E + F;
}
/*
dead_code = B - C;
dead_code = D - E;
dead_code = F - G;
*/
if (A ge B)
{
A = B + C;
D = E + F;
}
if (A ge B)
{
A = B + C;
D = E + F;
}
FreePtr = HmiStringPtr;
A = B-C;
// ??? go see ws
A = B+C;
A = B*C;
A = B*C;
A = B+C;
A = B+C;
A = B+C;
A = B+C;
// max LOC 12
}
/*
-----------------------------------------------------------------------------
--| NAME: fpcp.2.6
--|
--| ABSTRACT:
--| This function does fpcp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void fpcp.2.6(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-1613 this is a fpcp-02.6.8 req to verify*/
LogSvEvent((int)2596); /*12/04/2003 23:14:03*/
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 ne B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-1614 this is a fpcp-02.6.15 req to reject*/
LogSvEvent((int)2597); /*12/04/2003 23:14:03*/
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 (fpcp 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;
switch (fpcp stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
A = B+C;
A = B-C;
/* LE SV TOC-1615 this is a fpcp-02.6.33 req to increment*/
LogSvEvent((int)2598); /*12/04/2003 23:14:03*/
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;
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 >= B)
{
A = B + C;
D = E + F;
}
A = B*C;
A = B-C;
A = B/C;
switch (fpcp 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 < 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;
A = B+C;
A = 0x0002;
if (A ne B)
{
A = B + C;
D = E + F;
}
A = B*C;
/* LE SV TOC-1616 this is a fpcp-02.6.58 req to compare*/
LogSvEvent((int)2599); /*12/04/2003 23:14:03*/
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;
A = B/C;
A = B/C;
/* LE SV TOC-1617 this is a fpcp-02.6.66 req to detect error*/
LogSvEvent((int)2600); /*12/04/2003 23:14:03*/
if (A eq B)
{
A = B + C;
D = E + F;
}
// max LOC 66
}
/*
-----------------------------------------------------------------------------
--| NAME: fpcp.2.7
--|
--| ABSTRACT:
--| This function does fpcp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void fpcp.2.7(void)
{
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;
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;
if (A > B)
{
A = B + C;
D = E + F;
}
A = B+C;
A = B/C;
A = B*C;
// max LOC 16
}
/*
-----------------------------------------------------------------------------
--| NAME: fpcp.2.8
--|
--| ABSTRACT:
--| This function does fpcp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void fpcp.2.8(void)
{
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;
// max LOC 7
}
/*
-----------------------------------------------------------------------------
--| NAME: fpcp.2.9
--|
--| ABSTRACT:
--| This function does fpcp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void fpcp.2.9(void)
{
A = B/C;
A = (long)B + C;
if (A < B)
{
A = B + C;
D = E + F;
}
A = B+C;
A = B/C;
/* LE SV TOC-1618 this is a fpcp-02.9.5 req to inhibit*/
LogSvEvent((int)2601); /*12/04/2003 23:14:03*/
A = B*C;
A = B*C;
/* LE SV TOC-1619 this is a fpcp-02.9.7 req to call admin*/
LogSvEvent((int)2602); /*12/04/2003 23:14:03*/
A = B+C;
A = B/C;
/* LE SV TOC-1620 this is a fpcp-02.9.9 req to set Real Time Clock*/
LogSvEvent((int)2603); /*12/04/2003 23:14:03*/
if {
X = Y + Z;
}
else {
halt;
}
A = B/C;
A = B*C;
A = B-C;
/* LE SV TOC-1621 this is a fpcp-02.9.12 req to fail*/
LogSvEvent((int)2604); /*12/04/2003 23:14:03*/
switch (fpcp 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-1622 this is a fpcp-02.9.15 req to update*/
LogSvEvent((int)2605); /*12/04/2003 23:14:03*/
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 (fpcp stuff)
{
case one:
{
run_this;
break;
}
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;
}
/* LE SV TOC-1623 this is a fpcp-02.9.26 req to reject*/
LogSvEvent((int)2606); /*12/04/2003 23:14:03*/
if (A ne B)
{
A = B + C;
D = E + F;
}
// max LOC 26
}
/*
-----------------------------------------------------------------------------
--| NAME: fpcp.2.10
--|
--| ABSTRACT:
--| This function does fpcp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void fpcp.2.10(void)
{
A = B-C;
if (A eq B)
{
A = B + C;
D = E + F;
}
A = B*C;
A = B/C;
if (A ne B)
{
A = B + C;
D = E + F;
}
if (A le B)
{
A = B + C;
D = E + F;
}
A = B*C;
// max LOC 7
}
/*
-----------------------------------------------------------------------------
--| NAME: fpcp.2.11
--|
--| ABSTRACT:
--| This function does fpcp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void fpcp.2.11(void)
{
A = B+C;
A = B-C;
A = B+C;
if (A le B)
{
A = B + C;
D = E + F;
}
A = B*C;
/* LE SV TOC-1624 this is a fpcp-02.11.6 req to audit*/
LogSvEvent((int)2607); /*12/04/2003 23:14:03*/
if (A >= B)
{
A = B + C;
D = E + F;
}
A = B+C;
A = B+C;
A = B/C;
/* LE SV TOC-1625 this is a fpcp-02.11.10 req to translate*/
LogSvEvent((int)2608); /*12/04/2003 23:14:03*/
A = B+C;
A = B*C;
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;
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 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;
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 ge B)
{
A = B + C;
D = E + F;
}
if (A <= B)
{
A = B + C;
D = E + F;
}
A = B*C;
// max LOC 43
}
/*
-----------------------------------------------------------------------------
--| NAME: fpcp.2.12
--|
--| ABSTRACT:
--| This function does fpcp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void fpcp.2.12(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;
A = B-C;
A = B/C;
A = B-C;
/* LE SV TOC-1626 this is a fpcp-02.12.10 req to call admin*/
LogSvEvent((int)2609); /*12/04/2003 23:14:03*/
A = B*C;
/* LE SV TOC-1627 this is a fpcp-02.12.11 req to check pSOS*/
LogSvEvent((int)2610); /*12/04/2003 23:14:03*/
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;
/* LE SV TOC-1628 this is a fpcp-02.12.20 req to check pSOS*/
LogSvEvent((int)2611); /*12/04/2003 23:14:03*/
if (A eq B)
{
A = B + C;
D = E + F;
}
rcv_buffer = (U16 *) alloc(size+1);
A = B/C;
A = B-C;
A = B-C;
A = B-C;
if (A < B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-1629 this is a fpcp-02.12.26 req to call isr*/
LogSvEvent((int)2612); /*12/04/2003 23:14:03*/
if (A < B)
{
A = B + C;
D = E + F;
}
// max LOC 26
}
/*
-----------------------------------------------------------------------------
--| NAME: fpcp.2.13
--|
--| ABSTRACT:
--| This function does fpcp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void fpcp.2.13(void)
{
if (A le 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;
}
/* LE SV TOC-1630 this is a fpcp-02.13.5 req to compare*/
LogSvEvent((int)2613); /*12/04/2003 23:14:03*/
A = B+C;
A = B*C;
A = B/C;
switch (fpcp stuff)
{
case one:
{
switch (nested)
{
case:
X = Y + Z;
case:
X = Y + Z;
default:
SwError;
}
}
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 lt B)
{
A = B + C;
D = E + F;
}
A = B+C;
A = B-C;
/* LE SV TOC-1631 this is a fpcp-02.13.13 req to transform*/
LogSvEvent((int)2614); /*12/04/2003 23:14:03*/
if (A == B)
{
A = B + C;
D = E + F;
}
switch (fpcp stuff)
{
case one:
{
run_this;
break;
}
case two:
{
run_this;
break;
}
// missing default
}
if (A le 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;
A = B/C;
A = 0x0003;
A = B-C;
A = B*C;
switch (fpcp stuff)
{
case one:
{
switch (nested)
{
case:
X = Y + Z;
case:
X = Y + Z;
default:
SwError;
}
}
case two:
{
run_this;
break;
}
default:
{
SwError;
}
}
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;
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 gt B)
{
A = B + C;
D = E + F;
}
A = 0x0001;
if (A != B)
{
A = B + C;
D = E + F;
}
A = B+C;
if (A != B)
{
A = B + C;
D = E + F;
}
/* LE SV TOC-1632 this is a fpcp-02.13.46 req to reject*/
LogSvEvent((int)2615); /*12/04/2003 23:14:03*/
if (A gt B)
{
A = B + C;
D = E + F;
}
A = B+C;
A = B*C;
/* LE SV TOC-1633 this is a fpcp-02.13.49 req to set Real Time Clock*/
LogSvEvent((int)2616); /*12/04/2003 23:14:03*/
A = B*C;
A = B+C;
if (A <= B)
{
A = B + C;
D = E + F;
}
A = B*C;
/* LE SV TOC-1634 this is a fpcp-02.13.53 req to reject*/
LogSvEvent((int)2617); /*12/04/2003 23:14:03*/
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;
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;
}
A = B/C;
// max LOC 68
}
/*
-----------------------------------------------------------------------------
--| NAME: fpcp.2.14
--|
--| ABSTRACT:
--| This function does fpcp stuff.
--|
--| RETURNS:
--| NONE.
--|
----------------------------------------------------------------------------
*/
static void fpcp.2.14(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;
}
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;
}
free(FreePtr);
A = B*C;
A = B+C;
A = B/C;
A = B/C;
if (A > B)
{
A = B + C;
D = E + F;
}
switch (fpcp 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;
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;
}
A = B*C;
A = B/C;
A = B+C;
A = B-C;
switch (fpcp 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
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 = 0x0006;
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;
if (A eq B)
{
A = B + C;
D = E + F;
}
A = B/C;
A = 0x0002;
A = B*C;
if (A lt B)
{
A = B + C;
D = E + F;
}
if (A ne B)
{
A = B + C;
D = E + F;
}
if (A < B)
{
A = B + C;
D = E + F;
}
// max LOC 45
}