IAT

Regression Analysis v111003

Software Instrumentation and Analysis
Using The Analysis Reports
Running Your Own Software Analysis
Testing and LabReduction

Regression Analysis
Process and Traceability
Internal Operations
Regular Expressions

Regression Analysis v111003 analysis/ft-app-B1.1 s_regression.html

Regression is a web based analysis tool used to help identify potential areas of re-test when software is upgraded. It produces a DIFF report between the two versions and submits the resulting files to a detailed analysis which extracts information.

Analysis	Comment
Compare Translate	This analysis shows a DIFF between the original translate file and the new translate file.
Compare Software Filter Headers	This analysis shows a DIFF between the original source code and the new source code, but the header information is filtered.
Compare Software	This analysis shows a DIFF between the original source code and the new source code.
Baseline Files	This analysis shows whole files deleted from or added to the baseline.
Details	This analysis shows log events and possible regression tests based on keywords analysis and a DIFF.
Regression Test Keywords Analysis	This analysis shows a set of potential regression tests based on a keyword analysis.
Regression Test File Analysis	This analysis shows a set of changed files and potential regression tests based on a keyword analysis.

Other Analysis Reports . Old Source Code . New Source Code . Help

11/25/2003 18:34:59

Settings

Comments 
  rows
Classification
 Report Marking
 Classified Keywords

Paths 
 if saved use ../../
 Source Path
 CSCI
 Old Version
 New Version

Keywords
watchdog|download|down.load|self.test|selftest|power.on|power.off|mmi|hmi color
version color
delete|settings color
audit|halt|reset|TOC-\d+|logon|log.on||logoff|log.off color
radar|flight|plan|conflict|probe|beacon color

Reports 
 Controls   
 Translate   
 Compare 0 Include Headers
 Compare 1 Exclude Headers
 Details
 Abstract
 Ignore Files

Translate File Difference Report

The log event numbers and function names have been masked in this DIFF. The log event numbers change with each release and the functions change as the IAT function detector keeps getting better.

1 Old: analysis/ft-app-B1.1/temp1.dat
1 New: analysis/ft-app-B1.1/temp2.dat

PROPRIETARY

1c1
< time, Translate File Created 11/22/2003 23:07:01
---
> time, Translate File Created 11/25/2003 12:15:30

179,257c179,237
< dlp-01.c dlp.1.1 LE SV TOC-1201 this is a dlp-01.1.2 req to inhibit
< dlp-01.c dlp.1.1 LE SV TOC-1202 this is a dlp-01.1.15 req to check unix
< dlp-01.c dlp.1.1 LE SV TOC-1203 this is a dlp-01.1.27 req to increment
< dlp-01.c dlp.1.1 LE SV TOC-1204 this is a dlp-01.1.32 req to compare
< dlp-01.c dlp.1.1 LE SV TOC-1205 this is a dlp-01.1.38 req to process
< dlp-01.c dlp.1.2 LE SV TOC-1206 this is a dlp-01.2.13 req to record
< dlp-01.c dlp.1.3 LE SV TOC-1207 this is a dlp-01.3.15 req to process
< dlp-01.c dlp.1.3 LE SV TOC-1208 this is a dlp-01.3.22 req to fail
< dlp-01.c dlp.1.3 LE SV TOC-1209 this is a dlp-01.3.25 req to disable
< dlp-01.c dlp.1.3 LE SV TOC-1210 this is a dlp-01.3.37 req to verify
< dlp-01.c dlp.1.3 LE SV TOC-1211 this is a dlp-01.3.54 req to transform
< dlp-01.c dlp.1.4 LE SV TOC-1212 this is a dlp-01.4.19 req to set Real Time Clock
< dlp-01.c dlp.1.4 LE SV TOC-1213 this is a dlp-01.4.34 req to audit
< dlp-01.c dlp.1.4 LE SV TOC-1214 this is a dlp-01.4.35 req to increment
< dlp-01.c dlp.1.5 LE SV TOC-1215 this is a dlp-01.5.12 req to process
< dlp-01.c dlp.1.5 LE SV TOC-1216 this is a dlp-01.5.39 req to fail
< dlp-01.c dlp.1.5 LE SV TOC-1217 this is a dlp-01.5.48 req to reject
< dlp-01.c dlp.1.6 LE SV TOC-1218 this is a dlp-01.6.6 req to check unix
< dlp-01.c dlp.1.6 LE SV TOC-1219 this is a dlp-01.6.50 req to increment
< dlp-01.c dlp.1.6 LE SV TOC-1220 this is a dlp-01.6.55 req to halt
< dlp-01.c dlp.1.9 LE SV TOC-1221 this is a dlp-01.9.5 req to transform
< dlp-01.c dlp.1.9 LE SV TOC-1222 this is a dlp-01.9.26 req to store
< dlp-01.c dlp.1.9 LE SV TOC-1223 this is a dlp-01.9.43 req to fail
< dlp-02.c dlp.2.1 LE SV TOC-1224 this is a dlp-02.1.7 req to assign
< dlp-02.c dlp.2.1 LE SV TOC-1225 this is a dlp-02.1.28 req to inhibit
< dlp-02.c dlp.2.2 LE SV TOC-1226 this is a dlp-02.2.43 req to set RTC
< dlp-02.c dlp.2.2 LE SV TOC-1227 this is a dlp-02.2.70 req to convert
< dlp-02.c dlp.2.3 LE SV TOC-1228 this is a dlp-02.3.41 req to disable
< dlp-02.c dlp.2.4 LE SV TOC-1229 this is a dlp-02.4.42 req to verify
< dlp-02.c dlp.2.4 LE SV TOC-1230 this is a dlp-02.4.58 req to inhibit
< dlp-02.c dlp.2.4 LE SV TOC-1231 this is a dlp-02.4.67 req to call admin
< dlp-02.c dlp.2.5 LE SV TOC-1232 this is a dlp-02.5.17 req to halt
< dlp-02.c dlp.2.5 LE SV TOC-1233 this is a dlp-02.5.45 req to update
< dlp-02.c dlp.2.5 LE SV TOC-1234 this is a dlp-02.5.59 req to convert
< dlp-02.c dlp.2.6 LE SV TOC-1235 this is a dlp-02.6.5 req to check unix
< dlp-02.c dlp.2.6 LE SV TOC-1236 this is a dlp-02.6.24 req to call admin
< dlp-02.c dlp.2.6 LE SV TOC-1237 this is a dlp-02.6.34 req to update
< dlp-03.c dlp.3.1 LE SV TOC-1238 this is a dlp-03.1.2 req to process
< dlp-03.c dlp.3.1 LE SV TOC-1239 this is a dlp-03.1.21 req to set Real Time Clock
< dlp-03.c dlp.3.2 LE SV TOC-1240 this is a dlp-03.2.32 req to recover
< dlp-03.c dlp.3.2 LE SV TOC-008 we really should log all error calls
< dlp-03.c dlp.3.3 LE SV TOC-1241 this is a dlp-03.3.28 req to increment
< dlp-03.c dlp.3.3 LE SV TOC-1242 this is a dlp-03.3.44 req to record
< dlp-03.c dlp.3.4 LE SV TOC-1243 this is a dlp-03.4.1 req to audit
< dlp-03.c dlp.3.5 LE SV TOC-1244 this is a dlp-03.5.6 req to audit
< dlp-03.c dlp.3.5 LE SV TOC-1245 this is a dlp-03.5.22 req to call isr
< dlp-03.c dlp.3.5 LE SV TOC-1246 this is a dlp-03.5.28 req to set RTC
< dlp-03.c dlp.3.5 LE SV TOC-1247 this is a dlp-03.5.32 req to set RTC
< dlp-03.c dlp.3.5 LE SV TOC-1248 this is a dlp-03.5.55 req to enable
< dlp-03.c dlp.3.5 LE SV TOC-1249 this is a dlp-03.5.67 req to audit
< dlp-03.c dlp.3.5 LE SV TOC-1250 this is a dlp-03.5.68 req to verify
< dlp-03.c dlp.3.6 LE SV TOC-1251 this is a dlp-03.6.5 req to store
< dlp-03.c dlp.3.7 LE SV TOC-1252 this is a dlp-03.7.13 req to set Real Time Clock
< dlp-03.c dlp.3.8 LE SV TOC-1253 this is a dlp-03.8.7 req to detect error
< dlp-03.c dlp.3.9 LE SV TOC-1254 this is a dlp-03.9.13 req to compare
< dlp-03.c dlp.3.9 LE SV TOC-1255 this is a dlp-03.9.18 req to store
< dlp-03.c dlp.3.9 LE SV TOC-1256 this is a dlp-03.9.38 req to assign
< dlp-03.c dlp.3.10 LE SV TOC-1257 this is a dlp-03.10.21 req to increment
< dlp-04.c dlp.4.1 LE SV TOC-1258 this is a dlp-04.1.5 req to halt
< dlp-04.c dlp.4.2 LE SV TOC-1259 this is a dlp-04.2.2 req to halt
< dlp-04.c dlp.4.3 LE SV TOC-1260 this is a dlp-04.3.10 req to validate
< dlp-04.c dlp.4.3 LE SV TOC-1261 this is a dlp-04.3.17 req to assign
< dlp-04.c dlp.4.6 LE SV TOC-1262 this is a dlp-04.6.40 req to convert
< dlp-04.c dlp.4.7 LE SV TOC-1263 this is a dlp-04.7.5 req to store
< dlp-04.c dlp.4.7 LE SV TOC-1264 this is a dlp-04.7.6 req to recover
< dlp-04.c dlp.4.7 LE SV TOC-1265 this is a dlp-04.7.17 req to disable
< dlp-04.c dlp.4.7 LE SV TOC-1266 this is a dlp-04.7.23 req to store
< dlp-04.c dlp.4.8 LE SV TOC-1267 this is a dlp-04.8.11 req to increment
< dlp-04.c dlp.4.8 LE SV TOC-1268 this is a dlp-04.8.12 req to set Real Time Clock
< dlp-04.c dlp.4.8 LE SV TOC-1269 this is a dlp-04.8.40 req to process
< dlp-04.c dlp.4.8 LE SV TOC-1270 this is a dlp-04.8.81 req to validate
< dlp-04.c dlp.4.9 LE SV TOC-1271 this is a dlp-04.9.5 req to detect error
< dlp-04.c dlp.4.9 LE SV TOC-1272 this is a dlp-04.9.29 req to convert
< dlp-04.c dlp.4.12 LE SV TOC-1273 this is a dlp-04.12.11 req to recover
< dlp-04.c dlp.4.12 LE SV TOC-1274 this is a dlp-04.12.30 req to set Real Time Clock
< dlp-04.c dlp.4.13 LE SV TOC-1275 this is a dlp-04.13.62 req to halt
< dlp-04.c dlp.4.14 LE SV TOC-1276 this is a dlp-04.14.1 req to update
< dlp-04.c dlp.4.14 LE SV TOC-1277 this is a dlp-04.14.16 req to call isr
< dlp-04.c dlp.4.14 LE SV TOC-1278 this is a dlp-04.14.28 req to fail
---
> dlp-01.c dlp.1.1 LE SV TOC-1202 this is a dlp-01.1.30 req to disable
> dlp-01.c dlp.1.1 LE SV TOC-1203 this is a dlp-01.1.34 req to store
> dlp-01.c dlp.1.1 LE SV TOC-1204 this is a dlp-01.1.37 req to set Real Time Clock
> dlp-02.c dlp.2.1 LE SV TOC-1205 this is a dlp-02.1.8 req to disable
> dlp-02.c dlp.2.1 LE SV TOC-1206 this is a dlp-02.1.27 req to compare
> dlp-02.c dlp.2.2 LE SV TOC-1207 this is a dlp-02.2.11 req to transform
> dlp-02.c dlp.2.2 LE SV TOC-1208 this is a dlp-02.2.12 req to set Real Time Clock
> dlp-02.c dlp.2.3 LE SV TOC-1209 this is a dlp-02.3.11 req to check unix
> dlp-02.c dlp.2.3 LE SV TOC-1210 this is a dlp-02.3.16 req to convert
> dlp-02.c dlp.2.3 LE SV TOC-1211 this is a dlp-02.3.53 req to convert
> dlp-02.c dlp.2.3 LE SV TOC-1212 this is a dlp-02.3.72 req to recover
> dlp-02.c dlp.2.5 LE SV TOC-1213 this is a dlp-02.5.1 req to verify
> dlp-02.c dlp.2.5 LE SV TOC-1214 this is a dlp-02.5.2 req to process
> dlp-02.c dlp.2.5 LE SV TOC-1215 this is a dlp-02.5.19 req to verify
> dlp-02.c dlp.2.5 LE SV TOC-1216 this is a dlp-02.5.34 req to audit
> dlp-02.c dlp.2.6 LE SV TOC-1217 this is a dlp-02.6.14 req to validate
> dlp-02.c dlp.2.6 LE SV TOC-1218 this is a dlp-02.6.23 req to recover
> dlp-02.c dlp.2.6 LE SV TOC-1219 this is a dlp-02.6.43 req to check unix
> dlp-03.c dlp.3.1 LE SV TOC-1220 this is a dlp-03.1.21 req to process
> dlp-03.c dlp.3.1 LE SV TOC-1221 this is a dlp-03.1.24 req to transform
> dlp-03.c dlp.3.1 LE SV TOC-1222 this is a dlp-03.1.33 req to compare
> dlp-03.c dlp.3.2 LE SV TOC-1223 this is a dlp-03.2.2 req to compare
> dlp-03.c dlp.3.2 LE SV TOC-1224 this is a dlp-03.2.19 req to update
> dlp-03.c dlp.3.2 LE SV TOC-1225 this is a dlp-03.2.25 req to increment
> dlp-03.c dlp.3.2 LE SV TOC-1226 this is a dlp-03.2.39 req to store
> dlp-03.c dlp.3.4 LE SV TOC-1227 this is a dlp-03.4.5 req to set RTC
> dlp-03.c dlp.3.4 LE SV TOC-1228 this is a dlp-03.4.22 req to fail
> dlp-03.c dlp.3.5 LE SV TOC-1229 this is a dlp-03.5.14 req to update
> dlp-03.c dlp.3.5 LE SV TOC-1230 this is a dlp-03.5.22 req to verify
> dlp-03.c dlp.3.5 LE SV TOC-1231 this is a dlp-03.5.23 req to detect error
> dlp-03.c dlp.3.5 LE SV TOC-1232 this is a dlp-03.5.31 req to halt
> dlp-03.c dlp.3.5 LE SV TOC-1233 this is a dlp-03.5.77 req to halt
> dlp-03.c dlp.3.6 LE SV TOC-1234 this is a dlp-03.6.21 req to verify
> dlp-03.c dlp.3.6 LE SV TOC-1235 this is a dlp-03.6.30 req to validate
> dlp-03.c dlp.3.6 LE SV TOC-1236 this is a dlp-03.6.45 req to compare
> dlp-04.c dlp.4.1 LE SV TOC-1237 this is a dlp-04.1.1 req to recover
> dlp-04.c dlp.4.1 LE SV TOC-1238 this is a dlp-04.1.7 req to halt
> dlp-04.c dlp.4.2 LE SV TOC-1239 this is a dlp-04.2.7 req to recover
> dlp-04.c dlp.4.2 LE SV TOC-1240 this is a dlp-04.2.57 req to transform
> dlp-04.c dlp.4.3 LE SV TOC-1241 this is a dlp-04.3.15 req to halt
> dlp-04.c dlp.4.3 LE SV TOC-1242 this is a dlp-04.3.29 req to translate
> dlp-04.c dlp.4.5 LE SV TOC-1243 this is a dlp-04.5.20 req to assign
> dlp-04.c dlp.4.5 LE SV TOC-1244 this is a dlp-04.5.28 req to translate
> dlp-04.c dlp.4.6 LE SV TOC-1245 this is a dlp-04.6.4 req to call admin
> dlp-04.c dlp.4.6 LE SV TOC-1246 this is a dlp-04.6.15 req to store
> dlp-04.c dlp.4.6 LE SV TOC-1247 this is a dlp-04.6.16 req to recover
> dlp-04.c dlp.4.6 LE SV TOC-1248 this is a dlp-04.6.18 req to reject
> dlp-04.c dlp.4.6 LE SV TOC-1249 this is a dlp-04.6.20 req to verify
> dlp-04.c dlp.4.6 LE SV TOC-1250 this is a dlp-04.6.48 req to inhibit
> dlp-04.c dlp.4.7 LE SV TOC-1251 this is a dlp-04.7.2 req to set Real Time Clock
> dlp-04.c dlp.4.7 LE SV TOC-1252 this is a dlp-04.7.43 req to check pSOS
> dlp-04.c dlp.4.7 LE SV TOC-1253 this is a dlp-04.7.62 req to process
> dlp-04.c dlp.4.9 LE SV TOC-1254 this is a dlp-04.9.4 req to process
> dlp-04.c dlp.4.10 LE SV TOC-1255 this is a dlp-04.10.42 req to enable
> dlp-04.c dlp.4.10 LE SV TOC-1256 this is a dlp-04.10.62 req to validate
> dlp-04.c dlp.4.11 LE SV TOC-1257 this is a dlp-04.11.8 req to halt
> dlp-04.c dlp.4.11 LE SV TOC-008 we really should log all error calls
> dlp-04.c dlp.4.11 LE SV TOC-1258 this is a dlp-04.11.18 req to check unix
> dlp-04.c dlp.4.11 LE SV TOC-1259 this is a dlp-04.11.30 req to reject

Total Red LOC 80 . . . Green LOC 60 . . . Green minus Red -20

Difference Report - DIFF 1

This is a standard gnu DIFF report. Additions to the second file appear in green while deletions from the second file or additions to the first file appear in red. This DIFF report will traverse the entire directory tree structure. You must duplicate the tree structure of the source by copying the source into the result prior to executing this script.

1 19 Old: source/ft-app/ft-app-B1.0/dlp/dlp-01.c
1 19 New: source/ft-app/ft-app-B1.1/dlp/dlp-01.c

10c10
filtered header
< ----------------------------------------------------------------------------
< */
< static void dlp.1.9(void)
< {
<
< if (A le B)
< {
< A = B + C;
< D = E + F;
< }
<
<
< if (A le B)
< {
< A = B + C;
< D = E + F;
< }
<
< A = B/C;
<
< /*
< dead_code = B - C;
< dead_code = D - E;
< dead_code = F - G;
< */
<

1514,1518d198
< /* LE SV TOC-1221 this is a dlp-01.9.5 req to transform*/
< A = B+C;
< A = B+C;
< A = B/C;
< A = B*C;

1526,1546c206
< 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 eq B)
< {
< A = B + C;
< D = E + F;
< }
<
---
> /* LE SV TOC-1204 this is a dlp-01.1.37 req to set Real Time Clock*/

1547a208,209
> A = 0x0002;
> A = B/C;

1550,1575d211
< A = B+C;
<
< if (A le 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;
< }
<
< /* LE SV TOC-1222 this is a dlp-01.9.26 req to store*/
< A = B+C;
< A = B+C;
< A = B+C;

1578,1581d213
< A = B*C;
< A = B+C;
< A = B*C;
< A = B/C;

1583c215
< if (A <= B)
---
> if (A le B)

1589,1590d220
< A = B+C;
< A = B+C;

1592c222
< if (A != B)
---
> if (A >= B)

1598d227
< A = B*C;

1600,1602d228
< A = B*C;
< A = B*C;
< /* LE SV TOC-1223 this is a dlp-01.9.43 req to fail*/

1604,1611d229
<
< if (A < B)
< {
< A = B + C;
< D = E + F;
< }
<
< A = B+C;

1614,1622c232
< if (A == B)
< {
< A = B + C;
< D = E + F;
< }
<
< A = B-C;
<
< if (A > B)
---
> if (A >= B)

1628c238
< // max LOC 49
---
> // max LOC 48

Red LOC 111 . . . Green LOC 10 . . . Green minus Red -101

2 20 Old: source/ft-app/ft-app-B1.0/dlp/dlp-01.h
2 20 New: source/ft-app/ft-app-B1.1/dlp/dlp-01.h

20,21c20,24
< #define A;
< double C;
---
> int A;
> #include B;
> #include A;
> float B;
> #define C;

23c26,28
< // max LOC 3
---
> #include A;
> int A;
> // max LOC 8

Red LOC 3 . . . Green LOC 8 . . . Green minus Red 5

3 21 Old: source/ft-app/ft-app-B1.0/dlp/dlp-02.c
3 21 New: source/ft-app/ft-app-B1.1/dlp/dlp-02.c

PROPRIETARY

19a20,22
filtered header
< ----------------------------------------------------------------------------
< */
< static void dlp.2.6(void)
< {
< A = B*C;
< A = B*C;
---
> A = B-C;
> A = B-C;

1266c1033
< if (A > B)
---
> if (A <= B)

1275,1281c1042,1047
< case:
< case:
< // stacked case statements but only if there is a new line in between
<
< case:
< case:
< case:
---
> case one:
> {
> run_this;
> break;
> }
> case two:

1288c1054
< halt;
---
> SwError;

1292,1293d1057
< A = B*C;
< /* LE SV TOC-1235 this is a dlp-02.6.5 req to check unix*/

1295c1059
< if (A ge B)
---
> if (A >= B)

1300a1065,1072
> send_buffer = (U16 *) malloc(size+1);
> A = B+C;
> A = B-C;
> A = B-C;
> A = B/C;
> A = B-C;
> /* LE SV TOC-1219 this is a dlp-02.6.43 req to check unix*/
> A = B+C;

1302c1074
< if (A >= B)
---
> if (A lt B)

1307a1080,1098
>
> switch (dlp stuff)
> {
> case one:
> {
> run_this;
> break;
> }
> case two:
> {
> run_this;
> break;
> }
> default:
> {
> SwError;
> }
> }
>

1309,1310d1099
< A = B*C;
< A = B*C;

1318c1107,1108
< A = B/C;
---
> A = B+C;
> A = B*C;

1320c1110
< if (A le B)
---
> if (A == B)

1326,1332d1115
< A = B-C;
< A = B/C;
< A = B*C;
< A = B+C;
< A = B*C;
< A = B+C;
< do forever;

1334c1117
< if (A lt B)
---
> if (A le B)

1340c1123,1124
< A = B-C;
---
> A = B*C;
> A = B*C;

1341a1126,1127
> A = B*C;
> A = B*C;

1345,1357c1131,1137
< case one:
< {
< switch (nested)
< {
< case:
< X = Y + Z;
< case:
< X = Y + Z;
< default:
< SwError;
< }
< }
< case two:
---
> case:
> case:
> // stacked case statements but only if there is a new line in between
>
> case:
> case:
> case:

1364c1144
< SwError;
---
> halt;

1369,1370d1148
< A = B/C;
< /* LE SV TOC-1236 this is a dlp-02.6.24 req to call admin*/

1372c1150
< if (A <= B)
---
> switch (dlp stuff)

1374,1375c1152,1165
< A = B + C;
< D = E + F;
---
> case one:
> {
> run_this;
> break;
> }
> case two:
> {
> run_this;
> break;
> }
> default:
> {
> SwError;
> }

1378,1381c1168
< A = B*C;
< A = B/C;
< A = B/C;
< A = B-C;
---
> A = 0x0002;

1383c1170
< if (A ne B)
---
> if (A gt B)

1389,1390d1175
< A = B*C;
< A = B-C;

1392,1403c1177
< A = B+C;
< /* LE SV TOC-1237 this is a dlp-02.6.34 req to update*/
< A = B+C;
< A = B*C;
<
< if (A != B)
< {
< A = B + C;
< D = E + F;
< }
<
< // max LOC 36
---
> // max LOC 60

Red LOC 72 . . . Green LOC 76 . . . Green minus Red 4

4 22 Old: source/ft-app/ft-app-B1.0/dlp/dlp-02.h
4 22 New: source/ft-app/ft-app-B1.1/dlp/dlp-02.h

20,24c20
< #include D;
< int A;
< #define B;
< #define D;
< #define D;
---
> float B;

26c22,23
< // max LOC 6
---
> #define A;
> // max LOC 3

Red LOC 6 . . . Green LOC 3 . . . Green minus Red -3

5 23 Old: source/ft-app/ft-app-B1.0/dlp/dlp-03.c
5 23 New: source/ft-app/ft-app-B1.1/dlp/dlp-03.c

10c10
filtered header NAME: dlp.3.7

1578,1589c1009
< static void dlp.3.10(void)
< {
<
< if (A le B)
< {
< A = B + C;
< D = E + F;
< }
<
< A = B/C;
<
< if (A le B)
---
> static void dlp.3.7(void)

1591,1594c1011
< A = B + C;
< D = E + F;
< }
<
---
> A = B+C;

1595a1013
> A = B-C;

1597,1604c1015,1016
< A = 0x0004;
<
< if (A ne B)
< {
< A = B + C;
< D = E + F;
< }
<
---
> A = B+C;
> A = B+C;

1623a1036
> A = B/C;

1624a1038
> /* dead_code = A * B; */

1626c1040
< if (A gt B)
---
> if (A ne B)

1632,1633c1046,1054
< A = B-C;
< A = B-C;
---
> A = B+C;
>
> if (A lt B)
> {
> A = B + C;
> D = E + F;
> }
>
> A = B+C;

1636c1057
< switch (dlp stuff)
---
> if (A <= B)

1638,1651c1059,1060
< case one:
< {
< run_this;
< // missing break
< }
< case two:
< {
< run_this;
< break;
< }
< default:
< {
< SwError;
< }
---
> A = B + C;
> D = E + F;

1655d1063
< A = B/C;

1657c1065
< if (A ge B)
---
> if (A <= B)

1662a1071,1075
> A = B/C;
> FreePtr = HmiStringPtr;
> A = B+C;
> A = B*C;
> A = B-C;

1664c1077
< if (A == B)
---
> if (A > B)

1670d1082
< A = B*C;

1674,1675d1085
< /* LE SV TOC-1257 this is a dlp-03.10.21 req to increment*/
< A = B/C;

1676a1087
> A = B+C;

1678c1089
< if (A eq B)
---
> if (A le B)

1684,1685d1094
< A = B-C;
< A = B*C;

1687c1096
< if (A != B)
---
> if (A <= B)

1693d1101
< A = B+C;

1695c1103
< if (A gt B)
---
> if (A > B)

1701,1704c1109,1115
< A = B/C;
< A = B-C;
< A = B/C;
< A = B-C;
---
>
> if (A <= B)
> {
> A = B + C;
> D = E + F;
> }
>

1705a1117,1124
> A = B+C;
> A = B*C;
>
> if (A <= B)
> {
> A = B + C;
> D = E + F;
> }

1706a1126
>

1725c1145,1148
< // max LOC 34
---
> A = B/C;
> A = B-C;
> A = B*C;
> // max LOC 39

Red LOC 64 . . . Green LOC 53 . . . Green minus Red -11

6 24 Old: source/ft-app/ft-app-B1.0/dlp/dlp-03.h
6 24 New: source/ft-app/ft-app-B1.1/dlp/dlp-03.h

19a20,24
> double C;
> double C;
> char D;
> #include C;
> double C;

20a26,27
> #define B;
> #define D;

22,25c29
< #define A;
< char D;
< char D;
< // max LOC 5
---
> // max LOC 9

Red LOC 4 . . . Green LOC 8 . . . Green minus Red 4

7 25 Old: source/ft-app/ft-app-B1.0/dlp/dlp-04.c
7 25 New: source/ft-app/ft-app-B1.1/dlp/dlp-04.c

PROPRIETARY

10c10
filtered header NAME: dlp.4.11

2213c1510
< static void dlp.4.14(void)
---
> static void dlp.4.11(void)

2215c1512
< /* LE SV TOC-1276 this is a dlp-04.14.1 req to update*/
---
> A = B+C;

2224c1521
< if (A <= B)
---
> if (A ne B)

2231,2267c1528
<
< 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;
---
> // (P) this is really improtant

2269,2277c1530,1531
< 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*/
< A = B/C;
< free(FreePtr);
---
> A = 0x0001;
> A = B-C;

2279c1533
< if (A ge B)
---
> if (A lt B)

2285,2307c1539,1540
< 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;
---
> /* LE SV TOC-1257 this is a dlp-04.11.8 req to halt*/
> A = B*C;

2309c1542,1543
< if (A ne B)
---
> if ($dlp stuff > $otherdlp stuff)
> /* LE SV TOC-008 we really should log all error calls */

2312d1545
< D = E + F;

2315,2316d1547
< A = B-C;
< A = B*C;

2319c1550
< if (A lt B)
---
> if (A > B)

2324a1556
> A = B/C;

2333c1565
< if (A > B)
---
> if (A le B)

2339c1571,1573
< /* LE SV TOC-1278 this is a dlp-04.14.28 req to fail*/
---
> A = B+C;
> A = B/C;
> A = B/C;

2340a1575
> /* LE SV TOC-1258 this is a dlp-04.11.18 req to check unix*/

2343c1578
< if (A eq B)
---
> if (A ne B)

2349c1584,1587
< A = B/C;
---
> A = B*C;
> A = B+C;
> A = B-C;
> A = B-C;

2351c1589
< if (A > B)
---
> if (A gt B)

2356a1595,1601
> 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*/
> A = B-C;

2358c1603
< if (A gt B)
---
> if (A ne B)

2365c1610
< if (A ge B)
---
> if (A eq B)

2371d1615
< A = B-C;

2375c1619,1620
< A = B*C;
---
> A = B-C;
> A = B+C;

2377c1622
< if (A == B)
---
> if (A le B)

2383,2404d1627
< A = B*C;
< A = B/C;
<
< switch (dlp stuff)
< {
< case one:
< {
< run_this;
< break;
< }
< case two:
< {
< run_this;
< break;
< }
< default:
< {
< SwError;
< }
< }
<
< A = B+C;

2406c1629
< if (A <= B)
---
> if (A != B)

2412,2413d1634
< A = B+C;
< A = B+C;

2415c1636
< if (A le B)
---
> if (A ne B)

2421,2426d1641
< A = B/C;
< A = B*C;
< A = B/C;
< A = B*C;
< A = B*C;
< A = B/C;

2428c1643
< if (A le B)
---
> if (A gt B)

2434,2436d1648
< A = 0x0009;
< A = B-C;
< A = B-C;

2442c1654
< run_this;
---
> run_this;

2450,2453c1662
< default:
< {
< SwError;
< }
---
> // missing default

2456,2459d1664
< /* dead_code = A * B; */
< A = B/C;
< A = B*C;
< A = B-C;

2460a1666
> A = B+C;

2462c1668
< if (A <= B)
---
> if (A > B)

2468,2471d1673
< A = B/C;
< A = B+C;
< A = B*C;
< A = B*C;

2473,2474d1674
< A = B/C;
< A = B/C;

2476c1676
< if (A ne B)
---
> if (A ge B)

2482c1682,1684
< // max LOC 71
---
> send_buffer = (U16 *) malloc(size+1);
> A = B+C;
> // max LOC 47

Red LOC 145 . . . Green LOC 52 . . . Green minus Red -93

8 26 Old: source/ft-app/ft-app-B1.0/dlp/dlp-04.h
8 26 New: source/ft-app/ft-app-B1.1/dlp/dlp-04.h

20,21d19
< int A;
< #include D;

23c21
< float B;
---
> #define A;

25,26d22
< #include D;
< double C;

28c24
< // max LOC 8
---
> // max LOC 4

Red LOC 6 . . . Green LOC 2 . . . Green minus Red -4

A B C Clock D E F FreePtr G HmiStringPtr LAZY LE LOC NAME P Real SV SwError TOC Time X Y Z a admin all between break but call calls case char check dead_code default define dlp do double endif eq error fail filtered float forever free ge gt halt header if ifdef improtant in include increment int is isr le line log lt malloc max missing ne nested new nice not one only otherdlp really reject req run_this send_buffer set should size stacked statements static store stuff switch there this to transform two unix update void we

Total Red LOC 411 . . . Green LOC 212 . . . Green minus Red -199

Difference Report - DIFF 0

1 19 Old: source/ft-app/ft-app-B1.0/dlp/dlp-01.c
1 19 New: source/ft-app/ft-app-B1.1/dlp/dlp-01.c

PROPRIETARY

10c10
< --| This file contains the 9 functions that do file dlp stuff.
---
> --| This file contains the 1 functions that do file dlp stuff.

20,22c20
< char D;
< float B;
< char D;
---
> #include C;

23a22,23
> #include C;
> float B;

25,27c25,27
< #include A;
< double C;
< #define D;
---
> #define C;
> char D;
> #include C;

45,152d44
< A = B*C;
< /* LE SV TOC-1201 this is a dlp-01.1.2 req to inhibit*/
< A = B-C;
<
< if (A == B)
< {
< A = B + C;
< D = E + F;
< }
<
< A = B*C;
< A = B*C;
< // (P) this is really improtant
< 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-1202 this is a dlp-01.1.15 req to check unix*/
< A = B/C;
<
< if (A gt B)
< {
< A = B + C;
< D = E + F;
< }
<
< A = B-C;
<
< if (A gt B)
< {
< A = B + C;
< D = E + F;
< }
<
<
< 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;
< 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;
< }
<
<
< if (A == B)
< {
< A = B + C;
< D = E + F;
< }
<
< /* LE SV TOC-1203 this is a dlp-01.1.27 req to increment*/
< A = B-C;
< A = B*C;
<
< if (A gt B)
< {
< A = B + C;
< D = E + F;
< }
<
<
< if (A eq B)
< {
< A = B + C;
< D = E + F;
< }
<
< A = B+C;
< /* LE SV TOC-1204 this is a dlp-01.1.32 req to compare*/

154,251d45
< A = B-C;
< A = B-C;
< A = B*C;
< A = B*C;
<
< if (A >= B)
< {
< A = B + C;
< D = E + F;
< }
<
< /* LE SV TOC-1205 this is a dlp-01.1.38 req to process*/
<
< 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;
< 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 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;
< }
<
<
< if (A lt 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 ne B)
< {
< A = B + C;
< D = E + F;
< }

253,255c47
< A = B-C;
<
< if (A ne B)
---
> if (A != B)

261,284d52
< A = B*C;
< A = B-C;
< // max LOC 60
<
< }
<
<
< /*
< -----------------------------------------------------------------------------
< --| NAME: dlp.1.2
< --|
< --| ABSTRACT:
< --| This function does dlp stuff.
< --|
< --| RETURNS:
< --| NONE.
< --|
< ----------------------------------------------------------------------------
< */
< static void dlp.1.2(void)
< {
< // TBD - what do I do now
< A = B-C;
< A = B/C;

286d53
< goto error;

288,297d54
< A = B-C;
< A = B*C;
< A = B-C;
< A = B+C;
<
< if (A gt B)
< {
< A = B + C;
< D = E + F;
< }

299d55
<

306,357d61
< send_buffer = (U16 *) malloc(size+1);
< A = B-C;
< A = B/C;
< /* LE SV TOC-1206 this is a dlp-01.2.13 req to record*/
< A = B-C;
< A = B/C;
< A = B-C;
< A = B-C;
< A = B-C;
< A = 0x0004;
< A = B/C;
< A = B-C;
< A = B+C;
< // max LOC 20
<
< }
<
<
< /*
< -----------------------------------------------------------------------------
< --| NAME: dlp.1.3
< --|
< --| ABSTRACT:
< --| This function does dlp stuff.
< --|
< --| RETURNS:
< --| NONE.
< --|
< ----------------------------------------------------------------------------
< */
< static void dlp.1.3(void)
< {
< 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 = (float)B + C;

365,483d68
< A = B+C;
<
< if (A le 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;
< }
<
< /* LE SV TOC-1207 this is a dlp-01.3.15 req to process*/
<
< 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;
< /* LE SV TOC-1208 this is a dlp-01.3.22 req to fail*/
< A = B-C;
<
< if (A <= B)
< {
< A = B + C;
< D = E + F;
< }
<
<
< if (A le B)
< {
< A = B + C;
< D = E + F;
< }
<
< /* LE SV TOC-1209 this is a dlp-01.3.25 req to disable*/
<
< 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 = 0x0006;
< 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 >= B)
< {
< A = B + C;
< D = E + F;
< }
<
< /* LE SV TOC-1210 this is a dlp-01.3.37 req to verify*/
< A = 0x0002;
<
< switch (dlp stuff)
< {
< case one:
< {
< run_this;
< break;
< }
< case two:
< {
< run_this;
< break;
< }
< // missing default
< }
<
< 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;

492,562d76
< A = B-C;
<
< if (A eq B)
< {
< A = B + C;
< D = E + F;
< }
<
< A = B-C;
< A = 0x0002;
< A = B-C;
< A = B+C;
< A = B-C;
< A = B*C;
< /* LE SV TOC-1211 this is a dlp-01.3.54 req to transform*/
< A = B*C;
< A = B/C;
< // max LOC 55
<
< }
<
<
< /*
< -----------------------------------------------------------------------------
< --| NAME: dlp.1.4
< --|
< --| ABSTRACT:
< --| This function does dlp stuff.
< --|
< --| RETURNS:
< --| NONE.
< --|
< ----------------------------------------------------------------------------
< */
< static void dlp.1.4(void)
< {
< 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 ge B)
< {
< A = B + C;
< D = E + F;
< }
<
<
< if (A ge B)
< {
< A = B + C;
< D = E + F;
< }
<
< A = (int)B + C;
< A = B-C;
< A = B+C;
< A = B-C;
< A = B*C;
< A = B+C;
< A = B*C;
< A = B*C;

571,578d84
< if (A le B)
< {
< A = B + C;
< D = E + F;
< }
<
< /* LE SV TOC-1212 this is a dlp-01.4.19 req to set Real Time Clock*/
<

581c87
< case one:
---
> case one:

583c89
< run_this;
---
> run_this;

593c99
< // missing error call
---
> SwError;

597,706c103
< A = B/C;
< 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;
< 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;
<
< if (A ge B)
< {
< A = B + C;
< D = E + F;
< }
<
< /* LE SV TOC-1213 this is a dlp-01.4.34 req to audit*/
< A = B-C;
< /* LE SV TOC-1214 this is a dlp-01.4.35 req to increment*/
< A = 0x0003;
<
< 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 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;
< 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;
---
> // TBD - what do I do now

708,738d104
< 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;
<
< if (A lt B)
< {
< A = B + C;
< D = E + F;
< }
<
< A = B/C;
<
< if (A lt B)
< {
< A = B + C;
< D = E + F;
< }
<

740,766d105
< A = B/C;
< // max LOC 74
<
< }
<
<
< /*
< -----------------------------------------------------------------------------
< --| NAME: dlp.1.5
< --|
< --| ABSTRACT:
< --| This function does dlp stuff.
< --|
< --| RETURNS:
< --| NONE.
< --|
< ----------------------------------------------------------------------------
< */
< static void dlp.1.5(void)
< {
<
< if (A eq B)
< {
< A = B + C;
< D = E + F;
< }
<

768,781c107
<
< if (A lt B)
< {
< A = B + C;
< D = E + F;
< }
<
<
< if (A != B)
< {
< A = B + C;
< D = E + F;
< }
<
---
> A = 0x0007;

783,811d108
< 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;
< /* LE SV TOC-1215 this is a dlp-01.5.12 req to process*/
<
< 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;
< }
<

813,835d109
<
< if (A != B)
< {
< A = B + C;
< D = E + F;
< }
<
<
< if (A ge B)
< {
< A = B + C;
< D = E + F;
< }
<
<
< if (A le B)
< {
< A = B + C;
< D = E + F;
< }
<
< A = B/C;
< free(FreePtr);

837,846d110
<
< if (A == B)
< {
< A = B + C;
< D = E + F;
< }
<
< A = B/C;
< A = B+C;
< A = B-C;

848,855d111
< A = B-C;
<
< if (A le B)
< {
< A = B + C;
< D = E + F;
< }
<

857,866d112
< A = B/C;
< A = 0x0006;
< A = B/C;
<
< if (A < B)
< {
< A = B + C;
< D = E + F;
< }
<

874,876d119
< A = B*C;
< A = B/C;
< A = B-C;

878,893d120
< A = B*C;
< /* LE SV TOC-1216 this is a dlp-01.5.39 req to fail*/
<
< if (A lt B)
< {
< A = B + C;
< D = E + F;
< }
<
<
< if (A ge B)
< {
< A = B + C;
< D = E + F;
< }
<

901,944c128
<
< if (A le 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;
< /* LE SV TOC-1217 this is a dlp-01.5.48 req to reject*/
<
< switch (dlp stuff)
< {
< case one:
< {
< run_this;
< break;
< }
< case two:
< {
< run_this;
< break;
< }
< default:
< {
< // missing error call
< }
< }
<
---
> // TBD - what do I do now

952,989d135
< A = B-C;
< A = B*C;
< A = B+C;
<
< if (A ge 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;
<
< /*
< dead_code = B - C;
< dead_code = D - E;
< dead_code = F - G;
< */
<
< A = B+C;
<
< if (A < B)
< {
< A = B + C;
< D = E + F;
< }
<

991,999c137
< if (A > B)
< {
< A = B + C;
< D = E + F;
< }
<
< A = B+C;
<
< if (A eq B)
---
> if (A == B)

1006,1033d143
< 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;
<

1040,1107d149
<
< if (A gt 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;
< // max LOC 72
<
< }
<
<
< /*
< -----------------------------------------------------------------------------
< --| NAME: dlp.1.6
< --|
< --| ABSTRACT:
< --| This function does dlp stuff.
< --|
< --| RETURNS:
< --| NONE.
< --|
< ----------------------------------------------------------------------------
< */
< static void dlp.1.6(void)
< {
< 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;
< }
<
< /* LE SV TOC-1218 this is a dlp-01.6.6 req to check unix*/
<
< if (A <= B)
< {
< A = B + C;
< D = E + F;
< }
<
<
< if (A >= B)
< {
< A = B + C;
< D = E + F;
< }
<

1110,1148d151
< 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;
< A = B+C;
< A = B/C;
< A = B/C;
< A = B+C;
<

1155,1205d157
<
< 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 >= B)
< {
< A = B + C;
< D = E + F;
< }
<
< A = B*C;
< A = B-C;
< A = B+C;
<
< if {
< X = Y + Z;
< }
< else {
< halt;
< }
<
< A = B+C;
<
< if (A <= B)
< {
< A = B + C;
< D = E + F;
< }
<
< A = B+C;
< A = B*C;
< A = B/C;

1209c161
< if (A >= B)
---
> if (A != B)

1215,1217c167
< A = B-C;
< A = B-C;
< A = B/C;
---
> /* LE SV TOC-1202 this is a dlp-01.1.30 req to disable*/

1219,1236d168
<
< 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;
< /* LE SV TOC-1219 this is a dlp-01.6.50 req to increment*/

1238,1277d169
<
< switch (dlp stuff)
< {
< case one:
< {
< run_this;
< break;
< }
< case two:
< {
< run_this;
< break;
< }
< default:
< {
< SwError;
< }
< }
<
<
< switch (dlp stuff)
< {
< case one:
< {
< run_this;
< // missing break
< }
< case two:
< {
< run_this;
< break;
< }
< default:
< {
< SwError;
< }
< }
<
< A = B+C;
< A = B+C;

1279,1304d170
< /* LE SV TOC-1220 this is a dlp-01.6.55 req to halt*/
< A = B+C;
< A = B-C;
< A = B-C;
< 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;
< }
<

1306c172
< A = B-C;
---
> /* LE SV TOC-1203 this is a dlp-01.1.34 req to store*/

1326,1506d191
< 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;
< }
< // missing default
< }
<
< A = B-C;
< // max LOC 67
<
< }
<
<
< /*
< -----------------------------------------------------------------------------
< --| NAME: dlp.1.7
< --|
< --| ABSTRACT:
< --| This function does dlp stuff.
< --|
< --| RETURNS:
< --| NONE.
< --|
< ----------------------------------------------------------------------------
< */
< static void dlp.1.7(void)
< {
<
< 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;
<
< 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;
<
< if (A eq B)
< {
< A = B + C;
< D = E + F;
< }
<
<
< if (A != B)
< {
< A = B + C;
< D = E + F;
< }
<
< // max LOC 17
<
< }
<
<
< /*
< -----------------------------------------------------------------------------
< --| NAME: dlp.1.8
< --|
< --| ABSTRACT:
< --| This function does dlp stuff.
< --|
< --| RETURNS:
< --| NONE.
< --|
< ----------------------------------------------------------------------------
< */
< static void dlp.1.8(void)
< {
< 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 <= B)
< {
< A = B + C;
< D = E + F;
< }
<
< // max LOC 6
<
< }
<
<
< /*
< -----------------------------------------------------------------------------
< --| NAME: dlp.1.9
< --|
< --| ABSTRACT:
< --| This function does dlp stuff.
< --|
< --| RETURNS:
< --| NONE.
< --|
< ----------------------------------------------------------------------------
< */
< static void dlp.1.9(void)
< {
<
< if (A le B)
< {
< A = B + C;
< D = E + F;
< }
<
<
< if (A le B)
< {
< A = B + C;
< D = E + F;
< }
<
< A = B/C;
<
< /*
< dead_code = B - C;
< dead_code = D - E;
< dead_code = F - G;
< */
<

1514,1518d198
< /* LE SV TOC-1221 this is a dlp-01.9.5 req to transform*/
< A = B+C;
< A = B+C;
< A = B/C;
< A = B*C;

1526,1546c206
< 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 eq B)
< {
< A = B + C;
< D = E + F;
< }
<
---
> /* LE SV TOC-1204 this is a dlp-01.1.37 req to set Real Time Clock*/

1547a208,209
> A = 0x0002;
> A = B/C;

1550,1575d211
< A = B+C;
<
< if (A le 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;
< }
<
< /* LE SV TOC-1222 this is a dlp-01.9.26 req to store*/
< A = B+C;
< A = B+C;
< A = B+C;

1578,1581d213
< A = B*C;
< A = B+C;
< A = B*C;
< A = B/C;

1583c215
< if (A <= B)
---
> if (A le B)

1589,1590d220
< A = B+C;
< A = B+C;

1592c222
< if (A != B)
---
> if (A >= B)

1598d227
< A = B*C;

1600,1602d228
< A = B*C;
< A = B*C;
< /* LE SV TOC-1223 this is a dlp-01.9.43 req to fail*/

1604,1611d229
<
< if (A < B)
< {
< A = B + C;
< D = E + F;
< }
<
< A = B+C;

1614,1622c232
< if (A == B)
< {
< A = B + C;
< D = E + F;
< }
<
< A = B-C;
<
< if (A > B)
---
> if (A >= B)

1628c238
< // max LOC 49
---
> // max LOC 48

Red LOC 1436 . . . Green LOC 46 . . . Green minus Red -1390

2 20 Old: source/ft-app/ft-app-B1.0/dlp/dlp-01.h
2 20 New: source/ft-app/ft-app-B1.1/dlp/dlp-01.h

20,21c20,24
< #define A;
< double C;
---
> int A;
> #include B;
> #include A;
> float B;
> #define C;

23c26,28
< // max LOC 3
---
> #include A;
> int A;
> // max LOC 8

Red LOC 3 . . . Green LOC 8 . . . Green minus Red 5

3 21 Old: source/ft-app/ft-app-B1.0/dlp/dlp-02.c
3 21 New: source/ft-app/ft-app-B1.1/dlp/dlp-02.c

PROPRIETARY

19a20,22
> #include A;
> #include D;
> #define C;

20a24,28
> #define C;
> #define B;
> int A;
> #include D;
> #include C;

38,47d45
<
< if (A >= B)
< {
< A = B + C;
< D = E + F;
< }
<
< A = B-C;
< A = B/C;
< A = B+C;

49,58d46
<
< if (A > B)
< {
< A = B + C;
< D = E + F;
< }
<
< /* LE SV TOC-1224 this is a dlp-02.1.7 req to assign*/
< A = B-C;
< A = B*C;

59a48
> A = B/C;

61c50
< if (A != B)
---
> if (A lt B)

67d55
< A = B-C;

70,82d57
< free(FreePtr);
< 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;

84c59
< A = B-C;
---
> /* LE SV TOC-1205 this is a dlp-02.1.8 req to disable*/

87c62
< if (A >= B)
---
> if (A < B)

93,112c68,71
< A = B-C;
<
< switch (dlp 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;

113a73
> FreePtr = HmiStringPtr;

114a75,76
> A = 0x0004;
> A = B+C;

116d77
< /* LE SV TOC-1225 this is a dlp-02.1.28 req to inhibit*/

117a79,80
> // TBS - I need to figure this out
> A = B/C;

119c82
< if (A < B)
---
> if (A gt B)

124a88
> A = B-C;

126c90
< if (A eq B)
---
> if (A < B)

132,139d95
<
< /*
< dead_block = C * D;
< dead_block = E * F;
< */
<
< A = B/C;
< A = 0x0007;

140a97
> A = B*C;

142c99
< if (A >= B)
---
> if (A <= B)

148,167c105,108
<
< switch (dlp stuff)
< {
< case one:
< {
< run_this;
< break;
< }
< case two:
< {
< run_this;
< break;
< }
< default:
< {
< SwError;
< }
< }
<
< // max LOC 34
---
> A = B/C;
> /* LE SV TOC-1206 this is a dlp-02.1.27 req to compare*/
> A = B-C;
> // max LOC 27

186,230d126
< A = B+C;
<
< if (A lt 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;
< }
< }
<
<
< if (A gt B)
< {
< A = B + C;
< D = E + F;
< }
<
< A = B/C;
< A = B+C;
< A = B-C;
< A = B/C;

250,251c146,147
< A = B*C;
< // TBS - I need to figure this out
---
> A = B-C;
> A = B+C;

253c149
< if (A ne B)
---
> if (A <= B)

259,260d154
< A = B*C;
< A = B/C;

262c156
< if (A < B)
---
> if (A eq B)

268d161
< A = B/C;

270c163
< A = B*C;
---
> A = B-C;

277a171,173
> A = B*C;
> A = B/C;
> /* LE SV TOC-1207 this is a dlp-02.2.11 req to transform*/

278a175
> /* LE SV TOC-1208 this is a dlp-02.2.12 req to set Real Time Clock*/

280c177
< if (A le B)
---
> if (A lt B)

285a183
> A = (long)B + C;

293,296d190
< A = B+C;
< // (P) this is really improtant
< A = B-C;
< A = B*C;

298d191
< A = B+C;

301c194
< if (A eq B)
---
> if (A gt B)

306a200,203
> A = B-C;
> A = B+C;
> A = 0x0004;
> A = B*C;

309c206
< if (A <= B)
---
> if (A ne B)

316c213
< if (A < B)
---
> if (A ge B)

321a219,226
> A = B+C;
> A = B-C;
> A = B-C;
> A = B+C;
> A = B+C;
> A = B*C;
> A = B*C;
> A = B-C;

329c234,236
< send_buffer = (U16 *) malloc(size+1);
---
> A = B+C;
> A = B*C;
> // max LOC 33

331,334d237
< if (A eq B)
< {
< A = B + C;
< D = E + F;

338c241,253
< switch (dlp stuff)
---
> /*
> -----------------------------------------------------------------------------
> --| NAME: dlp.2.3
> --|
> --| ABSTRACT:
> --| This function does dlp stuff.
> --|
> --| RETURNS:
> --| NONE.
> --|
> ----------------------------------------------------------------------------
> */
> static void dlp.2.3(void)

340,357d254
< 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;

358a256,257
> A = B*C;
> A = B*C;

378,390d276
< 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;

392,396c278,279
< if (A lt B)
< {
< A = B + C;
< D = E + F;
< }
---
> /* dead_block = C * D;
> dead_block = E * F; */

398,400c281
< /* LE SV TOC-1226 this is a dlp-02.2.43 req to set RTC*/
< send_buffer = (U16 *) malloc(size+1);
< A = B*C;
---
> A = B+C;

402c283
< if (A ge B)
---
> if (A >= B)

408,423d288
<
< switch (dlp stuff)
< {
< case one:
< {
< run_this;
< break;
< }
< case two:
< {
< run_this;
< break;
< }
< // missing default
< }
<

425d289
< A = B*C;

427c291
< if (A ge B)
---
> if (A le B)

433d296
< A = B-C;

435,451d297
<
< if (A >= B)
< {
< A = B + C;
< D = E + F;
< }
<
< A = B-C;
< A = 0x0003;
< A = B-C;
<
< if (A != B)
< {
< A = B + C;
< D = E + F;
< }
<

453,454c299,300
< A = B*C;
< A = B*C;
---
> /* LE SV TOC-1209 this is a dlp-02.3.11 req to check unix*/
> A = B-C;

456,474c302
<
< switch (dlp stuff)
< {
< case one:
< {
< run_this;
< break;
< }
< case two:
< {
< run_this;
< break;
< }
< default:
< {
< SwError;
< }
< }
<
---
> A = B/C;

476c304
< if (A ge B)
---
> if (A < B)

482d309
< A = 0x0002;

483a311
> /* LE SV TOC-1210 this is a dlp-02.3.16 req to convert*/

485c313
< if (A le B)
---
> if (A lt B)

491,492d318
< A = B-C;
< A = B-C;

500,516d325
< A = B/C;
< A = B-C;
<
< if (A le B)
< {
< A = B + C;
< D = E + F;
< }
<
< A = B/C;
< A = B*C;
< /* LE SV TOC-1227 this is a dlp-02.2.70 req to convert*/
<
< if (veg)
< // missing curly brace
< variable = orange;
<

518c327
< if (A > B)
---
> if (A gt B)

524,543c333,334
< A = B*C;
< // max LOC 71
<
< }
<
<
< /*
< -----------------------------------------------------------------------------
< --| NAME: dlp.2.3
< --|
< --| ABSTRACT:
< --| This function does dlp stuff.
< --|
< --| RETURNS:
< --| NONE.
< --|
< ----------------------------------------------------------------------------
< */
< static void dlp.2.3(void)
< {
---
> A = B-C;
> // TBS - I need to figure this out

545c336
< if (A eq B)
---
> if (A ge B)

551,555d341
< A = B/C;
< A = B+C;
< A = B-C;
< A = B-C;
< A = B-C;

562a349,351
> A = B-C;
> A = B*C;
> A = B/C;

565c354
< if (A <= B)
---
> if (A != B)

572d360
< A = B+C;

574c362
< if (A < B)
---
> if (A le B)

580d367
< A = B/C;

582c369
< if (A != B)
---
> if (A ge B)

589c376
< if (A == B)
---
> if (A ge B)

597c384
< if (A le B)
---
> switch (dlp stuff)

599,600c386,399
< A = B + C;
< D = E + F;
---
> case one:
> {
> run_this;
> break;
> }
> case two:
> {
> run_this;
> break;
> }
> default:
> {
> SwError;
> }

603d401
< A = B+C;

605c403
< if (A lt B)
---
> if (A ge B)

612c410,411
< A = B-C;
---
> A = B+C;
> A = B/C;

614a414,415
> A = B/C;
> A = B*C;

616c417
< if (A >= B)
---
> if (A == B)

622d422
< A = B/C;

623a424
> A = B+C;

625c426
< if (A > B)
---
> if (A == B)

632d432
< A = B-C;

634d433
< A = B*C;

637c436
< if (A le B)
---
> if (A != B)

642a442,443
> A = B/C;
> A = B/C;

644c445,465
< if (A gt B)
---
> 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 != B)

650c471,472
< A = B*C;
---
> A = B/C;
> /* LE SV TOC-1211 this is a dlp-02.3.53 req to convert*/

652a475,477
> A = B/C;
> A = B/C;
> A = B*C;

654c479
< if (A <= B)
---
> switch (dlp stuff)

656,657c481,501
< A = B + C;
< D = E + F;
---
> case one:
> {
> switch (nested)
> {
> case:
> X = Y + Z;
> case:
> X = Y + Z;
> default:
> SwError;
> }
> }
> case two:
> {
> run_this;
> break;
> }
> default:
> {
> SwError;
> }

659a504,507
> A = B+C;
> A = B-C;
> A = B+C;
> A = B-C;

668c516
< if (A == B)
---
> if (A < B)

674c522
< /* LE SV TOC-1228 this is a dlp-02.3.41 req to disable*/
---
> A = B/C;

676c524
< if (A ge B)
---
> switch (dlp stuff)

678,679c526,540
< A = B + C;
< D = E + F;
---
> case:
> case:
> // stacked case statements but only if there is a new line in between
>
> case:
> case:
> case:
> {
> run_this;
> break;
> }
> default:
> {
> halt;
> }

681a543,547
> A = B/C;
> A = B+C;
> A = B-C;
> A = B*C;
> A = B/C;

701,713c567,568
< 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;
> /* LE SV TOC-1212 this is a dlp-02.3.72 req to recover*/

715c570
< if (A >= B)
---
> if (A le B)

721d575
< A = B*C;

729,730c583,593
< A = B+C;
< // max LOC 59
---
>
> if (A >= B)
> {
> A = B + C;
> D = E + F;
> }
>
> A = B-C;
> A = B/C;
> A = B/C;
> // max LOC 77

749,750c612,613
< A = 0x0002;
< A = B/C;
---
> A = B*C;
> A = B-C;

752a616,617
> A = B*C;
> /* dead_code = A * B; */

754c619
< if (A eq B)
---
> if (A == B)

760c625,628
< A = B+C;
---
> A = B/C;
> A = B*C;
> A = B-C;
> A = B/C;

762c630
< if (A <= B)
---
> if (A >= B)

769,793c637
< switch (dlp stuff)
< {
< case one:
< {
< run_this;
< break;
< }
< case two:
< {
< run_this;
< break;
< }
< default:
< {
< SwError;
< }
< }
<
< A = B-C;
< A = B+C;
< A = 0x0007;
< A = B/C;
< A = B*C;
<
< if (A gt B)
---
> if (A != B)

799,800c643
< A = B-C;
< A = B+C;
---
> A = B*C;

802c645
< if (A != B)
---
> if (A lt B)

808d650
< A = B-C;

815a658
> A = B*C;

822a666,667
> A = B+C;
> A = B/C;

824c669
< if (A ne B)
---
> if (A == B)

829a675,678
> A = B/C;
> A = B-C;
> A = B/C;
> // max LOC 23

831,834d679
< if (A < B)
< {
< A = B + C;
< D = E + F;

836a682,697
>
> /*
> -----------------------------------------------------------------------------
> --| NAME: dlp.2.5
> --|
> --| ABSTRACT:
> --| This function does dlp stuff.
> --|
> --| RETURNS:
> --| NONE.
> --|
> ----------------------------------------------------------------------------
> */
> static void dlp.2.5(void)
> {
> /* LE SV TOC-1213 this is a dlp-02.5.1 req to verify*/

837a699
> /* LE SV TOC-1214 this is a dlp-02.5.2 req to process*/

840d701
< A = B-C;

842,845d702
< A = B/C;
< A = B*C;
< A = B-C;
< A = (int)B + C;

848a706
> A = B*C;

857c715
< if (A >= B)
---
> if (A > B)

865,871c723,724
<
< if (A eq B)
< {
< A = B + C;
< D = E + F;
< }
<
---
> A = B/C;
> A = B-C;

873,874d725
< A = B*C;
< A = 0x0004;

876c727
< if (A le B)
---
> if (A ge B)

882d732
< A = B+C;

884c734
< if (A <= B)
---
> if (A le B)

890,891d739
< /* LE SV TOC-1229 this is a dlp-02.4.42 req to verify*/
< A = B/C;

892a741
> /* LE SV TOC-1215 this is a dlp-02.5.19 req to verify*/

894c743
< if (A >= B)
---
> if (A lt B)

900,901c749
< A = B+C;
< A = B+C;
---
> A = B-C;

902a751
> A = B+C;

910,913d758
< A = B*C;
< A = B-C;
< A = B+C;
< A = B-C;

915,921d759
<
< if (A lt B)
< {
< A = B + C;
< D = E + F;
< }
<

923,935d760
< A = B*C;
< A = B*C;
< /* LE SV TOC-1230 this is a dlp-02.4.58 req to inhibit*/
< A = B/C;
< A = B*C;
<
< if (A ne B)
< {
< A = B + C;
< D = E + F;
< }
<
< A = B*C;

943,950d767
< A = B-C;
<
< if (A gt B)
< {
< A = B + C;
< D = E + F;
< }
<

952,954d768
< A = B-C;
< /* LE SV TOC-1231 this is a dlp-02.4.67 req to call admin*/
< A = B-C;

956c770
< if (A ge B)
---
> if (A == B)

962d775
< A = B*C;

964,983d776
< // max LOC 70
<
< }
<
<
< /*
< -----------------------------------------------------------------------------
< --| NAME: dlp.2.5
< --|
< --| ABSTRACT:
< --| This function does dlp stuff.
< --|
< --| RETURNS:
< --| NONE.
< --|
< ----------------------------------------------------------------------------
< */
< static void dlp.2.5(void)
< {
< A = B-C;

985c778
< if (A >= B)
---
> if (A <= B)

991d783
< A = B-C;

994c786
< if (A <= B)
---
> if (A > B)

1000d791
< A = B*C;

1002c793
< if (A ne B)
---
> if (A > B)

1007a799,800
> /* LE SV TOC-1216 this is a dlp-02.5.34 req to audit*/
> A = B-C;

1009c802
< if (A > B)
---
> if (A gt B)

1015,1016c808
< // ??? go see ws
< A = B-C;
---
> A = B+C;

1039c831
< switch (dlp stuff)
---
> if (A != B)

1041,1054c833,834
< case one:
< {
< run_this;
< break;
< }
< case two:
< {
< run_this;
< break;
< }
< default:
< {
< SwError;
< }
---
> A = B + C;
> D = E + F;

1057c837
< A = B+C;
---
> A = B*C;

1059c839
< if (A lt B)
---
> if (A < B)

1066c846
< if (A eq B)
---
> if (A le B)

1072,1074d851
< /* LE SV TOC-1232 this is a dlp-02.5.17 req to halt*/
< A = B/C;
< A = B/C;

1082,1083d858
< // TBS - I need to figure this out
< A = B*C;

1085c860
< if (A ne B)
---
> if (A > B)

1090a866,868
> A = B*C;
> A = 0x0003;
> A = B*C;

1097a876
> // TBD - what do I do now

1099c878
< if (A eq B)
---
> if (A != B)

1105c884
< A = B*C;
---
> A = B-C;

1106a886
> // max LOC 51

1108,1111d887
< if (A eq B)
< {
< A = B + C;
< D = E + F;

1114,1116d889
< A = B/C;
< A = B/C;
< A = B/C;

1118c891,903
< if (A eq B)
---
> /*
> -----------------------------------------------------------------------------
> --| NAME: dlp.2.6
> --|
> --| ABSTRACT:
> --| This function does dlp stuff.
> --|
> --| RETURNS:
> --| NONE.
> --|
> ----------------------------------------------------------------------------
> */
> static void dlp.2.6(void)

1120,1125d904
< A = B + C;
< D = E + F;
< }
<
< A = B-C;
< A = B+C;

1127c906
< if (A lt B)
---
> if (A > B)

1133d911
< A = B*C;

1135c913
< if (A ne B)
---
> if (A eq B)

1140a919,920
> A = B-C;
> A = B*C;

1141a922
> A = B/C;

1143c924
< if (A ne B)
---
> if (A le B)

1148a930
> A = B*C;

1150c932
< if (A ge B)
---
> if (A == B)

1158,1159d939
< A = B-C;
< A = B*C;

1161c941
< if (A ge B)
---
> switch (dlp stuff)

1163,1164c943,956
< A = B + C;
< D = E + F;
---
> case one:
> {
> run_this;
> break;
> }
> case two:
> {
> run_this;
> break;
> }
> default:
> {
> SwError;
> }

1166a959,960
> A = B*C;
> /* LE SV TOC-1217 this is a dlp-02.6.14 req to validate*/

1168d961
< /* LE SV TOC-1233 this is a dlp-02.5.45 req to update*/

1170c963
< if (A >= B)
---
> if (A != B)

1176a970
> A = B-C;

1178c972
< if (A lt B)
---
> if (A gt B)

1185c979
< if (A >= B)
---
> if (A == B)

1191,1193d984
< A = B-C;
< FreePtr = HmiStringPtr;
< A = B+C;

1195c986
< if (A eq B)
---
> if (A lt B)

1201,1203d991
< A = B-C;
< A = B-C;
< A = B+C;

1204a993,994
> A = B+C;
> /* LE SV TOC-1218 this is a dlp-02.6.23 req to recover*/

1206c996
< if (A eq B)
---
> if (A gt B)

1212,1214d1001
< A = B+C;
< A = B*C;
< /* LE SV TOC-1234 this is a dlp-02.5.59 req to convert*/

1216c1003
< if (A != B)
---
> if (A > B)

1223c1010
< if (A <= B)
---
> if (A == B)

1228a1016,1017
> A = B/C;
> A = 0x0002;

1235a1025
> A = B*C;

1238d1027
< A = B+C;

1240d1028
< A = B+C;

1242,1264c1030,1031
< A = B*C;
< A = B*C;
< // max LOC 69
<
< }
<
<
< /*
< -----------------------------------------------------------------------------
< --| NAME: dlp.2.6
< --|
< --| ABSTRACT:
< --| This function does dlp stuff.
< --|
< --| RETURNS:
< --| NONE.
< --|
< ----------------------------------------------------------------------------
< */
< static void dlp.2.6(void)
< {
< A = B*C;
< A = B*C;
---
> A = B-C;
> A = B-C;

1266c1033
< if (A > B)
---
> if (A <= B)

1275,1281c1042,1047
< case:
< case:
< // stacked case statements but only if there is a new line in between
<
< case:
< case:
< case:
---
> case one:
> {
> run_this;
> break;
> }
> case two:

1288c1054
< halt;
---
> SwError;

1292,1293d1057
< A = B*C;
< /* LE SV TOC-1235 this is a dlp-02.6.5 req to check unix*/

1295c1059
< if (A ge B)
---
> if (A >= B)

1300a1065,1072
> send_buffer = (U16 *) malloc(size+1);
> A = B+C;
> A = B-C;
> A = B-C;
> A = B/C;
> A = B-C;
> /* LE SV TOC-1219 this is a dlp-02.6.43 req to check unix*/
> A = B+C;

1302c1074
< if (A >= B)
---
> if (A lt B)

1307a1080,1098
>
> switch (dlp stuff)
> {
> case one:
> {
> run_this;
> break;
> }
> case two:
> {
> run_this;
> break;
> }
> default:
> {
> SwError;
> }
> }
>

1309,1310d1099
< A = B*C;
< A = B*C;

1318c1107,1108
< A = B/C;
---
> A = B+C;
> A = B*C;

1320c1110
< if (A le B)
---
> if (A == B)

1326,1332d1115
< A = B-C;
< A = B/C;
< A = B*C;
< A = B+C;
< A = B*C;
< A = B+C;
< do forever;

1334c1117
< if (A lt B)
---
> if (A le B)

1340c1123,1124
< A = B-C;
---
> A = B*C;
> A = B*C;

1341a1126,1127
> A = B*C;
> A = B*C;

1345,1357c1131,1137
< case one:
< {
< switch (nested)
< {
< case:
< X = Y + Z;
< case:
< X = Y + Z;
< default:
< SwError;
< }
< }
< case two:
---
> case:
> case:
> // stacked case statements but only if there is a new line in between
>
> case:
> case:
> case:

1364c1144
< SwError;
---
> halt;

1369,1370d1148
< A = B/C;
< /* LE SV TOC-1236 this is a dlp-02.6.24 req to call admin*/

1372c1150
< if (A <= B)
---
> switch (dlp stuff)

1374,1375c1152,1165
< A = B + C;
< D = E + F;
---
> case one:
> {
> run_this;
> break;
> }
> case two:
> {
> run_this;
> break;
> }
> default:
> {
> SwError;
> }

1378,1381c1168
< A = B*C;
< A = B/C;
< A = B/C;
< A = B-C;
---
> A = 0x0002;

1383c1170
< if (A ne B)
---
> if (A gt B)

1389,1390d1175
< A = B*C;
< A = B-C;

1392,1403c1177
< A = B+C;
< /* LE SV TOC-1237 this is a dlp-02.6.34 req to update*/
< A = B+C;
< A = B*C;
<
< if (A != B)
< {
< A = B + C;
< D = E + F;
< }
<
< // max LOC 36
---
> // max LOC 60

Red LOC 653 . . . Green LOC 432 . . . Green minus Red -221

4 22 Old: source/ft-app/ft-app-B1.0/dlp/dlp-02.h
4 22 New: source/ft-app/ft-app-B1.1/dlp/dlp-02.h

20,24c20
< #include D;
< int A;
< #define B;
< #define D;
< #define D;
---
> float B;

26c22,23
< // max LOC 6
---
> #define A;
> // max LOC 3

Red LOC 6 . . . Green LOC 3 . . . Green minus Red -3

5 23 Old: source/ft-app/ft-app-B1.0/dlp/dlp-03.c
5 23 New: source/ft-app/ft-app-B1.1/dlp/dlp-03.c

PROPRIETARY

10c10
< --| This file contains the 10 functions that do file dlp stuff.
---
> --| This file contains the 7 functions that do file dlp stuff.

19a20,21
> #define B;
> double C;

20a23,24
> #define C;
> #include B;

38,39d41
< A = B/C;
< /* LE SV TOC-1238 this is a dlp-03.1.2 req to process*/

41c43
< if (A <= B)
---
> if (A ge B)

46a49,53
> A = B-C;
> // TBD - what do I do now
> A = B-C;
> A = B-C;
> A = B+C;

47a55
> A = B+C;

50c58
< if (A ne B)
---
> if (A != B)

57c65
< if (A lt B)
---
> if (A <= B)

65c73
< if (A ne B)
---
> if (A gt B)

70a79,81
> A = B+C;
> A = B+C;
> A = B*C;

72c83
< if (A <= B)
---
> if (A > B)

77a89,91
> A = B*C;
> A = B+C;
> A = B-C;

79c93
< if (A eq B)
---
> if (A ge B)

85,86c99
< A = B*C;
< A = B/C;
---
> /* LE SV TOC-1220 this is a dlp-03.1.21 req to process*/

87a101
> A = B-C;

89c103,123
< if (A eq B)
---
> switch (dlp stuff)
> {
> case one:
> {
> run_this;
> break;
> }
> case two:
> {
> run_this;
> break;
> }
> default:
> {
> SwError;
> }
> }
>
> /* LE SV TOC-1221 this is a dlp-03.1.24 req to transform*/
>
> if (A >= B)

95c129,135
< A = B-C;
---
> A = B+C;
> A = (long)B + C;
> A = B+C;
> A = 0x0004;
> A = B/C;
> A = B/C;
> A = B+C;

97c137
< if (A ne B)
---
> if (A == B)

102a143
> A = B*C;

109a151,155
> /* LE SV TOC-1222 this is a dlp-03.1.33 req to compare*/
> A = B-C;
> A = B/C;
> A = B+C;
> A = (long)B + C;

111c157
< switch (dlp stuff)
---
> if (A gt B)

113,127c159,160
< 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;
> D = E + F;

131,140d163
< A = B+C;
< A = B*C;
< /* LE SV TOC-1239 this is a dlp-03.1.21 req to set Real Time Clock*/
< A = B/C;
< A = B*C;
< A = B/C;
< A = B+C;
< A = B+C;
< A = B-C;
< A = B/C;

142c165
< if (A le B)
---
> if (A <= B)

148,152c171
< A = B+C;
< A = B+C;
< A = B-C;
< A = B+C;
< // max LOC 32
---
> // max LOC 38

171d189
< A = B*C;

173,181c191
<
< if (A ne B)
< {
< A = B + C;
< D = E + F;
< }
<
< A = B-C;
< A = B-C;
---
> /* LE SV TOC-1223 this is a dlp-03.2.2 req to compare*/

183c193
< if (A ge B)
---
> if (A > B)

188a199
> A = B+C;

190,192d200
< A = B-C;
< A = B-C;
< A = B-C;

194c202
< A = B/C;
---
> A = B-C;

202c210,217
< /* dead_code = A * B; */
---
> A = B*C;
> A = B-C;
> A = 0x0004;
> A = B+C;
> A = B+C;
> A = B*C;
> A = B*C;
> // ??? go see ws

204c219
< if (A != B)
---
> if (A >= B)

209a225
> A = B+C;

211,218c227,232
<
< if (A ne B)
< {
< A = B + C;
< D = E + F;
< }
<
< A = B-C;
---
> A = 0x0004;
> A = B*C;
> send_buffer = (U16 *) malloc(size+1);
> A = B*C;
> /* LE SV TOC-1224 this is a dlp-03.2.19 req to update*/
> A = B+C;

226,233c240,242
< A = B*C;
<
< if (A eq B)
< {
< A = B + C;
< D = E + F;
< }
<
---
> A = B-C;
> A = B/C;
> A = B+C;

235c244
< if (A ne B)
---
> if (A <= B)

241,243d249
< A = (long)B + C;
< A = B/C;
< A = B-C;

245c251
< do forever;
---
> /* LE SV TOC-1225 this is a dlp-03.2.25 req to increment*/

253a260
> A = B+C;

255,257d261
< A = B*C;
< A = B*C;
< A = B-C;

266,271d269
< /* LE SV TOC-1240 this is a dlp-03.2.32 req to recover*/
< A = B*C;
< A = B-C;
< A = B+C;
< A = B*C;
< A = B+C;

279d276
< A = B*C;

281,283d277
< A = B*C;
< A = B/C;
< A = B/C;

285c279
< if (A ne B)
---
> if (A lt B)

291,293c285
< A = (long)B + C;
< A = B*C;
< A = B*C;
---
> A = B+C;

294a287,288
> A = B-C;
> A = B/C;

296,297c290
< if ($dlp stuff > $otherdlp stuff)
< /* LE SV TOC-008 we really should log all error calls */
---
> if (A < B)

299a293
> D = E + F;

302,303c296,297
< A = B/C;
< A = B/C;
---
> /* LE SV TOC-1226 this is a dlp-03.2.39 req to store*/
> A = B*C;

305d298
< A = 0x0003;

307c300,301
< FreePtr = HmiStringPtr;
---
> // TBD - what do I do now
> A = B-C;

314a309,310
> A = 0x0007;
> A = B/C;

316,321c312
<
< /*
< dead_code = B - C;
< dead_code = D - E;
< dead_code = F - G;
< */
---
> // max LOC 45

323,327d313
<
< if (A gt B)
< {
< A = B + C;
< D = E + F;

330d315
< A = B/C;

332c317,329
< if (A ge B)
---
> /*
> -----------------------------------------------------------------------------
> --| NAME: dlp.3.3
> --|
> --| ABSTRACT:
> --| This function does dlp stuff.
> --|
> --| RETURNS:
> --| NONE.
> --|
> ----------------------------------------------------------------------------
> */
> static void dlp.3.3(void)

334,338d330
< A = B + C;
< D = E + F;
< }
<
< A = B-C;

340d331
< A = B/C;

343c334
< if (A eq B)
---
> if (A != B)

349,355d339
< A = B-C;
< A = B+C;
< A = B-C;
< A = B+C;
< A = B-C;
< A = B+C;
< A = B+C;

358c342
< if (A <= B)
---
> if (A lt B)

364,384c348,351
<
< switch (dlp stuff)
< {
< case one:
< {
< run_this;
< break;
< }
< case two:
< {
< run_this;
< break;
< }
< default:
< {
< SwError;
< }
< }
<
< A = B/C;
< // max LOC 71
---
> A = B*C;
> A = B*C;
> A = B+C;
> // max LOC 8

391c358
< --| NAME: dlp.3.3
---
> --| NAME: dlp.3.4

401c368
< static void dlp.3.3(void)
---
> static void dlp.3.4(void)

403,410d369
< A = B/C;
< A = B/C;
< A = B/C;
< A = B+C;
< A = B+C;
< A = B-C;
< A = B*C;
< A = 0x0003;

412,416c371,372
< /*
< dead_code = B - C;
< dead_code = D - E;
< dead_code = F - G;
< */
---
> /* dead_block = C * D;
> dead_block = E * F; */

418a375
> A = B+C;

420c377
< A = B-C;
---
> // (P) this is really improtant

421a379
> /* LE SV TOC-1227 this is a dlp-03.4.5 req to set RTC*/

423,424c381
< A = B/C;
< A = B-C;
---
> A = B+C;

426c383
< switch (dlp stuff)
---
> if (A != B)

428,441c385,386
< case one:
< {
< run_this;
< break;
< }
< case two:
< {
< run_this;
< break;
< }
< default:
< {
< SwError;
< }
---
> A = B + C;
> D = E + F;

444d388
< A = B/C;

446c390
< if (A eq B)
---
> if (A lt B)

452,453d395
< A = B*C;
< A = B/C;

473,478d414
< A = 0x0007;
< A = B*C;
< A = B*C;
< A = B/C;
< A = B-C;
< A = B-C;

479a416
> A = B*C;

481,514d417
< /* LE SV TOC-1241 this is a dlp-03.3.28 req to increment*/
<
< if (A == B)
< {
< A = B + C;
< D = E + F;
< }
<
< A = B+C;
< A = B/C;
< 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;
< }
<
< A = B/C;
<
< if (A > B)
< {
< A = B + C;
< D = E + F;
< }
<

516,524d418
< A = B-C;
< A = B+C;
<
< if (A == B)
< {
< A = B + C;
< D = E + F;
< }
<

526,541d419
< A = B/C;
<
< if (A le B)
< {
< A = B + C;
< D = E + F;
< }
<
< /* LE SV TOC-1242 this is a dlp-03.3.44 req to record*/
<
< if (A < B)
< {
< A = B + C;
< D = E + F;
< }
<

543,544d420
< A = B+C;
< A = B/C;

548c424
< if (A > B)
---
> if (A gt B)

553a430,431
> A = B/C;
> A = B-C;

561,579c439
<
< switch (dlp stuff)
< {
< case one:
< {
< run_this;
< break;
< }
< case two:
< {
< run_this;
< break;
< }
< default:
< {
< SwError;
< }
< }
<
---
> /* LE SV TOC-1228 this is a dlp-03.4.22 req to fail*/

582,615c442,443
< // max LOC 54
<
< }
<
<
< /*
< -----------------------------------------------------------------------------
< --| NAME: dlp.3.4
< --|
< --| ABSTRACT:
< --| This function does dlp stuff.
< --|
< --| RETURNS:
< --| NONE.
< --|
< ----------------------------------------------------------------------------
< */
< static void dlp.3.4(void)
< {
< /* LE SV TOC-1243 this is a dlp-03.4.1 req to audit*/
< 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;
< // max LOC 7
---
> A = B-C;
> // max LOC 24

634,653d461
< 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;
< }
<
< /* LE SV TOC-1244 this is a dlp-03.5.6 req to audit*/
< A = (long)B + C;
< A = B*C;

655c463
< if (A eq B)
---
> if (A gt B)

661d468
< A = B*C;

670,680d476
< A = B*C;
< A = B+C;
<
< if (A > B)
< {
< A = B + C;
< D = E + F;
< }
<
< A = B+C;
< A = B*C;

688,718d483
< A = B-C;
<
< switch (dlp stuff)
< {
< case one:
< {
< run_this;
< // missing break
< }
< case two:
< {
< run_this;
< break;
< }
< default:
< {
< SwError;
< }
< }
<
< A = B/C;
<
< /*
< dead_block = C * D;
< dead_block = E * F;
< */
<
< A = B/C;
< A = B+C;
< A = B*C;
< /* LE SV TOC-1245 this is a dlp-03.5.22 req to call isr*/

723,769d487
< if (A le B)
< {
< A = B + C;
< D = E + F;
< }
<
<
< /* dead_code = B + C;
< dead_code = D + E;
< dead_code = F + G; */
<
<
< if (A <= B)
< {
< A = B + C;
< D = E + F;
< }
<
<
< if (A > B)
< {
< A = B + C;
< D = E + F;
< }
<
< /* LE SV TOC-1246 this is a dlp-03.5.28 req to set RTC*/
< A = B/C;
< A = B*C;
< A = B/C;
< A = B*C;
< /* LE SV TOC-1247 this is a dlp-03.5.32 req to set RTC*/
< A = B*C;
<
< if (A >= B)
< {
< A = B + C;
< D = E + F;
< }
<
<
< if (A >= B)
< {
< A = B + C;
< D = E + F;
< }
<
<

776,782d493
<
< if (A eq B)
< {
< A = B + C;
< D = E + F;
< }
<

784,790c495,497
<
< if (A le B)
< {
< A = B + C;
< D = E + F;
< }
<
---
> A = B-C;
> A = B/C;
> A = B-C;

792c499
< if (A gt B)
---
> if (A >= B)

797a505
> /* LE SV TOC-1229 this is a dlp-03.5.14 req to update*/

799c507
< if (A le B)
---
> if (A ge B)

805d512
< A = B+C;

813,814d519
< A = B+C;
< A = B+C;

816,822d520
< A = B-C;
<
< if (A >= B)
< {
< A = B + C;
< D = E + F;
< }

824,829c522,524
<
< if (A < B)
< {
< A = B + C;
< D = E + F;
< }
---
> /* dead_code = B + C;
> dead_code = D + E;
> dead_code = F + G; */

831c526
< A = B+C;
---
> A = B-C;

839,843d533
< A = B*C;
< A = B+C;
< A = B*C;
< A = B+C;
< /* LE SV TOC-1248 this is a dlp-03.5.55 req to enable*/

850c540
< break;
---
> // missing break

859c549
< SwError;
---
> SwError;

863,864d552
< A = B/C;
< A = B+C;

866c554
< A = B+C;
---
> A = B/C;

868c556
< if (A >= B)
---
> if (A ne B)

874,878c562
< A = B+C;
< A = B*C;
< A = B*C;
< A = B-C;
< A = B*C;
---
> /* LE SV TOC-1230 this is a dlp-03.5.22 req to verify*/

886,892c570,571
< /* LE SV TOC-1249 this is a dlp-03.5.67 req to audit*/
< A = B-C;
< /* LE SV TOC-1250 this is a dlp-03.5.68 req to verify*/
< A = B*C;
< A = B/C;
< A = B*C;
< A = B-C;
---
> /* LE SV TOC-1231 this is a dlp-03.5.23 req to detect error*/
> A = B+C;

894c573
< if (A > B)
---
> if (A ge B)

900,901d578
< A = B-C;
< A = B/C;

903c580
< if (A > B)
---
> if (A le B)

909,927c586
< // max LOC 75
<
< }
<
<
< /*
< -----------------------------------------------------------------------------
< --| NAME: dlp.3.6
< --|
< --| ABSTRACT:
< --| This function does dlp stuff.
< --|
< --| RETURNS:
< --| NONE.
< --|
< ----------------------------------------------------------------------------
< */
< static void dlp.3.6(void)
< {
---
> send_buffer = (U16 *) malloc(size+1);

929,938c588
< A = B+C;
<
< if (A gt B)
< {
< A = B + C;
< D = E + F;
< }
<
< A = B*C;
< /* LE SV TOC-1251 this is a dlp-03.6.5 req to store*/
---
> A = B/C;

948c598
< A = B-C;
---
> /* LE SV TOC-1232 this is a dlp-03.5.31 req to halt*/

956,974d605
<
< switch (dlp stuff)
< {
< case one:
< {
< run_this;
< break;
< }
< case two:
< {
< run_this;
< break;
< }
< default:
< {
< SwError;
< }
< }
<

976c607
< A = B+C;
---
> A = B*C;

978c609
< if (A ge B)
---
> if (A > B)

984,985c615
< A = B*C;
< send_buffer = (U16 *) malloc(size+1);
---
> A = B-C;

987d616
< A = B/C;

989c618
< if (A <= B)
---
> if (A > B)

995,998c624
< A = B-C;
< A = B+C;
< A = B+C;
< A = B+C;
---
> A = B/C;

1000c626
< if (A != B)
---
> if (A ne B)

1005a632,636
> A = B*C;
> A = B*C;
> A = B/C;
> FreePtr = HmiStringPtr;
> A = B+C;

1007c638
< if (A ne B)
---
> if (A gt B)

1013d643
< A = 0x0001;

1015c645
< if (A lt B)
---
> if (A <= B)

1021d650
< A = B/C;

1022a652
> A = B+C;

1024c654
< if (A ne B)
---
> if (A ge B)

1030d659
< A = 0x0006;

1033,1035d661
< // max LOC 29
<
< }

1036a663,665
> if (veg)
> // missing curly brace
> variable = orange;

1038,1051d666
< /*
< -----------------------------------------------------------------------------
< --| NAME: dlp.3.7
< --|
< --| ABSTRACT:
< --| This function does dlp stuff.
< --|
< --| RETURNS:
< --| NONE.
< --|
< ----------------------------------------------------------------------------
< */
< static void dlp.3.7(void)
< {

1053c668
< if (A <= B)
---
> if (A gt B)

1059,1060c674
< A = (int)B + C;
< A = B/C;
---
> A = B*C;

1062,1063d675
< A = B/C;
< A = B/C;

1066,1073d677
< A = B+C;
<
< if (A > B)
< {
< A = B + C;
< D = E + F;
< }
<

1075,1081c679
<
< if (A > B)
< {
< A = B + C;
< D = E + F;
< }
<
---
> A = B*C;

1083d680
< /* LE SV TOC-1252 this is a dlp-03.7.13 req to set Real Time Clock*/

1085c682
< if (A < B)
---
> if (A != B)

1098,1125d694
<
< 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;

1127,1128c696
< A = B/C;
< A = B-C;
---
> A = B+C;

1130c698
< if (A eq B)
---
> if (A le B)

1136d703
< A = B+C;

1138c705
< A = B+C;
---
> A = B*C;

1141c708
< if (A lt B)
---
> if (A ne B)

1148,1154d714
< A = B-C;
< A = B*C;
< A = B+C;
< A = B*C;
< rcv_buffer = (U16 *) alloc(size+1);
< A = B-C;
< A = B*C;

1156,1157d715
< A = B*C;
< A = B*C;

1159,1160c717,718
< if (A == B)
< {
---
> #ifdef LAZY
> // this is not nice

1162,1167d719
< D = E + F;
< }
<
<
< if (A != B)
< {

1169,1170c721
< D = E + F;
< }
---
> #endif

1172d722
< A = B/C;

1174c724
< if (A ge B)
---
> if (A < B)

1180,1203d729
< do forever;
< 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;

1205c731
< if (A > B)
---
> if (A ge B)

1211,1212d736
< A = B*C;
< A = B/C;

1220,1226d743
<
< if (A eq B)
< {
< A = B + C;
< D = E + F;
< }
<

1228,1234d744
<
< if (A <= B)
< {
< A = B + C;
< D = E + F;
< }
<

1236,1263c746,750
< 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;
< }
< }
<
< // max LOC 57
---
> A = B/C;
> A = B-C;
> /* LE SV TOC-1233 this is a dlp-03.5.77 req to halt*/
> A = B+C;
> // max LOC 77

1270c757
< --| NAME: dlp.3.8
---
> --| NAME: dlp.3.6

1280c767
< static void dlp.3.8(void)
---
> static void dlp.3.6(void)

1281a769
> A = B/C;

1283c771
< switch (dlp stuff)
---
> if (A != B)

1285,1298c773,774
< case one:
< {
< run_this;
< break;
< }
< case two:
< {
< run_this;
< break;
< }
< default:
< {
< SwError;
< }
---
> A = B + C;
> D = E + F;

1302,1328d777
< A = B-C;
< A = B+C;
< A = B+C;
< A = 0x0008;
< A = B*C;
< /* LE SV TOC-1253 this is a dlp-03.8.7 req to detect error*/
< A = B*C;
< A = B+C;
< // max LOC 8
<
< }
<
<
< /*
< -----------------------------------------------------------------------------
< --| NAME: dlp.3.9
< --|
< --| ABSTRACT:
< --| This function does dlp stuff.
< --|
< --| RETURNS:
< --| NONE.
< --|
< ----------------------------------------------------------------------------
< */
< static void dlp.3.9(void)
< {

1330c779
< if (A <= B)
---
> if (A ne B)

1336,1337d784
< A = B-C;
< A = B*C;

1346c793,795
< A = B/C;
---
> A = B+C;
> A = B+C;
> A = B-C;

1348c797
< if (A gt B)
---
> if (A le B)

1353a803,805
> A = B/C;
> A = B*C;
> A = B+C;

1355c807,814
< if (A < B)
---
> #ifdef LAZY
> // this is not nice
> A = B + C;
> A = B + C;
> #endif
>
>
> if (A ne B)

1360a820
> A = B/C;

1361a822,823
> A = B*C;
> A = B-C;

1382,1391c844
< A = B*C;
< /* LE SV TOC-1254 this is a dlp-03.9.13 req to compare*/
<
< if (A gt B)
< {
< A = B + C;
< D = E + F;
< }
<
< A = B*C;
---
> /* LE SV TOC-1234 this is a dlp-03.6.21 req to verify*/

1398a852
> A = B/C;

1400,1402c854
< A = B-C;
< /* LE SV TOC-1255 this is a dlp-03.9.18 req to store*/
< A = B-C;
---
> A = B/C;

1404c856
< if (A ne B)
---
> if (A le B)

1410d861
< A = B-C;

1415,1420c866
<
< /* dead_code = B + C;
< dead_code = D + E;
< dead_code = F + G; */
<
< A = B-C;
---
> /* LE SV TOC-1235 this is a dlp-03.6.30 req to validate*/

1422c868
< if (A le B)
---
> if (A ge B)

1428,1436d873
< A = B+C;
<
< /* dead_code = B + C;
< dead_code = D + E;
< dead_code = F + G; */
<
< A = B-C;
< A = B*C;
< A = B+C;

1438c875
< if (A le B)
---
> if (A != B)

1444,1445d880
< A = B/C;
< A = B/C;

1447c882
< if (A > B)
---
> if (A lt B)

1454c889
< if (A ge B)
---
> if (A == B)

1461,1463d895
< A = B*C;
< /* LE SV TOC-1256 this is a dlp-03.9.38 req to assign*/
< A = B+C;

1465c897
< if (A le B)
---
> if (A <= B)

1470a903,908
> A = B*C;
> A = B*C;
> A = B*C;
> A = B-C;
> A = B/C;
> A = B-C;

1472c910,917
< if (A <= B)
---
> #ifdef LAZY
> // this is not nice
> A = B + C;
> A = B + C;
> #endif
>
>
> if (A < B)

1478,1488d922
< 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;

1490c924
< if (A ge B)
---
> if (A gt B)

1496,1498c930
< A = B+C;
< A = B+C;
< A = B-C;
---
> A = 0x0006;

1500c932
< if (A != B)
---
> if (A gt B)

1506c938
< A = (long)B + C;
---
> /* LE SV TOC-1236 this is a dlp-03.6.45 req to compare*/

1510c942
< if (A < B)
---
> if (A == B)

1515a948
> A = B+C;

1517c950
< if (A >= B)
---
> if (A le B)

1523,1526c956
< A = B/C;
< do forever;
< A = B-C;
< A = B+C;
---
> A = B*C;

1528,1531c958,960
< /*
< dead_code = B - C;
< dead_code = D - E;
< dead_code = F - G;
---
> /*
> dead_block = C * D;
> dead_block = E * F;

1534a964,965
> A = B-C;
> A = B-C;

1537c968
< if (A <= B)
---
> if (A lt B)

1543d973
< A = B*C;

1545a976,982
> A = B*C;
> A = B+C;
> A = 0x0007;
> A = B*C;
> A = B-C;
> A = B*C;
> A = B-C;

1547c984
< if (A le B)
---
> if (A >= B)

1554,1558d990
<
< if (veg)
< // missing curly brace
< variable = orange;
<

1560,1561c992
< A = B*C;
< // max LOC 73
---
> // max LOC 66

1568c999
< --| NAME: dlp.3.10
---
> --| NAME: dlp.3.7

1578,1589c1009
< static void dlp.3.10(void)
< {
<
< if (A le B)
< {
< A = B + C;
< D = E + F;
< }
<
< A = B/C;
<
< if (A le B)
---
> static void dlp.3.7(void)

1591,1594c1011
< A = B + C;
< D = E + F;
< }
<
---
> A = B+C;

1595a1013
> A = B-C;

1597,1604c1015,1016
< A = 0x0004;
<
< if (A ne B)
< {
< A = B + C;
< D = E + F;
< }
<
---
> A = B+C;
> A = B+C;

1623a1036
> A = B/C;

1624a1038
> /* dead_code = A * B; */

1626c1040
< if (A gt B)
---
> if (A ne B)

1632,1633c1046,1054
< A = B-C;
< A = B-C;
---
> A = B+C;
>
> if (A lt B)
> {
> A = B + C;
> D = E + F;
> }
>
> A = B+C;

1636c1057
< switch (dlp stuff)
---
> if (A <= B)

1638,1651c1059,1060
< case one:
< {
< run_this;
< // missing break
< }
< case two:
< {
< run_this;
< break;
< }
< default:
< {
< SwError;
< }
---
> A = B + C;
> D = E + F;

1655d1063
< A = B/C;

1657c1065
< if (A ge B)
---
> if (A <= B)

1662a1071,1075
> A = B/C;
> FreePtr = HmiStringPtr;
> A = B+C;
> A = B*C;
> A = B-C;

1664c1077
< if (A == B)
---
> if (A > B)

1670d1082
< A = B*C;

1674,1675d1085
< /* LE SV TOC-1257 this is a dlp-03.10.21 req to increment*/
< A = B/C;

1676a1087
> A = B+C;

1678c1089
< if (A eq B)
---
> if (A le B)

1684,1685d1094
< A = B-C;
< A = B*C;

1687c1096
< if (A != B)
---
> if (A <= B)

1693d1101
< A = B+C;

1695c1103
< if (A gt B)
---
> if (A > B)

1701,1704c1109,1115
< A = B/C;
< A = B-C;
< A = B/C;
< A = B-C;
---
>
> if (A <= B)
> {
> A = B + C;
> D = E + F;
> }
>

1705a1117,1124
> A = B+C;
> A = B*C;
>
> if (A <= B)
> {
> A = B + C;
> D = E + F;
> }

1706a1126
>

1725c1145,1148
< // max LOC 34
---
> A = B/C;
> A = B-C;
> A = B*C;
> // max LOC 39

Red LOC 932 . . . Green LOC 351 . . . Green minus Red -581

6 24 Old: source/ft-app/ft-app-B1.0/dlp/dlp-03.h
6 24 New: source/ft-app/ft-app-B1.1/dlp/dlp-03.h

19a20,24
> double C;
> double C;
> char D;
> #include C;
> double C;

20a26,27
> #define B;
> #define D;

22,25c29
< #define A;
< char D;
< char D;
< // max LOC 5
---
> // max LOC 9

Red LOC 4 . . . Green LOC 8 . . . Green minus Red 4

7 25 Old: source/ft-app/ft-app-B1.0/dlp/dlp-04.c
7 25 New: source/ft-app/ft-app-B1.1/dlp/dlp-04.c

PROPRIETARY

10c10
< --| This file contains the 14 functions that do file dlp stuff.
---
> --| This file contains the 11 functions that do file dlp stuff.

20,23c20
< #include A;
< #include C;
< #define C;
< #define D;
---
> #include B;

41,50c38
< 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*/
< A = B/C;
< A = B*C;
< A = B*C;
< A = B-C;
< A = B/C;
---
> /* LE SV TOC-1237 this is a dlp-04.1.1 req to recover*/

52c40
< if (A ge B)
---
> if (A eq B)

58c46,47
< A = B*C;
---
> A = 0x0009;
> A = B+C;

60,62c49,50
< #ifdef LAZY
< // this is not nice
< A = B + C;
---
> if (A != B)
> {

64c52,53
< #endif
---
> D = E + F;
> }

65a55,58
> A = B*C;
> A = B-C;
> A = B-C;
> /* LE SV TOC-1238 this is a dlp-04.1.7 req to halt*/

66a60,62
> A = B+C;
> A = B-C;
> A = B+C;

68d63
< // max LOC 13

69a65,72
> if (A >= B)
> {
> A = B + C;
> D = E + F;
> }
>
> // max LOC 12
>

88c91
< if (A ne B)
---
> if (A > B)

94d96
< /* LE SV TOC-1259 this is a dlp-04.2.2 req to halt*/

96,101c98
<
< /*
< dead_block = C * D;
< dead_block = E * F;
< */
<
---
> A = B-C;

109,113c106
< A = B/C;
<
< /* dead_block = C * D;
< dead_block = E * F; */
<
---
> A = B-C;

115c108
< if (A <= B)
---
> if (A gt B)

120a114
> /* LE SV TOC-1239 this is a dlp-04.2.7 req to recover*/

121a116,117
> A = B-C;
> A = B-C;

123c119
< if (A le B)
---
> if (A < B)

128a125
> A = B/C;

130c127
< if (A eq B)
---
> if (A != B)

137c134,142
< // max LOC 9
---
> 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;

138a144,147
> if (A > B)
> {
> A = B + C;
> D = E + F;

141,156d149
<
< /*
< -----------------------------------------------------------------------------
< --| NAME: dlp.4.3
< --|
< --| ABSTRACT:
< --| This function does dlp stuff.
< --|
< --| RETURNS:
< --| NONE.
< --|
< ----------------------------------------------------------------------------
< */
< static void dlp.4.3(void)
< {
< A = B+C;

157a151,154
> A = B+C;
> A = B*C;
> A = B*C;
> A = B*C;

159c156
< if (A ge B)
---
> if (A <= B)

165,166d161
< A = B*C;
< A = B/C;

168c163
< if (A gt B)
---
> if (A lt B)

174d168
< A = B/C;

176c170
< if (A >= B)
---
> if (A eq B)

182,184d175
< A = B/C;
< /* LE SV TOC-1260 this is a dlp-04.3.10 req to validate*/
< A = B-C;

186d176
< A = 0x0006;

187a178
> A = B*C;

189c180
< if (A != B)
---
> if (A > B)

195,199d185
< A = B+C;
< A = B*C;
< A = B/C;
< /* LE SV TOC-1261 this is a dlp-04.3.17 req to assign*/
< A = B-C;

203,211d188
< 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;

215,217d191
< A = B*C;
< A = B*C;
< A = B-C;

219,234d192
< A = B+C;
<
< if (A <= B)
< {
< A = B + C;
< D = E + F;
< }
<
<
< if (A != B)
< {
< A = B + C;
< D = E + F;
< }
<
< A = B+C;

236,242d193
< goto error;
<
< if (A eq B)
< {
< A = B + C;
< D = E + F;
< }

244,245c195
<
< if (A <= B)
---
> if (A == B)

251c201
< FreePtr = HmiStringPtr;
---
> A = B-C;

259,262c209
< A = B+C;
< A = B*C;
< A = B-C;
< A = B-C;
---
> A = B/C;

264d210
< rcv_buffer = (U16 *) alloc(size+1);

267d212
< A = B-C;

269c214
< if (A < B)
---
> if (A > B)

275,276c220
< A = B/C;
< A = B/C;
---
> A = B*C;

278c222
< A = B/C;
---
> A = B*C;

289,291c233
< A = B*C;
< A = B/C;
< A = B+C;
---
> /* LE SV TOC-1240 this is a dlp-04.2.57 req to transform*/

293c235
< if (A <= B)
---
> if (A >= B)

299,301c241
< A = B-C;
< A = B-C;
< A = B*C;
---
> A = B+C;

303d242
< A = B*C;

306c245
< if (A > B)
---
> if (A ne B)

311a251,252
> A = B*C;
> /* dead_code = A * B; */

313c254
< if (A != B)
---
> if (A <= B)

320,328d260
< A = B/C;
<
< if (A == B)
< {
< A = B + C;
< D = E + F;
< }
<
< A = B*C;

330,350c262,263
<
< switch (dlp stuff)
< {
< case one:
< {
< run_this;
< break;
< }
< case two:
< {
< run_this;
< break;
< }
< default:
< {
< SwError;
< }
< }
<
< A = B*C;
< // max LOC 79
---
> A = B+C;
> // max LOC 66

357c270
< --| NAME: dlp.4.4
---
> --| NAME: dlp.4.3

367c280
< static void dlp.4.4(void)
---
> static void dlp.4.3(void)

368a282,290
> 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;

376,403c298,299
<
< 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;
> A = (int)B + C;

405c301
< if (A ne B)
---
> if (A ge B)

411,421d306
< 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;

423c308
< if (A ne B)
---
> if (A ge B)

429,430c314,315
< A = 0x0008;
< A = B*C;
---
> A = B+C;
> /* LE SV TOC-1241 this is a dlp-04.3.15 req to halt*/

431a317
> A = B+C;

433c319
< switch (dlp stuff)
---
> if (A <= B)

435,448c321,322
< case one:
< {
< run_this;
< break;
< }
< case two:
< {
< run_this;
< break;
< }
< default:
< {
< SwError;
< }
---
> A = B + C;
> D = E + F;

451,454d324
< A = B-C;
< A = B-C;
< A = B-C;
< A = B+C;

456c326
< if (A ge B)
---
> if (A gt B)

462d331
< A = B-C;

465c334
< if (A <= B)
---
> if (A != B)

471,472d339
< A = B*C;
< A = B*C;

475c342
< if (A gt B)
---
> if (A != B)

480a348
> A = B*C;

482c350
< switch (dlp stuff)
---
> if (A le B)

484,497c352,353
< case one:
< {
< run_this;
< break;
< }
< case two:
< {
< run_this;
< break;
< }
< default:
< {
< SwError;
< }
---
> A = B + C;
> D = E + F;

501c357
< switch (dlp stuff)
---
> if (A eq B)

503,516c359,360
< case one:
< {
< run_this;
< break;
< }
< case two:
< {
< run_this;
< break;
< }
< default:
< {
< SwError;
< }
---
> A = B + C;
> D = E + F;

518a363,368
> 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*/
> A = B*C;

520c370
< switch (dlp stuff)
---
> if (A > B)

522,535c372,373
< case one:
< {
< run_this;
< break;
< }
< case two:
< {
< run_this;
< break;
< }
< default:
< {
< // missing error call
< }
---
> A = B + C;
> D = E + F;

538a377
> A = B*C;

546c385
< --| NAME: dlp.4.5
---
> --| NAME: dlp.4.4

556c395
< static void dlp.4.5(void)
---
> static void dlp.4.4(void)

557a397,398
> A = B+C;
> A = B*C;

559c400
< if (A ne B)
---
> if (A >= B)

565a407
> A = 0x0007;

567c409
< if (A gt B)
---
> if (A == B)

573c415,419
< A = B-C;
---
> A = B+C;
> A = B+C;
> A = B/C;
> A = B/C;
> A = B+C;

574a421,427
>
> if (A != B)
> {
> A = B + C;
> D = E + F;
> }
>

576c429
< // max LOC 6
---
> // max LOC 13

583c436
< --| NAME: dlp.4.6
---
> --| NAME: dlp.4.5

593c446
< static void dlp.4.6(void)
---
> static void dlp.4.5(void)

594a448
> A = B/C;

597c451
< if (A eq B)
---
> if (A <= B)

603,608d456
< A = B-C;
< A = B*C;
< A = B/C;
< A = B+C;
< A = B*C;
< A = B*C;

611c459
< if (A ge B)
---
> if (A gt B)

616a465,468
> A = B*C;
> A = B/C;
> A = B*C;
> // TBS - I need to figure this out

619c471
< if (A <= B)
---
> if (A != B)

625,646d476
< A = B-C;
< A = B*C;
< A = B*C;
<
< switch (dlp stuff)
< {
< case one:
< {
< run_this;
< break;
< }
< case two:
< {
< run_this;
< break;
< }
< default:
< {
< SwError;
< }
< }
<

648c478
< if (A gt B)
---
> if (A lt B)

653a484,486
> A = B+C;
> A = 0x0001;
> A = B*C;

655c488
< if (A lt B)
---
> if (A == B)

661c494,497
< A = B-C;
---
> A = B+C;
> A = B/C;
> A = B*C;
> A = B/C;

663c499
< if (A ne B)
---
> if (A le B)

668a505,507
> /* LE SV TOC-1243 this is a dlp-04.5.20 req to assign*/
> A = B-C;
> A = B/C;

669a509
> A = B-C;

671c511
< if (A <= B)
---
> if (A >= B)

677,678d516
< A = B-C;
< A = B/C;

684,685c522,530
< run_this;
< break;
---
> switch (nested)
> {
> case:
> X = Y + Z;
> case:
> X = Y + Z;
> default:
> SwError;
> }

694c539
< SwError;
---
> SwError;

699d543
< A = B+C;

702c546
< if (A le B)
---
> if (A eq B)

708c552
< A = 0x0007;
---
> /* LE SV TOC-1244 this is a dlp-04.5.28 req to translate*/

711,728d554
< 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;
< }
<

730,744d555
<
< if (A eq B)
< {
< A = B + C;
< D = E + F;
< }
<
< /* LE SV TOC-1262 this is a dlp-04.6.40 req to convert*/
<
< if (A le B)
< {
< A = B + C;
< D = E + F;
< }
<

746,748c557,559
< A = B-C;
< A = B-C;
< A = B-C;
---
> A = B+C;
> A = B/C;
> A = B*C;

751c562
< if (A le B)
---
> switch (dlp stuff)

753,754c564,577
< A = B + C;
< D = E + F;
---
> case one:
> {
> run_this;
> break;
> }
> case two:
> {
> run_this;
> break;
> }
> default:
> {
> SwError;
> }

757d579
< A = B*C;

765d586
< A = B-C;

767c588
< if (A gt B)
---
> if (A < B)

773d593
< A = B-C;

775c595
< if (A < B)
---
> if (A <= B)

781c601
< // max LOC 52
---
> // max LOC 39

788c608
< --| NAME: dlp.4.7
---
> --| NAME: dlp.4.6

798,802c618
< static void dlp.4.7(void)
< {
< A = B+C;
<
< if (A < B)
---
> static void dlp.4.6(void)

804,808c620
< A = B + C;
< D = E + F;
< }
<
< A = B-C;
---
> A = B*C;

816,852d627
< /* LE SV TOC-1263 this is a dlp-04.7.5 req to store*/
< A = B-C;
< /* LE SV TOC-1264 this is a dlp-04.7.6 req to recover*/
< 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;

860,868c635
<
< if (A > B)
< {
< A = B + C;
< D = E + F;
< }
<
< /* LE SV TOC-1265 this is a dlp-04.7.17 req to disable*/
< A = B*C;
---
> /* LE SV TOC-1245 this is a dlp-04.6.4 req to call admin*/

871c638
< if (A ge B)
---
> if (A eq B)

876a644
> A = B-C;

878c646
< if (A ge B)
---
> if (A >= B)

891,897c659,660
< A = B*C;
< /* LE SV TOC-1266 this is a dlp-04.7.23 req to store*/
< A = B-C;
< A = B-C;
< A = B-C;
< A = B+C;
< A = 0x0003;
---
> A = B/C;
> A = 0x0007;

899d661
< A = B*C;

901c663
< if (A gt B)
---
> if (A != B)

907,910d668
< A = B+C;
< // TBS - I need to figure this out
< A = B*C;
< A = B+C;

912c670
< if (A > B)
---
> if (A ne B)

919,927d676
< A = B-C;
<
< if (A ge B)
< {
< A = B + C;
< D = E + F;
< }
<
< A = B/C;

929,940c678
< // 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;
---
> /* LE SV TOC-1246 this is a dlp-04.6.15 req to store*/

942c680
< A = B+C;
---
> /* LE SV TOC-1247 this is a dlp-04.6.16 req to recover*/

944c682
< if (A gt B)
---
> if (A > B)

951c689
< A = B/C;
---
> /* LE SV TOC-1248 this is a dlp-04.6.18 req to reject*/

954c692
< if (A == B)
---
> if (A ne B)

959a698
> /* LE SV TOC-1249 this is a dlp-04.6.20 req to verify*/

961d699
< A = B/C;

963c701
< if (A >= B)
---
> if (A le B)

970,979d707
< A = B+C;
< A = B/C;
<
< if (A == B)
< {
< A = B + C;
< D = E + F;
< }
<
< A = B/C;

981c709
< if (A < B)
---
> if (A gt B)

986a715
> A = B-C;

987a717
> do forever;

989,1002c719,720
< 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 = (float)B + C;

1004,1011d721
< A = B/C;
<
< if (A == B)
< {
< A = B + C;
< D = E + F;
< }
<

1013,1016c723
< A = B/C;
< A = B*C;
< A = B/C;
< // TBD - what do I do now
---
> free(FreePtr);

1018d724
< A = B/C;

1021,1040c727
< // 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;

1047,1055c734,735
< switch (nested)
< {
< case:
< X = Y + Z;
< case:
< X = Y + Z;
< default:
< SwError;
< }
---
> run_this;
> break;

1064c744
< SwError;
---
> SwError;

1068,1070d747
< A = B/C;
< A = B/C;
< A = B-C;

1072c749
< if (A == B)
---
> if (A ge B)

1078d754
< A = B+C;

1080c756
< switch (dlp stuff)
---
> if (A ge B)

1082,1096c758,759
< 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;
> D = E + F;

1098a762,763
> A = B+C;
> A = B*C;

1100c765
< if (A lt B)
---
> if (A > B)

1106c771
< A = B+C;
---
> A = B*C;

1108c773
< if (A <= B)
---
> if (A gt B)

1114,1123d778
< /* LE SV TOC-1267 this is a dlp-04.8.11 req to increment*/
< A = B+C;
< /* LE SV TOC-1268 this is a dlp-04.8.12 req to set Real Time Clock*/
< A = B/C;
< A = B/C;
< A = B-C;
< A = B*C;
< A = B-C;
< A = 0x0002;
< A = B/C;

1125c780
< if (A != B)
---
> if (A le B)

1130a786
> A = B*C;

1132,1133c788,790
< 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*/

1135c792
< if (A != B)
---
> if (A < B)

1147a805
> A = B+C;

1149c807
< if (A <= B)
---
> if (A le B)

1155,1164c813
< 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;
---
> A = B*C;

1166c815
< if (A lt B)
---
> if (A > B)

1172d820
< A = B/C;

1174c822
< if (A ne B)
---
> if (A gt B)

1179a828
> A = B+C;

1199,1234d847
< 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*/
< 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;

1236,1237c849
< A = B/C;
< // (P) this is really improtant
---
> A = 0x0004;

1240,1247c852
< A = B*C;
<
< if (A == B)
< {
< A = B + C;
< D = E + F;
< }
<
---
> // max LOC 59

1249,1252d853
< if (A <= B)
< {
< A = B + C;
< D = E + F;

1255,1257d855
< A = B-C;
< A = B*C;
< A = B*C;

1259c857,869
< if (A ge B)
---
> /*
> -----------------------------------------------------------------------------
> --| NAME: dlp.4.7
> --|
> --| ABSTRACT:
> --| This function does dlp stuff.
> --|
> --| RETURNS:
> --| NONE.
> --|
> ----------------------------------------------------------------------------
> */
> static void dlp.4.7(void)

1261,1271d870
< 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;

1273c872
< if (A le B)
---
> if (A ne B)

1278a878
> /* LE SV TOC-1251 this is a dlp-04.7.2 req to set Real Time Clock*/

1286,1297d885
<
< 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;

1298a887
> A = (float)B + C;

1299a889,894
>
> /*
> dead_block = C * D;
> dead_block = E * F;
> */
>

1301d895
< A = B+C;

1303c897
< if (A == B)
---
> if (A ge B)

1309,1317d902
< /* LE SV TOC-1270 this is a dlp-04.8.81 req to validate*/
<
< if {
< X = Y + Z;
< }
< else {
< halt;
< }
<

1338,1341d922
< A = B/C;
< A = B*C;
< A = B*C;
< A = B+C;

1343a925,926
> A = B-C;
> A = B/C;

1345c928,932
< if (A < B)
---
> /* dead_block = C * D;
> dead_block = E * F; */
>
>
> if (A ne B)

1351d937
< A = B-C;

1359a946,954
> 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;

1367,1374d961
<
< if {
< X = Y + Z;
< }
< else {
< halt;
< }
<

1376c963,965
< A = B+C;
---
> A = B*C;
> A = B*C;
> A = B-C;

1384,1385c973,974
< A = B-C;
< // max LOC 97
---
> do forever;
> A = B+C;

1386a976,977
> if {
> X = Y + Z;

1388,1420c979,980
<
<
< /*
< -----------------------------------------------------------------------------
< --| 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;
< }
---
> else {
> halt;

1423c983,984
< A = 0x0009;
---
> A = B/C;
> A = B+C;

1425c986
< if (A ne B)
---
> if (A > B)

1431d991
< A = B-C;

1433c993
< if (A == B)
---
> if (A < B)

1439,1440c999,1002
< /* LE SV TOC-1271 this is a dlp-04.9.5 req to detect error*/
< A = B-C;
---
> A = B+C;
> A = B/C;
> A = B+C;
> A = B/C;

1441a1004,1006
> A = B+C;
> A = B+C;
> /* LE SV TOC-1252 this is a dlp-04.7.43 req to check pSOS*/

1443c1008
< if (A ne B)
---
> if (A <= B)

1449,1451d1013
< A = B/C;
< A = B*C;
< A = B+C;

1455,1460c1017,1023
< case one:
< {
< run_this;
< break;
< }
< case two:
---
> case:
> case:
> // stacked case statements but only if there is a new line in between
>
> case:
> case:
> case:

1467c1030
< SwError;
---
> halt;

1471,1472c1034,1036
< A = B*C;
< A = B*C;
---
> A = B/C;
> A = B/C;
> A = B/C;

1474d1037
< A = B*C;

1476c1039
< if (A < B)
---
> if (A <= B)

1482,1483d1044
< A = B-C;
< A = B+C;

1485d1045
< A = B+C;

1488c1048
< if (A == B)
---
> if (A lt B)

1494,1496d1053
< A = B*C;
< A = B-C;
< A = B/C;

1498c1055
< if (A < B)
---
> if (A le B)

1503a1061
> A = B*C;

1505c1063
< switch (dlp stuff)
---
> if (A gt B)

1507,1520c1065,1066
< case one:
< {
< run_this;
< break;
< }
< case two:
< {
< run_this;
< break;
< }
< default:
< {
< SwError;
< }
---
> A = B + C;
> D = E + F;

1523,1527c1069
< A = B/C;
< /* LE SV TOC-1272 this is a dlp-04.9.29 req to convert*/
< A = B*C;
< A = B/C;
< A = B*C;
---
> A = B+C;

1529c1071
< if (A <= B)
---
> if (A >= B)

1535c1077
< A = B+C;
---
> A = B-C;

1537c1079,1080
< A = B/C;
---
> A = B*C;
> A = B*C;

1539c1082
< if (A >= B)
---
> if (A != B)

1545c1088,1090
< A = B*C;
---
> /* LE SV TOC-1253 this is a dlp-04.7.62 req to process*/
> A = B-C;
> A = B-C;

1565a1111,1115
> A = B*C;
> A = B-C;
> A = B+C;
> A = B-C;
> A = B-C;

1574,1593d1123
< A = B/C;
< // max LOC 42
<
< }
<
<
< /*
< -----------------------------------------------------------------------------
< --| NAME: dlp.4.10
< --|
< --| ABSTRACT:
< --| This function does dlp stuff.
< --|
< --| RETURNS:
< --| NONE.
< --|
< ----------------------------------------------------------------------------
< */
< static void dlp.4.10(void)
< {

1595c1125
< if (A >= B)
---
> if (A > B)

1602,1604c1132
< A = B/C;
< A = B*C;
< // max LOC 4
---
> // max LOC 74

1611c1139
< --| NAME: dlp.4.11
---
> --| NAME: dlp.4.8

1621,1624c1149
< static void dlp.4.11(void)
< {
<
< if (A >= B)
---
> static void dlp.4.8(void)

1626,1629c1151,1152
< A = B + C;
< D = E + F;
< }
<
---
> A = B+C;
> A = B/C;

1631c1154
< if (A >= B)
---
> if (A == B)

1637,1640c1160
< A = B/C;
< A = B+C;
< A = B*C;
< A = B*C;
---
> A = B-C;

1660,1661c1180
< A = B+C;
< A = B*C;
---
> A = B/C;

1663c1182
< if (A eq B)
---
> if (A gt B)

1669c1188
< A = B-C;
---
> A = B/C;

1671a1191,1192
> A = B-C;
> A = B/C;

1673c1194
< if (A le B)
---
> if (A ge B)

1679d1199
< A = B*C;

1682,1685d1201
< A = B-C;
< A = B-C;
< A = B-C;
< A = B+C;

1687,1688c1203
< A = B+C;
< A = B+C;
---
> A = B-C;

1690c1205
< if (A >= B)
---
> switch (dlp stuff)

1692,1693c1207,1221
< A = B + C;
< D = E + F;
---
> case:
> case:
> // stacked case statements but only if there is a new line in between
>
> case:
> case:
> case:
> {
> run_this;
> break;
> }
> default:
> {
> halt;
> }

1696c1224
< A = B/C;
---
> A = B*C;

1698c1226
< if (A < B)
---
> if (A > B)

1704,1705c1232,1233
< A = B+C;
< // max LOC 28
---
> A = B*C;
> // max LOC 20

1712c1240
< --| NAME: dlp.4.12
---
> --| NAME: dlp.4.9

1722,1739c1250
< 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)
---
> static void dlp.4.9(void)

1741,1745d1251
< A = B + C;
< D = E + F;
< }
<
< A = B+C;

1748,1808d1253
< 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*/
< A = (int)B + C;
< A = B+C;
<
< if (A <= B)
< {
< A = B + C;
< D = E + F;
< }
<
<

1815d1259
< // ??? go see ws

1816a1261,1262
> /* LE SV TOC-1254 this is a dlp-04.9.4 req to process*/
> rcv_buffer = (U16 *) alloc(size+1);

1818c1264
< if (A lt B)
---
> if (A ge B)

1824,1825d1269
< A = 0x0001;
< A = B+C;

1826a1271
> A = B/C;

1834d1278
< A = B*C;

1835a1280
> A = B*C;

1836a1282
> A = B*C;

1838c1284
< if (A ne B)
---
> if (A le B)

1843a1290
> A = B+C;

1844a1292
> // max LOC 14

1846,1849d1293
< if (A le B)
< {
< A = B + C;
< D = E + F;

1851a1296,1310
>
> /*
> -----------------------------------------------------------------------------
> --| NAME: dlp.4.10
> --|
> --| ABSTRACT:
> --| This function does dlp stuff.
> --|
> --| RETURNS:
> --| NONE.
> --|
> ----------------------------------------------------------------------------
> */
> static void dlp.4.10(void)
> {

1854c1313
< A = B+C;
---
> A = B-C;

1856,1857d1314
< A = B/C;
< /* LE SV TOC-1274 this is a dlp-04.12.30 req to set Real Time Clock*/

1865,1870c1322,1323
<
< /*
< dead_block = C * D;
< dead_block = E * F;
< */
<
---
> A = 0x0003;
> A = B*C;

1872c1325
< A = B/C;
---
> A = B*C;

1874,1875c1327
< A = B-C;
< A = B-C;
---
> A = B*C;

1895d1346
< A = B+C;

1898,1907c1349
< if (A le B)
< {
< A = B + C;
< D = E + F;
< }
<
< A = B-C;
< rcv_buffer = (U16 *) alloc(size+1);
<
< if (A gt B)
---
> if (A >= B)

1914d1355
< A = B*C;

1916,1948d1356
< // 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;
< }
<

1954,1976c1362
< 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)
---
> if (A lt B)

1981a1368,1370
> A = B*C;
> A = B-C;
> A = B/C;

1982a1372,1373
> A = B*C;
> A = B*C;

1983a1375,1376
> A = B*C;
> goto error;

1985c1378
< if (A ge B)
---
> if (A <= B)

1991,2028d1383
<
< 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;
< }
< }
<

2030,2037c1385,1386
< A = 0x0003;
<
< if (A > B)
< {
< A = B + C;
< D = E + F;
< }
<
---
> A = B/C;
> A = B/C;

2039c1388
< if (A != B)
---
> if (A lt B)

2044a1394,1397
> A = B-C;
> A = B-C;
> A = B-C;
> A = B-C;

2047c1400
< if (A == B)
---
> if (A ge B)

2054c1407
< if (A < B)
---
> if (A > B)

2061c1414
< if (A <= B)
---
> if (A ge B)

2067,2068c1420
< A = B-C;
< A = B+C;
---
> /* LE SV TOC-1255 this is a dlp-04.10.42 req to enable*/

2070c1422
< if (A <= B)
---
> if (A ge B)

2077d1428
< A = B/C;

2080c1431
< if (A == B)
---
> if (A <= B)

2087c1438
< if (A gt B)
---
> if (A ne B)

2092a1444
> A = B-C;

2094c1446
< if (A eq B)
---
> if (A < B)

2099a1452,1453
> A = B*C;
> A = B+C;

2107,2115d1460
<
< if (A gt B)
< {
< A = B + C;
< D = E + F;
< }
<
< A = B/C;
< A = B/C;

2118,2149d1462
< 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;

2151c1464
< if (A >= B)
---
> if (A eq B)

2156a1470
> A = B/C;

2158c1472
< if (A gt B)
---
> if (A le B)

2164,2165d1477
< A = B/C;
< A = B-C;

2167,2174c1479
< 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*/
< A = B/C;
< A = B*C;
< A = B*C;
---
> do forever;

2177d1481
< A = B-C;

2179c1483
< if (A lt B)
---
> if (A == B)

2185a1490
> /* LE SV TOC-1256 this is a dlp-04.10.62 req to validate*/

2187,2196c1492,1493
< A = B*C;
< A = B/C;
<
< if (A gt B)
< {
< A = B + C;
< D = E + F;
< }
<
< // max LOC 73
---
> A = B-C;
> // max LOC 63

2203c1500
< --| NAME: dlp.4.14
---
> --| NAME: dlp.4.11

2213c1510
< static void dlp.4.14(void)
---
> static void dlp.4.11(void)

2215c1512
< /* LE SV TOC-1276 this is a dlp-04.14.1 req to update*/
---
> A = B+C;

2224c1521
< if (A <= B)
---
> if (A ne B)

2231,2267c1528
<
< 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;
---
> // (P) this is really improtant

2269,2277c1530,1531
< 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*/
< A = B/C;
< free(FreePtr);
---
> A = 0x0001;
> A = B-C;

2279c1533
< if (A ge B)
---
> if (A lt B)

2285,2307c1539,1540
< 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;
---
> /* LE SV TOC-1257 this is a dlp-04.11.8 req to halt*/
> A = B*C;

2309c1542,1543
< if (A ne B)
---
> if ($dlp stuff > $otherdlp stuff)
> /* LE SV TOC-008 we really should log all error calls */

2312d1545
< D = E + F;

2315,2316d1547
< A = B-C;
< A = B*C;

2319c1550
< if (A lt B)
---
> if (A > B)

2324a1556
> A = B/C;

2333c1565
< if (A > B)
---
> if (A le B)

2339c1571,1573
< /* LE SV TOC-1278 this is a dlp-04.14.28 req to fail*/
---
> A = B+C;
> A = B/C;
> A = B/C;

2340a1575
> /* LE SV TOC-1258 this is a dlp-04.11.18 req to check unix*/

2343c1578
< if (A eq B)
---
> if (A ne B)

2349c1584,1587
< A = B/C;
---
> A = B*C;
> A = B+C;
> A = B-C;
> A = B-C;

2351c1589
< if (A > B)
---
> if (A gt B)

2356a1595,1601
> 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*/
> A = B-C;

2358c1603
< if (A gt B)
---
> if (A ne B)

2365c1610
< if (A ge B)
---
> if (A eq B)

2371d1615
< A = B-C;

2375c1619,1620
< A = B*C;
---
> A = B-C;
> A = B+C;

2377c1622
< if (A == B)
---
> if (A le B)

2383,2404d1627
< A = B*C;
< A = B/C;
<
< switch (dlp stuff)
< {
< case one:
< {
< run_this;
< break;
< }
< case two:
< {
< run_this;
< break;
< }
< default:
< {
< SwError;
< }
< }
<
< A = B+C;

2406c1629
< if (A <= B)
---
> if (A != B)

2412,2413d1634
< A = B+C;
< A = B+C;

2415c1636
< if (A le B)
---
> if (A ne B)

2421,2426d1641
< A = B/C;
< A = B*C;
< A = B/C;
< A = B*C;
< A = B*C;
< A = B/C;

2428c1643
< if (A le B)
---
> if (A gt B)

2434,2436d1648
< A = 0x0009;
< A = B-C;
< A = B-C;

2442c1654
< run_this;
---
> run_this;

2450,2453c1662
< default:
< {
< SwError;
< }
---
> // missing default

2456,2459d1664
< /* dead_code = A * B; */
< A = B/C;
< A = B*C;
< A = B-C;

2460a1666
> A = B+C;

2462c1668
< if (A <= B)
---
> if (A > B)

2468,2471d1673
< A = B/C;
< A = B+C;
< A = B*C;
< A = B*C;

2473,2474d1674
< A = B/C;
< A = B/C;

2476c1676
< if (A ne B)
---
> if (A ge B)

2482c1682,1684
< // max LOC 71
---
> send_buffer = (U16 *) malloc(size+1);
> A = B+C;
> // max LOC 47

Red LOC 1329 . . . Green LOC 523 . . . Green minus Red -806

8 26 Old: source/ft-app/ft-app-B1.0/dlp/dlp-04.h
8 26 New: source/ft-app/ft-app-B1.1/dlp/dlp-04.h

20,21d19
< int A;
< #include D;

23c21
< float B;
---
> #define A;

25,26d22
< #include D;
< double C;

28c24
< // max LOC 8
---
> // max LOC 4

Red LOC 6 . . . Green LOC 2 . . . Green minus Red -4

Total Red LOC 4369 . . . Green LOC 1373 . . . Green minus Red -2996

Files Added To and Deleted From Baseline

Changed Files out of 134	New Files	Deleted Files
1 dlp/dlp-01.c 2 dlp/dlp-01.h 3 dlp/dlp-02.c 4 dlp/dlp-02.h 5 dlp/dlp-03.c 6 dlp/dlp-03.h 7 dlp/dlp-04.c 8 dlp/dlp-04.h

PROPRIETARY

Details Report

1 New: source/ft-app/ft-app-B1.1/dlp/dlp-01.c

Possible Regression Test: toc-1202

8 --| ABSTRACT:
9 --| This file contains the 1 functions that do file dlp stuff.
10 --|
34 --| ABSTRACT:
35 --| This function does dlp stuff.
36 --|
166 /* LE SV TOC-1202 this is a dlp-01.1.30 req to disable*/
171 /* LE SV TOC-1203 this is a dlp-01.1.34 req to store*/
205 /* LE SV TOC-1204 this is a dlp-01.1.37 req to set Real Time Clock*/

2 New: source/ft-app/ft-app-B1.1/dlp/dlp-01.h

No Regression Test Detected

8 --| ABSTRACT:
9 --| This file contains dlp-01 declarations.
10 --|

20,21c20,24
< #define A;
< double C;
---
> int A;
> #include B;
> #include A;
> float B;
> #define C;

23c26,28
< // max LOC 3
---
> #include A;
> int A;
> // max LOC 8

3 New: source/ft-app/ft-app-B1.1/dlp/dlp-02.c

Possible Regression Test: audit
Possible Regression Test: halt
Possible Regression Test: toc-1205

8 --| ABSTRACT:
9 --| This file contains the 6 functions that do file dlp stuff.
10 --|
35 --| ABSTRACT:
36 --| This function does dlp stuff.
37 --|
58 /* LE SV TOC-1205 this is a dlp-02.1.8 req to disable*/
105 /* LE SV TOC-1206 this is a dlp-02.1.27 req to compare*/
116 --| ABSTRACT:
117 --| This function does dlp stuff.
118 --|
172 /* LE SV TOC-1207 this is a dlp-02.2.11 req to transform*/
174 /* LE SV TOC-1208 this is a dlp-02.2.12 req to set Real Time Clock*/
244 --| ABSTRACT:
245 --| This function does dlp stuff.
246 --|
298 /* LE SV TOC-1209 this is a dlp-02.3.11 req to check unix*/
310 /* LE SV TOC-1210 this is a dlp-02.3.16 req to convert*/
471 /* LE SV TOC-1211 this is a dlp-02.3.53 req to convert*/
567 /* LE SV TOC-1212 this is a dlp-02.3.72 req to recover*/
601 --| ABSTRACT:
602 --| This function does dlp stuff.
603 --|
686 --| ABSTRACT:
687 --| This function does dlp stuff.
688 --|
696 /* LE SV TOC-1213 this is a dlp-02.5.1 req to verify*/
698 /* LE SV TOC-1214 this is a dlp-02.5.2 req to process*/
740 /* LE SV TOC-1215 this is a dlp-02.5.19 req to verify*/
798 /* LE SV TOC-1216 this is a dlp-02.5.34 req to audit*/
894 --| ABSTRACT:
895 --| This function does dlp stuff.
896 --|
959 /* LE SV TOC-1217 this is a dlp-02.6.14 req to validate*/
993 /* LE SV TOC-1218 this is a dlp-02.6.23 req to recover*/
1070 /* LE SV TOC-1219 this is a dlp-02.6.43 req to check unix*/

4 New: source/ft-app/ft-app-B1.1/dlp/dlp-02.h

No Regression Test Detected

8 --| ABSTRACT:
9 --| This file contains dlp-02 declarations.
10 --|

20,24c20
< #include D;
< int A;
< #define B;
< #define D;
< #define D;
---
> float B;

26c22,23
< // max LOC 6
---
> #define A;
> // max LOC 3

5 New: source/ft-app/ft-app-B1.1/dlp/dlp-03.c

Possible Regression Test: halt
Possible Regression Test: toc-1220

8 --| ABSTRACT:
9 --| This file contains the 7 functions that do file dlp stuff.
10 --|
31 --| ABSTRACT:
32 --| This function does dlp stuff.
33 --|
98 /* LE SV TOC-1220 this is a dlp-03.1.21 req to process*/
120 /* LE SV TOC-1221 this is a dlp-03.1.24 req to transform*/
150 /* LE SV TOC-1222 this is a dlp-03.1.33 req to compare*/
179 --| ABSTRACT:
180 --| This function does dlp stuff.
181 --|
190 /* LE SV TOC-1223 this is a dlp-03.2.2 req to compare*/
230 /* LE SV TOC-1224 this is a dlp-03.2.19 req to update*/
250 /* LE SV TOC-1225 this is a dlp-03.2.25 req to increment*/
295 /* LE SV TOC-1226 this is a dlp-03.2.39 req to store*/
320 --| ABSTRACT:
321 --| This function does dlp stuff.
322 --|
359 --| ABSTRACT:
360 --| This function does dlp stuff.
361 --|
378 /* LE SV TOC-1227 this is a dlp-03.4.5 req to set RTC*/
438 /* LE SV TOC-1228 this is a dlp-03.4.22 req to fail*/
451 --| ABSTRACT:
452 --| This function does dlp stuff.
453 --|
504 /* LE SV TOC-1229 this is a dlp-03.5.14 req to update*/
561 /* LE SV TOC-1230 this is a dlp-03.5.22 req to verify*/
569 /* LE SV TOC-1231 this is a dlp-03.5.23 req to detect error*/
597 /* LE SV TOC-1232 this is a dlp-03.5.31 req to halt*/
747 /* LE SV TOC-1233 this is a dlp-03.5.77 req to halt*/
758 --| ABSTRACT:
759 --| This function does dlp stuff.
760 --|
843 /* LE SV TOC-1234 this is a dlp-03.6.21 req to verify*/
865 /* LE SV TOC-1235 this is a dlp-03.6.30 req to validate*/
937 /* LE SV TOC-1236 this is a dlp-03.6.45 req to compare*/
1000 --| ABSTRACT:
1001 --| This function does dlp stuff.
1002 --|

6 New: source/ft-app/ft-app-B1.1/dlp/dlp-03.h

No Regression Test Detected

8 --| ABSTRACT:
9 --| This file contains dlp-03 declarations.
10 --|

19a20,24
> double C;
> double C;
> char D;
> #include C;
> double C;

20a26,27
> #define B;
> #define D;

22,25c29
< #define A;
< char D;
< char D;
< // max LOC 5
---
> // max LOC 9

7 New: source/ft-app/ft-app-B1.1/dlp/dlp-04.c

Possible Regression Test: halt
Possible Regression Test: toc-1237

8 --| ABSTRACT:
9 --| This file contains the 11 functions that do file dlp stuff.
10 --|
27 --| ABSTRACT:
28 --| This function does dlp stuff.
29 --|
37 /* LE SV TOC-1237 this is a dlp-04.1.1 req to recover*/
57 /* LE SV TOC-1238 this is a dlp-04.1.7 req to halt*/
79 --| ABSTRACT:
80 --| This function does dlp stuff.
81 --|
113 /* LE SV TOC-1239 this is a dlp-04.2.7 req to recover*/
232 /* LE SV TOC-1240 this is a dlp-04.2.57 req to transform*/
271 --| ABSTRACT:
272 --| This function does dlp stuff.
273 --|
314 /* LE SV TOC-1241 this is a dlp-04.3.15 req to halt*/
366 /* LE SV TOC-1242 this is a dlp-04.3.29 req to translate*/
386 --| ABSTRACT:
387 --| This function does dlp stuff.
388 --|
437 --| ABSTRACT:
438 --| This function does dlp stuff.
439 --|
504 /* LE SV TOC-1243 this is a dlp-04.5.20 req to assign*/
551 /* LE SV TOC-1244 this is a dlp-04.5.28 req to translate*/
609 --| ABSTRACT:
610 --| This function does dlp stuff.
611 --|
634 /* LE SV TOC-1245 this is a dlp-04.6.4 req to call admin*/
677 /* LE SV TOC-1246 this is a dlp-04.6.15 req to store*/
679 /* LE SV TOC-1247 this is a dlp-04.6.16 req to recover*/
688 /* LE SV TOC-1248 this is a dlp-04.6.18 req to reject*/
697 /* LE SV TOC-1249 this is a dlp-04.6.20 req to verify*/
789 /* LE SV TOC-1250 this is a dlp-04.6.48 req to inhibit*/
860 --| ABSTRACT:
861 --| This function does dlp stuff.
862 --|
877 /* LE SV TOC-1251 this is a dlp-04.7.2 req to set Real Time Clock*/
1005 /* LE SV TOC-1252 this is a dlp-04.7.43 req to check pSOS*/
1087 /* LE SV TOC-1253 this is a dlp-04.7.62 req to process*/
1140 --| ABSTRACT:
1141 --| This function does dlp stuff.
1142 --|
1241 --| ABSTRACT:
1242 --| This function does dlp stuff.
1243 --|
1260 /* LE SV TOC-1254 this is a dlp-04.9.4 req to process*/
1300 --| ABSTRACT:
1301 --| This function does dlp stuff.
1302 --|
1419 /* LE SV TOC-1255 this is a dlp-04.10.42 req to enable*/
1489 /* LE SV TOC-1256 this is a dlp-04.10.62 req to validate*/
1501 --| ABSTRACT:
1502 --| This function does dlp stuff.
1503 --|
1538 /* LE SV TOC-1257 this is a dlp-04.11.8 req to halt*/
1542 /* LE SV TOC-008 we really should log all error calls */
1574 /* LE SV TOC-1258 this is a dlp-04.11.18 req to check unix*/
1599 /* LE SV TOC-1259 this is a dlp-04.11.30 req to reject*/

8 New: source/ft-app/ft-app-B1.1/dlp/dlp-04.h

No Regression Test Detected

8 --| ABSTRACT:
9 --| This file contains dlp-04 declarations.
10 --|

20,21d19
< int A;
< #include D;

23c21
< float B;
---
> #define A;

25,26d22
< #include D;
< double C;

28c24
< // max LOC 8
---
> // max LOC 4

Possible Regression Tests Keyword Analysis

Keywords and number of files containing each keyword.

Number Sort

halt

toc-1202

toc-1220

audit

toc-1205

toc-1237

Alpha Sort

audit

halt

toc-1202

toc-1205

toc-1220

toc-1237

Keywords Not Found

watchdog	download	down.load	self.test	selftest	power.on
power.off	mmi	hmi	version	delete	settings
reset	logon	log.on	logoff	log.off	radar
flight	plan	conflict	probe	beacon

Possible Regression Tests File Analysis

Possible Regression Tests:
The following keywords were used to determine if regression testing is required: watchdog download down.load self.test selftest power.on power.off mmi hmi version delete settings audit halt reset TOC-\d+ logon log.on logoff log.off radar flight plan conflict probe beacon

done

PROPRIETARY

11/25/2003 18:35:06 done

1	source/ft-app/ft-app-B1.1/dlp/dlp-01.c	toc-1202	1
2	source/ft-app/ft-app-B1.1/dlp/dlp-01.h	No Regression Test Detected	-
3	source/ft-app/ft-app-B1.1/dlp/dlp-02.c	audit	1
4	source/ft-app/ft-app-B1.1/dlp/dlp-02.c	halt	1
5	source/ft-app/ft-app-B1.1/dlp/dlp-02.c	toc-1205	1
6	source/ft-app/ft-app-B1.1/dlp/dlp-02.h	No Regression Test Detected	-
7	source/ft-app/ft-app-B1.1/dlp/dlp-03.c	halt	1
8	source/ft-app/ft-app-B1.1/dlp/dlp-03.c	toc-1220	1
9	source/ft-app/ft-app-B1.1/dlp/dlp-03.h	No Regression Test Detected	-
10	source/ft-app/ft-app-B1.1/dlp/dlp-04.c	halt	1
11	source/ft-app/ft-app-B1.1/dlp/dlp-04.c	toc-1237	1
12	source/ft-app/ft-app-B1.1/dlp/dlp-04.h	No Regression Test Detected	-