Logevents v111003 analysis/ft-app-B1.1 s_cpc-listing-c.html C:\project-iat\inst\perl.exe 5.006001

Description This report generates a single listing of multiple c files. Its original purpose was to facilitate printing the software, not a easy activity on a windows system with hundreds of files. Currently it has been augmented with HTML anchors and color coding to support the hyper links in other reports such as stats-problems.
AnalysisComment
DetailsThis analysis shows the details from the original source code that are extracted from the search requests and internal error, warning, and caution settings. It also includes software metrics on a module basis.

Other Analysis Reports . Original Source Code . Instrumented Source Code . Help

12/01/2003 16:31:49

Details Report

1 1 Source: source/ft-app/ft-app-B1.1/ca/ca-01.c
 1-0 . /*
 1-1 . ----------------------------------------------------------------------------
 1-2 . --| BEGIN PROLOGUE
 1-3 . --|
 1-4 . --| CLASSIFICATION: UNCLASSIFIED
 1-5 . --|
 1-6 . --| FILE NAME:      ca-01.c
 1-7 . --|
 1-8 . --| ABSTRACT:
 1-9 . --|   This file contains the 10 functions that do file ca stuff.
 1-10 . --|
 1-11 . --| HISTORY:
 1-12 . --|   CCCQ_NAME:
 1-13 . --|   CCCQ_VER: 
 1-14 . --|
 1-15 . --| END PROLOGUE
 1-16 . ----------------------------------------------------------------------------
 1-17 . */
 1-18 . 
 1-19 . #include D;
 1-20 . #include C;
 1-21 . #define B;
 1-22 . double C;
 1-23 . int A;
 1-24 . #define C;
 1-25 . #include B;
 1-26 . #define D;
 1-27 . float B;
 1-28 . 
 1-29 . 
 1-30 . 
 1-31 . /*
 1-32 . -----------------------------------------------------------------------------
 1-33 . --| NAME:   ca.1.1
 1-34 . --|
 1-35 . --| ABSTRACT:
 1-36 . --|   This function does ca stuff.
 1-37 . --|
 1-38 . --| RETURNS:
 1-39 . --|   NONE.
 1-40 . --|
 1-41 . ----------------------------------------------------------------------------
 1-42 . */
 1-43 . static void ca.1.1(void)
 1-44 . {
 1-45 . send_buffer = (U16 *) malloc(size+1);
 1-46 . A = B*C;
 1-47 . A = B*C;
 1-48 . A = B/C;
 1-49 . A = B+C;
 1-50 . 
 1-51 . if (A == B)
 1-52 . {
 1-53 .    A = B + C;
 1-54 .    D = E + F;
 1-55 . }
 1-56 . 
 1-57 . A = B+C;
 1-58 . A = B-C;
 1-59 . A = B/C;
 1-60 . 
 1-61 . if (A gt B)
 1-62 . {
 1-63 .    A = B + C;
 1-64 .    D = E + F;
 1-65 . }
 1-66 . 
 1-67 . A = B*C;
 1-68 . 
 1-69 . if (A >  B)
 1-70 . {
 1-71 .    A = B + C;
 1-72 .    D = E + F;
 1-73 . }
 1-74 . 
 1-75 . A = B-C;
 1-76 . A = B+C;
 1-77 . A = B*C;
 1-78 . A = B-C;
 1-79 . 
 1-80 . if (A < = B)
 1-81 . {
 1-82 .    A = B + C;
 1-83 .    D = E + F;
 1-84 . }
 1-85 . 
 1-86 . 
 1-87 . if (A != B)
 1-88 . {
 1-89 .    A = B + C;
 1-90 .    D = E + F;
 1-91 . }
 1-92 . 
 1-93 . 
 1-94 . if (A gt B)
 1-95 . {
 1-96 .    A = B + C;
 1-97 .    D = E + F;
 1-98 . }
 1-99 . 
 1-100 . A = B+C;
 1-101 . A = B+C;
 1-102 . 
 1-103 . switch (ca stuff)
 1-104 . {
 1-105 .    case one:
 1-106 .    {
 1-107 .       run_this; 
 1-108 .       break;
 1-109 .    }
 1-110 .    case two:
 1-111 .    {
 1-112 .       run_this;
 1-113 .       break;
 1-114 .    }
 1-115 .    default:
 1-116 .    {
 1-117 .        SwError;
 1-118 .    }
 1-119 . }
 1-120 . 
 1-121 . 
 1-122 . if (A ge B)
 1-123 . {
 1-124 .    A = B + C;
 1-125 .    D = E + F;
 1-126 . }
 1-127 . 
 1-128 . A = B*C;
 1-129 . 
 1-130 . if (A == B)
 1-131 . {
 1-132 .    A = B + C;
 1-133 .    D = E + F;
 1-134 . }
 1-135 . 
 1-136 . A = B/C;
 1-137 . A = B/C;
 1-138 . A = B+C;
 1-139 . A = B/C;
 1-140 . 
 1-141 . if (A lt B)
 1-142 . {
 1-143 .    A = B + C;
 1-144 .    D = E + F;
 1-145 . }
 1-146 . 
 1-147 . /* LE SV TOC-1001 this is a ca-01.1.30 req to translate*/
 1-148 . 
 1-149 . if (A gt B)
 1-150 . {
 1-151 .    A = B + C;
 1-152 .    D = E + F;
 1-153 . }
 1-154 . 
 1-155 . 
 1-156 . if (A le B)
 1-157 . {
 1-158 .    A = B + C;
 1-159 .    D = E + F;
 1-160 . }
 1-161 . 
 1-162 . A = B/C;
 1-163 . A = B/C;
 1-164 . A = B/C;
 1-165 . A = B+C;
 1-166 . A = B-C;
 1-167 . A = B*C;
 1-168 . A = B*C;
 1-169 . A = 0x0008;
 1-170 . 
 1-171 . if (A == B)
 1-172 . {
 1-173 .    A = B + C;
 1-174 .    D = E + F;
 1-175 . }
 1-176 . 
 1-177 . A = B/C;
 1-178 . A = B*C;
 1-179 . 
 1-180 . if (A <  B)
 1-181 . {
 1-182 .    A = B + C;
 1-183 .    D = E + F;
 1-184 . }
 1-185 . 
 1-186 . A = B/C;
 1-187 . A = B-C;
 1-188 . A = B+C;
 1-189 . A = B-C;
 1-190 . A = B/C;
 1-191 . A = B/C;
 1-192 . A = 0x0002;
 1-193 . 
 1-194 . if (A != B)
 1-195 . {
 1-196 .    A = B + C;
 1-197 .    D = E + F;
 1-198 . }
 1-199 . 
 1-200 . A = B-C;
 1-201 . A = B*C;
 1-202 . A = B+C;
 1-203 . A = 0x0004;
 1-204 . 
 1-205 . switch (ca stuff)
 1-206 . {
 1-207 .    case one:
 1-208 .    {
 1-209 .       run_this; 
 1-210 .       break;
 1-211 .    }
 1-212 .    case two:
 1-213 .    {
 1-214 .       run_this;
 1-215 .       break;
 1-216 .    }
 1-217 .    default:
 1-218 .    {
 1-219 .        SwError;
 1-220 .    }
 1-221 . }
 1-222 . 
 1-223 . 
 1-224 . if (A != B)
 1-225 . {
 1-226 .    A = B + C;
 1-227 .    D = E + F;
 1-228 . }
 1-229 . 
 1-230 . 
 1-231 . if (A < = B)
 1-232 . {
 1-233 .    A = B + C;
 1-234 .    D = E + F;
 1-235 . }
 1-236 . 
 1-237 . 
 1-238 . if (A ne B)
 1-239 . {
 1-240 .    A = B + C;
 1-241 .    D = E + F;
 1-242 . }
 1-243 . 
 1-244 . A = B/C;
 1-245 . A = B*C;
 1-246 . 
 1-247 . if (A < = B)
 1-248 . {
 1-249 .    A = B + C;
 1-250 .    D = E + F;
 1-251 . }
 1-252 . 
 1-253 . A = B*C;
 1-254 . 
 1-255 . if (A lt B)
 1-256 . {
 1-257 .    A = B + C;
 1-258 .    D = E + F;
 1-259 . }
 1-260 . 
 1-261 . 
 1-262 . if (A gt B)
 1-263 . {
 1-264 .    A = B + C;
 1-265 .    D = E + F;
 1-266 . }
 1-267 . 
 1-268 . A = B*C;
 1-269 . A = B*C;
 1-270 . 
 1-271 . if (A <  B)
 1-272 . {
 1-273 .    A = B + C;
 1-274 .    D = E + F;
 1-275 . }
 1-276 . 
 1-277 . 
 1-278 . if (A == B)
 1-279 . {
 1-280 .    A = B + C;
 1-281 .    D = E + F;
 1-282 . }
 1-283 . 
 1-284 . A = B-C;
 1-285 . A = B+C;
 1-286 . A = B*C;
 1-287 . 
 1-288 . if (A le B)
 1-289 . {
 1-290 .    A = B + C;
 1-291 .    D = E + F;
 1-292 . }
 1-293 . 
 1-294 . /* LE SV TOC-1002 this is a ca-01.1.71 req to call admin*/
 1-295 . 
 1-296 . if (A lt B)
 1-297 . {
 1-298 .    A = B + C;
 1-299 .    D = E + F;
 1-300 . }
 1-301 . 
 1-302 . A = B/C;
 1-303 . 
 1-304 . if (A > = B)
 1-305 . {
 1-306 .    A = B + C;
 1-307 .    D = E + F;
 1-308 . }
 1-309 . 
 1-310 . A = B/C;
 1-311 . 
 1-312 . if (A le B)
 1-313 . {
 1-314 .    A = B + C;
 1-315 .    D = E + F;
 1-316 . }
 1-317 . 
 1-318 . A = B+C;
 1-319 . A = B*C;
 1-320 . 
 1-321 . if (A < = B)
 1-322 . {
 1-323 .    A = B + C;
 1-324 .    D = E + F;
 1-325 . }
 1-326 . 
 1-327 . // max LOC 78
 1-328 . 
 1-329 . }
 1-330 . 
 1-331 . 
 1-332 . /*
 1-333 . -----------------------------------------------------------------------------
 1-334 . --| NAME:   ca.1.2
 1-335 . --|
 1-336 . --| ABSTRACT:
 1-337 . --|   This function does ca stuff.
 1-338 . --|
 1-339 . --| RETURNS:
 1-340 . --|   NONE.
 1-341 . --|
 1-342 . ----------------------------------------------------------------------------
 1-343 . */
 1-344 . static void ca.1.2(void)
 1-345 . {
 1-346 . 
 1-347 . if (A != B)
 1-348 . {
 1-349 .    A = B + C;
 1-350 .    D = E + F;
 1-351 . }
 1-352 . 
 1-353 . 
 1-354 . switch (ca stuff)
 1-355 . {
 1-356 .    case one:
 1-357 .    {
 1-358 .       run_this; 
 1-359 .       break;
 1-360 .    }
 1-361 .    case two:
 1-362 .    {
 1-363 .       run_this;
 1-364 .       break;
 1-365 .    }
 1-366 .    default:
 1-367 .    {
 1-368 .        SwError;
 1-369 .    }
 1-370 . }
 1-371 . 
 1-372 . /* LE SV TOC-1003 this is a ca-01.2.3 req to update*/
 1-373 . A = B*C;
 1-374 . A = B*C;
 1-375 . 
 1-376 . if (A == B)
 1-377 . {
 1-378 .    A = B + C;
 1-379 .    D = E + F;
 1-380 . }
 1-381 . 
 1-382 . A = B/C;
 1-383 . A = B+C;
 1-384 . A = B-C;
 1-385 . A = B-C;
 1-386 . A = B*C;
 1-387 . A = B*C;
 1-388 . /* LE SV TOC-1004 this is a ca-01.2.12 req to audit*/
 1-389 . A = B+C;
 1-390 . A = B+C;
 1-391 . 
 1-392 . if (A lt B)
 1-393 . {
 1-394 .    A = B + C;
 1-395 .    D = E + F;
 1-396 . }
 1-397 . 
 1-398 . 
 1-399 . if (A != B)
 1-400 . {
 1-401 .    A = B + C;
 1-402 .    D = E + F;
 1-403 . }
 1-404 . 
 1-405 . A = B+C;
 1-406 . 
 1-407 . if (A le B)
 1-408 . {
 1-409 .    A = B + C;
 1-410 .    D = E + F;
 1-411 . }
 1-412 . 
 1-413 . A = B-C;
 1-414 . 
 1-415 . if (A le B)
 1-416 . {
 1-417 .    A = B + C;
 1-418 .    D = E + F;
 1-419 . }
 1-420 . 
 1-421 . A = B/C;
 1-422 . A = B/C;
 1-423 . 
 1-424 . if (A gt B)
 1-425 . {
 1-426 .    A = B + C;
 1-427 .    D = E + F;
 1-428 . }
 1-429 . 
 1-430 . 
 1-431 . if (A ne B)
 1-432 . {
 1-433 .    A = B + C;
 1-434 .    D = E + F;
 1-435 . }
 1-436 . 
 1-437 . 
 1-438 . if (A ge B)
 1-439 . {
 1-440 .    A = B + C;
 1-441 .    D = E + F;
 1-442 . }
 1-443 . 
 1-444 . A = B*C;
 1-445 . A = B/C;
 1-446 . A = B+C;
 1-447 . A = B-C;
 1-448 . A = (long)B + C;
 1-449 . 
 1-450 . if (A eq B)
 1-451 . {
 1-452 .    A = B + C;
 1-453 .    D = E + F;
 1-454 . }
 1-455 . 
 1-456 . /* LE SV TOC-1005 this is a ca-01.2.30 req to store*/
 1-457 . 
 1-458 . if (A < = B)
 1-459 . {
 1-460 .    A = B + C;
 1-461 .    D = E + F;
 1-462 . }
 1-463 . 
 1-464 . A = B-C;
 1-465 . free(FreePtr);
 1-466 . A = B-C;
 1-467 . 
 1-468 . if (A ne B)
 1-469 . {
 1-470 .    A = B + C;
 1-471 .    D = E + F;
 1-472 . }
 1-473 . 
 1-474 . A = B/C;
 1-475 . A = B-C;
 1-476 . A = B+C;
 1-477 . /* LE SV TOC-1006 this is a ca-01.2.37 req to convert*/
 1-478 . 
 1-479 . if (A ge B)
 1-480 . {
 1-481 .    A = B + C;
 1-482 .    D = E + F;
 1-483 . }
 1-484 . 
 1-485 . A = B-C;
 1-486 . A = B/C;
 1-487 . 
 1-488 . if (A < = B)
 1-489 . {
 1-490 .    A = B + C;
 1-491 .    D = E + F;
 1-492 . }
 1-493 . 
 1-494 . A = B/C;
 1-495 . A = B/C;
 1-496 . A = B+C;
 1-497 . 
 1-498 . if (A le B)
 1-499 . {
 1-500 .    A = B + C;
 1-501 .    D = E + F;
 1-502 . }
 1-503 . 
 1-504 . A = B+C;
 1-505 . 
 1-506 . #ifdef LAZY
 1-507 .    // this is not nice
 1-508 .    A = B + C;
 1-509 .    A = B + C;
 1-510 . #endif
 1-511 . 
 1-512 . A = B*C;
 1-513 . 
 1-514 . if (A le B)
 1-515 . {
 1-516 .    A = B + C;
 1-517 .    D = E + F;
 1-518 . }
 1-519 . 
 1-520 . A = B/C;
 1-521 . A = B-C;
 1-522 . 
 1-523 . if (A <  B)
 1-524 . {
 1-525 .    A = B + C;
 1-526 .    D = E + F;
 1-527 . }
 1-528 . 
 1-529 . 
 1-530 . if (A eq B)
 1-531 . {
 1-532 .    A = B + C;
 1-533 .    D = E + F;
 1-534 . }
 1-535 . 
 1-536 . A = B-C;
 1-537 . A = B+C;
 1-538 . A = B*C;
 1-539 . A = B-C;
 1-540 . A = B-C;
 1-541 . A = B+C;
 1-542 . A = B/C;
 1-543 . A = B-C;
 1-544 . A = B+C;
 1-545 . A = B+C;
 1-546 . /* LE SV TOC-1007 this is a ca-01.2.62 req to compare*/
 1-547 . A = B-C;
 1-548 . send_buffer = (U16 *) malloc(size+1);
 1-549 . A = B-C;
 1-550 . 
 1-551 . /* dead_code = B + C; 
 1-552 . dead_code = D + E; 
 1-553 . dead_code = F + G; */
 1-554 . 
 1-555 . A = B-C;
 1-556 . do forever;
 1-557 . A = B+C;
 1-558 . // max LOC 65
 1-559 . 
 1-560 . }
 1-561 . 
 1-562 . 
 1-563 . /*
 1-564 . -----------------------------------------------------------------------------
 1-565 . --| NAME:   ca.1.3
 1-566 . --|
 1-567 . --| ABSTRACT:
 1-568 . --|   This function does ca stuff.
 1-569 . --|
 1-570 . --| RETURNS:
 1-571 . --|   NONE.
 1-572 . --|
 1-573 . ----------------------------------------------------------------------------
 1-574 . */
 1-575 . static void ca.1.3(void)
 1-576 . {
 1-577 . 
 1-578 . if (A >  B)
 1-579 . {
 1-580 .    A = B + C;
 1-581 .    D = E + F;
 1-582 . }
 1-583 . 
 1-584 . 
 1-585 . switch (ca stuff)
 1-586 . {
 1-587 .    case one:
 1-588 .    {
 1-589 .       run_this; 
 1-590 .       break;
 1-591 .    }
 1-592 .    case two:
 1-593 .    {
 1-594 .       run_this;
 1-595 .       break;
 1-596 .    }
 1-597 .    default:
 1-598 .    {
 1-599 .        SwError;
 1-600 .    }
 1-601 . }
 1-602 . 
 1-603 . A = B/C;
 1-604 . A = B*C;
 1-605 . A = 0x0007;
 1-606 . A = B/C;
 1-607 . 
 1-608 . if (A <  B)
 1-609 . {
 1-610 .    A = B + C;
 1-611 .    D = E + F;
 1-612 . }
 1-613 . 
 1-614 . A = B*C;
 1-615 . A = B*C;
 1-616 . A = B-C;
 1-617 . A = B-C;
 1-618 . A = B*C;
 1-619 . 
 1-620 . if (A ne B)
 1-621 . {
 1-622 .    A = B + C;
 1-623 .    D = E + F;
 1-624 . }
 1-625 . 
 1-626 . A = B*C;
 1-627 . A = B+C;
 1-628 . /* LE SV TOC-1008 this is a ca-01.3.15 req to recover*/
 1-629 . 
 1-630 . if (A gt B)
 1-631 . {
 1-632 .    A = B + C;
 1-633 .    D = E + F;
 1-634 . }
 1-635 . 
 1-636 . A = B/C;
 1-637 . A = B/C;
 1-638 . A = 0x0004;
 1-639 . A = B/C;
 1-640 . 
 1-641 . if (A > = B)
 1-642 . {
 1-643 .    A = B + C;
 1-644 .    D = E + F;
 1-645 . }
 1-646 . 
 1-647 . A = B*C;
 1-648 . A = B*C;
 1-649 . 
 1-650 . switch (ca stuff)
 1-651 . {
 1-652 .    case one:
 1-653 .    {
 1-654 .       run_this; 
 1-655 .       break;
 1-656 .    }
 1-657 .    case two:
 1-658 .    {
 1-659 .       run_this;
 1-660 .       break;
 1-661 .    }
 1-662 .    default:
 1-663 .    {
 1-664 .        SwError;
 1-665 .    }
 1-666 . }
 1-667 . 
 1-668 . 
 1-669 . if (A == B)
 1-670 . {
 1-671 .    A = B + C;
 1-672 .    D = E + F;
 1-673 . }
 1-674 . 
 1-675 . 
 1-676 . if (A > = B)
 1-677 . {
 1-678 .    A = B + C;
 1-679 .    D = E + F;
 1-680 . }
 1-681 . 
 1-682 . // max LOC 24
 1-683 . 
 1-684 . }
 1-685 . 
 1-686 . 
 1-687 . /*
 1-688 . -----------------------------------------------------------------------------
 1-689 . --| NAME:   ca.1.4
 1-690 . --|
 1-691 . --| ABSTRACT:
 1-692 . --|   This function does ca stuff.
 1-693 . --|
 1-694 . --| RETURNS:
 1-695 . --|   NONE.
 1-696 . --|
 1-697 . ----------------------------------------------------------------------------
 1-698 . */
 1-699 . static void ca.1.4(void)
 1-700 . {
 1-701 . A = B+C;
 1-702 . 
 1-703 . switch (ca stuff)
 1-704 . {
 1-705 .    case one:
 1-706 .    {
 1-707 .       run_this; 
 1-708 .       // missing break
 1-709 .    }
 1-710 .    case two:
 1-711 .    {
 1-712 .       run_this;
 1-713 .       break;
 1-714 .    }
 1-715 .    default:
 1-716 .    {
 1-717 .       SwError;
 1-718 .    }
 1-719 . }
 1-720 . 
 1-721 . A = B+C;
 1-722 . 
 1-723 . switch (ca stuff)
 1-724 . {
 1-725 .    case one:
 1-726 .    {
 1-727 .       run_this; 
 1-728 .       break;
 1-729 .    }
 1-730 .    case two:
 1-731 .    {
 1-732 .       run_this;
 1-733 .       break;
 1-734 .    }
 1-735 .    default:
 1-736 .    {
 1-737 .        SwError;
 1-738 .    }
 1-739 . }
 1-740 . 
 1-741 . A = B-C;
 1-742 . A = B*C;
 1-743 . A = B/C;
 1-744 . A = B/C;
 1-745 . A = B*C;
 1-746 . A = B-C;
 1-747 . 
 1-748 . if (A < = B)
 1-749 . {
 1-750 .    A = B + C;
 1-751 .    D = E + F;
 1-752 . }
 1-753 . 
 1-754 . A = B*C;
 1-755 . A = B*C;
 1-756 . A = B+C;
 1-757 . A = B+C;
 1-758 . A = B*C;
 1-759 . A = B-C;
 1-760 . A = B/C;
 1-761 . A = B/C;
 1-762 . A = B*C;
 1-763 . A = B+C;
 1-764 . // max LOC 20
 1-765 . 
 1-766 . }
 1-767 . 
 1-768 . 
 1-769 . /*
 1-770 . -----------------------------------------------------------------------------
 1-771 . --| NAME:   ca.1.5
 1-772 . --|
 1-773 . --| ABSTRACT:
 1-774 . --|   This function does ca stuff.
 1-775 . --|
 1-776 . --| RETURNS:
 1-777 . --|   NONE.
 1-778 . --|
 1-779 . ----------------------------------------------------------------------------
 1-780 . */
 1-781 . static void ca.1.5(void)
 1-782 . {
 1-783 . A = B+C;
 1-784 . 
 1-785 . if (A >  B)
 1-786 . {
 1-787 .    A = B + C;
 1-788 .    D = E + F;
 1-789 . }
 1-790 . 
 1-791 . 
 1-792 . if (A gt B)
 1-793 . {
 1-794 .    A = B + C;
 1-795 .    D = E + F;
 1-796 . }
 1-797 . 
 1-798 . 
 1-799 . if (A lt B)
 1-800 . {
 1-801 .    A = B + C;
 1-802 .    D = E + F;
 1-803 . }
 1-804 . 
 1-805 . A = B-C;
 1-806 . A = B+C;
 1-807 . /* LE SV TOC-1009 this is a ca-01.5.7 req to set Real Time Clock*/
 1-808 . A = B+C;
 1-809 . A = B/C;
 1-810 . 
 1-811 . if (A >  B)
 1-812 . {
 1-813 .    A = B + C;
 1-814 .    D = E + F;
 1-815 . }
 1-816 . 
 1-817 . A = B/C;
 1-818 . A = B*C;
 1-819 . A = B+C;
 1-820 . 
 1-821 . if (A == B)
 1-822 . {
 1-823 .    A = B + C;
 1-824 .    D = E + F;
 1-825 . }
 1-826 . 
 1-827 . A = B-C;
 1-828 . A = B-C;
 1-829 . A = B+C;
 1-830 . /* LE SV TOC-1010 this is a ca-01.5.17 req to halt*/
 1-831 . 
 1-832 . if (A ne B)
 1-833 . {
 1-834 .    A = B + C;
 1-835 .    D = E + F;
 1-836 . }
 1-837 . 
 1-838 . A = B-C;
 1-839 . A = B*C;
 1-840 . 
 1-841 . if (A eq B)
 1-842 . {
 1-843 .    A = B + C;
 1-844 .    D = E + F;
 1-845 . }
 1-846 . 
 1-847 . A = 0x0004;
 1-848 . A = B+C;
 1-849 . 
 1-850 . if (A eq B)
 1-851 . {
 1-852 .    A = B + C;
 1-853 .    D = E + F;
 1-854 . }
 1-855 . 
 1-856 . /* LE SV TOC-1011 this is a ca-01.5.23 req to record*/
 1-857 . A = B-C;
 1-858 . A = B-C;
 1-859 . A = B/C;
 1-860 . // max LOC 25
 1-861 . 
 1-862 . }
 1-863 . 
 1-864 . 
 1-865 . /*
 1-866 . -----------------------------------------------------------------------------
 1-867 . --| NAME:   ca.1.6
 1-868 . --|
 1-869 . --| ABSTRACT:
 1-870 . --|   This function does ca stuff.
 1-871 . --|
 1-872 . --| RETURNS:
 1-873 . --|   NONE.
 1-874 . --|
 1-875 . ----------------------------------------------------------------------------
 1-876 . */
 1-877 . static void ca.1.6(void)
 1-878 . {
 1-879 . /* LE SV TOC-1012 this is a ca-01.6.1 req to fail*/
 1-880 . A = B/C;
 1-881 . A = B*C;
 1-882 . A = B/C;
 1-883 . A = B-C;
 1-884 . 
 1-885 . if (A ne B)
 1-886 . {
 1-887 .    A = B + C;
 1-888 .    D = E + F;
 1-889 . }
 1-890 . 
 1-891 . A = B*C;
 1-892 . A = B+C;
 1-893 . A = B+C;
 1-894 . A = B/C;
 1-895 . 
 1-896 . if (A ge B)
 1-897 . {
 1-898 .    A = B + C;
 1-899 .    D = E + F;
 1-900 . }
 1-901 . 
 1-902 . 
 1-903 . if (A < = B)
 1-904 . {
 1-905 .    A = B + C;
 1-906 .    D = E + F;
 1-907 . }
 1-908 . 
 1-909 . 
 1-910 . if (A >  B)
 1-911 . {
 1-912 .    A = B + C;
 1-913 .    D = E + F;
 1-914 . }
 1-915 . 
 1-916 . 
 1-917 . if (A < = B)
 1-918 . {
 1-919 .    A = B + C;
 1-920 .    D = E + F;
 1-921 . }
 1-922 . 
 1-923 . A = B-C;
 1-924 . A = B-C;
 1-925 . A = B*C;
 1-926 . A = B+C;
 1-927 . A = 0x0004;
 1-928 . A = B/C;
 1-929 . 
 1-930 . if (A >  B)
 1-931 . {
 1-932 .    A = B + C;
 1-933 .    D = E + F;
 1-934 . }
 1-935 . 
 1-936 . /* LE SV TOC-1013 this is a ca-01.6.20 req to assign*/
 1-937 . 
 1-938 . if (A lt B)
 1-939 . {
 1-940 .    A = B + C;
 1-941 .    D = E + F;
 1-942 . }
 1-943 . 
 1-944 . // TBD - what do I do now
 1-945 . A = B*C;
 1-946 . A = B/C;
 1-947 . A = B+C;
 1-948 . A = B+C;
 1-949 . A = B*C;
 1-950 . A = B/C;
 1-951 . // max LOC 26
 1-952 . 
 1-953 . }
 1-954 . 
 1-955 . 
 1-956 . /*
 1-957 . -----------------------------------------------------------------------------
 1-958 . --| NAME:   ca.1.7
 1-959 . --|
 1-960 . --| ABSTRACT:
 1-961 . --|   This function does ca stuff.
 1-962 . --|
 1-963 . --| RETURNS:
 1-964 . --|   NONE.
 1-965 . --|
 1-966 . ----------------------------------------------------------------------------
 1-967 . */
 1-968 . static void ca.1.7(void)
 1-969 . {
 1-970 . A = B*C;
 1-971 . 
 1-972 . if (A gt B)
 1-973 . {
 1-974 .    A = B + C;
 1-975 .    D = E + F;
 1-976 . }
 1-977 . 
 1-978 . A = B+C;
 1-979 . A = B-C;
 1-980 . A = B/C;
 1-981 . A = B-C;
 1-982 . A = B+C;
 1-983 . 
 1-984 . if (A < = B)
 1-985 . {
 1-986 .    A = B + C;
 1-987 .    D = E + F;
 1-988 . }
 1-989 . 
 1-990 . A = B+C;
 1-991 . A = B-C;
 1-992 . /* LE SV TOC-1014 this is a ca-01.7.11 req to validate*/
 1-993 . A = B*C;
 1-994 . A = B-C;
 1-995 . A = B+C;
 1-996 . A = 0x0001;
 1-997 . A = B*C;
 1-998 . A = B/C;
 1-999 . A = B/C;
 1-1000 . A = B/C;
 1-1001 . 
 1-1002 . if (A != B)
 1-1003 . {
 1-1004 .    A = B + C;
 1-1005 .    D = E + F;
 1-1006 . }
 1-1007 . 
 1-1008 . A = B+C;
 1-1009 . A = B/C;
 1-1010 . A = B*C;
 1-1011 . 
 1-1012 . if (A >  B)
 1-1013 . {
 1-1014 .    A = B + C;
 1-1015 .    D = E + F;
 1-1016 . }
 1-1017 . 
 1-1018 . A = B-C;
 1-1019 . /* LE SV TOC-1015 this is a ca-01.7.24 req to translate*/
 1-1020 . 
 1-1021 . if (A gt B)
 1-1022 . {
 1-1023 .    A = B + C;
 1-1024 .    D = E + F;
 1-1025 . }
 1-1026 . 
 1-1027 . A = 0x0002;
 1-1028 . A = B*C;
 1-1029 . 
 1-1030 . if (A > = B)
 1-1031 . {
 1-1032 .    A = B + C;
 1-1033 .    D = E + F;
 1-1034 . }
 1-1035 . 
 1-1036 . A = B-C;
 1-1037 . A = B/C;
 1-1038 . A = B+C;
 1-1039 . A = B+C;
 1-1040 . A = B*C;
 1-1041 . A = B-C;
 1-1042 . 
 1-1043 . if (A == B)
 1-1044 . {
 1-1045 .    A = B + C;
 1-1046 .    D = E + F;
 1-1047 . }
 1-1048 . 
 1-1049 . A = B/C;
 1-1050 . A = B+C;
 1-1051 . 
 1-1052 . if (A > = B)
 1-1053 . {
 1-1054 .    A = B + C;
 1-1055 .    D = E + F;
 1-1056 . }
 1-1057 . 
 1-1058 . 
 1-1059 . if (A ne B)
 1-1060 . {
 1-1061 .    A = B + C;
 1-1062 .    D = E + F;
 1-1063 . }
 1-1064 . 
 1-1065 . A = B+C;
 1-1066 . 
 1-1067 . if (A < = B)
 1-1068 . {
 1-1069 .    A = B + C;
 1-1070 .    D = E + F;
 1-1071 . }
 1-1072 . 
 1-1073 . A = B*C;
 1-1074 . 
 1-1075 . if (A gt B)
 1-1076 . {
 1-1077 .    A = B + C;
 1-1078 .    D = E + F;
 1-1079 . }
 1-1080 . 
 1-1081 . A = B/C;
 1-1082 . A = B/C;
 1-1083 . A = B+C;
 1-1084 . 
 1-1085 . if (A <  B)
 1-1086 . {
 1-1087 .    A = B + C;
 1-1088 .    D = E + F;
 1-1089 . }
 1-1090 . 
 1-1091 . A = B+C;
 1-1092 . A = B/C;
 1-1093 . /* LE SV TOC-1016 this is a ca-01.7.48 req to transform*/
 1-1094 . 
 1-1095 . if (veg)
 1-1096 .    // missing curly brace
 1-1097 .    variable = orange;
 1-1098 . 
 1-1099 . 
 1-1100 . if (A <  B)
 1-1101 . {
 1-1102 .    A = B + C;
 1-1103 .    D = E + F;
 1-1104 . }
 1-1105 . 
 1-1106 . A = B+C;
 1-1107 . 
 1-1108 . if (A le B)
 1-1109 . {
 1-1110 .    A = B + C;
 1-1111 .    D = E + F;
 1-1112 . }
 1-1113 . 
 1-1114 . 
 1-1115 . if (A != B)
 1-1116 . {
 1-1117 .    A = B + C;
 1-1118 .    D = E + F;
 1-1119 . }
 1-1120 . 
 1-1121 . A = B+C;
 1-1122 . 
 1-1123 . if (A ge B)
 1-1124 . {
 1-1125 .    A = B + C;
 1-1126 .    D = E + F;
 1-1127 . }
 1-1128 . 
 1-1129 . A = B-C;
 1-1130 . A = B*C;
 1-1131 . 
 1-1132 . if (A lt B)
 1-1133 . {
 1-1134 .    A = B + C;
 1-1135 .    D = E + F;
 1-1136 . }
 1-1137 . 
 1-1138 . A = B/C;
 1-1139 . 
 1-1140 . if (A lt B)
 1-1141 . {
 1-1142 .    A = B + C;
 1-1143 .    D = E + F;
 1-1144 . }
 1-1145 . 
 1-1146 . A = B-C;
 1-1147 . 
 1-1148 . if (A >  B)
 1-1149 . {
 1-1150 .    A = B + C;
 1-1151 .    D = E + F;
 1-1152 . }
 1-1153 . 
 1-1154 . A = B-C;
 1-1155 . A = B-C;
 1-1156 . A = B+C;
 1-1157 . 
 1-1158 . if (A < = B)
 1-1159 . {
 1-1160 .    A = B + C;
 1-1161 .    D = E + F;
 1-1162 . }
 1-1163 . 
 1-1164 . A = B/C;
 1-1165 . 
 1-1166 . if (A gt B)
 1-1167 . {
 1-1168 .    A = B + C;
 1-1169 .    D = E + F;
 1-1170 . }
 1-1171 . 
 1-1172 . A = B/C;
 1-1173 . A = B-C;
 1-1174 . A = B+C;
 1-1175 . A = B/C;
 1-1176 . 
 1-1177 . #ifdef LAZY
 1-1178 .    // this is not nice
 1-1179 .    A = B + C;
 1-1180 .    A = B + C;
 1-1181 . #endif
 1-1182 . 
 1-1183 . A = B+C;
 1-1184 . A = B+C;
 1-1185 . 
 1-1186 . if (A > = B)
 1-1187 . {
 1-1188 .    A = B + C;
 1-1189 .    D = E + F;
 1-1190 . }
 1-1191 . 
 1-1192 . A = B*C;
 1-1193 . 
 1-1194 . if (A eq B)
 1-1195 . {
 1-1196 .    A = B + C;
 1-1197 .    D = E + F;
 1-1198 . }
 1-1199 . 
 1-1200 . A = B*C;
 1-1201 . 
 1-1202 . if (A >  B)
 1-1203 . {
 1-1204 .    A = B + C;
 1-1205 .    D = E + F;
 1-1206 . }
 1-1207 . 
 1-1208 . // max LOC 77
 1-1209 . 
 1-1210 . }
 1-1211 . 
 1-1212 . 
 1-1213 . /*
 1-1214 . -----------------------------------------------------------------------------
 1-1215 . --| NAME:   ca.1.8
 1-1216 . --|
 1-1217 . --| ABSTRACT:
 1-1218 . --|   This function does ca stuff.
 1-1219 . --|
 1-1220 . --| RETURNS:
 1-1221 . --|   NONE.
 1-1222 . --|
 1-1223 . ----------------------------------------------------------------------------
 1-1224 . */
 1-1225 . static void ca.1.8(void)
 1-1226 . {
 1-1227 . 
 1-1228 . if (A >  B)
 1-1229 . {
 1-1230 .    A = B + C;
 1-1231 .    D = E + F;
 1-1232 . }
 1-1233 . 
 1-1234 . 
 1-1235 . if (A >  B)
 1-1236 . {
 1-1237 .    A = B + C;
 1-1238 .    D = E + F;
 1-1239 . }
 1-1240 . 
 1-1241 . A = B+C;
 1-1242 . A = B-C;
 1-1243 . A = B*C;
 1-1244 . A = B/C;
 1-1245 . A = B*C;
 1-1246 . A = B/C;
 1-1247 . A = B*C;
 1-1248 . A = B-C;
 1-1249 . /* LE SV TOC-1017 this is a ca-01.8.11 req to check unix*/
 1-1250 . A = B-C;
 1-1251 . A = B-C;
 1-1252 . A = B+C;
 1-1253 . /* LE SV TOC-1018 this is a ca-01.8.14 req to update*/
 1-1254 . A = B/C;
 1-1255 . 
 1-1256 . switch (ca stuff)
 1-1257 . {
 1-1258 .    case one:
 1-1259 .    {
 1-1260 .       run_this; 
 1-1261 .       break;
 1-1262 .    }
 1-1263 .    case two:
 1-1264 .    {
 1-1265 .       run_this;
 1-1266 .       break;
 1-1267 .    }
 1-1268 .    default:
 1-1269 .    {
 1-1270 .        SwError;
 1-1271 .    }
 1-1272 . }
 1-1273 . 
 1-1274 . 
 1-1275 . if (A > = B)
 1-1276 . {
 1-1277 .    A = B + C;
 1-1278 .    D = E + F;
 1-1279 . }
 1-1280 . 
 1-1281 . A = B+C;
 1-1282 . A = B/C;
 1-1283 . A = B/C;
 1-1284 . 
 1-1285 . if (A <  B)
 1-1286 . {
 1-1287 .    A = B + C;
 1-1288 .    D = E + F;
 1-1289 . }
 1-1290 . 
 1-1291 . A = B*C;
 1-1292 . A = B-C;
 1-1293 . A = B-C;
 1-1294 . 
 1-1295 . if (A eq B)
 1-1296 . {
 1-1297 .    A = B + C;
 1-1298 .    D = E + F;
 1-1299 . }
 1-1300 . 
 1-1301 . /* LE SV TOC-1019 this is a ca-01.8.25 req to verify*/
 1-1302 . 
 1-1303 . if (A gt B)
 1-1304 . {
 1-1305 .    A = B + C;
 1-1306 .    D = E + F;
 1-1307 . }
 1-1308 . 
 1-1309 . 
 1-1310 . if (A <  B)
 1-1311 . {
 1-1312 .    A = B + C;
 1-1313 .    D = E + F;
 1-1314 . }
 1-1315 . 
 1-1316 . /* LE SV TOC-1020 this is a ca-01.8.27 req to process*/
 1-1317 . 
 1-1318 . if (A > = B)
 1-1319 . {
 1-1320 .    A = B + C;
 1-1321 .    D = E + F;
 1-1322 . }
 1-1323 . 
 1-1324 . A = B-C;
 1-1325 . 
 1-1326 . if (A ne B)
 1-1327 . {
 1-1328 .    A = B + C;
 1-1329 .    D = E + F;
 1-1330 . }
 1-1331 . 
 1-1332 . 
 1-1333 . #ifdef LAZY
 1-1334 .    // this is not nice
 1-1335 .    A = B + C;
 1-1336 .    A = B + C;
 1-1337 . #endif
 1-1338 . 
 1-1339 . A = B-C;
 1-1340 . 
 1-1341 . if (A == B)
 1-1342 . {
 1-1343 .    A = B + C;
 1-1344 .    D = E + F;
 1-1345 . }
 1-1346 . 
 1-1347 . A = B/C;
 1-1348 . A = B+C;
 1-1349 . A = B+C;
 1-1350 . A = B/C;
 1-1351 . A = B+C;
 1-1352 . A = B+C;
 1-1353 . 
 1-1354 . if (A ne B)
 1-1355 . {
 1-1356 .    A = B + C;
 1-1357 .    D = E + F;
 1-1358 . }
 1-1359 . 
 1-1360 . A = B/C;
 1-1361 . A = B/C;
 1-1362 . 
 1-1363 . if (A != B)
 1-1364 . {
 1-1365 .    A = B + C;
 1-1366 .    D = E + F;
 1-1367 . }
 1-1368 . 
 1-1369 . /* LE SV TOC-1021 this is a ca-01.8.42 req to fail*/
 1-1370 . 
 1-1371 . if (A >  B)
 1-1372 . {
 1-1373 .    A = B + C;
 1-1374 .    D = E + F;
 1-1375 . }
 1-1376 . 
 1-1377 . A = B+C;
 1-1378 . A = 0x0009;
 1-1379 . A = B*C;
 1-1380 . A = B-C;
 1-1381 . A = B-C;
 1-1382 . 
 1-1383 . if (A == B)
 1-1384 . {
 1-1385 .    A = B + C;
 1-1386 .    D = E + F;
 1-1387 . }
 1-1388 . 
 1-1389 . A = B+C;
 1-1390 . A = B+C;
 1-1391 . A = B*C;
 1-1392 . A = B-C;
 1-1393 . 
 1-1394 . if (A <  B)
 1-1395 . {
 1-1396 .    A = B + C;
 1-1397 .    D = E + F;
 1-1398 . }
 1-1399 . 
 1-1400 . 
 1-1401 . if (A ne B)
 1-1402 . {
 1-1403 .    A = B + C;
 1-1404 .    D = E + F;
 1-1405 . }
 1-1406 . 
 1-1407 . A = B+C;
 1-1408 . 
 1-1409 . if (A ge B)
 1-1410 . {
 1-1411 .    A = B + C;
 1-1412 .    D = E + F;
 1-1413 . }
 1-1414 . 
 1-1415 . 
 1-1416 . if (A le B)
 1-1417 . {
 1-1418 .    A = B + C;
 1-1419 .    D = E + F;
 1-1420 . }
 1-1421 . 
 1-1422 . 
 1-1423 . switch (ca stuff)
 1-1424 . {
 1-1425 .    case one:
 1-1426 .    {
 1-1427 .       run_this; 
 1-1428 .       break;
 1-1429 .    }
 1-1430 .    case two:
 1-1431 .    {
 1-1432 .       run_this;
 1-1433 .       break;
 1-1434 .    }
 1-1435 .    default:
 1-1436 .    {
 1-1437 .        SwError;
 1-1438 .    }
 1-1439 . }
 1-1440 . 
 1-1441 . 
 1-1442 . if (A == B)
 1-1443 . {
 1-1444 .    A = B + C;
 1-1445 .    D = E + F;
 1-1446 . }
 1-1447 . 
 1-1448 . A = B/C;
 1-1449 . A = B+C;
 1-1450 . A = B+C;
 1-1451 . A = B/C;
 1-1452 . A = B/C;
 1-1453 . A = B+C;
 1-1454 . A = B-C;
 1-1455 . A = B+C;
 1-1456 . A = B+C;
 1-1457 . 
 1-1458 . if (A ge B)
 1-1459 . {
 1-1460 .    A = B + C;
 1-1461 .    D = E + F;
 1-1462 . }
 1-1463 . 
 1-1464 . A = B*C;
 1-1465 . 
 1-1466 . if (A == B)
 1-1467 . {
 1-1468 .    A = B + C;
 1-1469 .    D = E + F;
 1-1470 . }
 1-1471 . 
 1-1472 . A = B/C;
 1-1473 . A = B-C;
 1-1474 . 
 1-1475 . if (A < = B)
 1-1476 . {
 1-1477 .    A = B + C;
 1-1478 .    D = E + F;
 1-1479 . }
 1-1480 . 
 1-1481 . 
 1-1482 . if (A lt B)
 1-1483 . {
 1-1484 .    A = B + C;
 1-1485 .    D = E + F;
 1-1486 . }
 1-1487 . 
 1-1488 . A = B/C;
 1-1489 . A = 0x0009;
 1-1490 . A = B/C;
 1-1491 . A = B/C;
 1-1492 . A = B-C;
 1-1493 . // max LOC 78
 1-1494 . 
 1-1495 . }
 1-1496 . 
 1-1497 . 
 1-1498 . /*
 1-1499 . -----------------------------------------------------------------------------
 1-1500 . --| NAME:   ca.1.9
 1-1501 . --|
 1-1502 . --| ABSTRACT:
 1-1503 . --|   This function does ca stuff.
 1-1504 . --|
 1-1505 . --| RETURNS:
 1-1506 . --|   NONE.
 1-1507 . --|
 1-1508 . ----------------------------------------------------------------------------
 1-1509 . */
 1-1510 . static void ca.1.9(void)
 1-1511 . {
 1-1512 . A = B-C;
 1-1513 . /* LE SV TOC-1022 this is a ca-01.9.2 req to assign*/
 1-1514 . 
 1-1515 . /* dead_code = B + C; 
 1-1516 . dead_code = D + E; 
 1-1517 . dead_code = F + G; */
 1-1518 . 
 1-1519 . A = B-C;
 1-1520 . A = B/C;
 1-1521 . A = B/C;
 1-1522 . A = B/C;
 1-1523 . A = B/C;
 1-1524 . A = B+C;
 1-1525 . A = B-C;
 1-1526 . A = B+C;
 1-1527 . 
 1-1528 . if (A == B)
 1-1529 . {
 1-1530 .    A = B + C;
 1-1531 .    D = E + F;
 1-1532 . }
 1-1533 . 
 1-1534 . 
 1-1535 . if (A <  B)
 1-1536 . {
 1-1537 .    A = B + C;
 1-1538 .    D = E + F;
 1-1539 . }
 1-1540 . 
 1-1541 . A = B-C;
 1-1542 . A = 0x0004;
 1-1543 . A = B+C;
 1-1544 . A = B*C;
 1-1545 . 
 1-1546 . if (A <  B)
 1-1547 . {
 1-1548 .    A = B + C;
 1-1549 .    D = E + F;
 1-1550 . }
 1-1551 . 
 1-1552 . A = B-C;
 1-1553 . A = B/C;
 1-1554 . A = B*C;
 1-1555 . 
 1-1556 . if {
 1-1557 .    X = Y + Z;
 1-1558 . }
 1-1559 . else {
 1-1560 .    halt;
 1-1561 . }
 1-1562 . 
 1-1563 . 
 1-1564 . if (A == B)
 1-1565 . {
 1-1566 .    A = B + C;
 1-1567 .    D = E + F;
 1-1568 . }
 1-1569 . 
 1-1570 . A = B/C;
 1-1571 . 
 1-1572 . if (A == B)
 1-1573 . {
 1-1574 .    A = B + C;
 1-1575 .    D = E + F;
 1-1576 . }
 1-1577 . 
 1-1578 . 
 1-1579 . if (A > = B)
 1-1580 . {
 1-1581 .    A = B + C;
 1-1582 .    D = E + F;
 1-1583 . }
 1-1584 . 
 1-1585 . A = B*C;
 1-1586 . A = B/C;
 1-1587 . 
 1-1588 . if (A < = B)
 1-1589 . {
 1-1590 .    A = B + C;
 1-1591 .    D = E + F;
 1-1592 . }
 1-1593 . 
 1-1594 . 
 1-1595 . if (A eq B)
 1-1596 . {
 1-1597 .    A = B + C;
 1-1598 .    D = E + F;
 1-1599 . }
 1-1600 . 
 1-1601 . /* LE SV TOC-1023 this is a ca-01.9.27 req to reject*/
 1-1602 . A = B+C;
 1-1603 . A = B/C;
 1-1604 . /* LE SV TOC-1024 this is a ca-01.9.29 req to process*/
 1-1605 . A = B/C;
 1-1606 . A = B+C;
 1-1607 . /* LE SV TOC-1025 this is a ca-01.9.31 req to assign*/
 1-1608 . A = B*C;
 1-1609 . A = B+C;
 1-1610 . A = 0x0001;
 1-1611 . A = B+C;
 1-1612 . A = B/C;
 1-1613 . 
 1-1614 . if (A > = B)
 1-1615 . {
 1-1616 .    A = B + C;
 1-1617 .    D = E + F;
 1-1618 . }
 1-1619 . 
 1-1620 . A = B/C;
 1-1621 . A = B+C;
 1-1622 . 
 1-1623 . if (A >  B)
 1-1624 . {
 1-1625 .    A = B + C;
 1-1626 .    D = E + F;
 1-1627 . }
 1-1628 . 
 1-1629 . A = B-C;
 1-1630 . A = B*C;
 1-1631 . 
 1-1632 . switch (ca stuff)
 1-1633 . {
 1-1634 .    case:
 1-1635 .    case:
 1-1636 .    // stacked case statements but only if there is a new line in between
 1-1637 . 
 1-1638 .    case:
 1-1639 .    case:
 1-1640 .    case:
 1-1641 .    {
 1-1642 .       run_this;
 1-1643 .       break;
 1-1644 .    }
 1-1645 .    default:
 1-1646 .    {
 1-1647 .       halt;
 1-1648 .    }
 1-1649 . }
 1-1650 . 
 1-1651 . 
 1-1652 . if (A < = B)
 1-1653 . {
 1-1654 .    A = B + C;
 1-1655 .    D = E + F;
 1-1656 . }
 1-1657 . 
 1-1658 . A = B-C;
 1-1659 . A = B/C;
 1-1660 . 
 1-1661 . if (A != B)
 1-1662 . {
 1-1663 .    A = B + C;
 1-1664 .    D = E + F;
 1-1665 . }
 1-1666 . 
 1-1667 . A = B-C;
 1-1668 . 
 1-1669 . if (A gt B)
 1-1670 . {
 1-1671 .    A = B + C;
 1-1672 .    D = E + F;
 1-1673 . }
 1-1674 . 
 1-1675 . A = B*C;
 1-1676 . A = B*C;
 1-1677 . /* LE SV TOC-1026 this is a ca-01.9.49 req to call isr*/
 1-1678 . A = B+C;
 1-1679 . A = B+C;
 1-1680 . 
 1-1681 . switch (ca stuff)
 1-1682 . {
 1-1683 .    case one:
 1-1684 .    {
 1-1685 .       run_this; 
 1-1686 .       break;
 1-1687 .    }
 1-1688 .    case two:
 1-1689 .    {
 1-1690 .       run_this;
 1-1691 .       break;
 1-1692 .    }
 1-1693 .    default:
 1-1694 .    {
 1-1695 .        SwError;
 1-1696 .    }
 1-1697 . }
 1-1698 . 
 1-1699 . 
 1-1700 . if (A lt B)
 1-1701 . {
 1-1702 .    A = B + C;
 1-1703 .    D = E + F;
 1-1704 . }
 1-1705 . 
 1-1706 . 
 1-1707 . if (veg)
 1-1708 .    // missing curly brace
 1-1709 .    variable = orange;
 1-1710 . 
 1-1711 . A = B/C;
 1-1712 . A = B-C;
 1-1713 . A = B*C;
 1-1714 . // (P) this is really improtant
 1-1715 . 
 1-1716 . switch (ca stuff)
 1-1717 . {
 1-1718 .    case one:
 1-1719 .    {
 1-1720 .       run_this; 
 1-1721 .       break;
 1-1722 .    }
 1-1723 .    case two:
 1-1724 .    {
 1-1725 .       run_this;
 1-1726 .       break;
 1-1727 .    }
 1-1728 .    default:
 1-1729 .    {
 1-1730 .        SwError;
 1-1731 .    }
 1-1732 . }
 1-1733 . 
 1-1734 . A = B-C;
 1-1735 . A = B*C;
 1-1736 . 
 1-1737 . if (A gt B)
 1-1738 . {
 1-1739 .    A = B + C;
 1-1740 .    D = E + F;
 1-1741 . }
 1-1742 . 
 1-1743 . A = B-C;
 1-1744 . A = B/C;
 1-1745 . A = B+C;
 1-1746 . A = B+C;
 1-1747 . A = 0x0007;
 1-1748 . 
 1-1749 . if (A le B)
 1-1750 . {
 1-1751 .    A = B + C;
 1-1752 .    D = E + F;
 1-1753 . }
 1-1754 . 
 1-1755 . A = B+C;
 1-1756 . A = B/C;
 1-1757 . A = 0x0001;
 1-1758 . A = B-C;
 1-1759 . A = B*C;
 1-1760 . A = B-C;
 1-1761 . 
 1-1762 . if (A lt B)
 1-1763 . {
 1-1764 .    A = B + C;
 1-1765 .    D = E + F;
 1-1766 . }
 1-1767 . 
 1-1768 . A = B/C;
 1-1769 . /* LE SV TOC-1027 this is a ca-01.9.72 req to record*/
 1-1770 . A = B+C;
 1-1771 . // ??? go see ws
 1-1772 . A = B*C;
 1-1773 . A = B+C;
 1-1774 . A = B/C;
 1-1775 . A = B-C;
 1-1776 . A = B*C;
 1-1777 . A = B-C;
 1-1778 . /* LE SV TOC-1028 this is a ca-01.9.79 req to audit*/
 1-1779 . A = B/C;
 1-1780 . A = B-C;
 1-1781 . 
 1-1782 . if (A >  B)
 1-1783 . {
 1-1784 .    A = B + C;
 1-1785 .    D = E + F;
 1-1786 . }
 1-1787 . 
 1-1788 . 
 1-1789 . if (A lt B)
 1-1790 . {
 1-1791 .    A = B + C;
 1-1792 .    D = E + F;
 1-1793 . }
 1-1794 . 
 1-1795 . A = B+C;
 1-1796 . A = B/C;
 1-1797 . // max LOC 84
 1-1798 . 
 1-1799 . }
 1-1800 . 
 1-1801 . 
 1-1802 . /*
 1-1803 . -----------------------------------------------------------------------------
 1-1804 . --| NAME:   ca.1.10
 1-1805 . --|
 1-1806 . --| ABSTRACT:
 1-1807 . --|   This function does ca stuff.
 1-1808 . --|
 1-1809 . --| RETURNS:
 1-1810 . --|   NONE.
 1-1811 . --|
 1-1812 . ----------------------------------------------------------------------------
 1-1813 . */
 1-1814 . static void ca.1.10(void)
 1-1815 . {
 1-1816 . A = B/C;
 1-1817 . /* LE SV TOC-1029 this is a ca-01.10.2 req to convert*/
 1-1818 . send_buffer = (U16 *) malloc(size+1);
 1-1819 . A = B*C;
 1-1820 . 
 1-1821 . if (A != B)
 1-1822 . {
 1-1823 .    A = B + C;
 1-1824 .    D = E + F;
 1-1825 . }
 1-1826 . 
 1-1827 . A = B+C;
 1-1828 . A = B-C;
 1-1829 . A = B+C;
 1-1830 . A = B-C;
 1-1831 . A = B*C;
 1-1832 . 
 1-1833 . if (A == B)
 1-1834 . {
 1-1835 .    A = B + C;
 1-1836 .    D = E + F;
 1-1837 . }
 1-1838 . 
 1-1839 . A = B*C;
 1-1840 . 
 1-1841 . if ($ca stuff >  $otherca stuff) 
 1-1842 . /* LE SV TOC-008 we really should log all error calls */
 1-1843 . {
 1-1844 .    A = B + C;
 1-1845 . }
 1-1846 . 
 1-1847 . A = B+C;
 1-1848 . A = B-C;
 1-1849 . A = B*C;
 1-1850 . 
 1-1851 . if (A > = B)
 1-1852 . {
 1-1853 .    A = B + C;
 1-1854 .    D = E + F;
 1-1855 . }
 1-1856 . 
 1-1857 . A = B-C;
 1-1858 . A = B*C;
 1-1859 . 
 1-1860 . if (A != B)
 1-1861 . {
 1-1862 .    A = B + C;
 1-1863 .    D = E + F;
 1-1864 . }
 1-1865 . 
 1-1866 . A = B-C;
 1-1867 . A = B-C;
 1-1868 . A = B-C;
 1-1869 . 
 1-1870 . switch (ca stuff)
 1-1871 . {
 1-1872 .    case one:
 1-1873 .    {
 1-1874 .       run_this; 
 1-1875 .       break;
 1-1876 .    }
 1-1877 .    case two:
 1-1878 .    {
 1-1879 .       run_this;
 1-1880 .       break;
 1-1881 .    }
 1-1882 .    default:
 1-1883 .    {
 1-1884 .        SwError;
 1-1885 .    }
 1-1886 . }
 1-1887 . 
 1-1888 . 
 1-1889 . if (A gt B)
 1-1890 . {
 1-1891 .    A = B + C;
 1-1892 .    D = E + F;
 1-1893 . }
 1-1894 . 
 1-1895 . A = B+C;
 1-1896 . A = B+C;
 1-1897 . 
 1-1898 . if (A gt B)
 1-1899 . {
 1-1900 .    A = B + C;
 1-1901 .    D = E + F;
 1-1902 . }
 1-1903 . 
 1-1904 . A = 0x0001;
 1-1905 . A = B/C;
 1-1906 . 
 1-1907 . if (A >  B)
 1-1908 . {
 1-1909 .    A = B + C;
 1-1910 .    D = E + F;
 1-1911 . }
 1-1912 . 
 1-1913 . A = B+C;
 1-1914 . A = B+C;
 1-1915 . // max LOC 29
 1-1916 . 
 1-1917 . }
 1-1918 . 

1 1 Result: result/source/ft-app/ft-app-B1.1/ca/ca-01.c


2 2 Source: source/ft-app/ft-app-B1.1/ca/ca-02.c
 2-0 . /*
 2-1 . ----------------------------------------------------------------------------
 2-2 . --| BEGIN PROLOGUE
 2-3 . --|
 2-4 . --| CLASSIFICATION: UNCLASSIFIED
 2-5 . --|
 2-6 . --| FILE NAME:      ca-02.c
 2-7 . --|
 2-8 . --| ABSTRACT:
 2-9 . --|   This file contains the 8 functions that do file ca stuff.
 2-10 . --|
 2-11 . --| HISTORY:
 2-12 . --|   CCCQ_NAME:
 2-13 . --|   CCCQ_VER: 
 2-14 . --|
 2-15 . --| END PROLOGUE
 2-16 . ----------------------------------------------------------------------------
 2-17 . */
 2-18 . 
 2-19 . double C;
 2-20 . #include A;
 2-21 . #define C;
 2-22 . #include D;
 2-23 . double C;
 2-24 . #define C;
 2-25 . 
 2-26 . 
 2-27 . 
 2-28 . /*
 2-29 . -----------------------------------------------------------------------------
 2-30 . --| NAME:   ca.2.1
 2-31 . --|
 2-32 . --| ABSTRACT:
 2-33 . --|   This function does ca stuff.
 2-34 . --|
 2-35 . --| RETURNS:
 2-36 . --|   NONE.
 2-37 . --|
 2-38 . ----------------------------------------------------------------------------
 2-39 . */
 2-40 . static void ca.2.1(void)
 2-41 . {
 2-42 . A = B-C;
 2-43 . A = B/C;
 2-44 . A = B+C;
 2-45 . A = B*C;
 2-46 . A = B+C;
 2-47 . 
 2-48 . if (A lt B)
 2-49 . {
 2-50 .    A = B + C;
 2-51 .    D = E + F;
 2-52 . }
 2-53 . 
 2-54 . A = B/C;
 2-55 . 
 2-56 . if (A > = B)
 2-57 . {
 2-58 .    A = B + C;
 2-59 .    D = E + F;
 2-60 . }
 2-61 . 
 2-62 . A = B+C;
 2-63 . A = B+C;
 2-64 . A = B-C;
 2-65 . A = B+C;
 2-66 . 
 2-67 . if (A > = B)
 2-68 . {
 2-69 .    A = B + C;
 2-70 .    D = E + F;
 2-71 . }
 2-72 . 
 2-73 . A = B-C;
 2-74 . A = B+C;
 2-75 . /* LE SV TOC-1030 this is a ca-02.1.16 req to audit*/
 2-76 . A = B+C;
 2-77 . /* LE SV TOC-1031 this is a ca-02.1.17 req to compare*/
 2-78 . A = B-C;
 2-79 . /* LE SV TOC-1032 this is a ca-02.1.18 req to update*/
 2-80 . A = B*C;
 2-81 . A = B+C;
 2-82 . A = B-C;
 2-83 . A = B-C;
 2-84 . A = B*C;
 2-85 . A = B+C;
 2-86 . 
 2-87 . if (A > = B)
 2-88 . {
 2-89 .    A = B + C;
 2-90 .    D = E + F;
 2-91 . }
 2-92 . 
 2-93 . A = B*C;
 2-94 . A = B+C;
 2-95 . 
 2-96 . switch (ca stuff)
 2-97 . {
 2-98 .    case one:
 2-99 .    {
 2-100 .       run_this; 
 2-101 .       break;
 2-102 .    }
 2-103 .    case two:
 2-104 .    {
 2-105 .       run_this;
 2-106 .       break;
 2-107 .    }
 2-108 .    default:
 2-109 .    {
 2-110 .        SwError;
 2-111 .    }
 2-112 . }
 2-113 . 
 2-114 . A = B-C;
 2-115 . A = B*C;
 2-116 . 
 2-117 . if (A eq B)
 2-118 . {
 2-119 .    A = B + C;
 2-120 .    D = E + F;
 2-121 . }
 2-122 . 
 2-123 . A = B*C;
 2-124 . A = B/C;
 2-125 . 
 2-126 . if (A > = B)
 2-127 . {
 2-128 .    A = B + C;
 2-129 .    D = E + F;
 2-130 . }
 2-131 . 
 2-132 . 
 2-133 . if (A eq B)
 2-134 . {
 2-135 .    A = B + C;
 2-136 .    D = E + F;
 2-137 . }
 2-138 . 
 2-139 . 
 2-140 . if (A ge B)
 2-141 . {
 2-142 .    A = B + C;
 2-143 .    D = E + F;
 2-144 . }
 2-145 . 
 2-146 . A = B-C;
 2-147 . 
 2-148 . if (A == B)
 2-149 . {
 2-150 .    A = B + C;
 2-151 .    D = E + F;
 2-152 . }
 2-153 . 
 2-154 . 
 2-155 . if (A != B)
 2-156 . {
 2-157 .    A = B + C;
 2-158 .    D = E + F;
 2-159 . }
 2-160 . 
 2-161 . A = B*C;
 2-162 . 
 2-163 . if (A eq B)
 2-164 . {
 2-165 .    A = B + C;
 2-166 .    D = E + F;
 2-167 . }
 2-168 . 
 2-169 . 
 2-170 . if (A >  B)
 2-171 . {
 2-172 .    A = B + C;
 2-173 .    D = E + F;
 2-174 . }
 2-175 . 
 2-176 . A = B/C;
 2-177 . A = B+C;
 2-178 . A = B*C;
 2-179 . A = B-C;
 2-180 . 
 2-181 . if (A ge B)
 2-182 . {
 2-183 .    A = B + C;
 2-184 .    D = E + F;
 2-185 . }
 2-186 . 
 2-187 . 
 2-188 . if (A ne B)
 2-189 . {
 2-190 .    A = B + C;
 2-191 .    D = E + F;
 2-192 . }
 2-193 . 
 2-194 . A = B*C;
 2-195 . 
 2-196 . if (A gt B)
 2-197 . {
 2-198 .    A = B + C;
 2-199 .    D = E + F;
 2-200 . }
 2-201 . 
 2-202 . /* LE SV TOC-1033 this is a ca-02.1.50 req to store*/
 2-203 . A = (float)B + C;
 2-204 . 
 2-205 . if (A ge B)
 2-206 . {
 2-207 .    A = B + C;
 2-208 .    D = E + F;
 2-209 . }
 2-210 . 
 2-211 . 
 2-212 . if (A != B)
 2-213 . {
 2-214 .    A = B + C;
 2-215 .    D = E + F;
 2-216 . }
 2-217 . 
 2-218 . A = 0x0009;
 2-219 . A = B/C;
 2-220 . A = B/C;
 2-221 . A = B/C;
 2-222 . 
 2-223 . switch (ca stuff)
 2-224 . {
 2-225 .    case one:
 2-226 .    {
 2-227 .       run_this; 
 2-228 .       break;
 2-229 .    }
 2-230 .    case two:
 2-231 .    {
 2-232 .       run_this;
 2-233 .       break;
 2-234 .    }
 2-235 .    default:
 2-236 .    {
 2-237 .        SwError;
 2-238 .    }
 2-239 . }
 2-240 . 
 2-241 . 
 2-242 . if (A <  B)
 2-243 . {
 2-244 .    A = B + C;
 2-245 .    D = E + F;
 2-246 . }
 2-247 . 
 2-248 . 
 2-249 . if (A == B)
 2-250 . {
 2-251 .    A = B + C;
 2-252 .    D = E + F;
 2-253 . }
 2-254 . 
 2-255 . 
 2-256 . if (A gt B)
 2-257 . {
 2-258 .    A = B + C;
 2-259 .    D = E + F;
 2-260 . }
 2-261 . 
 2-262 . A = B+C;
 2-263 . A = B/C;
 2-264 . A = B*C;
 2-265 . A = B/C;
 2-266 . A = B-C;
 2-267 . 
 2-268 . if (A == B)
 2-269 . {
 2-270 .    A = B + C;
 2-271 .    D = E + F;
 2-272 . }
 2-273 . 
 2-274 . 
 2-275 . switch (ca stuff)
 2-276 . {
 2-277 .    case one:
 2-278 .    {
 2-279 .       run_this; 
 2-280 .       break;
 2-281 .    }
 2-282 .    case two:
 2-283 .    {
 2-284 .       run_this;
 2-285 .       break;
 2-286 .    }
 2-287 .    default:
 2-288 .    {
 2-289 .        SwError;
 2-290 .    }
 2-291 . }
 2-292 . 
 2-293 . /* LE SV TOC-1034 this is a ca-02.1.66 req to set RTC*/
 2-294 . 
 2-295 . if (A < = B)
 2-296 . {
 2-297 .    A = B + C;
 2-298 .    D = E + F;
 2-299 . }
 2-300 . 
 2-301 . A = B*C;
 2-302 . A = B+C;
 2-303 . A = B+C;
 2-304 . A = B+C;
 2-305 . 
 2-306 . if (A eq B)
 2-307 . {
 2-308 .    A = B + C;
 2-309 .    D = E + F;
 2-310 . }
 2-311 . 
 2-312 . 
 2-313 . if (A ge B)
 2-314 . {
 2-315 .    A = B + C;
 2-316 .    D = E + F;
 2-317 . }
 2-318 . 
 2-319 . 
 2-320 . if (A eq B)
 2-321 . {
 2-322 .    A = B + C;
 2-323 .    D = E + F;
 2-324 . }
 2-325 . 
 2-326 . 
 2-327 . if (A lt B)
 2-328 . {
 2-329 .    A = B + C;
 2-330 .    D = E + F;
 2-331 . }
 2-332 . 
 2-333 . A = B*C;
 2-334 . /* dead_code = A * B; */
 2-335 . A = B+C;
 2-336 . /* LE SV TOC-1035 this is a ca-02.1.77 req to compare*/
 2-337 . 
 2-338 . if (A le B)
 2-339 . {
 2-340 .    A = B + C;
 2-341 .    D = E + F;
 2-342 . }
 2-343 . 
 2-344 . 
 2-345 . if (A >  B)
 2-346 . {
 2-347 .    A = B + C;
 2-348 .    D = E + F;
 2-349 . }
 2-350 . 
 2-351 . A = B/C;
 2-352 . // max LOC 79
 2-353 . 
 2-354 . }
 2-355 . 
 2-356 . 
 2-357 . /*
 2-358 . -----------------------------------------------------------------------------
 2-359 . --| NAME:   ca.2.2
 2-360 . --|
 2-361 . --| ABSTRACT:
 2-362 . --|   This function does ca stuff.
 2-363 . --|
 2-364 . --| RETURNS:
 2-365 . --|   NONE.
 2-366 . --|
 2-367 . ----------------------------------------------------------------------------
 2-368 . */
 2-369 . static void ca.2.2(void)
 2-370 . {
 2-371 . A = B/C;
 2-372 . A = B/C;
 2-373 . 
 2-374 . if (A le B)
 2-375 . {
 2-376 .    A = B + C;
 2-377 .    D = E + F;
 2-378 . }
 2-379 . 
 2-380 . A = B/C;
 2-381 . A = B+C;
 2-382 . A = B/C;
 2-383 . A = B+C;
 2-384 . 
 2-385 . if (A eq B)
 2-386 . {
 2-387 .    A = B + C;
 2-388 .    D = E + F;
 2-389 . }
 2-390 . 
 2-391 . A = B+C;
 2-392 . A = 0x0001;
 2-393 . A = B+C;
 2-394 . A = B*C;
 2-395 . A = 0x0008;
 2-396 . A = B-C;
 2-397 . A = B+C;
 2-398 . A = B/C;
 2-399 . A = B*C;
 2-400 . A = B-C;
 2-401 . 
 2-402 . if (A ne B)
 2-403 . {
 2-404 .    A = B + C;
 2-405 .    D = E + F;
 2-406 . }
 2-407 . 
 2-408 . A = B+C;
 2-409 . /* LE SV TOC-1036 this is a ca-02.2.19 req to set RTC*/
 2-410 . 
 2-411 . if (A le B)
 2-412 . {
 2-413 .    A = B + C;
 2-414 .    D = E + F;
 2-415 . }
 2-416 . 
 2-417 . 
 2-418 . if (A lt B)
 2-419 . {
 2-420 .    A = B + C;
 2-421 .    D = E + F;
 2-422 . }
 2-423 . 
 2-424 . A = B+C;
 2-425 . A = B+C;
 2-426 . // max LOC 22
 2-427 . 
 2-428 . }
 2-429 . 
 2-430 . 
 2-431 . /*
 2-432 . -----------------------------------------------------------------------------
 2-433 . --| NAME:   ca.2.3
 2-434 . --|
 2-435 . --| ABSTRACT:
 2-436 . --|   This function does ca stuff.
 2-437 . --|
 2-438 . --| RETURNS:
 2-439 . --|   NONE.
 2-440 . --|
 2-441 . ----------------------------------------------------------------------------
 2-442 . */
 2-443 . static void ca.2.3(void)
 2-444 . {
 2-445 . A = B+C;
 2-446 . A = B+C;
 2-447 . 
 2-448 . if (A == B)
 2-449 . {
 2-450 .    A = B + C;
 2-451 .    D = E + F;
 2-452 . }
 2-453 . 
 2-454 . 
 2-455 . switch (ca stuff)
 2-456 . {
 2-457 .    case one:
 2-458 .    {
 2-459 .       run_this; 
 2-460 .       break;
 2-461 .    }
 2-462 .    case two:
 2-463 .    {
 2-464 .       run_this;
 2-465 .       break;
 2-466 .    }
 2-467 .    default:
 2-468 .    {
 2-469 .        SwError;
 2-470 .    }
 2-471 . }
 2-472 . 
 2-473 . A = B-C;
 2-474 . A = B/C;
 2-475 . 
 2-476 . if (A lt B)
 2-477 . {
 2-478 .    A = B + C;
 2-479 .    D = E + F;
 2-480 . }
 2-481 . 
 2-482 . 
 2-483 . if (A == B)
 2-484 . {
 2-485 .    A = B + C;
 2-486 .    D = E + F;
 2-487 . }
 2-488 . 
 2-489 . 
 2-490 . if (A le B)
 2-491 . {
 2-492 .    A = B + C;
 2-493 .    D = E + F;
 2-494 . }
 2-495 . 
 2-496 . A = B/C;
 2-497 . A = B-C;
 2-498 . /* LE SV TOC-1037 this is a ca-02.3.12 req to translate*/
 2-499 . A = B*C;
 2-500 . 
 2-501 . if (A == B)
 2-502 . {
 2-503 .    A = B + C;
 2-504 .    D = E + F;
 2-505 . }
 2-506 . 
 2-507 . A = B/C;
 2-508 . FreePtr = HmiStringPtr;
 2-509 . A = B/C;
 2-510 . 
 2-511 . if (A >  B)
 2-512 . {
 2-513 .    A = B + C;
 2-514 .    D = E + F;
 2-515 . }
 2-516 . 
 2-517 . A = B+C;
 2-518 . A = 0x0004;
 2-519 . 
 2-520 . if (A le B)
 2-521 . {
 2-522 .    A = B + C;
 2-523 .    D = E + F;
 2-524 . }
 2-525 . 
 2-526 . A = 0x0008;
 2-527 . 
 2-528 . if (A >  B)
 2-529 . {
 2-530 .    A = B + C;
 2-531 .    D = E + F;
 2-532 . }
 2-533 . 
 2-534 . 
 2-535 . if (A le B)
 2-536 . {
 2-537 .    A = B + C;
 2-538 .    D = E + F;
 2-539 . }
 2-540 . 
 2-541 . A = B*C;
 2-542 . send_buffer = (U16 *) malloc(size+1);
 2-543 . 
 2-544 . if (A eq B)
 2-545 . {
 2-546 .    A = B + C;
 2-547 .    D = E + F;
 2-548 . }
 2-549 . 
 2-550 . A = B/C;
 2-551 . A = B-C;
 2-552 . 
 2-553 . if (A ne B)
 2-554 . {
 2-555 .    A = B + C;
 2-556 .    D = E + F;
 2-557 . }
 2-558 . 
 2-559 . A = B/C;
 2-560 . A = B/C;
 2-561 . 
 2-562 . if (A ge B)
 2-563 . {
 2-564 .    A = B + C;
 2-565 .    D = E + F;
 2-566 . }
 2-567 . 
 2-568 . 
 2-569 . if (A != B)
 2-570 . {
 2-571 .    A = B + C;
 2-572 .    D = E + F;
 2-573 . }
 2-574 . 
 2-575 . A = B/C;
 2-576 . 
 2-577 . if (A <  B)
 2-578 . {
 2-579 .    A = B + C;
 2-580 .    D = E + F;
 2-581 . }
 2-582 . 
 2-583 . A = B*C;
 2-584 . A = B/C;
 2-585 . 
 2-586 . if (A ne B)
 2-587 . {
 2-588 .    A = B + C;
 2-589 .    D = E + F;
 2-590 . }
 2-591 . 
 2-592 . A = B/C;
 2-593 . 
 2-594 . if (A gt B)
 2-595 . {
 2-596 .    A = B + C;
 2-597 .    D = E + F;
 2-598 . }
 2-599 . 
 2-600 . A = B+C;
 2-601 . /* dead_code = A * B; */
 2-602 . A = B*C;
 2-603 . A = B-C;
 2-604 . A = B+C;
 2-605 . A = B+C;
 2-606 . A = B-C;
 2-607 . A = B+C;
 2-608 . A = B/C;
 2-609 . 
 2-610 . if (A <  B)
 2-611 . {
 2-612 .    A = B + C;
 2-613 .    D = E + F;
 2-614 . }
 2-615 . 
 2-616 . A = B+C;
 2-617 . A = B+C;
 2-618 . 
 2-619 . switch (ca stuff)
 2-620 . {
 2-621 .    case one:
 2-622 .    {
 2-623 .       run_this; 
 2-624 .       // missing break
 2-625 .    }
 2-626 .    case two:
 2-627 .    {
 2-628 .       run_this;
 2-629 .       break;
 2-630 .    }
 2-631 .    default:
 2-632 .    {
 2-633 .       SwError;
 2-634 .    }
 2-635 . }
 2-636 . 
 2-637 . A = B*C;
 2-638 . A = B+C;
 2-639 . 
 2-640 . if (A <  B)
 2-641 . {
 2-642 .    A = B + C;
 2-643 .    D = E + F;
 2-644 . }
 2-645 . 
 2-646 . 
 2-647 . if (A == B)
 2-648 . {
 2-649 .    A = B + C;
 2-650 .    D = E + F;
 2-651 . }
 2-652 . 
 2-653 . A = B/C;
 2-654 . A = B-C;
 2-655 . 
 2-656 . if (A == B)
 2-657 . {
 2-658 .    A = B + C;
 2-659 .    D = E + F;
 2-660 . }
 2-661 . 
 2-662 . 
 2-663 . if (A le B)
 2-664 . {
 2-665 .    A = B + C;
 2-666 .    D = E + F;
 2-667 . }
 2-668 . 
 2-669 . 
 2-670 . if (A le B)
 2-671 . {
 2-672 .    A = B + C;
 2-673 .    D = E + F;
 2-674 . }
 2-675 . 
 2-676 . A = B+C;
 2-677 . // max LOC 57
 2-678 . 
 2-679 . }
 2-680 . 
 2-681 . 
 2-682 . /*
 2-683 . -----------------------------------------------------------------------------
 2-684 . --| NAME:   ca.2.4
 2-685 . --|
 2-686 . --| ABSTRACT:
 2-687 . --|   This function does ca stuff.
 2-688 . --|
 2-689 . --| RETURNS:
 2-690 . --|   NONE.
 2-691 . --|
 2-692 . ----------------------------------------------------------------------------
 2-693 . */
 2-694 . static void ca.2.4(void)
 2-695 . {
 2-696 . A = B+C;
 2-697 . /* LE SV TOC-1038 this is a ca-02.4.2 req to halt*/
 2-698 . A = B+C;
 2-699 . 
 2-700 . if (A != B)
 2-701 . {
 2-702 .    A = B + C;
 2-703 .    D = E + F;
 2-704 . }
 2-705 . 
 2-706 . A = 0x0006;
 2-707 . 
 2-708 . if (A > = B)
 2-709 . {
 2-710 .    A = B + C;
 2-711 .    D = E + F;
 2-712 . }
 2-713 . 
 2-714 . A = B-C;
 2-715 . A = B/C;
 2-716 . 
 2-717 . if (A > = B)
 2-718 . {
 2-719 .    A = B + C;
 2-720 .    D = E + F;
 2-721 . }
 2-722 . 
 2-723 . A = B/C;
 2-724 . A = B*C;
 2-725 . A = B/C;
 2-726 . /* LE SV TOC-1039 this is a ca-02.4.11 req to increment*/
 2-727 . A = B+C;
 2-728 . A = B/C;
 2-729 . 
 2-730 . if (A >  B)
 2-731 . {
 2-732 .    A = B + C;
 2-733 .    D = E + F;
 2-734 . }
 2-735 . 
 2-736 . A = B-C;
 2-737 . A = B+C;
 2-738 . A = B-C;
 2-739 . A = B/C;
 2-740 . A = B+C;
 2-741 . A = B+C;
 2-742 . A = B-C;
 2-743 . A = B*C;
 2-744 . 
 2-745 . if (A gt B)
 2-746 . {
 2-747 .    A = B + C;
 2-748 .    D = E + F;
 2-749 . }
 2-750 . 
 2-751 . FreePtr = HmiStringPtr;
 2-752 . 
 2-753 . if (A > = B)
 2-754 . {
 2-755 .    A = B + C;
 2-756 .    D = E + F;
 2-757 . }
 2-758 . 
 2-759 . 
 2-760 . if (A < = B)
 2-761 . {
 2-762 .    A = B + C;
 2-763 .    D = E + F;
 2-764 . }
 2-765 . 
 2-766 . A = B/C;
 2-767 . /* LE SV TOC-1040 this is a ca-02.4.26 req to check unix*/
 2-768 . 
 2-769 . switch (ca stuff)
 2-770 . {
 2-771 .    case one:
 2-772 .    {
 2-773 .       run_this; 
 2-774 .       break;
 2-775 .    }
 2-776 .    case two:
 2-777 .    {
 2-778 .       run_this;
 2-779 .       break;
 2-780 .    }
 2-781 .    default:
 2-782 .    {
 2-783 .        SwError;
 2-784 .    }
 2-785 . }
 2-786 . 
 2-787 . A = B/C;
 2-788 . 
 2-789 . if (A lt B)
 2-790 . {
 2-791 .    A = B + C;
 2-792 .    D = E + F;
 2-793 . }
 2-794 . 
 2-795 . 
 2-796 . if (A >  B)
 2-797 . {
 2-798 .    A = B + C;
 2-799 .    D = E + F;
 2-800 . }
 2-801 . 
 2-802 . 
 2-803 . if (A lt B)
 2-804 . {
 2-805 .    A = B + C;
 2-806 .    D = E + F;
 2-807 . }
 2-808 . 
 2-809 . A = B+C;
 2-810 . 
 2-811 . if (A lt B)
 2-812 . {
 2-813 .    A = B + C;
 2-814 .    D = E + F;
 2-815 . }
 2-816 . 
 2-817 . 
 2-818 . if (A > = B)
 2-819 . {
 2-820 .    A = B + C;
 2-821 .    D = E + F;
 2-822 . }
 2-823 . 
 2-824 . 
 2-825 . if (A ne B)
 2-826 . {
 2-827 .    A = B + C;
 2-828 .    D = E + F;
 2-829 . }
 2-830 . 
 2-831 . A = B-C;
 2-832 . A = B-C;
 2-833 . A = B+C;
 2-834 . A = B/C;
 2-835 . 
 2-836 . if (A eq B)
 2-837 . {
 2-838 .    A = B + C;
 2-839 .    D = E + F;
 2-840 . }
 2-841 . 
 2-842 . 
 2-843 . if (A ge B)
 2-844 . {
 2-845 .    A = B + C;
 2-846 .    D = E + F;
 2-847 . }
 2-848 . 
 2-849 . /* LE SV TOC-1041 this is a ca-02.4.41 req to halt*/
 2-850 . 
 2-851 . if (A ne B)
 2-852 . {
 2-853 .    A = B + C;
 2-854 .    D = E + F;
 2-855 . }
 2-856 . 
 2-857 . A = B+C;
 2-858 . /* LE SV TOC-1042 this is a ca-02.4.43 req to audit*/
 2-859 . A = B*C;
 2-860 . 
 2-861 . if (A == B)
 2-862 . {
 2-863 .    A = B + C;
 2-864 .    D = E + F;
 2-865 . }
 2-866 . 
 2-867 . 
 2-868 . switch (ca stuff)
 2-869 . {
 2-870 .    case:
 2-871 .    case:
 2-872 .    // stacked case statements but only if there is a new line in between
 2-873 . 
 2-874 .    case:
 2-875 .    case:
 2-876 .    case:
 2-877 .    {
 2-878 .       run_this;
 2-879 .       break;
 2-880 .    }
 2-881 .    default:
 2-882 .    {
 2-883 .       halt;
 2-884 .    }
 2-885 . }
 2-886 . 
 2-887 . A = B-C;
 2-888 . A = B+C;
 2-889 . 
 2-890 . if (A > = B)
 2-891 . {
 2-892 .    A = B + C;
 2-893 .    D = E + F;
 2-894 . }
 2-895 . 
 2-896 . /* LE SV TOC-1043 this is a ca-02.4.48 req to check pSOS*/
 2-897 . A = B*C;
 2-898 . A = B-C;
 2-899 . A = 0x0006;
 2-900 . 
 2-901 . if (A == B)
 2-902 . {
 2-903 .    A = B + C;
 2-904 .    D = E + F;
 2-905 . }
 2-906 . 
 2-907 . A = B*C;
 2-908 . A = B+C;
 2-909 . A = B+C;
 2-910 . A = B-C;
 2-911 . A = B*C;
 2-912 . A = B-C;
 2-913 . A = B*C;
 2-914 . 
 2-915 . if (A le B)
 2-916 . {
 2-917 .    A = B + C;
 2-918 .    D = E + F;
 2-919 . }
 2-920 . 
 2-921 . A = B+C;
 2-922 . A = B/C;
 2-923 . A = B*C;
 2-924 . A = B*C;
 2-925 . A = B*C;
 2-926 . 
 2-927 . /* dead_code = B + C; 
 2-928 . dead_code = D + E; 
 2-929 . dead_code = F + G; */
 2-930 . 
 2-931 . A = B-C;
 2-932 . 
 2-933 . switch (ca stuff)
 2-934 . {
 2-935 .    case one:
 2-936 .    {
 2-937 .       run_this; 
 2-938 .       break;
 2-939 .    }
 2-940 .    case two:
 2-941 .    {
 2-942 .       run_this;
 2-943 .       break;
 2-944 .    }
 2-945 .    default:
 2-946 .    {
 2-947 .        SwError;
 2-948 .    }
 2-949 . }
 2-950 . 
 2-951 . 
 2-952 . if (A eq B)
 2-953 . {
 2-954 .    A = B + C;
 2-955 .    D = E + F;
 2-956 . }
 2-957 . 
 2-958 . A = B*C;
 2-959 . A = B-C;
 2-960 . 
 2-961 . if (A < = B)
 2-962 . {
 2-963 .    A = B + C;
 2-964 .    D = E + F;
 2-965 . }
 2-966 . 
 2-967 . A = B/C;
 2-968 . A = B*C;
 2-969 . A = B/C;
 2-970 . A = B+C;
 2-971 . A = B-C;
 2-972 . A = B/C;
 2-973 . A = B+C;
 2-974 . 
 2-975 . if ($ca stuff >  $otherca stuff) 
 2-976 . /* LE SV TOC-008 we really should log all error calls */
 2-977 . {
 2-978 .    A = B + C;
 2-979 . }
 2-980 . 
 2-981 . 
 2-982 . switch (ca stuff)
 2-983 . {
 2-984 .    case one:
 2-985 .    {
 2-986 .       run_this; 
 2-987 .       break;
 2-988 .    }
 2-989 .    case two:
 2-990 .    {
 2-991 .       run_this;
 2-992 .       break;
 2-993 .    }
 2-994 .    default:
 2-995 .    {
 2-996 .        SwError;
 2-997 .    }
 2-998 . }
 2-999 . 
 2-1000 . A = B+C;
 2-1001 . /* LE SV TOC-1044 this is a ca-02.4.79 req to recover*/
 2-1002 . 
 2-1003 . switch (ca stuff)
 2-1004 . {
 2-1005 .    case one:
 2-1006 .    {
 2-1007 .       run_this;
 2-1008 .       break;
 2-1009 .    }
 2-1010 .    case two:
 2-1011 .    {
 2-1012 .       run_this;
 2-1013 .       break;
 2-1014 .    }
 2-1015 .    // missing default
 2-1016 . }
 2-1017 . 
 2-1018 . A = B-C;
 2-1019 . A = B/C;
 2-1020 . 
 2-1021 . if (A != B)
 2-1022 . {
 2-1023 .    A = B + C;
 2-1024 .    D = E + F;
 2-1025 . }
 2-1026 . 
 2-1027 . A = B/C;
 2-1028 . // (P) this is really improtant
 2-1029 . A = B+C;
 2-1030 . 
 2-1031 . if (A le B)
 2-1032 . {
 2-1033 .    A = B + C;
 2-1034 .    D = E + F;
 2-1035 . }
 2-1036 . 
 2-1037 . 
 2-1038 . if (A gt B)
 2-1039 . {
 2-1040 .    A = B + C;
 2-1041 .    D = E + F;
 2-1042 . }
 2-1043 . 
 2-1044 . // max LOC 85
 2-1045 . 
 2-1046 . }
 2-1047 . 
 2-1048 . 
 2-1049 . /*
 2-1050 . -----------------------------------------------------------------------------
 2-1051 . --| NAME:   ca.2.5
 2-1052 . --|
 2-1053 . --| ABSTRACT:
 2-1054 . --|   This function does ca stuff.
 2-1055 . --|
 2-1056 . --| RETURNS:
 2-1057 . --|   NONE.
 2-1058 . --|
 2-1059 . ----------------------------------------------------------------------------
 2-1060 . */
 2-1061 . static void ca.2.5(void)
 2-1062 . {
 2-1063 . A = B+C;
 2-1064 . A = B*C;
 2-1065 . A = B*C;
 2-1066 . 
 2-1067 . if (A >  B)
 2-1068 . {
 2-1069 .    A = B + C;
 2-1070 .    D = E + F;
 2-1071 . }
 2-1072 . 
 2-1073 . A = B*C;
 2-1074 . A = B+C;
 2-1075 . A = B+C;
 2-1076 . 
 2-1077 . if (A lt B)
 2-1078 . {
 2-1079 .    A = B + C;
 2-1080 .    D = E + F;
 2-1081 . }
 2-1082 . 
 2-1083 . A = B/C;
 2-1084 . 
 2-1085 . switch (ca stuff)
 2-1086 . {
 2-1087 .    case one:
 2-1088 .    {
 2-1089 .       run_this; 
 2-1090 .       break;
 2-1091 .    }
 2-1092 .    case two:
 2-1093 .    {
 2-1094 .       run_this;
 2-1095 .       break;
 2-1096 .    }
 2-1097 .    default:
 2-1098 .    {
 2-1099 .        SwError;
 2-1100 .    }
 2-1101 . }
 2-1102 . 
 2-1103 . A = B/C;
 2-1104 . 
 2-1105 . if (A == B)
 2-1106 . {
 2-1107 .    A = B + C;
 2-1108 .    D = E + F;
 2-1109 . }
 2-1110 . 
 2-1111 . A = B*C;
 2-1112 . A = B/C;
 2-1113 . A = B+C;
 2-1114 . A = B-C;
 2-1115 . A = B-C;
 2-1116 . A = B+C;
 2-1117 . 
 2-1118 . if (veg)
 2-1119 .    // missing curly brace
 2-1120 .    variable = orange;
 2-1121 . 
 2-1122 . A = B*C;
 2-1123 . 
 2-1124 . if (A < = B)
 2-1125 . {
 2-1126 .    A = B + C;
 2-1127 .    D = E + F;
 2-1128 . }
 2-1129 . 
 2-1130 . A = B/C;
 2-1131 . A = B+C;
 2-1132 . A = B-C;
 2-1133 . A = B-C;
 2-1134 . A = B-C;
 2-1135 . A = B+C;
 2-1136 . /* LE SV TOC-1045 this is a ca-02.5.27 req to call admin*/
 2-1137 . 
 2-1138 . if (A le B)
 2-1139 . {
 2-1140 .    A = B + C;
 2-1141 .    D = E + F;
 2-1142 . }
 2-1143 . 
 2-1144 . A = B*C;
 2-1145 . A = B/C;
 2-1146 . 
 2-1147 . if (A < = B)
 2-1148 . {
 2-1149 .    A = B + C;
 2-1150 .    D = E + F;
 2-1151 . }
 2-1152 . 
 2-1153 . A = B*C;
 2-1154 . A = B-C;
 2-1155 . 
 2-1156 . if (A <  B)
 2-1157 . {
 2-1158 .    A = B + C;
 2-1159 .    D = E + F;
 2-1160 . }
 2-1161 . 
 2-1162 . A = B/C;
 2-1163 . A = B+C;
 2-1164 . 
 2-1165 . if (A <  B)
 2-1166 . {
 2-1167 .    A = B + C;
 2-1168 .    D = E + F;
 2-1169 . }
 2-1170 . 
 2-1171 . A = B*C;
 2-1172 . 
 2-1173 . if (A == B)
 2-1174 . {
 2-1175 .    A = B + C;
 2-1176 .    D = E + F;
 2-1177 . }
 2-1178 . 
 2-1179 . /* LE SV TOC-1046 this is a ca-02.5.39 req to set Real Time Clock*/
 2-1180 . 
 2-1181 . if (A le B)
 2-1182 . {
 2-1183 .    A = B + C;
 2-1184 .    D = E + F;
 2-1185 . }
 2-1186 . 
 2-1187 . A = B+C;
 2-1188 . 
 2-1189 . if (A > = B)
 2-1190 . {
 2-1191 .    A = B + C;
 2-1192 .    D = E + F;
 2-1193 . }
 2-1194 . 
 2-1195 . 
 2-1196 . if (A > = B)
 2-1197 . {
 2-1198 .    A = B + C;
 2-1199 .    D = E + F;
 2-1200 . }
 2-1201 . 
 2-1202 . A = B+C;
 2-1203 . A = B-C;
 2-1204 . A = B*C;
 2-1205 . A = B*C;
 2-1206 . A = B+C;
 2-1207 . A = B+C;
 2-1208 . 
 2-1209 . /* 
 2-1210 . dead_code = B - C; 
 2-1211 . dead_code = D - E; 
 2-1212 . dead_code = F - G;
 2-1213 . */
 2-1214 . 
 2-1215 . A = B-C;
 2-1216 . A = B-C;
 2-1217 . A = B/C;
 2-1218 . A = B*C;
 2-1219 . FreePtr = HmiStringPtr;
 2-1220 . 
 2-1221 . if (A gt B)
 2-1222 . {
 2-1223 .    A = B + C;
 2-1224 .    D = E + F;
 2-1225 . }
 2-1226 . 
 2-1227 . A = 0x0004;
 2-1228 . A = B+C;
 2-1229 . A = B-C;
 2-1230 . 
 2-1231 . switch (ca stuff)
 2-1232 . {
 2-1233 .    case:
 2-1234 .    case:
 2-1235 .    // stacked case statements but only if there is a new line in between
 2-1236 . 
 2-1237 .    case:
 2-1238 .    case:
 2-1239 .    case:
 2-1240 .    {
 2-1241 .       run_this;
 2-1242 .       break;
 2-1243 .    }
 2-1244 .    default:
 2-1245 .    {
 2-1246 .       halt;
 2-1247 .    }
 2-1248 . }
 2-1249 . 
 2-1250 . A = B/C;
 2-1251 . A = B+C;
 2-1252 . 
 2-1253 . if (A != B)
 2-1254 . {
 2-1255 .    A = B + C;
 2-1256 .    D = E + F;
 2-1257 . }
 2-1258 . 
 2-1259 . A = B*C;
 2-1260 . A = B*C;
 2-1261 . A = B*C;
 2-1262 . A = B+C;
 2-1263 . 
 2-1264 . if (A < = B)
 2-1265 . {
 2-1266 .    A = B + C;
 2-1267 .    D = E + F;
 2-1268 . }
 2-1269 . 
 2-1270 . A = B+C;
 2-1271 . 
 2-1272 . if (A <  B)
 2-1273 . {
 2-1274 .    A = B + C;
 2-1275 .    D = E + F;
 2-1276 . }
 2-1277 . 
 2-1278 . 
 2-1279 . if (A <  B)
 2-1280 . {
 2-1281 .    A = B + C;
 2-1282 .    D = E + F;
 2-1283 . }
 2-1284 . 
 2-1285 . A = B*C;
 2-1286 . A = B*C;
 2-1287 . A = B-C;
 2-1288 . 
 2-1289 . if (A != B)
 2-1290 . {
 2-1291 .    A = B + C;
 2-1292 .    D = E + F;
 2-1293 . }
 2-1294 . 
 2-1295 . // ??? go see ws
 2-1296 . A = B*C;
 2-1297 . // max LOC 71
 2-1298 . 
 2-1299 . }
 2-1300 . 
 2-1301 . 
 2-1302 . /*
 2-1303 . -----------------------------------------------------------------------------
 2-1304 . --| NAME:   ca.2.6
 2-1305 . --|
 2-1306 . --| ABSTRACT:
 2-1307 . --|   This function does ca stuff.
 2-1308 . --|
 2-1309 . --| RETURNS:
 2-1310 . --|   NONE.
 2-1311 . --|
 2-1312 . ----------------------------------------------------------------------------
 2-1313 . */
 2-1314 . static void ca.2.6(void)
 2-1315 . {
 2-1316 . 
 2-1317 . if (A ne B)
 2-1318 . {
 2-1319 .    A = B + C;
 2-1320 .    D = E + F;
 2-1321 . }
 2-1322 . 
 2-1323 . 
 2-1324 . if (A eq B)
 2-1325 . {
 2-1326 .    A = B + C;
 2-1327 .    D = E + F;
 2-1328 . }
 2-1329 . 
 2-1330 . 
 2-1331 . if (A lt B)
 2-1332 . {
 2-1333 .    A = B + C;
 2-1334 .    D = E + F;
 2-1335 . }
 2-1336 . 
 2-1337 . 
 2-1338 . if (A lt B)
 2-1339 . {
 2-1340 .    A = B + C;
 2-1341 .    D = E + F;
 2-1342 . }
 2-1343 . 
 2-1344 . 
 2-1345 . if (A lt B)
 2-1346 . {
 2-1347 .    A = B + C;
 2-1348 .    D = E + F;
 2-1349 . }
 2-1350 . 
 2-1351 . 
 2-1352 . switch (ca stuff)
 2-1353 . {
 2-1354 .    case one:
 2-1355 .    {
 2-1356 .       switch (nested)
 2-1357 .       {
 2-1358 .          case:
 2-1359 .             X = Y + Z;
 2-1360 .          case:
 2-1361 .             X = Y + Z;
 2-1362 .          default:
 2-1363 .             SwError;
 2-1364 .       } 
 2-1365 .    }
 2-1366 .    case two:
 2-1367 .    {
 2-1368 .       run_this;
 2-1369 .       break;
 2-1370 .    }
 2-1371 .    default:
 2-1372 .    {
 2-1373 .       SwError;
 2-1374 .    }
 2-1375 . }
 2-1376 . 
 2-1377 . A = B/C;
 2-1378 . A = B*C;
 2-1379 . goto error;
 2-1380 . A = B+C;
 2-1381 . A = B+C;
 2-1382 . 
 2-1383 . if (A ge B)
 2-1384 . {
 2-1385 .    A = B + C;
 2-1386 .    D = E + F;
 2-1387 . }
 2-1388 . 
 2-1389 . A = B-C;
 2-1390 . A = 0x0002;
 2-1391 . A = B/C;
 2-1392 . A = B+C;
 2-1393 . A = B*C;
 2-1394 . // max LOC 14
 2-1395 . 
 2-1396 . }
 2-1397 . 
 2-1398 . 
 2-1399 . /*
 2-1400 . -----------------------------------------------------------------------------
 2-1401 . --| NAME:   ca.2.7
 2-1402 . --|
 2-1403 . --| ABSTRACT:
 2-1404 . --|   This function does ca stuff.
 2-1405 . --|
 2-1406 . --| RETURNS:
 2-1407 . --|   NONE.
 2-1408 . --|
 2-1409 . ----------------------------------------------------------------------------
 2-1410 . */
 2-1411 . static void ca.2.7(void)
 2-1412 . {
 2-1413 . 
 2-1414 . if (A == B)
 2-1415 . {
 2-1416 .    A = B + C;
 2-1417 .    D = E + F;
 2-1418 . }
 2-1419 . 
 2-1420 . send_buffer = (U16 *) malloc(size+1);
 2-1421 . 
 2-1422 . if (A ne B)
 2-1423 . {
 2-1424 .    A = B + C;
 2-1425 .    D = E + F;
 2-1426 . }
 2-1427 . 
 2-1428 . A = B-C;
 2-1429 . 
 2-1430 . if (A ge B)
 2-1431 . {
 2-1432 .    A = B + C;
 2-1433 .    D = E + F;
 2-1434 . }
 2-1435 . 
 2-1436 . A = B+C;
 2-1437 . A = B*C;
 2-1438 . 
 2-1439 . if (A == B)
 2-1440 . {
 2-1441 .    A = B + C;
 2-1442 .    D = E + F;
 2-1443 . }
 2-1444 . 
 2-1445 . 
 2-1446 . if (A != B)
 2-1447 . {
 2-1448 .    A = B + C;
 2-1449 .    D = E + F;
 2-1450 . }
 2-1451 . 
 2-1452 . A = B/C;
 2-1453 . 
 2-1454 . if (A != B)
 2-1455 . {
 2-1456 .    A = B + C;
 2-1457 .    D = E + F;
 2-1458 . }
 2-1459 . 
 2-1460 . A = B*C;
 2-1461 . A = B/C;
 2-1462 . 
 2-1463 . if (A gt B)
 2-1464 . {
 2-1465 .    A = B + C;
 2-1466 .    D = E + F;
 2-1467 . }
 2-1468 . 
 2-1469 . A = B/C;
 2-1470 . 
 2-1471 . if (A > = B)
 2-1472 . {
 2-1473 .    A = B + C;
 2-1474 .    D = E + F;
 2-1475 . }
 2-1476 . 
 2-1477 . 
 2-1478 . if (A le B)
 2-1479 . {
 2-1480 .    A = B + C;
 2-1481 .    D = E + F;
 2-1482 . }
 2-1483 . 
 2-1484 . A = B-C;
 2-1485 . A = B+C;
 2-1486 . 
 2-1487 . if (A gt B)
 2-1488 . {
 2-1489 .    A = B + C;
 2-1490 .    D = E + F;
 2-1491 . }
 2-1492 . 
 2-1493 . do forever;
 2-1494 . A = B-C;
 2-1495 . A = B-C;
 2-1496 . A = B+C;
 2-1497 . A = B+C;
 2-1498 . A = B*C;
 2-1499 . A = B*C;
 2-1500 . A = B/C;
 2-1501 . A = B/C;
 2-1502 . A = B*C;
 2-1503 . A = B/C;
 2-1504 . 
 2-1505 . if (A eq B)
 2-1506 . {
 2-1507 .    A = B + C;
 2-1508 .    D = E + F;
 2-1509 . }
 2-1510 . 
 2-1511 . A = B*C;
 2-1512 . /* LE SV TOC-1047 this is a ca-02.7.32 req to increment*/
 2-1513 . 
 2-1514 . /*
 2-1515 . dead_block = C * D; 
 2-1516 . dead_block = E * F;
 2-1517 . */
 2-1518 . 
 2-1519 . A = B+C;
 2-1520 . 
 2-1521 . if (A <  B)
 2-1522 . {
 2-1523 .    A = B + C;
 2-1524 .    D = E + F;
 2-1525 . }
 2-1526 . 
 2-1527 . A = B+C;
 2-1528 . A = B*C;
 2-1529 . 
 2-1530 . if (A lt B)
 2-1531 . {
 2-1532 .    A = B + C;
 2-1533 .    D = E + F;
 2-1534 . }
 2-1535 . 
 2-1536 . 
 2-1537 . switch (ca stuff)
 2-1538 . {
 2-1539 .    case:
 2-1540 .    case:
 2-1541 .    // stacked case statements but only if there is a new line in between
 2-1542 . 
 2-1543 .    case:
 2-1544 .    case:
 2-1545 .    case:
 2-1546 .    {
 2-1547 .       run_this;
 2-1548 .       break;
 2-1549 .    }
 2-1550 .    default:
 2-1551 .    {
 2-1552 .       halt;
 2-1553 .    }
 2-1554 . }
 2-1555 . 
 2-1556 . A = B/C;
 2-1557 . 
 2-1558 . if (A ne B)
 2-1559 . {
 2-1560 .    A = B + C;
 2-1561 .    D = E + F;
 2-1562 . }
 2-1563 . 
 2-1564 . A = B*C;
 2-1565 . A = B-C;
 2-1566 . 
 2-1567 . if (A le B)
 2-1568 . {
 2-1569 .    A = B + C;
 2-1570 .    D = E + F;
 2-1571 . }
 2-1572 . 
 2-1573 . A = B*C;
 2-1574 . A = B*C;
 2-1575 . A = B/C;
 2-1576 . 
 2-1577 . if (A ge B)
 2-1578 . {
 2-1579 .    A = B + C;
 2-1580 .    D = E + F;
 2-1581 . }
 2-1582 . 
 2-1583 . 
 2-1584 . if (A < = B)
 2-1585 . {
 2-1586 .    A = B + C;
 2-1587 .    D = E + F;
 2-1588 . }
 2-1589 . 
 2-1590 . 
 2-1591 . if (A > = B)
 2-1592 . {
 2-1593 .    A = B + C;
 2-1594 .    D = E + F;
 2-1595 . }
 2-1596 . 
 2-1597 . 
 2-1598 . if (A < = B)
 2-1599 . {
 2-1600 .    A = B + C;
 2-1601 .    D = E + F;
 2-1602 . }
 2-1603 . 
 2-1604 . 
 2-1605 . if (A >  B)
 2-1606 . {
 2-1607 .    A = B + C;
 2-1608 .    D = E + F;
 2-1609 . }
 2-1610 . 
 2-1611 . A = B*C;
 2-1612 . 
 2-1613 . if (A le B)
 2-1614 . {
 2-1615 .    A = B + C;
 2-1616 .    D = E + F;
 2-1617 . }
 2-1618 . 
 2-1619 . 
 2-1620 . if (A == B)
 2-1621 . {
 2-1622 .    A = B + C;
 2-1623 .    D = E + F;
 2-1624 . }
 2-1625 . 
 2-1626 . A = B+C;
 2-1627 . A = B+C;
 2-1628 . A = B-C;
 2-1629 . A = B/C;
 2-1630 . 
 2-1631 . if (A eq B)
 2-1632 . {
 2-1633 .    A = B + C;
 2-1634 .    D = E + F;
 2-1635 . }
 2-1636 . 
 2-1637 . 
 2-1638 . if (A eq B)
 2-1639 . {
 2-1640 .    A = B + C;
 2-1641 .    D = E + F;
 2-1642 . }
 2-1643 . 
 2-1644 . A = B*C;
 2-1645 . /* LE SV TOC-1048 this is a ca-02.7.60 req to set RTC*/
 2-1646 . 
 2-1647 . if (A ne B)
 2-1648 . {
 2-1649 .    A = B + C;
 2-1650 .    D = E + F;
 2-1651 . }
 2-1652 . 
 2-1653 . A = B+C;
 2-1654 . A = B-C;
 2-1655 . /* LE SV TOC-1049 this is a ca-02.7.63 req to disable*/
 2-1656 . A = B+C;
 2-1657 . A = B*C;
 2-1658 . A = B*C;
 2-1659 . A = B-C;
 2-1660 . A = B*C;
 2-1661 . A = B-C;
 2-1662 . A = B+C;
 2-1663 . 
 2-1664 . if (A ne B)
 2-1665 . {
 2-1666 .    A = B + C;
 2-1667 .    D = E + F;
 2-1668 . }
 2-1669 . 
 2-1670 . 
 2-1671 . if (A ge B)
 2-1672 . {
 2-1673 .    A = B + C;
 2-1674 .    D = E + F;
 2-1675 . }
 2-1676 . 
 2-1677 . A = B+C;
 2-1678 . A = B-C;
 2-1679 . A = B/C;
 2-1680 . A = B*C;
 2-1681 . 
 2-1682 . if (A < = B)
 2-1683 . {
 2-1684 .    A = B + C;
 2-1685 .    D = E + F;
 2-1686 . }
 2-1687 . 
 2-1688 . A = B+C;
 2-1689 . 
 2-1690 . switch (ca stuff)
 2-1691 . {
 2-1692 .    case one:
 2-1693 .    {
 2-1694 .       run_this; 
 2-1695 .       // missing break
 2-1696 .    }
 2-1697 .    case two:
 2-1698 .    {
 2-1699 .       run_this;
 2-1700 .       break;
 2-1701 .    }
 2-1702 .    default:
 2-1703 .    {
 2-1704 .       SwError;
 2-1705 .    }
 2-1706 . }
 2-1707 . 
 2-1708 . A = B*C;
 2-1709 . 
 2-1710 . if (A le B)
 2-1711 . {
 2-1712 .    A = B + C;
 2-1713 .    D = E + F;
 2-1714 . }
 2-1715 . 
 2-1716 . A = B*C;
 2-1717 . // max LOC 80
 2-1718 . 
 2-1719 . }
 2-1720 . 
 2-1721 . 
 2-1722 . /*
 2-1723 . -----------------------------------------------------------------------------
 2-1724 . --| NAME:   ca.2.8
 2-1725 . --|
 2-1726 . --| ABSTRACT:
 2-1727 . --|   This function does ca stuff.
 2-1728 . --|
 2-1729 . --| RETURNS:
 2-1730 . --|   NONE.
 2-1731 . --|
 2-1732 . ----------------------------------------------------------------------------
 2-1733 . */
 2-1734 . static void ca.2.8(void)
 2-1735 . {
 2-1736 . A = B*C;
 2-1737 . 
 2-1738 . if (A != B)
 2-1739 . {
 2-1740 .    A = B + C;
 2-1741 .    D = E + F;
 2-1742 . }
 2-1743 . 
 2-1744 . // ??? go see ws
 2-1745 . A = B-C;
 2-1746 . 
 2-1747 . if (A le B)
 2-1748 . {
 2-1749 .    A = B + C;
 2-1750 .    D = E + F;
 2-1751 . }
 2-1752 . 
 2-1753 . 
 2-1754 . switch (ca stuff)
 2-1755 . {
 2-1756 .    case one:
 2-1757 .    {
 2-1758 .       run_this; 
 2-1759 .       break;
 2-1760 .    }
 2-1761 .    case two:
 2-1762 .    {
 2-1763 .       run_this;
 2-1764 .       break;
 2-1765 .    }
 2-1766 .    default:
 2-1767 .    {
 2-1768 .        SwError;
 2-1769 .    }
 2-1770 . }
 2-1771 . 
 2-1772 . 
 2-1773 . if (A < = B)
 2-1774 . {
 2-1775 .    A = B + C;
 2-1776 .    D = E + F;
 2-1777 . }
 2-1778 . 
 2-1779 . 
 2-1780 . switch (ca stuff)
 2-1781 . {
 2-1782 .    case one:
 2-1783 .    {
 2-1784 .       run_this; 
 2-1785 .       break;
 2-1786 .    }
 2-1787 .    case two:
 2-1788 .    {
 2-1789 .       run_this;
 2-1790 .       break;
 2-1791 .    }
 2-1792 .    default:
 2-1793 .    {
 2-1794 .        SwError;
 2-1795 .    }
 2-1796 . }
 2-1797 . 
 2-1798 . A = B-C;
 2-1799 . 
 2-1800 . if (A lt B)
 2-1801 . {
 2-1802 .    A = B + C;
 2-1803 .    D = E + F;
 2-1804 . }
 2-1805 . 
 2-1806 . A = B/C;
 2-1807 . A = B-C;
 2-1808 . A = B-C;
 2-1809 . A = B-C;
 2-1810 . // max LOC 13
 2-1811 . 
 2-1812 . }
 2-1813 . 

2 2 Result: result/source/ft-app/ft-app-B1.1/ca/ca-02.c


3 3 Source: source/ft-app/ft-app-B1.1/ca/ca-03.c
 3-0 . /*
 3-1 . ----------------------------------------------------------------------------
 3-2 . --| BEGIN PROLOGUE
 3-3 . --|
 3-4 . --| CLASSIFICATION: UNCLASSIFIED
 3-5 . --|
 3-6 . --| FILE NAME:      ca-03.c
 3-7 . --|
 3-8 . --| ABSTRACT:
 3-9 . --|   This file contains the 2 functions that do file ca stuff.
 3-10 . --|
 3-11 . --| HISTORY:
 3-12 . --|   CCCQ_NAME:
 3-13 . --|   CCCQ_VER: 
 3-14 . --|
 3-15 . --| END PROLOGUE
 3-16 . ----------------------------------------------------------------------------
 3-17 . */
 3-18 . 
 3-19 . double C;
 3-20 . #include B;
 3-21 . #include B;
 3-22 . #define C;
 3-23 . 
 3-24 . 
 3-25 . 
 3-26 . /*
 3-27 . -----------------------------------------------------------------------------
 3-28 . --| NAME:   ca.3.1
 3-29 . --|
 3-30 . --| ABSTRACT:
 3-31 . --|   This function does ca stuff.
 3-32 . --|
 3-33 . --| RETURNS:
 3-34 . --|   NONE.
 3-35 . --|
 3-36 . ----------------------------------------------------------------------------
 3-37 . */
 3-38 . static void ca.3.1(void)
 3-39 . {
 3-40 . A = B/C;
 3-41 . A = B+C;
 3-42 . 
 3-43 . if (A gt B)
 3-44 . {
 3-45 .    A = B + C;
 3-46 .    D = E + F;
 3-47 . }
 3-48 . 
 3-49 . A = B-C;
 3-50 . A = B-C;
 3-51 . 
 3-52 . if (A != B)
 3-53 . {
 3-54 .    A = B + C;
 3-55 .    D = E + F;
 3-56 . }
 3-57 . 
 3-58 . A = B+C;
 3-59 . A = B/C;
 3-60 . A = B-C;
 3-61 . A = 0x0001;
 3-62 . A = B+C;
 3-63 . A = B-C;
 3-64 . 
 3-65 . if (A == B)
 3-66 . {
 3-67 .    A = B + C;
 3-68 .    D = E + F;
 3-69 . }
 3-70 . 
 3-71 . A = B*C;
 3-72 . A = B-C;
 3-73 . 
 3-74 . if (A >  B)
 3-75 . {
 3-76 .    A = B + C;
 3-77 .    D = E + F;
 3-78 . }
 3-79 . 
 3-80 . A = (long)B + C;
 3-81 . A = B-C;
 3-82 . A = B*C;
 3-83 . A = B/C;
 3-84 . 
 3-85 . if (A ge B)
 3-86 . {
 3-87 .    A = B + C;
 3-88 .    D = E + F;
 3-89 . }
 3-90 . 
 3-91 . // max LOC 19
 3-92 . 
 3-93 . }
 3-94 . 
 3-95 . 
 3-96 . /*
 3-97 . -----------------------------------------------------------------------------
 3-98 . --| NAME:   ca.3.2
 3-99 . --|
 3-100 . --| ABSTRACT:
 3-101 . --|   This function does ca stuff.
 3-102 . --|
 3-103 . --| RETURNS:
 3-104 . --|   NONE.
 3-105 . --|
 3-106 . ----------------------------------------------------------------------------
 3-107 . */
 3-108 . static void ca.3.2(void)
 3-109 . {
 3-110 . A = 0x0006;
 3-111 . 
 3-112 . if (A > = B)
 3-113 . {
 3-114 .    A = B + C;
 3-115 .    D = E + F;
 3-116 . }
 3-117 . 
 3-118 . 
 3-119 . if (A == B)
 3-120 . {
 3-121 .    A = B + C;
 3-122 .    D = E + F;
 3-123 . }
 3-124 . 
 3-125 . 
 3-126 . if (A > = B)
 3-127 . {
 3-128 .    A = B + C;
 3-129 .    D = E + F;
 3-130 . }
 3-131 . 
 3-132 . 
 3-133 . if (A >  B)
 3-134 . {
 3-135 .    A = B + C;
 3-136 .    D = E + F;
 3-137 . }
 3-138 . 
 3-139 . 
 3-140 . if (A != B)
 3-141 . {
 3-142 .    A = B + C;
 3-143 .    D = E + F;
 3-144 . }
 3-145 . 
 3-146 . A = B*C;
 3-147 . A = B/C;
 3-148 . 
 3-149 . if (A gt B)
 3-150 . {
 3-151 .    A = B + C;
 3-152 .    D = E + F;
 3-153 . }
 3-154 . 
 3-155 . A = B*C;
 3-156 . A = B*C;
 3-157 . A = B+C;
 3-158 . /* LE SV TOC-1050 this is a ca-03.2.12 req to call isr*/
 3-159 . A = B/C;
 3-160 . A = B/C;
 3-161 . A = B/C;
 3-162 . A = B+C;
 3-163 . // max LOC 15
 3-164 . 
 3-165 . }
 3-166 . 

3 3 Result: result/source/ft-app/ft-app-B1.1/ca/ca-03.c


4 4 Source: source/ft-app/ft-app-B1.1/ca/ca-04.c
 4-0 . /*
 4-1 . ----------------------------------------------------------------------------
 4-2 . --| BEGIN PROLOGUE
 4-3 . --|
 4-4 . --| CLASSIFICATION: UNCLASSIFIED
 4-5 . --|
 4-6 . --| FILE NAME:      ca-04.c
 4-7 . --|
 4-8 . --| ABSTRACT:
 4-9 . --|   This file contains the 1 functions that do file ca stuff.
 4-10 . --|
 4-11 . --| HISTORY:
 4-12 . --|   CCCQ_NAME:
 4-13 . --|   CCCQ_VER: 
 4-14 . --|
 4-15 . --| END PROLOGUE
 4-16 . ----------------------------------------------------------------------------
 4-17 . */
 4-18 . 
 4-19 . int A;
 4-20 . #define B;
 4-21 . #include D;
 4-22 . #include C;
 4-23 . #include D;
 4-24 . 
 4-25 . 
 4-26 . 
 4-27 . /*
 4-28 . -----------------------------------------------------------------------------
 4-29 . --| NAME:   ca.4.1
 4-30 . --|
 4-31 . --| ABSTRACT:
 4-32 . --|   This function does ca stuff.
 4-33 . --|
 4-34 . --| RETURNS:
 4-35 . --|   NONE.
 4-36 . --|
 4-37 . ----------------------------------------------------------------------------
 4-38 . */
 4-39 . static void ca.4.1(void)
 4-40 . {
 4-41 . A = B+C;
 4-42 . 
 4-43 . if (A < = B)
 4-44 . {
 4-45 .    A = B + C;
 4-46 .    D = E + F;
 4-47 . }
 4-48 . 
 4-49 . A = B+C;
 4-50 . A = B+C;
 4-51 . A = B/C;
 4-52 . A = B-C;
 4-53 . A = B*C;
 4-54 . A = B*C;
 4-55 . A = (long)B + C;
 4-56 . 
 4-57 . if (A != B)
 4-58 . {
 4-59 .    A = B + C;
 4-60 .    D = E + F;
 4-61 . }
 4-62 . 
 4-63 . A = B-C;
 4-64 . A = B+C;
 4-65 . A = B*C;
 4-66 . A = B/C;
 4-67 . A = B/C;
 4-68 . A = B-C;
 4-69 . 
 4-70 . if (A eq B)
 4-71 . {
 4-72 .    A = B + C;
 4-73 .    D = E + F;
 4-74 . }
 4-75 . 
 4-76 . 
 4-77 . if (A eq B)
 4-78 . {
 4-79 .    A = B + C;
 4-80 .    D = E + F;
 4-81 . }
 4-82 . 
 4-83 . A = B*C;
 4-84 . 
 4-85 . if (A ge B)
 4-86 . {
 4-87 .    A = B + C;
 4-88 .    D = E + F;
 4-89 . }
 4-90 . 
 4-91 . /* LE SV TOC-1051 this is a ca-04.1.20 req to process*/
 4-92 . A = B/C;
 4-93 . A = B-C;
 4-94 . A = B+C;
 4-95 . A = B/C;
 4-96 . A = B-C;
 4-97 . A = B*C;
 4-98 . A = B-C;
 4-99 . A = B*C;
 4-100 . 
 4-101 . if (A <  B)
 4-102 . {
 4-103 .    A = B + C;
 4-104 .    D = E + F;
 4-105 . }
 4-106 . 
 4-107 . A = B*C;
 4-108 . A = B-C;
 4-109 . 
 4-110 . if (A lt B)
 4-111 . {
 4-112 .    A = B + C;
 4-113 .    D = E + F;
 4-114 . }
 4-115 . 
 4-116 . 
 4-117 . if (A >  B)
 4-118 . {
 4-119 .    A = B + C;
 4-120 .    D = E + F;
 4-121 . }
 4-122 . 
 4-123 . A = B-C;
 4-124 . A = B*C;
 4-125 . A = B+C;
 4-126 . A = B/C;
 4-127 . A = B/C;
 4-128 . /* LE SV TOC-1052 this is a ca-04.1.38 req to check pSOS*/
 4-129 . A = B-C;
 4-130 . A = B*C;
 4-131 . /* LE SV TOC-1053 this is a ca-04.1.40 req to detect error*/
 4-132 . A = B*C;
 4-133 . /* LE SV TOC-1054 this is a ca-04.1.41 req to halt*/
 4-134 . A = B-C;
 4-135 . 
 4-136 . if (A ne B)
 4-137 . {
 4-138 .    A = B + C;
 4-139 .    D = E + F;
 4-140 . }
 4-141 . 
 4-142 . A = B-C;
 4-143 . A = B*C;
 4-144 . 
 4-145 . if (A ne B)
 4-146 . {
 4-147 .    A = B + C;
 4-148 .    D = E + F;
 4-149 . }
 4-150 . 
 4-151 . A = B-C;
 4-152 . A = B*C;
 4-153 . A = B/C;
 4-154 . 
 4-155 . switch (ca stuff)
 4-156 . {
 4-157 .    case one:
 4-158 .    {
 4-159 .       run_this; 
 4-160 .       break;
 4-161 .    }
 4-162 .    case two:
 4-163 .    {
 4-164 .       run_this;
 4-165 .       break;
 4-166 .    }
 4-167 .    default:
 4-168 .    {
 4-169 .        SwError;
 4-170 .    }
 4-171 . }
 4-172 . 
 4-173 . A = B/C;
 4-174 . A = B+C;
 4-175 . 
 4-176 . if (A >  B)
 4-177 . {
 4-178 .    A = B + C;
 4-179 .    D = E + F;
 4-180 . }
 4-181 . 
 4-182 . A = B/C;
 4-183 . 
 4-184 . if (A gt B)
 4-185 . {
 4-186 .    A = B + C;
 4-187 .    D = E + F;
 4-188 . }
 4-189 . 
 4-190 . A = B/C;
 4-191 . A = B-C;
 4-192 . A = B/C;
 4-193 . A = B*C;
 4-194 . A = B-C;
 4-195 . A = B/C;
 4-196 . 
 4-197 . if (A == B)
 4-198 . {
 4-199 .    A = B + C;
 4-200 .    D = E + F;
 4-201 . }
 4-202 . 
 4-203 . A = B+C;
 4-204 . A = B*C;
 4-205 . 
 4-206 . if (A > = B)
 4-207 . {
 4-208 .    A = B + C;
 4-209 .    D = E + F;
 4-210 . }
 4-211 . 
 4-212 . 
 4-213 . if (A ne B)
 4-214 . {
 4-215 .    A = B + C;
 4-216 .    D = E + F;
 4-217 . }
 4-218 . 
 4-219 . 
 4-220 . if (A ne B)
 4-221 . {
 4-222 .    A = B + C;
 4-223 .    D = E + F;
 4-224 . }
 4-225 . 
 4-226 . A = B*C;
 4-227 . 
 4-228 . if (A > = B)
 4-229 . {
 4-230 .    A = B + C;
 4-231 .    D = E + F;
 4-232 . }
 4-233 . 
 4-234 . A = B-C;
 4-235 . 
 4-236 . if (A le B)
 4-237 . {
 4-238 .    A = B + C;
 4-239 .    D = E + F;
 4-240 . }
 4-241 . 
 4-242 . A = B/C;
 4-243 . A = B-C;
 4-244 . A = B/C;
 4-245 . A = B-C;
 4-246 . A = B*C;
 4-247 . A = B/C;
 4-248 . A = B/C;
 4-249 . A = B+C;
 4-250 . A = B*C;
 4-251 . /* LE SV TOC-1055 this is a ca-04.1.80 req to reject*/
 4-252 . A = B/C;
 4-253 . 
 4-254 . if (A gt B)
 4-255 . {
 4-256 .    A = B + C;
 4-257 .    D = E + F;
 4-258 . }
 4-259 . 
 4-260 . A = B/C;
 4-261 . A = B-C;
 4-262 . // max LOC 83
 4-263 . 
 4-264 . }
 4-265 . 

4 4 Result: result/source/ft-app/ft-app-B1.1/ca/ca-04.c


5 5 Source: source/ft-app/ft-app-B1.1/ca/ca-05.c
 5-0 . /*
 5-1 . ----------------------------------------------------------------------------
 5-2 . --| BEGIN PROLOGUE
 5-3 . --|
 5-4 . --| CLASSIFICATION: UNCLASSIFIED
 5-5 . --|
 5-6 . --| FILE NAME:      ca-05.c
 5-7 . --|
 5-8 . --| ABSTRACT:
 5-9 . --|   This file contains the 8 functions that do file ca stuff.
 5-10 . --|
 5-11 . --| HISTORY:
 5-12 . --|   CCCQ_NAME:
 5-13 . --|   CCCQ_VER: 
 5-14 . --|
 5-15 . --| END PROLOGUE
 5-16 . ----------------------------------------------------------------------------
 5-17 . */
 5-18 . 
 5-19 . #define D;
 5-20 . #define D;
 5-21 . #include C;
 5-22 . #include A;
 5-23 . int A;
 5-24 . #include A;
 5-25 . #include D;
 5-26 . float B;
 5-27 . #define D;
 5-28 . 
 5-29 . 
 5-30 . 
 5-31 . /*
 5-32 . -----------------------------------------------------------------------------
 5-33 . --| NAME:   ca.5.1
 5-34 . --|
 5-35 . --| ABSTRACT:
 5-36 . --|   This function does ca stuff.
 5-37 . --|
 5-38 . --| RETURNS:
 5-39 . --|   NONE.
 5-40 . --|
 5-41 . ----------------------------------------------------------------------------
 5-42 . */
 5-43 . static void ca.5.1(void)
 5-44 . {
 5-45 . 
 5-46 . if (A eq B)
 5-47 . {
 5-48 .    A = B + C;
 5-49 .    D = E + F;
 5-50 . }
 5-51 . 
 5-52 . 
 5-53 . if (A ge B)
 5-54 . {
 5-55 .    A = B + C;
 5-56 .    D = E + F;
 5-57 . }
 5-58 . 
 5-59 . 
 5-60 . if (A != B)
 5-61 . {
 5-62 .    A = B + C;
 5-63 .    D = E + F;
 5-64 . }
 5-65 . 
 5-66 . A = B/C;
 5-67 . 
 5-68 . if (A > = B)
 5-69 . {
 5-70 .    A = B + C;
 5-71 .    D = E + F;
 5-72 . }
 5-73 . 
 5-74 . A = B-C;
 5-75 . A = B*C;
 5-76 . A = B+C;
 5-77 . 
 5-78 . if (A <  B)
 5-79 . {
 5-80 .    A = B + C;
 5-81 .    D = E + F;
 5-82 . }
 5-83 . 
 5-84 . A = B*C;
 5-85 . A = B+C;
 5-86 . A = B-C;
 5-87 . A = B+C;
 5-88 . 
 5-89 . if (A >  B)
 5-90 . {
 5-91 .    A = B + C;
 5-92 .    D = E + F;
 5-93 . }
 5-94 . 
 5-95 . 
 5-96 . if (A == B)
 5-97 . {
 5-98 .    A = B + C;
 5-99 .    D = E + F;
 5-100 . }
 5-101 . 
 5-102 . 
 5-103 . if (A ne B)
 5-104 . {
 5-105 .    A = B + C;
 5-106 .    D = E + F;
 5-107 . }
 5-108 . 
 5-109 . /* LE SV TOC-1056 this is a ca-05.1.17 req to increment*/
 5-110 . A = B-C;
 5-111 . A = B/C;
 5-112 . A = B+C;
 5-113 . A = 0x0008;
 5-114 . A = B*C;
 5-115 . A = B+C;
 5-116 . 
 5-117 . if (A eq B)
 5-118 . {
 5-119 .    A = B + C;
 5-120 .    D = E + F;
 5-121 . }
 5-122 . 
 5-123 . A = B-C;
 5-124 . A = B-C;
 5-125 . A = B+C;
 5-126 . 
 5-127 . switch (ca stuff)
 5-128 . {
 5-129 .    case one:
 5-130 .    {
 5-131 .       run_this; 
 5-132 .       break;
 5-133 .    }
 5-134 .    case two:
 5-135 .    {
 5-136 .       run_this;
 5-137 .       break;
 5-138 .    }
 5-139 .    default:
 5-140 .    {
 5-141 .        SwError;
 5-142 .    }
 5-143 . }
 5-144 . 
 5-145 . // max LOC 26
 5-146 . 
 5-147 . }
 5-148 . 
 5-149 . 
 5-150 . /*
 5-151 . -----------------------------------------------------------------------------
 5-152 . --| NAME:   ca.5.2
 5-153 . --|
 5-154 . --| ABSTRACT:
 5-155 . --|   This function does ca stuff.
 5-156 . --|
 5-157 . --| RETURNS:
 5-158 . --|   NONE.
 5-159 . --|
 5-160 . ----------------------------------------------------------------------------
 5-161 . */
 5-162 . static void ca.5.2(void)
 5-163 . {
 5-164 . A = B*C;
 5-165 . A = B-C;
 5-166 . A = B*C;
 5-167 . 
 5-168 . if (A lt B)
 5-169 . {
 5-170 .    A = B + C;
 5-171 .    D = E + F;
 5-172 . }
 5-173 . 
 5-174 . 
 5-175 . if (A ge B)
 5-176 . {
 5-177 .    A = B + C;
 5-178 .    D = E + F;
 5-179 . }
 5-180 . 
 5-181 . A = B-C;
 5-182 . 
 5-183 . if (A > = B)
 5-184 . {
 5-185 .    A = B + C;
 5-186 .    D = E + F;
 5-187 . }
 5-188 . 
 5-189 . 
 5-190 . if (A gt B)
 5-191 . {
 5-192 .    A = B + C;
 5-193 .    D = E + F;
 5-194 . }
 5-195 . 
 5-196 . A = B+C;
 5-197 . /* LE SV TOC-1057 this is a ca-05.2.10 req to disable*/
 5-198 . A = B+C;
 5-199 . A = B+C;
 5-200 . A = B+C;
 5-201 . 
 5-202 . if (A eq B)
 5-203 . {
 5-204 .    A = B + C;
 5-205 .    D = E + F;
 5-206 . }
 5-207 . 
 5-208 . /* LE SV TOC-1058 this is a ca-05.2.14 req to set RTC*/
 5-209 . 
 5-210 . if (A < = B)
 5-211 . {
 5-212 .    A = B + C;
 5-213 .    D = E + F;
 5-214 . }
 5-215 . 
 5-216 . 
 5-217 . if (A ge B)
 5-218 . {
 5-219 .    A = B + C;
 5-220 .    D = E + F;
 5-221 . }
 5-222 . 
 5-223 . 
 5-224 . if (A <  B)
 5-225 . {
 5-226 .    A = B + C;
 5-227 .    D = E + F;
 5-228 . }
 5-229 . 
 5-230 . A = B-C;
 5-231 . A = B*C;
 5-232 . A = B+C;
 5-233 . 
 5-234 . if (A <  B)
 5-235 . {
 5-236 .    A = B + C;
 5-237 .    D = E + F;
 5-238 . }
 5-239 . 
 5-240 . 
 5-241 . if (A <  B)
 5-242 . {
 5-243 .    A = B + C;
 5-244 .    D = E + F;
 5-245 . }
 5-246 . 
 5-247 . A = B+C;
 5-248 . A = B+C;
 5-249 . /* LE SV TOC-1059 this is a ca-05.2.24 req to verify*/
 5-250 . A = B*C;
 5-251 . A = B-C;
 5-252 . /* LE SV TOC-1060 this is a ca-05.2.26 req to transform*/
 5-253 . A = B/C;
 5-254 . A = B+C;
 5-255 . A = B*C;
 5-256 . A = B*C;
 5-257 . // max LOC 29
 5-258 . 
 5-259 . }
 5-260 . 
 5-261 . 
 5-262 . /*
 5-263 . -----------------------------------------------------------------------------
 5-264 . --| NAME:   ca.5.3
 5-265 . --|
 5-266 . --| ABSTRACT:
 5-267 . --|   This function does ca stuff.
 5-268 . --|
 5-269 . --| RETURNS:
 5-270 . --|   NONE.
 5-271 . --|
 5-272 . ----------------------------------------------------------------------------
 5-273 . */
 5-274 . static void ca.5.3(void)
 5-275 . {
 5-276 . 
 5-277 . if (A lt B)
 5-278 . {
 5-279 .    A = B + C;
 5-280 .    D = E + F;
 5-281 . }
 5-282 . 
 5-283 . A = B+C;
 5-284 . 
 5-285 . if (A >  B)
 5-286 . {
 5-287 .    A = B + C;
 5-288 .    D = E + F;
 5-289 . }
 5-290 . 
 5-291 . A = B/C;
 5-292 . A = B-C;
 5-293 . A = B+C;
 5-294 . 
 5-295 . if (A gt B)
 5-296 . {
 5-297 .    A = B + C;
 5-298 .    D = E + F;
 5-299 . }
 5-300 . 
 5-301 . /* LE SV TOC-1061 this is a ca-05.3.8 req to store*/
 5-302 . A = B-C;
 5-303 . 
 5-304 . if (A == B)
 5-305 . {
 5-306 .    A = B + C;
 5-307 .    D = E + F;
 5-308 . }
 5-309 . 
 5-310 . A = B+C;
 5-311 . A = B*C;
 5-312 . A = B+C;
 5-313 . 
 5-314 . switch (ca stuff)
 5-315 . {
 5-316 .    case one:
 5-317 .    {
 5-318 .       run_this; 
 5-319 .       break;
 5-320 .    }
 5-321 .    case two:
 5-322 .    {
 5-323 .       run_this;
 5-324 .       break;
 5-325 .    }
 5-326 .    default:
 5-327 .    {
 5-328 .        SwError;
 5-329 .    }
 5-330 . }
 5-331 . 
 5-332 . A = B-C;
 5-333 . A = B/C;
 5-334 . A = B-C;
 5-335 . A = B*C;
 5-336 . 
 5-337 . if (A ge B)
 5-338 . {
 5-339 .    A = B + C;
 5-340 .    D = E + F;
 5-341 . }
 5-342 . 
 5-343 . A = B+C;
 5-344 . 
 5-345 . if (A ne B)
 5-346 . {
 5-347 .    A = B + C;
 5-348 .    D = E + F;
 5-349 . }
 5-350 . 
 5-351 . 
 5-352 . switch (ca stuff)
 5-353 . {
 5-354 .    case one:
 5-355 .    {
 5-356 .       run_this; 
 5-357 .       break;
 5-358 .    }
 5-359 .    case two:
 5-360 .    {
 5-361 .       run_this;
 5-362 .       break;
 5-363 .    }
 5-364 .    default:
 5-365 .    {
 5-366 .        SwError;
 5-367 .    }
 5-368 . }
 5-369 . 
 5-370 . A = B-C;
 5-371 . 
 5-372 . if (A >  B)
 5-373 . {
 5-374 .    A = B + C;
 5-375 .    D = E + F;
 5-376 . }
 5-377 . 
 5-378 . 
 5-379 . if (A < = B)
 5-380 . {
 5-381 .    A = B + C;
 5-382 .    D = E + F;
 5-383 . }
 5-384 . 
 5-385 . A = B-C;
 5-386 . A = B+C;
 5-387 . 
 5-388 . if (A >  B)
 5-389 . {
 5-390 .    A = B + C;
 5-391 .    D = E + F;
 5-392 . }
 5-393 . 
 5-394 . A = B/C;
 5-395 . A = B*C;
 5-396 . 
 5-397 . if (A lt B)
 5-398 . {
 5-399 .    A = B + C;
 5-400 .    D = E + F;
 5-401 . }
 5-402 . 
 5-403 . 
 5-404 . if (A < = B)
 5-405 . {
 5-406 .    A = B + C;
 5-407 .    D = E + F;
 5-408 . }
 5-409 . 
 5-410 . A = B*C;
 5-411 . 
 5-412 . if (A le B)
 5-413 . {
 5-414 .    A = B + C;
 5-415 .    D = E + F;
 5-416 . }
 5-417 . 
 5-418 . A = B-C;
 5-419 . A = B-C;
 5-420 . A = 0x0004;
 5-421 . 
 5-422 . if (A eq B)
 5-423 . {
 5-424 .    A = B + C;
 5-425 .    D = E + F;
 5-426 . }
 5-427 . 
 5-428 . 
 5-429 . if (A le B)
 5-430 . {
 5-431 .    A = B + C;
 5-432 .    D = E + F;
 5-433 . }
 5-434 . 
 5-435 . A = (long)B + C;
 5-436 . 
 5-437 . if (A != B)
 5-438 . {
 5-439 .    A = B + C;
 5-440 .    D = E + F;
 5-441 . }
 5-442 . 
 5-443 . A = B+C;
 5-444 . 
 5-445 . if (A eq B)
 5-446 . {
 5-447 .    A = B + C;
 5-448 .    D = E + F;
 5-449 . }
 5-450 . 
 5-451 . A = B/C;
 5-452 . A = B+C;
 5-453 . 
 5-454 . switch (ca stuff)
 5-455 . {
 5-456 .    case one:
 5-457 .    {
 5-458 .       run_this; 
 5-459 .       break;
 5-460 .    }
 5-461 .    case two:
 5-462 .    {
 5-463 .       run_this;
 5-464 .       break;
 5-465 .    }
 5-466 .    default:
 5-467 .    {
 5-468 .        SwError;
 5-469 .    }
 5-470 . }
 5-471 . 
 5-472 . A = B-C;
 5-473 . A = B/C;
 5-474 . A = B-C;
 5-475 . A = B-C;
 5-476 . A = B/C;
 5-477 . A = B*C;
 5-478 . A = B*C;
 5-479 . 
 5-480 . if (A <  B)
 5-481 . {
 5-482 .    A = B + C;
 5-483 .    D = E + F;
 5-484 . }
 5-485 . 
 5-486 . 
 5-487 . if (A le B)
 5-488 . {
 5-489 .    A = B + C;
 5-490 .    D = E + F;
 5-491 . }
 5-492 . 
 5-493 . 
 5-494 . if (A != B)
 5-495 . {
 5-496 .    A = B + C;
 5-497 .    D = E + F;
 5-498 . }
 5-499 . 
 5-500 . // max LOC 53
 5-501 . 
 5-502 . }
 5-503 . 
 5-504 . 
 5-505 . /*
 5-506 . -----------------------------------------------------------------------------
 5-507 . --| NAME:   ca.5.4
 5-508 . --|
 5-509 . --| ABSTRACT:
 5-510 . --|   This function does ca stuff.
 5-511 . --|
 5-512 . --| RETURNS:
 5-513 . --|   NONE.
 5-514 . --|
 5-515 . ----------------------------------------------------------------------------
 5-516 . */
 5-517 . static void ca.5.4(void)
 5-518 . {
 5-519 . A = B-C;
 5-520 . do forever;
 5-521 . A = B+C;
 5-522 . A = B-C;
 5-523 . A = B*C;
 5-524 . 
 5-525 . if (A != B)
 5-526 . {
 5-527 .    A = B + C;
 5-528 .    D = E + F;
 5-529 . }
 5-530 . 
 5-531 . A = B+C;
 5-532 . 
 5-533 . #ifdef LAZY
 5-534 .    // this is not nice
 5-535 .    A = B + C;
 5-536 .    A = B + C;
 5-537 . #endif
 5-538 . 
 5-539 . 
 5-540 . if (A == B)
 5-541 . {
 5-542 .    A = B + C;
 5-543 .    D = E + F;
 5-544 . }
 5-545 . 
 5-546 . 
 5-547 . switch (ca stuff)
 5-548 . {
 5-549 .    case one:
 5-550 .    {
 5-551 .       run_this; 
 5-552 .       break;
 5-553 .    }
 5-554 .    case two:
 5-555 .    {
 5-556 .       run_this;
 5-557 .       break;
 5-558 .    }
 5-559 .    default:
 5-560 .    {
 5-561 .        SwError;
 5-562 .    }
 5-563 . }
 5-564 . 
 5-565 . A = B-C;
 5-566 . 
 5-567 . if (A < = B)
 5-568 . {
 5-569 .    A = B + C;
 5-570 .    D = E + F;
 5-571 . }
 5-572 . 
 5-573 . /* LE SV TOC-1062 this is a ca-05.4.11 req to disable*/
 5-574 . A = B*C;
 5-575 . 
 5-576 . if (A gt B)
 5-577 . {
 5-578 .    A = B + C;
 5-579 .    D = E + F;
 5-580 . }
 5-581 . 
 5-582 . A = B-C;
 5-583 . 
 5-584 . if (A != B)
 5-585 . {
 5-586 .    A = B + C;
 5-587 .    D = E + F;
 5-588 . }
 5-589 . 
 5-590 . A = B-C;
 5-591 . A = B*C;
 5-592 . A = B*C;
 5-593 . A = 0x0006;
 5-594 . A = B-C;
 5-595 . A = B*C;
 5-596 . A = B+C;
 5-597 . 
 5-598 . if (A == B)
 5-599 . {
 5-600 .    A = B + C;
 5-601 .    D = E + F;
 5-602 . }
 5-603 . 
 5-604 . A = B*C;
 5-605 . A = B/C;
 5-606 . A = B+C;
 5-607 . A = B*C;
 5-608 . /* LE SV TOC-1063 this is a ca-05.4.26 req to record*/
 5-609 . A = B+C;
 5-610 . A = B-C;
 5-611 . 
 5-612 . switch (ca stuff)
 5-613 . {
 5-614 .    case one:
 5-615 .    {
 5-616 .       run_this; 
 5-617 .       break;
 5-618 .    }
 5-619 .    case two:
 5-620 .    {
 5-621 .       run_this;
 5-622 .       break;
 5-623 .    }
 5-624 .    default:
 5-625 .    {
 5-626 .        SwError;
 5-627 .    }
 5-628 . }
 5-629 . 
 5-630 . A = B*C;
 5-631 . 
 5-632 . if (A eq B)
 5-633 . {
 5-634 .    A = B + C;
 5-635 .    D = E + F;
 5-636 . }
 5-637 . 
 5-638 . A = B-C;
 5-639 . A = B*C;
 5-640 . 
 5-641 . if (A <  B)
 5-642 . {
 5-643 .    A = B + C;
 5-644 .    D = E + F;
 5-645 . }
 5-646 . 
 5-647 . A = B/C;
 5-648 . 
 5-649 . if (A ge B)
 5-650 . {
 5-651 .    A = B + C;
 5-652 .    D = E + F;
 5-653 . }
 5-654 . 
 5-655 . /* LE SV TOC-1064 this is a ca-05.4.36 req to increment*/
 5-656 . 
 5-657 . if (A le B)
 5-658 . {
 5-659 .    A = B + C;
 5-660 .    D = E + F;
 5-661 . }
 5-662 . 
 5-663 . 
 5-664 . if (A ne B)
 5-665 . {
 5-666 .    A = B + C;
 5-667 .    D = E + F;
 5-668 . }
 5-669 . 
 5-670 . A = B/C;
 5-671 . A = B+C;
 5-672 . 
 5-673 . if (A gt B)
 5-674 . {
 5-675 .    A = B + C;
 5-676 .    D = E + F;
 5-677 . }
 5-678 . 
 5-679 . A = B/C;
 5-680 . A = B*C;
 5-681 . /* LE SV TOC-1065 this is a ca-05.4.43 req to enable*/
 5-682 . A = B/C;
 5-683 . 
 5-684 . if (A < = B)
 5-685 . {
 5-686 .    A = B + C;
 5-687 .    D = E + F;
 5-688 . }
 5-689 . 
 5-690 . A = B-C;
 5-691 . A = B-C;
 5-692 . A = B/C;
 5-693 . 
 5-694 . if (A eq B)
 5-695 . {
 5-696 .    A = B + C;
 5-697 .    D = E + F;
 5-698 . }
 5-699 . 
 5-700 . A = B*C;
 5-701 . // ??? go see ws
 5-702 . A = B-C;
 5-703 . A = B*C;
 5-704 . A = B+C;
 5-705 . A = B*C;
 5-706 . A = B/C;
 5-707 . 
 5-708 . if (A != B)
 5-709 . {
 5-710 .    A = B + C;
 5-711 .    D = E + F;
 5-712 . }
 5-713 . 
 5-714 . 
 5-715 . if (A ne B)
 5-716 . {
 5-717 .    A = B + C;
 5-718 .    D = E + F;
 5-719 . }
 5-720 . 
 5-721 . A = B*C;
 5-722 . A = B-C;
 5-723 . 
 5-724 . if (A eq B)
 5-725 . {
 5-726 .    A = B + C;
 5-727 .    D = E + F;
 5-728 . }
 5-729 . 
 5-730 . A = B+C;
 5-731 . A = B/C;
 5-732 . A = B/C;
 5-733 . // max LOC 62
 5-734 . 
 5-735 . }
 5-736 . 
 5-737 . 
 5-738 . /*
 5-739 . -----------------------------------------------------------------------------
 5-740 . --| NAME:   ca.5.5
 5-741 . --|
 5-742 . --| ABSTRACT:
 5-743 . --|   This function does ca stuff.
 5-744 . --|
 5-745 . --| RETURNS:
 5-746 . --|   NONE.
 5-747 . --|
 5-748 . ----------------------------------------------------------------------------
 5-749 . */
 5-750 . static void ca.5.5(void)
 5-751 . {
 5-752 . A = B/C;
 5-753 . 
 5-754 . if (A ne B)
 5-755 . {
 5-756 .    A = B + C;
 5-757 .    D = E + F;
 5-758 . }
 5-759 . 
 5-760 . 
 5-761 . if (A ge B)
 5-762 . {
 5-763 .    A = B + C;
 5-764 .    D = E + F;
 5-765 . }
 5-766 . 
 5-767 . A = B*C;
 5-768 . 
 5-769 . if (A eq B)
 5-770 . {
 5-771 .    A = B + C;
 5-772 .    D = E + F;
 5-773 . }
 5-774 . 
 5-775 . 
 5-776 . if (A >  B)
 5-777 . {
 5-778 .    A = B + C;
 5-779 .    D = E + F;
 5-780 . }
 5-781 . 
 5-782 . A = B/C;
 5-783 . A = B/C;
 5-784 . 
 5-785 . switch (ca stuff)
 5-786 . {
 5-787 .    case one:
 5-788 .    {
 5-789 .       run_this; 
 5-790 .       break;
 5-791 .    }
 5-792 .    case two:
 5-793 .    {
 5-794 .       run_this;
 5-795 .       break;
 5-796 .    }
 5-797 .    default:
 5-798 .    {
 5-799 .        SwError;
 5-800 .    }
 5-801 . }
 5-802 . 
 5-803 . A = B*C;
 5-804 . A = B-C;
 5-805 . 
 5-806 . if (A >  B)
 5-807 . {
 5-808 .    A = B + C;
 5-809 .    D = E + F;
 5-810 . }
 5-811 . 
 5-812 . 
 5-813 . if (A <  B)
 5-814 . {
 5-815 .    A = B + C;
 5-816 .    D = E + F;
 5-817 . }
 5-818 . 
 5-819 . /* LE SV TOC-1066 this is a ca-05.5.14 req to update*/
 5-820 . A = B+C;
 5-821 . A = B/C;
 5-822 . 
 5-823 . if (A eq B)
 5-824 . {
 5-825 .    A = B + C;
 5-826 .    D = E + F;
 5-827 . }
 5-828 . 
 5-829 . A = B*C;
 5-830 . 
 5-831 . if (A gt B)
 5-832 . {
 5-833 .    A = B + C;
 5-834 .    D = E + F;
 5-835 . }
 5-836 . 
 5-837 . /* LE SV TOC-1067 this is a ca-05.5.19 req to set Real Time Clock*/
 5-838 . A = B-C;
 5-839 . A = B+C;
 5-840 . A = B-C;
 5-841 . // max LOC 21
 5-842 . 
 5-843 . }
 5-844 . 
 5-845 . 
 5-846 . /*
 5-847 . -----------------------------------------------------------------------------
 5-848 . --| NAME:   ca.5.6
 5-849 . --|
 5-850 . --| ABSTRACT:
 5-851 . --|   This function does ca stuff.
 5-852 . --|
 5-853 . --| RETURNS:
 5-854 . --|   NONE.
 5-855 . --|
 5-856 . ----------------------------------------------------------------------------
 5-857 . */
 5-858 . static void ca.5.6(void)
 5-859 . {
 5-860 . A = B+C;
 5-861 . A = B/C;
 5-862 . A = B/C;
 5-863 . 
 5-864 . if (A >  B)
 5-865 . {
 5-866 .    A = B + C;
 5-867 .    D = E + F;
 5-868 . }
 5-869 . 
 5-870 . A = B*C;
 5-871 . A = B+C;
 5-872 . A = B*C;
 5-873 . A = B*C;
 5-874 . 
 5-875 . if (A gt B)
 5-876 . {
 5-877 .    A = B + C;
 5-878 .    D = E + F;
 5-879 . }
 5-880 . 
 5-881 . A = B/C;
 5-882 . A = B+C;
 5-883 . goto error;
 5-884 . A = B+C;
 5-885 . 
 5-886 . if (A <  B)
 5-887 . {
 5-888 .    A = B + C;
 5-889 .    D = E + F;
 5-890 . }
 5-891 . 
 5-892 . do forever;
 5-893 . A = B-C;
 5-894 . A = B+C;
 5-895 . A = B*C;
 5-896 . A = B/C;
 5-897 . A = B-C;
 5-898 . A = B*C;
 5-899 . 
 5-900 . /* 
 5-901 . dead_code = B - C; 
 5-902 . dead_code = D - E; 
 5-903 . dead_code = F - G;
 5-904 . */
 5-905 . 
 5-906 . A = B+C;
 5-907 . 
 5-908 . if (A != B)
 5-909 . {
 5-910 .    A = B + C;
 5-911 .    D = E + F;
 5-912 . }
 5-913 . 
 5-914 . A = B-C;
 5-915 . A = B/C;
 5-916 . A = B*C;
 5-917 . A = B/C;
 5-918 . 
 5-919 . if (A <  B)
 5-920 . {
 5-921 .    A = B + C;
 5-922 .    D = E + F;
 5-923 . }
 5-924 . 
 5-925 . 
 5-926 . if (A < = B)
 5-927 . {
 5-928 .    A = B + C;
 5-929 .    D = E + F;
 5-930 . }
 5-931 . 
 5-932 . 
 5-933 . if (A gt B)
 5-934 . {
 5-935 .    A = B + C;
 5-936 .    D = E + F;
 5-937 . }
 5-938 . 
 5-939 . 
 5-940 . if (A gt B)
 5-941 . {
 5-942 .    A = B + C;
 5-943 .    D = E + F;
 5-944 . }
 5-945 . 
 5-946 . A = B+C;
 5-947 . A = B+C;
 5-948 . A = B*C;
 5-949 . A = B-C;
 5-950 . 
 5-951 . if (A ge B)
 5-952 . {
 5-953 .    A = B + C;
 5-954 .    D = E + F;
 5-955 . }
 5-956 . 
 5-957 . A = B*C;
 5-958 . A = B/C;
 5-959 . A = B/C;
 5-960 . A = B/C;
 5-961 . A = 0x0004;
 5-962 . A = B/C;
 5-963 . A = B-C;
 5-964 . // ??? go see ws
 5-965 . 
 5-966 . if (A < = B)
 5-967 . {
 5-968 .    A = B + C;
 5-969 .    D = E + F;
 5-970 . }
 5-971 . 
 5-972 . A = B+C;
 5-973 . A = B-C;
 5-974 . 
 5-975 . if (A < = B)
 5-976 . {
 5-977 .    A = B + C;
 5-978 .    D = E + F;
 5-979 . }
 5-980 . 
 5-981 . A = B+C;
 5-982 . 
 5-983 . if (A == B)
 5-984 . {
 5-985 .    A = B + C;
 5-986 .    D = E + F;
 5-987 . }
 5-988 . 
 5-989 . 
 5-990 . switch (ca stuff)
 5-991 . {
 5-992 .    case one:
 5-993 .    {
 5-994 .       run_this; 
 5-995 .       break;
 5-996 .    }
 5-997 .    case two:
 5-998 .    {
 5-999 .       run_this;
 5-1000 .       break;
 5-1001 .    }
 5-1002 .    default:
 5-1003 .    {
 5-1004 .        SwError;
 5-1005 .    }
 5-1006 . }
 5-1007 . 
 5-1008 . A = B*C;
 5-1009 . A = B-C;
 5-1010 . A = B/C;
 5-1011 . 
 5-1012 . switch (ca stuff)
 5-1013 . {
 5-1014 .    case one:
 5-1015 .    {
 5-1016 .       run_this; 
 5-1017 .       break;
 5-1018 .    }
 5-1019 .    case two:
 5-1020 .    {
 5-1021 .       run_this;
 5-1022 .       break;
 5-1023 .    }
 5-1024 .    default:
 5-1025 .    {
 5-1026 .        SwError;
 5-1027 .    }
 5-1028 . }
 5-1029 . 
 5-1030 . A = B-C;
 5-1031 . A = B-C;
 5-1032 . A = B*C;
 5-1033 . 
 5-1034 . switch (ca stuff)
 5-1035 . {
 5-1036 .    case one:
 5-1037 .    {
 5-1038 .       run_this; 
 5-1039 .       break;
 5-1040 .    }
 5-1041 .    case two:
 5-1042 .    {
 5-1043 .       run_this;
 5-1044 .       break;
 5-1045 .    }
 5-1046 .    default:
 5-1047 .    {
 5-1048 .        SwError;
 5-1049 .    }
 5-1050 . }
 5-1051 . 
 5-1052 . A = B-C;
 5-1053 . // TBD - what do I do now
 5-1054 . A = B-C;
 5-1055 . 
 5-1056 . if (A gt B)
 5-1057 . {
 5-1058 .    A = B + C;
 5-1059 .    D = E + F;
 5-1060 . }
 5-1061 . 
 5-1062 . A = B-C;
 5-1063 . A = B-C;
 5-1064 . // max LOC 60
 5-1065 . 
 5-1066 . }
 5-1067 . 
 5-1068 . 
 5-1069 . /*
 5-1070 . -----------------------------------------------------------------------------
 5-1071 . --| NAME:   ca.5.7
 5-1072 . --|
 5-1073 . --| ABSTRACT:
 5-1074 . --|   This function does ca stuff.
 5-1075 . --|
 5-1076 . --| RETURNS:
 5-1077 . --|   NONE.
 5-1078 . --|
 5-1079 . ----------------------------------------------------------------------------
 5-1080 . */
 5-1081 . static void ca.5.7(void)
 5-1082 . {
 5-1083 . A = B/C;
 5-1084 . A = B*C;
 5-1085 . 
 5-1086 . if (A == B)
 5-1087 . {
 5-1088 .    A = B + C;
 5-1089 .    D = E + F;
 5-1090 . }
 5-1091 . 
 5-1092 . A = B*C;
 5-1093 . A = B/C;
 5-1094 . A = B/C;
 5-1095 . A = B+C;
 5-1096 . A = B-C;
 5-1097 . A = B*C;
 5-1098 . send_buffer = (U16 *) malloc(size+1);
 5-1099 . A = B-C;
 5-1100 . A = B*C;
 5-1101 . 
 5-1102 . if (A == B)
 5-1103 . {
 5-1104 .    A = B + C;
 5-1105 .    D = E + F;
 5-1106 . }
 5-1107 . 
 5-1108 . A = B-C;
 5-1109 . A = 0x0006;
 5-1110 . 
 5-1111 . if (A le B)
 5-1112 . {
 5-1113 .    A = B + C;
 5-1114 .    D = E + F;
 5-1115 . }
 5-1116 . 
 5-1117 . 
 5-1118 . if (A gt B)
 5-1119 . {
 5-1120 .    A = B + C;
 5-1121 .    D = E + F;
 5-1122 . }
 5-1123 . 
 5-1124 . A = B-C;
 5-1125 . A = B/C;
 5-1126 . A = B-C;
 5-1127 . A = B*C;
 5-1128 . 
 5-1129 . if (A <  B)
 5-1130 . {
 5-1131 .    A = B + C;
 5-1132 .    D = E + F;
 5-1133 . }
 5-1134 . 
 5-1135 . A = B-C;
 5-1136 . A = B*C;
 5-1137 . A = B-C;
 5-1138 . A = 0x0009;
 5-1139 . A = B+C;
 5-1140 . A = B*C;
 5-1141 . A = B+C;
 5-1142 . A = B+C;
 5-1143 . A = B+C;
 5-1144 . A = B-C;
 5-1145 . A = B/C;
 5-1146 . A = B*C;
 5-1147 . A = B*C;
 5-1148 . A = B+C;
 5-1149 . A = B/C;
 5-1150 . A = B-C;
 5-1151 . A = B*C;
 5-1152 . // (P) this is really improtant
 5-1153 . A = B*C;
 5-1154 . A = B+C;
 5-1155 . A = B*C;
 5-1156 . A = B*C;
 5-1157 . 
 5-1158 . if ($ca stuff >  $otherca stuff) 
 5-1159 . /* LE SV TOC-008 we really should log all error calls */
 5-1160 . {
 5-1161 .    A = B + C;
 5-1162 . }
 5-1163 . 
 5-1164 . A = B/C;
 5-1165 . A = B*C;
 5-1166 . A = B*C;
 5-1167 . A = B/C;
 5-1168 . A = B*C;
 5-1169 . A = B-C;
 5-1170 . 
 5-1171 . if (A < = B)
 5-1172 . {
 5-1173 .    A = B + C;
 5-1174 .    D = E + F;
 5-1175 . }
 5-1176 . 
 5-1177 . A = B-C;
 5-1178 . // max LOC 48
 5-1179 . 
 5-1180 . }
 5-1181 . 
 5-1182 . 
 5-1183 . /*
 5-1184 . -----------------------------------------------------------------------------
 5-1185 . --| NAME:   ca.5.8
 5-1186 . --|
 5-1187 . --| ABSTRACT:
 5-1188 . --|   This function does ca stuff.
 5-1189 . --|
 5-1190 . --| RETURNS:
 5-1191 . --|   NONE.
 5-1192 . --|
 5-1193 . ----------------------------------------------------------------------------
 5-1194 . */
 5-1195 . static void ca.5.8(void)
 5-1196 . {
 5-1197 . A = B/C;
 5-1198 . A = B/C;
 5-1199 . A = B/C;
 5-1200 . A = B/C;
 5-1201 . A = B/C;
 5-1202 . 
 5-1203 . if (A <  B)
 5-1204 . {
 5-1205 .    A = B + C;
 5-1206 .    D = E + F;
 5-1207 . }
 5-1208 . 
 5-1209 . A = B*C;
 5-1210 . A = B*C;
 5-1211 . A = B/C;
 5-1212 . A = B/C;
 5-1213 . 
 5-1214 . switch (ca stuff)
 5-1215 . {
 5-1216 .    case one:
 5-1217 .    {
 5-1218 .       run_this; 
 5-1219 .       break;
 5-1220 .    }
 5-1221 .    case two:
 5-1222 .    {
 5-1223 .       run_this;
 5-1224 .       break;
 5-1225 .    }
 5-1226 .    default:
 5-1227 .    {
 5-1228 .        SwError;
 5-1229 .    }
 5-1230 . }
 5-1231 . 
 5-1232 . A = B+C;
 5-1233 . /* LE SV TOC-1068 this is a ca-05.8.13 req to translate*/
 5-1234 . A = B+C;
 5-1235 . A = B+C;
 5-1236 . 
 5-1237 . if (A < = B)
 5-1238 . {
 5-1239 .    A = B + C;
 5-1240 .    D = E + F;
 5-1241 . }
 5-1242 . 
 5-1243 . 
 5-1244 . if (A ge B)
 5-1245 . {
 5-1246 .    A = B + C;
 5-1247 .    D = E + F;
 5-1248 . }
 5-1249 . 
 5-1250 . A = B*C;
 5-1251 . A = B*C;
 5-1252 . A = B*C;
 5-1253 . 
 5-1254 . if (A >  B)
 5-1255 . {
 5-1256 .    A = B + C;
 5-1257 .    D = E + F;
 5-1258 . }
 5-1259 . 
 5-1260 . A = (int)B + C;
 5-1261 . 
 5-1262 . if (A > = B)
 5-1263 . {
 5-1264 .    A = B + C;
 5-1265 .    D = E + F;
 5-1266 . }
 5-1267 . 
 5-1268 . 
 5-1269 . if (A le B)
 5-1270 . {
 5-1271 .    A = B + C;
 5-1272 .    D = E + F;
 5-1273 . }
 5-1274 . 
 5-1275 . A = B*C;
 5-1276 . 
 5-1277 . if (A >  B)
 5-1278 . {
 5-1279 .    A = B + C;
 5-1280 .    D = E + F;
 5-1281 . }
 5-1282 . 
 5-1283 . 
 5-1284 . switch (ca stuff)
 5-1285 . {
 5-1286 .    case one:
 5-1287 .    {
 5-1288 .       switch (nested)
 5-1289 .       {
 5-1290 .          case:
 5-1291 .             X = Y + Z;
 5-1292 .          case:
 5-1293 .             X = Y + Z;
 5-1294 .          default:
 5-1295 .             SwError;
 5-1296 .       } 
 5-1297 .    }
 5-1298 .    case two:
 5-1299 .    {
 5-1300 .       run_this;
 5-1301 .       break;
 5-1302 .    }
 5-1303 .    default:
 5-1304 .    {
 5-1305 .       SwError;
 5-1306 .    }
 5-1307 . }
 5-1308 . 
 5-1309 . A = B+C;
 5-1310 . A = B-C;
 5-1311 . A = B-C;
 5-1312 . 
 5-1313 . if (A != B)
 5-1314 . {
 5-1315 .    A = B + C;
 5-1316 .    D = E + F;
 5-1317 . }
 5-1318 . 
 5-1319 . A = B/C;
 5-1320 . A = B*C;
 5-1321 . /* LE SV TOC-1069 this is a ca-05.8.31 req to convert*/
 5-1322 . A = B+C;
 5-1323 . A = B-C;
 5-1324 . A = B+C;
 5-1325 . A = B+C;
 5-1326 . A = B-C;
 5-1327 . do forever;
 5-1328 . 
 5-1329 . if (A != B)
 5-1330 . {
 5-1331 .    A = B + C;
 5-1332 .    D = E + F;
 5-1333 . }
 5-1334 . 
 5-1335 . A = 0x0008;
 5-1336 . A = B+C;
 5-1337 . A = B*C;
 5-1338 . 
 5-1339 . if (A != B)
 5-1340 . {
 5-1341 .    A = B + C;
 5-1342 .    D = E + F;
 5-1343 . }
 5-1344 . 
 5-1345 . 
 5-1346 . if (A >  B)
 5-1347 . {
 5-1348 .    A = B + C;
 5-1349 .    D = E + F;
 5-1350 . }
 5-1351 . 
 5-1352 . A = B+C;
 5-1353 . A = B-C;
 5-1354 . A = B/C;
 5-1355 . A = B*C;
 5-1356 . 
 5-1357 . switch (ca stuff)
 5-1358 . {
 5-1359 .    case one:
 5-1360 .    {
 5-1361 .       run_this; 
 5-1362 .       break;
 5-1363 .    }
 5-1364 .    case two:
 5-1365 .    {
 5-1366 .       run_this;
 5-1367 .       break;
 5-1368 .    }
 5-1369 .    default:
 5-1370 .    {
 5-1371 .        SwError;
 5-1372 .    }
 5-1373 . }
 5-1374 . 
 5-1375 . A = B/C;
 5-1376 . A = B/C;
 5-1377 . A = B-C;
 5-1378 . A = B+C;
 5-1379 . A = B*C;
 5-1380 . 
 5-1381 . if (A le B)
 5-1382 . {
 5-1383 .    A = B + C;
 5-1384 .    D = E + F;
 5-1385 . }
 5-1386 . 
 5-1387 . A = B*C;
 5-1388 . A = 0x0009;
 5-1389 . A = B+C;
 5-1390 . A = B-C;
 5-1391 . A = B/C;
 5-1392 . A = B+C;
 5-1393 . A = B/C;
 5-1394 . // max LOC 57
 5-1395 . 
 5-1396 . }
 5-1397 . 

5 5 Result: result/source/ft-app/ft-app-B1.1/ca/ca-05.c


6 6 Source: source/ft-app/ft-app-B1.1/ca/ca-06.c
 6-0 . /*
 6-1 . ----------------------------------------------------------------------------
 6-2 . --| BEGIN PROLOGUE
 6-3 . --|
 6-4 . --| CLASSIFICATION: UNCLASSIFIED
 6-5 . --|
 6-6 . --| FILE NAME:      ca-06.c
 6-7 . --|
 6-8 . --| ABSTRACT:
 6-9 . --|   This file contains the 10 functions that do file ca stuff.
 6-10 . --|
 6-11 . --| HISTORY:
 6-12 . --|   CCCQ_NAME:
 6-13 . --|   CCCQ_VER: 
 6-14 . --|
 6-15 . --| END PROLOGUE
 6-16 . ----------------------------------------------------------------------------
 6-17 . */
 6-18 . 
 6-19 . #define C;
 6-20 . #define C;
 6-21 . char D;
 6-22 . 
 6-23 . 
 6-24 . 
 6-25 . /*
 6-26 . -----------------------------------------------------------------------------
 6-27 . --| NAME:   ca.6.1
 6-28 . --|
 6-29 . --| ABSTRACT:
 6-30 . --|   This function does ca stuff.
 6-31 . --|
 6-32 . --| RETURNS:
 6-33 . --|   NONE.
 6-34 . --|
 6-35 . ----------------------------------------------------------------------------
 6-36 . */
 6-37 . static void ca.6.1(void)
 6-38 . {
 6-39 . A = B/C;
 6-40 . A = B-C;
 6-41 . 
 6-42 . if (A ge B)
 6-43 . {
 6-44 .    A = B + C;
 6-45 .    D = E + F;
 6-46 . }
 6-47 . 
 6-48 . A = B/C;
 6-49 . 
 6-50 . if (A ge B)
 6-51 . {
 6-52 .    A = B + C;
 6-53 .    D = E + F;
 6-54 . }
 6-55 . 
 6-56 . 
 6-57 . if (A == B)
 6-58 . {
 6-59 .    A = B + C;
 6-60 .    D = E + F;
 6-61 . }
 6-62 . 
 6-63 . A = B-C;
 6-64 . A = B*C;
 6-65 . 
 6-66 . if (A != B)
 6-67 . {
 6-68 .    A = B + C;
 6-69 .    D = E + F;
 6-70 . }
 6-71 . 
 6-72 . A = B-C;
 6-73 . A = B+C;
 6-74 . A = B-C;
 6-75 . 
 6-76 . if (A >  B)
 6-77 . {
 6-78 .    A = B + C;
 6-79 .    D = E + F;
 6-80 . }
 6-81 . 
 6-82 . 
 6-83 . /* dead_code = B + C; 
 6-84 . dead_code = D + E; 
 6-85 . dead_code = F + G; */
 6-86 . 
 6-87 . A = B-C;
 6-88 . A = B+C;
 6-89 . A = B+C;
 6-90 . 
 6-91 . if (A <  B)
 6-92 . {
 6-93 .    A = B + C;
 6-94 .    D = E + F;
 6-95 . }
 6-96 . 
 6-97 . A = B-C;
 6-98 . A = B-C;
 6-99 . 
 6-100 . if (A < = B)
 6-101 . {
 6-102 .    A = B + C;
 6-103 .    D = E + F;
 6-104 . }
 6-105 . 
 6-106 . A = B*C;
 6-107 . A = B+C;
 6-108 . 
 6-109 . if (A lt B)
 6-110 . {
 6-111 .    A = B + C;
 6-112 .    D = E + F;
 6-113 . }
 6-114 . 
 6-115 . /* LE SV TOC-1070 this is a ca-06.1.24 req to increment*/
 6-116 . A = B+C;
 6-117 . 
 6-118 . if (A != B)
 6-119 . {
 6-120 .    A = B + C;
 6-121 .    D = E + F;
 6-122 . }
 6-123 . 
 6-124 . 
 6-125 . if (A gt B)
 6-126 . {
 6-127 .    A = B + C;
 6-128 .    D = E + F;
 6-129 . }
 6-130 . 
 6-131 . A = B/C;
 6-132 . A = B/C;
 6-133 . A = B-C;
 6-134 . A = B+C;
 6-135 . A = B/C;
 6-136 . A = B+C;
 6-137 . 
 6-138 . if (A == B)
 6-139 . {
 6-140 .    A = B + C;
 6-141 .    D = E + F;
 6-142 . }
 6-143 . 
 6-144 . /* LE SV TOC-1071 this is a ca-06.1.34 req to assign*/
 6-145 . A = B/C;
 6-146 . A = B-C;
 6-147 . 
 6-148 . if (A == B)
 6-149 . {
 6-150 .    A = B + C;
 6-151 .    D = E + F;
 6-152 . }
 6-153 . 
 6-154 . /* LE SV TOC-1072 this is a ca-06.1.37 req to transform*/
 6-155 . A = B-C;
 6-156 . 
 6-157 . if (A >  B)
 6-158 . {
 6-159 .    A = B + C;
 6-160 .    D = E + F;
 6-161 . }
 6-162 . 
 6-163 . A = B+C;
 6-164 . 
 6-165 . if (A eq B)
 6-166 . {
 6-167 .    A = B + C;
 6-168 .    D = E + F;
 6-169 . }
 6-170 . 
 6-171 . A = B+C;
 6-172 . A = B/C;
 6-173 . A = B*C;
 6-174 . A = B+C;
 6-175 . /* LE SV TOC-1073 this is a ca-06.1.45 req to detect error*/
 6-176 . 
 6-177 . if (A > = B)
 6-178 . {
 6-179 .    A = B + C;
 6-180 .    D = E + F;
 6-181 . }
 6-182 . 
 6-183 . // ??? go see ws
 6-184 . A = B+C;
 6-185 . A = B+C;
 6-186 . 
 6-187 . if (A ne B)
 6-188 . {
 6-189 .    A = B + C;
 6-190 .    D = E + F;
 6-191 . }
 6-192 . 
 6-193 . // max LOC 48
 6-194 . 
 6-195 . }
 6-196 . 
 6-197 . 
 6-198 . /*
 6-199 . -----------------------------------------------------------------------------
 6-200 . --| NAME:   ca.6.2
 6-201 . --|
 6-202 . --| ABSTRACT:
 6-203 . --|   This function does ca stuff.
 6-204 . --|
 6-205 . --| RETURNS:
 6-206 . --|   NONE.
 6-207 . --|
 6-208 . ----------------------------------------------------------------------------
 6-209 . */
 6-210 . static void ca.6.2(void)
 6-211 . {
 6-212 . 
 6-213 . if (A eq B)
 6-214 . {
 6-215 .    A = B + C;
 6-216 .    D = E + F;
 6-217 . }
 6-218 . 
 6-219 . 
 6-220 . if (A >  B)
 6-221 . {
 6-222 .    A = B + C;
 6-223 .    D = E + F;
 6-224 . }
 6-225 . 
 6-226 . 
 6-227 . if (A le B)
 6-228 . {
 6-229 .    A = B + C;
 6-230 .    D = E + F;
 6-231 . }
 6-232 . 
 6-233 . A = B+C;
 6-234 . A = B-C;
 6-235 . A = B*C;
 6-236 . 
 6-237 . if (A eq B)
 6-238 . {
 6-239 .    A = B + C;
 6-240 .    D = E + F;
 6-241 . }
 6-242 . 
 6-243 . 
 6-244 . if (A eq B)
 6-245 . {
 6-246 .    A = B + C;
 6-247 .    D = E + F;
 6-248 . }
 6-249 . 
 6-250 . A = B+C;
 6-251 . A = B/C;
 6-252 . A = B*C;
 6-253 . 
 6-254 . if (A eq B)
 6-255 . {
 6-256 .    A = B + C;
 6-257 .    D = E + F;
 6-258 . }
 6-259 . 
 6-260 . /* LE SV TOC-1074 this is a ca-06.2.13 req to reject*/
 6-261 . goto error;
 6-262 . A = B+C;
 6-263 . A = B*C;
 6-264 . A = B-C;
 6-265 . A = B-C;
 6-266 . 
 6-267 . if (A gt B)
 6-268 . {
 6-269 .    A = B + C;
 6-270 .    D = E + F;
 6-271 . }
 6-272 . 
 6-273 . A = B*C;
 6-274 . A = B*C;
 6-275 . 
 6-276 . if (A gt B)
 6-277 . {
 6-278 .    A = B + C;
 6-279 .    D = E + F;
 6-280 . }
 6-281 . 
 6-282 . A = B-C;
 6-283 . A = B-C;
 6-284 . 
 6-285 . if (A >  B)
 6-286 . {
 6-287 .    A = B + C;
 6-288 .    D = E + F;
 6-289 . }
 6-290 . 
 6-291 . /* LE SV TOC-1075 this is a ca-06.2.24 req to audit*/
 6-292 . 
 6-293 . if (A le B)
 6-294 . {
 6-295 .    A = B + C;
 6-296 .    D = E + F;
 6-297 . }
 6-298 . 
 6-299 . A = B-C;
 6-300 . A = 0x0004;
 6-301 . A = B*C;
 6-302 . /* LE SV TOC-1076 this is a ca-06.2.27 req to enable*/
 6-303 . A = B-C;
 6-304 . A = B/C;
 6-305 . A = B+C;
 6-306 . A = B-C;
 6-307 . free(FreePtr);
 6-308 . A = B+C;
 6-309 . 
 6-310 . if (A le B)
 6-311 . {
 6-312 .    A = B + C;
 6-313 .    D = E + F;
 6-314 . }
 6-315 . 
 6-316 . 
 6-317 . if (A > = B)
 6-318 . {
 6-319 .    A = B + C;
 6-320 .    D = E + F;
 6-321 . }
 6-322 . 
 6-323 . A = B-C;
 6-324 . 
 6-325 . if (A >  B)
 6-326 . {
 6-327 .    A = B + C;
 6-328 .    D = E + F;
 6-329 . }
 6-330 . 
 6-331 . 
 6-332 . if (A <  B)
 6-333 . {
 6-334 .    A = B + C;
 6-335 .    D = E + F;
 6-336 . }
 6-337 . 
 6-338 . /* LE SV TOC-1077 this is a ca-06.2.37 req to record*/
 6-339 . A = B/C;
 6-340 . 
 6-341 . if (A lt B)
 6-342 . {
 6-343 .    A = B + C;
 6-344 .    D = E + F;
 6-345 . }
 6-346 . 
 6-347 . 
 6-348 . if (A lt B)
 6-349 . {
 6-350 .    A = B + C;
 6-351 .    D = E + F;
 6-352 . }
 6-353 . 
 6-354 . A = B+C;
 6-355 . 
 6-356 . if (A ge B)
 6-357 . {
 6-358 .    A = B + C;
 6-359 .    D = E + F;
 6-360 . }
 6-361 . 
 6-362 . A = B-C;
 6-363 . A = B/C;
 6-364 . A = B+C;
 6-365 . A = B/C;
 6-366 . 
 6-367 . if (A le B)
 6-368 . {
 6-369 .    A = B + C;
 6-370 .    D = E + F;
 6-371 . }
 6-372 . 
 6-373 . /* LE SV TOC-1078 this is a ca-06.2.47 req to record*/
 6-374 . A = B+C;
 6-375 . A = B/C;
 6-376 . A = B*C;
 6-377 . 
 6-378 . if (A < = B)
 6-379 . {
 6-380 .    A = B + C;
 6-381 .    D = E + F;
 6-382 . }
 6-383 . 
 6-384 . 
 6-385 . #ifdef LAZY
 6-386 .    // this is not nice
 6-387 .    A = B + C;
 6-388 .    A = B + C;
 6-389 . #endif
 6-390 . 
 6-391 . 
 6-392 . if (A > = B)
 6-393 . {
 6-394 .    A = B + C;
 6-395 .    D = E + F;
 6-396 . }
 6-397 . 
 6-398 . A = B-C;
 6-399 . 
 6-400 . if (A >  B)
 6-401 . {
 6-402 .    A = B + C;
 6-403 .    D = E + F;
 6-404 . }
 6-405 . 
 6-406 . 
 6-407 . if (A le B)
 6-408 . {
 6-409 .    A = B + C;
 6-410 .    D = E + F;
 6-411 . }
 6-412 . 
 6-413 . A = B-C;
 6-414 . /* LE SV TOC-1079 this is a ca-06.2.56 req to enable*/
 6-415 . 
 6-416 . if (A <  B)
 6-417 . {
 6-418 .    A = B + C;
 6-419 .    D = E + F;
 6-420 . }
 6-421 . 
 6-422 . send_buffer = (U16 *) malloc(size+1);
 6-423 . A = B-C;
 6-424 . A = B/C;
 6-425 . A = B/C;
 6-426 . // max LOC 59
 6-427 . 
 6-428 . }
 6-429 . 
 6-430 . 
 6-431 . /*
 6-432 . -----------------------------------------------------------------------------
 6-433 . --| NAME:   ca.6.3
 6-434 . --|
 6-435 . --| ABSTRACT:
 6-436 . --|   This function does ca stuff.
 6-437 . --|
 6-438 . --| RETURNS:
 6-439 . --|   NONE.
 6-440 . --|
 6-441 . ----------------------------------------------------------------------------
 6-442 . */
 6-443 . static void ca.6.3(void)
 6-444 . {
 6-445 . 
 6-446 . if (A <  B)
 6-447 . {
 6-448 .    A = B + C;
 6-449 .    D = E + F;
 6-450 . }
 6-451 . 
 6-452 . A = B-C;
 6-453 . A = B*C;
 6-454 . A = B+C;
 6-455 . A = B/C;
 6-456 . 
 6-457 . if (A > = B)
 6-458 . {
 6-459 .    A = B + C;
 6-460 .    D = E + F;
 6-461 . }
 6-462 . 
 6-463 . A = B*C;
 6-464 . A = B-C;
 6-465 . 
 6-466 . if (A gt B)
 6-467 . {
 6-468 .    A = B + C;
 6-469 .    D = E + F;
 6-470 . }
 6-471 . 
 6-472 . 
 6-473 . if (A lt B)
 6-474 . {
 6-475 .    A = B + C;
 6-476 .    D = E + F;
 6-477 . }
 6-478 . 
 6-479 . A = B-C;
 6-480 . /* LE SV TOC-1080 this is a ca-06.3.12 req to increment*/
 6-481 . A = B*C;
 6-482 . A = B/C;
 6-483 . A = B*C;
 6-484 . /* LE SV TOC-1081 this is a ca-06.3.15 req to halt*/
 6-485 . A = B/C;
 6-486 . A = B/C;
 6-487 . 
 6-488 . if (A != B)
 6-489 . {
 6-490 .    A = B + C;
 6-491 .    D = E + F;
 6-492 . }
 6-493 . 
 6-494 . 
 6-495 . if (A == B)
 6-496 . {
 6-497 .    A = B + C;
 6-498 .    D = E + F;
 6-499 . }
 6-500 . 
 6-501 . A = B-C;
 6-502 . 
 6-503 . if (A != B)
 6-504 . {
 6-505 .    A = B + C;
 6-506 .    D = E + F;
 6-507 . }
 6-508 . 
 6-509 . 
 6-510 . if (A le B)
 6-511 . {
 6-512 .    A = B + C;
 6-513 .    D = E + F;
 6-514 . }
 6-515 . 
 6-516 . A = B-C;
 6-517 . 
 6-518 . if (A eq B)
 6-519 . {
 6-520 .    A = B + C;
 6-521 .    D = E + F;
 6-522 . }
 6-523 . 
 6-524 . 
 6-525 . switch (ca stuff)
 6-526 . {
 6-527 .    case one:
 6-528 .    {
 6-529 .       run_this; 
 6-530 .       break;
 6-531 .    }
 6-532 .    case two:
 6-533 .    {
 6-534 .       run_this;
 6-535 .       break;
 6-536 .    }
 6-537 .    default:
 6-538 .    {
 6-539 .        SwError;
 6-540 .    }
 6-541 . }
 6-542 . 
 6-543 . A = B/C;
 6-544 . A = B-C;
 6-545 . A = B-C;
 6-546 . A = B/C;
 6-547 . A = B*C;
 6-548 . A = B+C;
 6-549 . A = B+C;
 6-550 . 
 6-551 . if (A <  B)
 6-552 . {
 6-553 .    A = B + C;
 6-554 .    D = E + F;
 6-555 . }
 6-556 . 
 6-557 . A = B+C;
 6-558 . 
 6-559 . if (A <  B)
 6-560 . {
 6-561 .    A = B + C;
 6-562 .    D = E + F;
 6-563 . }
 6-564 . 
 6-565 . A = B*C;
 6-566 . A = B/C;
 6-567 . A = B/C;
 6-568 . /* LE SV TOC-1082 this is a ca-06.3.38 req to inhibit*/
 6-569 . 
 6-570 . if (A >  B)
 6-571 . {
 6-572 .    A = B + C;
 6-573 .    D = E + F;
 6-574 . }
 6-575 . 
 6-576 . A = B+C;
 6-577 . A = 0x0003;
 6-578 . A = B/C;
 6-579 . 
 6-580 . if (A ne B)
 6-581 . {
 6-582 .    A = B + C;
 6-583 .    D = E + F;
 6-584 . }
 6-585 . 
 6-586 . A = B-C;
 6-587 . A = B*C;
 6-588 . A = B+C;
 6-589 . 
 6-590 . if (A < = B)
 6-591 . {
 6-592 .    A = B + C;
 6-593 .    D = E + F;
 6-594 . }
 6-595 . 
 6-596 . A = B*C;
 6-597 . A = B+C;
 6-598 . A = B-C;
 6-599 . A = B/C;
 6-600 . A = B-C;
 6-601 . 
 6-602 . if (A lt B)
 6-603 . {
 6-604 .    A = B + C;
 6-605 .    D = E + F;
 6-606 . }
 6-607 . 
 6-608 . A = B/C;
 6-609 . 
 6-610 . switch (ca stuff)
 6-611 . {
 6-612 .    case one:
 6-613 .    {
 6-614 .       run_this; 
 6-615 .       break;
 6-616 .    }
 6-617 .    case two:
 6-618 .    {
 6-619 .       run_this;
 6-620 .       break;
 6-621 .    }
 6-622 .    default:
 6-623 .    {
 6-624 .        SwError;
 6-625 .    }
 6-626 . }
 6-627 . 
 6-628 . 
 6-629 . if (A < = B)
 6-630 . {
 6-631 .    A = B + C;
 6-632 .    D = E + F;
 6-633 . }
 6-634 . 
 6-635 . 
 6-636 . if (A ne B)
 6-637 . {
 6-638 .    A = B + C;
 6-639 .    D = E + F;
 6-640 . }
 6-641 . 
 6-642 . A = B/C;
 6-643 . A = B*C;
 6-644 . /* LE SV TOC-1083 this is a ca-06.3.58 req to verify*/
 6-645 . A = B/C;
 6-646 . 
 6-647 . if ($ca stuff >  $otherca stuff) 
 6-648 . /* LE SV TOC-008 we really should log all error calls */
 6-649 . {
 6-650 .    A = B + C;
 6-651 . }
 6-652 . 
 6-653 . A = B*C;
 6-654 . A = B/C;
 6-655 . A = B*C;
 6-656 . A = B/C;
 6-657 . A = B*C;
 6-658 . A = B-C;
 6-659 . A = B*C;
 6-660 . /* LE SV TOC-1084 this is a ca-06.3.66 req to validate*/
 6-661 . A = B+C;
 6-662 . 
 6-663 . if (A > = B)
 6-664 . {
 6-665 .    A = B + C;
 6-666 .    D = E + F;
 6-667 . }
 6-668 . 
 6-669 . A = B-C;
 6-670 . 
 6-671 . if (A eq B)
 6-672 . {
 6-673 .    A = B + C;
 6-674 .    D = E + F;
 6-675 . }
 6-676 . 
 6-677 . A = B-C;
 6-678 . 
 6-679 . if (A eq B)
 6-680 . {
 6-681 .    A = B + C;
 6-682 .    D = E + F;
 6-683 . }
 6-684 . 
 6-685 . A = B*C;
 6-686 . A = B*C;
 6-687 . 
 6-688 . if (A le B)
 6-689 . {
 6-690 .    A = B + C;
 6-691 .    D = E + F;
 6-692 . }
 6-693 . 
 6-694 . A = B+C;
 6-695 . A = B+C;
 6-696 . A = B/C;
 6-697 . A = B*C;
 6-698 . 
 6-699 . if (A lt B)
 6-700 . {
 6-701 .    A = B + C;
 6-702 .    D = E + F;
 6-703 . }
 6-704 . 
 6-705 . /* dead_code = A * B; */
 6-706 . A = B+C;
 6-707 . 
 6-708 . if (A lt B)
 6-709 . {
 6-710 .    A = B + C;
 6-711 .    D = E + F;
 6-712 . }
 6-713 . 
 6-714 . 
 6-715 . switch (ca stuff)
 6-716 . {
 6-717 .    case one:
 6-718 .    {
 6-719 .       run_this; 
 6-720 .       break;
 6-721 .    }
 6-722 .    case two:
 6-723 .    {
 6-724 .       run_this;
 6-725 .       break;
 6-726 .    }
 6-727 .    default:
 6-728 .    {
 6-729 .        SwError;
 6-730 .    }
 6-731 . }
 6-732 . 
 6-733 . A = B-C;
 6-734 . A = B*C;
 6-735 . 
 6-736 . if (A eq B)
 6-737 . {
 6-738 .    A = B + C;
 6-739 .    D = E + F;
 6-740 . }
 6-741 . 
 6-742 . A = B-C;
 6-743 . A = B*C;
 6-744 . 
 6-745 . if (A <  B)
 6-746 . {
 6-747 .    A = B + C;
 6-748 .    D = E + F;
 6-749 . }
 6-750 . 
 6-751 . /* LE SV TOC-1085 this is a ca-06.3.89 req to call admin*/
 6-752 . A = B/C;
 6-753 . // max LOC 89
 6-754 . 
 6-755 . }
 6-756 . 
 6-757 . 
 6-758 . /*
 6-759 . -----------------------------------------------------------------------------
 6-760 . --| NAME:   ca.6.4
 6-761 . --|
 6-762 . --| ABSTRACT:
 6-763 . --|   This function does ca stuff.
 6-764 . --|
 6-765 . --| RETURNS:
 6-766 . --|   NONE.
 6-767 . --|
 6-768 . ----------------------------------------------------------------------------
 6-769 . */
 6-770 . static void ca.6.4(void)
 6-771 . {
 6-772 . A = B+C;
 6-773 . A = B-C;
 6-774 . 
 6-775 . if (A <  B)
 6-776 . {
 6-777 .    A = B + C;
 6-778 .    D = E + F;
 6-779 . }
 6-780 . 
 6-781 . A = B+C;
 6-782 . 
 6-783 . switch (ca stuff)
 6-784 . {
 6-785 .    case one:
 6-786 .    {
 6-787 .       run_this; 
 6-788 .       break;
 6-789 .    }
 6-790 .    case two:
 6-791 .    {
 6-792 .       run_this;
 6-793 .       break;
 6-794 .    }
 6-795 .    default:
 6-796 .    {
 6-797 .        SwError;
 6-798 .    }
 6-799 . }
 6-800 . 
 6-801 . A = B/C;
 6-802 . A = B-C;
 6-803 . A = B*C;
 6-804 . 
 6-805 . switch (ca stuff)
 6-806 . {
 6-807 .    case one:
 6-808 .    {
 6-809 .       run_this; 
 6-810 .       break;
 6-811 .    }
 6-812 .    case two:
 6-813 .    {
 6-814 .       run_this;
 6-815 .       break;
 6-816 .    }
 6-817 .    default:
 6-818 .    {
 6-819 .        SwError;
 6-820 .    }
 6-821 . }
 6-822 . 
 6-823 . A = B+C;
 6-824 . A = B/C;
 6-825 . A = B/C;
 6-826 . /* LE SV TOC-1086 this is a ca-06.4.13 req to increment*/
 6-827 . A = B+C;
 6-828 . A = B+C;
 6-829 . /* dead_code = A * B; */
 6-830 . A = B/C;
 6-831 . A = B+C;
 6-832 . 
 6-833 . if (A eq B)
 6-834 . {
 6-835 .    A = B + C;
 6-836 .    D = E + F;
 6-837 . }
 6-838 . 
 6-839 . /* LE SV TOC-1087 this is a ca-06.4.18 req to increment*/
 6-840 . 
 6-841 . if (A != B)
 6-842 . {
 6-843 .    A = B + C;
 6-844 .    D = E + F;
 6-845 . }
 6-846 . 
 6-847 . 
 6-848 . if (A eq B)
 6-849 . {
 6-850 .    A = B + C;
 6-851 .    D = E + F;
 6-852 . }
 6-853 . 
 6-854 . 
 6-855 . if (A < = B)
 6-856 . {
 6-857 .    A = B + C;
 6-858 .    D = E + F;
 6-859 . }
 6-860 . 
 6-861 . A = B*C;
 6-862 . A = B+C;
 6-863 . A = B*C;
 6-864 . 
 6-865 . if (A lt B)
 6-866 . {
 6-867 .    A = B + C;
 6-868 .    D = E + F;
 6-869 . }
 6-870 . 
 6-871 . 
 6-872 . #ifdef LAZY
 6-873 .    // this is not nice
 6-874 .    A = B + C;
 6-875 .    A = B + C;
 6-876 . #endif
 6-877 . 
 6-878 . A = B-C;
 6-879 . 
 6-880 . if (A < = B)
 6-881 . {
 6-882 .    A = B + C;
 6-883 .    D = E + F;
 6-884 . }
 6-885 . 
 6-886 . 
 6-887 . if (A <  B)
 6-888 . {
 6-889 .    A = B + C;
 6-890 .    D = E + F;
 6-891 . }
 6-892 . 
 6-893 . A = 0x0003;
 6-894 . 
 6-895 . if (A == B)
 6-896 . {
 6-897 .    A = B + C;
 6-898 .    D = E + F;
 6-899 . }
 6-900 . 
 6-901 . goto error;
 6-902 . 
 6-903 . if (A ge B)
 6-904 . {
 6-905 .    A = B + C;
 6-906 .    D = E + F;
 6-907 . }
 6-908 . 
 6-909 . A = B*C;
 6-910 . // ??? go see ws
 6-911 . 
 6-912 . if (A <  B)
 6-913 . {
 6-914 .    A = B + C;
 6-915 .    D = E + F;
 6-916 . }
 6-917 . 
 6-918 . 
 6-919 . if (A > = B)
 6-920 . {
 6-921 .    A = B + C;
 6-922 .    D = E + F;
 6-923 . }
 6-924 . 
 6-925 . 
 6-926 . if (A <  B)
 6-927 . {
 6-928 .    A = B + C;
 6-929 .    D = E + F;
 6-930 . }
 6-931 . 
 6-932 . A = B+C;
 6-933 . A = B/C;
 6-934 . // max LOC 35
 6-935 . 
 6-936 . }
 6-937 . 
 6-938 . 
 6-939 . /*
 6-940 . -----------------------------------------------------------------------------
 6-941 . --| NAME:   ca.6.5
 6-942 . --|
 6-943 . --| ABSTRACT:
 6-944 . --|   This function does ca stuff.
 6-945 . --|
 6-946 . --| RETURNS:
 6-947 . --|   NONE.
 6-948 . --|
 6-949 . ----------------------------------------------------------------------------
 6-950 . */
 6-951 . static void ca.6.5(void)
 6-952 . {
 6-953 . A = B-C;
 6-954 . A = B+C;
 6-955 . /* LE SV TOC-1088 this is a ca-06.5.3 req to update*/
 6-956 . 
 6-957 . if (A < = B)
 6-958 . {
 6-959 .    A = B + C;
 6-960 .    D = E + F;
 6-961 . }
 6-962 . 
 6-963 . 
 6-964 . switch (ca stuff)
 6-965 . {
 6-966 .    case one:
 6-967 .    {
 6-968 .       run_this; 
 6-969 .       // missing break
 6-970 .    }
 6-971 .    case two:
 6-972 .    {
 6-973 .       run_this;
 6-974 .       break;
 6-975 .    }
 6-976 .    default:
 6-977 .    {
 6-978 .       SwError;
 6-979 .    }
 6-980 . }
 6-981 . 
 6-982 . A = B+C;
 6-983 . A = B/C;
 6-984 . A = B*C;
 6-985 . 
 6-986 . if (A < = B)
 6-987 . {
 6-988 .    A = B + C;
 6-989 .    D = E + F;
 6-990 . }
 6-991 . 
 6-992 . A = B/C;
 6-993 . A = B*C;
 6-994 . /* LE SV TOC-1089 this is a ca-06.5.10 req to record*/
 6-995 . A = B*C;
 6-996 . 
 6-997 . if (A == B)
 6-998 . {
 6-999 .    A = B + C;
 6-1000 .    D = E + F;
 6-1001 . }
 6-1002 . 
 6-1003 . A = B+C;
 6-1004 . A = B-C;
 6-1005 . /* LE SV TOC-1090 this is a ca-06.5.14 req to audit*/
 6-1006 . A = B/C;
 6-1007 . A = B*C;
 6-1008 . A = B*C;
 6-1009 . A = B+C;
 6-1010 . A = B-C;
 6-1011 . A = B/C;
 6-1012 . 
 6-1013 . if (A lt B)
 6-1014 . {
 6-1015 .    A = B + C;
 6-1016 .    D = E + F;
 6-1017 . }
 6-1018 . 
 6-1019 . A = B-C;
 6-1020 . /* LE SV TOC-1091 this is a ca-06.5.22 req to compare*/
 6-1021 . 
 6-1022 . if (A != B)
 6-1023 . {
 6-1024 .    A = B + C;
 6-1025 .    D = E + F;
 6-1026 . }
 6-1027 . 
 6-1028 . A = B-C;
 6-1029 . A = B+C;
 6-1030 . 
 6-1031 . if (A lt B)
 6-1032 . {
 6-1033 .    A = B + C;
 6-1034 .    D = E + F;
 6-1035 . }
 6-1036 . 
 6-1037 . // max LOC 25
 6-1038 . 
 6-1039 . }
 6-1040 . 
 6-1041 . 
 6-1042 . /*
 6-1043 . -----------------------------------------------------------------------------
 6-1044 . --| NAME:   ca.6.6
 6-1045 . --|
 6-1046 . --| ABSTRACT:
 6-1047 . --|   This function does ca stuff.
 6-1048 . --|
 6-1049 . --| RETURNS:
 6-1050 . --|   NONE.
 6-1051 . --|
 6-1052 . ----------------------------------------------------------------------------
 6-1053 . */
 6-1054 . static void ca.6.6(void)
 6-1055 . {
 6-1056 . A = B/C;
 6-1057 . A = B-C;
 6-1058 . A = B*C;
 6-1059 . A = B+C;
 6-1060 . 
 6-1061 . if (A <  B)
 6-1062 . {
 6-1063 .    A = B + C;
 6-1064 .    D = E + F;
 6-1065 . }
 6-1066 . 
 6-1067 . A = B/C;
 6-1068 . 
 6-1069 . /* dead_code = B + C; 
 6-1070 . dead_code = D + E; 
 6-1071 . dead_code = F + G; */
 6-1072 . 
 6-1073 . A = B*C;
 6-1074 . A = 0x0009;
 6-1075 . A = B/C;
 6-1076 . A = B*C;
 6-1077 . A = B*C;
 6-1078 . A = B-C;
 6-1079 . 
 6-1080 . switch (ca stuff)
 6-1081 . {
 6-1082 .    case one:
 6-1083 .    {
 6-1084 .       run_this; 
 6-1085 .       break;
 6-1086 .    }
 6-1087 .    case two:
 6-1088 .    {
 6-1089 .       run_this;
 6-1090 .       break;
 6-1091 .    }
 6-1092 .    default:
 6-1093 .    {
 6-1094 .        SwError;
 6-1095 .    }
 6-1096 . }
 6-1097 . 
 6-1098 . A = B+C;
 6-1099 . A = B-C;
 6-1100 . A = B+C;
 6-1101 . A = B/C;
 6-1102 . 
 6-1103 . if (A == B)
 6-1104 . {
 6-1105 .    A = B + C;
 6-1106 .    D = E + F;
 6-1107 . }
 6-1108 . 
 6-1109 . A = B/C;
 6-1110 . A = B*C;
 6-1111 . // (P) this is really improtant
 6-1112 . A = B*C;
 6-1113 . 
 6-1114 . if (A gt B)
 6-1115 . {
 6-1116 .    A = B + C;
 6-1117 .    D = E + F;
 6-1118 . }
 6-1119 . 
 6-1120 . A = B-C;
 6-1121 . A = B*C;
 6-1122 . A = B/C;
 6-1123 . A = B+C;
 6-1124 . 
 6-1125 . if (A != B)
 6-1126 . {
 6-1127 .    A = B + C;
 6-1128 .    D = E + F;
 6-1129 . }
 6-1130 . 
 6-1131 . A = B-C;
 6-1132 . A = B*C;
 6-1133 . A = B/C;
 6-1134 . A = B*C;
 6-1135 . 
 6-1136 . if (A == B)
 6-1137 . {
 6-1138 .    A = B + C;
 6-1139 .    D = E + F;
 6-1140 . }
 6-1141 . 
 6-1142 . A = B/C;
 6-1143 . // max LOC 32
 6-1144 . 
 6-1145 . }
 6-1146 . 
 6-1147 . 
 6-1148 . /*
 6-1149 . -----------------------------------------------------------------------------
 6-1150 . --| NAME:   ca.6.7
 6-1151 . --|
 6-1152 . --| ABSTRACT:
 6-1153 . --|   This function does ca stuff.
 6-1154 . --|
 6-1155 . --| RETURNS:
 6-1156 . --|   NONE.
 6-1157 . --|
 6-1158 . ----------------------------------------------------------------------------
 6-1159 . */
 6-1160 . static void ca.6.7(void)
 6-1161 . {
 6-1162 . A = B-C;
 6-1163 . A = B/C;
 6-1164 . 
 6-1165 . if (A == B)
 6-1166 . {
 6-1167 .    A = B + C;
 6-1168 .    D = E + F;
 6-1169 . }
 6-1170 . 
 6-1171 . A = 0x0008;
 6-1172 . A = B+C;
 6-1173 . 
 6-1174 . switch (ca stuff)
 6-1175 . {
 6-1176 .    case one:
 6-1177 .    {
 6-1178 .       run_this; 
 6-1179 .       break;
 6-1180 .    }
 6-1181 .    case two:
 6-1182 .    {
 6-1183 .       run_this;
 6-1184 .       break;
 6-1185 .    }
 6-1186 .    default:
 6-1187 .    {
 6-1188 .        SwError;
 6-1189 .    }
 6-1190 . }
 6-1191 . 
 6-1192 . A = B*C;
 6-1193 . 
 6-1194 . if (A gt B)
 6-1195 . {
 6-1196 .    A = B + C;
 6-1197 .    D = E + F;
 6-1198 . }
 6-1199 . 
 6-1200 . 
 6-1201 . if (A eq B)
 6-1202 . {
 6-1203 .    A = B + C;
 6-1204 .    D = E + F;
 6-1205 . }
 6-1206 . 
 6-1207 . A = B*C;
 6-1208 . A = B/C;
 6-1209 . 
 6-1210 . if (A >  B)
 6-1211 . {
 6-1212 .    A = B + C;
 6-1213 .    D = E + F;
 6-1214 . }
 6-1215 . 
 6-1216 . A = B+C;
 6-1217 . A = 0x0004;
 6-1218 . A = B*C;
 6-1219 . A = B/C;
 6-1220 . 
 6-1221 . if (A >  B)
 6-1222 . {
 6-1223 .    A = B + C;
 6-1224 .    D = E + F;
 6-1225 . }
 6-1226 . 
 6-1227 . 
 6-1228 . if (A > = B)
 6-1229 . {
 6-1230 .    A = B + C;
 6-1231 .    D = E + F;
 6-1232 . }
 6-1233 . 
 6-1234 . A = B*C;
 6-1235 . A = B-C;
 6-1236 . A = B+C;
 6-1237 . A = B/C;
 6-1238 . A = (int)B + C;
 6-1239 . A = B*C;
 6-1240 . A = B/C;
 6-1241 . A = B*C;
 6-1242 . A = B/C;
 6-1243 . A = B+C;
 6-1244 . 
 6-1245 . if (A ne B)
 6-1246 . {
 6-1247 .    A = B + C;
 6-1248 .    D = E + F;
 6-1249 . }
 6-1250 . 
 6-1251 . A = B-C;
 6-1252 . 
 6-1253 . if (A != B)
 6-1254 . {
 6-1255 .    A = B + C;
 6-1256 .    D = E + F;
 6-1257 . }
 6-1258 . 
 6-1259 . A = B/C;
 6-1260 . goto error;
 6-1261 . 
 6-1262 . if (A <  B)
 6-1263 . {
 6-1264 .    A = B + C;
 6-1265 .    D = E + F;
 6-1266 . }
 6-1267 . 
 6-1268 . /* LE SV TOC-1092 this is a ca-06.7.31 req to halt*/
 6-1269 . A = B*C;
 6-1270 . A = B/C;
 6-1271 . 
 6-1272 . if (A > = B)
 6-1273 . {
 6-1274 .    A = B + C;
 6-1275 .    D = E + F;
 6-1276 . }
 6-1277 . 
 6-1278 . A = B*C;
 6-1279 . 
 6-1280 . if (A ge B)
 6-1281 . {
 6-1282 .    A = B + C;
 6-1283 .    D = E + F;
 6-1284 . }
 6-1285 . 
 6-1286 . 
 6-1287 . if (A == B)
 6-1288 . {
 6-1289 .    A = B + C;
 6-1290 .    D = E + F;
 6-1291 . }
 6-1292 . 
 6-1293 . A = B/C;
 6-1294 . A = B*C;
 6-1295 . /* LE SV TOC-1093 this is a ca-06.7.39 req to detect error*/
 6-1296 . A = B-C;
 6-1297 . 
 6-1298 . if (A lt B)
 6-1299 . {
 6-1300 .    A = B + C;
 6-1301 .    D = E + F;
 6-1302 . }
 6-1303 . 
 6-1304 . A = B*C;
 6-1305 . 
 6-1306 . if (A le B)
 6-1307 . {
 6-1308 .    A = B + C;
 6-1309 .    D = E + F;
 6-1310 . }
 6-1311 . 
 6-1312 . 
 6-1313 . if (A eq B)
 6-1314 . {
 6-1315 .    A = B + C;
 6-1316 .    D = E + F;
 6-1317 . }
 6-1318 . 
 6-1319 . 
 6-1320 . if (A > = B)
 6-1321 . {
 6-1322 .    A = B + C;
 6-1323 .    D = E + F;
 6-1324 . }
 6-1325 . 
 6-1326 . 
 6-1327 . if (A != B)
 6-1328 . {
 6-1329 .    A = B + C;
 6-1330 .    D = E + F;
 6-1331 . }
 6-1332 . 
 6-1333 . A = B+C;
 6-1334 . A = B/C;
 6-1335 . A = B/C;
 6-1336 . 
 6-1337 . if (A != B)
 6-1338 . {
 6-1339 .    A = B + C;
 6-1340 .    D = E + F;
 6-1341 . }
 6-1342 . 
 6-1343 . A = B*C;
 6-1344 . A = B*C;
 6-1345 . /* LE SV TOC-1094 this is a ca-06.7.52 req to store*/
 6-1346 . A = B*C;
 6-1347 . /* LE SV TOC-1095 this is a ca-06.7.53 req to assign*/
 6-1348 . A = B+C;
 6-1349 . A = B/C;
 6-1350 . /* LE SV TOC-1096 this is a ca-06.7.55 req to call isr*/
 6-1351 . A = B*C;
 6-1352 . /* LE SV TOC-1097 this is a ca-06.7.56 req to store*/
 6-1353 . A = B/C;
 6-1354 . A = B-C;
 6-1355 . A = B/C;
 6-1356 . 
 6-1357 . if (A < = B)
 6-1358 . {
 6-1359 .    A = B + C;
 6-1360 .    D = E + F;
 6-1361 . }
 6-1362 . 
 6-1363 . 
 6-1364 . if (A <  B)
 6-1365 . {
 6-1366 .    A = B + C;
 6-1367 .    D = E + F;
 6-1368 . }
 6-1369 . 
 6-1370 . 
 6-1371 . if (A > = B)
 6-1372 . {
 6-1373 .    A = B + C;
 6-1374 .    D = E + F;
 6-1375 . }
 6-1376 . 
 6-1377 . goto error;
 6-1378 . A = B-C;
 6-1379 . A = B*C;
 6-1380 . 
 6-1381 . if (A < = B)
 6-1382 . {
 6-1383 .    A = B + C;
 6-1384 .    D = E + F;
 6-1385 . }
 6-1386 . 
 6-1387 . 
 6-1388 . switch (ca stuff)
 6-1389 . {
 6-1390 .    case one:
 6-1391 .    {
 6-1392 .       run_this; 
 6-1393 .       break;
 6-1394 .    }
 6-1395 .    case two:
 6-1396 .    {
 6-1397 .       run_this;
 6-1398 .       break;
 6-1399 .    }
 6-1400 .    default:
 6-1401 .    {
 6-1402 .        SwError;
 6-1403 .    }
 6-1404 . }
 6-1405 . 
 6-1406 . A = B*C;
 6-1407 . // max LOC 66
 6-1408 . 
 6-1409 . }
 6-1410 . 
 6-1411 . 
 6-1412 . /*
 6-1413 . -----------------------------------------------------------------------------
 6-1414 . --| NAME:   ca.6.8
 6-1415 . --|
 6-1416 . --| ABSTRACT:
 6-1417 . --|   This function does ca stuff.
 6-1418 . --|
 6-1419 . --| RETURNS:
 6-1420 . --|   NONE.
 6-1421 . --|
 6-1422 . ----------------------------------------------------------------------------
 6-1423 . */
 6-1424 . static void ca.6.8(void)
 6-1425 . {
 6-1426 . A = B+C;
 6-1427 . /* LE SV TOC-1098 this is a ca-06.8.2 req to transform*/
 6-1428 . A = B/C;
 6-1429 . A = B+C;
 6-1430 . A = B/C;
 6-1431 . A = B/C;
 6-1432 . 
 6-1433 . if ($ca stuff >  $otherca stuff) 
 6-1434 . /* LE SV TOC-008 we really should log all error calls */
 6-1435 . {
 6-1436 .    A = B + C;
 6-1437 . }
 6-1438 . 
 6-1439 . A = B*C;
 6-1440 . A = B-C;
 6-1441 . A = B+C;
 6-1442 . goto error;
 6-1443 . A = B*C;
 6-1444 . A = B*C;
 6-1445 . A = B/C;
 6-1446 . A = B-C;
 6-1447 . 
 6-1448 . if (A gt B)
 6-1449 . {
 6-1450 .    A = B + C;
 6-1451 .    D = E + F;
 6-1452 . }
 6-1453 . 
 6-1454 . A = B+C;
 6-1455 . 
 6-1456 . if (A ne B)
 6-1457 . {
 6-1458 .    A = B + C;
 6-1459 .    D = E + F;
 6-1460 . }
 6-1461 . 
 6-1462 . 
 6-1463 . if (A >  B)
 6-1464 . {
 6-1465 .    A = B + C;
 6-1466 .    D = E + F;
 6-1467 . }
 6-1468 . 
 6-1469 . A = B+C;
 6-1470 . A = B-C;
 6-1471 . A = B/C;
 6-1472 . 
 6-1473 . if (A < = B)
 6-1474 . {
 6-1475 .    A = B + C;
 6-1476 .    D = E + F;
 6-1477 . }
 6-1478 . 
 6-1479 . FreePtr = HmiStringPtr;
 6-1480 . A = B-C;
 6-1481 . 
 6-1482 . if (A != B)
 6-1483 . {
 6-1484 .    A = B + C;
 6-1485 .    D = E + F;
 6-1486 . }
 6-1487 . 
 6-1488 . A = 0x0001;
 6-1489 . A = B/C;
 6-1490 . A = B+C;
 6-1491 . A = B*C;
 6-1492 . A = B/C;
 6-1493 . A = B*C;
 6-1494 . 
 6-1495 . if (A gt B)
 6-1496 . {
 6-1497 .    A = B + C;
 6-1498 .    D = E + F;
 6-1499 . }
 6-1500 . 
 6-1501 . A = B*C;
 6-1502 . A = B*C;
 6-1503 . A = B/C;
 6-1504 . A = B-C;
 6-1505 . A = B+C;
 6-1506 . A = B-C;
 6-1507 . A = B*C;
 6-1508 . A = B*C;
 6-1509 . 
 6-1510 . if (A le B)
 6-1511 . {
 6-1512 .    A = B + C;
 6-1513 .    D = E + F;
 6-1514 . }
 6-1515 . 
 6-1516 . 
 6-1517 . if (A == B)
 6-1518 . {
 6-1519 .    A = B + C;
 6-1520 .    D = E + F;
 6-1521 . }
 6-1522 . 
 6-1523 . A = B*C;
 6-1524 . 
 6-1525 . if (A > = B)
 6-1526 . {
 6-1527 .    A = B + C;
 6-1528 .    D = E + F;
 6-1529 . }
 6-1530 . 
 6-1531 . 
 6-1532 . if (A > = B)
 6-1533 . {
 6-1534 .    A = B + C;
 6-1535 .    D = E + F;
 6-1536 . }
 6-1537 . 
 6-1538 . A = B/C;
 6-1539 . A = B/C;
 6-1540 . A = B-C;
 6-1541 . 
 6-1542 . if (A > = B)
 6-1543 . {
 6-1544 .    A = B + C;
 6-1545 .    D = E + F;
 6-1546 . }
 6-1547 . 
 6-1548 . // TBD - what do I do now
 6-1549 . 
 6-1550 . if (A ge B)
 6-1551 . {
 6-1552 .    A = B + C;
 6-1553 .    D = E + F;
 6-1554 . }
 6-1555 . 
 6-1556 . A = B-C;
 6-1557 . A = B*C;
 6-1558 . A = B-C;
 6-1559 . A = B+C;
 6-1560 . A = B-C;
 6-1561 . A = B-C;
 6-1562 . A = B+C;
 6-1563 . A = B/C;
 6-1564 . 
 6-1565 . if (A gt B)
 6-1566 . {
 6-1567 .    A = B + C;
 6-1568 .    D = E + F;
 6-1569 . }
 6-1570 . 
 6-1571 . A = B*C;
 6-1572 . A = B-C;
 6-1573 . A = B/C;
 6-1574 . do forever;
 6-1575 . A = B-C;
 6-1576 . A = B*C;
 6-1577 . /* LE SV TOC-1099 this is a ca-06.8.61 req to call isr*/
 6-1578 . A = B/C;
 6-1579 . /* LE SV TOC-1100 this is a ca-06.8.62 req to recover*/
 6-1580 . A = B+C;
 6-1581 . A = B/C;
 6-1582 . A = B-C;
 6-1583 . 
 6-1584 . if (A < = B)
 6-1585 . {
 6-1586 .    A = B + C;
 6-1587 .    D = E + F;
 6-1588 . }
 6-1589 . 
 6-1590 . A = B+C;
 6-1591 . A = B-C;
 6-1592 . 
 6-1593 . switch (ca stuff)
 6-1594 . {
 6-1595 .    case:
 6-1596 .    case:
 6-1597 .    // stacked case statements but only if there is a new line in between
 6-1598 . 
 6-1599 .    case:
 6-1600 .    case:
 6-1601 .    case:
 6-1602 .    {
 6-1603 .       run_this;
 6-1604 .       break;
 6-1605 .    }
 6-1606 .    default:
 6-1607 .    {
 6-1608 .       halt;
 6-1609 .    }
 6-1610 . }
 6-1611 . 
 6-1612 . 
 6-1613 . if (A >  B)
 6-1614 . {
 6-1615 .    A = B + C;
 6-1616 .    D = E + F;
 6-1617 . }
 6-1618 . 
 6-1619 . 
 6-1620 . if (A eq B)
 6-1621 . {
 6-1622 .    A = B + C;
 6-1623 .    D = E + F;
 6-1624 . }
 6-1625 . 
 6-1626 . A = B-C;
 6-1627 . A = B*C;
 6-1628 . A = B-C;
 6-1629 . A = B-C;
 6-1630 . 
 6-1631 . if (A != B)
 6-1632 . {
 6-1633 .    A = B + C;
 6-1634 .    D = E + F;
 6-1635 . }
 6-1636 . 
 6-1637 . 
 6-1638 . if (A eq B)
 6-1639 . {
 6-1640 .    A = B + C;
 6-1641 .    D = E + F;
 6-1642 . }
 6-1643 . 
 6-1644 . A = B+C;
 6-1645 . A = B*C;
 6-1646 . A = B+C;
 6-1647 . A = B+C;
 6-1648 . 
 6-1649 . if (A >  B)
 6-1650 . {
 6-1651 .    A = B + C;
 6-1652 .    D = E + F;
 6-1653 . }
 6-1654 . 
 6-1655 . A = B*C;
 6-1656 . send_buffer = (U16 *) malloc(size+1);
 6-1657 . A = B+C;
 6-1658 . /* LE SV TOC-1101 this is a ca-06.8.83 req to inhibit*/
 6-1659 . 
 6-1660 . if (A == B)
 6-1661 . {
 6-1662 .    A = B + C;
 6-1663 .    D = E + F;
 6-1664 . }
 6-1665 . 
 6-1666 . 
 6-1667 . if (A >  B)
 6-1668 . {
 6-1669 .    A = B + C;
 6-1670 .    D = E + F;
 6-1671 . }
 6-1672 . 
 6-1673 . 
 6-1674 . if (A >  B)
 6-1675 . {
 6-1676 .    A = B + C;
 6-1677 .    D = E + F;
 6-1678 . }
 6-1679 . 
 6-1680 . /* LE SV TOC-1102 this is a ca-06.8.86 req to convert*/
 6-1681 . A = B+C;
 6-1682 . 
 6-1683 . if (A ne B)
 6-1684 . {
 6-1685 .    A = B + C;
 6-1686 .    D = E + F;
 6-1687 . }
 6-1688 . 
 6-1689 . 
 6-1690 . /* 
 6-1691 . dead_code = B - C; 
 6-1692 . dead_code = D - E; 
 6-1693 . dead_code = F - G;
 6-1694 . */
 6-1695 . 
 6-1696 . A = B/C;
 6-1697 . A = B+C;
 6-1698 . /* LE SV TOC-1103 this is a ca-06.8.90 req to record*/
 6-1699 . A = B/C;
 6-1700 . 
 6-1701 . if (A ne B)
 6-1702 . {
 6-1703 .    A = B + C;
 6-1704 .    D = E + F;
 6-1705 . }
 6-1706 . 
 6-1707 . A = B+C;
 6-1708 . A = B/C;
 6-1709 . 
 6-1710 . if (A > = B)
 6-1711 . {
 6-1712 .    A = B + C;
 6-1713 .    D = E + F;
 6-1714 . }
 6-1715 . 
 6-1716 . A = B+C;
 6-1717 . 
 6-1718 . if (A eq B)
 6-1719 . {
 6-1720 .    A = B + C;
 6-1721 .    D = E + F;
 6-1722 . }
 6-1723 . 
 6-1724 . A = B+C;
 6-1725 . // max LOC 97
 6-1726 . 
 6-1727 . }
 6-1728 . 
 6-1729 . 
 6-1730 . /*
 6-1731 . -----------------------------------------------------------------------------
 6-1732 . --| NAME:   ca.6.9
 6-1733 . --|
 6-1734 . --| ABSTRACT:
 6-1735 . --|   This function does ca stuff.
 6-1736 . --|
 6-1737 . --| RETURNS:
 6-1738 . --|   NONE.
 6-1739 . --|
 6-1740 . ----------------------------------------------------------------------------
 6-1741 . */
 6-1742 . static void ca.6.9(void)
 6-1743 . {
 6-1744 . 
 6-1745 . if ($ca stuff >  $otherca stuff) 
 6-1746 . /* LE SV TOC-008 we really should log all error calls */
 6-1747 . {
 6-1748 .    A = B + C;
 6-1749 . }
 6-1750 . 
 6-1751 . A = B-C;
 6-1752 . A = B+C;
 6-1753 . 
 6-1754 . if (A != B)
 6-1755 . {
 6-1756 .    A = B + C;
 6-1757 .    D = E + F;
 6-1758 . }
 6-1759 . 
 6-1760 . 
 6-1761 . if (A != B)
 6-1762 . {
 6-1763 .    A = B + C;
 6-1764 .    D = E + F;
 6-1765 . }
 6-1766 . 
 6-1767 . 
 6-1768 . if (A lt B)
 6-1769 . {
 6-1770 .    A = B + C;
 6-1771 .    D = E + F;
 6-1772 . }
 6-1773 . 
 6-1774 . A = B*C;
 6-1775 . 
 6-1776 . if (A > = B)
 6-1777 . {
 6-1778 .    A = B + C;
 6-1779 .    D = E + F;
 6-1780 . }
 6-1781 . 
 6-1782 . 
 6-1783 . if (A le B)
 6-1784 . {
 6-1785 .    A = B + C;
 6-1786 .    D = E + F;
 6-1787 . }
 6-1788 . 
 6-1789 . 
 6-1790 . if (A lt B)
 6-1791 . {
 6-1792 .    A = B + C;
 6-1793 .    D = E + F;
 6-1794 . }
 6-1795 . 
 6-1796 . A = B+C;
 6-1797 . 
 6-1798 . if (A >  B)
 6-1799 . {
 6-1800 .    A = B + C;
 6-1801 .    D = E + F;
 6-1802 . }
 6-1803 . 
 6-1804 . 
 6-1805 . if (A != B)
 6-1806 . {
 6-1807 .    A = B + C;
 6-1808 .    D = E + F;
 6-1809 . }
 6-1810 . 
 6-1811 . A = B-C;
 6-1812 . A = B/C;
 6-1813 . A = B+C;
 6-1814 . A = B/C;
 6-1815 . A = B-C;
 6-1816 . 
 6-1817 . if (A le B)
 6-1818 . {
 6-1819 .    A = B + C;
 6-1820 .    D = E + F;
 6-1821 . }
 6-1822 . 
 6-1823 . A = B*C;
 6-1824 . 
 6-1825 . if (A ne B)
 6-1826 . {
 6-1827 .    A = B + C;
 6-1828 .    D = E + F;
 6-1829 . }
 6-1830 . 
 6-1831 . 
 6-1832 . if (A < = B)
 6-1833 . {
 6-1834 .    A = B + C;
 6-1835 .    D = E + F;
 6-1836 . }
 6-1837 . 
 6-1838 . A = B/C;
 6-1839 . 
 6-1840 . if (A lt B)
 6-1841 . {
 6-1842 .    A = B + C;
 6-1843 .    D = E + F;
 6-1844 . }
 6-1845 . 
 6-1846 . /* LE SV TOC-1104 this is a ca-06.9.24 req to update*/
 6-1847 . A = B+C;
 6-1848 . 
 6-1849 . if (A <  B)
 6-1850 . {
 6-1851 .    A = B + C;
 6-1852 .    D = E + F;
 6-1853 . }
 6-1854 . 
 6-1855 . 
 6-1856 . if (A lt B)
 6-1857 . {
 6-1858 .    A = B + C;
 6-1859 .    D = E + F;
 6-1860 . }
 6-1861 . 
 6-1862 . 
 6-1863 . if (A ne B)
 6-1864 . {
 6-1865 .    A = B + C;
 6-1866 .    D = E + F;
 6-1867 . }
 6-1868 . 
 6-1869 . 
 6-1870 . if (A ne B)
 6-1871 . {
 6-1872 .    A = B + C;
 6-1873 .    D = E + F;
 6-1874 . }
 6-1875 . 
 6-1876 . A = B/C;
 6-1877 . 
 6-1878 . switch (ca stuff)
 6-1879 . {
 6-1880 .    case one:
 6-1881 .    {
 6-1882 .       run_this; 
 6-1883 .       break;
 6-1884 .    }
 6-1885 .    case two:
 6-1886 .    {
 6-1887 .       run_this;
 6-1888 .       break;
 6-1889 .    }
 6-1890 .    default:
 6-1891 .    {
 6-1892 .        SwError;
 6-1893 .    }
 6-1894 . }
 6-1895 . 
 6-1896 . A = B/C;
 6-1897 . A = 0x0001;
 6-1898 . A = B/C;
 6-1899 . A = B-C;
 6-1900 . 
 6-1901 . if (A lt B)
 6-1902 . {
 6-1903 .    A = B + C;
 6-1904 .    D = E + F;
 6-1905 . }
 6-1906 . 
 6-1907 . A = B/C;
 6-1908 . A = B/C;
 6-1909 . A = B+C;
 6-1910 . A = B+C;
 6-1911 . 
 6-1912 . if (A < = B)
 6-1913 . {
 6-1914 .    A = B + C;
 6-1915 .    D = E + F;
 6-1916 . }
 6-1917 . 
 6-1918 . 
 6-1919 . if (A >  B)
 6-1920 . {
 6-1921 .    A = B + C;
 6-1922 .    D = E + F;
 6-1923 . }
 6-1924 . 
 6-1925 . A = B+C;
 6-1926 . A = B-C;
 6-1927 . 
 6-1928 . if (A <  B)
 6-1929 . {
 6-1930 .    A = B + C;
 6-1931 .    D = E + F;
 6-1932 . }
 6-1933 . 
 6-1934 . 
 6-1935 . if (A > = B)
 6-1936 . {
 6-1937 .    A = B + C;
 6-1938 .    D = E + F;
 6-1939 . }
 6-1940 . 
 6-1941 . 
 6-1942 . if (A eq B)
 6-1943 . {
 6-1944 .    A = B + C;
 6-1945 .    D = E + F;
 6-1946 . }
 6-1947 . 
 6-1948 . 
 6-1949 . if (A < = B)
 6-1950 . {
 6-1951 .    A = B + C;
 6-1952 .    D = E + F;
 6-1953 . }
 6-1954 . 
 6-1955 . 
 6-1956 . if (A ge B)
 6-1957 . {
 6-1958 .    A = B + C;
 6-1959 .    D = E + F;
 6-1960 . }
 6-1961 . 
 6-1962 . // max LOC 47
 6-1963 . 
 6-1964 . }
 6-1965 . 
 6-1966 . 
 6-1967 . /*
 6-1968 . -----------------------------------------------------------------------------
 6-1969 . --| NAME:   ca.6.10
 6-1970 . --|
 6-1971 . --| ABSTRACT:
 6-1972 . --|   This function does ca stuff.
 6-1973 . --|
 6-1974 . --| RETURNS:
 6-1975 . --|   NONE.
 6-1976 . --|
 6-1977 . ----------------------------------------------------------------------------
 6-1978 . */
 6-1979 . static void ca.6.10(void)
 6-1980 . {
 6-1981 . A = B/C;
 6-1982 . A = B*C;
 6-1983 . A = B-C;
 6-1984 . A = B-C;
 6-1985 . 
 6-1986 . if (A == B)
 6-1987 . {
 6-1988 .    A = B + C;
 6-1989 .    D = E + F;
 6-1990 . }
 6-1991 . 
 6-1992 . A = B/C;
 6-1993 . 
 6-1994 . /* dead_block = C * D; 
 6-1995 . dead_block = E * F; */
 6-1996 . 
 6-1997 . A = B/C;
 6-1998 . A = B*C;
 6-1999 . /* LE SV TOC-1105 this is a ca-06.10.9 req to reject*/
 6-2000 . A = (float)B + C;
 6-2001 . A = B/C;
 6-2002 . A = B+C;
 6-2003 . A = B-C;
 6-2004 . A = B/C;
 6-2005 . A = B*C;
 6-2006 . A = 0x0009;
 6-2007 . A = B*C;
 6-2008 . A = B/C;
 6-2009 . A = B-C;
 6-2010 . 
 6-2011 . if (A > = B)
 6-2012 . {
 6-2013 .    A = B + C;
 6-2014 .    D = E + F;
 6-2015 . }
 6-2016 . 
 6-2017 . A = 0x0006;
 6-2018 . A = B+C;
 6-2019 . A = B-C;
 6-2020 . A = B-C;
 6-2021 . A = B+C;
 6-2022 . A = B-C;
 6-2023 . 
 6-2024 . if (A gt B)
 6-2025 . {
 6-2026 .    A = B + C;
 6-2027 .    D = E + F;
 6-2028 . }
 6-2029 . 
 6-2030 . A = 0x0002;
 6-2031 . A = B-C;
 6-2032 . A = B*C;
 6-2033 . 
 6-2034 . if (A == B)
 6-2035 . {
 6-2036 .    A = B + C;
 6-2037 .    D = E + F;
 6-2038 . }
 6-2039 . 
 6-2040 . A = B*C;
 6-2041 . A = 0x0006;
 6-2042 . A = B+C;
 6-2043 . A = B*C;
 6-2044 . A = B+C;
 6-2045 . A = B/C;
 6-2046 . A = 0x0006;
 6-2047 . A = B-C;
 6-2048 . 
 6-2049 . if (A ne B)
 6-2050 . {
 6-2051 .    A = B + C;
 6-2052 .    D = E + F;
 6-2053 . }
 6-2054 . 
 6-2055 . 
 6-2056 . if (A <  B)
 6-2057 . {
 6-2058 .    A = B + C;
 6-2059 .    D = E + F;
 6-2060 . }
 6-2061 . 
 6-2062 . A = B/C;
 6-2063 . A = B*C;
 6-2064 . A = B-C;
 6-2065 . /* LE SV TOC-1106 this is a ca-06.10.38 req to check pSOS*/
 6-2066 . 
 6-2067 . if (A < = B)
 6-2068 . {
 6-2069 .    A = B + C;
 6-2070 .    D = E + F;
 6-2071 . }
 6-2072 . 
 6-2073 . 
 6-2074 . if (A ge B)
 6-2075 . {
 6-2076 .    A = B + C;
 6-2077 .    D = E + F;
 6-2078 . }
 6-2079 . 
 6-2080 . 
 6-2081 . if (A le B)
 6-2082 . {
 6-2083 .    A = B + C;
 6-2084 .    D = E + F;
 6-2085 . }
 6-2086 . 
 6-2087 . 
 6-2088 . if (A gt B)
 6-2089 . {
 6-2090 .    A = B + C;
 6-2091 .    D = E + F;
 6-2092 . }
 6-2093 . 
 6-2094 . A = B/C;
 6-2095 . 
 6-2096 . if (A lt B)
 6-2097 . {
 6-2098 .    A = B + C;
 6-2099 .    D = E + F;
 6-2100 . }
 6-2101 . 
 6-2102 . 
 6-2103 . if (A ne B)
 6-2104 . {
 6-2105 .    A = B + C;
 6-2106 .    D = E + F;
 6-2107 . }
 6-2108 . 
 6-2109 . A = B/C;
 6-2110 . A = 0x0002;
 6-2111 . rcv_buffer = (U16 *) alloc(size+1);
 6-2112 . A = B/C;
 6-2113 . A = B-C;
 6-2114 . 
 6-2115 . switch (ca stuff)
 6-2116 . {
 6-2117 .    case one:
 6-2118 .    {
 6-2119 .       run_this; 
 6-2120 .       break;
 6-2121 .    }
 6-2122 .    case two:
 6-2123 .    {
 6-2124 .       run_this;
 6-2125 .       break;
 6-2126 .    }
 6-2127 .    default:
 6-2128 .    {
 6-2129 .        SwError;
 6-2130 .    }
 6-2131 . }
 6-2132 . 
 6-2133 . A = B-C;
 6-2134 . A = B+C;
 6-2135 . 
 6-2136 . switch (ca stuff)
 6-2137 . {
 6-2138 .    case one:
 6-2139 .    {
 6-2140 .       run_this; 
 6-2141 .       break;
 6-2142 .    }
 6-2143 .    case two:
 6-2144 .    {
 6-2145 .       run_this;
 6-2146 .       break;
 6-2147 .    }
 6-2148 .    default:
 6-2149 .    {
 6-2150 .        SwError;
 6-2151 .    }
 6-2152 . }
 6-2153 . 
 6-2154 . A = B*C;
 6-2155 . A = B/C;
 6-2156 . A = B*C;
 6-2157 . A = B-C;
 6-2158 . A = B-C;
 6-2159 . /* LE SV TOC-1107 this is a ca-06.10.57 req to validate*/
 6-2160 . A = B*C;
 6-2161 . A = B+C;
 6-2162 . A = B*C;
 6-2163 . A = B/C;
 6-2164 . 
 6-2165 . switch (ca stuff)
 6-2166 . {
 6-2167 .    case one:
 6-2168 .    {
 6-2169 .       run_this; 
 6-2170 .       break;
 6-2171 .    }
 6-2172 .    case two:
 6-2173 .    {
 6-2174 .       run_this;
 6-2175 .       break;
 6-2176 .    }
 6-2177 .    default:
 6-2178 .    {
 6-2179 .        SwError;
 6-2180 .    }
 6-2181 . }
 6-2182 . 
 6-2183 . A = B/C;
 6-2184 . 
 6-2185 . if (A ne B)
 6-2186 . {
 6-2187 .    A = B + C;
 6-2188 .    D = E + F;
 6-2189 . }
 6-2190 . 
 6-2191 . A = B+C;
 6-2192 . A = B/C;
 6-2193 . A = (long)B + C;
 6-2194 . 
 6-2195 . switch (ca stuff)
 6-2196 . {
 6-2197 .    case one:
 6-2198 .    {
 6-2199 .       run_this; 
 6-2200 .       break;
 6-2201 .    }
 6-2202 .    case two:
 6-2203 .    {
 6-2204 .       run_this;
 6-2205 .       break;
 6-2206 .    }
 6-2207 .    default:
 6-2208 .    {
 6-2209 .        SwError;
 6-2210 .    }
 6-2211 . }
 6-2212 . 
 6-2213 . A = B-C;
 6-2214 . A = B-C;
 6-2215 . A = B+C;
 6-2216 . A = B/C;
 6-2217 . A = B+C;
 6-2218 . A = B+C;
 6-2219 . /* LE SV TOC-1108 this is a ca-06.10.73 req to assign*/
 6-2220 . A = B-C;
 6-2221 . A = B-C;
 6-2222 . A = B*C;
 6-2223 . A = B/C;
 6-2224 . A = B+C;
 6-2225 . A = B/C;
 6-2226 . A = B*C;
 6-2227 . 
 6-2228 . if (A ne B)
 6-2229 . {
 6-2230 .    A = B + C;
 6-2231 .    D = E + F;
 6-2232 . }
 6-2233 . 
 6-2234 . A = B*C;
 6-2235 . 
 6-2236 . if {
 6-2237 .    X = Y + Z;
 6-2238 . }
 6-2239 . else {
 6-2240 .    halt;
 6-2241 . }
 6-2242 . 
 6-2243 . A = B/C;
 6-2244 . /* LE SV TOC-1109 this is a ca-06.10.83 req to validate*/
 6-2245 . 
 6-2246 . if (A le B)
 6-2247 . {
 6-2248 .    A = B + C;
 6-2249 .    D = E + F;
 6-2250 . }
 6-2251 . 
 6-2252 . // max LOC 83
 6-2253 . 
 6-2254 . }
 6-2255 . 

6 6 Result: result/source/ft-app/ft-app-B1.1/ca/ca-06.c


7 7 Source: source/ft-app/ft-app-B1.1/ca/ca-07.c
 7-0 . /*
 7-1 . ----------------------------------------------------------------------------
 7-2 . --| BEGIN PROLOGUE
 7-3 . --|
 7-4 . --| CLASSIFICATION: UNCLASSIFIED
 7-5 . --|
 7-6 . --| FILE NAME:      ca-07.c
 7-7 . --|
 7-8 . --| ABSTRACT:
 7-9 . --|   This file contains the 7 functions that do file ca stuff.
 7-10 . --|
 7-11 . --| HISTORY:
 7-12 . --|   CCCQ_NAME:
 7-13 . --|   CCCQ_VER: 
 7-14 . --|
 7-15 . --| END PROLOGUE
 7-16 . ----------------------------------------------------------------------------
 7-17 . */
 7-18 . 
 7-19 . #include C;
 7-20 . float B;
 7-21 . #define A;
 7-22 . float B;
 7-23 . #define D;
 7-24 . #define C;
 7-25 . 
 7-26 . 
 7-27 . 
 7-28 . /*
 7-29 . -----------------------------------------------------------------------------
 7-30 . --| NAME:   ca.7.1
 7-31 . --|
 7-32 . --| ABSTRACT:
 7-33 . --|   This function does ca stuff.
 7-34 . --|
 7-35 . --| RETURNS:
 7-36 . --|   NONE.
 7-37 . --|
 7-38 . ----------------------------------------------------------------------------
 7-39 . */
 7-40 . static void ca.7.1(void)
 7-41 . {
 7-42 . A = B*C;
 7-43 . A = B-C;
 7-44 . 
 7-45 . if (A ne B)
 7-46 . {
 7-47 .    A = B + C;
 7-48 .    D = E + F;
 7-49 . }
 7-50 . 
 7-51 . 
 7-52 . switch (ca stuff)
 7-53 . {
 7-54 .    case one:
 7-55 .    {
 7-56 .       run_this;
 7-57 .       break;
 7-58 .    }
 7-59 .    case two:
 7-60 .    {
 7-61 .       run_this;
 7-62 .       break;
 7-63 .    }
 7-64 .    // missing default
 7-65 . }
 7-66 . 
 7-67 . A = B-C;
 7-68 . A = B+C;
 7-69 . A = B-C;
 7-70 . A = B-C;
 7-71 . 
 7-72 . if (A gt B)
 7-73 . {
 7-74 .    A = B + C;
 7-75 .    D = E + F;
 7-76 . }
 7-77 . 
 7-78 . A = B/C;
 7-79 . A = B*C;
 7-80 . A = B*C;
 7-81 . 
 7-82 . if {
 7-83 .    X = Y + Z;
 7-84 . }
 7-85 . else {
 7-86 .    halt;
 7-87 . }
 7-88 . 
 7-89 . A = B*C;
 7-90 . 
 7-91 . if (A == B)
 7-92 . {
 7-93 .    A = B + C;
 7-94 .    D = E + F;
 7-95 . }
 7-96 . 
 7-97 . A = B*C;
 7-98 . 
 7-99 . if (A <  B)
 7-100 . {
 7-101 .    A = B + C;
 7-102 .    D = E + F;
 7-103 . }
 7-104 . 
 7-105 . /* LE SV TOC-1110 this is a ca-07.1.16 req to call isr*/
 7-106 . A = (int)B + C;
 7-107 . A = B+C;
 7-108 . A = B+C;
 7-109 . A = B*C;
 7-110 . A = B*C;
 7-111 . 
 7-112 . if (A le B)
 7-113 . {
 7-114 .    A = B + C;
 7-115 .    D = E + F;
 7-116 . }
 7-117 . 
 7-118 . 
 7-119 . if (A == B)
 7-120 . {
 7-121 .    A = B + C;
 7-122 .    D = E + F;
 7-123 . }
 7-124 . 
 7-125 . A = B+C;
 7-126 . A = B-C;
 7-127 . A = B/C;
 7-128 . A = B-C;
 7-129 . 
 7-130 . if (A le B)
 7-131 . {
 7-132 .    A = B + C;
 7-133 .    D = E + F;
 7-134 . }
 7-135 . 
 7-136 . A = B*C;
 7-137 . A = B-C;
 7-138 . A = B*C;
 7-139 . 
 7-140 . if (A == B)
 7-141 . {
 7-142 .    A = B + C;
 7-143 .    D = E + F;
 7-144 . }
 7-145 . 
 7-146 . 
 7-147 . if (A > = B)
 7-148 . {
 7-149 .    A = B + C;
 7-150 .    D = E + F;
 7-151 . }
 7-152 . 
 7-153 . A = B*C;
 7-154 . A = B+C;
 7-155 . A = B/C;
 7-156 . 
 7-157 . switch (ca stuff)
 7-158 . {
 7-159 .    case one:
 7-160 .    {
 7-161 .       run_this; 
 7-162 .       break;
 7-163 .    }
 7-164 .    case two:
 7-165 .    {
 7-166 .       run_this;
 7-167 .       break;
 7-168 .    }
 7-169 .    default:
 7-170 .    {
 7-171 .        SwError;
 7-172 .    }
 7-173 . }
 7-174 . 
 7-175 . 
 7-176 . if (A lt B)
 7-177 . {
 7-178 .    A = B + C;
 7-179 .    D = E + F;
 7-180 . }
 7-181 . 
 7-182 . 
 7-183 . if (A ge B)
 7-184 . {
 7-185 .    A = B + C;
 7-186 .    D = E + F;
 7-187 . }
 7-188 . 
 7-189 . 
 7-190 . /* dead_block = C * D; 
 7-191 . dead_block = E * F; */
 7-192 . 
 7-193 . A = B*C;
 7-194 . A = B*C;
 7-195 . A = B*C;
 7-196 . 
 7-197 . if (A <  B)
 7-198 . {
 7-199 .    A = B + C;
 7-200 .    D = E + F;
 7-201 . }
 7-202 . 
 7-203 . /* LE SV TOC-1111 this is a ca-07.1.42 req to fail*/
 7-204 . A = B-C;
 7-205 . A = B/C;
 7-206 . rcv_buffer = (U16 *) alloc(size+1);
 7-207 . A = B/C;
 7-208 . 
 7-209 . if (A > = B)
 7-210 . {
 7-211 .    A = B + C;
 7-212 .    D = E + F;
 7-213 . }
 7-214 . 
 7-215 . 
 7-216 . if (A ge B)
 7-217 . {
 7-218 .    A = B + C;
 7-219 .    D = E + F;
 7-220 . }
 7-221 . 
 7-222 . A = B/C;
 7-223 . A = B/C;
 7-224 . A = B/C;
 7-225 . A = B+C;
 7-226 . A = B*C;
 7-227 . A = B-C;
 7-228 . /* LE SV TOC-1112 this is a ca-07.1.53 req to store*/
 7-229 . A = B*C;
 7-230 . A = B/C;
 7-231 . 
 7-232 . switch (ca stuff)
 7-233 . {
 7-234 .    case one:
 7-235 .    {
 7-236 .       run_this; 
 7-237 .       break;
 7-238 .    }
 7-239 .    case two:
 7-240 .    {
 7-241 .       run_this;
 7-242 .       break;
 7-243 .    }
 7-244 .    default:
 7-245 .    {
 7-246 .        SwError;
 7-247 .    }
 7-248 . }
 7-249 . 
 7-250 . 
 7-251 . if (A ge B)
 7-252 . {
 7-253 .    A = B + C;
 7-254 .    D = E + F;
 7-255 . }
 7-256 . 
 7-257 . 
 7-258 . if (A lt B)
 7-259 . {
 7-260 .    A = B + C;
 7-261 .    D = E + F;
 7-262 . }
 7-263 . 
 7-264 . A = B+C;
 7-265 . 
 7-266 . if (A != B)
 7-267 . {
 7-268 .    A = B + C;
 7-269 .    D = E + F;
 7-270 . }
 7-271 . 
 7-272 . A = B*C;
 7-273 . A = B/C;
 7-274 . 
 7-275 . if (A eq B)
 7-276 . {
 7-277 .    A = B + C;
 7-278 .    D = E + F;
 7-279 . }
 7-280 . 
 7-281 . A = B+C;
 7-282 . A = B/C;
 7-283 . 
 7-284 . if (A ge B)
 7-285 . {
 7-286 .    A = B + C;
 7-287 .    D = E + F;
 7-288 . }
 7-289 . 
 7-290 . // max LOC 65
 7-291 . 
 7-292 . }
 7-293 . 
 7-294 . 
 7-295 . /*
 7-296 . -----------------------------------------------------------------------------
 7-297 . --| NAME:   ca.7.2
 7-298 . --|
 7-299 . --| ABSTRACT:
 7-300 . --|   This function does ca stuff.
 7-301 . --|
 7-302 . --| RETURNS:
 7-303 . --|   NONE.
 7-304 . --|
 7-305 . ----------------------------------------------------------------------------
 7-306 . */
 7-307 . static void ca.7.2(void)
 7-308 . {
 7-309 . 
 7-310 . if (A != B)
 7-311 . {
 7-312 .    A = B + C;
 7-313 .    D = E + F;
 7-314 . }
 7-315 . 
 7-316 . A = B+C;
 7-317 . A = B*C;
 7-318 . A = B*C;
 7-319 . A = B-C;
 7-320 . A = B+C;
 7-321 . A = B+C;
 7-322 . A = B+C;
 7-323 . 
 7-324 . switch (ca stuff)
 7-325 . {
 7-326 .    case one:
 7-327 .    {
 7-328 .       run_this; 
 7-329 .       break;
 7-330 .    }
 7-331 .    case two:
 7-332 .    {
 7-333 .       run_this;
 7-334 .       break;
 7-335 .    }
 7-336 .    default:
 7-337 .    {
 7-338 .        SwError;
 7-339 .    }
 7-340 . }
 7-341 . 
 7-342 . 
 7-343 . if (A le B)
 7-344 . {
 7-345 .    A = B + C;
 7-346 .    D = E + F;
 7-347 . }
 7-348 . 
 7-349 . A = B/C;
 7-350 . A = B*C;
 7-351 . A = B-C;
 7-352 . A = B+C;
 7-353 . A = B+C;
 7-354 . 
 7-355 . if (A > = B)
 7-356 . {
 7-357 .    A = B + C;
 7-358 .    D = E + F;
 7-359 . }
 7-360 . 
 7-361 . 
 7-362 . if (veg)
 7-363 .    // missing curly brace
 7-364 .    variable = orange;
 7-365 . 
 7-366 . 
 7-367 . if (A eq B)
 7-368 . {
 7-369 .    A = B + C;
 7-370 .    D = E + F;
 7-371 . }
 7-372 . 
 7-373 . A = B*C;
 7-374 . A = B*C;
 7-375 . 
 7-376 . if (A lt B)
 7-377 . {
 7-378 .    A = B + C;
 7-379 .    D = E + F;
 7-380 . }
 7-381 . 
 7-382 . A = B+C;
 7-383 . 
 7-384 . if (A > = B)
 7-385 . {
 7-386 .    A = B + C;
 7-387 .    D = E + F;
 7-388 . }
 7-389 . 
 7-390 . /* LE SV TOC-1113 this is a ca-07.2.23 req to call admin*/
 7-391 . A = B+C;
 7-392 . /* LE SV TOC-1114 this is a ca-07.2.24 req to convert*/
 7-393 . A = B*C;
 7-394 . /* LE SV TOC-1115 this is a ca-07.2.25 req to reject*/
 7-395 . A = B/C;
 7-396 . A = B-C;
 7-397 . A = B/C;
 7-398 . A = B-C;
 7-399 . A = B+C;
 7-400 . A = B-C;
 7-401 . 
 7-402 . if (A le B)
 7-403 . {
 7-404 .    A = B + C;
 7-405 .    D = E + F;
 7-406 . }
 7-407 . 
 7-408 . A = B+C;
 7-409 . 
 7-410 . if (A ne B)
 7-411 . {
 7-412 .    A = B + C;
 7-413 .    D = E + F;
 7-414 . }
 7-415 . 
 7-416 . A = B+C;
 7-417 . A = B*C;
 7-418 . A = B/C;
 7-419 . A = B-C;
 7-420 . 
 7-421 . if (A gt B)
 7-422 . {
 7-423 .    A = B + C;
 7-424 .    D = E + F;
 7-425 . }
 7-426 . 
 7-427 . A = B/C;
 7-428 . 
 7-429 . if (A < = B)
 7-430 . {
 7-431 .    A = B + C;
 7-432 .    D = E + F;
 7-433 . }
 7-434 . 
 7-435 . A = B+C;
 7-436 . A = B+C;
 7-437 . 
 7-438 . if (A == B)
 7-439 . {
 7-440 .    A = B + C;
 7-441 .    D = E + F;
 7-442 . }
 7-443 . 
 7-444 . A = B/C;
 7-445 . A = B/C;
 7-446 . A = B*C;
 7-447 . A = B+C;
 7-448 . A = B*C;
 7-449 . A = B/C;
 7-450 . A = B*C;
 7-451 . A = B/C;
 7-452 . A = B/C;
 7-453 . A = B/C;
 7-454 . 
 7-455 . if (A <  B)
 7-456 . {
 7-457 .    A = B + C;
 7-458 .    D = E + F;
 7-459 . }
 7-460 . 
 7-461 . A = B+C;
 7-462 . A = B-C;
 7-463 . A = B*C;
 7-464 . A = B*C;
 7-465 . 
 7-466 . if (A > = B)
 7-467 . {
 7-468 .    A = B + C;
 7-469 .    D = E + F;
 7-470 . }
 7-471 . 
 7-472 . A = B/C;
 7-473 . 
 7-474 . if (A ne B)
 7-475 . {
 7-476 .    A = B + C;
 7-477 .    D = E + F;
 7-478 . }
 7-479 . 
 7-480 . 
 7-481 . if (A >  B)
 7-482 . {
 7-483 .    A = B + C;
 7-484 .    D = E + F;
 7-485 . }
 7-486 . 
 7-487 . A = 0x0004;
 7-488 . A = B*C;
 7-489 . /* LE SV TOC-1116 this is a ca-07.2.64 req to call admin*/
 7-490 . 
 7-491 . if (A > = B)
 7-492 . {
 7-493 .    A = B + C;
 7-494 .    D = E + F;
 7-495 . }
 7-496 . 
 7-497 . A = B/C;
 7-498 . A = B/C;
 7-499 . A = B+C;
 7-500 . A = B+C;
 7-501 . A = B*C;
 7-502 . 
 7-503 . if (A gt B)
 7-504 . {
 7-505 .    A = B + C;
 7-506 .    D = E + F;
 7-507 . }
 7-508 . 
 7-509 . A = B/C;
 7-510 . 
 7-511 . if (A lt B)
 7-512 . {
 7-513 .    A = B + C;
 7-514 .    D = E + F;
 7-515 . }
 7-516 . 
 7-517 . A = B+C;
 7-518 . A = B-C;
 7-519 . A = B*C;
 7-520 . 
 7-521 . if (A >  B)
 7-522 . {
 7-523 .    A = B + C;
 7-524 .    D = E + F;
 7-525 . }
 7-526 . 
 7-527 . A = B+C;
 7-528 . FreePtr = HmiStringPtr;
 7-529 . 
 7-530 . if (A ge B)
 7-531 . {
 7-532 .    A = B + C;
 7-533 .    D = E + F;
 7-534 . }
 7-535 . 
 7-536 . A = B*C;
 7-537 . A = B*C;
 7-538 . A = B*C;
 7-539 . 
 7-540 . if (A >  B)
 7-541 . {
 7-542 .    A = B + C;
 7-543 .    D = E + F;
 7-544 . }
 7-545 . 
 7-546 . 
 7-547 . if (A ne B)
 7-548 . {
 7-549 .    A = B + C;
 7-550 .    D = E + F;
 7-551 . }
 7-552 . 
 7-553 . A = B*C;
 7-554 . A = B+C;
 7-555 . A = B/C;
 7-556 . A = B/C;
 7-557 . A = B*C;
 7-558 . A = B-C;
 7-559 . 
 7-560 . if (A > = B)
 7-561 . {
 7-562 .    A = B + C;
 7-563 .    D = E + F;
 7-564 . }
 7-565 . 
 7-566 . 
 7-567 . if (A eq B)
 7-568 . {
 7-569 .    A = B + C;
 7-570 .    D = E + F;
 7-571 . }
 7-572 . 
 7-573 . 
 7-574 . if {
 7-575 .    X = Y + Z;
 7-576 . }
 7-577 . else {
 7-578 .    halt;
 7-579 . }
 7-580 . 
 7-581 . A = B-C;
 7-582 . A = B*C;
 7-583 . /* LE SV TOC-1117 this is a ca-07.2.94 req to transform*/
 7-584 . A = B*C;
 7-585 . // max LOC 94
 7-586 . 
 7-587 . }
 7-588 . 
 7-589 . 
 7-590 . /*
 7-591 . -----------------------------------------------------------------------------
 7-592 . --| NAME:   ca.7.3
 7-593 . --|
 7-594 . --| ABSTRACT:
 7-595 . --|   This function does ca stuff.
 7-596 . --|
 7-597 . --| RETURNS:
 7-598 . --|   NONE.
 7-599 . --|
 7-600 . ----------------------------------------------------------------------------
 7-601 . */
 7-602 . static void ca.7.3(void)
 7-603 . {
 7-604 . A = B/C;
 7-605 . A = 0x0008;
 7-606 . A = B-C;
 7-607 . A = B*C;
 7-608 . A = B-C;
 7-609 . A = B*C;
 7-610 . A = B+C;
 7-611 . A = B/C;
 7-612 . A = B/C;
 7-613 . A = B/C;
 7-614 . A = B-C;
 7-615 . A = B+C;
 7-616 . 
 7-617 . if (A lt B)
 7-618 . {
 7-619 .    A = B + C;
 7-620 .    D = E + F;
 7-621 . }
 7-622 . 
 7-623 . 
 7-624 . if (A > = B)
 7-625 . {
 7-626 .    A = B + C;
 7-627 .    D = E + F;
 7-628 . }
 7-629 . 
 7-630 . A = B/C;
 7-631 . 
 7-632 . switch (ca stuff)
 7-633 . {
 7-634 .    case one:
 7-635 .    {
 7-636 .       run_this; 
 7-637 .       break;
 7-638 .    }
 7-639 .    case two:
 7-640 .    {
 7-641 .       run_this;
 7-642 .       break;
 7-643 .    }
 7-644 .    default:
 7-645 .    {
 7-646 .        SwError;
 7-647 .    }
 7-648 . }
 7-649 . 
 7-650 . /* LE SV TOC-1118 this is a ca-07.3.16 req to convert*/
 7-651 . A = B*C;
 7-652 . A = B*C;
 7-653 . A = B*C;
 7-654 . A = B-C;
 7-655 . A = B*C;
 7-656 . A = B*C;
 7-657 . A = B/C;
 7-658 . A = 0x0008;
 7-659 . A = B/C;
 7-660 . 
 7-661 . if (A >  B)
 7-662 . {
 7-663 .    A = B + C;
 7-664 .    D = E + F;
 7-665 . }
 7-666 . 
 7-667 . A = B/C;
 7-668 . /* LE SV TOC-1119 this is a ca-07.3.26 req to call admin*/
 7-669 . A = B*C;
 7-670 . A = B-C;
 7-671 . 
 7-672 . if (A < = B)
 7-673 . {
 7-674 .    A = B + C;
 7-675 .    D = E + F;
 7-676 . }
 7-677 . 
 7-678 . // TBD - what do I do now
 7-679 . A = B/C;
 7-680 . A = B*C;
 7-681 . 
 7-682 . if (A >  B)
 7-683 . {
 7-684 .    A = B + C;
 7-685 .    D = E + F;
 7-686 . }
 7-687 . 
 7-688 . 
 7-689 . if (A < = B)
 7-690 . {
 7-691 .    A = B + C;
 7-692 .    D = E + F;
 7-693 . }
 7-694 . 
 7-695 . A = B-C;
 7-696 . A = B+C;
 7-697 . A = B-C;
 7-698 . A = B-C;
 7-699 . A = (int)B + C;
 7-700 . A = B+C;
 7-701 . 
 7-702 . if (A <  B)
 7-703 . {
 7-704 .    A = B + C;
 7-705 .    D = E + F;
 7-706 . }
 7-707 . 
 7-708 . 
 7-709 . if (A lt B)
 7-710 . {
 7-711 .    A = B + C;
 7-712 .    D = E + F;
 7-713 . }
 7-714 . 
 7-715 . A = B+C;
 7-716 . A = B/C;
 7-717 . A = B-C;
 7-718 . A = B*C;
 7-719 . A = B*C;
 7-720 . 
 7-721 . if (A lt B)
 7-722 . {
 7-723 .    A = B + C;
 7-724 .    D = E + F;
 7-725 . }
 7-726 . 
 7-727 . 
 7-728 . switch (ca stuff)
 7-729 . {
 7-730 .    case one:
 7-731 .    {
 7-732 .       run_this; 
 7-733 .       break;
 7-734 .    }
 7-735 .    case two:
 7-736 .    {
 7-737 .       run_this;
 7-738 .       break;
 7-739 .    }
 7-740 .    default:
 7-741 .    {
 7-742 .        SwError;
 7-743 .    }
 7-744 . }
 7-745 . 
 7-746 . A = B*C;
 7-747 . A = B+C;
 7-748 . A = B+C;
 7-749 . 
 7-750 . if (A >  B)
 7-751 . {
 7-752 .    A = B + C;
 7-753 .    D = E + F;
 7-754 . }
 7-755 . 
 7-756 . /* LE SV TOC-1120 this is a ca-07.3.51 req to check pSOS*/
 7-757 . 
 7-758 . switch (ca stuff)
 7-759 . {
 7-760 .    case one:
 7-761 .    {
 7-762 .       run_this; 
 7-763 .       // missing break
 7-764 .    }
 7-765 .    case two:
 7-766 .    {
 7-767 .       run_this;
 7-768 .       break;
 7-769 .    }
 7-770 .    default:
 7-771 .    {
 7-772 .       SwError;
 7-773 .    }
 7-774 . }
 7-775 . 
 7-776 . 
 7-777 . if (A <  B)
 7-778 . {
 7-779 .    A = B + C;
 7-780 .    D = E + F;
 7-781 . }
 7-782 . 
 7-783 . 
 7-784 . if (A != B)
 7-785 . {
 7-786 .    A = B + C;
 7-787 .    D = E + F;
 7-788 . }
 7-789 . 
 7-790 . // max LOC 52
 7-791 . 
 7-792 . }
 7-793 . 
 7-794 . 
 7-795 . /*
 7-796 . -----------------------------------------------------------------------------
 7-797 . --| NAME:   ca.7.4
 7-798 . --|
 7-799 . --| ABSTRACT:
 7-800 . --|   This function does ca stuff.
 7-801 . --|
 7-802 . --| RETURNS:
 7-803 . --|   NONE.
 7-804 . --|
 7-805 . ----------------------------------------------------------------------------
 7-806 . */
 7-807 . static void ca.7.4(void)
 7-808 . {
 7-809 . 
 7-810 . if (A le B)
 7-811 . {
 7-812 .    A = B + C;
 7-813 .    D = E + F;
 7-814 . }
 7-815 . 
 7-816 . 
 7-817 . if (A < = B)
 7-818 . {
 7-819 .    A = B + C;
 7-820 .    D = E + F;
 7-821 . }
 7-822 . 
 7-823 . A = B/C;
 7-824 . A = B-C;
 7-825 . A = B-C;
 7-826 . A = B/C;
 7-827 . A = B*C;
 7-828 . A = B*C;
 7-829 . 
 7-830 . if (A <  B)
 7-831 . {
 7-832 .    A = B + C;
 7-833 .    D = E + F;
 7-834 . }
 7-835 . 
 7-836 . 
 7-837 . if (A < = B)
 7-838 . {
 7-839 .    A = B + C;
 7-840 .    D = E + F;
 7-841 . }
 7-842 . 
 7-843 . // TBD - what do I do now
 7-844 . A = B+C;
 7-845 . A = B+C;
 7-846 . /* LE SV TOC-1121 this is a ca-07.4.13 req to inhibit*/
 7-847 . A = B+C;
 7-848 . 
 7-849 . if (A > = B)
 7-850 . {
 7-851 .    A = B + C;
 7-852 .    D = E + F;
 7-853 . }
 7-854 . 
 7-855 . A = B-C;
 7-856 . /* LE SV TOC-1122 this is a ca-07.4.16 req to audit*/
 7-857 . A = B-C;
 7-858 . 
 7-859 . switch (ca stuff)
 7-860 . {
 7-861 .    case one:
 7-862 .    {
 7-863 .       run_this; 
 7-864 .       break;
 7-865 .    }
 7-866 .    case two:
 7-867 .    {
 7-868 .       run_this;
 7-869 .       break;
 7-870 .    }
 7-871 .    default:
 7-872 .    {
 7-873 .        SwError;
 7-874 .    }
 7-875 . }
 7-876 . 
 7-877 . /* LE SV TOC-1123 this is a ca-07.4.18 req to detect error*/
 7-878 . 
 7-879 . if (A ne B)
 7-880 . {
 7-881 .    A = B + C;
 7-882 .    D = E + F;
 7-883 . }
 7-884 . 
 7-885 . 
 7-886 . if (A > = B)
 7-887 . {
 7-888 .    A = B + C;
 7-889 .    D = E + F;
 7-890 . }
 7-891 . 
 7-892 . A = B/C;
 7-893 . A = B/C;
 7-894 . A = B+C;
 7-895 . A = B/C;
 7-896 . // max LOC 23
 7-897 . 
 7-898 . }
 7-899 . 
 7-900 . 
 7-901 . /*
 7-902 . -----------------------------------------------------------------------------
 7-903 . --| NAME:   ca.7.5
 7-904 . --|
 7-905 . --| ABSTRACT:
 7-906 . --|   This function does ca stuff.
 7-907 . --|
 7-908 . --| RETURNS:
 7-909 . --|   NONE.
 7-910 . --|
 7-911 . ----------------------------------------------------------------------------
 7-912 . */
 7-913 . static void ca.7.5(void)
 7-914 . {
 7-915 . A = B/C;
 7-916 . A = B+C;
 7-917 . 
 7-918 . if (A > = B)
 7-919 . {
 7-920 .    A = B + C;
 7-921 .    D = E + F;
 7-922 . }
 7-923 . 
 7-924 . A = B+C;
 7-925 . A = B/C;
 7-926 . A = B+C;
 7-927 . /* LE SV TOC-1124 this is a ca-07.5.7 req to update*/
 7-928 . A = B/C;
 7-929 . A = B/C;
 7-930 . A = B+C;
 7-931 . A = B+C;
 7-932 . A = B*C;
 7-933 . A = 0x0007;
 7-934 . A = B-C;
 7-935 . A = B/C;
 7-936 . A = B/C;
 7-937 . 
 7-938 . if (A <  B)
 7-939 . {
 7-940 .    A = B + C;
 7-941 .    D = E + F;
 7-942 . }
 7-943 . 
 7-944 . A = B/C;
 7-945 . A = B/C;
 7-946 . 
 7-947 . if (A lt B)
 7-948 . {
 7-949 .    A = B + C;
 7-950 .    D = E + F;
 7-951 . }
 7-952 . 
 7-953 . A = B/C;
 7-954 . 
 7-955 . if (A < = B)
 7-956 . {
 7-957 .    A = B + C;
 7-958 .    D = E + F;
 7-959 . }
 7-960 . 
 7-961 . A = B*C;
 7-962 . A = B*C;
 7-963 . A = B-C;
 7-964 . A = (int)B + C;
 7-965 . 
 7-966 . if (A > = B)
 7-967 . {
 7-968 .    A = B + C;
 7-969 .    D = E + F;
 7-970 . }
 7-971 . 
 7-972 . A = B+C;
 7-973 . A = B/C;
 7-974 . // max LOC 26
 7-975 . 
 7-976 . }
 7-977 . 
 7-978 . 
 7-979 . /*
 7-980 . -----------------------------------------------------------------------------
 7-981 . --| NAME:   ca.7.6
 7-982 . --|
 7-983 . --| ABSTRACT:
 7-984 . --|   This function does ca stuff.
 7-985 . --|
 7-986 . --| RETURNS:
 7-987 . --|   NONE.
 7-988 . --|
 7-989 . ----------------------------------------------------------------------------
 7-990 . */
 7-991 . static void ca.7.6(void)
 7-992 . {
 7-993 . A = B*C;
 7-994 . A = B/C;
 7-995 . 
 7-996 . if (A ge B)
 7-997 . {
 7-998 .    A = B + C;
 7-999 .    D = E + F;
 7-1000 . }
 7-1001 . 
 7-1002 . 
 7-1003 . if (A ge B)
 7-1004 . {
 7-1005 .    A = B + C;
 7-1006 .    D = E + F;
 7-1007 . }
 7-1008 . 
 7-1009 . A = B-C;
 7-1010 . 
 7-1011 . if (A >  B)
 7-1012 . {
 7-1013 .    A = B + C;
 7-1014 .    D = E + F;
 7-1015 . }
 7-1016 . 
 7-1017 . A = B+C;
 7-1018 . A = B+C;
 7-1019 . A = B*C;
 7-1020 . A = B*C;
 7-1021 . 
 7-1022 . if (A lt B)
 7-1023 . {
 7-1024 .    A = B + C;
 7-1025 .    D = E + F;
 7-1026 . }
 7-1027 . 
 7-1028 . A = B+C;
 7-1029 . /* LE SV TOC-1125 this is a ca-07.6.13 req to enable*/
 7-1030 . 
 7-1031 . if (A lt B)
 7-1032 . {
 7-1033 .    A = B + C;
 7-1034 .    D = E + F;
 7-1035 . }
 7-1036 . 
 7-1037 . A = B*C;
 7-1038 . 
 7-1039 . if (A gt B)
 7-1040 . {
 7-1041 .    A = B + C;
 7-1042 .    D = E + F;
 7-1043 . }
 7-1044 . 
 7-1045 . A = B*C;
 7-1046 . A = B-C;
 7-1047 . A = B*C;
 7-1048 . A = B*C;
 7-1049 . A = B/C;
 7-1050 . A = B/C;
 7-1051 . A = B/C;
 7-1052 . A = B*C;
 7-1053 . A = B/C;
 7-1054 . A = B-C;
 7-1055 . A = B/C;
 7-1056 . 
 7-1057 . if (A > = B)
 7-1058 . {
 7-1059 .    A = B + C;
 7-1060 .    D = E + F;
 7-1061 . }
 7-1062 . 
 7-1063 . 
 7-1064 . if (A eq B)
 7-1065 . {
 7-1066 .    A = B + C;
 7-1067 .    D = E + F;
 7-1068 . }
 7-1069 . 
 7-1070 . A = B-C;
 7-1071 . 
 7-1072 . if (A lt B)
 7-1073 . {
 7-1074 .    A = B + C;
 7-1075 .    D = E + F;
 7-1076 . }
 7-1077 . 
 7-1078 . /* LE SV TOC-1126 this is a ca-07.6.31 req to process*/
 7-1079 . A = B-C;
 7-1080 . A = B+C;
 7-1081 . A = B+C;
 7-1082 . 
 7-1083 . if (A le B)
 7-1084 . {
 7-1085 .    A = B + C;
 7-1086 .    D = E + F;
 7-1087 . }
 7-1088 . 
 7-1089 . 
 7-1090 . if (A ne B)
 7-1091 . {
 7-1092 .    A = B + C;
 7-1093 .    D = E + F;
 7-1094 . }
 7-1095 . 
 7-1096 . A = B*C;
 7-1097 . 
 7-1098 . if (A == B)
 7-1099 . {
 7-1100 .    A = B + C;
 7-1101 .    D = E + F;
 7-1102 . }
 7-1103 . 
 7-1104 . A = B-C;
 7-1105 . A = B+C;
 7-1106 . A = B/C;
 7-1107 . A = B+C;
 7-1108 . A = B+C;
 7-1109 . 
 7-1110 . if (A != B)
 7-1111 . {
 7-1112 .    A = B + C;
 7-1113 .    D = E + F;
 7-1114 . }
 7-1115 . 
 7-1116 . A = B+C;
 7-1117 . 
 7-1118 . if (A le B)
 7-1119 . {
 7-1120 .    A = B + C;
 7-1121 .    D = E + F;
 7-1122 . }
 7-1123 . 
 7-1124 . A = B+C;
 7-1125 . 
 7-1126 . if (A <  B)
 7-1127 . {
 7-1128 .    A = B + C;
 7-1129 .    D = E + F;
 7-1130 . }
 7-1131 . 
 7-1132 . A = B*C;
 7-1133 . 
 7-1134 . if (A > = B)
 7-1135 . {
 7-1136 .    A = B + C;
 7-1137 .    D = E + F;
 7-1138 . }
 7-1139 . 
 7-1140 . A = B+C;
 7-1141 . /* LE SV TOC-1127 this is a ca-07.6.51 req to compare*/
 7-1142 . 
 7-1143 . if (A != B)
 7-1144 . {
 7-1145 .    A = B + C;
 7-1146 .    D = E + F;
 7-1147 . }
 7-1148 . 
 7-1149 . A = B*C;
 7-1150 . A = B/C;
 7-1151 . A = B/C;
 7-1152 . A = B/C;
 7-1153 . A = B*C;
 7-1154 . A = B/C;
 7-1155 . A = B-C;
 7-1156 . A = B/C;
 7-1157 . A = B+C;
 7-1158 . /* LE SV TOC-1128 this is a ca-07.6.61 req to enable*/
 7-1159 . 
 7-1160 . if (A ne B)
 7-1161 . {
 7-1162 .    A = B + C;
 7-1163 .    D = E + F;
 7-1164 . }
 7-1165 . 
 7-1166 . A = B/C;
 7-1167 . // (P) this is really improtant
 7-1168 . A = B-C;
 7-1169 . 
 7-1170 . switch (ca stuff)
 7-1171 . {
 7-1172 .    case one:
 7-1173 .    {
 7-1174 .       run_this; 
 7-1175 .       break;
 7-1176 .    }
 7-1177 .    case two:
 7-1178 .    {
 7-1179 .       run_this;
 7-1180 .       break;
 7-1181 .    }
 7-1182 .    default:
 7-1183 .    {
 7-1184 .        SwError;
 7-1185 .    }
 7-1186 . }
 7-1187 . 
 7-1188 . 
 7-1189 . if (A ge B)
 7-1190 . {
 7-1191 .    A = B + C;
 7-1192 .    D = E + F;
 7-1193 . }
 7-1194 . 
 7-1195 . 
 7-1196 . if (A <  B)
 7-1197 . {
 7-1198 .    A = B + C;
 7-1199 .    D = E + F;
 7-1200 . }
 7-1201 . 
 7-1202 . A = B+C;
 7-1203 . A = B-C;
 7-1204 . 
 7-1205 . if (A == B)
 7-1206 . {
 7-1207 .    A = B + C;
 7-1208 .    D = E + F;
 7-1209 . }
 7-1210 . 
 7-1211 . A = B-C;
 7-1212 . A = B*C;
 7-1213 . A = B/C;
 7-1214 . A = B/C;
 7-1215 . /* LE SV TOC-1129 this is a ca-07.6.74 req to inhibit*/
 7-1216 . A = B*C;
 7-1217 . 
 7-1218 . if (A < = B)
 7-1219 . {
 7-1220 .    A = B + C;
 7-1221 .    D = E + F;
 7-1222 . }
 7-1223 . 
 7-1224 . A = B+C;
 7-1225 . A = B/C;
 7-1226 . // max LOC 77
 7-1227 . 
 7-1228 . }
 7-1229 . 
 7-1230 . 
 7-1231 . /*
 7-1232 . -----------------------------------------------------------------------------
 7-1233 . --| NAME:   ca.7.7
 7-1234 . --|
 7-1235 . --| ABSTRACT:
 7-1236 . --|   This function does ca stuff.
 7-1237 . --|
 7-1238 . --| RETURNS:
 7-1239 . --|   NONE.
 7-1240 . --|
 7-1241 . ----------------------------------------------------------------------------
 7-1242 . */
 7-1243 . static void ca.7.7(void)
 7-1244 . {
 7-1245 . A = B/C;
 7-1246 . A = B*C;
 7-1247 . 
 7-1248 . if (A eq B)
 7-1249 . {
 7-1250 .    A = B + C;
 7-1251 .    D = E + F;
 7-1252 . }
 7-1253 . 
 7-1254 . 
 7-1255 . if (A ne B)
 7-1256 . {
 7-1257 .    A = B + C;
 7-1258 .    D = E + F;
 7-1259 . }
 7-1260 . 
 7-1261 . 
 7-1262 . if (A eq B)
 7-1263 . {
 7-1264 .    A = B + C;
 7-1265 .    D = E + F;
 7-1266 . }
 7-1267 . 
 7-1268 . A = B-C;
 7-1269 . 
 7-1270 . if (A != B)
 7-1271 . {
 7-1272 .    A = B + C;
 7-1273 .    D = E + F;
 7-1274 . }
 7-1275 . 
 7-1276 . 
 7-1277 . if (A le B)
 7-1278 . {
 7-1279 .    A = B + C;
 7-1280 .    D = E + F;
 7-1281 . }
 7-1282 . 
 7-1283 . 
 7-1284 . if (A > = B)
 7-1285 . {
 7-1286 .    A = B + C;
 7-1287 .    D = E + F;
 7-1288 . }
 7-1289 . 
 7-1290 . 
 7-1291 . if (A lt B)
 7-1292 . {
 7-1293 .    A = B + C;
 7-1294 .    D = E + F;
 7-1295 . }
 7-1296 . 
 7-1297 . A = B+C;
 7-1298 . A = B/C;
 7-1299 . 
 7-1300 . if (A < = B)
 7-1301 . {
 7-1302 .    A = B + C;
 7-1303 .    D = E + F;
 7-1304 . }
 7-1305 . 
 7-1306 . 
 7-1307 . if (A ne B)
 7-1308 . {
 7-1309 .    A = B + C;
 7-1310 .    D = E + F;
 7-1311 . }
 7-1312 . 
 7-1313 . 
 7-1314 . if (A eq B)
 7-1315 . {
 7-1316 .    A = B + C;
 7-1317 .    D = E + F;
 7-1318 . }
 7-1319 . 
 7-1320 . A = B+C;
 7-1321 . 
 7-1322 . if (A != B)
 7-1323 . {
 7-1324 .    A = B + C;
 7-1325 .    D = E + F;
 7-1326 . }
 7-1327 . 
 7-1328 . // max LOC 17
 7-1329 . 
 7-1330 . }
 7-1331 . 

7 7 Result: result/source/ft-app/ft-app-B1.1/ca/ca-07.c


8 8 Source: source/ft-app/ft-app-B1.1/ca/ca-08.c
 8-0 . /*
 8-1 . ----------------------------------------------------------------------------
 8-2 . --| BEGIN PROLOGUE
 8-3 . --|
 8-4 . --| CLASSIFICATION: UNCLASSIFIED
 8-5 . --|
 8-6 . --| FILE NAME:      ca-08.c
 8-7 . --|
 8-8 . --| ABSTRACT:
 8-9 . --|   This file contains the 12 functions that do file ca stuff.
 8-10 . --|
 8-11 . --| HISTORY:
 8-12 . --|   CCCQ_NAME:
 8-13 . --|   CCCQ_VER: 
 8-14 . --|
 8-15 . --| END PROLOGUE
 8-16 . ----------------------------------------------------------------------------
 8-17 . */
 8-18 . 
 8-19 . #include B;
 8-20 . float B;
 8-21 . char D;
 8-22 . #define A;
 8-23 . #define C;
 8-24 . #include D;
 8-25 . #include A;
 8-26 . #include A;
 8-27 . 
 8-28 . 
 8-29 . 
 8-30 . /*
 8-31 . -----------------------------------------------------------------------------
 8-32 . --| NAME:   ca.8.1
 8-33 . --|
 8-34 . --| ABSTRACT:
 8-35 . --|   This function does ca stuff.
 8-36 . --|
 8-37 . --| RETURNS:
 8-38 . --|   NONE.
 8-39 . --|
 8-40 . ----------------------------------------------------------------------------
 8-41 . */
 8-42 . static void ca.8.1(void)
 8-43 . {
 8-44 . A = B+C;
 8-45 . A = B-C;
 8-46 . A = B+C;
 8-47 . A = B*C;
 8-48 . A = B-C;
 8-49 . A = B*C;
 8-50 . /* LE SV TOC-1130 this is a ca-08.1.7 req to fail*/
 8-51 . A = B+C;
 8-52 . A = B+C;
 8-53 . A = B+C;
 8-54 . 
 8-55 . if (A == B)
 8-56 . {
 8-57 .    A = B + C;
 8-58 .    D = E + F;
 8-59 . }
 8-60 . 
 8-61 . 
 8-62 . /* dead_block = C * D; 
 8-63 . dead_block = E * F; */
 8-64 . 
 8-65 . A = B/C;
 8-66 . 
 8-67 . if (A < = B)
 8-68 . {
 8-69 .    A = B + C;
 8-70 .    D = E + F;
 8-71 . }
 8-72 . 
 8-73 . A = B*C;
 8-74 . A = B*C;
 8-75 . A = B+C;
 8-76 . A = B/C;
 8-77 . 
 8-78 . if (A gt B)
 8-79 . {
 8-80 .    A = B + C;
 8-81 .    D = E + F;
 8-82 . }
 8-83 . 
 8-84 . A = B/C;
 8-85 . A = B-C;
 8-86 . A = B*C;
 8-87 . A = B+C;
 8-88 . A = B-C;
 8-89 . A = B-C;
 8-90 . A = B+C;
 8-91 . 
 8-92 . switch (ca stuff)
 8-93 . {
 8-94 .    case one:
 8-95 .    {
 8-96 .       run_this; 
 8-97 .       // missing break
 8-98 .    }
 8-99 .    case two:
 8-100 .    {
 8-101 .       run_this;
 8-102 .       break;
 8-103 .    }
 8-104 .    default:
 8-105 .    {
 8-106 .       SwError;
 8-107 .    }
 8-108 . }
 8-109 . 
 8-110 . A = B-C;
 8-111 . A = B-C;
 8-112 . A = B+C;
 8-113 . A = B+C;
 8-114 . A = B+C;
 8-115 . A = B/C;
 8-116 . A = B-C;
 8-117 . A = B*C;
 8-118 . 
 8-119 . if (A gt B)
 8-120 . {
 8-121 .    A = B + C;
 8-122 .    D = E + F;
 8-123 . }
 8-124 . 
 8-125 . 
 8-126 . if (A lt B)
 8-127 . {
 8-128 .    A = B + C;
 8-129 .    D = E + F;
 8-130 . }
 8-131 . 
 8-132 . A = B-C;
 8-133 . A = B*C;
 8-134 . A = (int)B + C;
 8-135 . A = B*C;
 8-136 . A = B*C;
 8-137 . A = B-C;
 8-138 . A = B/C;
 8-139 . 
 8-140 . if (A lt B)
 8-141 . {
 8-142 .    A = B + C;
 8-143 .    D = E + F;
 8-144 . }
 8-145 . 
 8-146 . A = B+C;
 8-147 . 
 8-148 . if (A ne B)
 8-149 . {
 8-150 .    A = B + C;
 8-151 .    D = E + F;
 8-152 . }
 8-153 . 
 8-154 . A = B+C;
 8-155 . A = B*C;
 8-156 . A = B/C;
 8-157 . send_buffer = (U16 *) malloc(size+1);
 8-158 . A = B+C;
 8-159 . A = B*C;
 8-160 . A = B/C;
 8-161 . A = B*C;
 8-162 . /* LE SV TOC-1131 this is a ca-08.1.51 req to set Real Time Clock*/
 8-163 . A = 0x0004;
 8-164 . A = B-C;
 8-165 . 
 8-166 . if (A < = B)
 8-167 . {
 8-168 .    A = B + C;
 8-169 .    D = E + F;
 8-170 . }
 8-171 . 
 8-172 . A = B/C;
 8-173 . 
 8-174 . if (A < = B)
 8-175 . {
 8-176 .    A = B + C;
 8-177 .    D = E + F;
 8-178 . }
 8-179 . 
 8-180 . 
 8-181 . if (A > = B)
 8-182 . {
 8-183 .    A = B + C;
 8-184 .    D = E + F;
 8-185 . }
 8-186 . 
 8-187 . A = B-C;
 8-188 . // max LOC 56
 8-189 . 
 8-190 . }
 8-191 . 
 8-192 . 
 8-193 . /*
 8-194 . -----------------------------------------------------------------------------
 8-195 . --| NAME:   ca.8.2
 8-196 . --|
 8-197 . --| ABSTRACT:
 8-198 . --|   This function does ca stuff.
 8-199 . --|
 8-200 . --| RETURNS:
 8-201 . --|   NONE.
 8-202 . --|
 8-203 . ----------------------------------------------------------------------------
 8-204 . */
 8-205 . static void ca.8.2(void)
 8-206 . {
 8-207 . 
 8-208 . if (A > = B)
 8-209 . {
 8-210 .    A = B + C;
 8-211 .    D = E + F;
 8-212 . }
 8-213 . 
 8-214 . A = B/C;
 8-215 . A = B+C;
 8-216 . A = B*C;
 8-217 . 
 8-218 . if (A > = B)
 8-219 . {
 8-220 .    A = B + C;
 8-221 .    D = E + F;
 8-222 . }
 8-223 . 
 8-224 . A = B/C;
 8-225 . 
 8-226 . if (A == B)
 8-227 . {
 8-228 .    A = B + C;
 8-229 .    D = E + F;
 8-230 . }
 8-231 . 
 8-232 . A = B+C;
 8-233 . A = B-C;
 8-234 . A = B/C;
 8-235 . 
 8-236 . if (A <  B)
 8-237 . {
 8-238 .    A = B + C;
 8-239 .    D = E + F;
 8-240 . }
 8-241 . 
 8-242 . // max LOC 11
 8-243 . 
 8-244 . }
 8-245 . 
 8-246 . 
 8-247 . /*
 8-248 . -----------------------------------------------------------------------------
 8-249 . --| NAME:   ca.8.3
 8-250 . --|
 8-251 . --| ABSTRACT:
 8-252 . --|   This function does ca stuff.
 8-253 . --|
 8-254 . --| RETURNS:
 8-255 . --|   NONE.
 8-256 . --|
 8-257 . ----------------------------------------------------------------------------
 8-258 . */
 8-259 . static void ca.8.3(void)
 8-260 . {
 8-261 . 
 8-262 . if (A gt B)
 8-263 . {
 8-264 .    A = B + C;
 8-265 .    D = E + F;
 8-266 . }
 8-267 . 
 8-268 . A = B-C;
 8-269 . A = B+C;
 8-270 . A = B+C;
 8-271 . 
 8-272 . if (A <  B)
 8-273 . {
 8-274 .    A = B + C;
 8-275 .    D = E + F;
 8-276 . }
 8-277 . 
 8-278 . /* LE SV TOC-1132 this is a ca-08.3.6 req to translate*/
 8-279 . A = B*C;
 8-280 . 
 8-281 . if (A eq B)
 8-282 . {
 8-283 .    A = B + C;
 8-284 .    D = E + F;
 8-285 . }
 8-286 . 
 8-287 . 
 8-288 . if (A > = B)
 8-289 . {
 8-290 .    A = B + C;
 8-291 .    D = E + F;
 8-292 . }
 8-293 . 
 8-294 . 
 8-295 . if (A >  B)
 8-296 . {
 8-297 .    A = B + C;
 8-298 .    D = E + F;
 8-299 . }
 8-300 . 
 8-301 . A = B-C;
 8-302 . A = B-C;
 8-303 . A = B+C;
 8-304 . A = B+C;
 8-305 . A = B-C;
 8-306 . A = B/C;
 8-307 . A = B-C;
 8-308 . A = B/C;
 8-309 . A = B*C;
 8-310 . 
 8-311 . /*
 8-312 . dead_block = C * D; 
 8-313 . dead_block = E * F;
 8-314 . */
 8-315 . 
 8-316 . 
 8-317 . if (A > = B)
 8-318 . {
 8-319 .    A = B + C;
 8-320 .    D = E + F;
 8-321 . }
 8-322 . 
 8-323 . A = B/C;
 8-324 . 
 8-325 . switch (ca stuff)
 8-326 . {
 8-327 .    case one:
 8-328 .    {
 8-329 .       run_this; 
 8-330 .       break;
 8-331 .    }
 8-332 .    case two:
 8-333 .    {
 8-334 .       run_this;
 8-335 .       break;
 8-336 .    }
 8-337 .    default:
 8-338 .    {
 8-339 .        SwError;
 8-340 .    }
 8-341 . }
 8-342 . 
 8-343 . 
 8-344 . if (A ge B)
 8-345 . {
 8-346 .    A = B + C;
 8-347 .    D = E + F;
 8-348 . }
 8-349 . 
 8-350 . 
 8-351 . if (A le B)
 8-352 . {
 8-353 .    A = B + C;
 8-354 .    D = E + F;
 8-355 . }
 8-356 . 
 8-357 . A = B-C;
 8-358 . 
 8-359 . if (A >  B)
 8-360 . {
 8-361 .    A = B + C;
 8-362 .    D = E + F;
 8-363 . }
 8-364 . 
 8-365 . 
 8-366 . if (A lt B)
 8-367 . {
 8-368 .    A = B + C;
 8-369 .    D = E + F;
 8-370 . }
 8-371 . 
 8-372 . 
 8-373 . if (A == B)
 8-374 . {
 8-375 .    A = B + C;
 8-376 .    D = E + F;
 8-377 . }
 8-378 . 
 8-379 . A = B/C;
 8-380 . A = B/C;
 8-381 . // max LOC 29
 8-382 . 
 8-383 . }
 8-384 . 
 8-385 . 
 8-386 . /*
 8-387 . -----------------------------------------------------------------------------
 8-388 . --| NAME:   ca.8.4
 8-389 . --|
 8-390 . --| ABSTRACT:
 8-391 . --|   This function does ca stuff.
 8-392 . --|
 8-393 . --| RETURNS:
 8-394 . --|   NONE.
 8-395 . --|
 8-396 . ----------------------------------------------------------------------------
 8-397 . */
 8-398 . static void ca.8.4(void)
 8-399 . {
 8-400 . 
 8-401 . if (A le B)
 8-402 . {
 8-403 .    A = B + C;
 8-404 .    D = E + F;
 8-405 . }
 8-406 . 
 8-407 . A = B/C;
 8-408 . 
 8-409 . switch (ca stuff)
 8-410 . {
 8-411 .    case one:
 8-412 .    {
 8-413 .       run_this; 
 8-414 .       break;
 8-415 .    }
 8-416 .    case two:
 8-417 .    {
 8-418 .       run_this;
 8-419 .       break;
 8-420 .    }
 8-421 .    default:
 8-422 .    {
 8-423 .        SwError;
 8-424 .    }
 8-425 . }
 8-426 . 
 8-427 . /* LE SV TOC-1133 this is a ca-08.4.4 req to translate*/
 8-428 . A = B-C;
 8-429 . 
 8-430 . if (A ge B)
 8-431 . {
 8-432 .    A = B + C;
 8-433 .    D = E + F;
 8-434 . }
 8-435 . 
 8-436 . A = B*C;
 8-437 . 
 8-438 . if (A > = B)
 8-439 . {
 8-440 .    A = B + C;
 8-441 .    D = E + F;
 8-442 . }
 8-443 . 
 8-444 . /* LE SV TOC-1134 this is a ca-08.4.8 req to set Real Time Clock*/
 8-445 . A = B/C;
 8-446 . 
 8-447 . if (A >  B)
 8-448 . {
 8-449 .    A = B + C;
 8-450 .    D = E + F;
 8-451 . }
 8-452 . 
 8-453 . rcv_buffer = (U16 *) alloc(size+1);
 8-454 . A = B-C;
 8-455 . /* LE SV TOC-1135 this is a ca-08.4.11 req to call admin*/
 8-456 . A = B*C;
 8-457 . 
 8-458 . if (A != B)
 8-459 . {
 8-460 .    A = B + C;
 8-461 .    D = E + F;
 8-462 . }
 8-463 . 
 8-464 . A = B/C;
 8-465 . 
 8-466 . if (A eq B)
 8-467 . {
 8-468 .    A = B + C;
 8-469 .    D = E + F;
 8-470 . }
 8-471 . 
 8-472 . 
 8-473 . if (A <  B)
 8-474 . {
 8-475 .    A = B + C;
 8-476 .    D = E + F;
 8-477 . }
 8-478 . 
 8-479 . A = B-C;
 8-480 . FreePtr = HmiStringPtr;
 8-481 . A = B+C;
 8-482 . A = B+C;
 8-483 . A = B/C;
 8-484 . A = B+C;
 8-485 . A = B/C;
 8-486 . /* LE SV TOC-1136 this is a ca-08.4.22 req to detect error*/
 8-487 . 
 8-488 . if (A != B)
 8-489 . {
 8-490 .    A = B + C;
 8-491 .    D = E + F;
 8-492 . }
 8-493 . 
 8-494 . A = B/C;
 8-495 . A = B+C;
 8-496 . // max LOC 24
 8-497 . 
 8-498 . }
 8-499 . 
 8-500 . 
 8-501 . /*
 8-502 . -----------------------------------------------------------------------------
 8-503 . --| NAME:   ca.8.5
 8-504 . --|
 8-505 . --| ABSTRACT:
 8-506 . --|   This function does ca stuff.
 8-507 . --|
 8-508 . --| RETURNS:
 8-509 . --|   NONE.
 8-510 . --|
 8-511 . ----------------------------------------------------------------------------
 8-512 . */
 8-513 . static void ca.8.5(void)
 8-514 . {
 8-515 . A = B+C;
 8-516 . 
 8-517 . if (A >  B)
 8-518 . {
 8-519 .    A = B + C;
 8-520 .    D = E + F;
 8-521 . }
 8-522 . 
 8-523 . A = B*C;
 8-524 . A = B+C;
 8-525 . 
 8-526 . if (A < = B)
 8-527 . {
 8-528 .    A = B + C;
 8-529 .    D = E + F;
 8-530 . }
 8-531 . 
 8-532 . 
 8-533 . if (A ge B)
 8-534 . {
 8-535 .    A = B + C;
 8-536 .    D = E + F;
 8-537 . }
 8-538 . 
 8-539 . 
 8-540 . if (A > = B)
 8-541 . {
 8-542 .    A = B + C;
 8-543 .    D = E + F;
 8-544 . }
 8-545 . 
 8-546 . A = B+C;
 8-547 . A = B*C;
 8-548 . 
 8-549 . if (A eq B)
 8-550 . {
 8-551 .    A = B + C;
 8-552 .    D = E + F;
 8-553 . }
 8-554 . 
 8-555 . A = B+C;
 8-556 . A = 0x0004;
 8-557 . 
 8-558 . if (A lt B)
 8-559 . {
 8-560 .    A = B + C;
 8-561 .    D = E + F;
 8-562 . }
 8-563 . 
 8-564 . // max LOC 12
 8-565 . 
 8-566 . }
 8-567 . 
 8-568 . 
 8-569 . /*
 8-570 . -----------------------------------------------------------------------------
 8-571 . --| NAME:   ca.8.6
 8-572 . --|
 8-573 . --| ABSTRACT:
 8-574 . --|   This function does ca stuff.
 8-575 . --|
 8-576 . --| RETURNS:
 8-577 . --|   NONE.
 8-578 . --|
 8-579 . ----------------------------------------------------------------------------
 8-580 . */
 8-581 . static void ca.8.6(void)
 8-582 . {
 8-583 . A = B*C;
 8-584 . A = B*C;
 8-585 . 
 8-586 . if ($ca stuff >  $otherca stuff) 
 8-587 . /* LE SV TOC-008 we really should log all error calls */
 8-588 . {
 8-589 .    A = B + C;
 8-590 . }
 8-591 . 
 8-592 . A = B*C;
 8-593 . 
 8-594 . if (A gt B)
 8-595 . {
 8-596 .    A = B + C;
 8-597 .    D = E + F;
 8-598 . }
 8-599 . 
 8-600 . A = B+C;
 8-601 . /* LE SV TOC-1137 this is a ca-08.6.6 req to enable*/
 8-602 . 
 8-603 . if (A gt B)
 8-604 . {
 8-605 .    A = B + C;
 8-606 .    D = E + F;
 8-607 . }
 8-608 . 
 8-609 . A = 0x0006;
 8-610 . 
 8-611 . if (A == B)
 8-612 . {
 8-613 .    A = B + C;
 8-614 .    D = E + F;
 8-615 . }
 8-616 . 
 8-617 . 
 8-618 . if (A < = B)
 8-619 . {
 8-620 .    A = B + C;
 8-621 .    D = E + F;
 8-622 . }
 8-623 . 
 8-624 . A = B*C;
 8-625 . A = B/C;
 8-626 . 
 8-627 . if (A le B)
 8-628 . {
 8-629 .    A = B + C;
 8-630 .    D = E + F;
 8-631 . }
 8-632 . 
 8-633 . A = B-C;
 8-634 . A = B-C;
 8-635 . A = B-C;
 8-636 . A = B+C;
 8-637 . A = B*C;
 8-638 . 
 8-639 . switch (ca stuff)
 8-640 . {
 8-641 .    case one:
 8-642 .    {
 8-643 .       run_this; 
 8-644 .       // missing break
 8-645 .    }
 8-646 .    case two:
 8-647 .    {
 8-648 .       run_this;
 8-649 .       break;
 8-650 .    }
 8-651 .    default:
 8-652 .    {
 8-653 .       SwError;
 8-654 .    }
 8-655 . }
 8-656 . 
 8-657 . A = B/C;
 8-658 . 
 8-659 . if (A lt B)
 8-660 . {
 8-661 .    A = B + C;
 8-662 .    D = E + F;
 8-663 . }
 8-664 . 
 8-665 . A = B/C;
 8-666 . A = B+C;
 8-667 . A = B+C;
 8-668 . A = B-C;
 8-669 . A = B/C;
 8-670 . /* LE SV TOC-1138 this is a ca-08.6.24 req to call isr*/
 8-671 . 
 8-672 . if (A < = B)
 8-673 . {
 8-674 .    A = B + C;
 8-675 .    D = E + F;
 8-676 . }
 8-677 . 
 8-678 . A = B-C;
 8-679 . A = B/C;
 8-680 . /* LE SV TOC-1139 this is a ca-08.6.27 req to call admin*/
 8-681 . 
 8-682 . if (A gt B)
 8-683 . {
 8-684 .    A = B + C;
 8-685 .    D = E + F;
 8-686 . }
 8-687 . 
 8-688 . A = B+C;
 8-689 . A = B+C;
 8-690 . 
 8-691 . if (A < = B)
 8-692 . {
 8-693 .    A = B + C;
 8-694 .    D = E + F;
 8-695 . }
 8-696 . 
 8-697 . A = B*C;
 8-698 . A = B+C;
 8-699 . A = B*C;
 8-700 . A = B*C;
 8-701 . A = 0x0003;
 8-702 . 
 8-703 . if (A == B)
 8-704 . {
 8-705 .    A = B + C;
 8-706 .    D = E + F;
 8-707 . }
 8-708 . 
 8-709 . 
 8-710 . if (A <  B)
 8-711 . {
 8-712 .    A = B + C;
 8-713 .    D = E + F;
 8-714 . }
 8-715 . 
 8-716 . A = B*C;
 8-717 . A = B+C;
 8-718 . A = B-C;
 8-719 . A = B-C;
 8-720 . A = B/C;
 8-721 . A = B-C;
 8-722 . A = B+C;
 8-723 . A = B/C;
 8-724 . 
 8-725 . if (A < = B)
 8-726 . {
 8-727 .    A = B + C;
 8-728 .    D = E + F;
 8-729 . }
 8-730 . 
 8-731 . A = B+C;
 8-732 . 
 8-733 . switch (ca stuff)
 8-734 . {
 8-735 .    case one:
 8-736 .    {
 8-737 .       run_this; 
 8-738 .       break;
 8-739 .    }
 8-740 .    case two:
 8-741 .    {
 8-742 .       run_this;
 8-743 .       break;
 8-744 .    }
 8-745 .    default:
 8-746 .    {
 8-747 .        SwError;
 8-748 .    }
 8-749 . }
 8-750 . 
 8-751 . 
 8-752 . if (A eq B)
 8-753 . {
 8-754 .    A = B + C;
 8-755 .    D = E + F;
 8-756 . }
 8-757 . 
 8-758 . A = B-C;
 8-759 . 
 8-760 . if (A >  B)
 8-761 . {
 8-762 .    A = B + C;
 8-763 .    D = E + F;
 8-764 . }
 8-765 . 
 8-766 . A = B+C;
 8-767 . 
 8-768 . if (A eq B)
 8-769 . {
 8-770 .    A = B + C;
 8-771 .    D = E + F;
 8-772 . }
 8-773 . 
 8-774 . A = B*C;
 8-775 . A = B-C;
 8-776 . 
 8-777 . if (A >  B)
 8-778 . {
 8-779 .    A = B + C;
 8-780 .    D = E + F;
 8-781 . }
 8-782 . 
 8-783 . 
 8-784 . if (A <  B)
 8-785 . {
 8-786 .    A = B + C;
 8-787 .    D = E + F;
 8-788 . }
 8-789 . 
 8-790 . A = B/C;
 8-791 . A = B+C;
 8-792 . A = B/C;
 8-793 . A = B+C;
 8-794 . 
 8-795 . if (A gt B)
 8-796 . {
 8-797 .    A = B + C;
 8-798 .    D = E + F;
 8-799 . }
 8-800 . 
 8-801 . A = B*C;
 8-802 . A = B-C;
 8-803 . A = B/C;
 8-804 . A = B*C;
 8-805 . A = B+C;
 8-806 . A = B/C;
 8-807 . A = B+C;
 8-808 . 
 8-809 . if (A gt B)
 8-810 . {
 8-811 .    A = B + C;
 8-812 .    D = E + F;
 8-813 . }
 8-814 . 
 8-815 . 
 8-816 . if (A <  B)
 8-817 . {
 8-818 .    A = B + C;
 8-819 .    D = E + F;
 8-820 . }
 8-821 . 
 8-822 . A = B*C;
 8-823 . A = B/C;
 8-824 . A = B+C;
 8-825 . 
 8-826 . if (A gt B)
 8-827 . {
 8-828 .    A = B + C;
 8-829 .    D = E + F;
 8-830 . }
 8-831 . 
 8-832 . // max LOC 74
 8-833 . 
 8-834 . }
 8-835 . 
 8-836 . 
 8-837 . /*
 8-838 . -----------------------------------------------------------------------------
 8-839 . --| NAME:   ca.8.7
 8-840 . --|
 8-841 . --| ABSTRACT:
 8-842 . --|   This function does ca stuff.
 8-843 . --|
 8-844 . --| RETURNS:
 8-845 . --|   NONE.
 8-846 . --|
 8-847 . ----------------------------------------------------------------------------
 8-848 . */
 8-849 . static void ca.8.7(void)
 8-850 . {
 8-851 . A = B/C;
 8-852 . A = B+C;
 8-853 . 
 8-854 . if (A < = B)
 8-855 . {
 8-856 .    A = B + C;
 8-857 .    D = E + F;
 8-858 . }
 8-859 . 
 8-860 . A = B*C;
 8-861 . 
 8-862 . if (A lt B)
 8-863 . {
 8-864 .    A = B + C;
 8-865 .    D = E + F;
 8-866 . }
 8-867 . 
 8-868 . A = B*C;
 8-869 . 
 8-870 . if (A >  B)
 8-871 . {
 8-872 .    A = B + C;
 8-873 .    D = E + F;
 8-874 . }
 8-875 . 
 8-876 . A = B+C;
 8-877 . 
 8-878 . if (A le B)
 8-879 . {
 8-880 .    A = B + C;
 8-881 .    D = E + F;
 8-882 . }
 8-883 . 
 8-884 . A = B-C;
 8-885 . A = B/C;
 8-886 . A = B+C;
 8-887 . A = B/C;
 8-888 . A = B+C;
 8-889 . A = B*C;
 8-890 . 
 8-891 . if (A < = B)
 8-892 . {
 8-893 .    A = B + C;
 8-894 .    D = E + F;
 8-895 . }
 8-896 . 
 8-897 . 
 8-898 . if (A ge B)
 8-899 . {
 8-900 .    A = B + C;
 8-901 .    D = E + F;
 8-902 . }
 8-903 . 
 8-904 . A = B*C;
 8-905 . 
 8-906 . switch (ca stuff)
 8-907 . {
 8-908 .    case one:
 8-909 .    {
 8-910 .       run_this; 
 8-911 .       break;
 8-912 .    }
 8-913 .    case two:
 8-914 .    {
 8-915 .       run_this;
 8-916 .       break;
 8-917 .    }
 8-918 .    default:
 8-919 .    {
 8-920 .        SwError;
 8-921 .    }
 8-922 . }
 8-923 . 
 8-924 . 
 8-925 . if (A le B)
 8-926 . {
 8-927 .    A = B + C;
 8-928 .    D = E + F;
 8-929 . }
 8-930 . 
 8-931 . A = B+C;
 8-932 . 
 8-933 . if (A ne B)
 8-934 . {
 8-935 .    A = B + C;
 8-936 .    D = E + F;
 8-937 . }
 8-938 . 
 8-939 . A = B/C;
 8-940 . A = B+C;
 8-941 . 
 8-942 . if (A le B)
 8-943 . {
 8-944 .    A = B + C;
 8-945 .    D = E + F;
 8-946 . }
 8-947 . 
 8-948 . A = B/C;
 8-949 . A = B/C;
 8-950 . A = B/C;
 8-951 . 
 8-952 . if (A == B)
 8-953 . {
 8-954 .    A = B + C;
 8-955 .    D = E + F;
 8-956 . }
 8-957 . 
 8-958 . 
 8-959 . if {
 8-960 .    X = Y + Z;
 8-961 . }
 8-962 . else {
 8-963 .    halt;
 8-964 . }
 8-965 . 
 8-966 . 
 8-967 . if (A <  B)
 8-968 . {
 8-969 .    A = B + C;
 8-970 .    D = E + F;
 8-971 . }
 8-972 . 
 8-973 . A = B+C;
 8-974 . 
 8-975 . if (A != B)
 8-976 . {
 8-977 .    A = B + C;
 8-978 .    D = E + F;
 8-979 . }
 8-980 . 
 8-981 . A = B-C;
 8-982 . 
 8-983 . if (A ge B)
 8-984 . {
 8-985 .    A = B + C;
 8-986 .    D = E + F;
 8-987 . }
 8-988 . 
 8-989 . 
 8-990 . switch (ca stuff)
 8-991 . {
 8-992 .    case one:
 8-993 .    {
 8-994 .       run_this; 
 8-995 .       break;
 8-996 .    }
 8-997 .    case two:
 8-998 .    {
 8-999 .       run_this;
 8-1000 .       break;
 8-1001 .    }
 8-1002 .    default:
 8-1003 .    {
 8-1004 .        SwError;
 8-1005 .    }
 8-1006 . }
 8-1007 . 
 8-1008 . A = B+C;
 8-1009 . A = B/C;
 8-1010 . A = B/C;
 8-1011 . 
 8-1012 . if (A < = B)
 8-1013 . {
 8-1014 .    A = B + C;
 8-1015 .    D = E + F;
 8-1016 . }
 8-1017 . 
 8-1018 . 
 8-1019 . if (A ge B)
 8-1020 . {
 8-1021 .    A = B + C;
 8-1022 .    D = E + F;
 8-1023 . }
 8-1024 . 
 8-1025 . A = B+C;
 8-1026 . A = B+C;
 8-1027 . A = B-C;
 8-1028 . A = 0x0009;
 8-1029 . A = B+C;
 8-1030 . A = 0x0003;
 8-1031 . 
 8-1032 . switch (ca stuff)
 8-1033 . {
 8-1034 .    case one:
 8-1035 .    {
 8-1036 .       run_this;
 8-1037 .       break;
 8-1038 .    }
 8-1039 .    case two:
 8-1040 .    {
 8-1041 .       run_this;
 8-1042 .       break;
 8-1043 .    }
 8-1044 .    // missing default
 8-1045 . }
 8-1046 . 
 8-1047 . A = B-C;
 8-1048 . A = B*C;
 8-1049 . A = B*C;
 8-1050 . A = B/C;
 8-1051 . A = B*C;
 8-1052 . A = B+C;
 8-1053 . A = B/C;
 8-1054 . // max LOC 51
 8-1055 . 
 8-1056 . }
 8-1057 . 
 8-1058 . 
 8-1059 . /*
 8-1060 . -----------------------------------------------------------------------------
 8-1061 . --| NAME:   ca.8.8
 8-1062 . --|
 8-1063 . --| ABSTRACT:
 8-1064 . --|   This function does ca stuff.
 8-1065 . --|
 8-1066 . --| RETURNS:
 8-1067 . --|   NONE.
 8-1068 . --|
 8-1069 . ----------------------------------------------------------------------------
 8-1070 . */
 8-1071 . static void ca.8.8(void)
 8-1072 . {
 8-1073 . A = B+C;
 8-1074 . /* LE SV TOC-1140 this is a ca-08.8.2 req to verify*/
 8-1075 . A = B/C;
 8-1076 . A = B*C;
 8-1077 . A = B+C;
 8-1078 . A = B*C;
 8-1079 . A = B/C;
 8-1080 . 
 8-1081 . if (A ne B)
 8-1082 . {
 8-1083 .    A = B + C;
 8-1084 .    D = E + F;
 8-1085 . }
 8-1086 . 
 8-1087 . 
 8-1088 . if (A != B)
 8-1089 . {
 8-1090 .    A = B + C;
 8-1091 .    D = E + F;
 8-1092 . }
 8-1093 . 
 8-1094 . A = B/C;
 8-1095 . A = B*C;
 8-1096 . 
 8-1097 . if (A < = B)
 8-1098 . {
 8-1099 .    A = B + C;
 8-1100 .    D = E + F;
 8-1101 . }
 8-1102 . 
 8-1103 . A = B*C;
 8-1104 . 
 8-1105 . if (A le B)
 8-1106 . {
 8-1107 .    A = B + C;
 8-1108 .    D = E + F;
 8-1109 . }
 8-1110 . 
 8-1111 . 
 8-1112 . if (A != B)
 8-1113 . {
 8-1114 .    A = B + C;
 8-1115 .    D = E + F;
 8-1116 . }
 8-1117 . 
 8-1118 . A = B+C;
 8-1119 . A = B-C;
 8-1120 . A = B+C;
 8-1121 . A = B/C;
 8-1122 . A = B/C;
 8-1123 . /* LE SV TOC-1141 this is a ca-08.8.20 req to verify*/
 8-1124 . A = B+C;
 8-1125 . A = B-C;
 8-1126 . /* LE SV TOC-1142 this is a ca-08.8.22 req to transform*/
 8-1127 . 
 8-1128 . if (A ne B)
 8-1129 . {
 8-1130 .    A = B + C;
 8-1131 .    D = E + F;
 8-1132 . }
 8-1133 . 
 8-1134 . A = B/C;
 8-1135 . A = B+C;
 8-1136 . 
 8-1137 . if (A == B)
 8-1138 . {
 8-1139 .    A = B + C;
 8-1140 .    D = E + F;
 8-1141 . }
 8-1142 . 
 8-1143 . A = B/C;
 8-1144 . 
 8-1145 . if (A eq B)
 8-1146 . {
 8-1147 .    A = B + C;
 8-1148 .    D = E + F;
 8-1149 . }
 8-1150 . 
 8-1151 . 
 8-1152 . if (A >  B)
 8-1153 . {
 8-1154 .    A = B + C;
 8-1155 .    D = E + F;
 8-1156 . }
 8-1157 . 
 8-1158 . 
 8-1159 . if (A >  B)
 8-1160 . {
 8-1161 .    A = B + C;
 8-1162 .    D = E + F;
 8-1163 . }
 8-1164 . 
 8-1165 . 
 8-1166 . if (A == B)
 8-1167 . {
 8-1168 .    A = B + C;
 8-1169 .    D = E + F;
 8-1170 . }
 8-1171 . 
 8-1172 . A = B-C;
 8-1173 . A = B+C;
 8-1174 . 
 8-1175 . switch (ca stuff)
 8-1176 . {
 8-1177 .       case one:
 8-1178 .    {
 8-1179 .       run_this;
 8-1180 .       break;
 8-1181 .    }
 8-1182 .    case two:
 8-1183 .    {
 8-1184 .       run_this;
 8-1185 .       break;
 8-1186 .    }
 8-1187 .    default:
 8-1188 .    {
 8-1189 .       // missing error call
 8-1190 .    }
 8-1191 . }
 8-1192 . 
 8-1193 . 
 8-1194 . if (A gt B)
 8-1195 . {
 8-1196 .    A = B + C;
 8-1197 .    D = E + F;
 8-1198 . }
 8-1199 . 
 8-1200 . A = B*C;
 8-1201 . 
 8-1202 . if (A >  B)
 8-1203 . {
 8-1204 .    A = B + C;
 8-1205 .    D = E + F;
 8-1206 . }
 8-1207 . 
 8-1208 . A = B+C;
 8-1209 . A = B/C;
 8-1210 . 
 8-1211 . if (A < = B)
 8-1212 . {
 8-1213 .    A = B + C;
 8-1214 .    D = E + F;
 8-1215 . }
 8-1216 . 
 8-1217 . A = B+C;
 8-1218 . A = B+C;
 8-1219 . A = B/C;
 8-1220 . // max LOC 41
 8-1221 . 
 8-1222 . }
 8-1223 . 
 8-1224 . 
 8-1225 . /*
 8-1226 . -----------------------------------------------------------------------------
 8-1227 . --| NAME:   ca.8.9
 8-1228 . --|
 8-1229 . --| ABSTRACT:
 8-1230 . --|   This function does ca stuff.
 8-1231 . --|
 8-1232 . --| RETURNS:
 8-1233 . --|   NONE.
 8-1234 . --|
 8-1235 . ----------------------------------------------------------------------------
 8-1236 . */
 8-1237 . static void ca.8.9(void)
 8-1238 . {
 8-1239 . 
 8-1240 . if (A ne B)
 8-1241 . {
 8-1242 .    A = B + C;
 8-1243 .    D = E + F;
 8-1244 . }
 8-1245 . 
 8-1246 . A = B*C;
 8-1247 . A = B+C;
 8-1248 . 
 8-1249 . if (A le B)
 8-1250 . {
 8-1251 .    A = B + C;
 8-1252 .    D = E + F;
 8-1253 . }
 8-1254 . 
 8-1255 . A = B-C;
 8-1256 . A = B+C;
 8-1257 . A = B*C;
 8-1258 . A = B-C;
 8-1259 . A = B/C;
 8-1260 . 
 8-1261 . switch (ca stuff)
 8-1262 . {
 8-1263 .    case one:
 8-1264 .    {
 8-1265 .       run_this; 
 8-1266 .       break;
 8-1267 .    }
 8-1268 .    case two:
 8-1269 .    {
 8-1270 .       run_this;
 8-1271 .       break;
 8-1272 .    }
 8-1273 .    default:
 8-1274 .    {
 8-1275 .        SwError;
 8-1276 .    }
 8-1277 . }
 8-1278 . 
 8-1279 . A = B/C;
 8-1280 . 
 8-1281 . if (A == B)
 8-1282 . {
 8-1283 .    A = B + C;
 8-1284 .    D = E + F;
 8-1285 . }
 8-1286 . 
 8-1287 . A = B*C;
 8-1288 . // max LOC 13
 8-1289 . 
 8-1290 . }
 8-1291 . 
 8-1292 . 
 8-1293 . /*
 8-1294 . -----------------------------------------------------------------------------
 8-1295 . --| NAME:   ca.8.10
 8-1296 . --|
 8-1297 . --| ABSTRACT:
 8-1298 . --|   This function does ca stuff.
 8-1299 . --|
 8-1300 . --| RETURNS:
 8-1301 . --|   NONE.
 8-1302 . --|
 8-1303 . ----------------------------------------------------------------------------
 8-1304 . */
 8-1305 . static void ca.8.10(void)
 8-1306 . {
 8-1307 . A = B/C;
 8-1308 . 
 8-1309 . if (A le B)
 8-1310 . {
 8-1311 .    A = B + C;
 8-1312 .    D = E + F;
 8-1313 . }
 8-1314 . 
 8-1315 . A = B/C;
 8-1316 . A = B-C;
 8-1317 . A = B-C;
 8-1318 . A = B+C;
 8-1319 . 
 8-1320 . if (A ge B)
 8-1321 . {
 8-1322 .    A = B + C;
 8-1323 .    D = E + F;
 8-1324 . }
 8-1325 . 
 8-1326 . A = 0x0003;
 8-1327 . A = B/C;
 8-1328 . A = B-C;
 8-1329 . A = B*C;
 8-1330 . A = B/C;
 8-1331 . A = B+C;
 8-1332 . A = B-C;
 8-1333 . A = B/C;
 8-1334 . A = B/C;
 8-1335 . A = B+C;
 8-1336 . A = B+C;
 8-1337 . A = B*C;
 8-1338 . // max LOC 18
 8-1339 . 
 8-1340 . }
 8-1341 . 
 8-1342 . 
 8-1343 . /*
 8-1344 . -----------------------------------------------------------------------------
 8-1345 . --| NAME:   ca.8.11
 8-1346 . --|
 8-1347 . --| ABSTRACT:
 8-1348 . --|   This function does ca stuff.
 8-1349 . --|
 8-1350 . --| RETURNS:
 8-1351 . --|   NONE.
 8-1352 . --|
 8-1353 . ----------------------------------------------------------------------------
 8-1354 . */
 8-1355 . static void ca.8.11(void)
 8-1356 . {
 8-1357 . A = B*C;
 8-1358 . /* LE SV TOC-1143 this is a ca-08.11.2 req to reject*/
 8-1359 . 
 8-1360 . if (A == B)
 8-1361 . {
 8-1362 .    A = B + C;
 8-1363 .    D = E + F;
 8-1364 . }
 8-1365 . 
 8-1366 . /* LE SV TOC-1144 this is a ca-08.11.3 req to audit*/
 8-1367 . A = B+C;
 8-1368 . A = B*C;
 8-1369 . A = B*C;
 8-1370 . A = B/C;
 8-1371 . 
 8-1372 . if (A eq B)
 8-1373 . {
 8-1374 .    A = B + C;
 8-1375 .    D = E + F;
 8-1376 . }
 8-1377 . 
 8-1378 . 
 8-1379 . if (A gt B)
 8-1380 . {
 8-1381 .    A = B + C;
 8-1382 .    D = E + F;
 8-1383 . }
 8-1384 . 
 8-1385 . A = B+C;
 8-1386 . A = B-C;
 8-1387 . 
 8-1388 . if (A ne B)
 8-1389 . {
 8-1390 .    A = B + C;
 8-1391 .    D = E + F;
 8-1392 . }
 8-1393 . 
 8-1394 . A = B-C;
 8-1395 . A = B-C;
 8-1396 . A = B/C;
 8-1397 . 
 8-1398 . switch (ca stuff)
 8-1399 . {
 8-1400 .    case one:
 8-1401 .    {
 8-1402 .       run_this; 
 8-1403 .       break;
 8-1404 .    }
 8-1405 .    case two:
 8-1406 .    {
 8-1407 .       run_this;
 8-1408 .       break;
 8-1409 .    }
 8-1410 .    default:
 8-1411 .    {
 8-1412 .        SwError;
 8-1413 .    }
 8-1414 . }
 8-1415 . 
 8-1416 . 
 8-1417 . if (A > = B)
 8-1418 . {
 8-1419 .    A = B + C;
 8-1420 .    D = E + F;
 8-1421 . }
 8-1422 . 
 8-1423 . A = B+C;
 8-1424 . 
 8-1425 . if (A lt B)
 8-1426 . {
 8-1427 .    A = B + C;
 8-1428 .    D = E + F;
 8-1429 . }
 8-1430 . 
 8-1431 . A = B/C;
 8-1432 . 
 8-1433 . if (A lt B)
 8-1434 . {
 8-1435 .    A = B + C;
 8-1436 .    D = E + F;
 8-1437 . }
 8-1438 . 
 8-1439 . A = B/C;
 8-1440 . A = B+C;
 8-1441 . /* LE SV TOC-1145 this is a ca-08.11.23 req to verify*/
 8-1442 . A = B+C;
 8-1443 . A = B-C;
 8-1444 . A = B/C;
 8-1445 . A = B+C;
 8-1446 . 
 8-1447 . if (A eq B)
 8-1448 . {
 8-1449 .    A = B + C;
 8-1450 .    D = E + F;
 8-1451 . }
 8-1452 . 
 8-1453 . 
 8-1454 . if (A le B)
 8-1455 . {
 8-1456 .    A = B + C;
 8-1457 .    D = E + F;
 8-1458 . }
 8-1459 . 
 8-1460 . A = 0x0009;
 8-1461 . A = B/C;
 8-1462 . A = B*C;
 8-1463 . 
 8-1464 . if (A ne B)
 8-1465 . {
 8-1466 .    A = B + C;
 8-1467 .    D = E + F;
 8-1468 . }
 8-1469 . 
 8-1470 . A = 0x0001;
 8-1471 . A = B*C;
 8-1472 . 
 8-1473 . if (A >  B)
 8-1474 . {
 8-1475 .    A = B + C;
 8-1476 .    D = E + F;
 8-1477 . }
 8-1478 . 
 8-1479 . 
 8-1480 . if (A <  B)
 8-1481 . {
 8-1482 .    A = B + C;
 8-1483 .    D = E + F;
 8-1484 . }
 8-1485 . 
 8-1486 . A = B-C;
 8-1487 . A = B-C;
 8-1488 . 
 8-1489 . if (A lt B)
 8-1490 . {
 8-1491 .    A = B + C;
 8-1492 .    D = E + F;
 8-1493 . }
 8-1494 . 
 8-1495 . 
 8-1496 . switch (ca stuff)
 8-1497 . {
 8-1498 .    case one:
 8-1499 .    {
 8-1500 .       run_this; 
 8-1501 .       break;
 8-1502 .    }
 8-1503 .    case two:
 8-1504 .    {
 8-1505 .       run_this;
 8-1506 .       break;
 8-1507 .    }
 8-1508 .    default:
 8-1509 .    {
 8-1510 .        SwError;
 8-1511 .    }
 8-1512 . }
 8-1513 . 
 8-1514 . A = B+C;
 8-1515 . A = B-C;
 8-1516 . 
 8-1517 . if (A > = B)
 8-1518 . {
 8-1519 .    A = B + C;
 8-1520 .    D = E + F;
 8-1521 . }
 8-1522 . 
 8-1523 . 
 8-1524 . if (A ne B)
 8-1525 . {
 8-1526 .    A = B + C;
 8-1527 .    D = E + F;
 8-1528 . }
 8-1529 . 
 8-1530 . A = B/C;
 8-1531 . A = B/C;
 8-1532 . A = B+C;
 8-1533 . // max LOC 45
 8-1534 . 
 8-1535 . }
 8-1536 . 
 8-1537 . 
 8-1538 . /*
 8-1539 . -----------------------------------------------------------------------------
 8-1540 . --| NAME:   ca.8.12
 8-1541 . --|
 8-1542 . --| ABSTRACT:
 8-1543 . --|   This function does ca stuff.
 8-1544 . --|
 8-1545 . --| RETURNS:
 8-1546 . --|   NONE.
 8-1547 . --|
 8-1548 . ----------------------------------------------------------------------------
 8-1549 . */
 8-1550 . static void ca.8.12(void)
 8-1551 . {
 8-1552 . A = B*C;
 8-1553 . A = 0x0008;
 8-1554 . A = B+C;
 8-1555 . 
 8-1556 . if (A gt B)
 8-1557 . {
 8-1558 .    A = B + C;
 8-1559 .    D = E + F;
 8-1560 . }
 8-1561 . 
 8-1562 . A = B*C;
 8-1563 . A = B*C;
 8-1564 . A = B*C;
 8-1565 . A = B+C;
 8-1566 . 
 8-1567 . if (A <  B)
 8-1568 . {
 8-1569 .    A = B + C;
 8-1570 .    D = E + F;
 8-1571 . }
 8-1572 . 
 8-1573 . A = B/C;
 8-1574 . // ??? go see ws
 8-1575 . A = B*C;
 8-1576 . /* LE SV TOC-1146 this is a ca-08.12.11 req to store*/
 8-1577 . 
 8-1578 . if (A == B)
 8-1579 . {
 8-1580 .    A = B + C;
 8-1581 .    D = E + F;
 8-1582 . }
 8-1583 . 
 8-1584 . 
 8-1585 . if (A ge B)
 8-1586 . {
 8-1587 .    A = B + C;
 8-1588 .    D = E + F;
 8-1589 . }
 8-1590 . 
 8-1591 . /* LE SV TOC-1147 this is a ca-08.12.13 req to update*/
 8-1592 . A = B*C;
 8-1593 . 
 8-1594 . if (A < = B)
 8-1595 . {
 8-1596 .    A = B + C;
 8-1597 .    D = E + F;
 8-1598 . }
 8-1599 . 
 8-1600 . A = B*C;
 8-1601 . A = B/C;
 8-1602 . A = B-C;
 8-1603 . 
 8-1604 . if (A le B)
 8-1605 . {
 8-1606 .    A = B + C;
 8-1607 .    D = E + F;
 8-1608 . }
 8-1609 . 
 8-1610 . A = B-C;
 8-1611 . 
 8-1612 . if (A < = B)
 8-1613 . {
 8-1614 .    A = B + C;
 8-1615 .    D = E + F;
 8-1616 . }
 8-1617 . 
 8-1618 . A = B/C;
 8-1619 . A = B*C;
 8-1620 . 
 8-1621 . if (A >  B)
 8-1622 . {
 8-1623 .    A = B + C;
 8-1624 .    D = E + F;
 8-1625 . }
 8-1626 . 
 8-1627 . A = B+C;
 8-1628 . A = B-C;
 8-1629 . 
 8-1630 . if (A lt B)
 8-1631 . {
 8-1632 .    A = B + C;
 8-1633 .    D = E + F;
 8-1634 . }
 8-1635 . 
 8-1636 . 
 8-1637 . switch (ca stuff)
 8-1638 . {
 8-1639 .    case one:
 8-1640 .    {
 8-1641 .       run_this; 
 8-1642 .       break;
 8-1643 .    }
 8-1644 .    case two:
 8-1645 .    {
 8-1646 .       run_this;
 8-1647 .       break;
 8-1648 .    }
 8-1649 .    default:
 8-1650 .    {
 8-1651 .        SwError;
 8-1652 .    }
 8-1653 . }
 8-1654 . 
 8-1655 . A = B/C;
 8-1656 . 
 8-1657 . if (A != B)
 8-1658 . {
 8-1659 .    A = B + C;
 8-1660 .    D = E + F;
 8-1661 . }
 8-1662 . 
 8-1663 . A = B-C;
 8-1664 . A = B-C;
 8-1665 . A = B+C;
 8-1666 . /* LE SV TOC-1148 this is a ca-08.12.33 req to check unix*/
 8-1667 . A = B-C;
 8-1668 . A = B/C;
 8-1669 . 
 8-1670 . if (A ge B)
 8-1671 . {
 8-1672 .    A = B + C;
 8-1673 .    D = E + F;
 8-1674 . }
 8-1675 . 
 8-1676 . A = B*C;
 8-1677 . A = B/C;
 8-1678 . 
 8-1679 . if (A lt B)
 8-1680 . {
 8-1681 .    A = B + C;
 8-1682 .    D = E + F;
 8-1683 . }
 8-1684 . 
 8-1685 . 
 8-1686 . if (A lt B)
 8-1687 . {
 8-1688 .    A = B + C;
 8-1689 .    D = E + F;
 8-1690 . }
 8-1691 . 
 8-1692 . A = B/C;
 8-1693 . 
 8-1694 . if (A >  B)
 8-1695 . {
 8-1696 .    A = B + C;
 8-1697 .    D = E + F;
 8-1698 . }
 8-1699 . 
 8-1700 . /* LE SV TOC-1149 this is a ca-08.12.42 req to reject*/
 8-1701 . A = B+C;
 8-1702 . A = 0x0006;
 8-1703 . 
 8-1704 . if (A gt B)
 8-1705 . {
 8-1706 .    A = B + C;
 8-1707 .    D = E + F;
 8-1708 . }
 8-1709 . 
 8-1710 . A = B+C;
 8-1711 . A = B/C;
 8-1712 . A = B+C;
 8-1713 . // max LOC 46
 8-1714 . 
 8-1715 . }
 8-1716 . 

8 8 Result: result/source/ft-app/ft-app-B1.1/ca/ca-08.c


9 9 Source: source/ft-app/ft-app-B1.1/ca/ca-09.c
 9-0 . 
 9-1 . 
 9-2 . #include A;
 9-3 . #define A;
 9-4 . float B;
 9-5 . #include B;
 9-6 . #define B;
 9-7 . 
 9-8 . 
 9-9 . 
 9-10 . /*
 9-11 . -----------------------------------------------------------------------------
 9-12 . --| NAME:   ca.9.1
 9-13 . --|
 9-14 . --| ABSTRACT:
 9-15 . --|   This function does ca stuff.
 9-16 . --|
 9-17 . --| RETURNS:
 9-18 . --|   NONE.
 9-19 . --|
 9-20 . ----------------------------------------------------------------------------
 9-21 . */
 9-22 . static void ca.9.1(void)
 9-23 . {
 9-24 . A = B/C;
 9-25 . A = B*C;
 9-26 . do forever;
 9-27 . 
 9-28 . if (A < = B)
 9-29 . {
 9-30 .    A = B + C;
 9-31 .    D = E + F;
 9-32 . }
 9-33 . 
 9-34 . A = B/C;
 9-35 . 
 9-36 . if (A <  B)
 9-37 . {
 9-38 .    A = B + C;
 9-39 .    D = E + F;
 9-40 . }
 9-41 . 
 9-42 . /* LE SV TOC-1150 this is a ca-09.1.6 req to increment*/
 9-43 . 
 9-44 . if (A != B)
 9-45 . {
 9-46 .    A = B + C;
 9-47 .    D = E + F;
 9-48 . }
 9-49 . 
 9-50 . A = B/C;
 9-51 . A = B/C;
 9-52 . // TBD - what do I do now
 9-53 . A = B/C;
 9-54 . A = B+C;
 9-55 . 
 9-56 . switch (ca stuff)
 9-57 . {
 9-58 .    case:
 9-59 .    case:
 9-60 .    // stacked case statements but only if there is a new line in between
 9-61 . 
 9-62 .    case:
 9-63 .    case:
 9-64 .    case:
 9-65 .    {
 9-66 .       run_this;
 9-67 .       break;
 9-68 .    }
 9-69 .    default:
 9-70 .    {
 9-71 .       halt;
 9-72 .    }
 9-73 . }
 9-74 . 
 9-75 . 
 9-76 . if (A <  B)
 9-77 . {
 9-78 .    A = B + C;
 9-79 .    D = E + F;
 9-80 . }
 9-81 . 
 9-82 . A = B*C;
 9-83 . 
 9-84 . if (A eq B)
 9-85 . {
 9-86 .    A = B + C;
 9-87 .    D = E + F;
 9-88 . }
 9-89 . 
 9-90 . 
 9-91 . switch (ca stuff)
 9-92 . {
 9-93 .    case one:
 9-94 .    {
 9-95 .       run_this; 
 9-96 .       break;
 9-97 .    }
 9-98 .    case two:
 9-99 .    {
 9-100 .       run_this;
 9-101 .       break;
 9-102 .    }
 9-103 .    default:
 9-104 .    {
 9-105 .        SwError;
 9-106 .    }
 9-107 . }
 9-108 . 
 9-109 . A = B/C;
 9-110 . 
 9-111 . if (A lt B)
 9-112 . {
 9-113 .    A = B + C;
 9-114 .    D = E + F;
 9-115 . }
 9-116 . 
 9-117 . A = B-C;
 9-118 . A = B+C;
 9-119 . A = B/C;
 9-120 . A = B/C;
 9-121 . /* LE SV TOC-1151 this is a ca-09.1.21 req to compare*/
 9-122 . 
 9-123 . if (A le B)
 9-124 . {
 9-125 .    A = B + C;
 9-126 .    D = E + F;
 9-127 . }
 9-128 . 
 9-129 . A = B*C;
 9-130 . 
 9-131 . switch (ca stuff)
 9-132 . {
 9-133 .    case one:
 9-134 .    {
 9-135 .       run_this; 
 9-136 .       break;
 9-137 .    }
 9-138 .    case two:
 9-139 .    {
 9-140 .       run_this;
 9-141 .       break;
 9-142 .    }
 9-143 .    default:
 9-144 .    {
 9-145 .        SwError;
 9-146 .    }
 9-147 . }
 9-148 . 
 9-149 . A = B-C;
 9-150 . A = B+C;
 9-151 . do forever;
 9-152 . A = B-C;
 9-153 . A = 0x0003;
 9-154 . 
 9-155 . if (A != B)
 9-156 . {
 9-157 .    A = B + C;
 9-158 .    D = E + F;
 9-159 . }
 9-160 . 
 9-161 . A = B*C;
 9-162 . 
 9-163 . if (A gt B)
 9-164 . {
 9-165 .    A = B + C;
 9-166 .    D = E + F;
 9-167 . }
 9-168 . 
 9-169 . A = B-C;
 9-170 . A = B/C;
 9-171 . A = B/C;
 9-172 . A = B+C;
 9-173 . A = B/C;
 9-174 . // max LOC 34
 9-175 . 
 9-176 . }
 9-177 . 
 9-178 . 
 9-179 . /*
 9-180 . -----------------------------------------------------------------------------
 9-181 . --| NAME:   ca.9.2
 9-182 . --|
 9-183 . --| ABSTRACT:
 9-184 . --|   This function does ca stuff.
 9-185 . --|
 9-186 . --| RETURNS:
 9-187 . --|   NONE.
 9-188 . --|
 9-189 . ----------------------------------------------------------------------------
 9-190 . */
 9-191 . static void ca.9.2(void)
 9-192 . {
 9-193 . A = B-C;
 9-194 . 
 9-195 . if (A != B)
 9-196 . {
 9-197 .    A = B + C;
 9-198 .    D = E + F;
 9-199 . }
 9-200 . 
 9-201 . A = B/C;
 9-202 . 
 9-203 . if (A eq B)
 9-204 . {
 9-205 .    A = B + C;
 9-206 .    D = E + F;
 9-207 . }
 9-208 . 
 9-209 . 
 9-210 . if (A < = B)
 9-211 . {
 9-212 .    A = B + C;
 9-213 .    D = E + F;
 9-214 . }
 9-215 . 
 9-216 . 
 9-217 . /* 
 9-218 . dead_code = B - C; 
 9-219 . dead_code = D - E; 
 9-220 . dead_code = F - G;
 9-221 . */
 9-222 . 
 9-223 . 
 9-224 . if (A lt B)
 9-225 . {
 9-226 .    A = B + C;
 9-227 .    D = E + F;
 9-228 . }
 9-229 . 
 9-230 . A = B+C;
 9-231 . A = B*C;
 9-232 . A = B-C;
 9-233 . A = B/C;
 9-234 . A = B-C;
 9-235 . 
 9-236 . if (A <  B)
 9-237 . {
 9-238 .    A = B + C;
 9-239 .    D = E + F;
 9-240 . }
 9-241 . 
 9-242 . 
 9-243 . if (A ge B)
 9-244 . {
 9-245 .    A = B + C;
 9-246 .    D = E + F;
 9-247 . }
 9-248 . 
 9-249 . 
 9-250 . if (A lt B)
 9-251 . {
 9-252 .    A = B + C;
 9-253 .    D = E + F;
 9-254 . }
 9-255 . 
 9-256 . A = B+C;
 9-257 . A = B/C;
 9-258 . 
 9-259 . if (A ge B)
 9-260 . {
 9-261 .    A = B + C;
 9-262 .    D = E + F;
 9-263 . }
 9-264 . 
 9-265 . A = B*C;
 9-266 . 
 9-267 . if (A ne B)
 9-268 . {
 9-269 .    A = B + C;
 9-270 .    D = E + F;
 9-271 . }
 9-272 . 
 9-273 . A = B-C;
 9-274 . A = B+C;
 9-275 . A = B/C;
 9-276 . A = B/C;
 9-277 . A = B-C;
 9-278 . 
 9-279 . if (A != B)
 9-280 . {
 9-281 .    A = B + C;
 9-282 .    D = E + F;
 9-283 . }
 9-284 . 
 9-285 . A = B-C;
 9-286 . 
 9-287 . if (A le B)
 9-288 . {
 9-289 .    A = B + C;
 9-290 .    D = E + F;
 9-291 . }
 9-292 . 
 9-293 . /* LE SV TOC-1152 this is a ca-09.2.28 req to call admin*/
 9-294 . A = B-C;
 9-295 . A = B-C;
 9-296 . A = B-C;
 9-297 . A = B+C;
 9-298 . A = B+C;
 9-299 . A = B/C;
 9-300 . A = B-C;
 9-301 . 
 9-302 . if (A eq B)
 9-303 . {
 9-304 .    A = B + C;
 9-305 .    D = E + F;
 9-306 . }
 9-307 . 
 9-308 . A = B/C;
 9-309 . 
 9-310 . if (A eq B)
 9-311 . {
 9-312 .    A = B + C;
 9-313 .    D = E + F;
 9-314 . }
 9-315 . 
 9-316 . 
 9-317 . if (A lt B)
 9-318 . {
 9-319 .    A = B + C;
 9-320 .    D = E + F;
 9-321 . }
 9-322 . 
 9-323 . A = B*C;
 9-324 . A = B-C;
 9-325 . A = B-C;
 9-326 . A = B-C;
 9-327 . A = B/C;
 9-328 . A = B-C;
 9-329 . A = B/C;
 9-330 . 
 9-331 . switch (ca stuff)
 9-332 . {
 9-333 .       case one:
 9-334 .    {
 9-335 .       run_this;
 9-336 .       break;
 9-337 .    }
 9-338 .    case two:
 9-339 .    {
 9-340 .       run_this;
 9-341 .       break;
 9-342 .    }
 9-343 .    default:
 9-344 .    {
 9-345 .       // missing error call
 9-346 .    }
 9-347 . }
 9-348 . 
 9-349 . A = B/C;
 9-350 . A = 0x0003;
 9-351 . A = B+C;
 9-352 . 
 9-353 . if (A eq B)
 9-354 . {
 9-355 .    A = B + C;
 9-356 .    D = E + F;
 9-357 . }
 9-358 . 
 9-359 . A = B+C;
 9-360 . 
 9-361 . if (A gt B)
 9-362 . {
 9-363 .    A = B + C;
 9-364 .    D = E + F;
 9-365 . }
 9-366 . 
 9-367 . A = B/C;
 9-368 . 
 9-369 . if (A lt B)
 9-370 . {
 9-371 .    A = B + C;
 9-372 .    D = E + F;
 9-373 . }
 9-374 . 
 9-375 . 
 9-376 . #ifdef LAZY
 9-377 .    // this is not nice
 9-378 .    A = B + C;
 9-379 .    A = B + C;
 9-380 . #endif
 9-381 . 
 9-382 . A = B/C;
 9-383 . A = B*C;
 9-384 . 
 9-385 . if (A eq B)
 9-386 . {
 9-387 .    A = B + C;
 9-388 .    D = E + F;
 9-389 . }
 9-390 . 
 9-391 . A = B+C;
 9-392 . A = B*C;
 9-393 . 
 9-394 . if (A > = B)
 9-395 . {
 9-396 .    A = B + C;
 9-397 .    D = E + F;
 9-398 . }
 9-399 . 
 9-400 . A = B/C;
 9-401 . A = B/C;
 9-402 . 
 9-403 . if (A == B)
 9-404 . {
 9-405 .    A = B + C;
 9-406 .    D = E + F;
 9-407 . }
 9-408 . 
 9-409 . A = B*C;
 9-410 . A = B*C;
 9-411 . A = B-C;
 9-412 . A = B/C;
 9-413 . A = B-C;
 9-414 . A = B+C;
 9-415 . 
 9-416 . if (A ne B)
 9-417 . {
 9-418 .    A = B + C;
 9-419 .    D = E + F;
 9-420 . }
 9-421 . 
 9-422 . A = B-C;
 9-423 . 
 9-424 . if (A ne B)
 9-425 . {
 9-426 .    A = B + C;
 9-427 .    D = E + F;
 9-428 . }
 9-429 . 
 9-430 . A = B-C;
 9-431 . A = B*C;
 9-432 . // max LOC 72
 9-433 . 
 9-434 . }
 9-435 . 
 9-436 . 
 9-437 . /*
 9-438 . -----------------------------------------------------------------------------
 9-439 . --| NAME:   ca.9.3
 9-440 . --|
 9-441 . --| ABSTRACT:
 9-442 . --|   This function does ca stuff.
 9-443 . --|
 9-444 . --| RETURNS:
 9-445 . --|   NONE.
 9-446 . --|
 9-447 . ----------------------------------------------------------------------------
 9-448 . */
 9-449 . static void ca.9.3(void)
 9-450 . {
 9-451 . A = B/C;
 9-452 . A = B/C;
 9-453 . A = B-C;
 9-454 . 
 9-455 . if (A <  B)
 9-456 . {
 9-457 .    A = B + C;
 9-458 .    D = E + F;
 9-459 . }
 9-460 . 
 9-461 . A = B*C;
 9-462 . A = B*C;
 9-463 . A = B/C;
 9-464 . A = B*C;
 9-465 . A = B/C;
 9-466 . A = B/C;
 9-467 . A = B/C;
 9-468 . A = B/C;
 9-469 . 
 9-470 . switch (ca stuff)
 9-471 . {
 9-472 .    case one:
 9-473 .    {
 9-474 .       run_this; 
 9-475 .       break;
 9-476 .    }
 9-477 .    case two:
 9-478 .    {
 9-479 .       run_this;
 9-480 .       break;
 9-481 .    }
 9-482 .    default:
 9-483 .    {
 9-484 .        SwError;
 9-485 .    }
 9-486 . }
 9-487 . 
 9-488 . 
 9-489 . if (A ne B)
 9-490 . {
 9-491 .    A = B + C;
 9-492 .    D = E + F;
 9-493 . }
 9-494 . 
 9-495 . 
 9-496 . if (A == B)
 9-497 . {
 9-498 .    A = B + C;
 9-499 .    D = E + F;
 9-500 . }
 9-501 . 
 9-502 . A = B-C;
 9-503 . A = B/C;
 9-504 . A = B-C;
 9-505 . A = B/C;
 9-506 . A = B-C;
 9-507 . 
 9-508 . if (A > = B)
 9-509 . {
 9-510 .    A = B + C;
 9-511 .    D = E + F;
 9-512 . }
 9-513 . 
 9-514 . A = B*C;
 9-515 . A = B/C;
 9-516 . A = B/C;
 9-517 . A = B-C;
 9-518 . A = B+C;
 9-519 . A = B*C;
 9-520 . 
 9-521 . if (A == B)
 9-522 . {
 9-523 .    A = B + C;
 9-524 .    D = E + F;
 9-525 . }
 9-526 . 
 9-527 . 
 9-528 . if (A ge B)
 9-529 . {
 9-530 .    A = B + C;
 9-531 .    D = E + F;
 9-532 . }
 9-533 . 
 9-534 . 
 9-535 . if (A <  B)
 9-536 . {
 9-537 .    A = B + C;
 9-538 .    D = E + F;
 9-539 . }
 9-540 . 
 9-541 . A = B/C;
 9-542 . A = B/C;
 9-543 . A = B*C;
 9-544 . 
 9-545 . if (A le B)
 9-546 . {
 9-547 .    A = B + C;
 9-548 .    D = E + F;
 9-549 . }
 9-550 . 
 9-551 . A = B-C;
 9-552 . A = B*C;
 9-553 . A = B+C;
 9-554 . 
 9-555 . /* dead_block = C * D; 
 9-556 . dead_block = E * F; */
 9-557 . 
 9-558 . A = B/C;
 9-559 . A = B/C;
 9-560 . 
 9-561 . if (A ne B)
 9-562 . {
 9-563 .    A = B + C;
 9-564 .    D = E + F;
 9-565 . }
 9-566 . 
 9-567 . A = B+C;
 9-568 . A = B-C;
 9-569 . 
 9-570 . if (A le B)
 9-571 . {
 9-572 .    A = B + C;
 9-573 .    D = E + F;
 9-574 . }
 9-575 . 
 9-576 . rcv_buffer = (U16 *) alloc(size+1);
 9-577 . A = B-C;
 9-578 . A = B-C;
 9-579 . 
 9-580 . if (A >  B)
 9-581 . {
 9-582 .    A = B + C;
 9-583 .    D = E + F;
 9-584 . }
 9-585 . 
 9-586 . A = B-C;
 9-587 . A = B/C;
 9-588 . 
 9-589 . if (A <  B)
 9-590 . {
 9-591 .    A = B + C;
 9-592 .    D = E + F;
 9-593 . }
 9-594 . 
 9-595 . // max LOC 49
 9-596 . 
 9-597 . }
 9-598 . 
 9-599 . 
 9-600 . /*
 9-601 . -----------------------------------------------------------------------------
 9-602 . --| NAME:   ca.9.4
 9-603 . --|
 9-604 . --| ABSTRACT:
 9-605 . --|   This function does ca stuff.
 9-606 . --|
 9-607 . --| RETURNS:
 9-608 . --|   NONE.
 9-609 . --|
 9-610 . ----------------------------------------------------------------------------
 9-611 . */
 9-612 . static void ca.9.4(void)
 9-613 . {
 9-614 . A = B+C;
 9-615 . A = B-C;
 9-616 . A = B+C;
 9-617 . A = B*C;
 9-618 . A = B*C;
 9-619 . A = B/C;
 9-620 . 
 9-621 . if (A gt B)
 9-622 . {
 9-623 .    A = B + C;
 9-624 .    D = E + F;
 9-625 . }
 9-626 . 
 9-627 . A = B*C;
 9-628 . 
 9-629 . switch (ca stuff)
 9-630 . {
 9-631 .       case one:
 9-632 .    {
 9-633 .       run_this;
 9-634 .       break;
 9-635 .    }
 9-636 .    case two:
 9-637 .    {
 9-638 .       run_this;
 9-639 .       break;
 9-640 .    }
 9-641 .    default:
 9-642 .    {
 9-643 .       // missing error call
 9-644 .    }
 9-645 . }
 9-646 . 
 9-647 . 
 9-648 . if (A eq B)
 9-649 . {
 9-650 .    A = B + C;
 9-651 .    D = E + F;
 9-652 . }
 9-653 . 
 9-654 . A = B-C;
 9-655 . A = B*C;
 9-656 . A = B/C;
 9-657 . A = B/C;
 9-658 . A = B+C;
 9-659 . /* LE SV TOC-1153 this is a ca-09.4.15 req to assign*/
 9-660 . A = B*C;
 9-661 . A = B-C;
 9-662 . free(FreePtr);
 9-663 . A = B/C;
 9-664 . 
 9-665 . if (A > = B)
 9-666 . {
 9-667 .    A = B + C;
 9-668 .    D = E + F;
 9-669 . }
 9-670 . 
 9-671 . A = B*C;
 9-672 . A = B*C;
 9-673 . A = B/C;
 9-674 . A = B*C;
 9-675 . /* LE SV TOC-1154 this is a ca-09.4.23 req to transform*/
 9-676 . 
 9-677 . if (A eq B)
 9-678 . {
 9-679 .    A = B + C;
 9-680 .    D = E + F;
 9-681 . }
 9-682 . 
 9-683 . A = B-C;
 9-684 . A = B*C;
 9-685 . A = B-C;
 9-686 . 
 9-687 . if (A < = B)
 9-688 . {
 9-689 .    A = B + C;
 9-690 .    D = E + F;
 9-691 . }
 9-692 . 
 9-693 . 
 9-694 . if (A eq B)
 9-695 . {
 9-696 .    A = B + C;
 9-697 .    D = E + F;
 9-698 . }
 9-699 . 
 9-700 . A = B-C;
 9-701 . A = B-C;
 9-702 . A = B*C;
 9-703 . 
 9-704 . if (A <  B)
 9-705 . {
 9-706 .    A = B + C;
 9-707 .    D = E + F;
 9-708 . }
 9-709 . 
 9-710 . 
 9-711 . if (A le B)
 9-712 . {
 9-713 .    A = B + C;
 9-714 .    D = E + F;
 9-715 . }
 9-716 . 
 9-717 . 
 9-718 . if (A ne B)
 9-719 . {
 9-720 .    A = B + C;
 9-721 .    D = E + F;
 9-722 . }
 9-723 . 
 9-724 . A = B+C;
 9-725 . 
 9-726 . if (A gt B)
 9-727 . {
 9-728 .    A = B + C;
 9-729 .    D = E + F;
 9-730 . }
 9-731 . 
 9-732 . A = B/C;
 9-733 . A = B*C;
 9-734 . A = B*C;
 9-735 . A = B/C;
 9-736 . A = B+C;
 9-737 . A = B-C;
 9-738 . A = B/C;
 9-739 . 
 9-740 . switch (ca stuff)
 9-741 . {
 9-742 .    case one:
 9-743 .    {
 9-744 .       switch (nested)
 9-745 .       {
 9-746 .          case:
 9-747 .             X = Y + Z;
 9-748 .          case:
 9-749 .             X = Y + Z;
 9-750 .          default:
 9-751 .             SwError;
 9-752 .       } 
 9-753 .    }
 9-754 .    case two:
 9-755 .    {
 9-756 .       run_this;
 9-757 .       break;
 9-758 .    }
 9-759 .    default:
 9-760 .    {
 9-761 .       SwError;
 9-762 .    }
 9-763 . }
 9-764 . 
 9-765 . 
 9-766 . switch (ca stuff)
 9-767 . {
 9-768 .    case one:
 9-769 .    {
 9-770 .       run_this; 
 9-771 .       break;
 9-772 .    }
 9-773 .    case two:
 9-774 .    {
 9-775 .       run_this;
 9-776 .       break;
 9-777 .    }
 9-778 .    default:
 9-779 .    {
 9-780 .        SwError;
 9-781 .    }
 9-782 . }
 9-783 . 
 9-784 . A = B+C;
 9-785 . A = B/C;
 9-786 . // max LOC 46
 9-787 . 
 9-788 . }
 9-789 . 
 9-790 . 
 9-791 . /*
 9-792 . -----------------------------------------------------------------------------
 9-793 . --| NAME:   ca.9.5
 9-794 . --|
 9-795 . --| ABSTRACT:
 9-796 . --|   This function does ca stuff.
 9-797 . --|
 9-798 . --| RETURNS:
 9-799 . --|   NONE.
 9-800 . --|
 9-801 . ----------------------------------------------------------------------------
 9-802 . */
 9-803 . static void ca.9.5(void)
 9-804 . {
 9-805 . 
 9-806 . if ($ca stuff >  $otherca stuff) 
 9-807 . /* LE SV TOC-008 we really should log all error calls */
 9-808 . {
 9-809 .    A = B + C;
 9-810 . }
 9-811 . 
 9-812 . A = B*C;
 9-813 . A = B*C;
 9-814 . 
 9-815 . if (A ne B)
 9-816 . {
 9-817 .    A = B + C;
 9-818 .    D = E + F;
 9-819 . }
 9-820 . 
 9-821 . A = B/C;
 9-822 . A = B/C;
 9-823 . A = B+C;
 9-824 . A = B/C;
 9-825 . A = B/C;
 9-826 . 
 9-827 . if (A le B)
 9-828 . {
 9-829 .    A = B + C;
 9-830 .    D = E + F;
 9-831 . }
 9-832 . 
 9-833 . A = B+C;
 9-834 . 
 9-835 . if (A > = B)
 9-836 . {
 9-837 .    A = B + C;
 9-838 .    D = E + F;
 9-839 . }
 9-840 . 
 9-841 . A = B/C;
 9-842 . A = B/C;
 9-843 . A = B/C;
 9-844 . 
 9-845 . switch (ca stuff)
 9-846 . {
 9-847 .    case one:
 9-848 .    {
 9-849 .       run_this; 
 9-850 .       break;
 9-851 .    }
 9-852 .    case two:
 9-853 .    {
 9-854 .       run_this;
 9-855 .       break;
 9-856 .    }
 9-857 .    default:
 9-858 .    {
 9-859 .        SwError;
 9-860 .    }
 9-861 . }
 9-862 . 
 9-863 . 
 9-864 . if (A eq B)
 9-865 . {
 9-866 .    A = B + C;
 9-867 .    D = E + F;
 9-868 . }
 9-869 . 
 9-870 . 
 9-871 . if (A < = B)
 9-872 . {
 9-873 .    A = B + C;
 9-874 .    D = E + F;
 9-875 . }
 9-876 . 
 9-877 . A = B/C;
 9-878 . 
 9-879 . if (A ne B)
 9-880 . {
 9-881 .    A = B + C;
 9-882 .    D = E + F;
 9-883 . }
 9-884 . 
 9-885 . 
 9-886 . if (A <  B)
 9-887 . {
 9-888 .    A = B + C;
 9-889 .    D = E + F;
 9-890 . }
 9-891 . 
 9-892 . /* LE SV TOC-1155 this is a ca-09.5.21 req to disable*/
 9-893 . A = B+C;
 9-894 . A = B*C;
 9-895 . A = B-C;
 9-896 . 
 9-897 . if (A gt B)
 9-898 . {
 9-899 .    A = B + C;
 9-900 .    D = E + F;
 9-901 . }
 9-902 . 
 9-903 . 
 9-904 . if (A < = B)
 9-905 . {
 9-906 .    A = B + C;
 9-907 .    D = E + F;
 9-908 . }
 9-909 . 
 9-910 . A = B/C;
 9-911 . 
 9-912 . if (A >  B)
 9-913 . {
 9-914 .    A = B + C;
 9-915 .    D = E + F;
 9-916 . }
 9-917 . 
 9-918 . A = B+C;
 9-919 . A = B/C;
 9-920 . A = B*C;
 9-921 . 
 9-922 . if (A le B)
 9-923 . {
 9-924 .    A = B + C;
 9-925 .    D = E + F;
 9-926 . }
 9-927 . 
 9-928 . 
 9-929 . if (A > = B)
 9-930 . {
 9-931 .    A = B + C;
 9-932 .    D = E + F;
 9-933 . }
 9-934 . 
 9-935 . A = B-C;
 9-936 . 
 9-937 . if (A != B)
 9-938 . {
 9-939 .    A = B + C;
 9-940 .    D = E + F;
 9-941 . }
 9-942 . 
 9-943 . A = B/C;
 9-944 . A = B-C;
 9-945 . A = B-C;
 9-946 . A = B*C;
 9-947 . A = (int)B + C;
 9-948 . A = B/C;
 9-949 . A = B/C;
 9-950 . 
 9-951 . if (A ne B)
 9-952 . {
 9-953 .    A = B + C;
 9-954 .    D = E + F;
 9-955 . }
 9-956 . 
 9-957 . A = B+C;
 9-958 . 
 9-959 . if (A <  B)
 9-960 . {
 9-961 .    A = B + C;
 9-962 .    D = E + F;
 9-963 . }
 9-964 . 
 9-965 . A = B+C;
 9-966 . A = B/C;
 9-967 . A = B/C;
 9-968 . 
 9-969 . if (A >  B)
 9-970 . {
 9-971 .    A = B + C;
 9-972 .    D = E + F;
 9-973 . }
 9-974 . 
 9-975 . 
 9-976 . if (A gt B)
 9-977 . {
 9-978 .    A = B + C;
 9-979 .    D = E + F;
 9-980 . }
 9-981 . 
 9-982 . 
 9-983 . switch (ca stuff)
 9-984 . {
 9-985 .    case one:
 9-986 .    {
 9-987 .       run_this; 
 9-988 .       break;
 9-989 .    }
 9-990 .    case two:
 9-991 .    {
 9-992 .       run_this;
 9-993 .       break;
 9-994 .    }
 9-995 .    default:
 9-996 .    {
 9-997 .        SwError;
 9-998 .    }
 9-999 . }
 9-1000 . 
 9-1001 . A = B/C;
 9-1002 . A = B-C;
 9-1003 . A = B-C;
 9-1004 . A = B-C;
 9-1005 . 
 9-1006 . if (A ne B)
 9-1007 . {
 9-1008 .    A = B + C;
 9-1009 .    D = E + F;
 9-1010 . }
 9-1011 . 
 9-1012 . A = B+C;
 9-1013 . A = B*C;
 9-1014 . 
 9-1015 . switch (ca stuff)
 9-1016 . {
 9-1017 .    case one:
 9-1018 .    {
 9-1019 .       run_this; 
 9-1020 .       break;
 9-1021 .    }
 9-1022 .    case two:
 9-1023 .    {
 9-1024 .       run_this;
 9-1025 .       break;
 9-1026 .    }
 9-1027 .    default:
 9-1028 .    {
 9-1029 .        SwError;
 9-1030 .    }
 9-1031 . }
 9-1032 . 
 9-1033 . A = B/C;
 9-1034 . A = B*C;
 9-1035 . A = B-C;
 9-1036 . A = B-C;
 9-1037 . A = B-C;
 9-1038 . 
 9-1039 . if (A ne B)
 9-1040 . {
 9-1041 .    A = B + C;
 9-1042 .    D = E + F;
 9-1043 . }
 9-1044 . 
 9-1045 . A = B*C;
 9-1046 . A = B/C;
 9-1047 . A = B-C;
 9-1048 . A = B-C;
 9-1049 . 
 9-1050 . if {
 9-1051 .    X = Y + Z;
 9-1052 . }
 9-1053 . else {
 9-1054 .    halt;
 9-1055 . }
 9-1056 . 
 9-1057 . A = B/C;
 9-1058 . A = B-C;
 9-1059 . A = B*C;
 9-1060 . 
 9-1061 . if (A != B)
 9-1062 . {
 9-1063 .    A = B + C;
 9-1064 .    D = E + F;
 9-1065 . }
 9-1066 . 
 9-1067 . 
 9-1068 . if (A <  B)
 9-1069 . {
 9-1070 .    A = B + C;
 9-1071 .    D = E + F;
 9-1072 . }
 9-1073 . 
 9-1074 . /* LE SV TOC-1156 this is a ca-09.5.73 req to enable*/
 9-1075 . A = B-C;
 9-1076 . 
 9-1077 . switch (ca stuff)
 9-1078 . {
 9-1079 .    case one:
 9-1080 .    {
 9-1081 .       run_this; 
 9-1082 .       // missing break
 9-1083 .    }
 9-1084 .    case two:
 9-1085 .    {
 9-1086 .       run_this;
 9-1087 .       break;
 9-1088 .    }
 9-1089 .    default:
 9-1090 .    {
 9-1091 .       SwError;
 9-1092 .    }
 9-1093 . }
 9-1094 . 
 9-1095 . A = B-C;
 9-1096 . 
 9-1097 . /* dead_code = B + C; 
 9-1098 . dead_code = D + E; 
 9-1099 . dead_code = F + G; */
 9-1100 . 
 9-1101 . A = B/C;
 9-1102 . A = B/C;
 9-1103 . A = B+C;
 9-1104 . A = B+C;
 9-1105 . // max LOC 78
 9-1106 . 
 9-1107 . }
 9-1108 . 
 9-1109 . 
 9-1110 . /*
 9-1111 . -----------------------------------------------------------------------------
 9-1112 . --| NAME:   ca.9.6
 9-1113 . --|
 9-1114 . --| ABSTRACT:
 9-1115 . --|   This function does ca stuff.
 9-1116 . --|
 9-1117 . --| RETURNS:
 9-1118 . --|   NONE.
 9-1119 . --|
 9-1120 . ----------------------------------------------------------------------------
 9-1121 . */
 9-1122 . static void ca.9.6(void)
 9-1123 . {
 9-1124 . 
 9-1125 . if (A ne B)
 9-1126 . {
 9-1127 .    A = B + C;
 9-1128 .    D = E + F;
 9-1129 . }
 9-1130 . 
 9-1131 . 
 9-1132 . if (A ge B)
 9-1133 . {
 9-1134 .    A = B + C;
 9-1135 .    D = E + F;
 9-1136 . }
 9-1137 . 
 9-1138 . A = B*C;
 9-1139 . A = B+C;
 9-1140 . A = 0x0001;
 9-1141 . A = B*C;
 9-1142 . A = B*C;
 9-1143 . /* LE SV TOC-1157 this is a ca-09.6.7 req to verify*/
 9-1144 . 
 9-1145 . if (A == B)
 9-1146 . {
 9-1147 .    A = B + C;
 9-1148 .    D = E + F;
 9-1149 . }
 9-1150 . 
 9-1151 . 
 9-1152 . if (A ne B)
 9-1153 . {
 9-1154 .    A = B + C;
 9-1155 .    D = E + F;
 9-1156 . }
 9-1157 . 
 9-1158 . A = B+C;
 9-1159 . A = B-C;
 9-1160 . A = B*C;
 9-1161 . A = B*C;
 9-1162 . A = B+C;
 9-1163 . A = 0x0009;
 9-1164 . A = B/C;
 9-1165 . /* LE SV TOC-1158 this is a ca-09.6.15 req to halt*/
 9-1166 . A = B-C;
 9-1167 . A = B-C;
 9-1168 . A = B*C;
 9-1169 . A = B*C;
 9-1170 . 
 9-1171 . /* dead_block = C * D; 
 9-1172 . dead_block = E * F; */
 9-1173 . 
 9-1174 . A = B*C;
 9-1175 . 
 9-1176 . switch (ca stuff)
 9-1177 . {
 9-1178 .    case one:
 9-1179 .    {
 9-1180 .       run_this; 
 9-1181 .       // missing break
 9-1182 .    }
 9-1183 .    case two:
 9-1184 .    {
 9-1185 .       run_this;
 9-1186 .       break;
 9-1187 .    }
 9-1188 .    default:
 9-1189 .    {
 9-1190 .       SwError;
 9-1191 .    }
 9-1192 . }
 9-1193 . 
 9-1194 . 
 9-1195 . if (A ne B)
 9-1196 . {
 9-1197 .    A = B + C;
 9-1198 .    D = E + F;
 9-1199 . }
 9-1200 . 
 9-1201 . A = B*C;
 9-1202 . 
 9-1203 . if (A lt B)
 9-1204 . {
 9-1205 .    A = B + C;
 9-1206 .    D = E + F;
 9-1207 . }
 9-1208 . 
 9-1209 . 
 9-1210 . if (A < = B)
 9-1211 . {
 9-1212 .    A = B + C;
 9-1213 .    D = E + F;
 9-1214 . }
 9-1215 . 
 9-1216 . A = B-C;
 9-1217 . A = B+C;
 9-1218 . 
 9-1219 . if (A le B)
 9-1220 . {
 9-1221 .    A = B + C;
 9-1222 .    D = E + F;
 9-1223 . }
 9-1224 . 
 9-1225 . A = B*C;
 9-1226 . 
 9-1227 . if (A > = B)
 9-1228 . {
 9-1229 .    A = B + C;
 9-1230 .    D = E + F;
 9-1231 . }
 9-1232 . 
 9-1233 . send_buffer = (U16 *) malloc(size+1);
 9-1234 . A = B*C;
 9-1235 . A = B-C;
 9-1236 . 
 9-1237 . /* dead_code = B + C; 
 9-1238 . dead_code = D + E; 
 9-1239 . dead_code = F + G; */
 9-1240 . 
 9-1241 . A = B-C;
 9-1242 . A = 0x0007;
 9-1243 . A = B/C;
 9-1244 . A = B/C;
 9-1245 . A = B-C;
 9-1246 . A = B+C;
 9-1247 . A = B*C;
 9-1248 . 
 9-1249 . if (A > = B)
 9-1250 . {
 9-1251 .    A = B + C;
 9-1252 .    D = E + F;
 9-1253 . }
 9-1254 . 
 9-1255 . A = B*C;
 9-1256 . A = B-C;
 9-1257 . A = B/C;
 9-1258 . A = B+C;
 9-1259 . A = B+C;
 9-1260 . // max LOC 42
 9-1261 . 
 9-1262 . }
 9-1263 . 
 9-1264 . 
 9-1265 . /*
 9-1266 . -----------------------------------------------------------------------------
 9-1267 . --| NAME:   ca.9.7
 9-1268 . --|
 9-1269 . --| ABSTRACT:
 9-1270 . --|   This function does ca stuff.
 9-1271 . --|
 9-1272 . --| RETURNS:
 9-1273 . --|   NONE.
 9-1274 . --|
 9-1275 . ----------------------------------------------------------------------------
 9-1276 . */
 9-1277 . static void ca.9.7(void)
 9-1278 . {
 9-1279 . A = B/C;
 9-1280 . A = B+C;
 9-1281 . A = B+C;
 9-1282 . 
 9-1283 . if (A ge B)
 9-1284 . {
 9-1285 .    A = B + C;
 9-1286 .    D = E + F;
 9-1287 . }
 9-1288 . 
 9-1289 . 
 9-1290 . if (A != B)
 9-1291 . {
 9-1292 .    A = B + C;
 9-1293 .    D = E + F;
 9-1294 . }
 9-1295 . 
 9-1296 . 
 9-1297 . if (A >  B)
 9-1298 . {
 9-1299 .    A = B + C;
 9-1300 .    D = E + F;
 9-1301 . }
 9-1302 . 
 9-1303 . A = B*C;
 9-1304 . 
 9-1305 . if (A ne B)
 9-1306 . {
 9-1307 .    A = B + C;
 9-1308 .    D = E + F;
 9-1309 . }
 9-1310 . 
 9-1311 . A = B*C;
 9-1312 . A = B+C;
 9-1313 . A = B+C;
 9-1314 . 
 9-1315 . if (A ge B)
 9-1316 . {
 9-1317 .    A = B + C;
 9-1318 .    D = E + F;
 9-1319 . }
 9-1320 . 
 9-1321 . 
 9-1322 . if (A != B)
 9-1323 . {
 9-1324 .    A = B + C;
 9-1325 .    D = E + F;
 9-1326 . }
 9-1327 . 
 9-1328 . A = B/C;
 9-1329 . A = B-C;
 9-1330 . A = B*C;
 9-1331 . A = B/C;
 9-1332 . A = B/C;
 9-1333 . A = B-C;
 9-1334 . 
 9-1335 . if (A <  B)
 9-1336 . {
 9-1337 .    A = B + C;
 9-1338 .    D = E + F;
 9-1339 . }
 9-1340 . 
 9-1341 . A = B-C;
 9-1342 . A = B+C;
 9-1343 . A = B+C;
 9-1344 . 
 9-1345 . if (A < = B)
 9-1346 . {
 9-1347 .    A = B + C;
 9-1348 .    D = E + F;
 9-1349 . }
 9-1350 . 
 9-1351 . A = B/C;
 9-1352 . /* LE SV TOC-1159 this is a ca-09.7.26 req to fail*/
 9-1353 . 
 9-1354 . if (A le B)
 9-1355 . {
 9-1356 .    A = B + C;
 9-1357 .    D = E + F;
 9-1358 . }
 9-1359 . 
 9-1360 . A = B*C;
 9-1361 . /* LE SV TOC-1160 this is a ca-09.7.28 req to audit*/
 9-1362 . 
 9-1363 . if (A == B)
 9-1364 . {
 9-1365 .    A = B + C;
 9-1366 .    D = E + F;
 9-1367 . }
 9-1368 . 
 9-1369 . 
 9-1370 . if (A < = B)
 9-1371 . {
 9-1372 .    A = B + C;
 9-1373 .    D = E + F;
 9-1374 . }
 9-1375 . 
 9-1376 . 
 9-1377 . if (A >  B)
 9-1378 . {
 9-1379 .    A = B + C;
 9-1380 .    D = E + F;
 9-1381 . }
 9-1382 . 
 9-1383 . 
 9-1384 . if (A gt B)
 9-1385 . {
 9-1386 .    A = B + C;
 9-1387 .    D = E + F;
 9-1388 . }
 9-1389 . 
 9-1390 . 
 9-1391 . if (A ge B)
 9-1392 . {
 9-1393 .    A = B + C;
 9-1394 .    D = E + F;
 9-1395 . }
 9-1396 . 
 9-1397 . A = B+C;
 9-1398 . 
 9-1399 . if (A ne B)
 9-1400 . {
 9-1401 .    A = B + C;
 9-1402 .    D = E + F;
 9-1403 . }
 9-1404 . 
 9-1405 . A = B/C;
 9-1406 . 
 9-1407 . if (A ge B)
 9-1408 . {
 9-1409 .    A = B + C;
 9-1410 .    D = E + F;
 9-1411 . }
 9-1412 . 
 9-1413 . A = B-C;
 9-1414 . A = 0x0003;
 9-1415 . 
 9-1416 . if (A lt B)
 9-1417 . {
 9-1418 .    A = B + C;
 9-1419 .    D = E + F;
 9-1420 . }
 9-1421 . 
 9-1422 . A = B/C;
 9-1423 . /* LE SV TOC-1161 this is a ca-09.7.40 req to audit*/
 9-1424 . A = B*C;
 9-1425 . A = B+C;
 9-1426 . 
 9-1427 . if (A > = B)
 9-1428 . {
 9-1429 .    A = B + C;
 9-1430 .    D = E + F;
 9-1431 . }
 9-1432 . 
 9-1433 . A = B/C;
 9-1434 . A = B-C;
 9-1435 . A = B*C;
 9-1436 . A = B/C;
 9-1437 . A = B+C;
 9-1438 . A = B+C;
 9-1439 . A = B*C;
 9-1440 . A = B*C;
 9-1441 . A = B+C;
 9-1442 . 
 9-1443 . switch (ca stuff)
 9-1444 . {
 9-1445 .    case one:
 9-1446 .    {
 9-1447 .       run_this; 
 9-1448 .       // missing break
 9-1449 .    }
 9-1450 .    case two:
 9-1451 .    {
 9-1452 .       run_this;
 9-1453 .       break;
 9-1454 .    }
 9-1455 .    default:
 9-1456 .    {
 9-1457 .       SwError;
 9-1458 .    }
 9-1459 . }
 9-1460 . 
 9-1461 . A = B/C;
 9-1462 . /* LE SV TOC-1162 this is a ca-09.7.53 req to transform*/
 9-1463 . A = B-C;
 9-1464 . A = B+C;
 9-1465 . A = B-C;
 9-1466 . 
 9-1467 . if (A > = B)
 9-1468 . {
 9-1469 .    A = B + C;
 9-1470 .    D = E + F;
 9-1471 . }
 9-1472 . 
 9-1473 . 
 9-1474 . if (A == B)
 9-1475 . {
 9-1476 .    A = B + C;
 9-1477 .    D = E + F;
 9-1478 . }
 9-1479 . 
 9-1480 . 
 9-1481 . switch (ca stuff)
 9-1482 . {
 9-1483 .    case one:
 9-1484 .    {
 9-1485 .       run_this; 
 9-1486 .       break;
 9-1487 .    }
 9-1488 .    case two:
 9-1489 .    {
 9-1490 .       run_this;
 9-1491 .       break;
 9-1492 .    }
 9-1493 .    default:
 9-1494 .    {
 9-1495 .        SwError;
 9-1496 .    }
 9-1497 . }
 9-1498 . 
 9-1499 . // max LOC 58
 9-1500 . 
 9-1501 . }
 9-1502 . 
 9-1503 . 
 9-1504 . /*
 9-1505 . -----------------------------------------------------------------------------
 9-1506 . --| NAME:   ca.9.8
 9-1507 . --|
 9-1508 . --| ABSTRACT:
 9-1509 . --|   This function does ca stuff.
 9-1510 . --|
 9-1511 . --| RETURNS:
 9-1512 . --|   NONE.
 9-1513 . --|
 9-1514 . ----------------------------------------------------------------------------
 9-1515 . */
 9-1516 . static void ca.9.8(void)
 9-1517 . {
 9-1518 . A = B/C;
 9-1519 . 
 9-1520 . if (A >  B)
 9-1521 . {
 9-1522 .    A = B + C;
 9-1523 .    D = E + F;
 9-1524 . }
 9-1525 . 
 9-1526 . 
 9-1527 . switch (ca stuff)
 9-1528 . {
 9-1529 .    case one:
 9-1530 .    {
 9-1531 .       run_this; 
 9-1532 .       break;
 9-1533 .    }
 9-1534 .    case two:
 9-1535 .    {
 9-1536 .       run_this;
 9-1537 .       break;
 9-1538 .    }
 9-1539 .    default:
 9-1540 .    {
 9-1541 .        SwError;
 9-1542 .    }
 9-1543 . }
 9-1544 . 
 9-1545 . 
 9-1546 . if (A eq B)
 9-1547 . {
 9-1548 .    A = B + C;
 9-1549 .    D = E + F;
 9-1550 . }
 9-1551 . 
 9-1552 . A = B-C;
 9-1553 . A = B-C;
 9-1554 . 
 9-1555 . if (A lt B)
 9-1556 . {
 9-1557 .    A = B + C;
 9-1558 .    D = E + F;
 9-1559 . }
 9-1560 . 
 9-1561 . 
 9-1562 . if (A >  B)
 9-1563 . {
 9-1564 .    A = B + C;
 9-1565 .    D = E + F;
 9-1566 . }
 9-1567 . 
 9-1568 . 
 9-1569 . if (A >  B)
 9-1570 . {
 9-1571 .    A = B + C;
 9-1572 .    D = E + F;
 9-1573 . }
 9-1574 . 
 9-1575 . A = 0x0001;
 9-1576 . A = B-C;
 9-1577 . 
 9-1578 . if (A <  B)
 9-1579 . {
 9-1580 .    A = B + C;
 9-1581 .    D = E + F;
 9-1582 . }
 9-1583 . 
 9-1584 . 
 9-1585 . if (A ge B)
 9-1586 . {
 9-1587 .    A = B + C;
 9-1588 .    D = E + F;
 9-1589 . }
 9-1590 . 
 9-1591 . 
 9-1592 . if (A > = B)
 9-1593 . {
 9-1594 .    A = B + C;
 9-1595 .    D = E + F;
 9-1596 . }
 9-1597 . 
 9-1598 . A = B-C;
 9-1599 . /* LE SV TOC-1163 this is a ca-09.8.15 req to call admin*/
 9-1600 . 
 9-1601 . if (A <  B)
 9-1602 . {
 9-1603 .    A = B + C;
 9-1604 .    D = E + F;
 9-1605 . }
 9-1606 . 
 9-1607 . A = 0x0002;
 9-1608 . A = B-C;
 9-1609 . A = B*C;
 9-1610 . A = B-C;
 9-1611 . A = B/C;
 9-1612 . A = B-C;
 9-1613 . A = B+C;
 9-1614 . 
 9-1615 . if (A != B)
 9-1616 . {
 9-1617 .    A = B + C;
 9-1618 .    D = E + F;
 9-1619 . }
 9-1620 . 
 9-1621 . 
 9-1622 . if (A == B)
 9-1623 . {
 9-1624 .    A = B + C;
 9-1625 .    D = E + F;
 9-1626 . }
 9-1627 . 
 9-1628 . 
 9-1629 . switch (ca stuff)
 9-1630 . {
 9-1631 .    case:
 9-1632 .    case:
 9-1633 .    // stacked case statements but only if there is a new line in between
 9-1634 . 
 9-1635 .    case:
 9-1636 .    case:
 9-1637 .    case:
 9-1638 .    {
 9-1639 .       run_this;
 9-1640 .       break;
 9-1641 .    }
 9-1642 .    default:
 9-1643 .    {
 9-1644 .       halt;
 9-1645 .    }
 9-1646 . }
 9-1647 . 
 9-1648 . A = B/C;
 9-1649 . A = B*C;
 9-1650 . A = B*C;
 9-1651 . 
 9-1652 . if (A != B)
 9-1653 . {
 9-1654 .    A = B + C;
 9-1655 .    D = E + F;
 9-1656 . }
 9-1657 . 
 9-1658 . A = B+C;
 9-1659 . A = B+C;
 9-1660 . A = B*C;
 9-1661 . 
 9-1662 . if (A ne B)
 9-1663 . {
 9-1664 .    A = B + C;
 9-1665 .    D = E + F;
 9-1666 . }
 9-1667 . 
 9-1668 . A = B-C;
 9-1669 . 
 9-1670 . if (A == B)
 9-1671 . {
 9-1672 .    A = B + C;
 9-1673 .    D = E + F;
 9-1674 . }
 9-1675 . 
 9-1676 . A = B*C;
 9-1677 . /* LE SV TOC-1164 this is a ca-09.8.35 req to assign*/
 9-1678 . A = B+C;
 9-1679 . A = B*C;
 9-1680 . 
 9-1681 . if (A <  B)
 9-1682 . {
 9-1683 .    A = B + C;
 9-1684 .    D = E + F;
 9-1685 . }
 9-1686 . 
 9-1687 . A = B/C;
 9-1688 . A = B-C;
 9-1689 . 
 9-1690 . if (A > = B)
 9-1691 . {
 9-1692 .    A = B + C;
 9-1693 .    D = E + F;
 9-1694 . }
 9-1695 . 
 9-1696 . A = B+C;
 9-1697 . A = B+C;
 9-1698 . A = B*C;
 9-1699 . /* LE SV TOC-1165 this is a ca-09.8.44 req to inhibit*/
 9-1700 . 
 9-1701 . if (A eq B)
 9-1702 . {
 9-1703 .    A = B + C;
 9-1704 .    D = E + F;
 9-1705 . }
 9-1706 . 
 9-1707 . A = B+C;
 9-1708 . A = B+C;
 9-1709 . A = B+C;
 9-1710 . 
 9-1711 . if (A lt B)
 9-1712 . {
 9-1713 .    A = B + C;
 9-1714 .    D = E + F;
 9-1715 . }
 9-1716 . 
 9-1717 . 
 9-1718 . if (A gt B)
 9-1719 . {
 9-1720 .    A = B + C;
 9-1721 .    D = E + F;
 9-1722 . }
 9-1723 . 
 9-1724 . A = B-C;
 9-1725 . A = B*C;
 9-1726 . A = 0x0009;
 9-1727 . A = B/C;
 9-1728 . A = B-C;
 9-1729 . A = B+C;
 9-1730 . /* LE SV TOC-1166 this is a ca-09.8.55 req to inhibit*/
 9-1731 . 
 9-1732 . if (A ge B)
 9-1733 . {
 9-1734 .    A = B + C;
 9-1735 .    D = E + F;
 9-1736 . }
 9-1737 . 
 9-1738 . A = B*C;
 9-1739 . A = B/C;
 9-1740 . A = B/C;
 9-1741 . A = B-C;
 9-1742 . A = B-C;
 9-1743 . A = B*C;
 9-1744 . A = B-C;
 9-1745 . A = B*C;
 9-1746 . A = B*C;
 9-1747 . A = B/C;
 9-1748 . 
 9-1749 . if (A == B)
 9-1750 . {
 9-1751 .    A = B + C;
 9-1752 .    D = E + F;
 9-1753 . }
 9-1754 . 
 9-1755 . A = B-C;
 9-1756 . 
 9-1757 . if (A > = B)
 9-1758 . {
 9-1759 .    A = B + C;
 9-1760 .    D = E + F;
 9-1761 . }
 9-1762 . 
 9-1763 . 
 9-1764 . if (A >  B)
 9-1765 . {
 9-1766 .    A = B + C;
 9-1767 .    D = E + F;
 9-1768 . }
 9-1769 . 
 9-1770 . 
 9-1771 . if (A gt B)
 9-1772 . {
 9-1773 .    A = B + C;
 9-1774 .    D = E + F;
 9-1775 . }
 9-1776 . 
 9-1777 . /* LE SV TOC-1167 this is a ca-09.8.71 req to set RTC*/
 9-1778 . A = B*C;
 9-1779 . A = B*C;
 9-1780 . A = B/C;
 9-1781 . 
 9-1782 . if (A ge B)
 9-1783 . {
 9-1784 .    A = B + C;
 9-1785 .    D = E + F;
 9-1786 . }
 9-1787 . 
 9-1788 . A = 0x0008;
 9-1789 . 
 9-1790 . if (A != B)
 9-1791 . {
 9-1792 .    A = B + C;
 9-1793 .    D = E + F;
 9-1794 . }
 9-1795 . 
 9-1796 . 
 9-1797 . switch (ca stuff)
 9-1798 . {
 9-1799 .    case one:
 9-1800 .    {
 9-1801 .       run_this; 
 9-1802 .       break;
 9-1803 .    }
 9-1804 .    case two:
 9-1805 .    {
 9-1806 .       run_this;
 9-1807 .       break;
 9-1808 .    }
 9-1809 .    default:
 9-1810 .    {
 9-1811 .        SwError;
 9-1812 .    }
 9-1813 . }
 9-1814 . 
 9-1815 . A = B/C;
 9-1816 . A = B*C;
 9-1817 . // max LOC 78
 9-1818 . 
 9-1819 . }
 9-1820 . 
 9-1821 . 
 9-1822 . /*
 9-1823 . -----------------------------------------------------------------------------
 9-1824 . --| NAME:   ca.9.9
 9-1825 . --|
 9-1826 . --| ABSTRACT:
 9-1827 . --|   This function does ca stuff.
 9-1828 . --|
 9-1829 . --| RETURNS:
 9-1830 . --|   NONE.
 9-1831 . --|
 9-1832 . ----------------------------------------------------------------------------
 9-1833 . */
 9-1834 . static void ca.9.9(void)
 9-1835 . {
 9-1836 . 
 9-1837 . switch (ca stuff)
 9-1838 . {
 9-1839 .    case one:
 9-1840 .    {
 9-1841 .       run_this; 
 9-1842 .       break;
 9-1843 .    }
 9-1844 .    case two:
 9-1845 .    {
 9-1846 .       run_this;
 9-1847 .       break;
 9-1848 .    }
 9-1849 .    default:
 9-1850 .    {
 9-1851 .        SwError;
 9-1852 .    }
 9-1853 . }
 9-1854 . 
 9-1855 . A = B-C;
 9-1856 . /* LE SV TOC-1168 this is a ca-09.9.3 req to set RTC*/
 9-1857 . 
 9-1858 . if (A <  B)
 9-1859 . {
 9-1860 .    A = B + C;
 9-1861 .    D = E + F;
 9-1862 . }
 9-1863 . 
 9-1864 . A = B+C;
 9-1865 . A = B*C;
 9-1866 . A = B/C;
 9-1867 . // (P) this is really improtant
 9-1868 . A = B-C;
 9-1869 . A = B/C;
 9-1870 . FreePtr = HmiStringPtr;
 9-1871 . A = B-C;
 9-1872 . A = B/C;
 9-1873 . 
 9-1874 . /* dead_code = B + C; 
 9-1875 . dead_code = D + E; 
 9-1876 . dead_code = F + G; */
 9-1877 . 
 9-1878 . A = B/C;
 9-1879 . 
 9-1880 . if (A ge B)
 9-1881 . {
 9-1882 .    A = B + C;
 9-1883 .    D = E + F;
 9-1884 . }
 9-1885 . 
 9-1886 . A = B+C;
 9-1887 . A = B*C;
 9-1888 . 
 9-1889 . if (A == B)
 9-1890 . {
 9-1891 .    A = B + C;
 9-1892 .    D = E + F;
 9-1893 . }
 9-1894 . 
 9-1895 . A = B*C;
 9-1896 . A = B+C;
 9-1897 . A = B/C;
 9-1898 . 
 9-1899 . if (A gt B)
 9-1900 . {
 9-1901 .    A = B + C;
 9-1902 .    D = E + F;
 9-1903 . }
 9-1904 . 
 9-1905 . 
 9-1906 . if (A <  B)
 9-1907 . {
 9-1908 .    A = B + C;
 9-1909 .    D = E + F;
 9-1910 . }
 9-1911 . 
 9-1912 . 
 9-1913 . if (A gt B)
 9-1914 . {
 9-1915 .    A = B + C;
 9-1916 .    D = E + F;
 9-1917 . }
 9-1918 . 
 9-1919 . A = B+C;
 9-1920 . A = B/C;
 9-1921 . 
 9-1922 . if (A lt B)
 9-1923 . {
 9-1924 .    A = B + C;
 9-1925 .    D = E + F;
 9-1926 . }
 9-1927 . 
 9-1928 . A = B+C;
 9-1929 . A = B-C;
 9-1930 . /* LE SV TOC-1169 this is a ca-09.9.27 req to halt*/
 9-1931 . A = B/C;
 9-1932 . A = B/C;
 9-1933 . A = B-C;
 9-1934 . FreePtr = HmiStringPtr;
 9-1935 . A = B-C;
 9-1936 . 
 9-1937 . if (A >  B)
 9-1938 . {
 9-1939 .    A = B + C;
 9-1940 .    D = E + F;
 9-1941 . }
 9-1942 . 
 9-1943 . 
 9-1944 . if (A <  B)
 9-1945 . {
 9-1946 .    A = B + C;
 9-1947 .    D = E + F;
 9-1948 . }
 9-1949 . 
 9-1950 . 
 9-1951 . switch (ca stuff)
 9-1952 . {
 9-1953 .    case one:
 9-1954 .    {
 9-1955 .       run_this; 
 9-1956 .       break;
 9-1957 .    }
 9-1958 .    case two:
 9-1959 .    {
 9-1960 .       run_this;
 9-1961 .       break;
 9-1962 .    }
 9-1963 .    default:
 9-1964 .    {
 9-1965 .        SwError;
 9-1966 .    }
 9-1967 . }
 9-1968 . 
 9-1969 . A = 0x0004;
 9-1970 . A = B-C;
 9-1971 . A = B-C;
 9-1972 . // max LOC 35
 9-1973 . 
 9-1974 . }
 9-1975 . 
 9-1976 . 
 9-1977 . /*
 9-1978 . -----------------------------------------------------------------------------
 9-1979 . --| NAME:   ca.9.10
 9-1980 . --|
 9-1981 . --| ABSTRACT:
 9-1982 . --|   This function does ca stuff.
 9-1983 . --|
 9-1984 . --| RETURNS:
 9-1985 . --|   NONE.
 9-1986 . --|
 9-1987 . ----------------------------------------------------------------------------
 9-1988 . */
 9-1989 . static void ca.9.10(void)
 9-1990 . {
 9-1991 . 
 9-1992 . if (A < = B)
 9-1993 . {
 9-1994 .    A = B + C;
 9-1995 .    D = E + F;
 9-1996 . }
 9-1997 . 
 9-1998 . 
 9-1999 . if (A ge B)
 9-2000 . {
 9-2001 .    A = B + C;
 9-2002 .    D = E + F;
 9-2003 . }
 9-2004 . 
 9-2005 . 
 9-2006 . if (A >  B)
 9-2007 . {
 9-2008 .    A = B + C;
 9-2009 .    D = E + F;
 9-2010 . }
 9-2011 . 
 9-2012 . 
 9-2013 . if (A >  B)
 9-2014 . {
 9-2015 .    A = B + C;
 9-2016 .    D = E + F;
 9-2017 . }
 9-2018 . 
 9-2019 . A = B+C;
 9-2020 . 
 9-2021 . if (A eq B)
 9-2022 . {
 9-2023 .    A = B + C;
 9-2024 .    D = E + F;
 9-2025 . }
 9-2026 . 
 9-2027 . 
 9-2028 . if (A > = B)
 9-2029 . {
 9-2030 .    A = B + C;
 9-2031 .    D = E + F;
 9-2032 . }
 9-2033 . 
 9-2034 . A = B/C;
 9-2035 . A = B*C;
 9-2036 . A = B*C;
 9-2037 . A = B+C;
 9-2038 . 
 9-2039 . if (A ne B)
 9-2040 . {
 9-2041 .    A = B + C;
 9-2042 .    D = E + F;
 9-2043 . }
 9-2044 . 
 9-2045 . A = B+C;
 9-2046 . // TBS - I need to figure this out
 9-2047 . A = B+C;
 9-2048 . A = B+C;
 9-2049 . 
 9-2050 . if (A > = B)
 9-2051 . {
 9-2052 .    A = B + C;
 9-2053 .    D = E + F;
 9-2054 . }
 9-2055 . 
 9-2056 . A = B*C;
 9-2057 . A = B/C;
 9-2058 . 
 9-2059 . if (A le B)
 9-2060 . {
 9-2061 .    A = B + C;
 9-2062 .    D = E + F;
 9-2063 . }
 9-2064 . 
 9-2065 . 
 9-2066 . if (A < = B)
 9-2067 . {
 9-2068 .    A = B + C;
 9-2069 .    D = E + F;
 9-2070 . }
 9-2071 . 
 9-2072 . 
 9-2073 . if (A gt B)
 9-2074 . {
 9-2075 .    A = B + C;
 9-2076 .    D = E + F;
 9-2077 . }
 9-2078 . 
 9-2079 . A = B*C;
 9-2080 . A = B+C;
 9-2081 . A = B-C;
 9-2082 . A = B/C;
 9-2083 . 
 9-2084 . if (A > = B)
 9-2085 . {
 9-2086 .    A = B + C;
 9-2087 .    D = E + F;
 9-2088 . }
 9-2089 . 
 9-2090 . A = B*C;
 9-2091 . A = B*C;
 9-2092 . 
 9-2093 . switch (ca stuff)
 9-2094 . {
 9-2095 .    case one:
 9-2096 .    {
 9-2097 .       run_this; 
 9-2098 .       break;
 9-2099 .    }
 9-2100 .    case two:
 9-2101 .    {
 9-2102 .       run_this;
 9-2103 .       break;
 9-2104 .    }
 9-2105 .    default:
 9-2106 .    {
 9-2107 .        SwError;
 9-2108 .    }
 9-2109 . }
 9-2110 . 
 9-2111 . A = B/C;
 9-2112 . A = B/C;
 9-2113 . A = B*C;
 9-2114 . 
 9-2115 . if (A > = B)
 9-2116 . {
 9-2117 .    A = B + C;
 9-2118 .    D = E + F;
 9-2119 . }
 9-2120 . 
 9-2121 . A = B-C;
 9-2122 . // max LOC 34
 9-2123 . 
 9-2124 . }
 9-2125 . 
 9-2126 . 
 9-2127 . /*
 9-2128 . -----------------------------------------------------------------------------
 9-2129 . --| NAME:   ca.9.11
 9-2130 . --|
 9-2131 . --| ABSTRACT:
 9-2132 . --|   This function does ca stuff.
 9-2133 . --|
 9-2134 . --| RETURNS:
 9-2135 . --|   NONE.
 9-2136 . --|
 9-2137 . ----------------------------------------------------------------------------
 9-2138 . */
 9-2139 . static void ca.9.11(void)
 9-2140 . {
 9-2141 . A = B+C;
 9-2142 . 
 9-2143 . if (A eq B)
 9-2144 . {
 9-2145 .    A = B + C;
 9-2146 .    D = E + F;
 9-2147 . }
 9-2148 . 
 9-2149 . A = B+C;
 9-2150 . 
 9-2151 . if (A == B)
 9-2152 . {
 9-2153 .    A = B + C;
 9-2154 .    D = E + F;
 9-2155 . }
 9-2156 . 
 9-2157 . A = B+C;
 9-2158 . A = B-C;
 9-2159 . A = B-C;
 9-2160 . A = B/C;
 9-2161 . A = B*C;
 9-2162 . // max LOC 9
 9-2163 . 
 9-2164 . }
 9-2165 . 

9 9 Result: result/source/ft-app/ft-app-B1.1/ca/ca-09.c


10 10 Source: source/ft-app/ft-app-B1.1/dlp/dlp-01.c
 10-0 . /*
 10-1 . ----------------------------------------------------------------------------
 10-2 . --| BEGIN PROLOGUE
 10-3 . --|
 10-4 . --| CLASSIFICATION: UNCLASSIFIED
 10-5 . --|
 10-6 . --| FILE NAME:      dlp-01.c
 10-7 . --|
 10-8 . --| ABSTRACT:
 10-9 . --|   This file contains the 1 functions that do file dlp stuff.
 10-10 . --|
 10-11 . --| HISTORY:
 10-12 . --|   CCCQ_NAME:
 10-13 . --|   CCCQ_VER: 
 10-14 . --|
 10-15 . --| END PROLOGUE
 10-16 . ----------------------------------------------------------------------------
 10-17 . */
 10-18 . 
 10-19 . #include C;
 10-20 . double C;
 10-21 . #include C;
 10-22 . float B;
 10-23 . #include B;
 10-24 . #define C;
 10-25 . char D;
 10-26 . #include C;
 10-27 . 
 10-28 . 
 10-29 . 
 10-30 . /*
 10-31 . -----------------------------------------------------------------------------
 10-32 . --| NAME:   dlp.1.1
 10-33 . --|
 10-34 . --| ABSTRACT:
 10-35 . --|   This function does dlp stuff.
 10-36 . --|
 10-37 . --| RETURNS:
 10-38 . --|   NONE.
 10-39 . --|
 10-40 . ----------------------------------------------------------------------------
 10-41 . */
 10-42 . static void dlp.1.1(void)
 10-43 . {
 10-44 . A = B/C;
 10-45 . 
 10-46 . if (A != B)
 10-47 . {
 10-48 .    A = B + C;
 10-49 .    D = E + F;
 10-50 . }
 10-51 . 
 10-52 . A = B+C;
 10-53 . A = B/C;
 10-54 . 
 10-55 . if (A ne B)
 10-56 . {
 10-57 .    A = B + C;
 10-58 .    D = E + F;
 10-59 . }
 10-60 . 
 10-61 . 
 10-62 . if (A ne B)
 10-63 . {
 10-64 .    A = B + C;
 10-65 .    D = E + F;
 10-66 . }
 10-67 . 
 10-68 . 
 10-69 . if (A > = B)
 10-70 . {
 10-71 .    A = B + C;
 10-72 .    D = E + F;
 10-73 . }
 10-74 . 
 10-75 . A = B+C;
 10-76 . 
 10-77 . if (A ge B)
 10-78 . {
 10-79 .    A = B + C;
 10-80 .    D = E + F;
 10-81 . }
 10-82 . 
 10-83 . 
 10-84 . switch (dlp stuff)
 10-85 . {
 10-86 .    case one:
 10-87 .    {
 10-88 .       run_this; 
 10-89 .       break;
 10-90 .    }
 10-91 .    case two:
 10-92 .    {
 10-93 .       run_this;
 10-94 .       break;
 10-95 .    }
 10-96 .    default:
 10-97 .    {
 10-98 .        SwError;
 10-99 .    }
 10-100 . }
 10-101 . 
 10-102 . // TBD - what do I do now
 10-103 . A = B-C;
 10-104 . A = B-C;
 10-105 . A = B-C;
 10-106 . A = 0x0007;
 10-107 . A = B-C;
 10-108 . A = B*C;
 10-109 . A = B*C;
 10-110 . A = B+C;
 10-111 . A = B+C;
 10-112 . 
 10-113 . if (A gt B)
 10-114 . {
 10-115 .    A = B + C;
 10-116 .    D = E + F;
 10-117 . }
 10-118 . 
 10-119 . A = B+C;
 10-120 . 
 10-121 . if (A ge B)
 10-122 . {
 10-123 .    A = B + C;
 10-124 .    D = E + F;
 10-125 . }
 10-126 . 
 10-127 . // TBD - what do I do now
 10-128 . 
 10-129 . if (A lt B)
 10-130 . {
 10-131 .    A = B + C;
 10-132 .    D = E + F;
 10-133 . }
 10-134 . 
 10-135 . 
 10-136 . if (A == B)
 10-137 . {
 10-138 .    A = B + C;
 10-139 .    D = E + F;
 10-140 . }
 10-141 . 
 10-142 . 
 10-143 . if (A ne B)
 10-144 . {
 10-145 .    A = B + C;
 10-146 .    D = E + F;
 10-147 . }
 10-148 . 
 10-149 . A = B*C;
 10-150 . 
 10-151 . if (A ne B)
 10-152 . {
 10-153 .    A = B + C;
 10-154 .    D = E + F;
 10-155 . }
 10-156 . 
 10-157 . A = B*C;
 10-158 . A = B/C;
 10-159 . 
 10-160 . if (A != B)
 10-161 . {
 10-162 .    A = B + C;
 10-163 .    D = E + F;
 10-164 . }
 10-165 . 
 10-166 . /* LE SV TOC-1202 this is a dlp-01.1.30 req to disable*/
 10-167 . A = B/C;
 10-168 . A = B/C;
 10-169 . A = B/C;
 10-170 . A = B+C;
 10-171 . /* LE SV TOC-1203 this is a dlp-01.1.34 req to store*/
 10-172 . 
 10-173 . switch (dlp stuff)
 10-174 . {
 10-175 .    case one:
 10-176 .    {
 10-177 .       run_this; 
 10-178 .       break;
 10-179 .    }
 10-180 .    case two:
 10-181 .    {
 10-182 .       run_this;
 10-183 .       break;
 10-184 .    }
 10-185 .    default:
 10-186 .    {
 10-187 .        SwError;
 10-188 .    }
 10-189 . }
 10-190 . 
 10-191 . 
 10-192 . if (A gt B)
 10-193 . {
 10-194 .    A = B + C;
 10-195 .    D = E + F;
 10-196 . }
 10-197 . 
 10-198 . 
 10-199 . if (A == B)
 10-200 . {
 10-201 .    A = B + C;
 10-202 .    D = E + F;
 10-203 . }
 10-204 . 
 10-205 . /* LE SV TOC-1204 this is a dlp-01.1.37 req to set Real Time Clock*/
 10-206 . A = B*C;
 10-207 . A = 0x0002;
 10-208 . A = B/C;
 10-209 . A = B-C;
 10-210 . A = B-C;
 10-211 . A = B-C;
 10-212 . A = B*C;
 10-213 . 
 10-214 . if (A le B)
 10-215 . {
 10-216 .    A = B + C;
 10-217 .    D = E + F;
 10-218 . }
 10-219 . 
 10-220 . 
 10-221 . if (A > = B)
 10-222 . {
 10-223 .    A = B + C;
 10-224 .    D = E + F;
 10-225 . }
 10-226 . 
 10-227 . A = B-C;
 10-228 . A = B-C;
 10-229 . A = B/C;
 10-230 . 
 10-231 . if (A > = B)
 10-232 . {
 10-233 .    A = B + C;
 10-234 .    D = E + F;
 10-235 . }
 10-236 . 
 10-237 . // max LOC 48
 10-238 . 
 10-239 . }
 10-240 . 

10 10 Result: result/source/ft-app/ft-app-B1.1/dlp/dlp-01.c


11 11 Source: source/ft-app/ft-app-B1.1/dlp/dlp-02.c
 11-0 . /*
 11-1 . ----------------------------------------------------------------------------
 11-2 . --| BEGIN PROLOGUE
 11-3 . --|
 11-4 . --| CLASSIFICATION: UNCLASSIFIED
 11-5 . --|
 11-6 . --| FILE NAME:      dlp-02.c
 11-7 . --|
 11-8 . --| ABSTRACT:
 11-9 . --|   This file contains the 6 functions that do file dlp stuff.
 11-10 . --|
 11-11 . --| HISTORY:
 11-12 . --|   CCCQ_NAME:
 11-13 . --|   CCCQ_VER: 
 11-14 . --|
 11-15 . --| END PROLOGUE
 11-16 . ----------------------------------------------------------------------------
 11-17 . */
 11-18 . 
 11-19 . #include A;
 11-20 . #include D;
 11-21 . #define C;
 11-22 . #include C;
 11-23 . #define C;
 11-24 . #define B;
 11-25 . int A;
 11-26 . #include D;
 11-27 . #include C;
 11-28 . 
 11-29 . 
 11-30 . 
 11-31 . /*
 11-32 . -----------------------------------------------------------------------------
 11-33 . --| NAME:   dlp.2.1
 11-34 . --|
 11-35 . --| ABSTRACT:
 11-36 . --|   This function does dlp stuff.
 11-37 . --|
 11-38 . --| RETURNS:
 11-39 . --|   NONE.
 11-40 . --|
 11-41 . ----------------------------------------------------------------------------
 11-42 . */
 11-43 . static void dlp.2.1(void)
 11-44 . {
 11-45 . A = B/C;
 11-46 . A = B*C;
 11-47 . A = B/C;
 11-48 . 
 11-49 . if (A lt B)
 11-50 . {
 11-51 .    A = B + C;
 11-52 .    D = E + F;
 11-53 . }
 11-54 . 
 11-55 . A = B+C;
 11-56 . A = B/C;
 11-57 . A = B*C;
 11-58 . /* LE SV TOC-1205 this is a dlp-02.1.8 req to disable*/
 11-59 . A = B-C;
 11-60 . 
 11-61 . if (A <  B)
 11-62 . {
 11-63 .    A = B + C;
 11-64 .    D = E + F;
 11-65 . }
 11-66 . 
 11-67 . A = B/C;
 11-68 . A = B/C;
 11-69 . A = B/C;
 11-70 . A = B+C;
 11-71 . A = B-C;
 11-72 . FreePtr = HmiStringPtr;
 11-73 . A = B/C;
 11-74 . A = 0x0004;
 11-75 . A = B+C;
 11-76 . A = B/C;
 11-77 . A = B-C;
 11-78 . // TBS - I need to figure this out
 11-79 . A = B/C;
 11-80 . 
 11-81 . if (A gt B)
 11-82 . {
 11-83 .    A = B + C;
 11-84 .    D = E + F;
 11-85 . }
 11-86 . 
 11-87 . A = B-C;
 11-88 . 
 11-89 . if (A <  B)
 11-90 . {
 11-91 .    A = B + C;
 11-92 .    D = E + F;
 11-93 . }
 11-94 . 
 11-95 . A = B+C;
 11-96 . A = B*C;
 11-97 . 
 11-98 . if (A < = B)
 11-99 . {
 11-100 .    A = B + C;
 11-101 .    D = E + F;
 11-102 . }
 11-103 . 
 11-104 . A = B/C;
 11-105 . /* LE SV TOC-1206 this is a dlp-02.1.27 req to compare*/
 11-106 . A = B-C;
 11-107 . // max LOC 27
 11-108 . 
 11-109 . }
 11-110 . 
 11-111 . 
 11-112 . /*
 11-113 . -----------------------------------------------------------------------------
 11-114 . --| NAME:   dlp.2.2
 11-115 . --|
 11-116 . --| ABSTRACT:
 11-117 . --|   This function does dlp stuff.
 11-118 . --|
 11-119 . --| RETURNS:
 11-120 . --|   NONE.
 11-121 . --|
 11-122 . ----------------------------------------------------------------------------
 11-123 . */
 11-124 . static void dlp.2.2(void)
 11-125 . {
 11-126 . 
 11-127 . switch (dlp stuff)
 11-128 . {
 11-129 .    case one:
 11-130 .    {
 11-131 .       run_this; 
 11-132 .       break;
 11-133 .    }
 11-134 .    case two:
 11-135 .    {
 11-136 .       run_this;
 11-137 .       break;
 11-138 .    }
 11-139 .    default:
 11-140 .    {
 11-141 .        SwError;
 11-142 .    }
 11-143 . }
 11-144 . 
 11-145 . A = B-C;
 11-146 . A = B+C;
 11-147 . 
 11-148 . if (A < = B)
 11-149 . {
 11-150 .    A = B + C;
 11-151 .    D = E + F;
 11-152 . }
 11-153 . 
 11-154 . 
 11-155 . if (A eq B)
 11-156 . {
 11-157 .    A = B + C;
 11-158 .    D = E + F;
 11-159 . }
 11-160 . 
 11-161 . A = B+C;
 11-162 . A = B-C;
 11-163 . 
 11-164 . if (A ge B)
 11-165 . {
 11-166 .    A = B + C;
 11-167 .    D = E + F;
 11-168 . }
 11-169 . 
 11-170 . A = B*C;
 11-171 . A = B/C;
 11-172 . /* LE SV TOC-1207 this is a dlp-02.2.11 req to transform*/
 11-173 . A = B/C;
 11-174 . /* LE SV TOC-1208 this is a dlp-02.2.12 req to set Real Time Clock*/
 11-175 . 
 11-176 . if (A lt B)
 11-177 . {
 11-178 .    A = B + C;
 11-179 .    D = E + F;
 11-180 . }
 11-181 . 
 11-182 . A = (long)B + C;
 11-183 . 
 11-184 . if (A ge B)
 11-185 . {
 11-186 .    A = B + C;
 11-187 .    D = E + F;
 11-188 . }
 11-189 . 
 11-190 . A = B/C;
 11-191 . A = B/C;
 11-192 . 
 11-193 . if (A gt B)
 11-194 . {
 11-195 .    A = B + C;
 11-196 .    D = E + F;
 11-197 . }
 11-198 . 
 11-199 . A = B-C;
 11-200 . A = B+C;
 11-201 . A = 0x0004;
 11-202 . A = B*C;
 11-203 . A = B/C;
 11-204 . 
 11-205 . if (A ne B)
 11-206 . {
 11-207 .    A = B + C;
 11-208 .    D = E + F;
 11-209 . }
 11-210 . 
 11-211 . 
 11-212 . if (A ge B)
 11-213 . {
 11-214 .    A = B + C;
 11-215 .    D = E + F;
 11-216 . }
 11-217 . 
 11-218 . A = B+C;
 11-219 . A = B-C;
 11-220 . A = B-C;
 11-221 . A = B+C;
 11-222 . A = B+C;
 11-223 . A = B*C;
 11-224 . A = B*C;
 11-225 . A = B-C;
 11-226 . 
 11-227 . if (A eq B)
 11-228 . {
 11-229 .    A = B + C;
 11-230 .    D = E + F;
 11-231 . }
 11-232 . 
 11-233 . A = B+C;
 11-234 . A = B*C;
 11-235 . // max LOC 33
 11-236 . 
 11-237 . }
 11-238 . 
 11-239 . 
 11-240 . /*
 11-241 . -----------------------------------------------------------------------------
 11-242 . --| NAME:   dlp.2.3
 11-243 . --|
 11-244 . --| ABSTRACT:
 11-245 . --|   This function does dlp stuff.
 11-246 . --|
 11-247 . --| RETURNS:
 11-248 . --|   NONE.
 11-249 . --|
 11-250 . ----------------------------------------------------------------------------
 11-251 . */
 11-252 . static void dlp.2.3(void)
 11-253 . {
 11-254 . A = B/C;
 11-255 . A = B*C;
 11-256 . A = B*C;
 11-257 . 
 11-258 . switch (dlp stuff)
 11-259 . {
 11-260 .    case one:
 11-261 .    {
 11-262 .       run_this; 
 11-263 .       break;
 11-264 .    }
 11-265 .    case two:
 11-266 .    {
 11-267 .       run_this;
 11-268 .       break;
 11-269 .    }
 11-270 .    default:
 11-271 .    {
 11-272 .        SwError;
 11-273 .    }
 11-274 . }
 11-275 . 
 11-276 . 
 11-277 . /* dead_block = C * D; 
 11-278 . dead_block = E * F; */
 11-279 . 
 11-280 . A = B+C;
 11-281 . 
 11-282 . if (A > = B)
 11-283 . {
 11-284 .    A = B + C;
 11-285 .    D = E + F;
 11-286 . }
 11-287 . 
 11-288 . A = B/C;
 11-289 . 
 11-290 . if (A le B)
 11-291 . {
 11-292 .    A = B + C;
 11-293 .    D = E + F;
 11-294 . }
 11-295 . 
 11-296 . A = B/C;
 11-297 . A = B+C;
 11-298 . /* LE SV TOC-1209 this is a dlp-02.3.11 req to check unix*/
 11-299 . A = B-C;
 11-300 . A = B+C;
 11-301 . A = B/C;
 11-302 . 
 11-303 . if (A <  B)
 11-304 . {
 11-305 .    A = B + C;
 11-306 .    D = E + F;
 11-307 . }
 11-308 . 
 11-309 . A = B+C;
 11-310 . /* LE SV TOC-1210 this is a dlp-02.3.16 req to convert*/
 11-311 . 
 11-312 . if (A lt B)
 11-313 . {
 11-314 .    A = B + C;
 11-315 .    D = E + F;
 11-316 . }
 11-317 . 
 11-318 . 
 11-319 . if (A <  B)
 11-320 . {
 11-321 .    A = B + C;
 11-322 .    D = E + F;
 11-323 . }
 11-324 . 
 11-325 . 
 11-326 . if (A gt B)
 11-327 . {
 11-328 .    A = B + C;
 11-329 .    D = E + F;
 11-330 . }
 11-331 . 
 11-332 . A = B-C;
 11-333 . // TBS - I need to figure this out
 11-334 . 
 11-335 . if (A ge B)
 11-336 . {
 11-337 .    A = B + C;
 11-338 .    D = E + F;
 11-339 . }
 11-340 . 
 11-341 . 
 11-342 . if (A lt B)
 11-343 . {
 11-344 .    A = B + C;
 11-345 .    D = E + F;
 11-346 . }
 11-347 . 
 11-348 . A = B-C;
 11-349 . A = B*C;
 11-350 . A = B/C;
 11-351 . A = B*C;
 11-352 . 
 11-353 . if (A != B)
 11-354 . {
 11-355 .    A = B + C;
 11-356 .    D = E + F;
 11-357 . }
 11-358 . 
 11-359 . A = B+C;
 11-360 . 
 11-361 . if (A le B)
 11-362 . {
 11-363 .    A = B + C;
 11-364 .    D = E + F;
 11-365 . }
 11-366 . 
 11-367 . 
 11-368 . if (A ge B)
 11-369 . {
 11-370 .    A = B + C;
 11-371 .    D = E + F;
 11-372 . }
 11-373 . 
 11-374 . 
 11-375 . if (A ge B)
 11-376 . {
 11-377 .    A = B + C;
 11-378 .    D = E + F;
 11-379 . }
 11-380 . 
 11-381 . A = B/C;
 11-382 . 
 11-383 . switch (dlp stuff)
 11-384 . {
 11-385 .    case one:
 11-386 .    {
 11-387 .       run_this; 
 11-388 .       break;
 11-389 .    }
 11-390 .    case two:
 11-391 .    {
 11-392 .       run_this;
 11-393 .       break;
 11-394 .    }
 11-395 .    default:
 11-396 .    {
 11-397 .        SwError;
 11-398 .    }
 11-399 . }
 11-400 . 
 11-401 . 
 11-402 . if (A ge B)
 11-403 . {
 11-404 .    A = B + C;
 11-405 .    D = E + F;
 11-406 . }
 11-407 . 
 11-408 . A = B-C;
 11-409 . A = B+C;
 11-410 . A = B/C;
 11-411 . A = B-C;
 11-412 . A = B*C;
 11-413 . A = B/C;
 11-414 . A = B*C;
 11-415 . 
 11-416 . if (A == B)
 11-417 . {
 11-418 .    A = B + C;
 11-419 .    D = E + F;
 11-420 . }
 11-421 . 
 11-422 . A = B+C;
 11-423 . A = B+C;
 11-424 . 
 11-425 . if (A == B)
 11-426 . {
 11-427 .    A = B + C;
 11-428 .    D = E + F;
 11-429 . }
 11-430 . 
 11-431 . A = B+C;
 11-432 . A = B*C;
 11-433 . A = B-C;
 11-434 . 
 11-435 . if (A != B)
 11-436 . {
 11-437 .    A = B + C;
 11-438 .    D = E + F;
 11-439 . }
 11-440 . 
 11-441 . A = B/C;
 11-442 . A = B/C;
 11-443 . 
 11-444 . switch (dlp stuff)
 11-445 . {
 11-446 .    case:
 11-447 .    case:
 11-448 .    // stacked case statements but only if there is a new line in between
 11-449 . 
 11-450 .    case:
 11-451 .    case:
 11-452 .    case:
 11-453 .    {
 11-454 .       run_this;
 11-455 .       break;
 11-456 .    }
 11-457 .    default:
 11-458 .    {
 11-459 .       halt;
 11-460 .    }
 11-461 . }
 11-462 . 
 11-463 . 
 11-464 . if (A != B)
 11-465 . {
 11-466 .    A = B + C;
 11-467 .    D = E + F;
 11-468 . }
 11-469 . 
 11-470 . A = B/C;
 11-471 . /* LE SV TOC-1211 this is a dlp-02.3.53 req to convert*/
 11-472 . A = B+C;
 11-473 . A = B-C;
 11-474 . A = B/C;
 11-475 . A = B/C;
 11-476 . A = B*C;
 11-477 . 
 11-478 . switch (dlp stuff)
 11-479 . {
 11-480 .    case one:
 11-481 .    {
 11-482 .       switch (nested)
 11-483 .       {
 11-484 .          case:
 11-485 .             X = Y + Z;
 11-486 .          case:
 11-487 .             X = Y + Z;
 11-488 .          default:
 11-489 .             SwError;
 11-490 .       } 
 11-491 .    }
 11-492 .    case two:
 11-493 .    {
 11-494 .       run_this;
 11-495 .       break;
 11-496 .    }
 11-497 .    default:
 11-498 .    {
 11-499 .       SwError;
 11-500 .    }
 11-501 . }
 11-502 . 
 11-503 . A = B+C;
 11-504 . A = B-C;
 11-505 . A = B+C;
 11-506 . A = B-C;
 11-507 . 
 11-508 . if (A == B)
 11-509 . {
 11-510 .    A = B + C;
 11-511 .    D = E + F;
 11-512 . }
 11-513 . 
 11-514 . 
 11-515 . if (A <  B)
 11-516 . {
 11-517 .    A = B + C;
 11-518 .    D = E + F;
 11-519 . }
 11-520 . 
 11-521 . A = B/C;
 11-522 . 
 11-523 . switch (dlp stuff)
 11-524 . {
 11-525 .    case:
 11-526 .    case:
 11-527 .    // stacked case statements but only if there is a new line in between
 11-528 . 
 11-529 .    case:
 11-530 .    case:
 11-531 .    case:
 11-532 .    {
 11-533 .       run_this;
 11-534 .       break;
 11-535 .    }
 11-536 .    default:
 11-537 .    {
 11-538 .       halt;
 11-539 .    }
 11-540 . }
 11-541 . 
 11-542 . A = B/C;
 11-543 . A = B+C;
 11-544 . A = B-C;
 11-545 . A = B*C;
 11-546 . A = B/C;
 11-547 . 
 11-548 . switch (dlp stuff)
 11-549 . {
 11-550 .    case one:
 11-551 .    {
 11-552 .       run_this; 
 11-553 .       break;
 11-554 .    }
 11-555 .    case two:
 11-556 .    {
 11-557 .       run_this;
 11-558 .       break;
 11-559 .    }
 11-560 .    default:
 11-561 .    {
 11-562 .        SwError;
 11-563 .    }
 11-564 . }
 11-565 . 
 11-566 . A = B+C;
 11-567 . /* LE SV TOC-1212 this is a dlp-02.3.72 req to recover*/
 11-568 . 
 11-569 . if (A le B)
 11-570 . {
 11-571 .    A = B + C;
 11-572 .    D = E + F;
 11-573 . }
 11-574 . 
 11-575 . 
 11-576 . if (A eq B)
 11-577 . {
 11-578 .    A = B + C;
 11-579 .    D = E + F;
 11-580 . }
 11-581 . 
 11-582 . 
 11-583 . if (A > = B)
 11-584 . {
 11-585 .    A = B + C;
 11-586 .    D = E + F;
 11-587 . }
 11-588 . 
 11-589 . A = B-C;
 11-590 . A = B/C;
 11-591 . A = B/C;
 11-592 . // max LOC 77
 11-593 . 
 11-594 . }
 11-595 . 
 11-596 . 
 11-597 . /*
 11-598 . -----------------------------------------------------------------------------
 11-599 . --| NAME:   dlp.2.4
 11-600 . --|
 11-601 . --| ABSTRACT:
 11-602 . --|   This function does dlp stuff.
 11-603 . --|
 11-604 . --| RETURNS:
 11-605 . --|   NONE.
 11-606 . --|
 11-607 . ----------------------------------------------------------------------------
 11-608 . */
 11-609 . static void dlp.2.4(void)
 11-610 . {
 11-611 . A = B*C;
 11-612 . A = B-C;
 11-613 . A = B*C;
 11-614 . A = B+C;
 11-615 . A = B*C;
 11-616 . /* dead_code = A * B; */
 11-617 . 
 11-618 . if (A == B)
 11-619 . {
 11-620 .    A = B + C;
 11-621 .    D = E + F;
 11-622 . }
 11-623 . 
 11-624 . A = B/C;
 11-625 . A = B*C;
 11-626 . A = B-C;
 11-627 . A = B/C;
 11-628 . 
 11-629 . if (A > = B)
 11-630 . {
 11-631 .    A = B + C;
 11-632 .    D = E + F;
 11-633 . }
 11-634 . 
 11-635 . 
 11-636 . if (A != B)
 11-637 . {
 11-638 .    A = B + C;
 11-639 .    D = E + F;
 11-640 . }
 11-641 . 
 11-642 . A = B*C;
 11-643 . 
 11-644 . if (A lt B)
 11-645 . {
 11-646 .    A = B + C;
 11-647 .    D = E + F;
 11-648 . }
 11-649 . 
 11-650 . 
 11-651 . if (A != B)
 11-652 . {
 11-653 .    A = B + C;
 11-654 .    D = E + F;
 11-655 . }
 11-656 . 
 11-657 . A = B*C;
 11-658 . 
 11-659 . if (A le B)
 11-660 . {
 11-661 .    A = B + C;
 11-662 .    D = E + F;
 11-663 . }
 11-664 . 
 11-665 . A = B+C;
 11-666 . A = B/C;
 11-667 . 
 11-668 . if (A == B)
 11-669 . {
 11-670 .    A = B + C;
 11-671 .    D = E + F;
 11-672 . }
 11-673 . 
 11-674 . A = B/C;
 11-675 . A = B-C;
 11-676 . A = B/C;
 11-677 . // max LOC 23
 11-678 . 
 11-679 . }
 11-680 . 
 11-681 . 
 11-682 . /*
 11-683 . -----------------------------------------------------------------------------
 11-684 . --| NAME:   dlp.2.5
 11-685 . --|
 11-686 . --| ABSTRACT:
 11-687 . --|   This function does dlp stuff.
 11-688 . --|
 11-689 . --| RETURNS:
 11-690 . --|   NONE.
 11-691 . --|
 11-692 . ----------------------------------------------------------------------------
 11-693 . */
 11-694 . static void dlp.2.5(void)
 11-695 . {
 11-696 . /* LE SV TOC-1213 this is a dlp-02.5.1 req to verify*/
 11-697 . A = B/C;
 11-698 . /* LE SV TOC-1214 this is a dlp-02.5.2 req to process*/
 11-699 . A = B*C;
 11-700 . A = B-C;
 11-701 . A = B+C;
 11-702 . A = B-C;
 11-703 . A = B-C;
 11-704 . A = B/C;
 11-705 . A = B*C;
 11-706 . 
 11-707 . if (A > = B)
 11-708 . {
 11-709 .    A = B + C;
 11-710 .    D = E + F;
 11-711 . }
 11-712 . 
 11-713 . 
 11-714 . if (A >  B)
 11-715 . {
 11-716 .    A = B + C;
 11-717 .    D = E + F;
 11-718 . }
 11-719 . 
 11-720 . A = B*C;
 11-721 . A = B+C;
 11-722 . A = B/C;
 11-723 . A = B-C;
 11-724 . A = B+C;
 11-725 . 
 11-726 . if (A ge B)
 11-727 . {
 11-728 .    A = B + C;
 11-729 .    D = E + F;
 11-730 . }
 11-731 . 
 11-732 . 
 11-733 . if (A le B)
 11-734 . {
 11-735 .    A = B + C;
 11-736 .    D = E + F;
 11-737 . }
 11-738 . 
 11-739 . A = B-C;
 11-740 . /* LE SV TOC-1215 this is a dlp-02.5.19 req to verify*/
 11-741 . 
 11-742 . if (A lt B)
 11-743 . {
 11-744 .    A = B + C;
 11-745 .    D = E + F;
 11-746 . }
 11-747 . 
 11-748 . A = B-C;
 11-749 . A = B*C;
 11-750 . A = B+C;
 11-751 . 
 11-752 . if (A eq B)
 11-753 . {
 11-754 .    A = B + C;
 11-755 .    D = E + F;
 11-756 . }
 11-757 . 
 11-758 . A = B/C;
 11-759 . A = B+C;
 11-760 . 
 11-761 . if (A >  B)
 11-762 . {
 11-763 .    A = B + C;
 11-764 .    D = E + F;
 11-765 . }
 11-766 . 
 11-767 . A = B/C;
 11-768 . 
 11-769 . if (A == B)
 11-770 . {
 11-771 .    A = B + C;
 11-772 .    D = E + F;
 11-773 . }
 11-774 . 
 11-775 . A = B/C;
 11-776 . 
 11-777 . if (A < = B)
 11-778 . {
 11-779 .    A = B + C;
 11-780 .    D = E + F;
 11-781 . }
 11-782 . 
 11-783 . A = B*C;
 11-784 . 
 11-785 . if (A >  B)
 11-786 . {
 11-787 .    A = B + C;
 11-788 .    D = E + F;
 11-789 . }
 11-790 . 
 11-791 . 
 11-792 . if (A >  B)
 11-793 . {
 11-794 .    A = B + C;
 11-795 .    D = E + F;
 11-796 . }
 11-797 . 
 11-798 . /* LE SV TOC-1216 this is a dlp-02.5.34 req to audit*/
 11-799 . A = B-C;
 11-800 . 
 11-801 . if (A gt B)
 11-802 . {
 11-803 .    A = B + C;
 11-804 .    D = E + F;
 11-805 . }
 11-806 . 
 11-807 . A = B+C;
 11-808 . A = B/C;
 11-809 . A = B-C;
 11-810 . 
 11-811 . switch (dlp stuff)
 11-812 . {
 11-813 .    case one:
 11-814 .    {
 11-815 .       run_this; 
 11-816 .       break;
 11-817 .    }
 11-818 .    case two:
 11-819 .    {
 11-820 .       run_this;
 11-821 .       break;
 11-822 .    }
 11-823 .    default:
 11-824 .    {
 11-825 .        SwError;
 11-826 .    }
 11-827 . }
 11-828 . 
 11-829 . 
 11-830 . if (A != B)
 11-831 . {
 11-832 .    A = B + C;
 11-833 .    D = E + F;
 11-834 . }
 11-835 . 
 11-836 . A = B*C;
 11-837 . 
 11-838 . if (A <  B)
 11-839 . {
 11-840 .    A = B + C;
 11-841 .    D = E + F;
 11-842 . }
 11-843 . 
 11-844 . 
 11-845 . if (A le B)
 11-846 . {
 11-847 .    A = B + C;
 11-848 .    D = E + F;
 11-849 . }
 11-850 . 
 11-851 . 
 11-852 . if (A ge B)
 11-853 . {
 11-854 .    A = B + C;
 11-855 .    D = E + F;
 11-856 . }
 11-857 . 
 11-858 . 
 11-859 . if (A >  B)
 11-860 . {
 11-861 .    A = B + C;
 11-862 .    D = E + F;
 11-863 . }
 11-864 . 
 11-865 . A = B*C;
 11-866 . A = 0x0003;
 11-867 . A = B*C;
 11-868 . 
 11-869 . if (A ne B)
 11-870 . {
 11-871 .    A = B + C;
 11-872 .    D = E + F;
 11-873 . }
 11-874 . 
 11-875 . // TBD - what do I do now
 11-876 . 
 11-877 . if (A != B)
 11-878 . {
 11-879 .    A = B + C;
 11-880 .    D = E + F;
 11-881 . }
 11-882 . 
 11-883 . A = B-C;
 11-884 . A = B*C;
 11-885 . // max LOC 51
 11-886 . 
 11-887 . }
 11-888 . 
 11-889 . 
 11-890 . /*
 11-891 . -----------------------------------------------------------------------------
 11-892 . --| NAME:   dlp.2.6
 11-893 . --|
 11-894 . --| ABSTRACT:
 11-895 . --|   This function does dlp stuff.
 11-896 . --|
 11-897 . --| RETURNS:
 11-898 . --|   NONE.
 11-899 . --|
 11-900 . ----------------------------------------------------------------------------
 11-901 . */
 11-902 . static void dlp.2.6(void)
 11-903 . {
 11-904 . 
 11-905 . if (A >  B)
 11-906 . {
 11-907 .    A = B + C;
 11-908 .    D = E + F;
 11-909 . }
 11-910 . 
 11-911 . 
 11-912 . if (A eq B)
 11-913 . {
 11-914 .    A = B + C;
 11-915 .    D = E + F;
 11-916 . }
 11-917 . 
 11-918 . A = B-C;
 11-919 . A = B*C;
 11-920 . A = B+C;
 11-921 . A = B/C;
 11-922 . 
 11-923 . if (A le B)
 11-924 . {
 11-925 .    A = B + C;
 11-926 .    D = E + F;
 11-927 . }
 11-928 . 
 11-929 . A = B*C;
 11-930 . 
 11-931 . if (A == B)
 11-932 . {
 11-933 .    A = B + C;
 11-934 .    D = E + F;
 11-935 . }
 11-936 . 
 11-937 . A = B-C;
 11-938 . A = B/C;
 11-939 . 
 11-940 . switch (dlp stuff)
 11-941 . {
 11-942 .    case one:
 11-943 .    {
 11-944 .       run_this; 
 11-945 .       break;
 11-946 .    }
 11-947 .    case two:
 11-948 .    {
 11-949 .       run_this;
 11-950 .       break;
 11-951 .    }
 11-952 .    default:
 11-953 .    {
 11-954 .        SwError;
 11-955 .    }
 11-956 . }
 11-957 . 
 11-958 . A = B*C;
 11-959 . /* LE SV TOC-1217 this is a dlp-02.6.14 req to validate*/
 11-960 . A = B-C;
 11-961 . 
 11-962 . if (A != B)
 11-963 . {
 11-964 .    A = B + C;
 11-965 .    D = E + F;
 11-966 . }
 11-967 . 
 11-968 . A = B+C;
 11-969 . A = B-C;
 11-970 . 
 11-971 . if (A gt B)
 11-972 . {
 11-973 .    A = B + C;
 11-974 .    D = E + F;
 11-975 . }
 11-976 . 
 11-977 . 
 11-978 . if (A == B)
 11-979 . {
 11-980 .    A = B + C;
 11-981 .    D = E + F;
 11-982 . }
 11-983 . 
 11-984 . 
 11-985 . if (A lt B)
 11-986 . {
 11-987 .    A = B + C;
 11-988 .    D = E + F;
 11-989 . }
 11-990 . 
 11-991 . A = B*C;
 11-992 . A = B+C;
 11-993 . /* LE SV TOC-1218 this is a dlp-02.6.23 req to recover*/
 11-994 . 
 11-995 . if (A gt B)
 11-996 . {
 11-997 .    A = B + C;
 11-998 .    D = E + F;
 11-999 . }
 11-1000 . 
 11-1001 . 
 11-1002 . if (A >  B)
 11-1003 . {
 11-1004 .    A = B + C;
 11-1005 .    D = E + F;
 11-1006 . }
 11-1007 . 
 11-1008 . 
 11-1009 . if (A == B)
 11-1010 . {
 11-1011 .    A = B + C;
 11-1012 .    D = E + F;
 11-1013 . }
 11-1014 . 
 11-1015 . A = B/C;
 11-1016 . A = 0x0002;
 11-1017 . 
 11-1018 . if (A eq B)
 11-1019 . {
 11-1020 .    A = B + C;
 11-1021 .    D = E + F;
 11-1022 . }
 11-1023 . 
 11-1024 . A = B*C;
 11-1025 . A = B/C;
 11-1026 . A = B-C;
 11-1027 . A = B-C;
 11-1028 . A = B/C;
 11-1029 . A = B-C;
 11-1030 . A = B-C;
 11-1031 . 
 11-1032 . if (A < = B)
 11-1033 . {
 11-1034 .    A = B + C;
 11-1035 .    D = E + F;
 11-1036 . }
 11-1037 . 
 11-1038 . 
 11-1039 . switch (dlp stuff)
 11-1040 . {
 11-1041 .    case one:
 11-1042 .    {
 11-1043 .       run_this; 
 11-1044 .       break;
 11-1045 .    }
 11-1046 .    case two:
 11-1047 .    {
 11-1048 .       run_this;
 11-1049 .       break;
 11-1050 .    }
 11-1051 .    default:
 11-1052 .    {
 11-1053 .        SwError;
 11-1054 .    }
 11-1055 . }
 11-1056 . 
 11-1057 . 
 11-1058 . if (A > = B)
 11-1059 . {
 11-1060 .    A = B + C;
 11-1061 .    D = E + F;
 11-1062 . }
 11-1063 . 
 11-1064 . send_buffer = (U16 *) malloc(size+1);
 11-1065 . A = B+C;
 11-1066 . A = B-C;
 11-1067 . A = B-C;
 11-1068 . A = B/C;
 11-1069 . A = B-C;
 11-1070 . /* LE SV TOC-1219 this is a dlp-02.6.43 req to check unix*/
 11-1071 . A = B+C;
 11-1072 . 
 11-1073 . if (A lt B)
 11-1074 . {
 11-1075 .    A = B + C;
 11-1076 .    D = E + F;
 11-1077 . }
 11-1078 . 
 11-1079 . 
 11-1080 . switch (dlp stuff)
 11-1081 . {
 11-1082 .    case one:
 11-1083 .    {
 11-1084 .       run_this; 
 11-1085 .       break;
 11-1086 .    }
 11-1087 .    case two:
 11-1088 .    {
 11-1089 .       run_this;
 11-1090 .       break;
 11-1091 .    }
 11-1092 .    default:
 11-1093 .    {
 11-1094 .        SwError;
 11-1095 .    }
 11-1096 . }
 11-1097 . 
 11-1098 . A = B-C;
 11-1099 . 
 11-1100 . if (A lt B)
 11-1101 . {
 11-1102 .    A = B + C;
 11-1103 .    D = E + F;
 11-1104 . }
 11-1105 . 
 11-1106 . A = B+C;
 11-1107 . A = B*C;
 11-1108 . 
 11-1109 . if (A == B)
 11-1110 . {
 11-1111 .    A = B + C;
 11-1112 .    D = E + F;
 11-1113 . }
 11-1114 . 
 11-1115 . 
 11-1116 . if (A le B)
 11-1117 . {
 11-1118 .    A = B + C;
 11-1119 .    D = E + F;
 11-1120 . }
 11-1121 . 
 11-1122 . A = B*C;
 11-1123 . A = B*C;
 11-1124 . A = B+C;
 11-1125 . A = B*C;
 11-1126 . A = B*C;
 11-1127 . 
 11-1128 . switch (dlp stuff)
 11-1129 . {
 11-1130 .    case:
 11-1131 .    case:
 11-1132 .    // stacked case statements but only if there is a new line in between
 11-1133 . 
 11-1134 .    case:
 11-1135 .    case:
 11-1136 .    case:
 11-1137 .    {
 11-1138 .       run_this;
 11-1139 .       break;
 11-1140 .    }
 11-1141 .    default:
 11-1142 .    {
 11-1143 .       halt;
 11-1144 .    }
 11-1145 . }
 11-1146 . 
 11-1147 . A = B*C;
 11-1148 . 
 11-1149 . switch (dlp stuff)
 11-1150 . {
 11-1151 .    case one:
 11-1152 .    {
 11-1153 .       run_this; 
 11-1154 .       break;
 11-1155 .    }
 11-1156 .    case two:
 11-1157 .    {
 11-1158 .       run_this;
 11-1159 .       break;
 11-1160 .    }
 11-1161 .    default:
 11-1162 .    {
 11-1163 .        SwError;
 11-1164 .    }
 11-1165 . }
 11-1166 . 
 11-1167 . A = 0x0002;
 11-1168 . 
 11-1169 . if (A gt B)
 11-1170 . {
 11-1171 .    A = B + C;
 11-1172 .    D = E + F;
 11-1173 . }
 11-1174 . 
 11-1175 . A = B/C;
 11-1176 . // max LOC 60
 11-1177 . 
 11-1178 . }
 11-1179 . 

11 11 Result: result/source/ft-app/ft-app-B1.1/dlp/dlp-02.c


12 12 Source: source/ft-app/ft-app-B1.1/dlp/dlp-03.c
 12-0 . /*
 12-1 . ----------------------------------------------------------------------------
 12-2 . --| BEGIN PROLOGUE
 12-3 . --|
 12-4 . --| CLASSIFICATION: UNCLASSIFIED
 12-5 . --|
 12-6 . --| FILE NAME:      dlp-03.c
 12-7 . --|
 12-8 . --| ABSTRACT:
 12-9 . --|   This file contains the 7 functions that do file dlp stuff.
 12-10 . --|
 12-11 . --| HISTORY:
 12-12 . --|   CCCQ_NAME:
 12-13 . --|   CCCQ_VER: 
 12-14 . --|
 12-15 . --| END PROLOGUE
 12-16 . ----------------------------------------------------------------------------
 12-17 . */
 12-18 . 
 12-19 . #define B;
 12-20 . double C;
 12-21 . #include B;
 12-22 . #define C;
 12-23 . #include B;
 12-24 . 
 12-25 . 
 12-26 . 
 12-27 . /*
 12-28 . -----------------------------------------------------------------------------
 12-29 . --| NAME:   dlp.3.1
 12-30 . --|
 12-31 . --| ABSTRACT:
 12-32 . --|   This function does dlp stuff.
 12-33 . --|
 12-34 . --| RETURNS:
 12-35 . --|   NONE.
 12-36 . --|
 12-37 . ----------------------------------------------------------------------------
 12-38 . */
 12-39 . static void dlp.3.1(void)
 12-40 . {
 12-41 . 
 12-42 . if (A ge B)
 12-43 . {
 12-44 .    A = B + C;
 12-45 .    D = E + F;
 12-46 . }
 12-47 . 
 12-48 . A = B-C;
 12-49 . // TBD - what do I do now
 12-50 . A = B-C;
 12-51 . A = B-C;
 12-52 . A = B+C;
 12-53 . A = B/C;
 12-54 . A = B+C;
 12-55 . A = B/C;
 12-56 . 
 12-57 . if (A != B)
 12-58 . {
 12-59 .    A = B + C;
 12-60 .    D = E + F;
 12-61 . }
 12-62 . 
 12-63 . 
 12-64 . if (A < = B)
 12-65 . {
 12-66 .    A = B + C;
 12-67 .    D = E + F;
 12-68 . }
 12-69 . 
 12-70 . A = B-C;
 12-71 . 
 12-72 . if (A gt B)
 12-73 . {
 12-74 .    A = B + C;
 12-75 .    D = E + F;
 12-76 . }
 12-77 . 
 12-78 . A = B+C;
 12-79 . A = B+C;
 12-80 . A = B*C;
 12-81 . 
 12-82 . if (A >  B)
 12-83 . {
 12-84 .    A = B + C;
 12-85 .    D = E + F;
 12-86 . }
 12-87 . 
 12-88 . A = B*C;
 12-89 . A = B+C;
 12-90 . A = B-C;
 12-91 . 
 12-92 . if (A ge B)
 12-93 . {
 12-94 .    A = B + C;
 12-95 .    D = E + F;
 12-96 . }
 12-97 . 
 12-98 . /* LE SV TOC-1220 this is a dlp-03.1.21 req to process*/
 12-99 . A = B/C;
 12-100 . A = B-C;
 12-101 . 
 12-102 . switch (dlp stuff)
 12-103 . {
 12-104 .    case one:
 12-105 .    {
 12-106 .       run_this; 
 12-107 .       break;
 12-108 .    }
 12-109 .    case two:
 12-110 .    {
 12-111 .       run_this;
 12-112 .       break;
 12-113 .    }
 12-114 .    default:
 12-115 .    {
 12-116 .        SwError;
 12-117 .    }
 12-118 . }
 12-119 . 
 12-120 . /* LE SV TOC-1221 this is a dlp-03.1.24 req to transform*/
 12-121 . 
 12-122 . if (A > = B)
 12-123 . {
 12-124 .    A = B + C;
 12-125 .    D = E + F;
 12-126 . }
 12-127 . 
 12-128 . A = B+C;
 12-129 . A = (long)B + C;
 12-130 . A = B+C;
 12-131 . A = 0x0004;
 12-132 . A = B/C;
 12-133 . A = B/C;
 12-134 . A = B+C;
 12-135 . 
 12-136 . if (A == B)
 12-137 . {
 12-138 .    A = B + C;
 12-139 .    D = E + F;
 12-140 . }
 12-141 . 
 12-142 . A = B*C;
 12-143 . 
 12-144 . if (A eq B)
 12-145 . {
 12-146 .    A = B + C;
 12-147 .    D = E + F;
 12-148 . }
 12-149 . 
 12-150 . /* LE SV TOC-1222 this is a dlp-03.1.33 req to compare*/
 12-151 . A = B-C;
 12-152 . A = B/C;
 12-153 . A = B+C;
 12-154 . A = (long)B + C;
 12-155 . 
 12-156 . if (A gt B)
 12-157 . {
 12-158 .    A = B + C;
 12-159 .    D = E + F;
 12-160 . }
 12-161 . 
 12-162 . A = B/C;
 12-163 . 
 12-164 . if (A < = B)
 12-165 . {
 12-166 .    A = B + C;
 12-167 .    D = E + F;
 12-168 . }
 12-169 . 
 12-170 . // max LOC 38
 12-171 . 
 12-172 . }
 12-173 . 
 12-174 . 
 12-175 . /*
 12-176 . -----------------------------------------------------------------------------
 12-177 . --| NAME:   dlp.3.2
 12-178 . --|
 12-179 . --| ABSTRACT:
 12-180 . --|   This function does dlp stuff.
 12-181 . --|
 12-182 . --| RETURNS:
 12-183 . --|   NONE.
 12-184 . --|
 12-185 . ----------------------------------------------------------------------------
 12-186 . */
 12-187 . static void dlp.3.2(void)
 12-188 . {
 12-189 . A = B/C;
 12-190 . /* LE SV TOC-1223 this is a dlp-03.2.2 req to compare*/
 12-191 . 
 12-192 . if (A >  B)
 12-193 . {
 12-194 .    A = B + C;
 12-195 .    D = E + F;
 12-196 . }
 12-197 . 
 12-198 . A = B+C;
 12-199 . A = B/C;
 12-200 . A = B*C;
 12-201 . A = B-C;
 12-202 . 
 12-203 . if (A != B)
 12-204 . {
 12-205 .    A = B + C;
 12-206 .    D = E + F;
 12-207 . }
 12-208 . 
 12-209 . A = B*C;
 12-210 . A = B-C;
 12-211 . A = 0x0004;
 12-212 . A = B+C;
 12-213 . A = B+C;
 12-214 . A = B*C;
 12-215 . A = B*C;
 12-216 . // ??? go see ws
 12-217 . 
 12-218 . if (A > = B)
 12-219 . {
 12-220 .    A = B + C;
 12-221 .    D = E + F;
 12-222 . }
 12-223 . 
 12-224 . A = B+C;
 12-225 . A = B/C;
 12-226 . A = 0x0004;
 12-227 . A = B*C;
 12-228 . send_buffer = (U16 *) malloc(size+1);
 12-229 . A = B*C;
 12-230 . /* LE SV TOC-1224 this is a dlp-03.2.19 req to update*/
 12-231 . A = B+C;
 12-232 . 
 12-233 . #ifdef LAZY
 12-234 .    // this is not nice
 12-235 .    A = B + C;
 12-236 .    A = B + C;
 12-237 . #endif
 12-238 . 
 12-239 . A = B-C;
 12-240 . A = B/C;
 12-241 . A = B+C;
 12-242 . 
 12-243 . if (A < = B)
 12-244 . {
 12-245 .    A = B + C;
 12-246 .    D = E + F;
 12-247 . }
 12-248 . 
 12-249 . A = B+C;
 12-250 . /* LE SV TOC-1225 this is a dlp-03.2.25 req to increment*/
 12-251 . 
 12-252 . if (A le B)
 12-253 . {
 12-254 .    A = B + C;
 12-255 .    D = E + F;
 12-256 . }
 12-257 . 
 12-258 . A = B/C;
 12-259 . A = B+C;
 12-260 . A = B/C;
 12-261 . A = B/C;
 12-262 . 
 12-263 . if (A ne B)
 12-264 . {
 12-265 .    A = B + C;
 12-266 .    D = E + F;
 12-267 . }
 12-268 . 
 12-269 . 
 12-270 . if (A eq B)
 12-271 . {
 12-272 .    A = B + C;
 12-273 .    D = E + F;
 12-274 . }
 12-275 . 
 12-276 . A = B+C;
 12-277 . 
 12-278 . if (A lt B)
 12-279 . {
 12-280 .    A = B + C;
 12-281 .    D = E + F;
 12-282 . }
 12-283 . 
 12-284 . A = B+C;
 12-285 . A = B*C;
 12-286 . A = B-C;
 12-287 . A = B/C;
 12-288 . 
 12-289 . if (A <  B)
 12-290 . {
 12-291 .    A = B + C;
 12-292 .    D = E + F;
 12-293 . }
 12-294 . 
 12-295 . /* LE SV TOC-1226 this is a dlp-03.2.39 req to store*/
 12-296 . A = B*C;
 12-297 . A = B+C;
 12-298 . A = B*C;
 12-299 . // TBD - what do I do now
 12-300 . A = B-C;
 12-301 . 
 12-302 . if (A ge B)
 12-303 . {
 12-304 .    A = B + C;
 12-305 .    D = E + F;
 12-306 . }
 12-307 . 
 12-308 . A = 0x0007;
 12-309 . A = B/C;
 12-310 . A = B*C;
 12-311 . // max LOC 45
 12-312 . 
 12-313 . }
 12-314 . 
 12-315 . 
 12-316 . /*
 12-317 . -----------------------------------------------------------------------------
 12-318 . --| NAME:   dlp.3.3
 12-319 . --|
 12-320 . --| ABSTRACT:
 12-321 . --|   This function does dlp stuff.
 12-322 . --|
 12-323 . --| RETURNS:
 12-324 . --|   NONE.
 12-325 . --|
 12-326 . ----------------------------------------------------------------------------
 12-327 . */
 12-328 . static void dlp.3.3(void)
 12-329 . {
 12-330 . A = B*C;
 12-331 . A = B+C;
 12-332 . 
 12-333 . if (A != B)
 12-334 . {
 12-335 .    A = B + C;
 12-336 .    D = E + F;
 12-337 . }
 12-338 . 
 12-339 . A = B/C;
 12-340 . 
 12-341 . if (A lt B)
 12-342 . {
 12-343 .    A = B + C;
 12-344 .    D = E + F;
 12-345 . }
 12-346 . 
 12-347 . A = B*C;
 12-348 . A = B*C;
 12-349 . A = B+C;
 12-350 . // max LOC 8
 12-351 . 
 12-352 . }
 12-353 . 
 12-354 . 
 12-355 . /*
 12-356 . -----------------------------------------------------------------------------
 12-357 . --| NAME:   dlp.3.4
 12-358 . --|
 12-359 . --| ABSTRACT:
 12-360 . --|   This function does dlp stuff.
 12-361 . --|
 12-362 . --| RETURNS:
 12-363 . --|   NONE.
 12-364 . --|
 12-365 . ----------------------------------------------------------------------------
 12-366 . */
 12-367 . static void dlp.3.4(void)
 12-368 . {
 12-369 . 
 12-370 . /* dead_block = C * D; 
 12-371 . dead_block = E * F; */
 12-372 . 
 12-373 . A = B-C;
 12-374 . A = B+C;
 12-375 . A = B*C;
 12-376 . // (P) this is really improtant
 12-377 . A = B/C;
 12-378 . /* LE SV TOC-1227 this is a dlp-03.4.5 req to set RTC*/
 12-379 . A = B+C;
 12-380 . A = B+C;
 12-381 . 
 12-382 . if (A != B)
 12-383 . {
 12-384 .    A = B + C;
 12-385 .    D = E + F;
 12-386 . }
 12-387 . 
 12-388 . 
 12-389 . if (A lt B)
 12-390 . {
 12-391 .    A = B + C;
 12-392 .    D = E + F;
 12-393 . }
 12-394 . 
 12-395 . 
 12-396 . switch (dlp stuff)
 12-397 . {
 12-398 .    case one:
 12-399 .    {
 12-400 .       run_this; 
 12-401 .       break;
 12-402 .    }
 12-403 .    case two:
 12-404 .    {
 12-405 .       run_this;
 12-406 .       break;
 12-407 .    }
 12-408 .    default:
 12-409 .    {
 12-410 .        SwError;
 12-411 .    }
 12-412 . }
 12-413 . 
 12-414 . A = B/C;
 12-415 . A = B*C;
 12-416 . A = B-C;
 12-417 . A = B/C;
 12-418 . A = B*C;
 12-419 . A = B-C;
 12-420 . A = B/C;
 12-421 . A = B*C;
 12-422 . 
 12-423 . if (A gt B)
 12-424 . {
 12-425 .    A = B + C;
 12-426 .    D = E + F;
 12-427 . }
 12-428 . 
 12-429 . A = B/C;
 12-430 . A = B-C;
 12-431 . 
 12-432 . if (A < = B)
 12-433 . {
 12-434 .    A = B + C;
 12-435 .    D = E + F;
 12-436 . }
 12-437 . 
 12-438 . /* LE SV TOC-1228 this is a dlp-03.4.22 req to fail*/
 12-439 . A = B/C;
 12-440 . A = B*C;
 12-441 . A = B-C;
 12-442 . // max LOC 24
 12-443 . 
 12-444 . }
 12-445 . 
 12-446 . 
 12-447 . /*
 12-448 . -----------------------------------------------------------------------------
 12-449 . --| NAME:   dlp.3.5
 12-450 . --|
 12-451 . --| ABSTRACT:
 12-452 . --|   This function does dlp stuff.
 12-453 . --|
 12-454 . --| RETURNS:
 12-455 . --|   NONE.
 12-456 . --|
 12-457 . ----------------------------------------------------------------------------
 12-458 . */
 12-459 . static void dlp.3.5(void)
 12-460 . {
 12-461 . 
 12-462 . if (A gt B)
 12-463 . {
 12-464 .    A = B + C;
 12-465 .    D = E + F;
 12-466 . }
 12-467 . 
 12-468 . 
 12-469 . if (A != B)
 12-470 . {
 12-471 .    A = B + C;
 12-472 .    D = E + F;
 12-473 . }
 12-474 . 
 12-475 . A = B+C;
 12-476 . 
 12-477 . if (A != B)
 12-478 . {
 12-479 .    A = B + C;
 12-480 .    D = E + F;
 12-481 . }
 12-482 . 
 12-483 . A = B/C;
 12-484 . A = B/C;
 12-485 . A = B-C;
 12-486 . 
 12-487 . if (A <  B)
 12-488 . {
 12-489 .    A = B + C;
 12-490 .    D = E + F;
 12-491 . }
 12-492 . 
 12-493 . A = B+C;
 12-494 . A = B-C;
 12-495 . A = B/C;
 12-496 . A = B-C;
 12-497 . 
 12-498 . if (A > = B)
 12-499 . {
 12-500 .    A = B + C;
 12-501 .    D = E + F;
 12-502 . }
 12-503 . 
 12-504 . /* LE SV TOC-1229 this is a dlp-03.5.14 req to update*/
 12-505 . 
 12-506 . if (A ge B)
 12-507 . {
 12-508 .    A = B + C;
 12-509 .    D = E + F;
 12-510 . }
 12-511 . 
 12-512 . 
 12-513 . if (A gt B)
 12-514 . {
 12-515 .    A = B + C;
 12-516 .    D = E + F;
 12-517 . }
 12-518 . 
 12-519 . A = B*C;
 12-520 . 
 12-521 . /* dead_code = B + C; 
 12-522 . dead_code = D + E; 
 12-523 . dead_code = F + G; */
 12-524 . 
 12-525 . A = B-C;
 12-526 . 
 12-527 . if (A gt B)
 12-528 . {
 12-529 .    A = B + C;
 12-530 .    D = E + F;
 12-531 . }
 12-532 . 
 12-533 . 
 12-534 . switch (dlp stuff)
 12-535 . {
 12-536 .    case one:
 12-537 .    {
 12-538 .       run_this; 
 12-539 .       // missing break
 12-540 .    }
 12-541 .    case two:
 12-542 .    {
 12-543 .       run_this;
 12-544 .       break;
 12-545 .    }
 12-546 .    default:
 12-547 .    {
 12-548 .       SwError;
 12-549 .    }
 12-550 . }
 12-551 . 
 12-552 . A = B+C;
 12-553 . A = B/C;
 12-554 . 
 12-555 . if (A ne B)
 12-556 . {
 12-557 .    A = B + C;
 12-558 .    D = E + F;
 12-559 . }
 12-560 . 
 12-561 . /* LE SV TOC-1230 this is a dlp-03.5.22 req to verify*/
 12-562 . 
 12-563 . if (A >  B)
 12-564 . {
 12-565 .    A = B + C;
 12-566 .    D = E + F;
 12-567 . }
 12-568 . 
 12-569 . /* LE SV TOC-1231 this is a dlp-03.5.23 req to detect error*/
 12-570 . A = B+C;
 12-571 . 
 12-572 . if (A ge B)
 12-573 . {
 12-574 .    A = B + C;
 12-575 .    D = E + F;
 12-576 . }
 12-577 . 
 12-578 . 
 12-579 . if (A le B)
 12-580 . {
 12-581 .    A = B + C;
 12-582 .    D = E + F;
 12-583 . }
 12-584 . 
 12-585 . send_buffer = (U16 *) malloc(size+1);
 12-586 . A = B/C;
 12-587 . A = B/C;
 12-588 . 
 12-589 . if (A > = B)
 12-590 . {
 12-591 .    A = B + C;
 12-592 .    D = E + F;
 12-593 . }
 12-594 . 
 12-595 . A = B-C;
 12-596 . A = B/C;
 12-597 . /* LE SV TOC-1232 this is a dlp-03.5.31 req to halt*/
 12-598 . 
 12-599 . if (A le B)
 12-600 . {
 12-601 .    A = B + C;
 12-602 .    D = E + F;
 12-603 . }
 12-604 . 
 12-605 . A = B-C;
 12-606 . A = B*C;
 12-607 . 
 12-608 . if (A >  B)
 12-609 . {
 12-610 .    A = B + C;
 12-611 .    D = E + F;
 12-612 . }
 12-613 . 
 12-614 . A = B-C;
 12-615 . A = B*C;
 12-616 . 
 12-617 . if (A >  B)
 12-618 . {
 12-619 .    A = B + C;
 12-620 .    D = E + F;
 12-621 . }
 12-622 . 
 12-623 . A = B/C;
 12-624 . 
 12-625 . if (A ne B)
 12-626 . {
 12-627 .    A = B + C;
 12-628 .    D = E + F;
 12-629 . }
 12-630 . 
 12-631 . A = B*C;
 12-632 . A = B*C;
 12-633 . A = B/C;
 12-634 . FreePtr = HmiStringPtr;
 12-635 . A = B+C;
 12-636 . 
 12-637 . if (A gt B)
 12-638 . {
 12-639 .    A = B + C;
 12-640 .    D = E + F;
 12-641 . }
 12-642 . 
 12-643 . 
 12-644 . if (A < = B)
 12-645 . {
 12-646 .    A = B + C;
 12-647 .    D = E + F;
 12-648 . }
 12-649 . 
 12-650 . A = B-C;
 12-651 . A = B+C;
 12-652 . 
 12-653 . if (A ge B)
 12-654 . {
 12-655 .    A = B + C;
 12-656 .    D = E + F;
 12-657 . }
 12-658 . 
 12-659 . A = B+C;
 12-660 . A = B+C;
 12-661 . 
 12-662 . if (veg)
 12-663 .    // missing curly brace
 12-664 .    variable = orange;
 12-665 . 
 12-666 . 
 12-667 . if (A gt B)
 12-668 . {
 12-669 .    A = B + C;
 12-670 .    D = E + F;
 12-671 . }
 12-672 . 
 12-673 . A = B*C;
 12-674 . A = B+C;
 12-675 . A = B+C;
 12-676 . A = B-C;
 12-677 . A = B/C;
 12-678 . A = B*C;
 12-679 . A = B/C;
 12-680 . 
 12-681 . if (A != B)
 12-682 . {
 12-683 .    A = B + C;
 12-684 .    D = E + F;
 12-685 . }
 12-686 . 
 12-687 . 
 12-688 . if (A > = B)
 12-689 . {
 12-690 .    A = B + C;
 12-691 .    D = E + F;
 12-692 . }
 12-693 . 
 12-694 . A = B*C;
 12-695 . A = B+C;
 12-696 . 
 12-697 . if (A le B)
 12-698 . {
 12-699 .    A = B + C;
 12-700 .    D = E + F;
 12-701 . }
 12-702 . 
 12-703 . A = B/C;
 12-704 . A = B*C;
 12-705 . A = B+C;
 12-706 . 
 12-707 . if (A ne B)
 12-708 . {
 12-709 .    A = B + C;
 12-710 .    D = E + F;
 12-711 . }
 12-712 . 
 12-713 . A = B/C;
 12-714 . A = B*C;
 12-715 . 
 12-716 . #ifdef LAZY
 12-717 .    // this is not nice
 12-718 .    A = B + C;
 12-719 .    A = B + C;
 12-720 . #endif
 12-721 . 
 12-722 . 
 12-723 . if (A <  B)
 12-724 . {
 12-725 .    A = B + C;
 12-726 .    D = E + F;
 12-727 . }
 12-728 . 
 12-729 . 
 12-730 . if (A ge B)
 12-731 . {
 12-732 .    A = B + C;
 12-733 .    D = E + F;
 12-734 . }
 12-735 . 
 12-736 . 
 12-737 . if (A gt B)
 12-738 . {
 12-739 .    A = B + C;
 12-740 .    D = E + F;
 12-741 . }
 12-742 . 
 12-743 . A = B*C;
 12-744 . A = B-C;
 12-745 . A = B/C;
 12-746 . A = B-C;
 12-747 . /* LE SV TOC-1233 this is a dlp-03.5.77 req to halt*/
 12-748 . A = B+C;
 12-749 . // max LOC 77
 12-750 . 
 12-751 . }
 12-752 . 
 12-753 . 
 12-754 . /*
 12-755 . -----------------------------------------------------------------------------
 12-756 . --| NAME:   dlp.3.6
 12-757 . --|
 12-758 . --| ABSTRACT:
 12-759 . --|   This function does dlp stuff.
 12-760 . --|
 12-761 . --| RETURNS:
 12-762 . --|   NONE.
 12-763 . --|
 12-764 . ----------------------------------------------------------------------------
 12-765 . */
 12-766 . static void dlp.3.6(void)
 12-767 . {
 12-768 . A = B/C;
 12-769 . 
 12-770 . if (A != B)
 12-771 . {
 12-772 .    A = B + C;
 12-773 .    D = E + F;
 12-774 . }
 12-775 . 
 12-776 . A = B-C;
 12-777 . 
 12-778 . if (A ne B)
 12-779 . {
 12-780 .    A = B + C;
 12-781 .    D = E + F;
 12-782 . }
 12-783 . 
 12-784 . A = B*C;
 12-785 . 
 12-786 . if (A <  B)
 12-787 . {
 12-788 .    A = B + C;
 12-789 .    D = E + F;
 12-790 . }
 12-791 . 
 12-792 . A = B+C;
 12-793 . A = B+C;
 12-794 . A = B-C;
 12-795 . 
 12-796 . if (A le B)
 12-797 . {
 12-798 .    A = B + C;
 12-799 .    D = E + F;
 12-800 . }
 12-801 . 
 12-802 . A = B/C;
 12-803 . A = B*C;
 12-804 . A = B+C;
 12-805 . 
 12-806 . #ifdef LAZY
 12-807 .    // this is not nice
 12-808 .    A = B + C;
 12-809 .    A = B + C;
 12-810 . #endif
 12-811 . 
 12-812 . 
 12-813 . if (A ne B)
 12-814 . {
 12-815 .    A = B + C;
 12-816 .    D = E + F;
 12-817 . }
 12-818 . 
 12-819 . A = B/C;
 12-820 . A = B+C;
 12-821 . A = B*C;
 12-822 . A = B-C;
 12-823 . 
 12-824 . switch (dlp stuff)
 12-825 . {
 12-826 .    case one:
 12-827 .    {
 12-828 .       run_this; 
 12-829 .       break;
 12-830 .    }
 12-831 .    case two:
 12-832 .    {
 12-833 .       run_this;
 12-834 .       break;
 12-835 .    }
 12-836 .    default:
 12-837 .    {
 12-838 .        SwError;
 12-839 .    }
 12-840 . }
 12-841 . 
 12-842 . A = B*C;
 12-843 . /* LE SV TOC-1234 this is a dlp-03.6.21 req to verify*/
 12-844 . 
 12-845 . if (A <  B)
 12-846 . {
 12-847 .    A = B + C;
 12-848 .    D = E + F;
 12-849 . }
 12-850 . 
 12-851 . A = B/C;
 12-852 . A = B*C;
 12-853 . A = B/C;
 12-854 . 
 12-855 . if (A le B)
 12-856 . {
 12-857 .    A = B + C;
 12-858 .    D = E + F;
 12-859 . }
 12-860 . 
 12-861 . A = B*C;
 12-862 . A = B*C;
 12-863 . A = B*C;
 12-864 . A = B+C;
 12-865 . /* LE SV TOC-1235 this is a dlp-03.6.30 req to validate*/
 12-866 . 
 12-867 . if (A ge B)
 12-868 . {
 12-869 .    A = B + C;
 12-870 .    D = E + F;
 12-871 . }
 12-872 . 
 12-873 . 
 12-874 . if (A != B)
 12-875 . {
 12-876 .    A = B + C;
 12-877 .    D = E + F;
 12-878 . }
 12-879 . 
 12-880 . 
 12-881 . if (A lt B)
 12-882 . {
 12-883 .    A = B + C;
 12-884 .    D = E + F;
 12-885 . }
 12-886 . 
 12-887 . 
 12-888 . if (A == B)
 12-889 . {
 12-890 .    A = B + C;
 12-891 .    D = E + F;
 12-892 . }
 12-893 . 
 12-894 . A = B-C;
 12-895 . 
 12-896 . if (A < = B)
 12-897 . {
 12-898 .    A = B + C;
 12-899 .    D = E + F;
 12-900 . }
 12-901 . 
 12-902 . A = B*C;
 12-903 . A = B*C;
 12-904 . A = B*C;
 12-905 . A = B-C;
 12-906 . A = B/C;
 12-907 . A = B-C;
 12-908 . 
 12-909 . #ifdef LAZY
 12-910 .    // this is not nice
 12-911 .    A = B + C;
 12-912 .    A = B + C;
 12-913 . #endif
 12-914 . 
 12-915 . 
 12-916 . if (A <  B)
 12-917 . {
 12-918 .    A = B + C;
 12-919 .    D = E + F;
 12-920 . }
 12-921 . 
 12-922 . 
 12-923 . if (A gt B)
 12-924 . {
 12-925 .    A = B + C;
 12-926 .    D = E + F;
 12-927 . }
 12-928 . 
 12-929 . A = 0x0006;
 12-930 . 
 12-931 . if (A gt B)
 12-932 . {
 12-933 .    A = B + C;
 12-934 .    D = E + F;
 12-935 . }
 12-936 . 
 12-937 . /* LE SV TOC-1236 this is a dlp-03.6.45 req to compare*/
 12-938 . A = B/C;
 12-939 . A = B-C;
 12-940 . 
 12-941 . if (A == B)
 12-942 . {
 12-943 .    A = B + C;
 12-944 .    D = E + F;
 12-945 . }
 12-946 . 
 12-947 . A = B+C;
 12-948 . 
 12-949 . if (A le B)
 12-950 . {
 12-951 .    A = B + C;
 12-952 .    D = E + F;
 12-953 . }
 12-954 . 
 12-955 . A = B*C;
 12-956 . 
 12-957 . /*
 12-958 . dead_block = C * D; 
 12-959 . dead_block = E * F;
 12-960 . */
 12-961 . 
 12-962 . A = B/C;
 12-963 . A = B-C;
 12-964 . A = B-C;
 12-965 . A = B*C;
 12-966 . 
 12-967 . if (A lt B)
 12-968 . {
 12-969 .    A = B + C;
 12-970 .    D = E + F;
 12-971 . }
 12-972 . 
 12-973 . A = B/C;
 12-974 . A = B-C;
 12-975 . A = B*C;
 12-976 . A = B+C;
 12-977 . A = 0x0007;
 12-978 . A = B*C;
 12-979 . A = B-C;
 12-980 . A = B*C;
 12-981 . A = B-C;
 12-982 . 
 12-983 . if (A > = B)
 12-984 . {
 12-985 .    A = B + C;
 12-986 .    D = E + F;
 12-987 . }
 12-988 . 
 12-989 . A = B+C;
 12-990 . A = B-C;
 12-991 . // max LOC 66
 12-992 . 
 12-993 . }
 12-994 . 
 12-995 . 
 12-996 . /*
 12-997 . -----------------------------------------------------------------------------
 12-998 . --| NAME:   dlp.3.7
 12-999 . --|
 12-1000 . --| ABSTRACT:
 12-1001 . --|   This function does dlp stuff.
 12-1002 . --|
 12-1003 . --| RETURNS:
 12-1004 . --|   NONE.
 12-1005 . --|
 12-1006 . ----------------------------------------------------------------------------
 12-1007 . */
 12-1008 . static void dlp.3.7(void)
 12-1009 . {
 12-1010 . A = B+C;
 12-1011 . A = B/C;
 12-1012 . A = B-C;
 12-1013 . A = B+C;
 12-1014 . A = B+C;
 12-1015 . A = B+C;
 12-1016 . 
 12-1017 . switch (dlp stuff)
 12-1018 . {
 12-1019 .    case one:
 12-1020 .    {
 12-1021 .       run_this; 
 12-1022 .       break;
 12-1023 .    }
 12-1024 .    case two:
 12-1025 .    {
 12-1026 .       run_this;
 12-1027 .       break;
 12-1028 .    }
 12-1029 .    default:
 12-1030 .    {
 12-1031 .        SwError;
 12-1032 .    }
 12-1033 . }
 12-1034 . 
 12-1035 . A = B/C;
 12-1036 . A = B*C;
 12-1037 . /* dead_code = A * B; */
 12-1038 . 
 12-1039 . if (A ne B)
 12-1040 . {
 12-1041 .    A = B + C;
 12-1042 .    D = E + F;
 12-1043 . }
 12-1044 . 
 12-1045 . A = B+C;
 12-1046 . 
 12-1047 . if (A lt B)
 12-1048 . {
 12-1049 .    A = B + C;
 12-1050 .    D = E + F;
 12-1051 . }
 12-1052 . 
 12-1053 . A = B+C;
 12-1054 . A = B*C;
 12-1055 . 
 12-1056 . if (A < = B)
 12-1057 . {
 12-1058 .    A = B + C;
 12-1059 .    D = E + F;
 12-1060 . }
 12-1061 . 
 12-1062 . A = B-C;
 12-1063 . 
 12-1064 . if (A < = B)
 12-1065 . {
 12-1066 .    A = B + C;
 12-1067 .    D = E + F;
 12-1068 . }
 12-1069 . 
 12-1070 . A = B/C;
 12-1071 . FreePtr = HmiStringPtr;
 12-1072 . A = B+C;
 12-1073 . A = B*C;
 12-1074 . A = B-C;
 12-1075 . 
 12-1076 . if (A >  B)
 12-1077 . {
 12-1078 .    A = B + C;
 12-1079 .    D = E + F;
 12-1080 . }
 12-1081 . 
 12-1082 . A = B+C;
 12-1083 . A = B/C;
 12-1084 . A = B/C;
 12-1085 . A = B*C;
 12-1086 . A = B+C;
 12-1087 . 
 12-1088 . if (A le B)
 12-1089 . {
 12-1090 .    A = B + C;
 12-1091 .    D = E + F;
 12-1092 . }
 12-1093 . 
 12-1094 . 
 12-1095 . if (A < = B)
 12-1096 . {
 12-1097 .    A = B + C;
 12-1098 .    D = E + F;
 12-1099 . }
 12-1100 . 
 12-1101 . 
 12-1102 . if (A >  B)
 12-1103 . {
 12-1104 .    A = B + C;
 12-1105 .    D = E + F;
 12-1106 . }
 12-1107 . 
 12-1108 . 
 12-1109 . if (A < = B)
 12-1110 . {
 12-1111 .    A = B + C;
 12-1112 .    D = E + F;
 12-1113 . }
 12-1114 . 
 12-1115 . A = B/C;
 12-1116 . A = B+C;
 12-1117 . A = B*C;
 12-1118 . 
 12-1119 . if (A < = B)
 12-1120 . {
 12-1121 .    A = B + C;
 12-1122 .    D = E + F;
 12-1123 . }
 12-1124 . 
 12-1125 . 
 12-1126 . switch (dlp stuff)
 12-1127 . {
 12-1128 .    case one:
 12-1129 .    {
 12-1130 .       run_this; 
 12-1131 .       break;
 12-1132 .    }
 12-1133 .    case two:
 12-1134 .    {
 12-1135 .       run_this;
 12-1136 .       break;
 12-1137 .    }
 12-1138 .    default:
 12-1139 .    {
 12-1140 .        SwError;
 12-1141 .    }
 12-1142 . }
 12-1143 . 
 12-1144 . A = B/C;
 12-1145 . A = B-C;
 12-1146 . A = B*C;
 12-1147 . // max LOC 39
 12-1148 . 
 12-1149 . }
 12-1150 . 

12 12 Result: result/source/ft-app/ft-app-B1.1/dlp/dlp-03.c


13 13 Source: source/ft-app/ft-app-B1.1/dlp/dlp-04.c
 13-0 . /*
 13-1 . ----------------------------------------------------------------------------
 13-2 . --| BEGIN PROLOGUE
 13-3 . --|
 13-4 . --| CLASSIFICATION: UNCLASSIFIED
 13-5 . --|
 13-6 . --| FILE NAME:      dlp-04.c
 13-7 . --|
 13-8 . --| ABSTRACT:
 13-9 . --|   This file contains the 11 functions that do file dlp stuff.
 13-10 . --|
 13-11 . --| HISTORY:
 13-12 . --|   CCCQ_NAME:
 13-13 . --|   CCCQ_VER: 
 13-14 . --|
 13-15 . --| END PROLOGUE
 13-16 . ----------------------------------------------------------------------------
 13-17 . */
 13-18 . 
 13-19 . #include B;
 13-20 . 
 13-21 . 
 13-22 . 
 13-23 . /*
 13-24 . -----------------------------------------------------------------------------
 13-25 . --| NAME:   dlp.4.1
 13-26 . --|
 13-27 . --| ABSTRACT:
 13-28 . --|   This function does dlp stuff.
 13-29 . --|
 13-30 . --| RETURNS:
 13-31 . --|   NONE.
 13-32 . --|
 13-33 . ----------------------------------------------------------------------------
 13-34 . */
 13-35 . static void dlp.4.1(void)
 13-36 . {
 13-37 . /* LE SV TOC-1237 this is a dlp-04.1.1 req to recover*/
 13-38 . 
 13-39 . if (A eq B)
 13-40 . {
 13-41 .    A = B + C;
 13-42 .    D = E + F;
 13-43 . }
 13-44 . 
 13-45 . A = 0x0009;
 13-46 . A = B+C;
 13-47 . 
 13-48 . if (A != B)
 13-49 . {
 13-50 .    A = B + C;
 13-51 .    D = E + F;
 13-52 . }
 13-53 . 
 13-54 . A = B*C;
 13-55 . A = B-C;
 13-56 . A = B-C;
 13-57 . /* LE SV TOC-1238 this is a dlp-04.1.7 req to halt*/
 13-58 . A = B/C;
 13-59 . A = B+C;
 13-60 . A = B-C;
 13-61 . A = B+C;
 13-62 . A = B/C;
 13-63 . 
 13-64 . if (A > = B)
 13-65 . {
 13-66 .    A = B + C;
 13-67 .    D = E + F;
 13-68 . }
 13-69 . 
 13-70 . // max LOC 12
 13-71 . 
 13-72 . }
 13-73 . 
 13-74 . 
 13-75 . /*
 13-76 . -----------------------------------------------------------------------------
 13-77 . --| NAME:   dlp.4.2
 13-78 . --|
 13-79 . --| ABSTRACT:
 13-80 . --|   This function does dlp stuff.
 13-81 . --|
 13-82 . --| RETURNS:
 13-83 . --|   NONE.
 13-84 . --|
 13-85 . ----------------------------------------------------------------------------
 13-86 . */
 13-87 . static void dlp.4.2(void)
 13-88 . {
 13-89 . 
 13-90 . if (A >  B)
 13-91 . {
 13-92 .    A = B + C;
 13-93 .    D = E + F;
 13-94 . }
 13-95 . 
 13-96 . A = B+C;
 13-97 . A = B-C;
 13-98 . 
 13-99 . if (A == B)
 13-100 . {
 13-101 .    A = B + C;
 13-102 .    D = E + F;
 13-103 . }
 13-104 . 
 13-105 . A = B-C;
 13-106 . 
 13-107 . if (A gt B)
 13-108 . {
 13-109 .    A = B + C;
 13-110 .    D = E + F;
 13-111 . }
 13-112 . 
 13-113 . /* LE SV TOC-1239 this is a dlp-04.2.7 req to recover*/
 13-114 . A = B/C;
 13-115 . A = B-C;
 13-116 . A = B-C;
 13-117 . 
 13-118 . if (A <  B)
 13-119 . {
 13-120 .    A = B + C;
 13-121 .    D = E + F;
 13-122 . }
 13-123 . 
 13-124 . A = B/C;
 13-125 . 
 13-126 . if (A != B)
 13-127 . {
 13-128 .    A = B + C;
 13-129 .    D = E + F;
 13-130 . }
 13-131 . 
 13-132 . A = B*C;
 13-133 . A = B+C;
 13-134 . A = B-C;
 13-135 . A = 0x0007;
 13-136 . FreePtr = HmiStringPtr;
 13-137 . A = B-C;
 13-138 . A = B*C;
 13-139 . A = B*C;
 13-140 . A = B*C;
 13-141 . A = B/C;
 13-142 . 
 13-143 . if (A >  B)
 13-144 . {
 13-145 .    A = B + C;
 13-146 .    D = E + F;
 13-147 . }
 13-148 . 
 13-149 . A = B/C;
 13-150 . A = B+C;
 13-151 . A = B*C;
 13-152 . A = B*C;
 13-153 . A = B*C;
 13-154 . 
 13-155 . if (A < = B)
 13-156 . {
 13-157 .    A = B + C;
 13-158 .    D = E + F;
 13-159 . }
 13-160 . 
 13-161 . 
 13-162 . if (A lt B)
 13-163 . {
 13-164 .    A = B + C;
 13-165 .    D = E + F;
 13-166 . }
 13-167 . 
 13-168 . 
 13-169 . if (A eq B)
 13-170 . {
 13-171 .    A = B + C;
 13-172 .    D = E + F;
 13-173 . }
 13-174 . 
 13-175 . A = B-C;
 13-176 . A = B*C;
 13-177 . A = B*C;
 13-178 . 
 13-179 . if (A >  B)
 13-180 . {
 13-181 .    A = B + C;
 13-182 .    D = E + F;
 13-183 . }
 13-184 . 
 13-185 . A = B*C;
 13-186 . A = B/C;
 13-187 . A = B/C;
 13-188 . A = B-C;
 13-189 . A = B*C;
 13-190 . A = B/C;
 13-191 . A = B/C;
 13-192 . A = B-C;
 13-193 . 
 13-194 . if (A == B)
 13-195 . {
 13-196 .    A = B + C;
 13-197 .    D = E + F;
 13-198 . }
 13-199 . 
 13-200 . A = B-C;
 13-201 . 
 13-202 . if (A == B)
 13-203 . {
 13-204 .    A = B + C;
 13-205 .    D = E + F;
 13-206 . }
 13-207 . 
 13-208 . A = B/C;
 13-209 . A = B+C;
 13-210 . A = B*C;
 13-211 . A = B+C;
 13-212 . 
 13-213 . if (A >  B)
 13-214 . {
 13-215 .    A = B + C;
 13-216 .    D = E + F;
 13-217 . }
 13-218 . 
 13-219 . A = B*C;
 13-220 . A = B+C;
 13-221 . A = B*C;
 13-222 . 
 13-223 . if (A gt B)
 13-224 . {
 13-225 .    A = B + C;
 13-226 .    D = E + F;
 13-227 . }
 13-228 . 
 13-229 . A = B+C;
 13-230 . A = B*C;
 13-231 . A = B*C;
 13-232 . /* LE SV TOC-1240 this is a dlp-04.2.57 req to transform*/
 13-233 . 
 13-234 . if (A > = B)
 13-235 . {
 13-236 .    A = B + C;
 13-237 .    D = E + F;
 13-238 . }
 13-239 . 
 13-240 . A = B+C;
 13-241 . A = B-C;
 13-242 . A = B+C;
 13-243 . 
 13-244 . if (A ne B)
 13-245 . {
 13-246 .    A = B + C;
 13-247 .    D = E + F;
 13-248 . }
 13-249 . 
 13-250 . A = B*C;
 13-251 . /* dead_code = A * B; */
 13-252 . 
 13-253 . if (A < = B)
 13-254 . {
 13-255 .    A = B + C;
 13-256 .    D = E + F;
 13-257 . }
 13-258 . 
 13-259 . A = B/C;
 13-260 . A = B+C;
 13-261 . A = B+C;
 13-262 . // max LOC 66
 13-263 . 
 13-264 . }
 13-265 . 
 13-266 . 
 13-267 . /*
 13-268 . -----------------------------------------------------------------------------
 13-269 . --| NAME:   dlp.4.3
 13-270 . --|
 13-271 . --| ABSTRACT:
 13-272 . --|   This function does dlp stuff.
 13-273 . --|
 13-274 . --| RETURNS:
 13-275 . --|   NONE.
 13-276 . --|
 13-277 . ----------------------------------------------------------------------------
 13-278 . */
 13-279 . static void dlp.4.3(void)
 13-280 . {
 13-281 . A = B*C;
 13-282 . A = B/C;
 13-283 . A = B/C;
 13-284 . A = B/C;
 13-285 . A = B+C;
 13-286 . A = B+C;
 13-287 . A = B/C;
 13-288 . A = B/C;
 13-289 . A = B-C;
 13-290 . 
 13-291 . if (A != B)
 13-292 . {
 13-293 .    A = B + C;
 13-294 .    D = E + F;
 13-295 . }
 13-296 . 
 13-297 . A = B*C;
 13-298 . A = (int)B + C;
 13-299 . 
 13-300 . if (A ge B)
 13-301 . {
 13-302 .    A = B + C;
 13-303 .    D = E + F;
 13-304 . }
 13-305 . 
 13-306 . 
 13-307 . if (A ge B)
 13-308 . {
 13-309 .    A = B + C;
 13-310 .    D = E + F;
 13-311 . }
 13-312 . 
 13-313 . A = B+C;
 13-314 . /* LE SV TOC-1241 this is a dlp-04.3.15 req to halt*/
 13-315 . A = B*C;
 13-316 . A = B+C;
 13-317 . 
 13-318 . if (A < = B)
 13-319 . {
 13-320 .    A = B + C;
 13-321 .    D = E + F;
 13-322 . }
 13-323 . 
 13-324 . 
 13-325 . if (A gt B)
 13-326 . {
 13-327 .    A = B + C;
 13-328 .    D = E + F;
 13-329 . }
 13-330 . 
 13-331 . A = B/C;
 13-332 . 
 13-333 . if (A != B)
 13-334 . {
 13-335 .    A = B + C;
 13-336 .    D = E + F;
 13-337 . }
 13-338 . 
 13-339 . A = B/C;
 13-340 . 
 13-341 . if (A != B)
 13-342 . {
 13-343 .    A = B + C;
 13-344 .    D = E + F;
 13-345 . }
 13-346 . 
 13-347 . A = B*C;
 13-348 . 
 13-349 . if (A le B)
 13-350 . {
 13-351 .    A = B + C;
 13-352 .    D = E + F;
 13-353 . }
 13-354 . 
 13-355 . 
 13-356 . if (A eq B)
 13-357 . {
 13-358 .    A = B + C;
 13-359 .    D = E + F;
 13-360 . }
 13-361 . 
 13-362 . goto error;
 13-363 . A = B-C;
 13-364 . A = B/C;
 13-365 . A = B*C;
 13-366 . /* LE SV TOC-1242 this is a dlp-04.3.29 req to translate*/
 13-367 . A = B*C;
 13-368 . 
 13-369 . if (A >  B)
 13-370 . {
 13-371 .    A = B + C;
 13-372 .    D = E + F;
 13-373 . }
 13-374 . 
 13-375 . A = B+C;
 13-376 . A = B*C;
 13-377 . // max LOC 32
 13-378 . 
 13-379 . }
 13-380 . 
 13-381 . 
 13-382 . /*
 13-383 . -----------------------------------------------------------------------------
 13-384 . --| NAME:   dlp.4.4
 13-385 . --|
 13-386 . --| ABSTRACT:
 13-387 . --|   This function does dlp stuff.
 13-388 . --|
 13-389 . --| RETURNS:
 13-390 . --|   NONE.
 13-391 . --|
 13-392 . ----------------------------------------------------------------------------
 13-393 . */
 13-394 . static void dlp.4.4(void)
 13-395 . {
 13-396 . A = B+C;
 13-397 . A = B*C;
 13-398 . 
 13-399 . if (A > = B)
 13-400 . {
 13-401 .    A = B + C;
 13-402 .    D = E + F;
 13-403 . }
 13-404 . 
 13-405 . A = B+C;
 13-406 . A = 0x0007;
 13-407 . 
 13-408 . if (A == B)
 13-409 . {
 13-410 .    A = B + C;
 13-411 .    D = E + F;
 13-412 . }
 13-413 . 
 13-414 . A = B+C;
 13-415 . A = B+C;
 13-416 . A = B/C;
 13-417 . A = B/C;
 13-418 . A = B+C;
 13-419 . A = B-C;
 13-420 . 
 13-421 . if (A != B)
 13-422 . {
 13-423 .    A = B + C;
 13-424 .    D = E + F;
 13-425 . }
 13-426 . 
 13-427 . A = B-C;
 13-428 . // max LOC 13
 13-429 . 
 13-430 . }
 13-431 . 
 13-432 . 
 13-433 . /*
 13-434 . -----------------------------------------------------------------------------
 13-435 . --| NAME:   dlp.4.5
 13-436 . --|
 13-437 . --| ABSTRACT:
 13-438 . --|   This function does dlp stuff.
 13-439 . --|
 13-440 . --| RETURNS:
 13-441 . --|   NONE.
 13-442 . --|
 13-443 . ----------------------------------------------------------------------------
 13-444 . */
 13-445 . static void dlp.4.5(void)
 13-446 . {
 13-447 . A = B/C;
 13-448 . A = B-C;
 13-449 . 
 13-450 . if (A < = B)
 13-451 . {
 13-452 .    A = B + C;
 13-453 .    D = E + F;
 13-454 . }
 13-455 . 
 13-456 . A = B*C;
 13-457 . 
 13-458 . if (A gt B)
 13-459 . {
 13-460 .    A = B + C;
 13-461 .    D = E + F;
 13-462 . }
 13-463 . 
 13-464 . A = B*C;
 13-465 . A = B/C;
 13-466 . A = B*C;
 13-467 . // TBS - I need to figure this out
 13-468 . A = B/C;
 13-469 . 
 13-470 . if (A != B)
 13-471 . {
 13-472 .    A = B + C;
 13-473 .    D = E + F;
 13-474 . }
 13-475 . 
 13-476 . 
 13-477 . if (A lt B)
 13-478 . {
 13-479 .    A = B + C;
 13-480 .    D = E + F;
 13-481 . }
 13-482 . 
 13-483 . A = B+C;
 13-484 . A = 0x0001;
 13-485 . A = B*C;
 13-486 . 
 13-487 . if (A == B)
 13-488 . {
 13-489 .    A = B + C;
 13-490 .    D = E + F;
 13-491 . }
 13-492 . 
 13-493 . A = B+C;
 13-494 . A = B/C;
 13-495 . A = B*C;
 13-496 . A = B/C;
 13-497 . 
 13-498 . if (A le B)
 13-499 . {
 13-500 .    A = B + C;
 13-501 .    D = E + F;
 13-502 . }
 13-503 . 
 13-504 . /* LE SV TOC-1243 this is a dlp-04.5.20 req to assign*/
 13-505 . A = B-C;
 13-506 . A = B/C;
 13-507 . A = B*C;
 13-508 . A = B-C;
 13-509 . 
 13-510 . if (A > = B)
 13-511 . {
 13-512 .    A = B + C;
 13-513 .    D = E + F;
 13-514 . }
 13-515 . 
 13-516 . 
 13-517 . switch (dlp stuff)
 13-518 . {
 13-519 .    case one:
 13-520 .    {
 13-521 .       switch (nested)
 13-522 .       {
 13-523 .          case:
 13-524 .             X = Y + Z;
 13-525 .          case:
 13-526 .             X = Y + Z;
 13-527 .          default:
 13-528 .             SwError;
 13-529 .       } 
 13-530 .    }
 13-531 .    case two:
 13-532 .    {
 13-533 .       run_this;
 13-534 .       break;
 13-535 .    }
 13-536 .    default:
 13-537 .    {
 13-538 .       SwError;
 13-539 .    }
 13-540 . }
 13-541 . 
 13-542 . A = B*C;
 13-543 . A = B/C;
 13-544 . 
 13-545 . if (A eq B)
 13-546 . {
 13-547 .    A = B + C;
 13-548 .    D = E + F;
 13-549 . }
 13-550 . 
 13-551 . /* LE SV TOC-1244 this is a dlp-04.5.28 req to translate*/
 13-552 . A = B+C;
 13-553 . A = B/C;
 13-554 . A = B-C;
 13-555 . A = B+C;
 13-556 . A = B+C;
 13-557 . A = B/C;
 13-558 . A = B*C;
 13-559 . A = B*C;
 13-560 . 
 13-561 . switch (dlp stuff)
 13-562 . {
 13-563 .    case one:
 13-564 .    {
 13-565 .       run_this; 
 13-566 .       break;
 13-567 .    }
 13-568 .    case two:
 13-569 .    {
 13-570 .       run_this;
 13-571 .       break;
 13-572 .    }
 13-573 .    default:
 13-574 .    {
 13-575 .        SwError;
 13-576 .    }
 13-577 . }
 13-578 . 
 13-579 . 
 13-580 . if (A >  B)
 13-581 . {
 13-582 .    A = B + C;
 13-583 .    D = E + F;
 13-584 . }
 13-585 . 
 13-586 . 
 13-587 . if (A <  B)
 13-588 . {
 13-589 .    A = B + C;
 13-590 .    D = E + F;
 13-591 . }
 13-592 . 
 13-593 . 
 13-594 . if (A < = B)
 13-595 . {
 13-596 .    A = B + C;
 13-597 .    D = E + F;
 13-598 . }
 13-599 . 
 13-600 . // max LOC 39
 13-601 . 
 13-602 . }
 13-603 . 
 13-604 . 
 13-605 . /*
 13-606 . -----------------------------------------------------------------------------
 13-607 . --| NAME:   dlp.4.6
 13-608 . --|
 13-609 . --| ABSTRACT:
 13-610 . --|   This function does dlp stuff.
 13-611 . --|
 13-612 . --| RETURNS:
 13-613 . --|   NONE.
 13-614 . --|
 13-615 . ----------------------------------------------------------------------------
 13-616 . */
 13-617 . static void dlp.4.6(void)
 13-618 . {
 13-619 . A = B*C;
 13-620 . 
 13-621 . if (A > = B)
 13-622 . {
 13-623 .    A = B + C;
 13-624 .    D = E + F;
 13-625 . }
 13-626 . 
 13-627 . 
 13-628 . if (A <  B)
 13-629 . {
 13-630 .    A = B + C;
 13-631 .    D = E + F;
 13-632 . }
 13-633 . 
 13-634 . /* LE SV TOC-1245 this is a dlp-04.6.4 req to call admin*/
 13-635 . A = B-C;
 13-636 . 
 13-637 . if (A eq B)
 13-638 . {
 13-639 .    A = B + C;
 13-640 .    D = E + F;
 13-641 . }
 13-642 . 
 13-643 . A = B-C;
 13-644 . 
 13-645 . if (A > = B)
 13-646 . {
 13-647 .    A = B + C;
 13-648 .    D = E + F;
 13-649 . }
 13-650 . 
 13-651 . 
 13-652 . if (A <  B)
 13-653 . {
 13-654 .    A = B + C;
 13-655 .    D = E + F;
 13-656 . }
 13-657 . 
 13-658 . A = B/C;
 13-659 . A = 0x0007;
 13-660 . A = B-C;
 13-661 . 
 13-662 . if (A != B)
 13-663 . {
 13-664 .    A = B + C;
 13-665 .    D = E + F;
 13-666 . }
 13-667 . 
 13-668 . 
 13-669 . if (A ne B)
 13-670 . {
 13-671 .    A = B + C;
 13-672 .    D = E + F;
 13-673 . }
 13-674 . 
 13-675 . A = B+C;
 13-676 . A = B+C;
 13-677 . /* LE SV TOC-1246 this is a dlp-04.6.15 req to store*/
 13-678 . A = B/C;
 13-679 . /* LE SV TOC-1247 this is a dlp-04.6.16 req to recover*/
 13-680 . 
 13-681 . if (A >  B)
 13-682 . {
 13-683 .    A = B + C;
 13-684 .    D = E + F;
 13-685 . }
 13-686 . 
 13-687 . A = B*C;
 13-688 . /* LE SV TOC-1248 this is a dlp-04.6.18 req to reject*/
 13-689 . A = B*C;
 13-690 . 
 13-691 . if (A ne B)
 13-692 . {
 13-693 .    A = B + C;
 13-694 .    D = E + F;
 13-695 . }
 13-696 . 
 13-697 . /* LE SV TOC-1249 this is a dlp-04.6.20 req to verify*/
 13-698 . A = B*C;
 13-699 . 
 13-700 . if (A le B)
 13-701 . {
 13-702 .    A = B + C;
 13-703 .    D = E + F;
 13-704 . }
 13-705 . 
 13-706 . A = B+C;
 13-707 . 
 13-708 . if (A gt B)
 13-709 . {
 13-710 .    A = B + C;
 13-711 .    D = E + F;
 13-712 . }
 13-713 . 
 13-714 . A = B-C;
 13-715 . A = B*C;
 13-716 . do forever;
 13-717 . A = B+C;
 13-718 . A = B*C;
 13-719 . A = (float)B + C;
 13-720 . A = B+C;
 13-721 . A = B+C;
 13-722 . free(FreePtr);
 13-723 . A = B*C;
 13-724 . A = B*C;
 13-725 . A = B+C;
 13-726 . A = B-C;
 13-727 . A = B*C;
 13-728 . 
 13-729 . switch (dlp stuff)
 13-730 . {
 13-731 .    case one:
 13-732 .    {
 13-733 .       run_this; 
 13-734 .       break;
 13-735 .    }
 13-736 .    case two:
 13-737 .    {
 13-738 .       run_this;
 13-739 .       break;
 13-740 .    }
 13-741 .    default:
 13-742 .    {
 13-743 .        SwError;
 13-744 .    }
 13-745 . }
 13-746 . 
 13-747 . 
 13-748 . if (A ge B)
 13-749 . {
 13-750 .    A = B + C;
 13-751 .    D = E + F;
 13-752 . }
 13-753 . 
 13-754 . 
 13-755 . if (A ge B)
 13-756 . {
 13-757 .    A = B + C;
 13-758 .    D = E + F;
 13-759 . }
 13-760 . 
 13-761 . A = B+C;
 13-762 . A = B*C;
 13-763 . 
 13-764 . if (A >  B)
 13-765 . {
 13-766 .    A = B + C;
 13-767 .    D = E + F;
 13-768 . }
 13-769 . 
 13-770 . A = B*C;
 13-771 . 
 13-772 . if (A gt B)
 13-773 . {
 13-774 .    A = B + C;
 13-775 .    D = E + F;
 13-776 . }
 13-777 . 
 13-778 . 
 13-779 . if (A le B)
 13-780 . {
 13-781 .    A = B + C;
 13-782 .    D = E + F;
 13-783 . }
 13-784 . 
 13-785 . A = B*C;
 13-786 . A = B-C;
 13-787 . A = B+C;
 13-788 . A = B+C;
 13-789 . /* LE SV TOC-1250 this is a dlp-04.6.48 req to inhibit*/
 13-790 . 
 13-791 . if (A <  B)
 13-792 . {
 13-793 .    A = B + C;
 13-794 .    D = E + F;
 13-795 . }
 13-796 . 
 13-797 . 
 13-798 . if (A > = B)
 13-799 . {
 13-800 .    A = B + C;
 13-801 .    D = E + F;
 13-802 . }
 13-803 . 
 13-804 . A = B+C;
 13-805 . 
 13-806 . if (A le B)
 13-807 . {
 13-808 .    A = B + C;
 13-809 .    D = E + F;
 13-810 . }
 13-811 . 
 13-812 . A = B*C;
 13-813 . 
 13-814 . if (A >  B)
 13-815 . {
 13-816 .    A = B + C;
 13-817 .    D = E + F;
 13-818 . }
 13-819 . 
 13-820 . 
 13-821 . if (A gt B)
 13-822 . {
 13-823 .    A = B + C;
 13-824 .    D = E + F;
 13-825 . }
 13-826 . 
 13-827 . A = B+C;
 13-828 . 
 13-829 . switch (dlp stuff)
 13-830 . {
 13-831 .    case one:
 13-832 .    {
 13-833 .       run_this; 
 13-834 .       break;
 13-835 .    }
 13-836 .    case two:
 13-837 .    {
 13-838 .       run_this;
 13-839 .       break;
 13-840 .    }
 13-841 .    default:
 13-842 .    {
 13-843 .        SwError;
 13-844 .    }
 13-845 . }
 13-846 . 
 13-847 . A = B+C;
 13-848 . A = 0x0004;
 13-849 . A = B-C;
 13-850 . A = B*C;
 13-851 . // max LOC 59
 13-852 . 
 13-853 . }
 13-854 . 
 13-855 . 
 13-856 . /*
 13-857 . -----------------------------------------------------------------------------
 13-858 . --| NAME:   dlp.4.7
 13-859 . --|
 13-860 . --| ABSTRACT:
 13-861 . --|   This function does dlp stuff.
 13-862 . --|
 13-863 . --| RETURNS:
 13-864 . --|   NONE.
 13-865 . --|
 13-866 . ----------------------------------------------------------------------------
 13-867 . */
 13-868 . static void dlp.4.7(void)
 13-869 . {
 13-870 . 
 13-871 . if (A ne B)
 13-872 . {
 13-873 .    A = B + C;
 13-874 .    D = E + F;
 13-875 . }
 13-876 . 
 13-877 . /* LE SV TOC-1251 this is a dlp-04.7.2 req to set Real Time Clock*/
 13-878 . 
 13-879 . if (A gt B)
 13-880 . {
 13-881 .    A = B + C;
 13-882 .    D = E + F;
 13-883 . }
 13-884 . 
 13-885 . A = B*C;
 13-886 . A = (float)B + C;
 13-887 . A = B/C;
 13-888 . 
 13-889 . /*
 13-890 . dead_block = C * D; 
 13-891 . dead_block = E * F;
 13-892 . */
 13-893 . 
 13-894 . A = B/C;
 13-895 . 
 13-896 . if (A ge B)
 13-897 . {
 13-898 .    A = B + C;
 13-899 .    D = E + F;
 13-900 . }
 13-901 . 
 13-902 . 
 13-903 . switch (dlp stuff)
 13-904 . {
 13-905 .    case one:
 13-906 .    {
 13-907 .       run_this; 
 13-908 .       break;
 13-909 .    }
 13-910 .    case two:
 13-911 .    {
 13-912 .       run_this;
 13-913 .       break;
 13-914 .    }
 13-915 .    default:
 13-916 .    {
 13-917 .        SwError;
 13-918 .    }
 13-919 . }
 13-920 . 
 13-921 . A = B+C;
 13-922 . A = B-C;
 13-923 . A = B*C;
 13-924 . A = B-C;
 13-925 . A = B/C;
 13-926 . 
 13-927 . /* dead_block = C * D; 
 13-928 . dead_block = E * F; */
 13-929 . 
 13-930 . 
 13-931 . if (A ne B)
 13-932 . {
 13-933 .    A = B + C;
 13-934 .    D = E + F;
 13-935 . }
 13-936 . 
 13-937 . 
 13-938 . if (A gt B)
 13-939 . {
 13-940 .    A = B + C;
 13-941 .    D = E + F;
 13-942 . }
 13-943 . 
 13-944 . A = B*C;
 13-945 . A = B/C;
 13-946 . A = B+C;
 13-947 . A = B-C;
 13-948 . A = B-C;
 13-949 . A = B/C;
 13-950 . A = B-C;
 13-951 . A = B-C;
 13-952 . A = B-C;
 13-953 . A = B+C;
 13-954 . 
 13-955 . if (A le B)
 13-956 . {
 13-957 .    A = B + C;
 13-958 .    D = E + F;
 13-959 . }
 13-960 . 
 13-961 . A = B-C;
 13-962 . A = B*C;
 13-963 . A = B*C;
 13-964 . A = B-C;
 13-965 . 
 13-966 . if (A <  B)
 13-967 . {
 13-968 .    A = B + C;
 13-969 .    D = E + F;
 13-970 . }
 13-971 . 
 13-972 . do forever;
 13-973 . A = B+C;
 13-974 . 
 13-975 . if {
 13-976 .    X = Y + Z;
 13-977 . }
 13-978 . else {
 13-979 .    halt;
 13-980 . }
 13-981 . 
 13-982 . A = B/C;
 13-983 . A = B+C;
 13-984 . 
 13-985 . if (A >  B)
 13-986 . {
 13-987 .    A = B + C;
 13-988 .    D = E + F;
 13-989 . }
 13-990 . 
 13-991 . 
 13-992 . if (A <  B)
 13-993 . {
 13-994 .    A = B + C;
 13-995 .    D = E + F;
 13-996 . }
 13-997 . 
 13-998 . A = B+C;
 13-999 . A = B/C;
 13-1000 . A = B+C;
 13-1001 . A = B/C;
 13-1002 . A = B+C;
 13-1003 . A = B+C;
 13-1004 . A = B+C;
 13-1005 . /* LE SV TOC-1252 this is a dlp-04.7.43 req to check pSOS*/
 13-1006 . 
 13-1007 . if (A < = B)
 13-1008 . {
 13-1009 .    A = B + C;
 13-1010 .    D = E + F;
 13-1011 . }
 13-1012 . 
 13-1013 . 
 13-1014 . switch (dlp stuff)
 13-1015 . {
 13-1016 .    case:
 13-1017 .    case:
 13-1018 .    // stacked case statements but only if there is a new line in between
 13-1019 . 
 13-1020 .    case:
 13-1021 .    case:
 13-1022 .    case:
 13-1023 .    {
 13-1024 .       run_this;
 13-1025 .       break;
 13-1026 .    }
 13-1027 .    default:
 13-1028 .    {
 13-1029 .       halt;
 13-1030 .    }
 13-1031 . }
 13-1032 . 
 13-1033 . A = B/C;
 13-1034 . A = B/C;
 13-1035 . A = B/C;
 13-1036 . A = B+C;
 13-1037 . 
 13-1038 . if (A < = B)
 13-1039 . {
 13-1040 .    A = B + C;
 13-1041 .    D = E + F;
 13-1042 . }
 13-1043 . 
 13-1044 . A = B*C;
 13-1045 . A = B*C;
 13-1046 . 
 13-1047 . if (A lt B)
 13-1048 . {
 13-1049 .    A = B + C;
 13-1050 .    D = E + F;
 13-1051 . }
 13-1052 . 
 13-1053 . 
 13-1054 . if (A le B)
 13-1055 . {
 13-1056 .    A = B + C;
 13-1057 .    D = E + F;
 13-1058 . }
 13-1059 . 
 13-1060 . A = B*C;
 13-1061 . 
 13-1062 . if (A gt B)
 13-1063 . {
 13-1064 .    A = B + C;
 13-1065 .    D = E + F;
 13-1066 . }
 13-1067 . 
 13-1068 . A = B+C;
 13-1069 . 
 13-1070 . if (A > = B)
 13-1071 . {
 13-1072 .    A = B + C;
 13-1073 .    D = E + F;
 13-1074 . }
 13-1075 . 
 13-1076 . A = B-C;
 13-1077 . A = B*C;
 13-1078 . A = B*C;
 13-1079 . A = B*C;
 13-1080 . 
 13-1081 . if (A != B)
 13-1082 . {
 13-1083 .    A = B + C;
 13-1084 .    D = E + F;
 13-1085 . }
 13-1086 . 
 13-1087 . /* LE SV TOC-1253 this is a dlp-04.7.62 req to process*/
 13-1088 . A = B-C;
 13-1089 . A = B-C;
 13-1090 . A = B/C;
 13-1091 . 
 13-1092 . switch (dlp stuff)
 13-1093 . {
 13-1094 .    case one:
 13-1095 .    {
 13-1096 .       run_this; 
 13-1097 .       break;
 13-1098 .    }
 13-1099 .    case two:
 13-1100 .    {
 13-1101 .       run_this;
 13-1102 .       break;
 13-1103 .    }
 13-1104 .    default:
 13-1105 .    {
 13-1106 .        SwError;
 13-1107 .    }
 13-1108 . }
 13-1109 . 
 13-1110 . A = B*C;
 13-1111 . A = B-C;
 13-1112 . A = B+C;
 13-1113 . A = B-C;
 13-1114 . A = B-C;
 13-1115 . 
 13-1116 . if (A ge B)
 13-1117 . {
 13-1118 .    A = B + C;
 13-1119 .    D = E + F;
 13-1120 . }
 13-1121 . 
 13-1122 . A = B/C;
 13-1123 . 
 13-1124 . if (A >  B)
 13-1125 . {
 13-1126 .    A = B + C;
 13-1127 .    D = E + F;
 13-1128 . }
 13-1129 . 
 13-1130 . A = B/C;
 13-1131 . // max LOC 74
 13-1132 . 
 13-1133 . }
 13-1134 . 
 13-1135 . 
 13-1136 . /*
 13-1137 . -----------------------------------------------------------------------------
 13-1138 . --| NAME:   dlp.4.8
 13-1139 . --|
 13-1140 . --| ABSTRACT:
 13-1141 . --|   This function does dlp stuff.
 13-1142 . --|
 13-1143 . --| RETURNS:
 13-1144 . --|   NONE.
 13-1145 . --|
 13-1146 . ----------------------------------------------------------------------------
 13-1147 . */
 13-1148 . static void dlp.4.8(void)
 13-1149 . {
 13-1150 . A = B+C;
 13-1151 . A = B/C;
 13-1152 . 
 13-1153 . if (A == B)
 13-1154 . {
 13-1155 .    A = B + C;
 13-1156 .    D = E + F;
 13-1157 . }
 13-1158 . 
 13-1159 . A = B-C;
 13-1160 . 
 13-1161 . switch (dlp stuff)
 13-1162 . {
 13-1163 .    case one:
 13-1164 .    {
 13-1165 .       run_this; 
 13-1166 .       break;
 13-1167 .    }
 13-1168 .    case two:
 13-1169 .    {
 13-1170 .       run_this;
 13-1171 .       break;
 13-1172 .    }
 13-1173 .    default:
 13-1174 .    {
 13-1175 .        SwError;
 13-1176 .    }
 13-1177 . }
 13-1178 . 
 13-1179 . A = B/C;
 13-1180 . 
 13-1181 . if (A gt B)
 13-1182 . {
 13-1183 .    A = B + C;
 13-1184 .    D = E + F;
 13-1185 . }
 13-1186 . 
 13-1187 . A = B/C;
 13-1188 . A = B+C;
 13-1189 . A = B*C;
 13-1190 . A = B-C;
 13-1191 . A = B/C;
 13-1192 . 
 13-1193 . if (A ge B)
 13-1194 . {
 13-1195 .    A = B + C;
 13-1196 .    D = E + F;
 13-1197 . }
 13-1198 . 
 13-1199 . A = B/C;
 13-1200 . A = B+C;
 13-1201 . A = B/C;
 13-1202 . A = B-C;
 13-1203 . 
 13-1204 . switch (dlp stuff)
 13-1205 . {
 13-1206 .    case:
 13-1207 .    case:
 13-1208 .    // stacked case statements but only if there is a new line in between
 13-1209 . 
 13-1210 .    case:
 13-1211 .    case:
 13-1212 .    case:
 13-1213 .    {
 13-1214 .       run_this;
 13-1215 .       break;
 13-1216 .    }
 13-1217 .    default:
 13-1218 .    {
 13-1219 .       halt;
 13-1220 .    }
 13-1221 . }
 13-1222 . 
 13-1223 . A = B*C;
 13-1224 . 
 13-1225 . if (A >  B)
 13-1226 . {
 13-1227 .    A = B + C;
 13-1228 .    D = E + F;
 13-1229 . }
 13-1230 . 
 13-1231 . A = B*C;
 13-1232 . // max LOC 20
 13-1233 . 
 13-1234 . }
 13-1235 . 
 13-1236 . 
 13-1237 . /*
 13-1238 . -----------------------------------------------------------------------------
 13-1239 . --| NAME:   dlp.4.9
 13-1240 . --|
 13-1241 . --| ABSTRACT:
 13-1242 . --|   This function does dlp stuff.
 13-1243 . --|
 13-1244 . --| RETURNS:
 13-1245 . --|   NONE.
 13-1246 . --|
 13-1247 . ----------------------------------------------------------------------------
 13-1248 . */
 13-1249 . static void dlp.4.9(void)
 13-1250 . {
 13-1251 . A = B/C;
 13-1252 . 
 13-1253 . if (A < = B)
 13-1254 . {
 13-1255 .    A = B + C;
 13-1256 .    D = E + F;
 13-1257 . }
 13-1258 . 
 13-1259 . A = B+C;
 13-1260 . /* LE SV TOC-1254 this is a dlp-04.9.4 req to process*/
 13-1261 . rcv_buffer = (U16 *) alloc(size+1);
 13-1262 . 
 13-1263 . if (A ge B)
 13-1264 . {
 13-1265 .    A = B + C;
 13-1266 .    D = E + F;
 13-1267 . }
 13-1268 . 
 13-1269 . A = B-C;
 13-1270 . A = B/C;
 13-1271 . 
 13-1272 . if (A eq B)
 13-1273 . {
 13-1274 .    A = B + C;
 13-1275 .    D = E + F;
 13-1276 . }
 13-1277 . 
 13-1278 . A = B-C;
 13-1279 . A = B*C;
 13-1280 . A = B/C;
 13-1281 . A = B*C;
 13-1282 . 
 13-1283 . if (A le B)
 13-1284 . {
 13-1285 .    A = B + C;
 13-1286 .    D = E + F;
 13-1287 . }
 13-1288 . 
 13-1289 . A = B+C;
 13-1290 . A = B*C;
 13-1291 . // max LOC 14
 13-1292 . 
 13-1293 . }
 13-1294 . 
 13-1295 . 
 13-1296 . /*
 13-1297 . -----------------------------------------------------------------------------
 13-1298 . --| NAME:   dlp.4.10
 13-1299 . --|
 13-1300 . --| ABSTRACT:
 13-1301 . --|   This function does dlp stuff.
 13-1302 . --|
 13-1303 . --| RETURNS:
 13-1304 . --|   NONE.
 13-1305 . --|
 13-1306 . ----------------------------------------------------------------------------
 13-1307 . */
 13-1308 . static void dlp.4.10(void)
 13-1309 . {
 13-1310 . A = B*C;
 13-1311 . A = B-C;
 13-1312 . A = B-C;
 13-1313 . A = B*C;
 13-1314 . 
 13-1315 . if (A != B)
 13-1316 . {
 13-1317 .    A = B + C;
 13-1318 .    D = E + F;
 13-1319 . }
 13-1320 . 
 13-1321 . A = 0x0003;
 13-1322 . A = B*C;
 13-1323 . A = B+C;
 13-1324 . A = B*C;
 13-1325 . A = B+C;
 13-1326 . A = B*C;
 13-1327 . 
 13-1328 . switch (dlp stuff)
 13-1329 . {
 13-1330 .    case one:
 13-1331 .    {
 13-1332 .       run_this; 
 13-1333 .       break;
 13-1334 .    }
 13-1335 .    case two:
 13-1336 .    {
 13-1337 .       run_this;
 13-1338 .       break;
 13-1339 .    }
 13-1340 .    default:
 13-1341 .    {
 13-1342 .        SwError;
 13-1343 .    }
 13-1344 . }
 13-1345 . 
 13-1346 . A = B/C;
 13-1347 . 
 13-1348 . if (A > = B)
 13-1349 . {
 13-1350 .    A = B + C;
 13-1351 .    D = E + F;
 13-1352 . }
 13-1353 . 
 13-1354 . A = B-C;
 13-1355 . A = B+C;
 13-1356 . A = B/C;
 13-1357 . A = B*C;
 13-1358 . A = B/C;
 13-1359 . A = B*C;
 13-1360 . 
 13-1361 . if (A lt B)
 13-1362 . {
 13-1363 .    A = B + C;
 13-1364 .    D = E + F;
 13-1365 . }
 13-1366 . 
 13-1367 . A = B*C;
 13-1368 . A = B-C;
 13-1369 . A = B/C;
 13-1370 . A = B/C;
 13-1371 . A = B*C;
 13-1372 . A = B*C;
 13-1373 . A = B-C;
 13-1374 . A = B*C;
 13-1375 . goto error;
 13-1376 . 
 13-1377 . if (A < = B)
 13-1378 . {
 13-1379 .    A = B + C;
 13-1380 .    D = E + F;
 13-1381 . }
 13-1382 . 
 13-1383 . A = B/C;
 13-1384 . A = B/C;
 13-1385 . A = B/C;
 13-1386 . 
 13-1387 . if (A lt B)
 13-1388 . {
 13-1389 .    A = B + C;
 13-1390 .    D = E + F;
 13-1391 . }
 13-1392 . 
 13-1393 . A = B-C;
 13-1394 . A = B-C;
 13-1395 . A = B-C;
 13-1396 . A = B-C;
 13-1397 . A = B+C;
 13-1398 . 
 13-1399 . if (A ge B)
 13-1400 . {
 13-1401 .    A = B + C;
 13-1402 .    D = E + F;
 13-1403 . }
 13-1404 . 
 13-1405 . 
 13-1406 . if (A >  B)
 13-1407 . {
 13-1408 .    A = B + C;
 13-1409 .    D = E + F;
 13-1410 . }
 13-1411 . 
 13-1412 . 
 13-1413 . if (A ge B)
 13-1414 . {
 13-1415 .    A = B + C;
 13-1416 .    D = E + F;
 13-1417 . }
 13-1418 . 
 13-1419 . /* LE SV TOC-1255 this is a dlp-04.10.42 req to enable*/
 13-1420 . 
 13-1421 . if (A ge B)
 13-1422 . {
 13-1423 .    A = B + C;
 13-1424 .    D = E + F;
 13-1425 . }
 13-1426 . 
 13-1427 . A = B+C;
 13-1428 . A = B+C;
 13-1429 . 
 13-1430 . if (A < = B)
 13-1431 . {
 13-1432 .    A = B + C;
 13-1433 .    D = E + F;
 13-1434 . }
 13-1435 . 
 13-1436 . 
 13-1437 . if (A ne B)
 13-1438 . {
 13-1439 .    A = B + C;
 13-1440 .    D = E + F;
 13-1441 . }
 13-1442 . 
 13-1443 . A = B-C;
 13-1444 . 
 13-1445 . if (A <  B)
 13-1446 . {
 13-1447 .    A = B + C;
 13-1448 .    D = E + F;
 13-1449 . }
 13-1450 . 
 13-1451 . A = B*C;
 13-1452 . A = B+C;
 13-1453 . 
 13-1454 . if (A lt B)
 13-1455 . {
 13-1456 .    A = B + C;
 13-1457 .    D = E + F;
 13-1458 . }
 13-1459 . 
 13-1460 . A = B-C;
 13-1461 . A = B-C;
 13-1462 . 
 13-1463 . if (A eq B)
 13-1464 . {
 13-1465 .    A = B + C;
 13-1466 .    D = E + F;
 13-1467 . }
 13-1468 . 
 13-1469 . A = B/C;
 13-1470 . 
 13-1471 . if (A le B)
 13-1472 . {
 13-1473 .    A = B + C;
 13-1474 .    D = E + F;
 13-1475 . }
 13-1476 . 
 13-1477 . A = B+C;
 13-1478 . do forever;
 13-1479 . A = B-C;
 13-1480 . A = B+C;
 13-1481 . 
 13-1482 . if (A == B)
 13-1483 . {
 13-1484 .    A = B + C;
 13-1485 .    D = E + F;
 13-1486 . }
 13-1487 . 
 13-1488 . A = B+C;
 13-1489 . /* LE SV TOC-1256 this is a dlp-04.10.62 req to validate*/
 13-1490 . A = B+C;
 13-1491 . A = B-C;
 13-1492 . // max LOC 63
 13-1493 . 
 13-1494 . }
 13-1495 . 
 13-1496 . 
 13-1497 . /*
 13-1498 . -----------------------------------------------------------------------------
 13-1499 . --| NAME:   dlp.4.11
 13-1500 . --|
 13-1501 . --| ABSTRACT:
 13-1502 . --|   This function does dlp stuff.
 13-1503 . --|
 13-1504 . --| RETURNS:
 13-1505 . --|   NONE.
 13-1506 . --|
 13-1507 . ----------------------------------------------------------------------------
 13-1508 . */
 13-1509 . static void dlp.4.11(void)
 13-1510 . {
 13-1511 . A = B+C;
 13-1512 . 
 13-1513 . if (A ge B)
 13-1514 . {
 13-1515 .    A = B + C;
 13-1516 .    D = E + F;
 13-1517 . }
 13-1518 . 
 13-1519 . 
 13-1520 . if (A ne B)
 13-1521 . {
 13-1522 .    A = B + C;
 13-1523 .    D = E + F;
 13-1524 . }
 13-1525 . 
 13-1526 . A = B-C;
 13-1527 . // (P) this is really improtant
 13-1528 . A = B-C;
 13-1529 . A = 0x0001;
 13-1530 . A = B-C;
 13-1531 . 
 13-1532 . if (A lt B)
 13-1533 . {
 13-1534 .    A = B + C;
 13-1535 .    D = E + F;
 13-1536 . }
 13-1537 . 
 13-1538 . /* LE SV TOC-1257 this is a dlp-04.11.8 req to halt*/
 13-1539 . A = B*C;
 13-1540 . 
 13-1541 . if ($dlp stuff >  $otherdlp stuff) 
 13-1542 . /* LE SV TOC-008 we really should log all error calls */
 13-1543 . {
 13-1544 .    A = B + C;
 13-1545 . }
 13-1546 . 
 13-1547 . A = B*C;
 13-1548 . 
 13-1549 . if (A >  B)
 13-1550 . {
 13-1551 .    A = B + C;
 13-1552 .    D = E + F;
 13-1553 . }
 13-1554 . 
 13-1555 . A = B/C;
 13-1556 . 
 13-1557 . if (A eq B)
 13-1558 . {
 13-1559 .    A = B + C;
 13-1560 .    D = E + F;
 13-1561 . }
 13-1562 . 
 13-1563 . 
 13-1564 . if (A le B)
 13-1565 . {
 13-1566 .    A = B + C;
 13-1567 .    D = E + F;
 13-1568 . }
 13-1569 . 
 13-1570 . A = B+C;
 13-1571 . A = B/C;
 13-1572 . A = B/C;
 13-1573 . A = B*C;
 13-1574 . /* LE SV TOC-1258 this is a dlp-04.11.18 req to check unix*/
 13-1575 . A = B/C;
 13-1576 . 
 13-1577 . if (A ne B)
 13-1578 . {
 13-1579 .    A = B + C;
 13-1580 .    D = E + F;
 13-1581 . }
 13-1582 . 
 13-1583 . A = B*C;
 13-1584 . A = B+C;
 13-1585 . A = B-C;
 13-1586 . A = B-C;
 13-1587 . 
 13-1588 . if (A gt B)
 13-1589 . {
 13-1590 .    A = B + C;
 13-1591 .    D = E + F;
 13-1592 . }
 13-1593 . 
 13-1594 . A = B-C;
 13-1595 . A = B*C;
 13-1596 . A = B+C;
 13-1597 . A = B+C;
 13-1598 . A = B/C;
 13-1599 . /* LE SV TOC-1259 this is a dlp-04.11.30 req to reject*/
 13-1600 . A = B-C;
 13-1601 . 
 13-1602 . if (A ne B)
 13-1603 . {
 13-1604 .    A = B + C;
 13-1605 .    D = E + F;
 13-1606 . }
 13-1607 . 
 13-1608 . 
 13-1609 . if (A eq B)
 13-1610 . {
 13-1611 .    A = B + C;
 13-1612 .    D = E + F;
 13-1613 . }
 13-1614 . 
 13-1615 . A = B*C;
 13-1616 . A = B/C;
 13-1617 . A = B*C;
 13-1618 . A = B-C;
 13-1619 . A = B+C;
 13-1620 . 
 13-1621 . if (A le B)
 13-1622 . {
 13-1623 .    A = B + C;
 13-1624 .    D = E + F;
 13-1625 . }
 13-1626 . 
 13-1627 . 
 13-1628 . if (A != B)
 13-1629 . {
 13-1630 .    A = B + C;
 13-1631 .    D = E + F;
 13-1632 . }
 13-1633 . 
 13-1634 . 
 13-1635 . if (A ne B)
 13-1636 . {
 13-1637 .    A = B + C;
 13-1638 .    D = E + F;
 13-1639 . }
 13-1640 . 
 13-1641 . 
 13-1642 . if (A gt B)
 13-1643 . {
 13-1644 .    A = B + C;
 13-1645 .    D = E + F;
 13-1646 . }
 13-1647 . 
 13-1648 . 
 13-1649 . switch (dlp stuff)
 13-1650 . {
 13-1651 .    case one:
 13-1652 .    {
 13-1653 .       run_this;
 13-1654 .       break;
 13-1655 .    }
 13-1656 .    case two:
 13-1657 .    {
 13-1658 .       run_this;
 13-1659 .       break;
 13-1660 .    }
 13-1661 .    // missing default
 13-1662 . }
 13-1663 . 
 13-1664 . A = B+C;
 13-1665 . A = B+C;
 13-1666 . 
 13-1667 . if (A >  B)
 13-1668 . {
 13-1669 .    A = B + C;
 13-1670 .    D = E + F;
 13-1671 . }
 13-1672 . 
 13-1673 . A = B+C;
 13-1674 . 
 13-1675 . if (A ge B)
 13-1676 . {
 13-1677 .    A = B + C;
 13-1678 .    D = E + F;
 13-1679 . }
 13-1680 . 
 13-1681 . send_buffer = (U16 *) malloc(size+1);
 13-1682 . A = B+C;
 13-1683 . // max LOC 47
 13-1684 . 
 13-1685 . }
 13-1686 . 

13 13 Result: result/source/ft-app/ft-app-B1.1/dlp/dlp-04.c


14 14 Source: source/ft-app/ft-app-B1.1/fdp/fdp-01.c
 14-0 . /*
 14-1 . ----------------------------------------------------------------------------
 14-2 . --| BEGIN PROLOGUE
 14-3 . --|
 14-4 . --| CLASSIFICATION: UNCLASSIFIED
 14-5 . --|
 14-6 . --| FILE NAME:      fdp-01.c
 14-7 . --|
 14-8 . --| ABSTRACT:
 14-9 . --|   This file contains the 14 functions that do file fdp stuff.
 14-10 . --|
 14-11 . --| HISTORY:
 14-12 . --|   CCCQ_NAME:
 14-13 . --|   CCCQ_VER: 
 14-14 . --|
 14-15 . --| END PROLOGUE
 14-16 . ----------------------------------------------------------------------------
 14-17 . */
 14-18 . 
 14-19 . #define D;
 14-20 . #define A;
 14-21 . #define B;
 14-22 . float B;
 14-23 . #define B;
 14-24 . #define C;
 14-25 . int A;
 14-26 . #define D;
 14-27 . 
 14-28 . 
 14-29 . 
 14-30 . /*
 14-31 . -----------------------------------------------------------------------------
 14-32 . --| NAME:   fdp.1.1
 14-33 . --|
 14-34 . --| ABSTRACT:
 14-35 . --|   This function does fdp stuff.
 14-36 . --|
 14-37 . --| RETURNS:
 14-38 . --|   NONE.
 14-39 . --|
 14-40 . ----------------------------------------------------------------------------
 14-41 . */
 14-42 . static void fdp.1.1(void)
 14-43 . {
 14-44 . A = B/C;
 14-45 . A = B+C;
 14-46 . A = B/C;
 14-47 . A = B*C;
 14-48 . 
 14-49 . if (A >  B)
 14-50 . {
 14-51 .    A = B + C;
 14-52 .    D = E + F;
 14-53 . }
 14-54 . 
 14-55 . A = B*C;
 14-56 . 
 14-57 . if (A ge B)
 14-58 . {
 14-59 .    A = B + C;
 14-60 .    D = E + F;
 14-61 . }
 14-62 . 
 14-63 . A = B*C;
 14-64 . A = B-C;
 14-65 . 
 14-66 . if (A >  B)
 14-67 . {
 14-68 .    A = B + C;
 14-69 .    D = E + F;
 14-70 . }
 14-71 . 
 14-72 . A = B*C;
 14-73 . A = B+C;
 14-74 . 
 14-75 . if (A le B)
 14-76 . {
 14-77 .    A = B + C;
 14-78 .    D = E + F;
 14-79 . }
 14-80 . 
 14-81 . 
 14-82 . if (A lt B)
 14-83 . {
 14-84 .    A = B + C;
 14-85 .    D = E + F;
 14-86 . }
 14-87 . 
 14-88 . A = B-C;
 14-89 . A = B/C;
 14-90 . A = B+C;
 14-91 . A = B/C;
 14-92 . A = B+C;
 14-93 . A = B-C;
 14-94 . A = B/C;
 14-95 . A = B+C;
 14-96 . A = B*C;
 14-97 . A = B/C;
 14-98 . A = B/C;
 14-99 . A = B*C;
 14-100 . /* LE SV TOC-1401 this is a fdp-01.1.27 req to translate*/
 14-101 . 
 14-102 . if (A lt B)
 14-103 . {
 14-104 .    A = B + C;
 14-105 .    D = E + F;
 14-106 . }
 14-107 . 
 14-108 . A = B*C;
 14-109 . A = B/C;
 14-110 . A = B-C;
 14-111 . A = B/C;
 14-112 . A = B*C;
 14-113 . A = B-C;
 14-114 . 
 14-115 . if (A le B)
 14-116 . {
 14-117 .    A = B + C;
 14-118 .    D = E + F;
 14-119 . }
 14-120 . 
 14-121 . A = B+C;
 14-122 . 
 14-123 . if (A == B)
 14-124 . {
 14-125 .    A = B + C;
 14-126 .    D = E + F;
 14-127 . }
 14-128 . 
 14-129 . A = B*C;
 14-130 . A = B/C;
 14-131 . A = B*C;
 14-132 . A = B-C;
 14-133 . 
 14-134 . if (A ge B)
 14-135 . {
 14-136 .    A = B + C;
 14-137 .    D = E + F;
 14-138 . }
 14-139 . 
 14-140 . A = B+C;
 14-141 . /* LE SV TOC-1402 this is a fdp-01.1.43 req to compare*/
 14-142 . A = B+C;
 14-143 . A = B*C;
 14-144 . A = B*C;
 14-145 . A = B/C;
 14-146 . 
 14-147 . if (A > = B)
 14-148 . {
 14-149 .    A = B + C;
 14-150 .    D = E + F;
 14-151 . }
 14-152 . 
 14-153 . A = B*C;
 14-154 . A = B+C;
 14-155 . 
 14-156 . if (A >  B)
 14-157 . {
 14-158 .    A = B + C;
 14-159 .    D = E + F;
 14-160 . }
 14-161 . 
 14-162 . 
 14-163 . switch (fdp stuff)
 14-164 . {
 14-165 .       case one:
 14-166 .    {
 14-167 .       run_this;
 14-168 .       break;
 14-169 .    }
 14-170 .    case two:
 14-171 .    {
 14-172 .       run_this;
 14-173 .       break;
 14-174 .    }
 14-175 .    default:
 14-176 .    {
 14-177 .       // missing error call
 14-178 .    }
 14-179 . }
 14-180 . 
 14-181 . A = B+C;
 14-182 . A = B*C;
 14-183 . A = B/C;
 14-184 . A = B/C;
 14-185 . 
 14-186 . if (A <  B)
 14-187 . {
 14-188 .    A = B + C;
 14-189 .    D = E + F;
 14-190 . }
 14-191 . 
 14-192 . A = B*C;
 14-193 . 
 14-194 . if (A le B)
 14-195 . {
 14-196 .    A = B + C;
 14-197 .    D = E + F;
 14-198 . }
 14-199 . 
 14-200 . 
 14-201 . if (A ne B)
 14-202 . {
 14-203 .    A = B + C;
 14-204 .    D = E + F;
 14-205 . }
 14-206 . 
 14-207 . A = B*C;
 14-208 . A = B+C;
 14-209 . A = B*C;
 14-210 . A = B*C;
 14-211 . A = B/C;
 14-212 . A = B+C;
 14-213 . 
 14-214 . if (A gt B)
 14-215 . {
 14-216 .    A = B + C;
 14-217 .    D = E + F;
 14-218 . }
 14-219 . 
 14-220 . 
 14-221 . /*
 14-222 . dead_block = C * D; 
 14-223 . dead_block = E * F;
 14-224 . */
 14-225 . 
 14-226 . A = B+C;
 14-227 . A = B/C;
 14-228 . A = B+C;
 14-229 . 
 14-230 . if (A eq B)
 14-231 . {
 14-232 .    A = B + C;
 14-233 .    D = E + F;
 14-234 . }
 14-235 . 
 14-236 . // max LOC 69
 14-237 . 
 14-238 . }
 14-239 . 
 14-240 . 
 14-241 . /*
 14-242 . -----------------------------------------------------------------------------
 14-243 . --| NAME:   fdp.1.2
 14-244 . --|
 14-245 . --| ABSTRACT:
 14-246 . --|   This function does fdp stuff.
 14-247 . --|
 14-248 . --| RETURNS:
 14-249 . --|   NONE.
 14-250 . --|
 14-251 . ----------------------------------------------------------------------------
 14-252 . */
 14-253 . static void fdp.1.2(void)
 14-254 . {
 14-255 . A = B/C;
 14-256 . A = B*C;
 14-257 . 
 14-258 . if (A ge B)
 14-259 . {
 14-260 .    A = B + C;
 14-261 .    D = E + F;
 14-262 . }
 14-263 . 
 14-264 . A = 0x0007;
 14-265 . A = B+C;
 14-266 . A = B+C;
 14-267 . 
 14-268 . if (A != B)
 14-269 . {
 14-270 .    A = B + C;
 14-271 .    D = E + F;
 14-272 . }
 14-273 . 
 14-274 . 
 14-275 . if (A < = B)
 14-276 . {
 14-277 .    A = B + C;
 14-278 .    D = E + F;
 14-279 . }
 14-280 . 
 14-281 . A = B+C;
 14-282 . 
 14-283 . if (A < = B)
 14-284 . {
 14-285 .    A = B + C;
 14-286 .    D = E + F;
 14-287 . }
 14-288 . 
 14-289 . A = B-C;
 14-290 . /* LE SV TOC-1403 this is a fdp-01.2.11 req to record*/
 14-291 . A = B-C;
 14-292 . A = 0x0004;
 14-293 . A = B/C;
 14-294 . A = B-C;
 14-295 . 
 14-296 . /* dead_block = C * D; 
 14-297 . dead_block = E * F; */
 14-298 . 
 14-299 . 
 14-300 . if (A != B)
 14-301 . {
 14-302 .    A = B + C;
 14-303 .    D = E + F;
 14-304 . }
 14-305 . 
 14-306 . A = B+C;
 14-307 . /* LE SV TOC-1404 this is a fdp-01.2.16 req to translate*/
 14-308 . A = B/C;
 14-309 . A = B+C;
 14-310 . A = B*C;
 14-311 . A = 0x0001;
 14-312 . 
 14-313 . if (A le B)
 14-314 . {
 14-315 .    A = B + C;
 14-316 .    D = E + F;
 14-317 . }
 14-318 . 
 14-319 . /* LE SV TOC-1405 this is a fdp-01.2.20 req to translate*/
 14-320 . A = B-C;
 14-321 . A = B-C;
 14-322 . A = B/C;
 14-323 . 
 14-324 . if (A <  B)
 14-325 . {
 14-326 .    A = B + C;
 14-327 .    D = E + F;
 14-328 . }
 14-329 . 
 14-330 . A = B+C;
 14-331 . 
 14-332 . if (A == B)
 14-333 . {
 14-334 .    A = B + C;
 14-335 .    D = E + F;
 14-336 . }
 14-337 . 
 14-338 . 
 14-339 . if (A ge B)
 14-340 . {
 14-341 .    A = B + C;
 14-342 .    D = E + F;
 14-343 . }
 14-344 . 
 14-345 . A = B*C;
 14-346 . 
 14-347 . if (A eq B)
 14-348 . {
 14-349 .    A = B + C;
 14-350 .    D = E + F;
 14-351 . }
 14-352 . 
 14-353 . A = B*C;
 14-354 . A = B/C;
 14-355 . A = B-C;
 14-356 . 
 14-357 . if (A ne B)
 14-358 . {
 14-359 .    A = B + C;
 14-360 .    D = E + F;
 14-361 . }
 14-362 . 
 14-363 . 
 14-364 . if (A >  B)
 14-365 . {
 14-366 .    A = B + C;
 14-367 .    D = E + F;
 14-368 . }
 14-369 . 
 14-370 . A = B/C;
 14-371 . A = B*C;
 14-372 . 
 14-373 . if (A ge B)
 14-374 . {
 14-375 .    A = B + C;
 14-376 .    D = E + F;
 14-377 . }
 14-378 . 
 14-379 . A = B+C;
 14-380 . A = B*C;
 14-381 . A = B/C;
 14-382 . // max LOC 39
 14-383 . 
 14-384 . }
 14-385 . 
 14-386 . 
 14-387 . /*
 14-388 . -----------------------------------------------------------------------------
 14-389 . --| NAME:   fdp.1.3
 14-390 . --|
 14-391 . --| ABSTRACT:
 14-392 . --|   This function does fdp stuff.
 14-393 . --|
 14-394 . --| RETURNS:
 14-395 . --|   NONE.
 14-396 . --|
 14-397 . ----------------------------------------------------------------------------
 14-398 . */
 14-399 . static void fdp.1.3(void)
 14-400 . {
 14-401 . 
 14-402 . if (A ne B)
 14-403 . {
 14-404 .    A = B + C;
 14-405 .    D = E + F;
 14-406 . }
 14-407 . 
 14-408 . A = B/C;
 14-409 . 
 14-410 . if (A < = B)
 14-411 . {
 14-412 .    A = B + C;
 14-413 .    D = E + F;
 14-414 . }
 14-415 . 
 14-416 . /* LE SV TOC-1406 this is a fdp-01.3.4 req to check pSOS*/
 14-417 . A = B+C;
 14-418 . 
 14-419 . if (A < = B)
 14-420 . {
 14-421 .    A = B + C;
 14-422 .    D = E + F;
 14-423 . }
 14-424 . 
 14-425 . 
 14-426 . if (A >  B)
 14-427 . {
 14-428 .    A = B + C;
 14-429 .    D = E + F;
 14-430 . }
 14-431 . 
 14-432 . A = B+C;
 14-433 . 
 14-434 . if (A lt B)
 14-435 . {
 14-436 .    A = B + C;
 14-437 .    D = E + F;
 14-438 . }
 14-439 . 
 14-440 . 
 14-441 . if (A <  B)
 14-442 . {
 14-443 .    A = B + C;
 14-444 .    D = E + F;
 14-445 . }
 14-446 . 
 14-447 . // max LOC 9
 14-448 . 
 14-449 . }
 14-450 . 
 14-451 . 
 14-452 . /*
 14-453 . -----------------------------------------------------------------------------
 14-454 . --| NAME:   fdp.1.4
 14-455 . --|
 14-456 . --| ABSTRACT:
 14-457 . --|   This function does fdp stuff.
 14-458 . --|
 14-459 . --| RETURNS:
 14-460 . --|   NONE.
 14-461 . --|
 14-462 . ----------------------------------------------------------------------------
 14-463 . */
 14-464 . static void fdp.1.4(void)
 14-465 . {
 14-466 . 
 14-467 . switch (fdp stuff)
 14-468 . {
 14-469 .    case one:
 14-470 .    {
 14-471 .       run_this; 
 14-472 .       break;
 14-473 .    }
 14-474 .    case two:
 14-475 .    {
 14-476 .       run_this;
 14-477 .       break;
 14-478 .    }
 14-479 .    default:
 14-480 .    {
 14-481 .        SwError;
 14-482 .    }
 14-483 . }
 14-484 . 
 14-485 . A = B*C;
 14-486 . A = B*C;
 14-487 . 
 14-488 . if (A <  B)
 14-489 . {
 14-490 .    A = B + C;
 14-491 .    D = E + F;
 14-492 . }
 14-493 . 
 14-494 . 
 14-495 . if (A gt B)
 14-496 . {
 14-497 .    A = B + C;
 14-498 .    D = E + F;
 14-499 . }
 14-500 . 
 14-501 . 
 14-502 . if (A == B)
 14-503 . {
 14-504 .    A = B + C;
 14-505 .    D = E + F;
 14-506 . }
 14-507 . 
 14-508 . A = B*C;
 14-509 . A = B-C;
 14-510 . A = B+C;
 14-511 . A = B/C;
 14-512 . A = B*C;
 14-513 . 
 14-514 . if (A eq B)
 14-515 . {
 14-516 .    A = B + C;
 14-517 .    D = E + F;
 14-518 . }
 14-519 . 
 14-520 . A = B+C;
 14-521 . A = B-C;
 14-522 . A = B*C;
 14-523 . 
 14-524 . switch (fdp stuff)
 14-525 . {
 14-526 .    case one:
 14-527 .    {
 14-528 .       run_this; 
 14-529 .       break;
 14-530 .    }
 14-531 .    case two:
 14-532 .    {
 14-533 .       run_this;
 14-534 .       break;
 14-535 .    }
 14-536 .    default:
 14-537 .    {
 14-538 .        SwError;
 14-539 .    }
 14-540 . }
 14-541 . 
 14-542 . A = B-C;
 14-543 . 
 14-544 . switch (fdp stuff)
 14-545 . {
 14-546 .    case one:
 14-547 .    {
 14-548 .       run_this; 
 14-549 .       break;
 14-550 .    }
 14-551 .    case two:
 14-552 .    {
 14-553 .       run_this;
 14-554 .       break;
 14-555 .    }
 14-556 .    default:
 14-557 .    {
 14-558 .        SwError;
 14-559 .    }
 14-560 . }
 14-561 . 
 14-562 . A = B/C;
 14-563 . A = B/C;
 14-564 . A = B-C;
 14-565 . /* LE SV TOC-1407 this is a fdp-01.4.22 req to process*/
 14-566 . A = B*C;
 14-567 . /* LE SV TOC-1408 this is a fdp-01.4.23 req to check pSOS*/
 14-568 . 
 14-569 . if (A lt B)
 14-570 . {
 14-571 .    A = B + C;
 14-572 .    D = E + F;
 14-573 . }
 14-574 . 
 14-575 . 
 14-576 . if (A eq B)
 14-577 . {
 14-578 .    A = B + C;
 14-579 .    D = E + F;
 14-580 . }
 14-581 . 
 14-582 . A = 0x0006;
 14-583 . A = B-C;
 14-584 . A = B-C;
 14-585 . 
 14-586 . if (A >  B)
 14-587 . {
 14-588 .    A = B + C;
 14-589 .    D = E + F;
 14-590 . }
 14-591 . 
 14-592 . A = B/C;
 14-593 . A = B-C;
 14-594 . 
 14-595 . if (A != B)
 14-596 . {
 14-597 .    A = B + C;
 14-598 .    D = E + F;
 14-599 . }
 14-600 . 
 14-601 . 
 14-602 . if (A < = B)
 14-603 . {
 14-604 .    A = B + C;
 14-605 .    D = E + F;
 14-606 . }
 14-607 . 
 14-608 . A = B+C;
 14-609 . // max LOC 32
 14-610 . 
 14-611 . }
 14-612 . 
 14-613 . 
 14-614 . /*
 14-615 . -----------------------------------------------------------------------------
 14-616 . --| NAME:   fdp.1.5
 14-617 . --|
 14-618 . --| ABSTRACT:
 14-619 . --|   This function does fdp stuff.
 14-620 . --|
 14-621 . --| RETURNS:
 14-622 . --|   NONE.
 14-623 . --|
 14-624 . ----------------------------------------------------------------------------
 14-625 . */
 14-626 . static void fdp.1.5(void)
 14-627 . {
 14-628 . A = B*C;
 14-629 . A = B/C;
 14-630 . /* LE SV TOC-1409 this is a fdp-01.5.3 req to validate*/
 14-631 . A = B+C;
 14-632 . 
 14-633 . if (A le B)
 14-634 . {
 14-635 .    A = B + C;
 14-636 .    D = E + F;
 14-637 . }
 14-638 . 
 14-639 . A = B+C;
 14-640 . A = B/C;
 14-641 . A = B*C;
 14-642 . 
 14-643 . if (A ne B)
 14-644 . {
 14-645 .    A = B + C;
 14-646 .    D = E + F;
 14-647 . }
 14-648 . 
 14-649 . A = B*C;
 14-650 . A = B-C;
 14-651 . 
 14-652 . if (A ge B)
 14-653 . {
 14-654 .    A = B + C;
 14-655 .    D = E + F;
 14-656 . }
 14-657 . 
 14-658 . A = B+C;
 14-659 . 
 14-660 . if (A <  B)
 14-661 . {
 14-662 .    A = B + C;
 14-663 .    D = E + F;
 14-664 . }
 14-665 . 
 14-666 . A = B/C;
 14-667 . 
 14-668 . if (A ge B)
 14-669 . {
 14-670 .    A = B + C;
 14-671 .    D = E + F;
 14-672 . }
 14-673 . 
 14-674 . 
 14-675 . if (A eq B)
 14-676 . {
 14-677 .    A = B + C;
 14-678 .    D = E + F;
 14-679 . }
 14-680 . 
 14-681 . 
 14-682 . /* dead_block = C * D; 
 14-683 . dead_block = E * F; */
 14-684 . 
 14-685 . A = B-C;
 14-686 . A = B-C;
 14-687 . A = B+C;
 14-688 . A = B+C;
 14-689 . A = B/C;
 14-690 . 
 14-691 . if (A <  B)
 14-692 . {
 14-693 .    A = B + C;
 14-694 .    D = E + F;
 14-695 . }
 14-696 . 
 14-697 . 
 14-698 . switch (fdp stuff)
 14-699 . {
 14-700 .       case one:
 14-701 .    {
 14-702 .       run_this;
 14-703 .       break;
 14-704 .    }
 14-705 .    case two:
 14-706 .    {
 14-707 .       run_this;
 14-708 .       break;
 14-709 .    }
 14-710 .    default:
 14-711 .    {
 14-712 .       // missing error call
 14-713 .    }
 14-714 . }
 14-715 . 
 14-716 . 
 14-717 . if (A >  B)
 14-718 . {
 14-719 .    A = B + C;
 14-720 .    D = E + F;
 14-721 . }
 14-722 . 
 14-723 . A = B/C;
 14-724 . /* LE SV TOC-1410 this is a fdp-01.5.25 req to audit*/
 14-725 . A = B+C;
 14-726 . // TBS - I need to figure this out
 14-727 . A = B/C;
 14-728 . 
 14-729 . if (A eq B)
 14-730 . {
 14-731 .    A = B + C;
 14-732 .    D = E + F;
 14-733 . }
 14-734 . 
 14-735 . A = B/C;
 14-736 . 
 14-737 . if (A <  B)
 14-738 . {
 14-739 .    A = B + C;
 14-740 .    D = E + F;
 14-741 . }
 14-742 . 
 14-743 . 
 14-744 . if (A le B)
 14-745 . {
 14-746 .    A = B + C;
 14-747 .    D = E + F;
 14-748 . }
 14-749 . 
 14-750 . 
 14-751 . if (A le B)
 14-752 . {
 14-753 .    A = B + C;
 14-754 .    D = E + F;
 14-755 . }
 14-756 . 
 14-757 . 
 14-758 . switch (fdp stuff)
 14-759 . {
 14-760 .    case:
 14-761 .    case:
 14-762 .    // stacked case statements but only if there is a new line in between
 14-763 . 
 14-764 .    case:
 14-765 .    case:
 14-766 .    case:
 14-767 .    {
 14-768 .       run_this;
 14-769 .       break;
 14-770 .    }
 14-771 .    default:
 14-772 .    {
 14-773 .       halt;
 14-774 .    }
 14-775 . }
 14-776 . 
 14-777 . A = B/C;
 14-778 . A = B*C;
 14-779 . /* LE SV TOC-1411 this is a fdp-01.5.34 req to compare*/
 14-780 . A = B+C;
 14-781 . A = B+C;
 14-782 . /* LE SV TOC-1412 this is a fdp-01.5.36 req to increment*/
 14-783 . A = B*C;
 14-784 . A = B-C;
 14-785 . A = B-C;
 14-786 . /* LE SV TOC-1413 this is a fdp-01.5.39 req to disable*/
 14-787 . 
 14-788 . if (A ne B)
 14-789 . {
 14-790 .    A = B + C;
 14-791 .    D = E + F;
 14-792 . }
 14-793 . 
 14-794 . 
 14-795 . /*
 14-796 . dead_block = C * D; 
 14-797 . dead_block = E * F;
 14-798 . */
 14-799 . 
 14-800 . 
 14-801 . if (A le B)
 14-802 . {
 14-803 .    A = B + C;
 14-804 .    D = E + F;
 14-805 . }
 14-806 . 
 14-807 . // max LOC 40
 14-808 . 
 14-809 . }
 14-810 . 
 14-811 . 
 14-812 . /*
 14-813 . -----------------------------------------------------------------------------
 14-814 . --| NAME:   fdp.1.6
 14-815 . --|
 14-816 . --| ABSTRACT:
 14-817 . --|   This function does fdp stuff.
 14-818 . --|
 14-819 . --| RETURNS:
 14-820 . --|   NONE.
 14-821 . --|
 14-822 . ----------------------------------------------------------------------------
 14-823 . */
 14-824 . static void fdp.1.6(void)
 14-825 . {
 14-826 . 
 14-827 . if (A < = B)
 14-828 . {
 14-829 .    A = B + C;
 14-830 .    D = E + F;
 14-831 . }
 14-832 . 
 14-833 . 
 14-834 . switch (fdp stuff)
 14-835 . {
 14-836 .    case one:
 14-837 .    {
 14-838 .       run_this; 
 14-839 .       break;
 14-840 .    }
 14-841 .    case two:
 14-842 .    {
 14-843 .       run_this;
 14-844 .       break;
 14-845 .    }
 14-846 .    default:
 14-847 .    {
 14-848 .        SwError;
 14-849 .    }
 14-850 . }
 14-851 . 
 14-852 . /* LE SV TOC-1414 this is a fdp-01.6.3 req to detect error*/
 14-853 . A = B*C;
 14-854 . A = B-C;
 14-855 . A = B/C;
 14-856 . A = B+C;
 14-857 . 
 14-858 . if (A <  B)
 14-859 . {
 14-860 .    A = B + C;
 14-861 .    D = E + F;
 14-862 . }
 14-863 . 
 14-864 . A = B/C;
 14-865 . A = B+C;
 14-866 . 
 14-867 . if (A != B)
 14-868 . {
 14-869 .    A = B + C;
 14-870 .    D = E + F;
 14-871 . }
 14-872 . 
 14-873 . 
 14-874 . if (A ne B)
 14-875 . {
 14-876 .    A = B + C;
 14-877 .    D = E + F;
 14-878 . }
 14-879 . 
 14-880 . A = B*C;
 14-881 . A = B-C;
 14-882 . 
 14-883 . if (A < = B)
 14-884 . {
 14-885 .    A = B + C;
 14-886 .    D = E + F;
 14-887 . }
 14-888 . 
 14-889 . A = B-C;
 14-890 . A = B*C;
 14-891 . 
 14-892 . if (A le B)
 14-893 . {
 14-894 .    A = B + C;
 14-895 .    D = E + F;
 14-896 . }
 14-897 . 
 14-898 . // max LOC 17
 14-899 . 
 14-900 . }
 14-901 . 
 14-902 . 
 14-903 . /*
 14-904 . -----------------------------------------------------------------------------
 14-905 . --| NAME:   fdp.1.7
 14-906 . --|
 14-907 . --| ABSTRACT:
 14-908 . --|   This function does fdp stuff.
 14-909 . --|
 14-910 . --| RETURNS:
 14-911 . --|   NONE.
 14-912 . --|
 14-913 . ----------------------------------------------------------------------------
 14-914 . */
 14-915 . static void fdp.1.7(void)
 14-916 . {
 14-917 . 
 14-918 . if (A <  B)
 14-919 . {
 14-920 .    A = B + C;
 14-921 .    D = E + F;
 14-922 . }
 14-923 . 
 14-924 . /* LE SV TOC-1415 this is a fdp-01.7.2 req to call isr*/
 14-925 . 
 14-926 . if (A lt B)
 14-927 . {
 14-928 .    A = B + C;
 14-929 .    D = E + F;
 14-930 . }
 14-931 . 
 14-932 . A = B+C;
 14-933 . A = B-C;
 14-934 . A = B-C;
 14-935 . 
 14-936 . if (A >  B)
 14-937 . {
 14-938 .    A = B + C;
 14-939 .    D = E + F;
 14-940 . }
 14-941 . 
 14-942 . A = B-C;
 14-943 . A = B+C;
 14-944 . A = B+C;
 14-945 . A = B-C;
 14-946 . rcv_buffer = (U16 *) alloc(size+1);
 14-947 . A = B+C;
 14-948 . 
 14-949 . if (A == B)
 14-950 . {
 14-951 .    A = B + C;
 14-952 .    D = E + F;
 14-953 . }
 14-954 . 
 14-955 . A = B+C;
 14-956 . 
 14-957 . if (A ne B)
 14-958 . {
 14-959 .    A = B + C;
 14-960 .    D = E + F;
 14-961 . }
 14-962 . 
 14-963 . A = B-C;
 14-964 . A = B+C;
 14-965 . 
 14-966 . if (A <  B)
 14-967 . {
 14-968 .    A = B + C;
 14-969 .    D = E + F;
 14-970 . }
 14-971 . 
 14-972 . A = 0x0001;
 14-973 . A = B/C;
 14-974 . A = B-C;
 14-975 . A = B*C;
 14-976 . 
 14-977 . if (A ne B)
 14-978 . {
 14-979 .    A = B + C;
 14-980 .    D = E + F;
 14-981 . }
 14-982 . 
 14-983 . A = B+C;
 14-984 . 
 14-985 . if (A > = B)
 14-986 . {
 14-987 .    A = B + C;
 14-988 .    D = E + F;
 14-989 . }
 14-990 . 
 14-991 . A = B*C;
 14-992 . 
 14-993 . if (A == B)
 14-994 . {
 14-995 .    A = B + C;
 14-996 .    D = E + F;
 14-997 . }
 14-998 . 
 14-999 . A = B-C;
 14-1000 . 
 14-1001 . if (A <  B)
 14-1002 . {
 14-1003 .    A = B + C;
 14-1004 .    D = E + F;
 14-1005 . }
 14-1006 . 
 14-1007 . 
 14-1008 . if (A lt B)
 14-1009 . {
 14-1010 .    A = B + C;
 14-1011 .    D = E + F;
 14-1012 . }
 14-1013 . 
 14-1014 . A = B*C;
 14-1015 . A = B*C;
 14-1016 . A = B+C;
 14-1017 . A = B*C;
 14-1018 . 
 14-1019 . switch (fdp stuff)
 14-1020 . {
 14-1021 .    case one:
 14-1022 .    {
 14-1023 .       run_this; 
 14-1024 .       break;
 14-1025 .    }
 14-1026 .    case two:
 14-1027 .    {
 14-1028 .       run_this;
 14-1029 .       break;
 14-1030 .    }
 14-1031 .    default:
 14-1032 .    {
 14-1033 .        SwError;
 14-1034 .    }
 14-1035 . }
 14-1036 . 
 14-1037 . A = B*C;
 14-1038 . 
 14-1039 . if (A lt B)
 14-1040 . {
 14-1041 .    A = B + C;
 14-1042 .    D = E + F;
 14-1043 . }
 14-1044 . 
 14-1045 . A = B*C;
 14-1046 . A = B+C;
 14-1047 . A = B-C;
 14-1048 . A = B-C;
 14-1049 . A = B-C;
 14-1050 . 
 14-1051 . if (A le B)
 14-1052 . {
 14-1053 .    A = B + C;
 14-1054 .    D = E + F;
 14-1055 . }
 14-1056 . 
 14-1057 . 
 14-1058 . if (A <  B)
 14-1059 . {
 14-1060 .    A = B + C;
 14-1061 .    D = E + F;
 14-1062 . }
 14-1063 . 
 14-1064 . A = B+C;
 14-1065 . A = B-C;
 14-1066 . A = B-C;
 14-1067 . /* LE SV TOC-1416 this is a fdp-01.7.46 req to reject*/
 14-1068 . A = B/C;
 14-1069 . A = B+C;
 14-1070 . 
 14-1071 . /* dead_block = C * D; 
 14-1072 . dead_block = E * F; */
 14-1073 . 
 14-1074 . 
 14-1075 . if (A >  B)
 14-1076 . {
 14-1077 .    A = B + C;
 14-1078 .    D = E + F;
 14-1079 . }
 14-1080 . 
 14-1081 . A = B*C;
 14-1082 . A = B+C;
 14-1083 . A = B/C;
 14-1084 . A = B*C;
 14-1085 . A = B/C;
 14-1086 . A = B/C;
 14-1087 . A = B+C;
 14-1088 . A = B/C;
 14-1089 . A = B*C;
 14-1090 . A = B/C;
 14-1091 . A = B-C;
 14-1092 . A = B-C;
 14-1093 . A = B*C;
 14-1094 . 
 14-1095 . if (A <  B)
 14-1096 . {
 14-1097 .    A = B + C;
 14-1098 .    D = E + F;
 14-1099 . }
 14-1100 . 
 14-1101 . 
 14-1102 . if (A != B)
 14-1103 . {
 14-1104 .    A = B + C;
 14-1105 .    D = E + F;
 14-1106 . }
 14-1107 . 
 14-1108 . 
 14-1109 . if (veg)
 14-1110 .    // missing curly brace
 14-1111 .    variable = orange;
 14-1112 . 
 14-1113 . 
 14-1114 . if (A ne B)
 14-1115 . {
 14-1116 .    A = B + C;
 14-1117 .    D = E + F;
 14-1118 . }
 14-1119 . 
 14-1120 . A = B*C;
 14-1121 . /* LE SV TOC-1417 this is a fdp-01.7.66 req to recover*/
 14-1122 . 
 14-1123 . if (A ne B)
 14-1124 . {
 14-1125 .    A = B + C;
 14-1126 .    D = E + F;
 14-1127 . }
 14-1128 . 
 14-1129 . // max LOC 66
 14-1130 . 
 14-1131 . }
 14-1132 . 
 14-1133 . 
 14-1134 . /*
 14-1135 . -----------------------------------------------------------------------------
 14-1136 . --| NAME:   fdp.1.8
 14-1137 . --|
 14-1138 . --| ABSTRACT:
 14-1139 . --|   This function does fdp stuff.
 14-1140 . --|
 14-1141 . --| RETURNS:
 14-1142 . --|   NONE.
 14-1143 . --|
 14-1144 . ----------------------------------------------------------------------------
 14-1145 . */
 14-1146 . static void fdp.1.8(void)
 14-1147 . {
 14-1148 . // (P) this is really improtant
 14-1149 . A = B*C;
 14-1150 . 
 14-1151 . if (A >  B)
 14-1152 . {
 14-1153 .    A = B + C;
 14-1154 .    D = E + F;
 14-1155 . }
 14-1156 . 
 14-1157 . A = B-C;
 14-1158 . send_buffer = (U16 *) malloc(size+1);
 14-1159 . 
 14-1160 . if (A gt B)
 14-1161 . {
 14-1162 .    A = B + C;
 14-1163 .    D = E + F;
 14-1164 . }
 14-1165 . 
 14-1166 . 
 14-1167 . switch (fdp stuff)
 14-1168 . {
 14-1169 .    case one:
 14-1170 .    {
 14-1171 .       run_this;
 14-1172 .       break;
 14-1173 .    }
 14-1174 .    case two:
 14-1175 .    {
 14-1176 .       run_this;
 14-1177 .       break;
 14-1178 .    }
 14-1179 .    // missing default
 14-1180 . }
 14-1181 . 
 14-1182 . A = B/C;
 14-1183 . A = B*C;
 14-1184 . A = B-C;
 14-1185 . A = B-C;
 14-1186 . A = B/C;
 14-1187 . A = B+C;
 14-1188 . A = B*C;
 14-1189 . A = B+C;
 14-1190 . // max LOC 12
 14-1191 . 
 14-1192 . }
 14-1193 . 
 14-1194 . 
 14-1195 . /*
 14-1196 . -----------------------------------------------------------------------------
 14-1197 . --| NAME:   fdp.1.9
 14-1198 . --|
 14-1199 . --| ABSTRACT:
 14-1200 . --|   This function does fdp stuff.
 14-1201 . --|
 14-1202 . --| RETURNS:
 14-1203 . --|   NONE.
 14-1204 . --|
 14-1205 . ----------------------------------------------------------------------------
 14-1206 . */
 14-1207 . static void fdp.1.9(void)
 14-1208 . {
 14-1209 . A = B/C;
 14-1210 . A = B/C;
 14-1211 . 
 14-1212 . switch (fdp stuff)
 14-1213 . {
 14-1214 .    case one:
 14-1215 .    {
 14-1216 .       run_this; 
 14-1217 .       break;
 14-1218 .    }
 14-1219 .    case two:
 14-1220 .    {
 14-1221 .       run_this;
 14-1222 .       break;
 14-1223 .    }
 14-1224 .    default:
 14-1225 .    {
 14-1226 .        SwError;
 14-1227 .    }
 14-1228 . }
 14-1229 . 
 14-1230 . A = B-C;
 14-1231 . A = B-C;
 14-1232 . 
 14-1233 . if (A lt B)
 14-1234 . {
 14-1235 .    A = B + C;
 14-1236 .    D = E + F;
 14-1237 . }
 14-1238 . 
 14-1239 . 
 14-1240 . /*
 14-1241 . dead_block = C * D; 
 14-1242 . dead_block = E * F;
 14-1243 . */
 14-1244 . 
 14-1245 . A = B-C;
 14-1246 . 
 14-1247 . if (A != B)
 14-1248 . {
 14-1249 .    A = B + C;
 14-1250 .    D = E + F;
 14-1251 . }
 14-1252 . 
 14-1253 . 
 14-1254 . if (A == B)
 14-1255 . {
 14-1256 .    A = B + C;
 14-1257 .    D = E + F;
 14-1258 . }
 14-1259 . 
 14-1260 . /* LE SV TOC-1418 this is a fdp-01.9.10 req to call isr*/
 14-1261 . A = B*C;
 14-1262 . A = B/C;
 14-1263 . /* LE SV TOC-1419 this is a fdp-01.9.12 req to enable*/
 14-1264 . 
 14-1265 . if (A >  B)
 14-1266 . {
 14-1267 .    A = B + C;
 14-1268 .    D = E + F;
 14-1269 . }
 14-1270 . 
 14-1271 . /* LE SV TOC-1420 this is a fdp-01.9.13 req to recover*/
 14-1272 . A = B+C;
 14-1273 . A = B/C;
 14-1274 . 
 14-1275 . if (A == B)
 14-1276 . {
 14-1277 .    A = B + C;
 14-1278 .    D = E + F;
 14-1279 . }
 14-1280 . 
 14-1281 . 
 14-1282 . if (A le B)
 14-1283 . {
 14-1284 .    A = B + C;
 14-1285 .    D = E + F;
 14-1286 . }
 14-1287 . 
 14-1288 . A = B/C;
 14-1289 . A = B-C;
 14-1290 . A = 0x0007;
 14-1291 . A = B+C;
 14-1292 . A = B+C;
 14-1293 . A = B+C;
 14-1294 . 
 14-1295 . /*
 14-1296 . dead_block = C * D; 
 14-1297 . dead_block = E * F;
 14-1298 . */
 14-1299 . 
 14-1300 . A = B/C;
 14-1301 . A = B/C;
 14-1302 . A = B-C;
 14-1303 . 
 14-1304 . if (A > = B)
 14-1305 . {
 14-1306 .    A = B + C;
 14-1307 .    D = E + F;
 14-1308 . }
 14-1309 . 
 14-1310 . A = B+C;
 14-1311 . 
 14-1312 . if (A gt B)
 14-1313 . {
 14-1314 .    A = B + C;
 14-1315 .    D = E + F;
 14-1316 . }
 14-1317 . 
 14-1318 . /* LE SV TOC-1421 this is a fdp-01.9.28 req to set Real Time Clock*/
 14-1319 . A = B*C;
 14-1320 . 
 14-1321 . /*
 14-1322 . dead_block = C * D; 
 14-1323 . dead_block = E * F;
 14-1324 . */
 14-1325 . 
 14-1326 . 
 14-1327 . if (A eq B)
 14-1328 . {
 14-1329 .    A = B + C;
 14-1330 .    D = E + F;
 14-1331 . }
 14-1332 . 
 14-1333 . A = B/C;
 14-1334 . A = B*C;
 14-1335 . A = B/C;
 14-1336 . A = B-C;
 14-1337 . A = B/C;
 14-1338 . 
 14-1339 . switch (fdp stuff)
 14-1340 . {
 14-1341 .    case one:
 14-1342 .    {
 14-1343 .       run_this; 
 14-1344 .       break;
 14-1345 .    }
 14-1346 .    case two:
 14-1347 .    {
 14-1348 .       run_this;
 14-1349 .       break;
 14-1350 .    }
 14-1351 .    default:
 14-1352 .    {
 14-1353 .        SwError;
 14-1354 .    }
 14-1355 . }
 14-1356 . 
 14-1357 . goto error;
 14-1358 . A = B/C;
 14-1359 . A = B-C;
 14-1360 . 
 14-1361 . if (A gt B)
 14-1362 . {
 14-1363 .    A = B + C;
 14-1364 .    D = E + F;
 14-1365 . }
 14-1366 . 
 14-1367 . A = B-C;
 14-1368 . A = B-C;
 14-1369 . A = B+C;
 14-1370 . A = B+C;
 14-1371 . A = B-C;
 14-1372 . 
 14-1373 . switch (fdp stuff)
 14-1374 . {
 14-1375 .    case one:
 14-1376 .    {
 14-1377 .       run_this; 
 14-1378 .       break;
 14-1379 .    }
 14-1380 .    case two:
 14-1381 .    {
 14-1382 .       run_this;
 14-1383 .       break;
 14-1384 .    }
 14-1385 .    default:
 14-1386 .    {
 14-1387 .        SwError;
 14-1388 .    }
 14-1389 . }
 14-1390 . 
 14-1391 . A = B/C;
 14-1392 . A = B+C;
 14-1393 . A = B-C;
 14-1394 . /* LE SV TOC-1422 this is a fdp-01.9.48 req to store*/
 14-1395 . A = B/C;
 14-1396 . 
 14-1397 . if (A < = B)
 14-1398 . {
 14-1399 .    A = B + C;
 14-1400 .    D = E + F;
 14-1401 . }
 14-1402 . 
 14-1403 . A = B/C;
 14-1404 . 
 14-1405 . if (A == B)
 14-1406 . {
 14-1407 .    A = B + C;
 14-1408 .    D = E + F;
 14-1409 . }
 14-1410 . 
 14-1411 . 
 14-1412 . if (A lt B)
 14-1413 . {
 14-1414 .    A = B + C;
 14-1415 .    D = E + F;
 14-1416 . }
 14-1417 . 
 14-1418 . A = B+C;
 14-1419 . /* LE SV TOC-1423 this is a fdp-01.9.54 req to set RTC*/
 14-1420 . A = B-C;
 14-1421 . A = B*C;
 14-1422 . A = B+C;
 14-1423 . A = B+C;
 14-1424 . A = B+C;
 14-1425 . /* LE SV TOC-1424 this is a fdp-01.9.59 req to fail*/
 14-1426 . A = B*C;
 14-1427 . 
 14-1428 . if (A < = B)
 14-1429 . {
 14-1430 .    A = B + C;
 14-1431 .    D = E + F;
 14-1432 . }
 14-1433 . 
 14-1434 . A = B-C;
 14-1435 . 
 14-1436 . if (A eq B)
 14-1437 . {
 14-1438 .    A = B + C;
 14-1439 .    D = E + F;
 14-1440 . }
 14-1441 . 
 14-1442 . A = B*C;
 14-1443 . A = B/C;
 14-1444 . A = B+C;
 14-1445 . // max LOC 65
 14-1446 . 
 14-1447 . }
 14-1448 . 
 14-1449 . 
 14-1450 . /*
 14-1451 . -----------------------------------------------------------------------------
 14-1452 . --| NAME:   fdp.1.10
 14-1453 . --|
 14-1454 . --| ABSTRACT:
 14-1455 . --|   This function does fdp stuff.
 14-1456 . --|
 14-1457 . --| RETURNS:
 14-1458 . --|   NONE.
 14-1459 . --|
 14-1460 . ----------------------------------------------------------------------------
 14-1461 . */
 14-1462 . static void fdp.1.10(void)
 14-1463 . {
 14-1464 . A = B/C;
 14-1465 . A = B/C;
 14-1466 . A = B*C;
 14-1467 . A = B+C;
 14-1468 . A = B+C;
 14-1469 . 
 14-1470 . switch (fdp stuff)
 14-1471 . {
 14-1472 .    case one:
 14-1473 .    {
 14-1474 .       run_this;
 14-1475 .       break;
 14-1476 .    }
 14-1477 .    case two:
 14-1478 .    {
 14-1479 .       run_this;
 14-1480 .       break;
 14-1481 .    }
 14-1482 .    // missing default
 14-1483 . }
 14-1484 . 
 14-1485 . A = B-C;
 14-1486 . A = B*C;
 14-1487 . A = B+C;
 14-1488 . A = 0x0009;
 14-1489 . 
 14-1490 . if (A ge B)
 14-1491 . {
 14-1492 .    A = B + C;
 14-1493 .    D = E + F;
 14-1494 . }
 14-1495 . 
 14-1496 . A = B/C;
 14-1497 . A = B+C;
 14-1498 . A = B+C;
 14-1499 . 
 14-1500 . if (A < = B)
 14-1501 . {
 14-1502 .    A = B + C;
 14-1503 .    D = E + F;
 14-1504 . }
 14-1505 . 
 14-1506 . A = B/C;
 14-1507 . 
 14-1508 . if (A le B)
 14-1509 . {
 14-1510 .    A = B + C;
 14-1511 .    D = E + F;
 14-1512 . }
 14-1513 . 
 14-1514 . A = B+C;
 14-1515 . 
 14-1516 . if (A > = B)
 14-1517 . {
 14-1518 .    A = B + C;
 14-1519 .    D = E + F;
 14-1520 . }
 14-1521 . 
 14-1522 . 
 14-1523 . if ($fdp stuff >  $otherfdp stuff) 
 14-1524 . /* LE SV TOC-008 we really should log all error calls */
 14-1525 . {
 14-1526 .    A = B + C;
 14-1527 . }
 14-1528 . 
 14-1529 . A = B/C;
 14-1530 . A = B/C;
 14-1531 . // max LOC 19
 14-1532 . 
 14-1533 . }
 14-1534 . 
 14-1535 . 
 14-1536 . /*
 14-1537 . -----------------------------------------------------------------------------
 14-1538 . --| NAME:   fdp.1.11
 14-1539 . --|
 14-1540 . --| ABSTRACT:
 14-1541 . --|   This function does fdp stuff.
 14-1542 . --|
 14-1543 . --| RETURNS:
 14-1544 . --|   NONE.
 14-1545 . --|
 14-1546 . ----------------------------------------------------------------------------
 14-1547 . */
 14-1548 . static void fdp.1.11(void)
 14-1549 . {
 14-1550 . 
 14-1551 . if (A == B)
 14-1552 . {
 14-1553 .    A = B + C;
 14-1554 .    D = E + F;
 14-1555 . }
 14-1556 . 
 14-1557 . A = B-C;
 14-1558 . 
 14-1559 . if (A >  B)
 14-1560 . {
 14-1561 .    A = B + C;
 14-1562 .    D = E + F;
 14-1563 . }
 14-1564 . 
 14-1565 . A = B*C;
 14-1566 . /* LE SV TOC-1425 this is a fdp-01.11.5 req to assign*/
 14-1567 . A = B-C;
 14-1568 . A = B/C;
 14-1569 . A = B+C;
 14-1570 . A = B*C;
 14-1571 . 
 14-1572 . if (A <  B)
 14-1573 . {
 14-1574 .    A = B + C;
 14-1575 .    D = E + F;
 14-1576 . }
 14-1577 . 
 14-1578 . A = B*C;
 14-1579 . A = B*C;
 14-1580 . 
 14-1581 . if (A eq B)
 14-1582 . {
 14-1583 .    A = B + C;
 14-1584 .    D = E + F;
 14-1585 . }
 14-1586 . 
 14-1587 . A = B-C;
 14-1588 . A = B*C;
 14-1589 . 
 14-1590 . if (A != B)
 14-1591 . {
 14-1592 .    A = B + C;
 14-1593 .    D = E + F;
 14-1594 . }
 14-1595 . 
 14-1596 . A = B/C;
 14-1597 . A = B+C;
 14-1598 . A = 0x0001;
 14-1599 . A = B+C;
 14-1600 . A = B-C;
 14-1601 . 
 14-1602 . if (A != B)
 14-1603 . {
 14-1604 .    A = B + C;
 14-1605 .    D = E + F;
 14-1606 . }
 14-1607 . 
 14-1608 . 
 14-1609 . if (A <  B)
 14-1610 . {
 14-1611 .    A = B + C;
 14-1612 .    D = E + F;
 14-1613 . }
 14-1614 . 
 14-1615 . 
 14-1616 . if (A le B)
 14-1617 . {
 14-1618 .    A = B + C;
 14-1619 .    D = E + F;
 14-1620 . }
 14-1621 . 
 14-1622 . A = 0x0007;
 14-1623 . A = B-C;
 14-1624 . 
 14-1625 . if (A ne B)
 14-1626 . {
 14-1627 .    A = B + C;
 14-1628 .    D = E + F;
 14-1629 . }
 14-1630 . 
 14-1631 . A = B*C;
 14-1632 . A = B/C;
 14-1633 . 
 14-1634 . if (A == B)
 14-1635 . {
 14-1636 .    A = B + C;
 14-1637 .    D = E + F;
 14-1638 . }
 14-1639 . 
 14-1640 . A = B-C;
 14-1641 . A = B+C;
 14-1642 . 
 14-1643 . if (A > = B)
 14-1644 . {
 14-1645 .    A = B + C;
 14-1646 .    D = E + F;
 14-1647 . }
 14-1648 . 
 14-1649 . A = B*C;
 14-1650 . A = B*C;
 14-1651 . A = B-C;
 14-1652 . A = B/C;
 14-1653 . A = B/C;
 14-1654 . A = B/C;
 14-1655 . A = B-C;
 14-1656 . 
 14-1657 . if (A <  B)
 14-1658 . {
 14-1659 .    A = B + C;
 14-1660 .    D = E + F;
 14-1661 . }
 14-1662 . 
 14-1663 . A = B-C;
 14-1664 . A = B-C;
 14-1665 . A = B+C;
 14-1666 . 
 14-1667 . switch (fdp stuff)
 14-1668 . {
 14-1669 .    case one:
 14-1670 .    {
 14-1671 .       switch (nested)
 14-1672 .       {
 14-1673 .          case:
 14-1674 .             X = Y + Z;
 14-1675 .          case:
 14-1676 .             X = Y + Z;
 14-1677 .          default:
 14-1678 .             SwError;
 14-1679 .       } 
 14-1680 .    }
 14-1681 .    case two:
 14-1682 .    {
 14-1683 .       run_this;
 14-1684 .       break;
 14-1685 .    }
 14-1686 .    default:
 14-1687 .    {
 14-1688 .       SwError;
 14-1689 .    }
 14-1690 . }
 14-1691 . 
 14-1692 . A = B/C;
 14-1693 . 
 14-1694 . if (A != B)
 14-1695 . {
 14-1696 .    A = B + C;
 14-1697 .    D = E + F;
 14-1698 . }
 14-1699 . 
 14-1700 . A = B-C;
 14-1701 . A = B/C;
 14-1702 . A = B*C;
 14-1703 . 
 14-1704 . if (A >  B)
 14-1705 . {
 14-1706 .    A = B + C;
 14-1707 .    D = E + F;
 14-1708 . }
 14-1709 . 
 14-1710 . A = B-C;
 14-1711 . A = B+C;
 14-1712 . A = 0x0008;
 14-1713 . A = B+C;
 14-1714 . A = B+C;
 14-1715 . A = B/C;
 14-1716 . 
 14-1717 . if (A != B)
 14-1718 . {
 14-1719 .    A = B + C;
 14-1720 .    D = E + F;
 14-1721 . }
 14-1722 . 
 14-1723 . A = B+C;
 14-1724 . 
 14-1725 . if (A > = B)
 14-1726 . {
 14-1727 .    A = B + C;
 14-1728 .    D = E + F;
 14-1729 . }
 14-1730 . 
 14-1731 . 
 14-1732 . if (A ge B)
 14-1733 . {
 14-1734 .    A = B + C;
 14-1735 .    D = E + F;
 14-1736 . }
 14-1737 . 
 14-1738 . A = B-C;
 14-1739 . A = B/C;
 14-1740 . A = B-C;
 14-1741 . A = B-C;
 14-1742 . A = B*C;
 14-1743 . A = B*C;
 14-1744 . A = B/C;
 14-1745 . A = B-C;
 14-1746 . 
 14-1747 . if (A ge B)
 14-1748 . {
 14-1749 .    A = B + C;
 14-1750 .    D = E + F;
 14-1751 . }
 14-1752 . 
 14-1753 . A = B*C;
 14-1754 . A = B*C;
 14-1755 . A = B*C;
 14-1756 . A = B/C;
 14-1757 . A = B/C;
 14-1758 . A = B*C;
 14-1759 . A = B/C;
 14-1760 . 
 14-1761 . if (A lt B)
 14-1762 . {
 14-1763 .    A = B + C;
 14-1764 .    D = E + F;
 14-1765 . }
 14-1766 . 
 14-1767 . // max LOC 73
 14-1768 . 
 14-1769 . }
 14-1770 . 
 14-1771 . 
 14-1772 . /*
 14-1773 . -----------------------------------------------------------------------------
 14-1774 . --| NAME:   fdp.1.12
 14-1775 . --|
 14-1776 . --| ABSTRACT:
 14-1777 . --|   This function does fdp stuff.
 14-1778 . --|
 14-1779 . --| RETURNS:
 14-1780 . --|   NONE.
 14-1781 . --|
 14-1782 . ----------------------------------------------------------------------------
 14-1783 . */
 14-1784 . static void fdp.1.12(void)
 14-1785 . {
 14-1786 . A = B*C;
 14-1787 . A = B/C;
 14-1788 . A = B/C;
 14-1789 . A = B-C;
 14-1790 . 
 14-1791 . if (A eq B)
 14-1792 . {
 14-1793 .    A = B + C;
 14-1794 .    D = E + F;
 14-1795 . }
 14-1796 . 
 14-1797 . A = B/C;
 14-1798 . 
 14-1799 . if (A gt B)
 14-1800 . {
 14-1801 .    A = B + C;
 14-1802 .    D = E + F;
 14-1803 . }
 14-1804 . 
 14-1805 . A = B/C;
 14-1806 . A = B*C;
 14-1807 . 
 14-1808 . if (A > = B)
 14-1809 . {
 14-1810 .    A = B + C;
 14-1811 .    D = E + F;
 14-1812 . }
 14-1813 . 
 14-1814 . 
 14-1815 . switch (fdp stuff)
 14-1816 . {
 14-1817 .    case one:
 14-1818 .    {
 14-1819 .       run_this; 
 14-1820 .       break;
 14-1821 .    }
 14-1822 .    case two:
 14-1823 .    {
 14-1824 .       run_this;
 14-1825 .       break;
 14-1826 .    }
 14-1827 .    default:
 14-1828 .    {
 14-1829 .        SwError;
 14-1830 .    }
 14-1831 . }
 14-1832 . 
 14-1833 . 
 14-1834 . if (A le B)
 14-1835 . {
 14-1836 .    A = B + C;
 14-1837 .    D = E + F;
 14-1838 . }
 14-1839 . 
 14-1840 . A = B+C;
 14-1841 . 
 14-1842 . if (A lt B)
 14-1843 . {
 14-1844 .    A = B + C;
 14-1845 .    D = E + F;
 14-1846 . }
 14-1847 . 
 14-1848 . A = B/C;
 14-1849 . 
 14-1850 . if (A le B)
 14-1851 . {
 14-1852 .    A = B + C;
 14-1853 .    D = E + F;
 14-1854 . }
 14-1855 . 
 14-1856 . 
 14-1857 . switch (fdp stuff)
 14-1858 . {
 14-1859 .    case one:
 14-1860 .    {
 14-1861 .       run_this;
 14-1862 .       break;
 14-1863 .    }
 14-1864 .    case two:
 14-1865 .    {
 14-1866 .       run_this;
 14-1867 .       break;
 14-1868 .    }
 14-1869 .    // missing default
 14-1870 . }
 14-1871 . 
 14-1872 . 
 14-1873 . if (A < = B)
 14-1874 . {
 14-1875 .    A = B + C;
 14-1876 .    D = E + F;
 14-1877 . }
 14-1878 . 
 14-1879 . A = B-C;
 14-1880 . 
 14-1881 . if (A ne B)
 14-1882 . {
 14-1883 .    A = B + C;
 14-1884 .    D = E + F;
 14-1885 . }
 14-1886 . 
 14-1887 . 
 14-1888 . if (A eq B)
 14-1889 . {
 14-1890 .    A = B + C;
 14-1891 .    D = E + F;
 14-1892 . }
 14-1893 . 
 14-1894 . 
 14-1895 . if (A gt B)
 14-1896 . {
 14-1897 .    A = B + C;
 14-1898 .    D = E + F;
 14-1899 . }
 14-1900 . 
 14-1901 . A = B*C;
 14-1902 . 
 14-1903 . if (A lt B)
 14-1904 . {
 14-1905 .    A = B + C;
 14-1906 .    D = E + F;
 14-1907 . }
 14-1908 . 
 14-1909 . 
 14-1910 . switch (fdp stuff)
 14-1911 . {
 14-1912 .       case one:
 14-1913 .    {
 14-1914 .       run_this;
 14-1915 .       break;
 14-1916 .    }
 14-1917 .    case two:
 14-1918 .    {
 14-1919 .       run_this;
 14-1920 .       break;
 14-1921 .    }
 14-1922 .    default:
 14-1923 .    {
 14-1924 .       // missing error call
 14-1925 .    }
 14-1926 . }
 14-1927 . 
 14-1928 . 
 14-1929 . if (A ne B)
 14-1930 . {
 14-1931 .    A = B + C;
 14-1932 .    D = E + F;
 14-1933 . }
 14-1934 . 
 14-1935 . A = B*C;
 14-1936 . A = B+C;
 14-1937 . A = B+C;
 14-1938 . A = B+C;
 14-1939 . 
 14-1940 . if (A gt B)
 14-1941 . {
 14-1942 .    A = B + C;
 14-1943 .    D = E + F;
 14-1944 . }
 14-1945 . 
 14-1946 . A = 0x0003;
 14-1947 . 
 14-1948 . if (A lt B)
 14-1949 . {
 14-1950 .    A = B + C;
 14-1951 .    D = E + F;
 14-1952 . }
 14-1953 . 
 14-1954 . A = B*C;
 14-1955 . A = B-C;
 14-1956 . A = B/C;
 14-1957 . A = B+C;
 14-1958 . A = B-C;
 14-1959 . A = B-C;
 14-1960 . A = B-C;
 14-1961 . 
 14-1962 . if (A le B)
 14-1963 . {
 14-1964 .    A = B + C;
 14-1965 .    D = E + F;
 14-1966 . }
 14-1967 . 
 14-1968 . A = B+C;
 14-1969 . A = B/C;
 14-1970 . /* LE SV TOC-1426 this is a fdp-01.12.41 req to set Real Time Clock*/
 14-1971 . A = 0x0004;
 14-1972 . A = B*C;
 14-1973 . 
 14-1974 . if (A ne B)
 14-1975 . {
 14-1976 .    A = B + C;
 14-1977 .    D = E + F;
 14-1978 . }
 14-1979 . 
 14-1980 . A = B-C;
 14-1981 . A = B-C;
 14-1982 . 
 14-1983 . if (A > = B)
 14-1984 . {
 14-1985 .    A = B + C;
 14-1986 .    D = E + F;
 14-1987 . }
 14-1988 . 
 14-1989 . A = B-C;
 14-1990 . // ??? go see ws
 14-1991 . 
 14-1992 . if (A > = B)
 14-1993 . {
 14-1994 .    A = B + C;
 14-1995 .    D = E + F;
 14-1996 . }
 14-1997 . 
 14-1998 . A = B-C;
 14-1999 . A = B-C;
 14-2000 . A = B/C;
 14-2001 . 
 14-2002 . if (A <  B)
 14-2003 . {
 14-2004 .    A = B + C;
 14-2005 .    D = E + F;
 14-2006 . }
 14-2007 . 
 14-2008 . 
 14-2009 . if (A gt B)
 14-2010 . {
 14-2011 .    A = B + C;
 14-2012 .    D = E + F;
 14-2013 . }
 14-2014 . 
 14-2015 . A = B/C;
 14-2016 . A = B*C;
 14-2017 . A = B/C;
 14-2018 . 
 14-2019 . if (A == B)
 14-2020 . {
 14-2021 .    A = B + C;
 14-2022 .    D = E + F;
 14-2023 . }
 14-2024 . 
 14-2025 . A = B/C;
 14-2026 . 
 14-2027 . if (A ne B)
 14-2028 . {
 14-2029 .    A = B + C;
 14-2030 .    D = E + F;
 14-2031 . }
 14-2032 . 
 14-2033 . A = B*C;
 14-2034 . 
 14-2035 . if (A ge B)
 14-2036 . {
 14-2037 .    A = B + C;
 14-2038 .    D = E + F;
 14-2039 . }
 14-2040 . 
 14-2041 . 
 14-2042 . if (A eq B)
 14-2043 . {
 14-2044 .    A = B + C;
 14-2045 .    D = E + F;
 14-2046 . }
 14-2047 . 
 14-2048 . A = B+C;
 14-2049 . A = B-C;
 14-2050 . A = B+C;
 14-2051 . // max LOC 64
 14-2052 . 
 14-2053 . }
 14-2054 . 
 14-2055 . 
 14-2056 . /*
 14-2057 . -----------------------------------------------------------------------------
 14-2058 . --| NAME:   fdp.1.13
 14-2059 . --|
 14-2060 . --| ABSTRACT:
 14-2061 . --|   This function does fdp stuff.
 14-2062 . --|
 14-2063 . --| RETURNS:
 14-2064 . --|   NONE.
 14-2065 . --|
 14-2066 . ----------------------------------------------------------------------------
 14-2067 . */
 14-2068 . static void fdp.1.13(void)
 14-2069 . {
 14-2070 . 
 14-2071 . if (A ge B)
 14-2072 . {
 14-2073 .    A = B + C;
 14-2074 .    D = E + F;
 14-2075 . }
 14-2076 . 
 14-2077 . 
 14-2078 . if (A > = B)
 14-2079 . {
 14-2080 .    A = B + C;
 14-2081 .    D = E + F;
 14-2082 . }
 14-2083 . 
 14-2084 . A = B-C;
 14-2085 . A = B-C;
 14-2086 . A = B*C;
 14-2087 . /* LE SV TOC-1427 this is a fdp-01.13.6 req to transform*/
 14-2088 . A = B*C;
 14-2089 . A = B*C;
 14-2090 . A = B*C;
 14-2091 . A = B/C;
 14-2092 . A = B*C;
 14-2093 . A = B+C;
 14-2094 . A = B+C;
 14-2095 . 
 14-2096 . if {
 14-2097 .    X = Y + Z;
 14-2098 . }
 14-2099 . else {
 14-2100 .    halt;
 14-2101 . }
 14-2102 . 
 14-2103 . A = B*C;
 14-2104 . A = B*C;
 14-2105 . A = B+C;
 14-2106 . A = B+C;
 14-2107 . A = 0x0002;
 14-2108 . 
 14-2109 . /* dead_code = B + C; 
 14-2110 . dead_code = D + E; 
 14-2111 . dead_code = F + G; */
 14-2112 . 
 14-2113 . A = B-C;
 14-2114 . A = B*C;
 14-2115 . 
 14-2116 . if (A ge B)
 14-2117 . {
 14-2118 .    A = B + C;
 14-2119 .    D = E + F;
 14-2120 . }
 14-2121 . 
 14-2122 . 
 14-2123 . switch (fdp stuff)
 14-2124 . {
 14-2125 .    case:
 14-2126 .    case:
 14-2127 .    // stacked case statements but only if there is a new line in between
 14-2128 . 
 14-2129 .    case:
 14-2130 .    case:
 14-2131 .    case:
 14-2132 .    {
 14-2133 .       run_this;
 14-2134 .       break;
 14-2135 .    }
 14-2136 .    default:
 14-2137 .    {
 14-2138 .       halt;
 14-2139 .    }
 14-2140 . }
 14-2141 . 
 14-2142 . A = B*C;
 14-2143 . A = B*C;
 14-2144 . A = B*C;
 14-2145 . A = B-C;
 14-2146 . A = 0x0002;
 14-2147 . A = B+C;
 14-2148 . A = B*C;
 14-2149 . 
 14-2150 . if (A != B)
 14-2151 . {
 14-2152 .    A = B + C;
 14-2153 .    D = E + F;
 14-2154 . }
 14-2155 . 
 14-2156 . A = B-C;
 14-2157 . A = B*C;
 14-2158 . A = B*C;
 14-2159 . 
 14-2160 . if (A le B)
 14-2161 . {
 14-2162 .    A = B + C;
 14-2163 .    D = E + F;
 14-2164 . }
 14-2165 . 
 14-2166 . A = B-C;
 14-2167 . 
 14-2168 . if (A ne B)
 14-2169 . {
 14-2170 .    A = B + C;
 14-2171 .    D = E + F;
 14-2172 . }
 14-2173 . 
 14-2174 . 
 14-2175 . if (A lt B)
 14-2176 . {
 14-2177 .    A = B + C;
 14-2178 .    D = E + F;
 14-2179 . }
 14-2180 . 
 14-2181 . A = B+C;
 14-2182 . A = B+C;
 14-2183 . A = B-C;
 14-2184 . A = B+C;
 14-2185 . A = B/C;
 14-2186 . A = B*C;
 14-2187 . A = B+C;
 14-2188 . A = B*C;
 14-2189 . A = B*C;
 14-2190 . A = B/C;
 14-2191 . A = B-C;
 14-2192 . 
 14-2193 . if (A ne B)
 14-2194 . {
 14-2195 .    A = B + C;
 14-2196 .    D = E + F;
 14-2197 . }
 14-2198 . 
 14-2199 . 
 14-2200 . if {
 14-2201 .    X = Y + Z;
 14-2202 . }
 14-2203 . else {
 14-2204 .    halt;
 14-2205 . }
 14-2206 . 
 14-2207 . A = B/C;
 14-2208 . A = B/C;
 14-2209 . 
 14-2210 . if (A != B)
 14-2211 . {
 14-2212 .    A = B + C;
 14-2213 .    D = E + F;
 14-2214 . }
 14-2215 . 
 14-2216 . A = B+C;
 14-2217 . A = B+C;
 14-2218 . 
 14-2219 . if (A ge B)
 14-2220 . {
 14-2221 .    A = B + C;
 14-2222 .    D = E + F;
 14-2223 . }
 14-2224 . 
 14-2225 . A = B/C;
 14-2226 . A = B*C;
 14-2227 . A = B*C;
 14-2228 . A = B/C;
 14-2229 . 
 14-2230 . if (A ne B)
 14-2231 . {
 14-2232 .    A = B + C;
 14-2233 .    D = E + F;
 14-2234 . }
 14-2235 . 
 14-2236 . 
 14-2237 . switch (fdp stuff)
 14-2238 . {
 14-2239 .       case one:
 14-2240 .    {
 14-2241 .       run_this;
 14-2242 .       break;
 14-2243 .    }
 14-2244 .    case two:
 14-2245 .    {
 14-2246 .       run_this;
 14-2247 .       break;
 14-2248 .    }
 14-2249 .    default:
 14-2250 .    {
 14-2251 .       // missing error call
 14-2252 .    }
 14-2253 . }
 14-2254 . 
 14-2255 . A = B+C;
 14-2256 . 
 14-2257 . switch (fdp stuff)
 14-2258 . {
 14-2259 .       case one:
 14-2260 .    {
 14-2261 .       run_this;
 14-2262 .       break;
 14-2263 .    }
 14-2264 .    case two:
 14-2265 .    {
 14-2266 .       run_this;
 14-2267 .       break;
 14-2268 .    }
 14-2269 .    default:
 14-2270 .    {
 14-2271 .       // missing error call
 14-2272 .    }
 14-2273 . }
 14-2274 . 
 14-2275 . A = B*C;
 14-2276 . A = B*C;
 14-2277 . 
 14-2278 . if (A le B)
 14-2279 . {
 14-2280 .    A = B + C;
 14-2281 .    D = E + F;
 14-2282 . }
 14-2283 . 
 14-2284 . A = B/C;
 14-2285 . 
 14-2286 . if (A == B)
 14-2287 . {
 14-2288 .    A = B + C;
 14-2289 .    D = E + F;
 14-2290 . }
 14-2291 . 
 14-2292 . A = B*C;
 14-2293 . A = B+C;
 14-2294 . A = B-C;
 14-2295 . A = B-C;
 14-2296 . A = B/C;
 14-2297 . 
 14-2298 . if (A eq B)
 14-2299 . {
 14-2300 .    A = B + C;
 14-2301 .    D = E + F;
 14-2302 . }
 14-2303 . 
 14-2304 . /* LE SV TOC-1428 this is a fdp-01.13.69 req to check pSOS*/
 14-2305 . 
 14-2306 . if (A ne B)
 14-2307 . {
 14-2308 .    A = B + C;
 14-2309 .    D = E + F;
 14-2310 . }
 14-2311 . 
 14-2312 . A = B+C;
 14-2313 . A = B+C;
 14-2314 . A = B/C;
 14-2315 . A = B+C;
 14-2316 . 
 14-2317 . if {
 14-2318 .    X = Y + Z;
 14-2319 . }
 14-2320 . else {
 14-2321 .    halt;
 14-2322 . }
 14-2323 . 
 14-2324 . 
 14-2325 . if (A lt B)
 14-2326 . {
 14-2327 .    A = B + C;
 14-2328 .    D = E + F;
 14-2329 . }
 14-2330 . 
 14-2331 . 
 14-2332 . if (A eq B)
 14-2333 . {
 14-2334 .    A = B + C;
 14-2335 .    D = E + F;
 14-2336 . }
 14-2337 . 
 14-2338 . A = B+C;
 14-2339 . A = B-C;
 14-2340 . 
 14-2341 . if (A < = B)
 14-2342 . {
 14-2343 .    A = B + C;
 14-2344 .    D = E + F;
 14-2345 . }
 14-2346 . 
 14-2347 . // max LOC 78
 14-2348 . 
 14-2349 . }
 14-2350 . 
 14-2351 . 
 14-2352 . /*
 14-2353 . -----------------------------------------------------------------------------
 14-2354 . --| NAME:   fdp.1.14
 14-2355 . --|
 14-2356 . --| ABSTRACT:
 14-2357 . --|   This function does fdp stuff.
 14-2358 . --|
 14-2359 . --| RETURNS:
 14-2360 . --|   NONE.
 14-2361 . --|
 14-2362 . ----------------------------------------------------------------------------
 14-2363 . */
 14-2364 . static void fdp.1.14(void)
 14-2365 . {
 14-2366 . 
 14-2367 . if (A >  B)
 14-2368 . {
 14-2369 .    A = B + C;
 14-2370 .    D = E + F;
 14-2371 . }
 14-2372 . 
 14-2373 . A = B/C;
 14-2374 . A = B*C;
 14-2375 . 
 14-2376 . if (A <  B)
 14-2377 . {
 14-2378 .    A = B + C;
 14-2379 .    D = E + F;
 14-2380 . }
 14-2381 . 
 14-2382 . A = B/C;
 14-2383 . A = B-C;
 14-2384 . A = B*C;
 14-2385 . A = B*C;
 14-2386 . 
 14-2387 . if (A gt B)
 14-2388 . {
 14-2389 .    A = B + C;
 14-2390 .    D = E + F;
 14-2391 . }
 14-2392 . 
 14-2393 . 
 14-2394 . if (A <  B)
 14-2395 . {
 14-2396 .    A = B + C;
 14-2397 .    D = E + F;
 14-2398 . }
 14-2399 . 
 14-2400 . A = B-C;
 14-2401 . /* LE SV TOC-1429 this is a fdp-01.14.12 req to reject*/
 14-2402 . A = B+C;
 14-2403 . free(FreePtr);
 14-2404 . A = B+C;
 14-2405 . A = B/C;
 14-2406 . 
 14-2407 . if (A != B)
 14-2408 . {
 14-2409 .    A = B + C;
 14-2410 .    D = E + F;
 14-2411 . }
 14-2412 . 
 14-2413 . A = B+C;
 14-2414 . A = B-C;
 14-2415 . A = B*C;
 14-2416 . A = B+C;
 14-2417 . // max LOC 19
 14-2418 . 
 14-2419 . }
 14-2420 . 

14 14 Result: result/source/ft-app/ft-app-B1.1/fdp/fdp-01.c


15 15 Source: source/ft-app/ft-app-B1.1/fdp/fdp-02.c
 15-0 . /*
 15-1 . ----------------------------------------------------------------------------
 15-2 . --| BEGIN PROLOGUE
 15-3 . --|
 15-4 . --| CLASSIFICATION: UNCLASSIFIED
 15-5 . --|
 15-6 . --| FILE NAME:      fdp-02.c
 15-7 . --|
 15-8 . --| ABSTRACT:
 15-9 . --|   This file contains the 10 functions that do file fdp stuff.
 15-10 . --|
 15-11 . --| HISTORY:
 15-12 . --|   CCCQ_NAME:
 15-13 . --|   CCCQ_VER: 
 15-14 . --|
 15-15 . --| END PROLOGUE
 15-16 . ----------------------------------------------------------------------------
 15-17 . */
 15-18 . 
 15-19 . #include D;
 15-20 . #include D;
 15-21 . #include D;
 15-22 . #include A;
 15-23 . #define B;
 15-24 . #include A;
 15-25 . float B;
 15-26 . 
 15-27 . 
 15-28 . 
 15-29 . /*
 15-30 . -----------------------------------------------------------------------------
 15-31 . --| NAME:   fdp.2.1
 15-32 . --|
 15-33 . --| ABSTRACT:
 15-34 . --|   This function does fdp stuff.
 15-35 . --|
 15-36 . --| RETURNS:
 15-37 . --|   NONE.
 15-38 . --|
 15-39 . ----------------------------------------------------------------------------
 15-40 . */
 15-41 . static void fdp.2.1(void)
 15-42 . {
 15-43 . 
 15-44 . if (veg)
 15-45 .    // missing curly brace
 15-46 .    variable = orange;
 15-47 . 
 15-48 . 
 15-49 . if (A ne B)
 15-50 . {
 15-51 .    A = B + C;
 15-52 .    D = E + F;
 15-53 . }
 15-54 . 
 15-55 . // TBD - what do I do now
 15-56 . A = B-C;
 15-57 . 
 15-58 . if (A <  B)
 15-59 . {
 15-60 .    A = B + C;
 15-61 .    D = E + F;
 15-62 . }
 15-63 . 
 15-64 . A = B+C;
 15-65 . 
 15-66 . if (A ne B)
 15-67 . {
 15-68 .    A = B + C;
 15-69 .    D = E + F;
 15-70 . }
 15-71 . 
 15-72 . 
 15-73 . if (A < = B)
 15-74 . {
 15-75 .    A = B + C;
 15-76 .    D = E + F;
 15-77 . }
 15-78 . 
 15-79 . 
 15-80 . if (A le B)
 15-81 . {
 15-82 .    A = B + C;
 15-83 .    D = E + F;
 15-84 . }
 15-85 . 
 15-86 . A = B+C;
 15-87 . A = B*C;
 15-88 . A = B/C;
 15-89 . A = B-C;
 15-90 . 
 15-91 . if (A lt B)
 15-92 . {
 15-93 .    A = B + C;
 15-94 .    D = E + F;
 15-95 . }
 15-96 . 
 15-97 . A = B*C;
 15-98 . 
 15-99 . if (A ge B)
 15-100 . {
 15-101 .    A = B + C;
 15-102 .    D = E + F;
 15-103 . }
 15-104 . 
 15-105 . 
 15-106 . if (A >  B)
 15-107 . {
 15-108 .    A = B + C;
 15-109 .    D = E + F;
 15-110 . }
 15-111 . 
 15-112 . A = B/C;
 15-113 . 
 15-114 . /*
 15-115 . dead_block = C * D; 
 15-116 . dead_block = E * F;
 15-117 . */
 15-118 . 
 15-119 . 
 15-120 . if (A lt B)
 15-121 . {
 15-122 .    A = B + C;
 15-123 .    D = E + F;
 15-124 . }
 15-125 . 
 15-126 . 
 15-127 . /* dead_code = B + C; 
 15-128 . dead_code = D + E; 
 15-129 . dead_code = F + G; */
 15-130 . 
 15-131 . A = B+C;
 15-132 . A = B+C;
 15-133 . 
 15-134 . /*
 15-135 . dead_block = C * D; 
 15-136 . dead_block = E * F;
 15-137 . */
 15-138 . 
 15-139 . A = B*C;
 15-140 . A = B-C;
 15-141 . A = B-C;
 15-142 . A = B+C;
 15-143 . A = B*C;
 15-144 . A = B+C;
 15-145 . A = B/C;
 15-146 . A = B*C;
 15-147 . A = B-C;
 15-148 . A = B/C;
 15-149 . // max LOC 29
 15-150 . 
 15-151 . }
 15-152 . 
 15-153 . 
 15-154 . /*
 15-155 . -----------------------------------------------------------------------------
 15-156 . --| NAME:   fdp.2.2
 15-157 . --|
 15-158 . --| ABSTRACT:
 15-159 . --|   This function does fdp stuff.
 15-160 . --|
 15-161 . --| RETURNS:
 15-162 . --|   NONE.
 15-163 . --|
 15-164 . ----------------------------------------------------------------------------
 15-165 . */
 15-166 . static void fdp.2.2(void)
 15-167 . {
 15-168 . A = B-C;
 15-169 . A = B/C;
 15-170 . A = B-C;
 15-171 . 
 15-172 . if (A >  B)
 15-173 . {
 15-174 .    A = B + C;
 15-175 .    D = E + F;
 15-176 . }
 15-177 . 
 15-178 . A = B*C;
 15-179 . 
 15-180 . if (A eq B)
 15-181 . {
 15-182 .    A = B + C;
 15-183 .    D = E + F;
 15-184 . }
 15-185 . 
 15-186 . A = 0x0006;
 15-187 . A = B-C;
 15-188 . A = B*C;
 15-189 . A = B*C;
 15-190 . A = B*C;
 15-191 . A = B+C;
 15-192 . A = B+C;
 15-193 . /* LE SV TOC-1430 this is a fdp-02.2.13 req to store*/
 15-194 . A = B-C;
 15-195 . 
 15-196 . if (A >  B)
 15-197 . {
 15-198 .    A = B + C;
 15-199 .    D = E + F;
 15-200 . }
 15-201 . 
 15-202 . FreePtr = HmiStringPtr;
 15-203 . 
 15-204 . if (A < = B)
 15-205 . {
 15-206 .    A = B + C;
 15-207 .    D = E + F;
 15-208 . }
 15-209 . 
 15-210 . 
 15-211 . if (A != B)
 15-212 . {
 15-213 .    A = B + C;
 15-214 .    D = E + F;
 15-215 . }
 15-216 . 
 15-217 . 
 15-218 . if (A > = B)
 15-219 . {
 15-220 .    A = B + C;
 15-221 .    D = E + F;
 15-222 . }
 15-223 . 
 15-224 . 
 15-225 . if (A == B)
 15-226 . {
 15-227 .    A = B + C;
 15-228 .    D = E + F;
 15-229 . }
 15-230 . 
 15-231 . 
 15-232 . if (A gt B)
 15-233 . {
 15-234 .    A = B + C;
 15-235 .    D = E + F;
 15-236 . }
 15-237 . 
 15-238 . 
 15-239 . if (A ne B)
 15-240 . {
 15-241 .    A = B + C;
 15-242 .    D = E + F;
 15-243 . }
 15-244 . 
 15-245 . A = B/C;
 15-246 . // TBS - I need to figure this out
 15-247 . 
 15-248 . if (A != B)
 15-249 . {
 15-250 .    A = B + C;
 15-251 .    D = E + F;
 15-252 . }
 15-253 . 
 15-254 . A = B/C;
 15-255 . 
 15-256 . if (A lt B)
 15-257 . {
 15-258 .    A = B + C;
 15-259 .    D = E + F;
 15-260 . }
 15-261 . 
 15-262 . A = B+C;
 15-263 . 
 15-264 . if (A == B)
 15-265 . {
 15-266 .    A = B + C;
 15-267 .    D = E + F;
 15-268 . }
 15-269 . 
 15-270 . 
 15-271 . if (A <  B)
 15-272 . {
 15-273 .    A = B + C;
 15-274 .    D = E + F;
 15-275 . }
 15-276 . 
 15-277 . A = B-C;
 15-278 . A = B+C;
 15-279 . 
 15-280 . if (A <  B)
 15-281 . {
 15-282 .    A = B + C;
 15-283 .    D = E + F;
 15-284 . }
 15-285 . 
 15-286 . /* LE SV TOC-1431 this is a fdp-02.2.31 req to check unix*/
 15-287 . A = B/C;
 15-288 . 
 15-289 . if (A == B)
 15-290 . {
 15-291 .    A = B + C;
 15-292 .    D = E + F;
 15-293 . }
 15-294 . 
 15-295 . // max LOC 32
 15-296 . 
 15-297 . }
 15-298 . 
 15-299 . 
 15-300 . /*
 15-301 . -----------------------------------------------------------------------------
 15-302 . --| NAME:   fdp.2.3
 15-303 . --|
 15-304 . --| ABSTRACT:
 15-305 . --|   This function does fdp stuff.
 15-306 . --|
 15-307 . --| RETURNS:
 15-308 . --|   NONE.
 15-309 . --|
 15-310 . ----------------------------------------------------------------------------
 15-311 . */
 15-312 . static void fdp.2.3(void)
 15-313 . {
 15-314 . A = B+C;
 15-315 . 
 15-316 . switch (fdp stuff)
 15-317 . {
 15-318 .    case one:
 15-319 .    {
 15-320 .       run_this; 
 15-321 .       break;
 15-322 .    }
 15-323 .    case two:
 15-324 .    {
 15-325 .       run_this;
 15-326 .       break;
 15-327 .    }
 15-328 .    default:
 15-329 .    {
 15-330 .        SwError;
 15-331 .    }
 15-332 . }
 15-333 . 
 15-334 . A = B*C;
 15-335 . A = B-C;
 15-336 . A = B+C;
 15-337 . A = B/C;
 15-338 . 
 15-339 . if (A < = B)
 15-340 . {
 15-341 .    A = B + C;
 15-342 .    D = E + F;
 15-343 . }
 15-344 . 
 15-345 . A = B*C;
 15-346 . A = B*C;
 15-347 . 
 15-348 . if (A le B)
 15-349 . {
 15-350 .    A = B + C;
 15-351 .    D = E + F;
 15-352 . }
 15-353 . 
 15-354 . A = B+C;
 15-355 . 
 15-356 . if (A <  B)
 15-357 . {
 15-358 .    A = B + C;
 15-359 .    D = E + F;
 15-360 . }
 15-361 . 
 15-362 . A = B/C;
 15-363 . A = B/C;
 15-364 . /* dead_code = A * B; */
 15-365 . 
 15-366 . if (A ne B)
 15-367 . {
 15-368 .    A = B + C;
 15-369 .    D = E + F;
 15-370 . }
 15-371 . 
 15-372 . 
 15-373 . if (A lt B)
 15-374 . {
 15-375 .    A = B + C;
 15-376 .    D = E + F;
 15-377 . }
 15-378 . 
 15-379 . A = B+C;
 15-380 . A = B*C;
 15-381 . 
 15-382 . if (A lt B)
 15-383 . {
 15-384 .    A = B + C;
 15-385 .    D = E + F;
 15-386 . }
 15-387 . 
 15-388 . A = B*C;
 15-389 . A = B+C;
 15-390 . A = B+C;
 15-391 . A = B+C;
 15-392 . A = B/C;
 15-393 . 
 15-394 . switch (fdp stuff)
 15-395 . {
 15-396 .    case one:
 15-397 .    {
 15-398 .       run_this; 
 15-399 .       break;
 15-400 .    }
 15-401 .    case two:
 15-402 .    {
 15-403 .       run_this;
 15-404 .       break;
 15-405 .    }
 15-406 .    default:
 15-407 .    {
 15-408 .        SwError;
 15-409 .    }
 15-410 . }
 15-411 . 
 15-412 . A = B+C;
 15-413 . A = B+C;
 15-414 . A = B/C;
 15-415 . A = B-C;
 15-416 . 
 15-417 . if (A != B)
 15-418 . {
 15-419 .    A = B + C;
 15-420 .    D = E + F;
 15-421 . }
 15-422 . 
 15-423 . A = B*C;
 15-424 . A = B-C;
 15-425 . A = 0x0002;
 15-426 . A = B-C;
 15-427 . 
 15-428 . if (A != B)
 15-429 . {
 15-430 .    A = B + C;
 15-431 .    D = E + F;
 15-432 . }
 15-433 . 
 15-434 . A = B+C;
 15-435 . A = B/C;
 15-436 . // max LOC 36
 15-437 . 
 15-438 . }
 15-439 . 
 15-440 . 
 15-441 . /*
 15-442 . -----------------------------------------------------------------------------
 15-443 . --| NAME:   fdp.2.4
 15-444 . --|
 15-445 . --| ABSTRACT:
 15-446 . --|   This function does fdp stuff.
 15-447 . --|
 15-448 . --| RETURNS:
 15-449 . --|   NONE.
 15-450 . --|
 15-451 . ----------------------------------------------------------------------------
 15-452 . */
 15-453 . static void fdp.2.4(void)
 15-454 . {
 15-455 . A = B*C;
 15-456 . A = B*C;
 15-457 . A = B*C;
 15-458 . A = B-C;
 15-459 . A = B*C;
 15-460 . 
 15-461 . if (A ne B)
 15-462 . {
 15-463 .    A = B + C;
 15-464 .    D = E + F;
 15-465 . }
 15-466 . 
 15-467 . 
 15-468 . if (A >  B)
 15-469 . {
 15-470 .    A = B + C;
 15-471 .    D = E + F;
 15-472 . }
 15-473 . 
 15-474 . 
 15-475 . if (A eq B)
 15-476 . {
 15-477 .    A = B + C;
 15-478 .    D = E + F;
 15-479 . }
 15-480 . 
 15-481 . A = B/C;
 15-482 . 
 15-483 . if (A le B)
 15-484 . {
 15-485 .    A = B + C;
 15-486 .    D = E + F;
 15-487 . }
 15-488 . 
 15-489 . 
 15-490 . switch (fdp stuff)
 15-491 . {
 15-492 .    case one:
 15-493 .    {
 15-494 .       run_this; 
 15-495 .       break;
 15-496 .    }
 15-497 .    case two:
 15-498 .    {
 15-499 .       run_this;
 15-500 .       break;
 15-501 .    }
 15-502 .    default:
 15-503 .    {
 15-504 .        SwError;
 15-505 .    }
 15-506 . }
 15-507 . 
 15-508 . 
 15-509 . switch (fdp stuff)
 15-510 . {
 15-511 .    case one:
 15-512 .    {
 15-513 .       run_this; 
 15-514 .       break;
 15-515 .    }
 15-516 .    case two:
 15-517 .    {
 15-518 .       run_this;
 15-519 .       break;
 15-520 .    }
 15-521 .    default:
 15-522 .    {
 15-523 .        SwError;
 15-524 .    }
 15-525 . }
 15-526 . 
 15-527 . A = B-C;
 15-528 . 
 15-529 . if (A ne B)
 15-530 . {
 15-531 .    A = B + C;
 15-532 .    D = E + F;
 15-533 . }
 15-534 . 
 15-535 . A = B+C;
 15-536 . A = B/C;
 15-537 . 
 15-538 . if ($fdp stuff >  $otherfdp stuff) 
 15-539 . /* LE SV TOC-008 we really should log all error calls */
 15-540 . {
 15-541 .    A = B + C;
 15-542 . }
 15-543 . 
 15-544 . 
 15-545 . if (A le B)
 15-546 . {
 15-547 .    A = B + C;
 15-548 .    D = E + F;
 15-549 . }
 15-550 . 
 15-551 . // max LOC 17
 15-552 . 
 15-553 . }
 15-554 . 
 15-555 . 
 15-556 . /*
 15-557 . -----------------------------------------------------------------------------
 15-558 . --| NAME:   fdp.2.5
 15-559 . --|
 15-560 . --| ABSTRACT:
 15-561 . --|   This function does fdp stuff.
 15-562 . --|
 15-563 . --| RETURNS:
 15-564 . --|   NONE.
 15-565 . --|
 15-566 . ----------------------------------------------------------------------------
 15-567 . */
 15-568 . static void fdp.2.5(void)
 15-569 . {
 15-570 . rcv_buffer = (U16 *) alloc(size+1);
 15-571 . A = B+C;
 15-572 . 
 15-573 . switch (fdp stuff)
 15-574 . {
 15-575 .    case one:
 15-576 .    {
 15-577 .       run_this; 
 15-578 .       break;
 15-579 .    }
 15-580 .    case two:
 15-581 .    {
 15-582 .       run_this;
 15-583 .       break;
 15-584 .    }
 15-585 .    default:
 15-586 .    {
 15-587 .        SwError;
 15-588 .    }
 15-589 . }
 15-590 . 
 15-591 . A = B*C;
 15-592 . A = B*C;
 15-593 . 
 15-594 . if (A == B)
 15-595 . {
 15-596 .    A = B + C;
 15-597 .    D = E + F;
 15-598 . }
 15-599 . 
 15-600 . 
 15-601 . if (A > = B)
 15-602 . {
 15-603 .    A = B + C;
 15-604 .    D = E + F;
 15-605 . }
 15-606 . 
 15-607 . A = B+C;
 15-608 . 
 15-609 . switch (fdp stuff)
 15-610 . {
 15-611 .    case one:
 15-612 .    {
 15-613 .       run_this; 
 15-614 .       break;
 15-615 .    }
 15-616 .    case two:
 15-617 .    {
 15-618 .       run_this;
 15-619 .       break;
 15-620 .    }
 15-621 .    default:
 15-622 .    {
 15-623 .        SwError;
 15-624 .    }
 15-625 . }
 15-626 . 
 15-627 . 
 15-628 . if (A < = B)
 15-629 . {
 15-630 .    A = B + C;
 15-631 .    D = E + F;
 15-632 . }
 15-633 . 
 15-634 . 
 15-635 . if (A == B)
 15-636 . {
 15-637 .    A = B + C;
 15-638 .    D = E + F;
 15-639 . }
 15-640 . 
 15-641 . A = B+C;
 15-642 . A = B-C;
 15-643 . A = B/C;
 15-644 . 
 15-645 . if (A <  B)
 15-646 . {
 15-647 .    A = B + C;
 15-648 .    D = E + F;
 15-649 . }
 15-650 . 
 15-651 . A = B+C;
 15-652 . 
 15-653 . if (A lt B)
 15-654 . {
 15-655 .    A = B + C;
 15-656 .    D = E + F;
 15-657 . }
 15-658 . 
 15-659 . A = B-C;
 15-660 . A = B*C;
 15-661 . 
 15-662 . if (A gt B)
 15-663 . {
 15-664 .    A = B + C;
 15-665 .    D = E + F;
 15-666 . }
 15-667 . 
 15-668 . A = B+C;
 15-669 . A = B/C;
 15-670 . /* LE SV TOC-1432 this is a fdp-02.5.22 req to update*/
 15-671 . A = B*C;
 15-672 . A = B/C;
 15-673 . A = B+C;
 15-674 . 
 15-675 . if (A > = B)
 15-676 . {
 15-677 .    A = B + C;
 15-678 .    D = E + F;
 15-679 . }
 15-680 . 
 15-681 . A = B+C;
 15-682 . A = B+C;
 15-683 . A = B*C;
 15-684 . A = B/C;
 15-685 . 
 15-686 . /* dead_code = B + C; 
 15-687 . dead_code = D + E; 
 15-688 . dead_code = F + G; */
 15-689 . 
 15-690 . A = B-C;
 15-691 . /* LE SV TOC-1433 this is a fdp-02.5.31 req to translate*/
 15-692 . 
 15-693 . if (A ne B)
 15-694 . {
 15-695 .    A = B + C;
 15-696 .    D = E + F;
 15-697 . }
 15-698 . 
 15-699 . A = B+C;
 15-700 . 
 15-701 . if (A ge B)
 15-702 . {
 15-703 .    A = B + C;
 15-704 .    D = E + F;
 15-705 . }
 15-706 . 
 15-707 . /* dead_code = A * B; */
 15-708 . A = B*C;
 15-709 . 
 15-710 . if (A > = B)
 15-711 . {
 15-712 .    A = B + C;
 15-713 .    D = E + F;
 15-714 . }
 15-715 . 
 15-716 . A = B*C;
 15-717 . A = B+C;
 15-718 . 
 15-719 . if (A != B)
 15-720 . {
 15-721 .    A = B + C;
 15-722 .    D = E + F;
 15-723 . }
 15-724 . 
 15-725 . 
 15-726 . if (A >  B)
 15-727 . {
 15-728 .    A = B + C;
 15-729 .    D = E + F;
 15-730 . }
 15-731 . 
 15-732 . 
 15-733 . #ifdef LAZY
 15-734 .    // this is not nice
 15-735 .    A = B + C;
 15-736 .    A = B + C;
 15-737 . #endif
 15-738 . 
 15-739 . A = B+C;
 15-740 . A = B*C;
 15-741 . 
 15-742 . if (A <  B)
 15-743 . {
 15-744 .    A = B + C;
 15-745 .    D = E + F;
 15-746 . }
 15-747 . 
 15-748 . 
 15-749 . if (A == B)
 15-750 . {
 15-751 .    A = B + C;
 15-752 .    D = E + F;
 15-753 . }
 15-754 . 
 15-755 . /* LE SV TOC-1434 this is a fdp-02.5.44 req to record*/
 15-756 . A = B+C;
 15-757 . free(FreePtr);
 15-758 . A = B/C;
 15-759 . A = B-C;
 15-760 . A = B*C;
 15-761 . A = B*C;
 15-762 . A = B*C;
 15-763 . 
 15-764 . if (A <  B)
 15-765 . {
 15-766 .    A = B + C;
 15-767 .    D = E + F;
 15-768 . }
 15-769 . 
 15-770 . A = B*C;
 15-771 . 
 15-772 . if (A == B)
 15-773 . {
 15-774 .    A = B + C;
 15-775 .    D = E + F;
 15-776 . }
 15-777 . 
 15-778 . 
 15-779 . if (A ge B)
 15-780 . {
 15-781 .    A = B + C;
 15-782 .    D = E + F;
 15-783 . }
 15-784 . 
 15-785 . A = B/C;
 15-786 . /* LE SV TOC-1435 this is a fdp-02.5.55 req to increment*/
 15-787 . A = B/C;
 15-788 . // max LOC 55
 15-789 . 
 15-790 . }
 15-791 . 
 15-792 . 
 15-793 . /*
 15-794 . -----------------------------------------------------------------------------
 15-795 . --| NAME:   fdp.2.6
 15-796 . --|
 15-797 . --| ABSTRACT:
 15-798 . --|   This function does fdp stuff.
 15-799 . --|
 15-800 . --| RETURNS:
 15-801 . --|   NONE.
 15-802 . --|
 15-803 . ----------------------------------------------------------------------------
 15-804 . */
 15-805 . static void fdp.2.6(void)
 15-806 . {
 15-807 . A = B*C;
 15-808 . 
 15-809 . if (A != B)
 15-810 . {
 15-811 .    A = B + C;
 15-812 .    D = E + F;
 15-813 . }
 15-814 . 
 15-815 . A = B-C;
 15-816 . FreePtr = HmiStringPtr;
 15-817 . 
 15-818 . if (A ge B)
 15-819 . {
 15-820 .    A = B + C;
 15-821 .    D = E + F;
 15-822 . }
 15-823 . 
 15-824 . A = B/C;
 15-825 . A = B/C;
 15-826 . 
 15-827 . switch (fdp stuff)
 15-828 . {
 15-829 .    case one:
 15-830 .    {
 15-831 .       run_this; 
 15-832 .       break;
 15-833 .    }
 15-834 .    case two:
 15-835 .    {
 15-836 .       run_this;
 15-837 .       break;
 15-838 .    }
 15-839 .    default:
 15-840 .    {
 15-841 .        SwError;
 15-842 .    }
 15-843 . }
 15-844 . 
 15-845 . A = B*C;
 15-846 . 
 15-847 . /* dead_block = C * D; 
 15-848 . dead_block = E * F; */
 15-849 . 
 15-850 . A = B*C;
 15-851 . 
 15-852 . if (A >  B)
 15-853 . {
 15-854 .    A = B + C;
 15-855 .    D = E + F;
 15-856 . }
 15-857 . 
 15-858 . A = B-C;
 15-859 . 
 15-860 . #ifdef LAZY
 15-861 .    // this is not nice
 15-862 .    A = B + C;
 15-863 .    A = B + C;
 15-864 . #endif
 15-865 . 
 15-866 . 
 15-867 . if (A <  B)
 15-868 . {
 15-869 .    A = B + C;
 15-870 .    D = E + F;
 15-871 . }
 15-872 . 
 15-873 . A = B*C;
 15-874 . A = B-C;
 15-875 . A = B/C;
 15-876 . A = B/C;
 15-877 . A = B-C;
 15-878 . A = B*C;
 15-879 . A = B/C;
 15-880 . A = B*C;
 15-881 . // max LOC 20
 15-882 . 
 15-883 . }
 15-884 . 
 15-885 . 
 15-886 . /*
 15-887 . -----------------------------------------------------------------------------
 15-888 . --| NAME:   fdp.2.7
 15-889 . --|
 15-890 . --| ABSTRACT:
 15-891 . --|   This function does fdp stuff.
 15-892 . --|
 15-893 . --| RETURNS:
 15-894 . --|   NONE.
 15-895 . --|
 15-896 . ----------------------------------------------------------------------------
 15-897 . */
 15-898 . static void fdp.2.7(void)
 15-899 . {
 15-900 . 
 15-901 . if (A > = B)
 15-902 . {
 15-903 .    A = B + C;
 15-904 .    D = E + F;
 15-905 . }
 15-906 . 
 15-907 . 
 15-908 . if (A lt B)
 15-909 . {
 15-910 .    A = B + C;
 15-911 .    D = E + F;
 15-912 . }
 15-913 . 
 15-914 . 
 15-915 . if (A > = B)
 15-916 . {
 15-917 .    A = B + C;
 15-918 .    D = E + F;
 15-919 . }
 15-920 . 
 15-921 . 
 15-922 . if (A gt B)
 15-923 . {
 15-924 .    A = B + C;
 15-925 .    D = E + F;
 15-926 . }
 15-927 . 
 15-928 . A = B*C;
 15-929 . 
 15-930 . if (A le B)
 15-931 . {
 15-932 .    A = B + C;
 15-933 .    D = E + F;
 15-934 . }
 15-935 . 
 15-936 . 
 15-937 . switch (fdp stuff)
 15-938 . {
 15-939 .    case one:
 15-940 .    {
 15-941 .       run_this; 
 15-942 .       break;
 15-943 .    }
 15-944 .    case two:
 15-945 .    {
 15-946 .       run_this;
 15-947 .       break;
 15-948 .    }
 15-949 .    default:
 15-950 .    {
 15-951 .        SwError;
 15-952 .    }
 15-953 . }
 15-954 . 
 15-955 . A = B-C;
 15-956 . 
 15-957 . if (A >  B)
 15-958 . {
 15-959 .    A = B + C;
 15-960 .    D = E + F;
 15-961 . }
 15-962 . 
 15-963 . A = B+C;
 15-964 . A = B*C;
 15-965 . goto error;
 15-966 . A = B/C;
 15-967 . /* LE SV TOC-1436 this is a fdp-02.7.13 req to update*/
 15-968 . 
 15-969 . if (A != B)
 15-970 . {
 15-971 .    A = B + C;
 15-972 .    D = E + F;
 15-973 . }
 15-974 . 
 15-975 . 
 15-976 . if (A le B)
 15-977 . {
 15-978 .    A = B + C;
 15-979 .    D = E + F;
 15-980 . }
 15-981 . 
 15-982 . A = B*C;
 15-983 . A = B*C;
 15-984 . A = 0x0003;
 15-985 . 
 15-986 . if (A le B)
 15-987 . {
 15-988 .    A = B + C;
 15-989 .    D = E + F;
 15-990 . }
 15-991 . 
 15-992 . 
 15-993 . switch (fdp stuff)
 15-994 . {
 15-995 .    case one:
 15-996 .    {
 15-997 .       run_this; 
 15-998 .       break;
 15-999 .    }
 15-1000 .    case two:
 15-1001 .    {
 15-1002 .       run_this;
 15-1003 .       break;
 15-1004 .    }
 15-1005 .    default:
 15-1006 .    {
 15-1007 .        SwError;
 15-1008 .    }
 15-1009 . }
 15-1010 . 
 15-1011 . 
 15-1012 . if (A < = B)
 15-1013 . {
 15-1014 .    A = B + C;
 15-1015 .    D = E + F;
 15-1016 . }
 15-1017 . 
 15-1018 . A = B+C;
 15-1019 . A = B*C;
 15-1020 . A = B+C;
 15-1021 . A = B*C;
 15-1022 . A = B*C;
 15-1023 . A = B*C;
 15-1024 . 
 15-1025 . if (A gt B)
 15-1026 . {
 15-1027 .    A = B + C;
 15-1028 .    D = E + F;
 15-1029 . }
 15-1030 . 
 15-1031 . A = B-C;
 15-1032 . A = B*C;
 15-1033 . 
 15-1034 . if (A eq B)
 15-1035 . {
 15-1036 .    A = B + C;
 15-1037 .    D = E + F;
 15-1038 . }
 15-1039 . 
 15-1040 . 
 15-1041 . if (A ge B)
 15-1042 . {
 15-1043 .    A = B + C;
 15-1044 .    D = E + F;
 15-1045 . }
 15-1046 . 
 15-1047 . A = B+C;
 15-1048 . A = B/C;
 15-1049 . A = B-C;
 15-1050 . A = B/C;
 15-1051 . A = B/C;
 15-1052 . A = B+C;
 15-1053 . A = B+C;
 15-1054 . 
 15-1055 . if (A < = B)
 15-1056 . {
 15-1057 .    A = B + C;
 15-1058 .    D = E + F;
 15-1059 . }
 15-1060 . 
 15-1061 . A = B*C;
 15-1062 . A = B-C;
 15-1063 . A = B*C;
 15-1064 . A = B/C;
 15-1065 . A = B+C;
 15-1066 . // (P) this is really improtant
 15-1067 . A = B/C;
 15-1068 . A = B/C;
 15-1069 . A = B+C;
 15-1070 . A = B/C;
 15-1071 . A = B+C;
 15-1072 . A = B-C;
 15-1073 . A = B-C;
 15-1074 . A = B/C;
 15-1075 . A = B*C;
 15-1076 . A = B/C;
 15-1077 . A = B+C;
 15-1078 . 
 15-1079 . if (A != B)
 15-1080 . {
 15-1081 .    A = B + C;
 15-1082 .    D = E + F;
 15-1083 . }
 15-1084 . 
 15-1085 . send_buffer = (U16 *) malloc(size+1);
 15-1086 . A = B*C;
 15-1087 . 
 15-1088 . if (A > = B)
 15-1089 . {
 15-1090 .    A = B + C;
 15-1091 .    D = E + F;
 15-1092 . }
 15-1093 . 
 15-1094 . A = B/C;
 15-1095 . A = B/C;
 15-1096 . A = B-C;
 15-1097 . A = B/C;
 15-1098 . A = B-C;
 15-1099 . 
 15-1100 . if (A gt B)
 15-1101 . {
 15-1102 .    A = B + C;
 15-1103 .    D = E + F;
 15-1104 . }
 15-1105 . 
 15-1106 . A = B/C;
 15-1107 . A = B*C;
 15-1108 . 
 15-1109 . if (A eq B)
 15-1110 . {
 15-1111 .    A = B + C;
 15-1112 .    D = E + F;
 15-1113 . }
 15-1114 . 
 15-1115 . A = B/C;
 15-1116 . /* LE SV TOC-1437 this is a fdp-02.7.68 req to check unix*/
 15-1117 . A = B*C;
 15-1118 . 
 15-1119 . if (A eq B)
 15-1120 . {
 15-1121 .    A = B + C;
 15-1122 .    D = E + F;
 15-1123 . }
 15-1124 . 
 15-1125 . A = B*C;
 15-1126 . A = B-C;
 15-1127 . 
 15-1128 . if (A lt B)
 15-1129 . {
 15-1130 .    A = B + C;
 15-1131 .    D = E + F;
 15-1132 . }
 15-1133 . 
 15-1134 . 
 15-1135 . if (A gt B)
 15-1136 . {
 15-1137 .    A = B + C;
 15-1138 .    D = E + F;
 15-1139 . }
 15-1140 . 
 15-1141 . A = B+C;
 15-1142 . // max LOC 74
 15-1143 . 
 15-1144 . }
 15-1145 . 
 15-1146 . 
 15-1147 . /*
 15-1148 . -----------------------------------------------------------------------------
 15-1149 . --| NAME:   fdp.2.8
 15-1150 . --|
 15-1151 . --| ABSTRACT:
 15-1152 . --|   This function does fdp stuff.
 15-1153 . --|
 15-1154 . --| RETURNS:
 15-1155 . --|   NONE.
 15-1156 . --|
 15-1157 . ----------------------------------------------------------------------------
 15-1158 . */
 15-1159 . static void fdp.2.8(void)
 15-1160 . {
 15-1161 . A = B+C;
 15-1162 . A = B*C;
 15-1163 . A = B-C;
 15-1164 . 
 15-1165 . if (A lt B)
 15-1166 . {
 15-1167 .    A = B + C;
 15-1168 .    D = E + F;
 15-1169 . }
 15-1170 . 
 15-1171 . A = B*C;
 15-1172 . 
 15-1173 . if (A ne B)
 15-1174 . {
 15-1175 .    A = B + C;
 15-1176 .    D = E + F;
 15-1177 . }
 15-1178 . 
 15-1179 . A = B-C;
 15-1180 . A = B-C;
 15-1181 . A = B+C;
 15-1182 . // (P) this is really improtant
 15-1183 . 
 15-1184 . if (A < = B)
 15-1185 . {
 15-1186 .    A = B + C;
 15-1187 .    D = E + F;
 15-1188 . }
 15-1189 . 
 15-1190 . /* LE SV TOC-1438 this is a fdp-02.8.11 req to detect error*/
 15-1191 . 
 15-1192 . if (A le B)
 15-1193 . {
 15-1194 .    A = B + C;
 15-1195 .    D = E + F;
 15-1196 . }
 15-1197 . 
 15-1198 . 
 15-1199 . if (A > = B)
 15-1200 . {
 15-1201 .    A = B + C;
 15-1202 .    D = E + F;
 15-1203 . }
 15-1204 . 
 15-1205 . A = B*C;
 15-1206 . A = B+C;
 15-1207 . A = B-C;
 15-1208 . A = B-C;
 15-1209 . 
 15-1210 . if (A > = B)
 15-1211 . {
 15-1212 .    A = B + C;
 15-1213 .    D = E + F;
 15-1214 . }
 15-1215 . 
 15-1216 . A = B+C;
 15-1217 . 
 15-1218 . switch (fdp stuff)
 15-1219 . {
 15-1220 .    case one:
 15-1221 .    {
 15-1222 .       run_this; 
 15-1223 .       break;
 15-1224 .    }
 15-1225 .    case two:
 15-1226 .    {
 15-1227 .       run_this;
 15-1228 .       break;
 15-1229 .    }
 15-1230 .    default:
 15-1231 .    {
 15-1232 .        SwError;
 15-1233 .    }
 15-1234 . }
 15-1235 . 
 15-1236 . A = B/C;
 15-1237 . A = B/C;
 15-1238 . /* LE SV TOC-1439 this is a fdp-02.8.22 req to set RTC*/
 15-1239 . A = B-C;
 15-1240 . A = B/C;
 15-1241 . 
 15-1242 . if (A eq B)
 15-1243 . {
 15-1244 .    A = B + C;
 15-1245 .    D = E + F;
 15-1246 . }
 15-1247 . 
 15-1248 . A = B-C;
 15-1249 . A = B-C;
 15-1250 . A = B/C;
 15-1251 . A = B/C;
 15-1252 . A = B/C;
 15-1253 . A = B-C;
 15-1254 . A = B*C;
 15-1255 . A = B*C;
 15-1256 . 
 15-1257 . if (A ne B)
 15-1258 . {
 15-1259 .    A = B + C;
 15-1260 .    D = E + F;
 15-1261 . }
 15-1262 . 
 15-1263 . A = B/C;
 15-1264 . 
 15-1265 . if (A < = B)
 15-1266 . {
 15-1267 .    A = B + C;
 15-1268 .    D = E + F;
 15-1269 . }
 15-1270 . 
 15-1271 . A = B-C;
 15-1272 . A = 0x0001;
 15-1273 . 
 15-1274 . if (A >  B)
 15-1275 . {
 15-1276 .    A = B + C;
 15-1277 .    D = E + F;
 15-1278 . }
 15-1279 . 
 15-1280 . A = B-C;
 15-1281 . A = B/C;
 15-1282 . A = 0x0004;
 15-1283 . 
 15-1284 . /* 
 15-1285 . dead_code = B - C; 
 15-1286 . dead_code = D - E; 
 15-1287 . dead_code = F - G;
 15-1288 . */
 15-1289 . 
 15-1290 . A = B/C;
 15-1291 . A = B+C;
 15-1292 . A = B/C;
 15-1293 . 
 15-1294 . if (A >  B)
 15-1295 . {
 15-1296 .    A = B + C;
 15-1297 .    D = E + F;
 15-1298 . }
 15-1299 . 
 15-1300 . A = B+C;
 15-1301 . 
 15-1302 . if (A eq B)
 15-1303 . {
 15-1304 .    A = B + C;
 15-1305 .    D = E + F;
 15-1306 . }
 15-1307 . 
 15-1308 . 
 15-1309 . if (A < = B)
 15-1310 . {
 15-1311 .    A = B + C;
 15-1312 .    D = E + F;
 15-1313 . }
 15-1314 . 
 15-1315 . A = B+C;
 15-1316 . A = B/C;
 15-1317 . A = B-C;
 15-1318 . A = B/C;
 15-1319 . 
 15-1320 . if (A eq B)
 15-1321 . {
 15-1322 .    A = B + C;
 15-1323 .    D = E + F;
 15-1324 . }
 15-1325 . 
 15-1326 . 
 15-1327 . if (A <  B)
 15-1328 . {
 15-1329 .    A = B + C;
 15-1330 .    D = E + F;
 15-1331 . }
 15-1332 . 
 15-1333 . A = B-C;
 15-1334 . 
 15-1335 . if (A le B)
 15-1336 . {
 15-1337 .    A = B + C;
 15-1338 .    D = E + F;
 15-1339 . }
 15-1340 . 
 15-1341 . A = B/C;
 15-1342 . A = B+C;
 15-1343 . A = B+C;
 15-1344 . 
 15-1345 . if (A ge B)
 15-1346 . {
 15-1347 .    A = B + C;
 15-1348 .    D = E + F;
 15-1349 . }
 15-1350 . 
 15-1351 . A = B+C;
 15-1352 . 
 15-1353 . if (A lt B)
 15-1354 . {
 15-1355 .    A = B + C;
 15-1356 .    D = E + F;
 15-1357 . }
 15-1358 . 
 15-1359 . 
 15-1360 . if (A le B)
 15-1361 . {
 15-1362 .    A = B + C;
 15-1363 .    D = E + F;
 15-1364 . }
 15-1365 . 
 15-1366 . /* LE SV TOC-1440 this is a fdp-02.8.62 req to check pSOS*/
 15-1367 . A = B-C;
 15-1368 . A = B/C;
 15-1369 . A = B*C;
 15-1370 . A = B/C;
 15-1371 . A = B*C;
 15-1372 . A = B+C;
 15-1373 . A = B*C;
 15-1374 . A = B/C;
 15-1375 . A = B-C;
 15-1376 . 
 15-1377 . if (A ge B)
 15-1378 . {
 15-1379 .    A = B + C;
 15-1380 .    D = E + F;
 15-1381 . }
 15-1382 . 
 15-1383 . A = B-C;
 15-1384 . A = B-C;
 15-1385 . A = B/C;
 15-1386 . A = B+C;
 15-1387 . A = B*C;
 15-1388 . A = B+C;
 15-1389 . A = B+C;
 15-1390 . // TBD - what do I do now
 15-1391 . 
 15-1392 . switch (fdp stuff)
 15-1393 . {
 15-1394 .    case one:
 15-1395 .    {
 15-1396 .       run_this; 
 15-1397 .       break;
 15-1398 .    }
 15-1399 .    case two:
 15-1400 .    {
 15-1401 .       run_this;
 15-1402 .       break;
 15-1403 .    }
 15-1404 .    default:
 15-1405 .    {
 15-1406 .        SwError;
 15-1407 .    }
 15-1408 . }
 15-1409 . 
 15-1410 . 
 15-1411 . if (A == B)
 15-1412 . {
 15-1413 .    A = B + C;
 15-1414 .    D = E + F;
 15-1415 . }
 15-1416 . 
 15-1417 . A = B*C;
 15-1418 . // max LOC 81
 15-1419 . 
 15-1420 . }
 15-1421 . 
 15-1422 . 
 15-1423 . /*
 15-1424 . -----------------------------------------------------------------------------
 15-1425 . --| NAME:   fdp.2.9
 15-1426 . --|
 15-1427 . --| ABSTRACT:
 15-1428 . --|   This function does fdp stuff.
 15-1429 . --|
 15-1430 . --| RETURNS:
 15-1431 . --|   NONE.
 15-1432 . --|
 15-1433 . ----------------------------------------------------------------------------
 15-1434 . */
 15-1435 . static void fdp.2.9(void)
 15-1436 . {
 15-1437 . 
 15-1438 . if (A < = B)
 15-1439 . {
 15-1440 .    A = B + C;
 15-1441 .    D = E + F;
 15-1442 . }
 15-1443 . 
 15-1444 . A = 0x0003;
 15-1445 . A = B/C;
 15-1446 . A = B+C;
 15-1447 . A = 0x0007;
 15-1448 . A = B*C;
 15-1449 . A = B*C;
 15-1450 . /* LE SV TOC-1441 this is a fdp-02.9.6 req to store*/
 15-1451 . A = B+C;
 15-1452 . A = B/C;
 15-1453 . A = B/C;
 15-1454 . A = B+C;
 15-1455 . A = B-C;
 15-1456 . A = B-C;
 15-1457 . A = B/C;
 15-1458 . /* LE SV TOC-1442 this is a fdp-02.9.13 req to verify*/
 15-1459 . A = B/C;
 15-1460 . A = B+C;
 15-1461 . 
 15-1462 . if (A lt B)
 15-1463 . {
 15-1464 .    A = B + C;
 15-1465 .    D = E + F;
 15-1466 . }
 15-1467 . 
 15-1468 . 
 15-1469 . if (A eq B)
 15-1470 . {
 15-1471 .    A = B + C;
 15-1472 .    D = E + F;
 15-1473 . }
 15-1474 . 
 15-1475 . A = B*C;
 15-1476 . A = B/C;
 15-1477 . A = B-C;
 15-1478 . A = B*C;
 15-1479 . A = B-C;
 15-1480 . // max LOC 21
 15-1481 . 
 15-1482 . }
 15-1483 . 
 15-1484 . 
 15-1485 . /*
 15-1486 . -----------------------------------------------------------------------------
 15-1487 . --| NAME:   fdp.2.10
 15-1488 . --|
 15-1489 . --| ABSTRACT:
 15-1490 . --|   This function does fdp stuff.
 15-1491 . --|
 15-1492 . --| RETURNS:
 15-1493 . --|   NONE.
 15-1494 . --|
 15-1495 . ----------------------------------------------------------------------------
 15-1496 . */
 15-1497 . static void fdp.2.10(void)
 15-1498 . {
 15-1499 . 
 15-1500 . if (A eq B)
 15-1501 . {
 15-1502 .    A = B + C;
 15-1503 .    D = E + F;
 15-1504 . }
 15-1505 . 
 15-1506 . A = B*C;
 15-1507 . A = B/C;
 15-1508 . A = B-C;
 15-1509 . 
 15-1510 . if (A != B)
 15-1511 . {
 15-1512 .    A = B + C;
 15-1513 .    D = E + F;
 15-1514 . }
 15-1515 . 
 15-1516 . A = B*C;
 15-1517 . 
 15-1518 . if (A >  B)
 15-1519 . {
 15-1520 .    A = B + C;
 15-1521 .    D = E + F;
 15-1522 . }
 15-1523 . 
 15-1524 . A = B+C;
 15-1525 . A = B*C;
 15-1526 . 
 15-1527 . if (A != B)
 15-1528 . {
 15-1529 .    A = B + C;
 15-1530 .    D = E + F;
 15-1531 . }
 15-1532 . 
 15-1533 . 
 15-1534 . if (A gt B)
 15-1535 . {
 15-1536 .    A = B + C;
 15-1537 .    D = E + F;
 15-1538 . }
 15-1539 . 
 15-1540 . A = B*C;
 15-1541 . A = B-C;
 15-1542 . A = B/C;
 15-1543 . A = B+C;
 15-1544 . A = B*C;
 15-1545 . A = B/C;
 15-1546 . 
 15-1547 . if (A ne B)
 15-1548 . {
 15-1549 .    A = B + C;
 15-1550 .    D = E + F;
 15-1551 . }
 15-1552 . 
 15-1553 . 
 15-1554 . if (A le B)
 15-1555 . {
 15-1556 .    A = B + C;
 15-1557 .    D = E + F;
 15-1558 . }
 15-1559 . 
 15-1560 . A = B-C;
 15-1561 . 
 15-1562 . if (A == B)
 15-1563 . {
 15-1564 .    A = B + C;
 15-1565 .    D = E + F;
 15-1566 . }
 15-1567 . 
 15-1568 . A = B*C;
 15-1569 . A = B-C;
 15-1570 . A = B-C;
 15-1571 . 
 15-1572 . if (A gt B)
 15-1573 . {
 15-1574 .    A = B + C;
 15-1575 .    D = E + F;
 15-1576 . }
 15-1577 . 
 15-1578 . A = B+C;
 15-1579 . A = B+C;
 15-1580 . 
 15-1581 . if (A == B)
 15-1582 . {
 15-1583 .    A = B + C;
 15-1584 .    D = E + F;
 15-1585 . }
 15-1586 . 
 15-1587 . 
 15-1588 . if (A < = B)
 15-1589 . {
 15-1590 .    A = B + C;
 15-1591 .    D = E + F;
 15-1592 . }
 15-1593 . 
 15-1594 . 
 15-1595 . if (A ge B)
 15-1596 . {
 15-1597 .    A = B + C;
 15-1598 .    D = E + F;
 15-1599 . }
 15-1600 . 
 15-1601 . A = B*C;
 15-1602 . A = B-C;
 15-1603 . 
 15-1604 . if (A >  B)
 15-1605 . {
 15-1606 .    A = B + C;
 15-1607 .    D = E + F;
 15-1608 . }
 15-1609 . 
 15-1610 . 
 15-1611 . if (A <  B)
 15-1612 . {
 15-1613 .    A = B + C;
 15-1614 .    D = E + F;
 15-1615 . }
 15-1616 . 
 15-1617 . 
 15-1618 . if (A gt B)
 15-1619 . {
 15-1620 .    A = B + C;
 15-1621 .    D = E + F;
 15-1622 . }
 15-1623 . 
 15-1624 . A = B+C;
 15-1625 . A = B*C;
 15-1626 . A = B-C;
 15-1627 . A = B/C;
 15-1628 . A = B/C;
 15-1629 . A = B/C;
 15-1630 . A = B/C;
 15-1631 . A = B-C;
 15-1632 . FreePtr = HmiStringPtr;
 15-1633 . A = B/C;
 15-1634 . 
 15-1635 . if (A < = B)
 15-1636 . {
 15-1637 .    A = B + C;
 15-1638 .    D = E + F;
 15-1639 . }
 15-1640 . 
 15-1641 . FreePtr = HmiStringPtr;
 15-1642 . A = B+C;
 15-1643 . A = B/C;
 15-1644 . /* LE SV TOC-1443 this is a fdp-02.10.48 req to convert*/
 15-1645 . 
 15-1646 . switch (fdp stuff)
 15-1647 . {
 15-1648 .    case one:
 15-1649 .    {
 15-1650 .       run_this; 
 15-1651 .       break;
 15-1652 .    }
 15-1653 .    case two:
 15-1654 .    {
 15-1655 .       run_this;
 15-1656 .       break;
 15-1657 .    }
 15-1658 .    default:
 15-1659 .    {
 15-1660 .        SwError;
 15-1661 .    }
 15-1662 . }
 15-1663 . 
 15-1664 . A = B-C;
 15-1665 . A = 0x0006;
 15-1666 . A = B-C;
 15-1667 . A = B+C;
 15-1668 . 
 15-1669 . if (A eq B)
 15-1670 . {
 15-1671 .    A = B + C;
 15-1672 .    D = E + F;
 15-1673 . }
 15-1674 . 
 15-1675 . A = B*C;
 15-1676 . 
 15-1677 . if (A lt B)
 15-1678 . {
 15-1679 .    A = B + C;
 15-1680 .    D = E + F;
 15-1681 . }
 15-1682 . 
 15-1683 . A = B-C;
 15-1684 . A = B/C;
 15-1685 . 
 15-1686 . if (A gt B)
 15-1687 . {
 15-1688 .    A = B + C;
 15-1689 .    D = E + F;
 15-1690 . }
 15-1691 . 
 15-1692 . 
 15-1693 . if (A eq B)
 15-1694 . {
 15-1695 .    A = B + C;
 15-1696 .    D = E + F;
 15-1697 . }
 15-1698 . 
 15-1699 . 
 15-1700 . if (A lt B)
 15-1701 . {
 15-1702 .    A = B + C;
 15-1703 .    D = E + F;
 15-1704 . }
 15-1705 . 
 15-1706 . A = 0x0003;
 15-1707 . A = B-C;
 15-1708 . A = B/C;
 15-1709 . A = B*C;
 15-1710 . A = B-C;
 15-1711 . 
 15-1712 . if (A ge B)
 15-1713 . {
 15-1714 .    A = B + C;
 15-1715 .    D = E + F;
 15-1716 . }
 15-1717 . 
 15-1718 . A = B+C;
 15-1719 . A = B*C;
 15-1720 . A = B/C;
 15-1721 . A = B*C;
 15-1722 . A = B-C;
 15-1723 . 
 15-1724 . if (A gt B)
 15-1725 . {
 15-1726 .    A = B + C;
 15-1727 .    D = E + F;
 15-1728 . }
 15-1729 . 
 15-1730 . A = B+C;
 15-1731 . 
 15-1732 . if (A eq B)
 15-1733 . {
 15-1734 .    A = B + C;
 15-1735 .    D = E + F;
 15-1736 . }
 15-1737 . 
 15-1738 . A = B*C;
 15-1739 . A = B-C;
 15-1740 . A = B/C;
 15-1741 . // max LOC 75
 15-1742 . 
 15-1743 . }
 15-1744 . 

15 15 Result: result/source/ft-app/ft-app-B1.1/fdp/fdp-02.c


16 16 Source: source/ft-app/ft-app-B1.1/fdp/fdp-03.c
 16-0 . /*
 16-1 . ----------------------------------------------------------------------------
 16-2 . --| BEGIN PROLOGUE
 16-3 . --|
 16-4 . --| CLASSIFICATION: UNCLASSIFIED
 16-5 . --|
 16-6 . --| FILE NAME:      fdp-03.c
 16-7 . --|
 16-8 . --| ABSTRACT:
 16-9 . --|   This file contains the 3 functions that do file fdp stuff.
 16-10 . --|
 16-11 . --| HISTORY:
 16-12 . --|   CCCQ_NAME:
 16-13 . --|   CCCQ_VER: 
 16-14 . --|
 16-15 . --| END PROLOGUE
 16-16 . ----------------------------------------------------------------------------
 16-17 . */
 16-18 . 
 16-19 . #define B;
 16-20 . float B;
 16-21 . 
 16-22 . 
 16-23 . 
 16-24 . /*
 16-25 . -----------------------------------------------------------------------------
 16-26 . --| NAME:   fdp.3.1
 16-27 . --|
 16-28 . --| ABSTRACT:
 16-29 . --|   This function does fdp stuff.
 16-30 . --|
 16-31 . --| RETURNS:
 16-32 . --|   NONE.
 16-33 . --|
 16-34 . ----------------------------------------------------------------------------
 16-35 . */
 16-36 . static void fdp.3.1(void)
 16-37 . {
 16-38 . rcv_buffer = (U16 *) alloc(size+1);
 16-39 . 
 16-40 . if (A <  B)
 16-41 . {
 16-42 .    A = B + C;
 16-43 .    D = E + F;
 16-44 . }
 16-45 . 
 16-46 . 
 16-47 . if (A ne B)
 16-48 . {
 16-49 .    A = B + C;
 16-50 .    D = E + F;
 16-51 . }
 16-52 . 
 16-53 . A = B+C;
 16-54 . A = B*C;
 16-55 . 
 16-56 . if (A gt B)
 16-57 . {
 16-58 .    A = B + C;
 16-59 .    D = E + F;
 16-60 . }
 16-61 . 
 16-62 . A = B*C;
 16-63 . A = 0x0002;
 16-64 . A = B/C;
 16-65 . A = B+C;
 16-66 . A = B-C;
 16-67 . A = B+C;
 16-68 . A = B/C;
 16-69 . // max LOC 11
 16-70 . 
 16-71 . }
 16-72 . 
 16-73 . 
 16-74 . /*
 16-75 . -----------------------------------------------------------------------------
 16-76 . --| NAME:   fdp.3.2
 16-77 . --|
 16-78 . --| ABSTRACT:
 16-79 . --|   This function does fdp stuff.
 16-80 . --|
 16-81 . --| RETURNS:
 16-82 . --|   NONE.
 16-83 . --|
 16-84 . ----------------------------------------------------------------------------
 16-85 . */
 16-86 . static void fdp.3.2(void)
 16-87 . {
 16-88 . A = B*C;
 16-89 . A = B*C;
 16-90 . 
 16-91 . if (A gt B)
 16-92 . {
 16-93 .    A = B + C;
 16-94 .    D = E + F;
 16-95 . }
 16-96 . 
 16-97 . 
 16-98 . if (A > = B)
 16-99 . {
 16-100 .    A = B + C;
 16-101 .    D = E + F;
 16-102 . }
 16-103 . 
 16-104 . A = B/C;
 16-105 . 
 16-106 . if (A <  B)
 16-107 . {
 16-108 .    A = B + C;
 16-109 .    D = E + F;
 16-110 . }
 16-111 . 
 16-112 . A = B+C;
 16-113 . A = B+C;
 16-114 . /* LE SV TOC-1444 this is a fdp-03.2.9 req to recover*/
 16-115 . A = B/C;
 16-116 . A = B+C;
 16-117 . A = B+C;
 16-118 . A = B+C;
 16-119 . A = B/C;
 16-120 . A = B+C;
 16-121 . A = B+C;
 16-122 . A = (float)B + C;
 16-123 . A = B/C;
 16-124 . A = B*C;
 16-125 . A = B-C;
 16-126 . /* LE SV TOC-1445 this is a fdp-03.2.19 req to call isr*/
 16-127 . 
 16-128 . if (A ne B)
 16-129 . {
 16-130 .    A = B + C;
 16-131 .    D = E + F;
 16-132 . }
 16-133 . 
 16-134 . 
 16-135 . if (A != B)
 16-136 . {
 16-137 .    A = B + C;
 16-138 .    D = E + F;
 16-139 . }
 16-140 . 
 16-141 . A = B+C;
 16-142 . A = B-C;
 16-143 . A = B+C;
 16-144 . A = B*C;
 16-145 . 
 16-146 . if (A gt B)
 16-147 . {
 16-148 .    A = B + C;
 16-149 .    D = E + F;
 16-150 . }
 16-151 . 
 16-152 . A = B-C;
 16-153 . 
 16-154 . if (A != B)
 16-155 . {
 16-156 .    A = B + C;
 16-157 .    D = E + F;
 16-158 . }
 16-159 . 
 16-160 . A = B*C;
 16-161 . A = B/C;
 16-162 . A = B/C;
 16-163 . 
 16-164 . if (A ne B)
 16-165 . {
 16-166 .    A = B + C;
 16-167 .    D = E + F;
 16-168 . }
 16-169 . 
 16-170 . A = B/C;
 16-171 . A = B*C;
 16-172 . A = B*C;
 16-173 . A = B-C;
 16-174 . 
 16-175 . switch (fdp stuff)
 16-176 . {
 16-177 .    case one:
 16-178 .    {
 16-179 .       run_this; 
 16-180 .       break;
 16-181 .    }
 16-182 .    case two:
 16-183 .    {
 16-184 .       run_this;
 16-185 .       break;
 16-186 .    }
 16-187 .    default:
 16-188 .    {
 16-189 .        SwError;
 16-190 .    }
 16-191 . }
 16-192 . 
 16-193 . 
 16-194 . switch (fdp stuff)
 16-195 . {
 16-196 .    case one:
 16-197 .    {
 16-198 .       run_this; 
 16-199 .       break;
 16-200 .    }
 16-201 .    case two:
 16-202 .    {
 16-203 .       run_this;
 16-204 .       break;
 16-205 .    }
 16-206 .    default:
 16-207 .    {
 16-208 .        SwError;
 16-209 .    }
 16-210 . }
 16-211 . 
 16-212 . 
 16-213 . if (A != B)
 16-214 . {
 16-215 .    A = B + C;
 16-216 .    D = E + F;
 16-217 . }
 16-218 . 
 16-219 . A = B+C;
 16-220 . A = B/C;
 16-221 . A = B*C;
 16-222 . A = B+C;
 16-223 . A = (long)B + C;
 16-224 . A = B-C;
 16-225 . A = B*C;
 16-226 . A = B+C;
 16-227 . A = 0x0006;
 16-228 . A = B-C;
 16-229 . A = B*C;
 16-230 . A = B-C;
 16-231 . A = B-C;
 16-232 . A = B/C;
 16-233 . A = B-C;
 16-234 . /* LE SV TOC-1446 this is a fdp-03.2.52 req to detect error*/
 16-235 . A = B-C;
 16-236 . // max LOC 52
 16-237 . 
 16-238 . }
 16-239 . 
 16-240 . 
 16-241 . /*
 16-242 . -----------------------------------------------------------------------------
 16-243 . --| NAME:   fdp.3.3
 16-244 . --|
 16-245 . --| ABSTRACT:
 16-246 . --|   This function does fdp stuff.
 16-247 . --|
 16-248 . --| RETURNS:
 16-249 . --|   NONE.
 16-250 . --|
 16-251 . ----------------------------------------------------------------------------
 16-252 . */
 16-253 . static void fdp.3.3(void)
 16-254 . {
 16-255 . A = B/C;
 16-256 . 
 16-257 . switch (fdp stuff)
 16-258 . {
 16-259 .    case one:
 16-260 .    {
 16-261 .       run_this; 
 16-262 .       break;
 16-263 .    }
 16-264 .    case two:
 16-265 .    {
 16-266 .       run_this;
 16-267 .       break;
 16-268 .    }
 16-269 .    default:
 16-270 .    {
 16-271 .        SwError;
 16-272 .    }
 16-273 . }
 16-274 . 
 16-275 . 
 16-276 . if (A gt B)
 16-277 . {
 16-278 .    A = B + C;
 16-279 .    D = E + F;
 16-280 . }
 16-281 . 
 16-282 . A = B/C;
 16-283 . 
 16-284 . if (A >  B)
 16-285 . {
 16-286 .    A = B + C;
 16-287 .    D = E + F;
 16-288 . }
 16-289 . 
 16-290 . A = B/C;
 16-291 . A = B+C;
 16-292 . A = B/C;
 16-293 . 
 16-294 . if (A != B)
 16-295 . {
 16-296 .    A = B + C;
 16-297 .    D = E + F;
 16-298 . }
 16-299 . 
 16-300 . 
 16-301 . if (A lt B)
 16-302 . {
 16-303 .    A = B + C;
 16-304 .    D = E + F;
 16-305 . }
 16-306 . 
 16-307 . A = B-C;
 16-308 . A = B*C;
 16-309 . 
 16-310 . if (A != B)
 16-311 . {
 16-312 .    A = B + C;
 16-313 .    D = E + F;
 16-314 . }
 16-315 . 
 16-316 . A = B/C;
 16-317 . 
 16-318 . if (A < = B)
 16-319 . {
 16-320 .    A = B + C;
 16-321 .    D = E + F;
 16-322 . }
 16-323 . 
 16-324 . A = B+C;
 16-325 . A = B/C;
 16-326 . 
 16-327 . if (A != B)
 16-328 . {
 16-329 .    A = B + C;
 16-330 .    D = E + F;
 16-331 . }
 16-332 . 
 16-333 . A = B*C;
 16-334 . 
 16-335 . if (A < = B)
 16-336 . {
 16-337 .    A = B + C;
 16-338 .    D = E + F;
 16-339 . }
 16-340 . 
 16-341 . A = B+C;
 16-342 . A = B*C;
 16-343 . A = B+C;
 16-344 . 
 16-345 . if (A == B)
 16-346 . {
 16-347 .    A = B + C;
 16-348 .    D = E + F;
 16-349 . }
 16-350 . 
 16-351 . 
 16-352 . if (A ne B)
 16-353 . {
 16-354 .    A = B + C;
 16-355 .    D = E + F;
 16-356 . }
 16-357 . 
 16-358 . 
 16-359 . if (A ne B)
 16-360 . {
 16-361 .    A = B + C;
 16-362 .    D = E + F;
 16-363 . }
 16-364 . 
 16-365 . 
 16-366 . if (A ne B)
 16-367 . {
 16-368 .    A = B + C;
 16-369 .    D = E + F;
 16-370 . }
 16-371 . 
 16-372 . A = B*C;
 16-373 . A = B+C;
 16-374 . A = B/C;
 16-375 . 
 16-376 . if (A == B)
 16-377 . {
 16-378 .    A = B + C;
 16-379 .    D = E + F;
 16-380 . }
 16-381 . 
 16-382 . A = B-C;
 16-383 . A = B/C;
 16-384 . A = B+C;
 16-385 . A = B-C;
 16-386 . 
 16-387 . if (A gt B)
 16-388 . {
 16-389 .    A = B + C;
 16-390 .    D = E + F;
 16-391 . }
 16-392 . 
 16-393 . A = B*C;
 16-394 . A = B+C;
 16-395 . A = B*C;
 16-396 . A = B/C;
 16-397 . 
 16-398 . if (A >  B)
 16-399 . {
 16-400 .    A = B + C;
 16-401 .    D = E + F;
 16-402 . }
 16-403 . 
 16-404 . /* LE SV TOC-1447 this is a fdp-03.3.42 req to audit*/
 16-405 . A = B*C;
 16-406 . 
 16-407 . if (A < = B)
 16-408 . {
 16-409 .    A = B + C;
 16-410 .    D = E + F;
 16-411 . }
 16-412 . 
 16-413 . A = B+C;
 16-414 . A = B-C;
 16-415 . A = B/C;
 16-416 . /* LE SV TOC-1448 this is a fdp-03.3.47 req to detect error*/
 16-417 . A = B*C;
 16-418 . A = B+C;
 16-419 . A = B+C;
 16-420 . 
 16-421 . if (A >  B)
 16-422 . {
 16-423 .    A = B + C;
 16-424 .    D = E + F;
 16-425 . }
 16-426 . 
 16-427 . A = B/C;
 16-428 . A = B+C;
 16-429 . /* LE SV TOC-1449 this is a fdp-03.3.53 req to recover*/
 16-430 . A = B/C;
 16-431 . 
 16-432 . /*
 16-433 . dead_block = C * D; 
 16-434 . dead_block = E * F;
 16-435 . */
 16-436 . 
 16-437 . A = B-C;
 16-438 . A = B+C;
 16-439 . A = B-C;
 16-440 . A = B+C;
 16-441 . A = B*C;
 16-442 . 
 16-443 . if (A <  B)
 16-444 . {
 16-445 .    A = B + C;
 16-446 .    D = E + F;
 16-447 . }
 16-448 . 
 16-449 . A = B/C;
 16-450 . 
 16-451 . switch (fdp stuff)
 16-452 . {
 16-453 .    case one:
 16-454 .    {
 16-455 .       run_this; 
 16-456 .       break;
 16-457 .    }
 16-458 .    case two:
 16-459 .    {
 16-460 .       run_this;
 16-461 .       break;
 16-462 .    }
 16-463 .    default:
 16-464 .    {
 16-465 .        SwError;
 16-466 .    }
 16-467 . }
 16-468 . 
 16-469 . A = B+C;
 16-470 . A = 0x0006;
 16-471 . A = B/C;
 16-472 . /* LE SV TOC-1450 this is a fdp-03.3.64 req to call admin*/
 16-473 . A = B+C;
 16-474 . // max LOC 64
 16-475 . 
 16-476 . }
 16-477 . 

16 16 Result: result/source/ft-app/ft-app-B1.1/fdp/fdp-03.c


17 17 Source: source/ft-app/ft-app-B1.1/fdp/fdp-04.c
 17-0 . /*
 17-1 . ----------------------------------------------------------------------------
 17-2 . --| BEGIN PROLOGUE
 17-3 . --|
 17-4 . --| CLASSIFICATION: UNCLASSIFIED
 17-5 . --|
 17-6 . --| FILE NAME:      fdp-04.c
 17-7 . --|
 17-8 . --| ABSTRACT:
 17-9 . --|   This file contains the 1 functions that do file fdp stuff.
 17-10 . --|
 17-11 . --| HISTORY:
 17-12 . --|   CCCQ_NAME:
 17-13 . --|   CCCQ_VER: 
 17-14 . --|
 17-15 . --| END PROLOGUE
 17-16 . ----------------------------------------------------------------------------
 17-17 . */
 17-18 . 
 17-19 . #include B;
 17-20 . char D;
 17-21 . #define D;
 17-22 . 
 17-23 . 
 17-24 . 
 17-25 . /*
 17-26 . -----------------------------------------------------------------------------
 17-27 . --| NAME:   fdp.4.1
 17-28 . --|
 17-29 . --| ABSTRACT:
 17-30 . --|   This function does fdp stuff.
 17-31 . --|
 17-32 . --| RETURNS:
 17-33 . --|   NONE.
 17-34 . --|
 17-35 . ----------------------------------------------------------------------------
 17-36 . */
 17-37 . static void fdp.4.1(void)
 17-38 . {
 17-39 . A = B+C;
 17-40 . A = B-C;
 17-41 . A = B-C;
 17-42 . 
 17-43 . if (A ge B)
 17-44 . {
 17-45 .    A = B + C;
 17-46 .    D = E + F;
 17-47 . }
 17-48 . 
 17-49 . A = B+C;
 17-50 . A = B/C;
 17-51 . 
 17-52 . switch (fdp stuff)
 17-53 . {
 17-54 .    case one:
 17-55 .    {
 17-56 .       run_this; 
 17-57 .       break;
 17-58 .    }
 17-59 .    case two:
 17-60 .    {
 17-61 .       run_this;
 17-62 .       break;
 17-63 .    }
 17-64 .    default:
 17-65 .    {
 17-66 .        SwError;
 17-67 .    }
 17-68 . }
 17-69 . 
 17-70 . A = B/C;
 17-71 . /* LE SV TOC-1451 this is a fdp-04.1.9 req to set RTC*/
 17-72 . A = B/C;
 17-73 . A = B+C;
 17-74 . 
 17-75 . if (A > = B)
 17-76 . {
 17-77 .    A = B + C;
 17-78 .    D = E + F;
 17-79 . }
 17-80 . 
 17-81 . 
 17-82 . if (A > = B)
 17-83 . {
 17-84 .    A = B + C;
 17-85 .    D = E + F;
 17-86 . }
 17-87 . 
 17-88 . A = (long)B + C;
 17-89 . A = B*C;
 17-90 . 
 17-91 . if (A <  B)
 17-92 . {
 17-93 .    A = B + C;
 17-94 .    D = E + F;
 17-95 . }
 17-96 . 
 17-97 . A = B/C;
 17-98 . 
 17-99 . if (A != B)
 17-100 . {
 17-101 .    A = B + C;
 17-102 .    D = E + F;
 17-103 . }
 17-104 . 
 17-105 . 
 17-106 . if (A eq B)
 17-107 . {
 17-108 .    A = B + C;
 17-109 .    D = E + F;
 17-110 . }
 17-111 . 
 17-112 . 
 17-113 . if (A lt B)
 17-114 . {
 17-115 .    A = B + C;
 17-116 .    D = E + F;
 17-117 . }
 17-118 . 
 17-119 . A = B-C;
 17-120 . 
 17-121 . if (A != B)
 17-122 . {
 17-123 .    A = B + C;
 17-124 .    D = E + F;
 17-125 . }
 17-126 . 
 17-127 . A = B+C;
 17-128 . A = B*C;
 17-129 . A = B/C;
 17-130 . A = B/C;
 17-131 . A = B-C;
 17-132 . A = B*C;
 17-133 . A = B/C;
 17-134 . A = B+C;
 17-135 . A = B/C;
 17-136 . A = B*C;
 17-137 . A = B+C;
 17-138 . A = B/C;
 17-139 . A = B+C;
 17-140 . A = B/C;
 17-141 . 
 17-142 . switch (fdp stuff)
 17-143 . {
 17-144 .    case one:
 17-145 .    {
 17-146 .       run_this; 
 17-147 .       // missing break
 17-148 .    }
 17-149 .    case two:
 17-150 .    {
 17-151 .       run_this;
 17-152 .       break;
 17-153 .    }
 17-154 .    default:
 17-155 .    {
 17-156 .       SwError;
 17-157 .    }
 17-158 . }
 17-159 . 
 17-160 . A = B-C;
 17-161 . 
 17-162 . if (A > = B)
 17-163 . {
 17-164 .    A = B + C;
 17-165 .    D = E + F;
 17-166 . }
 17-167 . 
 17-168 . 
 17-169 . switch (fdp stuff)
 17-170 . {
 17-171 .    case one:
 17-172 .    {
 17-173 .       run_this;
 17-174 .       break;
 17-175 .    }
 17-176 .    case two:
 17-177 .    {
 17-178 .       run_this;
 17-179 .       break;
 17-180 .    }
 17-181 .    // missing default
 17-182 . }
 17-183 . 
 17-184 . A = B-C;
 17-185 . A = B+C;
 17-186 . 
 17-187 . if (A >  B)
 17-188 . {
 17-189 .    A = B + C;
 17-190 .    D = E + F;
 17-191 . }
 17-192 . 
 17-193 . A = B/C;
 17-194 . A = B+C;
 17-195 . A = B-C;
 17-196 . A = B*C;
 17-197 . A = B*C;
 17-198 . A = B/C;
 17-199 . 
 17-200 . /* 
 17-201 . dead_code = B - C; 
 17-202 . dead_code = D - E; 
 17-203 . dead_code = F - G;
 17-204 . */
 17-205 . 
 17-206 . A = B/C;
 17-207 . 
 17-208 . if (A gt B)
 17-209 . {
 17-210 .    A = B + C;
 17-211 .    D = E + F;
 17-212 . }
 17-213 . 
 17-214 . A = B*C;
 17-215 . A = B+C;
 17-216 . A = B-C;
 17-217 . A = B-C;
 17-218 . A = B*C;
 17-219 . 
 17-220 . if (A != B)
 17-221 . {
 17-222 .    A = B + C;
 17-223 .    D = E + F;
 17-224 . }
 17-225 . 
 17-226 . A = B+C;
 17-227 . 
 17-228 . if (A != B)
 17-229 . {
 17-230 .    A = B + C;
 17-231 .    D = E + F;
 17-232 . }
 17-233 . 
 17-234 . A = B*C;
 17-235 . A = B+C;
 17-236 . 
 17-237 . if (A > = B)
 17-238 . {
 17-239 .    A = B + C;
 17-240 .    D = E + F;
 17-241 . }
 17-242 . 
 17-243 . A = B+C;
 17-244 . A = B+C;
 17-245 . A = B/C;
 17-246 . 
 17-247 . /* dead_code = B + C; 
 17-248 . dead_code = D + E; 
 17-249 . dead_code = F + G; */
 17-250 . 
 17-251 . A = B+C;
 17-252 . A = B/C;
 17-253 . A = B/C;
 17-254 . A = B-C;
 17-255 . A = B/C;
 17-256 . A = B*C;
 17-257 . // max LOC 67
 17-258 . 
 17-259 . }
 17-260 . 

17 17 Result: result/source/ft-app/ft-app-B1.1/fdp/fdp-04.c


18 18 Source: source/ft-app/ft-app-B1.1/fdp/fdp-05.c
 18-0 . 
 18-1 . 
 18-2 . char D;
 18-3 . #define D;
 18-4 . #include D;
 18-5 . int A;
 18-6 . char D;
 18-7 . 
 18-8 . 
 18-9 . 
 18-10 . /*
 18-11 . -----------------------------------------------------------------------------
 18-12 . --| NAME:   fdp.5.1
 18-13 . --|
 18-14 . --| ABSTRACT:
 18-15 . --|   This function does fdp stuff.
 18-16 . --|
 18-17 . --| RETURNS:
 18-18 . --|   NONE.
 18-19 . --|
 18-20 . ----------------------------------------------------------------------------
 18-21 . */
 18-22 . static void fdp.5.1(void)
 18-23 . {
 18-24 . A = B*C;
 18-25 . A = B*C;
 18-26 . 
 18-27 . if (A <  B)
 18-28 . {
 18-29 .    A = B + C;
 18-30 .    D = E + F;
 18-31 . }
 18-32 . 
 18-33 . 
 18-34 . if (A ge B)
 18-35 . {
 18-36 .    A = B + C;
 18-37 .    D = E + F;
 18-38 . }
 18-39 . 
 18-40 . 
 18-41 . if (A < = B)
 18-42 . {
 18-43 .    A = B + C;
 18-44 .    D = E + F;
 18-45 . }
 18-46 . 
 18-47 . A = B+C;
 18-48 . A = B-C;
 18-49 . A = B-C;
 18-50 . 
 18-51 . if (A > = B)
 18-52 . {
 18-53 .    A = B + C;
 18-54 .    D = E + F;
 18-55 . }
 18-56 . 
 18-57 . A = B+C;
 18-58 . 
 18-59 . if (A eq B)
 18-60 . {
 18-61 .    A = B + C;
 18-62 .    D = E + F;
 18-63 . }
 18-64 . 
 18-65 . A = B/C;
 18-66 . 
 18-67 . if (A >  B)
 18-68 . {
 18-69 .    A = B + C;
 18-70 .    D = E + F;
 18-71 . }
 18-72 . 
 18-73 . A = B+C;
 18-74 . /* LE SV TOC-1452 this is a fdp-05.1.15 req to recover*/
 18-75 . A = B-C;
 18-76 . 
 18-77 . if (A <  B)
 18-78 . {
 18-79 .    A = B + C;
 18-80 .    D = E + F;
 18-81 . }
 18-82 . 
 18-83 . /* LE SV TOC-1453 this is a fdp-05.1.17 req to detect error*/
 18-84 . 
 18-85 . if (A < = B)
 18-86 . {
 18-87 .    A = B + C;
 18-88 .    D = E + F;
 18-89 . }
 18-90 . 
 18-91 . 
 18-92 . if (A == B)
 18-93 . {
 18-94 .    A = B + C;
 18-95 .    D = E + F;
 18-96 . }
 18-97 . 
 18-98 . 
 18-99 . switch (fdp stuff)
 18-100 . {
 18-101 .    case:
 18-102 .    case:
 18-103 .    // stacked case statements but only if there is a new line in between
 18-104 . 
 18-105 .    case:
 18-106 .    case:
 18-107 .    case:
 18-108 .    {
 18-109 .       run_this;
 18-110 .       break;
 18-111 .    }
 18-112 .    default:
 18-113 .    {
 18-114 .       halt;
 18-115 .    }
 18-116 . }
 18-117 . 
 18-118 . 
 18-119 . if (A < = B)
 18-120 . {
 18-121 .    A = B + C;
 18-122 .    D = E + F;
 18-123 . }
 18-124 . 
 18-125 . A = B-C;
 18-126 . 
 18-127 . if (A <  B)
 18-128 . {
 18-129 .    A = B + C;
 18-130 .    D = E + F;
 18-131 . }
 18-132 . 
 18-133 . A = B/C;
 18-134 . /* LE SV TOC-1454 this is a fdp-05.1.23 req to verify*/
 18-135 . rcv_buffer = (U16 *) alloc(size+1);
 18-136 . A = B+C;
 18-137 . A = B*C;
 18-138 . A = B+C;
 18-139 . 
 18-140 . if (A >  B)
 18-141 . {
 18-142 .    A = B + C;
 18-143 .    D = E + F;
 18-144 . }
 18-145 . 
 18-146 . A = B+C;
 18-147 . A = B+C;
 18-148 . 
 18-149 . if (A >  B)
 18-150 . {
 18-151 .    A = B + C;
 18-152 .    D = E + F;
 18-153 . }
 18-154 . 
 18-155 . A = B*C;
 18-156 . A = B-C;
 18-157 . // max LOC 31
 18-158 . 
 18-159 . }
 18-160 . 
 18-161 . 
 18-162 . /*
 18-163 . -----------------------------------------------------------------------------
 18-164 . --| NAME:   fdp.5.2
 18-165 . --|
 18-166 . --| ABSTRACT:
 18-167 . --|   This function does fdp stuff.
 18-168 . --|
 18-169 . --| RETURNS:
 18-170 . --|   NONE.
 18-171 . --|
 18-172 . ----------------------------------------------------------------------------
 18-173 . */
 18-174 . static void fdp.5.2(void)
 18-175 . {
 18-176 . A = B/C;
 18-177 . A = B-C;
 18-178 . A = 0x0001;
 18-179 . A = B+C;
 18-180 . A = B+C;
 18-181 . 
 18-182 . if (A == B)
 18-183 . {
 18-184 .    A = B + C;
 18-185 .    D = E + F;
 18-186 . }
 18-187 . 
 18-188 . A = B/C;
 18-189 . A = B/C;
 18-190 . A = B*C;
 18-191 . A = B+C;
 18-192 . A = B+C;
 18-193 . A = B*C;
 18-194 . A = B/C;
 18-195 . 
 18-196 . if (A lt B)
 18-197 . {
 18-198 .    A = B + C;
 18-199 .    D = E + F;
 18-200 . }
 18-201 . 
 18-202 . A = B/C;
 18-203 . A = B+C;
 18-204 . A = B*C;
 18-205 . A = B-C;
 18-206 . A = B+C;
 18-207 . 
 18-208 . switch (fdp stuff)
 18-209 . {
 18-210 .    case one:
 18-211 .    {
 18-212 .       run_this;
 18-213 .       break;
 18-214 .    }
 18-215 .    case two:
 18-216 .    {
 18-217 .       run_this;
 18-218 .       break;
 18-219 .    }
 18-220 .    // missing default
 18-221 . }
 18-222 . 
 18-223 . A = B*C;
 18-224 . A = B/C;
 18-225 . A = B*C;
 18-226 . A = B-C;
 18-227 . // TBD - what do I do now
 18-228 . 
 18-229 . if (A <  B)
 18-230 . {
 18-231 .    A = B + C;
 18-232 .    D = E + F;
 18-233 . }
 18-234 . 
 18-235 . A = B/C;
 18-236 . A = B/C;
 18-237 . A = B/C;
 18-238 . 
 18-239 . switch (fdp stuff)
 18-240 . {
 18-241 .    case:
 18-242 .    case:
 18-243 .    // stacked case statements but only if there is a new line in between
 18-244 . 
 18-245 .    case:
 18-246 .    case:
 18-247 .    case:
 18-248 .    {
 18-249 .       run_this;
 18-250 .       break;
 18-251 .    }
 18-252 .    default:
 18-253 .    {
 18-254 .       halt;
 18-255 .    }
 18-256 . }
 18-257 . 
 18-258 . A = B*C;
 18-259 . A = B-C;
 18-260 . /* LE SV TOC-1455 this is a fdp-05.2.29 req to halt*/
 18-261 . A = B/C;
 18-262 . A = B-C;
 18-263 . 
 18-264 . if (A ge B)
 18-265 . {
 18-266 .    A = B + C;
 18-267 .    D = E + F;
 18-268 . }
 18-269 . 
 18-270 . A = B+C;
 18-271 . 
 18-272 . switch (fdp stuff)
 18-273 . {
 18-274 .    case one:
 18-275 .    {
 18-276 .       run_this;
 18-277 .       break;
 18-278 .    }
 18-279 .    case two:
 18-280 .    {
 18-281 .       run_this;
 18-282 .       break;
 18-283 .    }
 18-284 .    // missing default
 18-285 . }
 18-286 . 
 18-287 . A = B+C;
 18-288 . // max LOC 33
 18-289 . 
 18-290 . }
 18-291 . 

18 18 Result: result/source/ft-app/ft-app-B1.1/fdp/fdp-05.c


19 19 Source: source/ft-app/ft-app-B1.1/fdp/fdp-07.c
 19-0 . /*
 19-1 . ----------------------------------------------------------------------------
 19-2 . --| BEGIN PROLOGUE
 19-3 . --|
 19-4 . --| CLASSIFICATION: UNCLASSIFIED
 19-5 . --|
 19-6 . --| FILE NAME:      fdp-07.c
 19-7 . --|
 19-8 . --| ABSTRACT:
 19-9 . --|   This file contains the 9 functions that do file fdp stuff.
 19-10 . --|
 19-11 . --| HISTORY:
 19-12 . --|   CCCQ_NAME:
 19-13 . --|   CCCQ_VER: 
 19-14 . --|
 19-15 . --| END PROLOGUE
 19-16 . ----------------------------------------------------------------------------
 19-17 . */
 19-18 . 
 19-19 . #include C;
 19-20 . #include D;
 19-21 . #define A;
 19-22 . #include C;
 19-23 . 
 19-24 . 
 19-25 . 
 19-26 . /*
 19-27 . -----------------------------------------------------------------------------
 19-28 . --| NAME:   fdp.7.1
 19-29 . --|
 19-30 . --| ABSTRACT:
 19-31 . --|   This function does fdp stuff.
 19-32 . --|
 19-33 . --| RETURNS:
 19-34 . --|   NONE.
 19-35 . --|
 19-36 . ----------------------------------------------------------------------------
 19-37 . */
 19-38 . static void fdp.7.1(void)
 19-39 . {
 19-40 . A = B*C;
 19-41 . /* LE SV TOC-1481 this is a fdp-07.1.2 req to set RTC*/
 19-42 . A = B+C;
 19-43 . A = B+C;
 19-44 . A = B*C;
 19-45 . A = B*C;
 19-46 . 
 19-47 . if (veg)
 19-48 .    // missing curly brace
 19-49 .    variable = orange;
 19-50 . 
 19-51 . A = B*C;
 19-52 . A = B+C;
 19-53 . /* LE SV TOC-1482 this is a fdp-07.1.8 req to increment*/
 19-54 . 
 19-55 . if (A > = B)
 19-56 . {
 19-57 .    A = B + C;
 19-58 .    D = E + F;
 19-59 . }
 19-60 . 
 19-61 . 
 19-62 . if (A == B)
 19-63 . {
 19-64 .    A = B + C;
 19-65 .    D = E + F;
 19-66 . }
 19-67 . 
 19-68 . A = B/C;
 19-69 . A = B-C;
 19-70 . A = B/C;
 19-71 . 
 19-72 . if (A eq B)
 19-73 . {
 19-74 .    A = B + C;
 19-75 .    D = E + F;
 19-76 . }
 19-77 . 
 19-78 . 
 19-79 . if (A le B)
 19-80 . {
 19-81 .    A = B + C;
 19-82 .    D = E + F;
 19-83 . }
 19-84 . 
 19-85 . 
 19-86 . if (A eq B)
 19-87 . {
 19-88 .    A = B + C;
 19-89 .    D = E + F;
 19-90 . }
 19-91 . 
 19-92 . A = B-C;
 19-93 . A = B+C;
 19-94 . 
 19-95 . if (A gt B)
 19-96 . {
 19-97 .    A = B + C;
 19-98 .    D = E + F;
 19-99 . }
 19-100 . 
 19-101 . 
 19-102 . if (A lt B)
 19-103 . {
 19-104 .    A = B + C;
 19-105 .    D = E + F;
 19-106 . }
 19-107 . 
 19-108 . 
 19-109 . if (A > = B)
 19-110 . {
 19-111 .    A = B + C;
 19-112 .    D = E + F;
 19-113 . }
 19-114 . 
 19-115 . A = B/C;
 19-116 . A = B-C;
 19-117 . A = B+C;
 19-118 . 
 19-119 . if (A <  B)
 19-120 . {
 19-121 .    A = B + C;
 19-122 .    D = E + F;
 19-123 . }
 19-124 . 
 19-125 . 
 19-126 . switch (fdp stuff)
 19-127 . {
 19-128 .    case:
 19-129 .    case:
 19-130 .    // stacked case statements but only if there is a new line in between
 19-131 . 
 19-132 .    case:
 19-133 .    case:
 19-134 .    case:
 19-135 .    {
 19-136 .       run_this;
 19-137 .       break;
 19-138 .    }
 19-139 .    default:
 19-140 .    {
 19-141 .       halt;
 19-142 .    }
 19-143 . }
 19-144 . 
 19-145 . 
 19-146 . if (A < = B)
 19-147 . {
 19-148 .    A = B + C;
 19-149 .    D = E + F;
 19-150 . }
 19-151 . 
 19-152 . A = B+C;
 19-153 . A = B+C;
 19-154 . 
 19-155 . if (A eq B)
 19-156 . {
 19-157 .    A = B + C;
 19-158 .    D = E + F;
 19-159 . }
 19-160 . 
 19-161 . 
 19-162 . if (A != B)
 19-163 . {
 19-164 .    A = B + C;
 19-165 .    D = E + F;
 19-166 . }
 19-167 . 
 19-168 . A = B/C;
 19-169 . 
 19-170 . if (A >  B)
 19-171 . {
 19-172 .    A = B + C;
 19-173 .    D = E + F;
 19-174 . }
 19-175 . 
 19-176 . A = B*C;
 19-177 . A = B/C;
 19-178 . /* LE SV TOC-1483 this is a fdp-07.1.34 req to assign*/
 19-179 . A = B*C;
 19-180 . 
 19-181 . switch (fdp stuff)
 19-182 . {
 19-183 .    case one:
 19-184 .    {
 19-185 .       run_this; 
 19-186 .       break;
 19-187 .    }
 19-188 .    case two:
 19-189 .    {
 19-190 .       run_this;
 19-191 .       break;
 19-192 .    }
 19-193 .    default:
 19-194 .    {
 19-195 .        SwError;
 19-196 .    }
 19-197 . }
 19-198 . 
 19-199 . 
 19-200 . if (A >  B)
 19-201 . {
 19-202 .    A = B + C;
 19-203 .    D = E + F;
 19-204 . }
 19-205 . 
 19-206 . A = B*C;
 19-207 . A = B-C;
 19-208 . A = B-C;
 19-209 . 
 19-210 . if (A ge B)
 19-211 . {
 19-212 .    A = B + C;
 19-213 .    D = E + F;
 19-214 . }
 19-215 . 
 19-216 . A = B/C;
 19-217 . A = B-C;
 19-218 . A = B*C;
 19-219 . A = B*C;
 19-220 . /* LE SV TOC-1484 this is a fdp-07.1.45 req to process*/
 19-221 . A = B/C;
 19-222 . A = B-C;
 19-223 . 
 19-224 . if (A == B)
 19-225 . {
 19-226 .    A = B + C;
 19-227 .    D = E + F;
 19-228 . }
 19-229 . 
 19-230 . 
 19-231 . if (A ge B)
 19-232 . {
 19-233 .    A = B + C;
 19-234 .    D = E + F;
 19-235 . }
 19-236 . 
 19-237 . A = B+C;
 19-238 . A = B*C;
 19-239 . A = B*C;
 19-240 . /* LE SV TOC-1485 this is a fdp-07.1.52 req to increment*/
 19-241 . 
 19-242 . if (A gt B)
 19-243 . {
 19-244 .    A = B + C;
 19-245 .    D = E + F;
 19-246 . }
 19-247 . 
 19-248 . A = B+C;
 19-249 . A = B/C;
 19-250 . 
 19-251 . #ifdef LAZY
 19-252 .    // this is not nice
 19-253 .    A = B + C;
 19-254 .    A = B + C;
 19-255 . #endif
 19-256 . 
 19-257 . A = B/C;
 19-258 . A = B+C;
 19-259 . 
 19-260 . if (A != B)
 19-261 . {
 19-262 .    A = B + C;
 19-263 .    D = E + F;
 19-264 . }
 19-265 . 
 19-266 . A = B/C;
 19-267 . A = B+C;
 19-268 . 
 19-269 . if (A >  B)
 19-270 . {
 19-271 .    A = B + C;
 19-272 .    D = E + F;
 19-273 . }
 19-274 . 
 19-275 . 
 19-276 . if (A le B)
 19-277 . {
 19-278 .    A = B + C;
 19-279 .    D = E + F;
 19-280 . }
 19-281 . 
 19-282 . A = B*C;
 19-283 . A = B-C;
 19-284 . A = B-C;
 19-285 . // TBD - what do I do now
 19-286 . A = B+C;
 19-287 . // ??? go see ws
 19-288 . 
 19-289 . if (A < = B)
 19-290 . {
 19-291 .    A = B + C;
 19-292 .    D = E + F;
 19-293 . }
 19-294 . 
 19-295 . A = B*C;
 19-296 . 
 19-297 . if (A lt B)
 19-298 . {
 19-299 .    A = B + C;
 19-300 .    D = E + F;
 19-301 . }
 19-302 . 
 19-303 . A = B*C;
 19-304 . 
 19-305 . if (A != B)
 19-306 . {
 19-307 .    A = B + C;
 19-308 .    D = E + F;
 19-309 . }
 19-310 . 
 19-311 . A = B-C;
 19-312 . A = B*C;
 19-313 . A = B/C;
 19-314 . A = B-C;
 19-315 . // max LOC 74
 19-316 . 
 19-317 . }
 19-318 . 
 19-319 . 
 19-320 . /*
 19-321 . -----------------------------------------------------------------------------
 19-322 . --| NAME:   fdp.7.2
 19-323 . --|
 19-324 . --| ABSTRACT:
 19-325 . --|   This function does fdp stuff.
 19-326 . --|
 19-327 . --| RETURNS:
 19-328 . --|   NONE.
 19-329 . --|
 19-330 . ----------------------------------------------------------------------------
 19-331 . */
 19-332 . static void fdp.7.2(void)
 19-333 . {
 19-334 . 
 19-335 . if (A gt B)
 19-336 . {
 19-337 .    A = B + C;
 19-338 .    D = E + F;
 19-339 . }
 19-340 . 
 19-341 . 
 19-342 . if (A lt B)
 19-343 . {
 19-344 .    A = B + C;
 19-345 .    D = E + F;
 19-346 . }
 19-347 . 
 19-348 . A = B-C;
 19-349 . A = B-C;
 19-350 . A = B/C;
 19-351 . A = B/C;
 19-352 . A = B*C;
 19-353 . 
 19-354 . if (A lt B)
 19-355 . {
 19-356 .    A = B + C;
 19-357 .    D = E + F;
 19-358 . }
 19-359 . 
 19-360 . A = B*C;
 19-361 . A = B+C;
 19-362 . A = B/C;
 19-363 . A = B+C;
 19-364 . 
 19-365 . if (A le B)
 19-366 . {
 19-367 .    A = B + C;
 19-368 .    D = E + F;
 19-369 . }
 19-370 . 
 19-371 . A = B*C;
 19-372 . A = B*C;
 19-373 . A = B*C;
 19-374 . A = B*C;
 19-375 . A = B+C;
 19-376 . A = B/C;
 19-377 . A = B/C;
 19-378 . do forever;
 19-379 . A = B+C;
 19-380 . 
 19-381 . if (A ne B)
 19-382 . {
 19-383 .    A = B + C;
 19-384 .    D = E + F;
 19-385 . }
 19-386 . 
 19-387 . A = B-C;
 19-388 . A = B*C;
 19-389 . A = B*C;
 19-390 . A = B+C;
 19-391 . 
 19-392 . if (A >  B)
 19-393 . {
 19-394 .    A = B + C;
 19-395 .    D = E + F;
 19-396 . }
 19-397 . 
 19-398 . A = B-C;
 19-399 . A = B-C;
 19-400 . 
 19-401 . if (A le B)
 19-402 . {
 19-403 .    A = B + C;
 19-404 .    D = E + F;
 19-405 . }
 19-406 . 
 19-407 . A = B+C;
 19-408 . A = B-C;
 19-409 . // max LOC 32
 19-410 . 
 19-411 . }
 19-412 . 
 19-413 . 
 19-414 . /*
 19-415 . -----------------------------------------------------------------------------
 19-416 . --| NAME:   fdp.7.3
 19-417 . --|
 19-418 . --| ABSTRACT:
 19-419 . --|   This function does fdp stuff.
 19-420 . --|
 19-421 . --| RETURNS:
 19-422 . --|   NONE.
 19-423 . --|
 19-424 . ----------------------------------------------------------------------------
 19-425 . */
 19-426 . static void fdp.7.3(void)
 19-427 . {
 19-428 . A = B/C;
 19-429 . A = B+C;
 19-430 . // (P) this is really improtant
 19-431 . A = B-C;
 19-432 . 
 19-433 . switch (fdp stuff)
 19-434 . {
 19-435 .       case one:
 19-436 .    {
 19-437 .       run_this;
 19-438 .       break;
 19-439 .    }
 19-440 .    case two:
 19-441 .    {
 19-442 .       run_this;
 19-443 .       break;
 19-444 .    }
 19-445 .    default:
 19-446 .    {
 19-447 .       // missing error call
 19-448 .    }
 19-449 . }
 19-450 . 
 19-451 . A = B-C;
 19-452 . 
 19-453 . if (A le B)
 19-454 . {
 19-455 .    A = B + C;
 19-456 .    D = E + F;
 19-457 . }
 19-458 . 
 19-459 . 
 19-460 . if (A >  B)
 19-461 . {
 19-462 .    A = B + C;
 19-463 .    D = E + F;
 19-464 . }
 19-465 . 
 19-466 . A = B/C;
 19-467 . A = B*C;
 19-468 . A = B+C;
 19-469 . 
 19-470 . if (A <  B)
 19-471 . {
 19-472 .    A = B + C;
 19-473 .    D = E + F;
 19-474 . }
 19-475 . 
 19-476 . A = B*C;
 19-477 . 
 19-478 . if (A <  B)
 19-479 . {
 19-480 .    A = B + C;
 19-481 .    D = E + F;
 19-482 . }
 19-483 . 
 19-484 . A = B/C;
 19-485 . 
 19-486 . if (A <  B)
 19-487 . {
 19-488 .    A = B + C;
 19-489 .    D = E + F;
 19-490 . }
 19-491 . 
 19-492 . A = B/C;
 19-493 . /* LE SV TOC-1486 this is a fdp-07.3.16 req to check unix*/
 19-494 . A = B+C;
 19-495 . A = B-C;
 19-496 . 
 19-497 . if (A >  B)
 19-498 . {
 19-499 .    A = B + C;
 19-500 .    D = E + F;
 19-501 . }
 19-502 . 
 19-503 . A = B-C;
 19-504 . 
 19-505 . if (A == B)
 19-506 . {
 19-507 .    A = B + C;
 19-508 .    D = E + F;
 19-509 . }
 19-510 . 
 19-511 . A = B-C;
 19-512 . A = B-C;
 19-513 . 
 19-514 . if (A <  B)
 19-515 . {
 19-516 .    A = B + C;
 19-517 .    D = E + F;
 19-518 . }
 19-519 . 
 19-520 . 
 19-521 . switch (fdp stuff)
 19-522 . {
 19-523 .    case one:
 19-524 .    {
 19-525 .       run_this;
 19-526 .       break;
 19-527 .    }
 19-528 .    case two:
 19-529 .    {
 19-530 .       run_this;
 19-531 .       break;
 19-532 .    }
 19-533 .    // missing default
 19-534 . }
 19-535 . 
 19-536 . 
 19-537 . if (A > = B)
 19-538 . {
 19-539 .    A = B + C;
 19-540 .    D = E + F;
 19-541 . }
 19-542 . 
 19-543 . A = B-C;
 19-544 . A = B*C;
 19-545 . A = B-C;
 19-546 . A = B-C;
 19-547 . 
 19-548 . if (A <  B)
 19-549 . {
 19-550 .    A = B + C;
 19-551 .    D = E + F;
 19-552 . }
 19-553 . 
 19-554 . /* LE SV TOC-1487 this is a fdp-07.3.30 req to record*/
 19-555 . A = B/C;
 19-556 . A = B-C;
 19-557 . 
 19-558 . if (A != B)
 19-559 . {
 19-560 .    A = B + C;
 19-561 .    D = E + F;
 19-562 . }
 19-563 . 
 19-564 . /* LE SV TOC-1488 this is a fdp-07.3.33 req to transform*/
 19-565 . 
 19-566 . if (A lt B)
 19-567 . {
 19-568 .    A = B + C;
 19-569 .    D = E + F;
 19-570 . }
 19-571 . 
 19-572 . 
 19-573 . if (A lt B)
 19-574 . {
 19-575 .    A = B + C;
 19-576 .    D = E + F;
 19-577 . }
 19-578 . 
 19-579 . A = B-C;
 19-580 . 
 19-581 . if (A ge B)
 19-582 . {
 19-583 .    A = B + C;
 19-584 .    D = E + F;
 19-585 . }
 19-586 . 
 19-587 . 
 19-588 . if (A != B)
 19-589 . {
 19-590 .    A = B + C;
 19-591 .    D = E + F;
 19-592 . }
 19-593 . 
 19-594 . A = B*C;
 19-595 . A = B/C;
 19-596 . A = B+C;
 19-597 . A = B+C;
 19-598 . send_buffer = (U16 *) malloc(size+1);
 19-599 . A = B+C;
 19-600 . 
 19-601 . if (A eq B)
 19-602 . {
 19-603 .    A = B + C;
 19-604 .    D = E + F;
 19-605 . }
 19-606 . 
 19-607 . A = B/C;
 19-608 . A = B*C;
 19-609 . A = B-C;
 19-610 . A = B+C;
 19-611 . A = B*C;
 19-612 . 
 19-613 . if (A < = B)
 19-614 . {
 19-615 .    A = B + C;
 19-616 .    D = E + F;
 19-617 . }
 19-618 . 
 19-619 . 
 19-620 . switch (fdp stuff)
 19-621 . {
 19-622 .    case one:
 19-623 .    {
 19-624 .       run_this; 
 19-625 .       break;
 19-626 .    }
 19-627 .    case two:
 19-628 .    {
 19-629 .       run_this;
 19-630 .       break;
 19-631 .    }
 19-632 .    default:
 19-633 .    {
 19-634 .        SwError;
 19-635 .    }
 19-636 . }
 19-637 . 
 19-638 . A = B-C;
 19-639 . 
 19-640 . if (A gt B)
 19-641 . {
 19-642 .    A = B + C;
 19-643 .    D = E + F;
 19-644 . }
 19-645 . 
 19-646 . /* LE SV TOC-1489 this is a fdp-07.3.53 req to store*/
 19-647 . A = B-C;
 19-648 . 
 19-649 . if (A eq B)
 19-650 . {
 19-651 .    A = B + C;
 19-652 .    D = E + F;
 19-653 . }
 19-654 . 
 19-655 . A = B-C;
 19-656 . A = B-C;
 19-657 . 
 19-658 . if (A ne B)
 19-659 . {
 19-660 .    A = B + C;
 19-661 .    D = E + F;
 19-662 . }
 19-663 . 
 19-664 . 
 19-665 . if (A eq B)
 19-666 . {
 19-667 .    A = B + C;
 19-668 .    D = E + F;
 19-669 . }
 19-670 . 
 19-671 . A = B+C;
 19-672 . 
 19-673 . if (A <  B)
 19-674 . {
 19-675 .    A = B + C;
 19-676 .    D = E + F;
 19-677 . }
 19-678 . 
 19-679 . 
 19-680 . if (A >  B)
 19-681 . {
 19-682 .    A = B + C;
 19-683 .    D = E + F;
 19-684 . }
 19-685 . 
 19-686 . 
 19-687 . if (A gt B)
 19-688 . {
 19-689 .    A = B + C;
 19-690 .    D = E + F;
 19-691 . }
 19-692 . 
 19-693 . 
 19-694 . if (A <  B)
 19-695 . {
 19-696 .    A = B + C;
 19-697 .    D = E + F;
 19-698 . }
 19-699 . 
 19-700 . // max LOC 63
 19-701 . 
 19-702 . }
 19-703 . 
 19-704 . 
 19-705 . /*
 19-706 . -----------------------------------------------------------------------------
 19-707 . --| NAME:   fdp.7.4
 19-708 . --|
 19-709 . --| ABSTRACT:
 19-710 . --|   This function does fdp stuff.
 19-711 . --|
 19-712 . --| RETURNS:
 19-713 . --|   NONE.
 19-714 . --|
 19-715 . ----------------------------------------------------------------------------
 19-716 . */
 19-717 . static void fdp.7.4(void)
 19-718 . {
 19-719 . 
 19-720 . if (A gt B)
 19-721 . {
 19-722 .    A = B + C;
 19-723 .    D = E + F;
 19-724 . }
 19-725 . 
 19-726 . A = B/C;
 19-727 . 
 19-728 . if (A == B)
 19-729 . {
 19-730 .    A = B + C;
 19-731 .    D = E + F;
 19-732 . }
 19-733 . 
 19-734 . A = B+C;
 19-735 . 
 19-736 . if (A != B)
 19-737 . {
 19-738 .    A = B + C;
 19-739 .    D = E + F;
 19-740 . }
 19-741 . 
 19-742 . /* LE SV TOC-1490 this is a fdp-07.4.6 req to assign*/
 19-743 . A = B+C;
 19-744 . 
 19-745 . if (A lt B)
 19-746 . {
 19-747 .    A = B + C;
 19-748 .    D = E + F;
 19-749 . }
 19-750 . 
 19-751 . A = B+C;
 19-752 . 
 19-753 . if (A ne B)
 19-754 . {
 19-755 .    A = B + C;
 19-756 .    D = E + F;
 19-757 . }
 19-758 . 
 19-759 . A = B*C;
 19-760 . A = B+C;
 19-761 . A = B-C;
 19-762 . A = B/C;
 19-763 . 
 19-764 . if (A ne B)
 19-765 . {
 19-766 .    A = B + C;
 19-767 .    D = E + F;
 19-768 . }
 19-769 . 
 19-770 . 
 19-771 . if (A <  B)
 19-772 . {
 19-773 .    A = B + C;
 19-774 .    D = E + F;
 19-775 . }
 19-776 . 
 19-777 . A = B+C;
 19-778 . A = B*C;
 19-779 . A = B-C;
 19-780 . A = B-C;
 19-781 . 
 19-782 . if (A le B)
 19-783 . {
 19-784 .    A = B + C;
 19-785 .    D = E + F;
 19-786 . }
 19-787 . 
 19-788 . A = B*C;
 19-789 . A = B+C;
 19-790 . A = B+C;
 19-791 . A = B/C;
 19-792 . A = B/C;
 19-793 . A = B-C;
 19-794 . /* LE SV TOC-1491 this is a fdp-07.4.27 req to halt*/
 19-795 . A = B+C;
 19-796 . A = B+C;
 19-797 . A = B-C;
 19-798 . A = B-C;
 19-799 . A = B/C;
 19-800 . A = B/C;
 19-801 . A = B*C;
 19-802 . A = B-C;
 19-803 . A = B-C;
 19-804 . A = B-C;
 19-805 . 
 19-806 . if (A le B)
 19-807 . {
 19-808 .    A = B + C;
 19-809 .    D = E + F;
 19-810 . }
 19-811 . 
 19-812 . 
 19-813 . if (A != B)
 19-814 . {
 19-815 .    A = B + C;
 19-816 .    D = E + F;
 19-817 . }
 19-818 . 
 19-819 . 
 19-820 . if (A gt B)
 19-821 . {
 19-822 .    A = B + C;
 19-823 .    D = E + F;
 19-824 . }
 19-825 . 
 19-826 . A = B-C;
 19-827 . A = B-C;
 19-828 . A = B+C;
 19-829 . A = B/C;
 19-830 . A = B*C;
 19-831 . A = B+C;
 19-832 . 
 19-833 . if (A ge B)
 19-834 . {
 19-835 .    A = B + C;
 19-836 .    D = E + F;
 19-837 . }
 19-838 . 
 19-839 . 
 19-840 . if (A == B)
 19-841 . {
 19-842 .    A = B + C;
 19-843 .    D = E + F;
 19-844 . }
 19-845 . 
 19-846 . A = B*C;
 19-847 . A = B*C;
 19-848 . 
 19-849 . if (A ge B)
 19-850 . {
 19-851 .    A = B + C;
 19-852 .    D = E + F;
 19-853 . }
 19-854 . 
 19-855 . A = B+C;
 19-856 . 
 19-857 . if (A != B)
 19-858 . {
 19-859 .    A = B + C;
 19-860 .    D = E + F;
 19-861 . }
 19-862 . 
 19-863 . A = B-C;
 19-864 . FreePtr = HmiStringPtr;
 19-865 . A = B-C;
 19-866 . 
 19-867 . if (A ge B)
 19-868 . {
 19-869 .    A = B + C;
 19-870 .    D = E + F;
 19-871 . }
 19-872 . 
 19-873 . A = B-C;
 19-874 . A = 0x0008;
 19-875 . A = B+C;
 19-876 . A = B*C;
 19-877 . A = B/C;
 19-878 . 
 19-879 . if (A eq B)
 19-880 . {
 19-881 .    A = B + C;
 19-882 .    D = E + F;
 19-883 . }
 19-884 . 
 19-885 . 
 19-886 . if (A <  B)
 19-887 . {
 19-888 .    A = B + C;
 19-889 .    D = E + F;
 19-890 . }
 19-891 . 
 19-892 . A = B+C;
 19-893 . A = B/C;
 19-894 . A = B/C;
 19-895 . A = B+C;
 19-896 . A = B+C;
 19-897 . 
 19-898 . if (A ne B)
 19-899 . {
 19-900 .    A = B + C;
 19-901 .    D = E + F;
 19-902 . }
 19-903 . 
 19-904 . A = B/C;
 19-905 . 
 19-906 . if (A lt B)
 19-907 . {
 19-908 .    A = B + C;
 19-909 .    D = E + F;
 19-910 . }
 19-911 . 
 19-912 . 
 19-913 . if (A > = B)
 19-914 . {
 19-915 .    A = B + C;
 19-916 .    D = E + F;
 19-917 . }
 19-918 . 
 19-919 . A = B*C;
 19-920 . 
 19-921 . switch (fdp stuff)
 19-922 . {
 19-923 .    case one:
 19-924 .    {
 19-925 .       run_this; 
 19-926 .       break;
 19-927 .    }
 19-928 .    case two:
 19-929 .    {
 19-930 .       run_this;
 19-931 .       break;
 19-932 .    }
 19-933 .    default:
 19-934 .    {
 19-935 .        SwError;
 19-936 .    }
 19-937 . }
 19-938 . 
 19-939 . A = B*C;
 19-940 . 
 19-941 . if (A eq B)
 19-942 . {
 19-943 .    A = B + C;
 19-944 .    D = E + F;
 19-945 . }
 19-946 . 
 19-947 . 
 19-948 . if (A >  B)
 19-949 . {
 19-950 .    A = B + C;
 19-951 .    D = E + F;
 19-952 . }
 19-953 . 
 19-954 . A = B+C;
 19-955 . 
 19-956 . if (A <  B)
 19-957 . {
 19-958 .    A = B + C;
 19-959 .    D = E + F;
 19-960 . }
 19-961 . 
 19-962 . A = (int)B + C;
 19-963 . A = B-C;
 19-964 . A = B/C;
 19-965 . A = B/C;
 19-966 . 
 19-967 . if (A eq B)
 19-968 . {
 19-969 .    A = B + C;
 19-970 .    D = E + F;
 19-971 . }
 19-972 . 
 19-973 . A = B+C;
 19-974 . A = B/C;
 19-975 . A = B-C;
 19-976 . 
 19-977 . if (A gt B)
 19-978 . {
 19-979 .    A = B + C;
 19-980 .    D = E + F;
 19-981 . }
 19-982 . 
 19-983 . 
 19-984 . if (A <  B)
 19-985 . {
 19-986 .    A = B + C;
 19-987 .    D = E + F;
 19-988 . }
 19-989 . 
 19-990 . A = B*C;
 19-991 . A = B-C;
 19-992 . A = B+C;
 19-993 . A = B*C;
 19-994 . A = B*C;
 19-995 . // max LOC 91
 19-996 . 
 19-997 . }
 19-998 . 
 19-999 . 
 19-1000 . /*
 19-1001 . -----------------------------------------------------------------------------
 19-1002 . --| NAME:   fdp.7.5
 19-1003 . --|
 19-1004 . --| ABSTRACT:
 19-1005 . --|   This function does fdp stuff.
 19-1006 . --|
 19-1007 . --| RETURNS:
 19-1008 . --|   NONE.
 19-1009 . --|
 19-1010 . ----------------------------------------------------------------------------
 19-1011 . */
 19-1012 . static void fdp.7.5(void)
 19-1013 . {
 19-1014 . A = B/C;
 19-1015 . 
 19-1016 . switch (fdp stuff)
 19-1017 . {
 19-1018 .    case one:
 19-1019 .    {
 19-1020 .       switch (nested)
 19-1021 .       {
 19-1022 .          case:
 19-1023 .             X = Y + Z;
 19-1024 .          case:
 19-1025 .             X = Y + Z;
 19-1026 .          default:
 19-1027 .             SwError;
 19-1028 .       } 
 19-1029 .    }
 19-1030 .    case two:
 19-1031 .    {
 19-1032 .       run_this;
 19-1033 .       break;
 19-1034 .    }
 19-1035 .    default:
 19-1036 .    {
 19-1037 .       SwError;
 19-1038 .    }
 19-1039 . }
 19-1040 . 
 19-1041 . A = B/C;
 19-1042 . A = B+C;
 19-1043 . /* LE SV TOC-1492 this is a fdp-07.5.4 req to assign*/
 19-1044 . A = B*C;
 19-1045 . A = B/C;
 19-1046 . send_buffer = (U16 *) malloc(size+1);
 19-1047 . A = B*C;
 19-1048 . 
 19-1049 . if (A <  B)
 19-1050 . {
 19-1051 .    A = B + C;
 19-1052 .    D = E + F;
 19-1053 . }
 19-1054 . 
 19-1055 . // max LOC 7
 19-1056 . 
 19-1057 . }
 19-1058 . 
 19-1059 . 
 19-1060 . /*
 19-1061 . -----------------------------------------------------------------------------
 19-1062 . --| NAME:   fdp.7.6
 19-1063 . --|
 19-1064 . --| ABSTRACT:
 19-1065 . --|   This function does fdp stuff.
 19-1066 . --|
 19-1067 . --| RETURNS:
 19-1068 . --|   NONE.
 19-1069 . --|
 19-1070 . ----------------------------------------------------------------------------
 19-1071 . */
 19-1072 . static void fdp.7.6(void)
 19-1073 . {
 19-1074 . A = B/C;
 19-1075 . A = B-C;
 19-1076 . A = B*C;
 19-1077 . // TBD - what do I do now
 19-1078 . A = B*C;
 19-1079 . A = B/C;
 19-1080 . A = B+C;
 19-1081 . A = B+C;
 19-1082 . A = B/C;
 19-1083 . A = B+C;
 19-1084 . A = B-C;
 19-1085 . 
 19-1086 . if (A eq B)
 19-1087 . {
 19-1088 .    A = B + C;
 19-1089 .    D = E + F;
 19-1090 . }
 19-1091 . 
 19-1092 . A = B-C;
 19-1093 . A = B/C;
 19-1094 . A = B/C;
 19-1095 . A = B/C;
 19-1096 . A = B+C;
 19-1097 . A = B/C;
 19-1098 . A = B+C;
 19-1099 . A = B*C;
 19-1100 . 
 19-1101 . if (A >  B)
 19-1102 . {
 19-1103 .    A = B + C;
 19-1104 .    D = E + F;
 19-1105 . }
 19-1106 . 
 19-1107 . A = B/C;
 19-1108 . 
 19-1109 . switch (fdp stuff)
 19-1110 . {
 19-1111 .    case one:
 19-1112 .    {
 19-1113 .       run_this; 
 19-1114 .       break;
 19-1115 .    }
 19-1116 .    case two:
 19-1117 .    {
 19-1118 .       run_this;
 19-1119 .       break;
 19-1120 .    }
 19-1121 .    default:
 19-1122 .    {
 19-1123 .        SwError;
 19-1124 .    }
 19-1125 . }
 19-1126 . 
 19-1127 . A = B+C;
 19-1128 . A = B/C;
 19-1129 . 
 19-1130 . if (A > = B)
 19-1131 . {
 19-1132 .    A = B + C;
 19-1133 .    D = E + F;
 19-1134 . }
 19-1135 . 
 19-1136 . 
 19-1137 . if (A le B)
 19-1138 . {
 19-1139 .    A = B + C;
 19-1140 .    D = E + F;
 19-1141 . }
 19-1142 . 
 19-1143 . A = B+C;
 19-1144 . A = B*C;
 19-1145 . A = B*C;
 19-1146 . A = B*C;
 19-1147 . A = B-C;
 19-1148 . A = B-C;
 19-1149 . A = B+C;
 19-1150 . 
 19-1151 . if (A lt B)
 19-1152 . {
 19-1153 .    A = B + C;
 19-1154 .    D = E + F;
 19-1155 . }
 19-1156 . 
 19-1157 . A = B+C;
 19-1158 . A = B*C;
 19-1159 . /* LE SV TOC-1493 this is a fdp-07.6.37 req to recover*/
 19-1160 . A = B*C;
 19-1161 . A = B+C;
 19-1162 . A = 0x0008;
 19-1163 . A = B-C;
 19-1164 . 
 19-1165 . if (A > = B)
 19-1166 . {
 19-1167 .    A = B + C;
 19-1168 .    D = E + F;
 19-1169 . }
 19-1170 . 
 19-1171 . /* LE SV TOC-1494 this is a fdp-07.6.41 req to recover*/
 19-1172 . A = B/C;
 19-1173 . A = B*C;
 19-1174 . A = B+C;
 19-1175 . 
 19-1176 . switch (fdp stuff)
 19-1177 . {
 19-1178 .    case one:
 19-1179 .    {
 19-1180 .       run_this; 
 19-1181 .       break;
 19-1182 .    }
 19-1183 .    case two:
 19-1184 .    {
 19-1185 .       run_this;
 19-1186 .       break;
 19-1187 .    }
 19-1188 .    default:
 19-1189 .    {
 19-1190 .        SwError;
 19-1191 .    }
 19-1192 . }
 19-1193 . 
 19-1194 . 
 19-1195 . if (A <  B)
 19-1196 . {
 19-1197 .    A = B + C;
 19-1198 .    D = E + F;
 19-1199 . }
 19-1200 . 
 19-1201 . A = B-C;
 19-1202 . A = B+C;
 19-1203 . A = B-C;
 19-1204 . A = B*C;
 19-1205 . A = B/C;
 19-1206 . A = B-C;
 19-1207 . 
 19-1208 . if (A eq B)
 19-1209 . {
 19-1210 .    A = B + C;
 19-1211 .    D = E + F;
 19-1212 . }
 19-1213 . 
 19-1214 . A = B*C;
 19-1215 . 
 19-1216 . if (A ge B)
 19-1217 . {
 19-1218 .    A = B + C;
 19-1219 .    D = E + F;
 19-1220 . }
 19-1221 . 
 19-1222 . 
 19-1223 . if (A < = B)
 19-1224 . {
 19-1225 .    A = B + C;
 19-1226 .    D = E + F;
 19-1227 . }
 19-1228 . 
 19-1229 . 
 19-1230 . if (A >  B)
 19-1231 . {
 19-1232 .    A = B + C;
 19-1233 .    D = E + F;
 19-1234 . }
 19-1235 . 
 19-1236 . 
 19-1237 . if (A lt B)
 19-1238 . {
 19-1239 .    A = B + C;
 19-1240 .    D = E + F;
 19-1241 . }
 19-1242 . 
 19-1243 . A = B+C;
 19-1244 . 
 19-1245 . if (A lt B)
 19-1246 . {
 19-1247 .    A = B + C;
 19-1248 .    D = E + F;
 19-1249 . }
 19-1250 . 
 19-1251 . A = B*C;
 19-1252 . 
 19-1253 . if (A eq B)
 19-1254 . {
 19-1255 .    A = B + C;
 19-1256 .    D = E + F;
 19-1257 . }
 19-1258 . 
 19-1259 . A = B*C;
 19-1260 . A = B*C;
 19-1261 . A = B+C;
 19-1262 . A = B-C;
 19-1263 . 
 19-1264 . if (A ge B)
 19-1265 . {
 19-1266 .    A = B + C;
 19-1267 .    D = E + F;
 19-1268 . }
 19-1269 . 
 19-1270 . A = B*C;
 19-1271 . A = B+C;
 19-1272 . A = B-C;
 19-1273 . A = B-C;
 19-1274 . A = B*C;
 19-1275 . A = B/C;
 19-1276 . A = B+C;
 19-1277 . A = B*C;
 19-1278 . /* LE SV TOC-1495 this is a fdp-07.6.75 req to recover*/
 19-1279 . A = B*C;
 19-1280 . A = B/C;
 19-1281 . A = B+C;
 19-1282 . A = B-C;
 19-1283 . A = B+C;
 19-1284 . A = B*C;
 19-1285 . 
 19-1286 . switch (fdp stuff)
 19-1287 . {
 19-1288 .    case one:
 19-1289 .    {
 19-1290 .       switch (nested)
 19-1291 .       {
 19-1292 .          case:
 19-1293 .             X = Y + Z;
 19-1294 .          case:
 19-1295 .             X = Y + Z;
 19-1296 .          default:
 19-1297 .             SwError;
 19-1298 .       } 
 19-1299 .    }
 19-1300 .    case two:
 19-1301 .    {
 19-1302 .       run_this;
 19-1303 .       break;
 19-1304 .    }
 19-1305 .    default:
 19-1306 .    {
 19-1307 .       SwError;
 19-1308 .    }
 19-1309 . }
 19-1310 . 
 19-1311 . 
 19-1312 . if (A le B)
 19-1313 . {
 19-1314 .    A = B + C;
 19-1315 .    D = E + F;
 19-1316 . }
 19-1317 . 
 19-1318 . 
 19-1319 . if (A != B)
 19-1320 . {
 19-1321 .    A = B + C;
 19-1322 .    D = E + F;
 19-1323 . }
 19-1324 . 
 19-1325 . A = B-C;
 19-1326 . 
 19-1327 . if (A != B)
 19-1328 . {
 19-1329 .    A = B + C;
 19-1330 .    D = E + F;
 19-1331 . }
 19-1332 . 
 19-1333 . // max LOC 84
 19-1334 . 
 19-1335 . }
 19-1336 . 
 19-1337 . 
 19-1338 . /*
 19-1339 . -----------------------------------------------------------------------------
 19-1340 . --| NAME:   fdp.7.7
 19-1341 . --|
 19-1342 . --| ABSTRACT:
 19-1343 . --|   This function does fdp stuff.
 19-1344 . --|
 19-1345 . --| RETURNS:
 19-1346 . --|   NONE.
 19-1347 . --|
 19-1348 . ----------------------------------------------------------------------------
 19-1349 . */
 19-1350 . static void fdp.7.7(void)
 19-1351 . {
 19-1352 . A = B*C;
 19-1353 . A = B+C;
 19-1354 . A = B*C;
 19-1355 . A = B-C;
 19-1356 . A = B-C;
 19-1357 . A = B-C;
 19-1358 . A = B+C;
 19-1359 . A = B*C;
 19-1360 . 
 19-1361 . if (A lt B)
 19-1362 . {
 19-1363 .    A = B + C;
 19-1364 .    D = E + F;
 19-1365 . }
 19-1366 . 
 19-1367 . A = B/C;
 19-1368 . /* LE SV TOC-1496 this is a fdp-07.7.11 req to compare*/
 19-1369 . A = B/C;
 19-1370 . 
 19-1371 . if (A ge B)
 19-1372 . {
 19-1373 .    A = B + C;
 19-1374 .    D = E + F;
 19-1375 . }
 19-1376 . 
 19-1377 . 
 19-1378 . if (A gt B)
 19-1379 . {
 19-1380 .    A = B + C;
 19-1381 .    D = E + F;
 19-1382 . }
 19-1383 . 
 19-1384 . A = B+C;
 19-1385 . 
 19-1386 . if (A >  B)
 19-1387 . {
 19-1388 .    A = B + C;
 19-1389 .    D = E + F;
 19-1390 . }
 19-1391 . 
 19-1392 . A = B/C;
 19-1393 . 
 19-1394 . if (A ge B)
 19-1395 . {
 19-1396 .    A = B + C;
 19-1397 .    D = E + F;
 19-1398 . }
 19-1399 . 
 19-1400 . 
 19-1401 . if (A < = B)
 19-1402 . {
 19-1403 .    A = B + C;
 19-1404 .    D = E + F;
 19-1405 . }
 19-1406 . 
 19-1407 . A = B*C;
 19-1408 . A = B/C;
 19-1409 . 
 19-1410 . if (A > = B)
 19-1411 . {
 19-1412 .    A = B + C;
 19-1413 .    D = E + F;
 19-1414 . }
 19-1415 . 
 19-1416 . A = B/C;
 19-1417 . A = B*C;
 19-1418 . A = (int)B + C;
 19-1419 . A = B*C;
 19-1420 . A = B+C;
 19-1421 . A = B*C;
 19-1422 . 
 19-1423 . if (A le B)
 19-1424 . {
 19-1425 .    A = B + C;
 19-1426 .    D = E + F;
 19-1427 . }
 19-1428 . 
 19-1429 . 
 19-1430 . if (A ge B)
 19-1431 . {
 19-1432 .    A = B + C;
 19-1433 .    D = E + F;
 19-1434 . }
 19-1435 . 
 19-1436 . /* LE SV TOC-1497 this is a fdp-07.7.29 req to process*/
 19-1437 . A = B-C;
 19-1438 . A = 0x0003;
 19-1439 . A = B-C;
 19-1440 . /* LE SV TOC-1498 this is a fdp-07.7.31 req to update*/
 19-1441 . A = B*C;
 19-1442 . A = B*C;
 19-1443 . A = B*C;
 19-1444 . A = B-C;
 19-1445 . // TBD - what do I do now
 19-1446 . A = B+C;
 19-1447 . A = B-C;
 19-1448 . 
 19-1449 . if (A < = B)
 19-1450 . {
 19-1451 .    A = B + C;
 19-1452 .    D = E + F;
 19-1453 . }
 19-1454 . 
 19-1455 . // max LOC 37
 19-1456 . 
 19-1457 . }
 19-1458 . 
 19-1459 . 
 19-1460 . /*
 19-1461 . -----------------------------------------------------------------------------
 19-1462 . --| NAME:   fdp.7.8
 19-1463 . --|
 19-1464 . --| ABSTRACT:
 19-1465 . --|   This function does fdp stuff.
 19-1466 . --|
 19-1467 . --| RETURNS:
 19-1468 . --|   NONE.
 19-1469 . --|
 19-1470 . ----------------------------------------------------------------------------
 19-1471 . */
 19-1472 . static void fdp.7.8(void)
 19-1473 . {
 19-1474 . A = B-C;
 19-1475 . /* LE SV TOC-1499 this is a fdp-07.8.2 req to increment*/
 19-1476 . A = B-C;
 19-1477 . 
 19-1478 . switch (fdp stuff)
 19-1479 . {
 19-1480 .    case one:
 19-1481 .    {
 19-1482 .       run_this; 
 19-1483 .       break;
 19-1484 .    }
 19-1485 .    case two:
 19-1486 .    {
 19-1487 .       run_this;
 19-1488 .       break;
 19-1489 .    }
 19-1490 .    default:
 19-1491 .    {
 19-1492 .        SwError;
 19-1493 .    }
 19-1494 . }
 19-1495 . 
 19-1496 . A = B-C;
 19-1497 . A = B-C;
 19-1498 . A = B+C;
 19-1499 . A = B+C;
 19-1500 . A = B-C;
 19-1501 . 
 19-1502 . if (A lt B)
 19-1503 . {
 19-1504 .    A = B + C;
 19-1505 .    D = E + F;
 19-1506 . }
 19-1507 . 
 19-1508 . // max LOC 9
 19-1509 . 
 19-1510 . }
 19-1511 . 
 19-1512 . 
 19-1513 . /*
 19-1514 . -----------------------------------------------------------------------------
 19-1515 . --| NAME:   fdp.7.9
 19-1516 . --|
 19-1517 . --| ABSTRACT:
 19-1518 . --|   This function does fdp stuff.
 19-1519 . --|
 19-1520 . --| RETURNS:
 19-1521 . --|   NONE.
 19-1522 . --|
 19-1523 . ----------------------------------------------------------------------------
 19-1524 . */
 19-1525 . static void fdp.7.9(void)
 19-1526 . {
 19-1527 . 
 19-1528 . if (A gt B)
 19-1529 . {
 19-1530 .    A = B + C;
 19-1531 .    D = E + F;
 19-1532 . }
 19-1533 . 
 19-1534 . A = B*C;
 19-1535 . A = B/C;
 19-1536 . 
 19-1537 . if (A ne B)
 19-1538 . {
 19-1539 .    A = B + C;
 19-1540 .    D = E + F;
 19-1541 . }
 19-1542 . 
 19-1543 . A = B/C;
 19-1544 . A = B-C;
 19-1545 . A = B*C;
 19-1546 . 
 19-1547 . if (A != B)
 19-1548 . {
 19-1549 .    A = B + C;
 19-1550 .    D = E + F;
 19-1551 . }
 19-1552 . 
 19-1553 . 
 19-1554 . if (A > = B)
 19-1555 . {
 19-1556 .    A = B + C;
 19-1557 .    D = E + F;
 19-1558 . }
 19-1559 . 
 19-1560 . A = B/C;
 19-1561 . A = B/C;
 19-1562 . A = B/C;
 19-1563 . A = B*C;
 19-1564 . 
 19-1565 . switch (fdp stuff)
 19-1566 . {
 19-1567 .       case one:
 19-1568 .    {
 19-1569 .       run_this;
 19-1570 .       break;
 19-1571 .    }
 19-1572 .    case two:
 19-1573 .    {
 19-1574 .       run_this;
 19-1575 .       break;
 19-1576 .    }
 19-1577 .    default:
 19-1578 .    {
 19-1579 .       // missing error call
 19-1580 .    }
 19-1581 . }
 19-1582 . 
 19-1583 . 
 19-1584 . if (A le B)
 19-1585 . {
 19-1586 .    A = B + C;
 19-1587 .    D = E + F;
 19-1588 . }
 19-1589 . 
 19-1590 . 
 19-1591 . if (A eq B)
 19-1592 . {
 19-1593 .    A = B + C;
 19-1594 .    D = E + F;
 19-1595 . }
 19-1596 . 
 19-1597 . A = 0x0006;
 19-1598 . 
 19-1599 . if (A == B)
 19-1600 . {
 19-1601 .    A = B + C;
 19-1602 .    D = E + F;
 19-1603 . }
 19-1604 . 
 19-1605 . A = B*C;
 19-1606 . A = B-C;
 19-1607 . A = B-C;
 19-1608 . A = B-C;
 19-1609 . 
 19-1610 . if (A le B)
 19-1611 . {
 19-1612 .    A = B + C;
 19-1613 .    D = E + F;
 19-1614 . }
 19-1615 . 
 19-1616 . A = B+C;
 19-1617 . A = B-C;
 19-1618 . A = B+C;
 19-1619 . A = B*C;
 19-1620 . 
 19-1621 . if (A le B)
 19-1622 . {
 19-1623 .    A = B + C;
 19-1624 .    D = E + F;
 19-1625 . }
 19-1626 . 
 19-1627 . A = B/C;
 19-1628 . 
 19-1629 . if (A ne B)
 19-1630 . {
 19-1631 .    A = B + C;
 19-1632 .    D = E + F;
 19-1633 . }
 19-1634 . 
 19-1635 . A = B-C;
 19-1636 . A = B/C;
 19-1637 . 
 19-1638 . if (A lt B)
 19-1639 . {
 19-1640 .    A = B + C;
 19-1641 .    D = E + F;
 19-1642 . }
 19-1643 . 
 19-1644 . 
 19-1645 . if (A le B)
 19-1646 . {
 19-1647 .    A = B + C;
 19-1648 .    D = E + F;
 19-1649 . }
 19-1650 . 
 19-1651 . A = B/C;
 19-1652 . A = B/C;
 19-1653 . A = B-C;
 19-1654 . 
 19-1655 . if (A le B)
 19-1656 . {
 19-1657 .    A = B + C;
 19-1658 .    D = E + F;
 19-1659 . }
 19-1660 . 
 19-1661 . /* LE SV TOC-1500 this is a fdp-07.9.37 req to compare*/
 19-1662 . A = B*C;
 19-1663 . A = B*C;
 19-1664 . A = B+C;
 19-1665 . A = B/C;
 19-1666 . A = B-C;
 19-1667 . A = B/C;
 19-1668 . A = B/C;
 19-1669 . A = B*C;
 19-1670 . A = B-C;
 19-1671 . A = B*C;
 19-1672 . // max LOC 46
 19-1673 . 
 19-1674 . }
 19-1675 . 

19 19 Result: result/source/ft-app/ft-app-B1.1/fdp/fdp-07.c


20 20 Source: source/ft-app/ft-app-B1.1/fdp/fdp-08.c
 20-0 . /*
 20-1 . ----------------------------------------------------------------------------
 20-2 . --| BEGIN PROLOGUE
 20-3 . --|
 20-4 . --| CLASSIFICATION: UNCLASSIFIED
 20-5 . --|
 20-6 . --| FILE NAME:      fdp-08.c
 20-7 . --|
 20-8 . --| ABSTRACT:
 20-9 . --|   This file contains the 3 functions that do file fdp stuff.
 20-10 . --|
 20-11 . --| HISTORY:
 20-12 . --|   CCCQ_NAME:
 20-13 . --|   CCCQ_VER: 
 20-14 . --|
 20-15 . --| END PROLOGUE
 20-16 . ----------------------------------------------------------------------------
 20-17 . */
 20-18 . 
 20-19 . double C;
 20-20 . #include B;
 20-21 . #define C;
 20-22 . #define A;
 20-23 . double C;
 20-24 . #define A;
 20-25 . #define D;
 20-26 . 
 20-27 . 
 20-28 . 
 20-29 . /*
 20-30 . -----------------------------------------------------------------------------
 20-31 . --| NAME:   fdp.8.1
 20-32 . --|
 20-33 . --| ABSTRACT:
 20-34 . --|   This function does fdp stuff.
 20-35 . --|
 20-36 . --| RETURNS:
 20-37 . --|   NONE.
 20-38 . --|
 20-39 . ----------------------------------------------------------------------------
 20-40 . */
 20-41 . static void fdp.8.1(void)
 20-42 . {
 20-43 . A = B+C;
 20-44 . /* LE SV TOC-1501 this is a fdp-08.1.2 req to process*/
 20-45 . A = B/C;
 20-46 . 
 20-47 . if (A le B)
 20-48 . {
 20-49 .    A = B + C;
 20-50 .    D = E + F;
 20-51 . }
 20-52 . 
 20-53 . 
 20-54 . if (A != B)
 20-55 . {
 20-56 .    A = B + C;
 20-57 .    D = E + F;
 20-58 . }
 20-59 . 
 20-60 . A = B-C;
 20-61 . A = 0x0004;
 20-62 . A = B/C;
 20-63 . A = B+C;
 20-64 . 
 20-65 . if (A < = B)
 20-66 . {
 20-67 .    A = B + C;
 20-68 .    D = E + F;
 20-69 . }
 20-70 . 
 20-71 . A = B*C;
 20-72 . 
 20-73 . if (A le B)
 20-74 . {
 20-75 .    A = B + C;
 20-76 .    D = E + F;
 20-77 . }
 20-78 . 
 20-79 . A = B-C;
 20-80 . A = B/C;
 20-81 . A = B-C;
 20-82 . A = B-C;
 20-83 . do forever;
 20-84 . 
 20-85 . if (A < = B)
 20-86 . {
 20-87 .    A = B + C;
 20-88 .    D = E + F;
 20-89 . }
 20-90 . 
 20-91 . A = B*C;
 20-92 . A = B/C;
 20-93 . A = B*C;
 20-94 . 
 20-95 . if (A gt B)
 20-96 . {
 20-97 .    A = B + C;
 20-98 .    D = E + F;
 20-99 . }
 20-100 . 
 20-101 . 
 20-102 . if (A > = B)
 20-103 . {
 20-104 .    A = B + C;
 20-105 .    D = E + F;
 20-106 . }
 20-107 . 
 20-108 . A = B/C;
 20-109 . A = B-C;
 20-110 . A = B/C;
 20-111 . A = B+C;
 20-112 . send_buffer = (U16 *) malloc(size+1);
 20-113 . A = B-C;
 20-114 . A = B*C;
 20-115 . A = B-C;
 20-116 . A = B*C;
 20-117 . A = B-C;
 20-118 . A = B*C;
 20-119 . A = B*C;
 20-120 . A = B*C;
 20-121 . A = B+C;
 20-122 . /* LE SV TOC-1502 this is a fdp-08.1.34 req to store*/
 20-123 . 
 20-124 . if (A gt B)
 20-125 . {
 20-126 .    A = B + C;
 20-127 .    D = E + F;
 20-128 . }
 20-129 . 
 20-130 . 
 20-131 . if (A == B)
 20-132 . {
 20-133 .    A = B + C;
 20-134 .    D = E + F;
 20-135 . }
 20-136 . 
 20-137 . A = B-C;
 20-138 . A = B*C;
 20-139 . 
 20-140 . if (A gt B)
 20-141 . {
 20-142 .    A = B + C;
 20-143 .    D = E + F;
 20-144 . }
 20-145 . 
 20-146 . A = B*C;
 20-147 . A = B+C;
 20-148 . /* LE SV TOC-1503 this is a fdp-08.1.41 req to enable*/
 20-149 . A = B/C;
 20-150 . 
 20-151 . if ($fdp stuff >  $otherfdp stuff) 
 20-152 . /* LE SV TOC-008 we really should log all error calls */
 20-153 . {
 20-154 .    A = B + C;
 20-155 . }
 20-156 . 
 20-157 . A = B/C;
 20-158 . A = B*C;
 20-159 . A = B/C;
 20-160 . A = B*C;
 20-161 . 
 20-162 . if (A eq B)
 20-163 . {
 20-164 .    A = B + C;
 20-165 .    D = E + F;
 20-166 . }
 20-167 . 
 20-168 . // max LOC 46
 20-169 . 
 20-170 . }
 20-171 . 
 20-172 . 
 20-173 . /*
 20-174 . -----------------------------------------------------------------------------
 20-175 . --| NAME:   fdp.8.2
 20-176 . --|
 20-177 . --| ABSTRACT:
 20-178 . --|   This function does fdp stuff.
 20-179 . --|
 20-180 . --| RETURNS:
 20-181 . --|   NONE.
 20-182 . --|
 20-183 . ----------------------------------------------------------------------------
 20-184 . */
 20-185 . static void fdp.8.2(void)
 20-186 . {
 20-187 . A = B*C;
 20-188 . A = B+C;
 20-189 . A = B-C;
 20-190 . A = B+C;
 20-191 . A = B/C;
 20-192 . 
 20-193 . if (A ne B)
 20-194 . {
 20-195 .    A = B + C;
 20-196 .    D = E + F;
 20-197 . }
 20-198 . 
 20-199 . 
 20-200 . if (A > = B)
 20-201 . {
 20-202 .    A = B + C;
 20-203 .    D = E + F;
 20-204 . }
 20-205 . 
 20-206 . /* LE SV TOC-1504 this is a fdp-08.2.8 req to set Real Time Clock*/
 20-207 . A = B*C;
 20-208 . A = B*C;
 20-209 . 
 20-210 . switch (fdp stuff)
 20-211 . {
 20-212 .    case one:
 20-213 .    {
 20-214 .       run_this; 
 20-215 .       break;
 20-216 .    }
 20-217 .    case two:
 20-218 .    {
 20-219 .       run_this;
 20-220 .       break;
 20-221 .    }
 20-222 .    default:
 20-223 .    {
 20-224 .        SwError;
 20-225 .    }
 20-226 . }
 20-227 . 
 20-228 . A = B+C;
 20-229 . 
 20-230 . if (A == B)
 20-231 . {
 20-232 .    A = B + C;
 20-233 .    D = E + F;
 20-234 . }
 20-235 . 
 20-236 . A = B-C;
 20-237 . A = B/C;
 20-238 . /* LE SV TOC-1505 this is a fdp-08.2.15 req to detect error*/
 20-239 . A = B-C;
 20-240 . A = B-C;
 20-241 . A = B/C;
 20-242 . A = B+C;
 20-243 . A = B-C;
 20-244 . A = B*C;
 20-245 . A = B*C;
 20-246 . A = B+C;
 20-247 . A = B*C;
 20-248 . A = B*C;
 20-249 . A = B-C;
 20-250 . 
 20-251 . if (A > = B)
 20-252 . {
 20-253 .    A = B + C;
 20-254 .    D = E + F;
 20-255 . }
 20-256 . 
 20-257 . // max LOC 26
 20-258 . 
 20-259 . }
 20-260 . 
 20-261 . 
 20-262 . /*
 20-263 . -----------------------------------------------------------------------------
 20-264 . --| NAME:   fdp.8.3
 20-265 . --|
 20-266 . --| ABSTRACT:
 20-267 . --|   This function does fdp stuff.
 20-268 . --|
 20-269 . --| RETURNS:
 20-270 . --|   NONE.
 20-271 . --|
 20-272 . ----------------------------------------------------------------------------
 20-273 . */
 20-274 . static void fdp.8.3(void)
 20-275 . {
 20-276 . /* LE SV TOC-1506 this is a fdp-08.3.1 req to update*/
 20-277 . 
 20-278 . if (A eq B)
 20-279 . {
 20-280 .    A = B + C;
 20-281 .    D = E + F;
 20-282 . }
 20-283 . 
 20-284 . A = 0x0004;
 20-285 . 
 20-286 . if (A < = B)
 20-287 . {
 20-288 .    A = B + C;
 20-289 .    D = E + F;
 20-290 . }
 20-291 . 
 20-292 . A = B/C;
 20-293 . A = B*C;
 20-294 . 
 20-295 . if (A > = B)
 20-296 . {
 20-297 .    A = B + C;
 20-298 .    D = E + F;
 20-299 . }
 20-300 . 
 20-301 . A = B+C;
 20-302 . 
 20-303 . if (A ge B)
 20-304 . {
 20-305 .    A = B + C;
 20-306 .    D = E + F;
 20-307 . }
 20-308 . 
 20-309 . A = B/C;
 20-310 . 
 20-311 . if (A <  B)
 20-312 . {
 20-313 .    A = B + C;
 20-314 .    D = E + F;
 20-315 . }
 20-316 . 
 20-317 . A = B+C;
 20-318 . A = B/C;
 20-319 . A = B*C;
 20-320 . A = B*C;
 20-321 . A = B/C;
 20-322 . A = B/C;
 20-323 . A = B+C;
 20-324 . 
 20-325 . if (A != B)
 20-326 . {
 20-327 .    A = B + C;
 20-328 .    D = E + F;
 20-329 . }
 20-330 . 
 20-331 . A = B*C;
 20-332 . A = B+C;
 20-333 . A = B-C;
 20-334 . A = B*C;
 20-335 . /* LE SV TOC-1507 this is a fdp-08.3.22 req to halt*/
 20-336 . // TBD - what do I do now
 20-337 . A = B-C;
 20-338 . 
 20-339 . if (A == B)
 20-340 . {
 20-341 .    A = B + C;
 20-342 .    D = E + F;
 20-343 . }
 20-344 . 
 20-345 . 
 20-346 . if (A ne B)
 20-347 . {
 20-348 .    A = B + C;
 20-349 .    D = E + F;
 20-350 . }
 20-351 . 
 20-352 . 
 20-353 . if (A == B)
 20-354 . {
 20-355 .    A = B + C;
 20-356 .    D = E + F;
 20-357 . }
 20-358 . 
 20-359 . A = B-C;
 20-360 . 
 20-361 . if (A >  B)
 20-362 . {
 20-363 .    A = B + C;
 20-364 .    D = E + F;
 20-365 . }
 20-366 . 
 20-367 . /* LE SV TOC-1508 this is a fdp-08.3.28 req to check unix*/
 20-368 . A = B-C;
 20-369 . 
 20-370 . if (A gt B)
 20-371 . {
 20-372 .    A = B + C;
 20-373 .    D = E + F;
 20-374 . }
 20-375 . 
 20-376 . goto error;
 20-377 . A = B-C;
 20-378 . A = B+C;
 20-379 . 
 20-380 . if (A < = B)
 20-381 . {
 20-382 .    A = B + C;
 20-383 .    D = E + F;
 20-384 . }
 20-385 . 
 20-386 . 
 20-387 . if (A >  B)
 20-388 . {
 20-389 .    A = B + C;
 20-390 .    D = E + F;
 20-391 . }
 20-392 . 
 20-393 . A = B/C;
 20-394 . A = B/C;
 20-395 . A = B-C;
 20-396 . A = B+C;
 20-397 . A = B-C;
 20-398 . 
 20-399 . if (A le B)
 20-400 . {
 20-401 .    A = B + C;
 20-402 .    D = E + F;
 20-403 . }
 20-404 . 
 20-405 . A = 0x0003;
 20-406 . 
 20-407 . if (A != B)
 20-408 . {
 20-409 .    A = B + C;
 20-410 .    D = E + F;
 20-411 . }
 20-412 . 
 20-413 . 
 20-414 . if (A < = B)
 20-415 . {
 20-416 .    A = B + C;
 20-417 .    D = E + F;
 20-418 . }
 20-419 . 
 20-420 . A = B*C;
 20-421 . A = B+C;
 20-422 . 
 20-423 . if (A != B)
 20-424 . {
 20-425 .    A = B + C;
 20-426 .    D = E + F;
 20-427 . }
 20-428 . 
 20-429 . A = B+C;
 20-430 . A = B/C;
 20-431 . // TBS - I need to figure this out
 20-432 . 
 20-433 . if (A le B)
 20-434 . {
 20-435 .    A = B + C;
 20-436 .    D = E + F;
 20-437 . }
 20-438 . 
 20-439 . A = B-C;
 20-440 . 
 20-441 . if (A <  B)
 20-442 . {
 20-443 .    A = B + C;
 20-444 .    D = E + F;
 20-445 . }
 20-446 . 
 20-447 . 
 20-448 . if (A gt B)
 20-449 . {
 20-450 .    A = B + C;
 20-451 .    D = E + F;
 20-452 . }
 20-453 . 
 20-454 . 
 20-455 . if (A != B)
 20-456 . {
 20-457 .    A = B + C;
 20-458 .    D = E + F;
 20-459 . }
 20-460 . 
 20-461 . A = B+C;
 20-462 . A = B+C;
 20-463 . A = B*C;
 20-464 . A = B/C;
 20-465 . A = B*C;
 20-466 . A = B/C;
 20-467 . A = B-C;
 20-468 . 
 20-469 . if (A > = B)
 20-470 . {
 20-471 .    A = B + C;
 20-472 .    D = E + F;
 20-473 . }
 20-474 . 
 20-475 . 
 20-476 . if (A gt B)
 20-477 . {
 20-478 .    A = B + C;
 20-479 .    D = E + F;
 20-480 . }
 20-481 . 
 20-482 . 
 20-483 . if (A > = B)
 20-484 . {
 20-485 .    A = B + C;
 20-486 .    D = E + F;
 20-487 . }
 20-488 . 
 20-489 . // max LOC 61
 20-490 . 
 20-491 . }
 20-492 . 

20 20 Result: result/source/ft-app/ft-app-B1.1/fdp/fdp-08.c


21 21 Source: source/ft-app/ft-app-B1.1/fdp/p_fdp-06.c
 21-0 . /*
 21-1 . ----------------------------------------------------------------------------
 21-2 . --| BEGIN PROLOGUE
 21-3 . --|
 21-4 . --| CLASSIFICATION: UNCLASSIFIED
 21-5 . --|
 21-6 . --| FILE NAME:      p_fdp-06.c
 21-7 . --|
 21-8 . --| ABSTRACT:
 21-9 . --|   This file contains the 12 functions that do file fdp stuff.
 21-10 . --|
 21-11 . --| HISTORY:
 21-12 . --|   CCCQ_NAME:
 21-13 . --|   CCCQ_VER: 
 21-14 . --|
 21-15 . --| END PROLOGUE
 21-16 . ----------------------------------------------------------------------------
 21-17 . */
 21-18 . 
 21-19 . #define D;
 21-20 . int A;
 21-21 . #define A;
 21-22 . #include B;
 21-23 . int A;
 21-24 . char D;
 21-25 . #include B;
 21-26 . #include B;
 21-27 . 
 21-28 . 
 21-29 . 
 21-30 . /*
 21-31 . -----------------------------------------------------------------------------
 21-32 . --| NAME:   fdp.6.1
 21-33 . --|
 21-34 . --| ABSTRACT:
 21-35 . --|   This function does fdp stuff.
 21-36 . --|
 21-37 . --| RETURNS:
 21-38 . --|   NONE.
 21-39 . --|
 21-40 . ----------------------------------------------------------------------------
 21-41 . */
 21-42 . static void fdp.6.1(void)
 21-43 . {
 21-44 . 
 21-45 . if (A gt B)
 21-46 . {
 21-47 .    A = B + C;
 21-48 .    D = E + F;
 21-49 . }
 21-50 . 
 21-51 . 
 21-52 . if (A == B)
 21-53 . {
 21-54 .    A = B + C;
 21-55 .    D = E + F;
 21-56 . }
 21-57 . 
 21-58 . A = B/C;
 21-59 . A = B*C;
 21-60 . 
 21-61 . if (A gt B)
 21-62 . {
 21-63 .    A = B + C;
 21-64 .    D = E + F;
 21-65 . }
 21-66 . 
 21-67 . A = B+C;
 21-68 . 
 21-69 . if (A ge B)
 21-70 . {
 21-71 .    A = B + C;
 21-72 .    D = E + F;
 21-73 . }
 21-74 . 
 21-75 . A = B-C;
 21-76 . 
 21-77 . if (A <  B)
 21-78 . {
 21-79 .    A = B + C;
 21-80 .    D = E + F;
 21-81 . }
 21-82 . 
 21-83 . 
 21-84 . if (A ne B)
 21-85 . {
 21-86 .    A = B + C;
 21-87 .    D = E + F;
 21-88 . }
 21-89 . 
 21-90 . A = B*C;
 21-91 . 
 21-92 . if (A eq B)
 21-93 . {
 21-94 .    A = B + C;
 21-95 .    D = E + F;
 21-96 . }
 21-97 . 
 21-98 . 
 21-99 . if (A != B)
 21-100 . {
 21-101 .    A = B + C;
 21-102 .    D = E + F;
 21-103 . }
 21-104 . 
 21-105 . A = 0x0001;
 21-106 . 
 21-107 . if (A ne B)
 21-108 . {
 21-109 .    A = B + C;
 21-110 .    D = E + F;
 21-111 . }
 21-112 . 
 21-113 . A = B+C;
 21-114 . A = B-C;
 21-115 . /* LE SV TOC-1456 this is a p_fdp-06.1.17 req to translate*/
 21-116 . A = B*C;
 21-117 . A = B/C;
 21-118 . 
 21-119 . if (A le B)
 21-120 . {
 21-121 .    A = B + C;
 21-122 .    D = E + F;
 21-123 . }
 21-124 . 
 21-125 . A = B-C;
 21-126 . A = B/C;
 21-127 . /* LE SV TOC-1457 this is a p_fdp-06.1.22 req to set Real Time Clock*/
 21-128 . 
 21-129 . if (A le B)
 21-130 . {
 21-131 .    A = B + C;
 21-132 .    D = E + F;
 21-133 . }
 21-134 . 
 21-135 . A = B+C;
 21-136 . A = B*C;
 21-137 . // max LOC 24
 21-138 . 
 21-139 . }
 21-140 . 
 21-141 . 
 21-142 . /*
 21-143 . -----------------------------------------------------------------------------
 21-144 . --| NAME:   fdp.6.2
 21-145 . --|
 21-146 . --| ABSTRACT:
 21-147 . --|   This function does fdp stuff.
 21-148 . --|
 21-149 . --| RETURNS:
 21-150 . --|   NONE.
 21-151 . --|
 21-152 . ----------------------------------------------------------------------------
 21-153 . */
 21-154 . static void fdp.6.2(void)
 21-155 . {
 21-156 . A = B/C;
 21-157 . A = B*C;
 21-158 . A = B/C;
 21-159 . A = B*C;
 21-160 . /* LE SV TOC-1458 this is a p_fdp-06.2.5 req to compare*/
 21-161 . 
 21-162 . if (A eq B)
 21-163 . {
 21-164 .    A = B + C;
 21-165 .    D = E + F;
 21-166 . }
 21-167 . 
 21-168 . A = B+C;
 21-169 . A = B*C;
 21-170 . 
 21-171 . if (A le B)
 21-172 . {
 21-173 .    A = B + C;
 21-174 .    D = E + F;
 21-175 . }
 21-176 . 
 21-177 . A = B-C;
 21-178 . A = B*C;
 21-179 . A = B+C;
 21-180 . // max LOC 11
 21-181 . 
 21-182 . }
 21-183 . 
 21-184 . 
 21-185 . /*
 21-186 . -----------------------------------------------------------------------------
 21-187 . --| NAME:   fdp.6.3
 21-188 . --|
 21-189 . --| ABSTRACT:
 21-190 . --|   This function does fdp stuff.
 21-191 . --|
 21-192 . --| RETURNS:
 21-193 . --|   NONE.
 21-194 . --|
 21-195 . ----------------------------------------------------------------------------
 21-196 . */
 21-197 . static void fdp.6.3(void)
 21-198 . {
 21-199 . A = B/C;
 21-200 . A = B/C;
 21-201 . 
 21-202 . if (A lt B)
 21-203 . {
 21-204 .    A = B + C;
 21-205 .    D = E + F;
 21-206 . }
 21-207 . 
 21-208 . A = B/C;
 21-209 . A = B/C;
 21-210 . 
 21-211 . if (A == B)
 21-212 . {
 21-213 .    A = B + C;
 21-214 .    D = E + F;
 21-215 . }
 21-216 . 
 21-217 . A = B/C;
 21-218 . 
 21-219 . switch (fdp stuff)
 21-220 . {
 21-221 .    case one:
 21-222 .    {
 21-223 .       run_this; 
 21-224 .       break;
 21-225 .    }
 21-226 .    case two:
 21-227 .    {
 21-228 .       run_this;
 21-229 .       break;
 21-230 .    }
 21-231 .    default:
 21-232 .    {
 21-233 .        SwError;
 21-234 .    }
 21-235 . }
 21-236 . 
 21-237 . 
 21-238 . if (A lt B)
 21-239 . {
 21-240 .    A = B + C;
 21-241 .    D = E + F;
 21-242 . }
 21-243 . 
 21-244 . A = B/C;
 21-245 . A = 0x0009;
 21-246 . 
 21-247 . if (A ne B)
 21-248 . {
 21-249 .    A = B + C;
 21-250 .    D = E + F;
 21-251 . }
 21-252 . 
 21-253 . A = B/C;
 21-254 . A = B-C;
 21-255 . A = B+C;
 21-256 . /* LE SV TOC-1459 this is a p_fdp-06.3.15 req to detect error*/
 21-257 . A = B/C;
 21-258 . A = B*C;
 21-259 . 
 21-260 . if (A >  B)
 21-261 . {
 21-262 .    A = B + C;
 21-263 .    D = E + F;
 21-264 . }
 21-265 . 
 21-266 . A = B-C;
 21-267 . A = B-C;
 21-268 . A = B/C;
 21-269 . A = B*C;
 21-270 . A = 0x0003;
 21-271 . 
 21-272 . if (A eq B)
 21-273 . {
 21-274 .    A = B + C;
 21-275 .    D = E + F;
 21-276 . }
 21-277 . 
 21-278 . 
 21-279 . switch (fdp stuff)
 21-280 . {
 21-281 .    case one:
 21-282 .    {
 21-283 .       run_this;
 21-284 .       break;
 21-285 .    }
 21-286 .    case two:
 21-287 .    {
 21-288 .       run_this;
 21-289 .       break;
 21-290 .    }
 21-291 .    // missing default
 21-292 . }
 21-293 . 
 21-294 . A = B/C;
 21-295 . A = B-C;
 21-296 . 
 21-297 . if (A lt B)
 21-298 . {
 21-299 .    A = B + C;
 21-300 .    D = E + F;
 21-301 . }
 21-302 . 
 21-303 . A = B/C;
 21-304 . A = B-C;
 21-305 . 
 21-306 . if (A > = B)
 21-307 . {
 21-308 .    A = B + C;
 21-309 .    D = E + F;
 21-310 . }
 21-311 . 
 21-312 . A = B*C;
 21-313 . 
 21-314 . if (A ne B)
 21-315 . {
 21-316 .    A = B + C;
 21-317 .    D = E + F;
 21-318 . }
 21-319 . 
 21-320 . A = B/C;
 21-321 . A = B+C;
 21-322 . A = B/C;
 21-323 . A = B+C;
 21-324 . A = B*C;
 21-325 . /* LE SV TOC-1460 this is a p_fdp-06.3.36 req to translate*/
 21-326 . A = B*C;
 21-327 . /* LE SV TOC-1461 this is a p_fdp-06.3.37 req to reject*/
 21-328 . A = B/C;
 21-329 . A = B*C;
 21-330 . A = B/C;
 21-331 . A = B*C;
 21-332 . A = B-C;
 21-333 . A = B*C;
 21-334 . A = B-C;
 21-335 . A = B+C;
 21-336 . A = B-C;
 21-337 . 
 21-338 . switch (fdp stuff)
 21-339 . {
 21-340 .    case one:
 21-341 .    {
 21-342 .       run_this; 
 21-343 .       break;
 21-344 .    }
 21-345 .    case two:
 21-346 .    {
 21-347 .       run_this;
 21-348 .       break;
 21-349 .    }
 21-350 .    default:
 21-351 .    {
 21-352 .        SwError;
 21-353 .    }
 21-354 . }
 21-355 . 
 21-356 . 
 21-357 . if (A < = B)
 21-358 . {
 21-359 .    A = B + C;
 21-360 .    D = E + F;
 21-361 . }
 21-362 . 
 21-363 . 
 21-364 . if (A >  B)
 21-365 . {
 21-366 .    A = B + C;
 21-367 .    D = E + F;
 21-368 . }
 21-369 . 
 21-370 . A = B+C;
 21-371 . 
 21-372 . if (A le B)
 21-373 . {
 21-374 .    A = B + C;
 21-375 .    D = E + F;
 21-376 . }
 21-377 . 
 21-378 . A = B*C;
 21-379 . A = B*C;
 21-380 . 
 21-381 . if (veg)
 21-382 .    // missing curly brace
 21-383 .    variable = orange;
 21-384 . 
 21-385 . A = B*C;
 21-386 . A = B/C;
 21-387 . A = B*C;
 21-388 . 
 21-389 . if (A eq B)
 21-390 . {
 21-391 .    A = B + C;
 21-392 .    D = E + F;
 21-393 . }
 21-394 . 
 21-395 . // max LOC 56
 21-396 . 
 21-397 . }
 21-398 . 
 21-399 . 
 21-400 . /*
 21-401 . -----------------------------------------------------------------------------
 21-402 . --| NAME:   fdp.6.4
 21-403 . --|
 21-404 . --| ABSTRACT:
 21-405 . --|   This function does fdp stuff.
 21-406 . --|
 21-407 . --| RETURNS:
 21-408 . --|   NONE.
 21-409 . --|
 21-410 . ----------------------------------------------------------------------------
 21-411 . */
 21-412 . static void fdp.6.4(void)
 21-413 . {
 21-414 . A = B/C;
 21-415 . 
 21-416 . if (A == B)
 21-417 . {
 21-418 .    A = B + C;
 21-419 .    D = E + F;
 21-420 . }
 21-421 . 
 21-422 . A = B-C;
 21-423 . A = B/C;
 21-424 . 
 21-425 . if (A != B)
 21-426 . {
 21-427 .    A = B + C;
 21-428 .    D = E + F;
 21-429 . }
 21-430 . 
 21-431 . A = B-C;
 21-432 . A = B-C;
 21-433 . A = B+C;
 21-434 . 
 21-435 . switch (fdp stuff)
 21-436 . {
 21-437 .    case one:
 21-438 .    {
 21-439 .       switch (nested)
 21-440 .       {
 21-441 .          case:
 21-442 .             X = Y + Z;
 21-443 .          case:
 21-444 .             X = Y + Z;
 21-445 .          default:
 21-446 .             SwError;
 21-447 .       } 
 21-448 .    }
 21-449 .    case two:
 21-450 .    {
 21-451 .       run_this;
 21-452 .       break;
 21-453 .    }
 21-454 .    default:
 21-455 .    {
 21-456 .       SwError;
 21-457 .    }
 21-458 . }
 21-459 . 
 21-460 . 
 21-461 . if (A eq B)
 21-462 . {
 21-463 .    A = B + C;
 21-464 .    D = E + F;
 21-465 . }
 21-466 . 
 21-467 . A = B+C;
 21-468 . A = B*C;
 21-469 . A = 0x0004;
 21-470 . 
 21-471 . switch (fdp stuff)
 21-472 . {
 21-473 .    case:
 21-474 .    case:
 21-475 .    // stacked case statements but only if there is a new line in between
 21-476 . 
 21-477 .    case:
 21-478 .    case:
 21-479 .    case:
 21-480 .    {
 21-481 .       run_this;
 21-482 .       break;
 21-483 .    }
 21-484 .    default:
 21-485 .    {
 21-486 .       halt;
 21-487 .    }
 21-488 . }
 21-489 . 
 21-490 . 
 21-491 . if (A lt B)
 21-492 . {
 21-493 .    A = B + C;
 21-494 .    D = E + F;
 21-495 . }
 21-496 . 
 21-497 . A = B+C;
 21-498 . A = B/C;
 21-499 . A = B/C;
 21-500 . A = B-C;
 21-501 . A = B*C;
 21-502 . 
 21-503 . switch (fdp stuff)
 21-504 . {
 21-505 .    case one:
 21-506 .    {
 21-507 .       switch (nested)
 21-508 .       {
 21-509 .          case:
 21-510 .             X = Y + Z;
 21-511 .          case:
 21-512 .             X = Y + Z;
 21-513 .          default:
 21-514 .             SwError;
 21-515 .       } 
 21-516 .    }
 21-517 .    case two:
 21-518 .    {
 21-519 .       run_this;
 21-520 .       break;
 21-521 .    }
 21-522 .    default:
 21-523 .    {
 21-524 .       SwError;
 21-525 .    }
 21-526 . }
 21-527 . 
 21-528 . A = B/C;
 21-529 . A = B+C;
 21-530 . A = B+C;
 21-531 . A = B/C;
 21-532 . A = B+C;
 21-533 . A = B/C;
 21-534 . A = B+C;
 21-535 . A = B+C;
 21-536 . 
 21-537 . if (A ne B)
 21-538 . {
 21-539 .    A = B + C;
 21-540 .    D = E + F;
 21-541 . }
 21-542 . 
 21-543 . A = B-C;
 21-544 . 
 21-545 . if (A >  B)
 21-546 . {
 21-547 .    A = B + C;
 21-548 .    D = E + F;
 21-549 . }
 21-550 . 
 21-551 . A = B/C;
 21-552 . A = B+C;
 21-553 . A = B*C;
 21-554 . 
 21-555 . if (A ge B)
 21-556 . {
 21-557 .    A = B + C;
 21-558 .    D = E + F;
 21-559 . }
 21-560 . 
 21-561 . A = B/C;
 21-562 . A = B*C;
 21-563 . A = B/C;
 21-564 . A = B/C;
 21-565 . A = B+C;
 21-566 . 
 21-567 . if (A ne B)
 21-568 . {
 21-569 .    A = B + C;
 21-570 .    D = E + F;
 21-571 . }
 21-572 . 
 21-573 . 
 21-574 . if (A eq B)
 21-575 . {
 21-576 .    A = B + C;
 21-577 .    D = E + F;
 21-578 . }
 21-579 . 
 21-580 . A = B*C;
 21-581 . // max LOC 40
 21-582 . 
 21-583 . }
 21-584 . 
 21-585 . 
 21-586 . /*
 21-587 . -----------------------------------------------------------------------------
 21-588 . --| NAME:   fdp.6.5
 21-589 . --|
 21-590 . --| ABSTRACT:
 21-591 . --|   This function does fdp stuff.
 21-592 . --|
 21-593 . --| RETURNS:
 21-594 . --|   NONE.
 21-595 . --|
 21-596 . ----------------------------------------------------------------------------
 21-597 . */
 21-598 . static void fdp.6.5(void)
 21-599 . {
 21-600 . /* LE SV TOC-1462 this is a p_fdp-06.5.1 req to transform*/
 21-601 . A = B/C;
 21-602 . A = B*C;
 21-603 . /* LE SV TOC-1463 this is a p_fdp-06.5.3 req to process*/
 21-604 . 
 21-605 . if (A > = B)
 21-606 . {
 21-607 .    A = B + C;
 21-608 .    D = E + F;
 21-609 . }
 21-610 . 
 21-611 . A = B-C;
 21-612 . 
 21-613 . if (A ne B)
 21-614 . {
 21-615 .    A = B + C;
 21-616 .    D = E + F;
 21-617 . }
 21-618 . 
 21-619 . A = B-C;
 21-620 . A = B*C;
 21-621 . free(FreePtr);
 21-622 . A = B-C;
 21-623 . A = 0x0003;
 21-624 . 
 21-625 . if (veg)
 21-626 .    // missing curly brace
 21-627 .    variable = orange;
 21-628 . 
 21-629 . A = B/C;
 21-630 . // max LOC 9
 21-631 . 
 21-632 . }
 21-633 . 
 21-634 . 
 21-635 . /*
 21-636 . -----------------------------------------------------------------------------
 21-637 . --| NAME:   fdp.6.6
 21-638 . --|
 21-639 . --| ABSTRACT:
 21-640 . --|   This function does fdp stuff.
 21-641 . --|
 21-642 . --| RETURNS:
 21-643 . --|   NONE.
 21-644 . --|
 21-645 . ----------------------------------------------------------------------------
 21-646 . */
 21-647 . static void fdp.6.6(void)
 21-648 . {
 21-649 . 
 21-650 . if (A gt B)
 21-651 . {
 21-652 .    A = B + C;
 21-653 .    D = E + F;
 21-654 . }
 21-655 . 
 21-656 . 
 21-657 . if (A ne B)
 21-658 . {
 21-659 .    A = B + C;
 21-660 .    D = E + F;
 21-661 . }
 21-662 . 
 21-663 . A = B/C;
 21-664 . A = B-C;
 21-665 . 
 21-666 . if (A > = B)
 21-667 . {
 21-668 .    A = B + C;
 21-669 .    D = E + F;
 21-670 . }
 21-671 . 
 21-672 . A = B*C;
 21-673 . A = B+C;
 21-674 . A = B/C;
 21-675 . A = B+C;
 21-676 . A = B-C;
 21-677 . A = B-C;
 21-678 . 
 21-679 . if (A ge B)
 21-680 . {
 21-681 .    A = B + C;
 21-682 .    D = E + F;
 21-683 . }
 21-684 . 
 21-685 . A = B+C;
 21-686 . /* LE SV TOC-1464 this is a p_fdp-06.6.14 req to check pSOS*/
 21-687 . A = B+C;
 21-688 . /* LE SV TOC-1465 this is a p_fdp-06.6.15 req to translate*/
 21-689 . A = B/C;
 21-690 . 
 21-691 . if (A >  B)
 21-692 . {
 21-693 .    A = B + C;
 21-694 .    D = E + F;
 21-695 . }
 21-696 . 
 21-697 . /* LE SV TOC-1466 this is a p_fdp-06.6.17 req to check unix*/
 21-698 . 
 21-699 . if {
 21-700 .    X = Y + Z;
 21-701 . }
 21-702 . else {
 21-703 .    halt;
 21-704 . }
 21-705 . 
 21-706 . 
 21-707 . if (A < = B)
 21-708 . {
 21-709 .    A = B + C;
 21-710 .    D = E + F;
 21-711 . }
 21-712 . 
 21-713 . A = B-C;
 21-714 . A = B-C;
 21-715 . A = B/C;
 21-716 . A = B/C;
 21-717 . A = B+C;
 21-718 . A = B*C;
 21-719 . 
 21-720 . if (A le B)
 21-721 . {
 21-722 .    A = B + C;
 21-723 .    D = E + F;
 21-724 . }
 21-725 . 
 21-726 . A = B*C;
 21-727 . A = B/C;
 21-728 . /* LE SV TOC-1467 this is a p_fdp-06.6.27 req to set RTC*/
 21-729 . A = B*C;
 21-730 . A = B-C;
 21-731 . A = B*C;
 21-732 . A = B*C;
 21-733 . A = B/C;
 21-734 . A = B-C;
 21-735 . A = B/C;
 21-736 . 
 21-737 . switch (fdp stuff)
 21-738 . {
 21-739 .    case:
 21-740 .    case:
 21-741 .    // stacked case statements but only if there is a new line in between
 21-742 . 
 21-743 .    case:
 21-744 .    case:
 21-745 .    case:
 21-746 .    {
 21-747 .       run_this;
 21-748 .       break;
 21-749 .    }
 21-750 .    default:
 21-751 .    {
 21-752 .       halt;
 21-753 .    }
 21-754 . }
 21-755 . 
 21-756 . A = B-C;
 21-757 . 
 21-758 . if (A != B)
 21-759 . {
 21-760 .    A = B + C;
 21-761 .    D = E + F;
 21-762 . }
 21-763 . 
 21-764 . free(FreePtr);
 21-765 . A = B-C;
 21-766 . /* LE SV TOC-1468 this is a p_fdp-06.6.37 req to convert*/
 21-767 . goto error;
 21-768 . A = B-C;
 21-769 . A = B/C;
 21-770 . 
 21-771 . if (A < = B)
 21-772 . {
 21-773 .    A = B + C;
 21-774 .    D = E + F;
 21-775 . }
 21-776 . 
 21-777 . A = B*C;
 21-778 . /* LE SV TOC-1469 this is a p_fdp-06.6.41 req to increment*/
 21-779 . A = B-C;
 21-780 . A = B-C;
 21-781 . /* LE SV TOC-1470 this is a p_fdp-06.6.43 req to halt*/
 21-782 . A = B-C;
 21-783 . A = B/C;
 21-784 . A = B-C;
 21-785 . A = B-C;
 21-786 . A = B+C;
 21-787 . A = B/C;
 21-788 . A = B*C;
 21-789 . A = B/C;
 21-790 . 
 21-791 . if (A < = B)
 21-792 . {
 21-793 .    A = B + C;
 21-794 .    D = E + F;
 21-795 . }
 21-796 . 
 21-797 . A = B+C;
 21-798 . A = B+C;
 21-799 . 
 21-800 . if (A <  B)
 21-801 . {
 21-802 .    A = B + C;
 21-803 .    D = E + F;
 21-804 . }
 21-805 . 
 21-806 . A = B+C;
 21-807 . A = 0x0008;
 21-808 . A = B+C;
 21-809 . A = B*C;
 21-810 . A = B*C;
 21-811 . A = B+C;
 21-812 . A = 0x0006;
 21-813 . 
 21-814 . switch (fdp stuff)
 21-815 . {
 21-816 .    case one:
 21-817 .    {
 21-818 .       run_this; 
 21-819 .       break;
 21-820 .    }
 21-821 .    case two:
 21-822 .    {
 21-823 .       run_this;
 21-824 .       break;
 21-825 .    }
 21-826 .    default:
 21-827 .    {
 21-828 .        SwError;
 21-829 .    }
 21-830 . }
 21-831 . 
 21-832 . 
 21-833 . if (A >  B)
 21-834 . {
 21-835 .    A = B + C;
 21-836 .    D = E + F;
 21-837 . }
 21-838 . 
 21-839 . // max LOC 61
 21-840 . 
 21-841 . }
 21-842 . 
 21-843 . 
 21-844 . /*
 21-845 . -----------------------------------------------------------------------------
 21-846 . --| NAME:   fdp.6.7
 21-847 . --|
 21-848 . --| ABSTRACT:
 21-849 . --|   This function does fdp stuff.
 21-850 . --|
 21-851 . --| RETURNS:
 21-852 . --|   NONE.
 21-853 . --|
 21-854 . ----------------------------------------------------------------------------
 21-855 . */
 21-856 . static void fdp.6.7(void)
 21-857 . {
 21-858 . A = B-C;
 21-859 . A = B*C;
 21-860 . A = B/C;
 21-861 . 
 21-862 . switch (fdp stuff)
 21-863 . {
 21-864 .    case one:
 21-865 .    {
 21-866 .       run_this; 
 21-867 .       break;
 21-868 .    }
 21-869 .    case two:
 21-870 .    {
 21-871 .       run_this;
 21-872 .       break;
 21-873 .    }
 21-874 .    default:
 21-875 .    {
 21-876 .        SwError;
 21-877 .    }
 21-878 . }
 21-879 . 
 21-880 . A = B+C;
 21-881 . // max LOC 5
 21-882 . 
 21-883 . }
 21-884 . 
 21-885 . 
 21-886 . /*
 21-887 . -----------------------------------------------------------------------------
 21-888 . --| NAME:   fdp.6.8
 21-889 . --|
 21-890 . --| ABSTRACT:
 21-891 . --|   This function does fdp stuff.
 21-892 . --|
 21-893 . --| RETURNS:
 21-894 . --|   NONE.
 21-895 . --|
 21-896 . ----------------------------------------------------------------------------
 21-897 . */
 21-898 . static void fdp.6.8(void)
 21-899 . {
 21-900 . A = B+C;
 21-901 . A = B*C;
 21-902 . A = B+C;
 21-903 . /* LE SV TOC-1471 this is a p_fdp-06.8.4 req to translate*/
 21-904 . 
 21-905 . switch (fdp stuff)
 21-906 . {
 21-907 .    case one:
 21-908 .    {
 21-909 .       run_this; 
 21-910 .       break;
 21-911 .    }
 21-912 .    case two:
 21-913 .    {
 21-914 .       run_this;
 21-915 .       break;
 21-916 .    }
 21-917 .    default:
 21-918 .    {
 21-919 .        SwError;
 21-920 .    }
 21-921 . }
 21-922 . 
 21-923 . 
 21-924 . if (A < = B)
 21-925 . {
 21-926 .    A = B + C;
 21-927 .    D = E + F;
 21-928 . }
 21-929 . 
 21-930 . A = B-C;
 21-931 . A = B+C;
 21-932 . 
 21-933 . if (A gt B)
 21-934 . {
 21-935 .    A = B + C;
 21-936 .    D = E + F;
 21-937 . }
 21-938 . 
 21-939 . A = B-C;
 21-940 . A = B/C;
 21-941 . 
 21-942 . if (A <  B)
 21-943 . {
 21-944 .    A = B + C;
 21-945 .    D = E + F;
 21-946 . }
 21-947 . 
 21-948 . A = B*C;
 21-949 . A = B*C;
 21-950 . A = B-C;
 21-951 . A = B*C;
 21-952 . /* LE SV TOC-1472 this is a p_fdp-06.8.16 req to check pSOS*/
 21-953 . A = B*C;
 21-954 . A = B*C;
 21-955 . A = B/C;
 21-956 . 
 21-957 . if (A ne B)
 21-958 . {
 21-959 .    A = B + C;
 21-960 .    D = E + F;
 21-961 . }
 21-962 . 
 21-963 . goto error;
 21-964 . 
 21-965 . if (A lt B)
 21-966 . {
 21-967 .    A = B + C;
 21-968 .    D = E + F;
 21-969 . }
 21-970 . 
 21-971 . A = B-C;
 21-972 . A = B/C;
 21-973 . A = B/C;
 21-974 . 
 21-975 . /*
 21-976 . dead_block = C * D; 
 21-977 . dead_block = E * F;
 21-978 . */
 21-979 . 
 21-980 . A = B*C;
 21-981 . A = B+C;
 21-982 . /* LE SV TOC-1473 this is a p_fdp-06.8.26 req to disable*/
 21-983 . A = B/C;
 21-984 . A = B-C;
 21-985 . A = B*C;
 21-986 . A = B+C;
 21-987 . A = B*C;
 21-988 . A = B-C;
 21-989 . A = B*C;
 21-990 . A = B-C;
 21-991 . A = B+C;
 21-992 . 
 21-993 . if (A <  B)
 21-994 . {
 21-995 .    A = B + C;
 21-996 .    D = E + F;
 21-997 . }
 21-998 . 
 21-999 . A = B/C;
 21-1000 . A = B-C;
 21-1001 . /* LE SV TOC-1474 this is a p_fdp-06.8.38 req to record*/
 21-1002 . A = 0x0001;
 21-1003 . A = B+C;
 21-1004 . A = 0x0006;
 21-1005 . A = B-C;
 21-1006 . A = B*C;
 21-1007 . 
 21-1008 . if (A <  B)
 21-1009 . {
 21-1010 .    A = B + C;
 21-1011 .    D = E + F;
 21-1012 . }
 21-1013 . 
 21-1014 . A = B*C;
 21-1015 . A = B+C;
 21-1016 . 
 21-1017 . if (A == B)
 21-1018 . {
 21-1019 .    A = B + C;
 21-1020 .    D = E + F;
 21-1021 . }
 21-1022 . 
 21-1023 . 
 21-1024 . if (A gt B)
 21-1025 . {
 21-1026 .    A = B + C;
 21-1027 .    D = E + F;
 21-1028 . }
 21-1029 . 
 21-1030 . 
 21-1031 . if (A gt B)
 21-1032 . {
 21-1033 .    A = B + C;
 21-1034 .    D = E + F;
 21-1035 . }
 21-1036 . 
 21-1037 . A = B*C;
 21-1038 . /* LE SV TOC-1475 this is a p_fdp-06.8.48 req to increment*/
 21-1039 . A = B/C;
 21-1040 . 
 21-1041 . switch (fdp stuff)
 21-1042 . {
 21-1043 .    case one:
 21-1044 .    {
 21-1045 .       run_this; 
 21-1046 .       break;
 21-1047 .    }
 21-1048 .    case two:
 21-1049 .    {
 21-1050 .       run_this;
 21-1051 .       break;
 21-1052 .    }
 21-1053 .    default:
 21-1054 .    {
 21-1055 .        SwError;
 21-1056 .    }
 21-1057 . }
 21-1058 . 
 21-1059 . 
 21-1060 . switch (fdp stuff)
 21-1061 . {
 21-1062 .    case one:
 21-1063 .    {
 21-1064 .       run_this; 
 21-1065 .       break;
 21-1066 .    }
 21-1067 .    case two:
 21-1068 .    {
 21-1069 .       run_this;
 21-1070 .       break;
 21-1071 .    }
 21-1072 .    default:
 21-1073 .    {
 21-1074 .        SwError;
 21-1075 .    }
 21-1076 . }
 21-1077 . 
 21-1078 . A = B+C;
 21-1079 . A = B-C;
 21-1080 . A = B+C;
 21-1081 . 
 21-1082 . if (A ge B)
 21-1083 . {
 21-1084 .    A = B + C;
 21-1085 .    D = E + F;
 21-1086 . }
 21-1087 . 
 21-1088 . A = B/C;
 21-1089 . A = B-C;
 21-1090 . 
 21-1091 . if (A eq B)
 21-1092 . {
 21-1093 .    A = B + C;
 21-1094 .    D = E + F;
 21-1095 . }
 21-1096 . 
 21-1097 . A = B-C;
 21-1098 . 
 21-1099 . if (A ge B)
 21-1100 . {
 21-1101 .    A = B + C;
 21-1102 .    D = E + F;
 21-1103 . }
 21-1104 . 
 21-1105 . A = B/C;
 21-1106 . A = B+C;
 21-1107 . A = B+C;
 21-1108 . A = B*C;
 21-1109 . A = B-C;
 21-1110 . 
 21-1111 . switch (fdp stuff)
 21-1112 . {
 21-1113 .    case one:
 21-1114 .    {
 21-1115 .       run_this; 
 21-1116 .       break;
 21-1117 .    }
 21-1118 .    case two:
 21-1119 .    {
 21-1120 .       run_this;
 21-1121 .       break;
 21-1122 .    }
 21-1123 .    default:
 21-1124 .    {
 21-1125 .        SwError;
 21-1126 .    }
 21-1127 . }
 21-1128 . 
 21-1129 . A = B+C;
 21-1130 . 
 21-1131 . if (A > = B)
 21-1132 . {
 21-1133 .    A = B + C;
 21-1134 .    D = E + F;
 21-1135 . }
 21-1136 . 
 21-1137 . 
 21-1138 . if (A le B)
 21-1139 . {
 21-1140 .    A = B + C;
 21-1141 .    D = E + F;
 21-1142 . }
 21-1143 . 
 21-1144 . 
 21-1145 . if (A == B)
 21-1146 . {
 21-1147 .    A = B + C;
 21-1148 .    D = E + F;
 21-1149 . }
 21-1150 . 
 21-1151 . A = B/C;
 21-1152 . 
 21-1153 . if (A ne B)
 21-1154 . {
 21-1155 .    A = B + C;
 21-1156 .    D = E + F;
 21-1157 . }
 21-1158 . 
 21-1159 . A = B/C;
 21-1160 . A = B*C;
 21-1161 . A = B/C;
 21-1162 . 
 21-1163 . if (A ne B)
 21-1164 . {
 21-1165 .    A = B + C;
 21-1166 .    D = E + F;
 21-1167 . }
 21-1168 . 
 21-1169 . 
 21-1170 . if (A ge B)
 21-1171 . {
 21-1172 .    A = B + C;
 21-1173 .    D = E + F;
 21-1174 . }
 21-1175 . 
 21-1176 . A = B+C;
 21-1177 . A = B+C;
 21-1178 . A = 0x0009;
 21-1179 . 
 21-1180 . if (A ge B)
 21-1181 . {
 21-1182 .    A = B + C;
 21-1183 .    D = E + F;
 21-1184 . }
 21-1185 . 
 21-1186 . A = B+C;
 21-1187 . /* LE SV TOC-1476 this is a p_fdp-06.8.81 req to translate*/
 21-1188 . A = B/C;
 21-1189 . A = B*C;
 21-1190 . 
 21-1191 . if (A < = B)
 21-1192 . {
 21-1193 .    A = B + C;
 21-1194 .    D = E + F;
 21-1195 . }
 21-1196 . 
 21-1197 . 
 21-1198 . if (A > = B)
 21-1199 . {
 21-1200 .    A = B + C;
 21-1201 .    D = E + F;
 21-1202 . }
 21-1203 . 
 21-1204 . A = B+C;
 21-1205 . A = 0x0009;
 21-1206 . A = B*C;
 21-1207 . A = B*C;
 21-1208 . A = B-C;
 21-1209 . A = B-C;
 21-1210 . A = B-C;
 21-1211 . A = B/C;
 21-1212 . // max LOC 91
 21-1213 . 
 21-1214 . }
 21-1215 . 
 21-1216 . 
 21-1217 . /*
 21-1218 . -----------------------------------------------------------------------------
 21-1219 . --| NAME:   fdp.6.9
 21-1220 . --|
 21-1221 . --| ABSTRACT:
 21-1222 . --|   This function does fdp stuff.
 21-1223 . --|
 21-1224 . --| RETURNS:
 21-1225 . --|   NONE.
 21-1226 . --|
 21-1227 . ----------------------------------------------------------------------------
 21-1228 . */
 21-1229 . static void fdp.6.9(void)
 21-1230 . {
 21-1231 . 
 21-1232 . if (A gt B)
 21-1233 . {
 21-1234 .    A = B + C;
 21-1235 .    D = E + F;
 21-1236 . }
 21-1237 . 
 21-1238 . 
 21-1239 . if (A le B)
 21-1240 . {
 21-1241 .    A = B + C;
 21-1242 .    D = E + F;
 21-1243 . }
 21-1244 . 
 21-1245 . /* LE SV TOC-1477 this is a p_fdp-06.9.3 req to enable*/
 21-1246 . A = B/C;
 21-1247 . A = B*C;
 21-1248 . 
 21-1249 . if (A != B)
 21-1250 . {
 21-1251 .    A = B + C;
 21-1252 .    D = E + F;
 21-1253 . }
 21-1254 . 
 21-1255 . A = B/C;
 21-1256 . A = B-C;
 21-1257 . A = B*C;
 21-1258 . A = B*C;
 21-1259 . A = B+C;
 21-1260 . A = B+C;
 21-1261 . 
 21-1262 . if (A gt B)
 21-1263 . {
 21-1264 .    A = B + C;
 21-1265 .    D = E + F;
 21-1266 . }
 21-1267 . 
 21-1268 . A = B-C;
 21-1269 . A = B-C;
 21-1270 . 
 21-1271 . if (A gt B)
 21-1272 . {
 21-1273 .    A = B + C;
 21-1274 .    D = E + F;
 21-1275 . }
 21-1276 . 
 21-1277 . 
 21-1278 . if (A ne B)
 21-1279 . {
 21-1280 .    A = B + C;
 21-1281 .    D = E + F;
 21-1282 . }
 21-1283 . 
 21-1284 . A = B/C;
 21-1285 . A = B-C;
 21-1286 . /* LE SV TOC-1478 this is a p_fdp-06.9.19 req to record*/
 21-1287 . A = B-C;
 21-1288 . 
 21-1289 . switch (fdp stuff)
 21-1290 . {
 21-1291 .    case one:
 21-1292 .    {
 21-1293 .       run_this; 
 21-1294 .       break;
 21-1295 .    }
 21-1296 .    case two:
 21-1297 .    {
 21-1298 .       run_this;
 21-1299 .       break;
 21-1300 .    }
 21-1301 .    default:
 21-1302 .    {
 21-1303 .        SwError;
 21-1304 .    }
 21-1305 . }
 21-1306 . 
 21-1307 . 
 21-1308 . if (A gt B)
 21-1309 . {
 21-1310 .    A = B + C;
 21-1311 .    D = E + F;
 21-1312 . }
 21-1313 . 
 21-1314 . A = B/C;
 21-1315 . 
 21-1316 . if (A < = B)
 21-1317 . {
 21-1318 .    A = B + C;
 21-1319 .    D = E + F;
 21-1320 . }
 21-1321 . 
 21-1322 . A = B*C;
 21-1323 . A = B*C;
 21-1324 . 
 21-1325 . if (A == B)
 21-1326 . {
 21-1327 .    A = B + C;
 21-1328 .    D = E + F;
 21-1329 . }
 21-1330 . 
 21-1331 . A = B-C;
 21-1332 . A = B/C;
 21-1333 . // ??? go see ws
 21-1334 . A = B-C;
 21-1335 . 
 21-1336 . if (A <  B)
 21-1337 . {
 21-1338 .    A = B + C;
 21-1339 .    D = E + F;
 21-1340 . }
 21-1341 . 
 21-1342 . 
 21-1343 . if (A >  B)
 21-1344 . {
 21-1345 .    A = B + C;
 21-1346 .    D = E + F;
 21-1347 . }
 21-1348 . 
 21-1349 . /* LE SV TOC-1479 this is a p_fdp-06.9.32 req to call isr*/
 21-1350 . A = B-C;
 21-1351 . A = B+C;
 21-1352 . 
 21-1353 . if (A ge B)
 21-1354 . {
 21-1355 .    A = B + C;
 21-1356 .    D = E + F;
 21-1357 . }
 21-1358 . 
 21-1359 . A = B-C;
 21-1360 . A = B+C;
 21-1361 . A = B+C;
 21-1362 . A = B+C;
 21-1363 . A = B+C;
 21-1364 . A = B-C;
 21-1365 . A = B/C;
 21-1366 . A = B*C;
 21-1367 . 
 21-1368 . if (A < = B)
 21-1369 . {
 21-1370 .    A = B + C;
 21-1371 .    D = E + F;
 21-1372 . }
 21-1373 . 
 21-1374 . 
 21-1375 . if (veg)
 21-1376 .    // missing curly brace
 21-1377 .    variable = orange;
 21-1378 . 
 21-1379 . A = B*C;
 21-1380 . A = B/C;
 21-1381 . A = B+C;
 21-1382 . A = B+C;
 21-1383 . A = (int)B + C;
 21-1384 . A = B*C;
 21-1385 . 
 21-1386 . switch (fdp stuff)
 21-1387 . {
 21-1388 .    case one:
 21-1389 .    {
 21-1390 .       run_this; 
 21-1391 .       break;
 21-1392 .    }
 21-1393 .    case two:
 21-1394 .    {
 21-1395 .       run_this;
 21-1396 .       break;
 21-1397 .    }
 21-1398 .    default:
 21-1399 .    {
 21-1400 .        SwError;
 21-1401 .    }
 21-1402 . }
 21-1403 . 
 21-1404 . // max LOC 49
 21-1405 . 
 21-1406 . }
 21-1407 . 
 21-1408 . 
 21-1409 . /*
 21-1410 . -----------------------------------------------------------------------------
 21-1411 . --| NAME:   fdp.6.10
 21-1412 . --|
 21-1413 . --| ABSTRACT:
 21-1414 . --|   This function does fdp stuff.
 21-1415 . --|
 21-1416 . --| RETURNS:
 21-1417 . --|   NONE.
 21-1418 . --|
 21-1419 . ----------------------------------------------------------------------------
 21-1420 . */
 21-1421 . static void fdp.6.10(void)
 21-1422 . {
 21-1423 . A = B+C;
 21-1424 . A = B/C;
 21-1425 . A = B/C;
 21-1426 . 
 21-1427 . if (A <  B)
 21-1428 . {
 21-1429 .    A = B + C;
 21-1430 .    D = E + F;
 21-1431 . }
 21-1432 . 
 21-1433 . 
 21-1434 . if (A gt B)
 21-1435 . {
 21-1436 .    A = B + C;
 21-1437 .    D = E + F;
 21-1438 . }
 21-1439 . 
 21-1440 . 
 21-1441 . /*
 21-1442 . dead_block = C * D; 
 21-1443 . dead_block = E * F;
 21-1444 . */
 21-1445 . 
 21-1446 . A = B+C;
 21-1447 . A = B*C;
 21-1448 . A = B/C;
 21-1449 . A = B+C;
 21-1450 . A = B-C;
 21-1451 . 
 21-1452 . switch (fdp stuff)
 21-1453 . {
 21-1454 .    case one:
 21-1455 .    {
 21-1456 .       run_this; 
 21-1457 .       break;
 21-1458 .    }
 21-1459 .    case two:
 21-1460 .    {
 21-1461 .       run_this;
 21-1462 .       break;
 21-1463 .    }
 21-1464 .    default:
 21-1465 .    {
 21-1466 .        SwError;
 21-1467 .    }
 21-1468 . }
 21-1469 . 
 21-1470 . A = B*C;
 21-1471 . A = B*C;
 21-1472 . A = B*C;
 21-1473 . 
 21-1474 . if (A lt B)
 21-1475 . {
 21-1476 .    A = B + C;
 21-1477 .    D = E + F;
 21-1478 . }
 21-1479 . 
 21-1480 . 
 21-1481 . if (A ne B)
 21-1482 . {
 21-1483 .    A = B + C;
 21-1484 .    D = E + F;
 21-1485 . }
 21-1486 . 
 21-1487 . 
 21-1488 . if (A < = B)
 21-1489 . {
 21-1490 .    A = B + C;
 21-1491 .    D = E + F;
 21-1492 . }
 21-1493 . 
 21-1494 . FreePtr = HmiStringPtr;
 21-1495 . A = B+C;
 21-1496 . 
 21-1497 . if (A < = B)
 21-1498 . {
 21-1499 .    A = B + C;
 21-1500 .    D = E + F;
 21-1501 . }
 21-1502 . 
 21-1503 . 
 21-1504 . if (A gt B)
 21-1505 . {
 21-1506 .    A = B + C;
 21-1507 .    D = E + F;
 21-1508 . }
 21-1509 . 
 21-1510 . A = B-C;
 21-1511 . 
 21-1512 . if (A ge B)
 21-1513 . {
 21-1514 .    A = B + C;
 21-1515 .    D = E + F;
 21-1516 . }
 21-1517 . 
 21-1518 . A = B/C;
 21-1519 . A = B+C;
 21-1520 . A = B+C;
 21-1521 . A = B+C;
 21-1522 . 
 21-1523 . if (A ne B)
 21-1524 . {
 21-1525 .    A = B + C;
 21-1526 .    D = E + F;
 21-1527 . }
 21-1528 . 
 21-1529 . A = B/C;
 21-1530 . A = B/C;
 21-1531 . A = B-C;
 21-1532 . A = B*C;
 21-1533 . A = B/C;
 21-1534 . A = B-C;
 21-1535 . A = B/C;
 21-1536 . /* LE SV TOC-1480 this is a p_fdp-06.10.35 req to check pSOS*/
 21-1537 . A = B+C;
 21-1538 . 
 21-1539 . switch (fdp stuff)
 21-1540 . {
 21-1541 .    case one:
 21-1542 .    {
 21-1543 .       switch (nested)
 21-1544 .       {
 21-1545 .          case:
 21-1546 .             X = Y + Z;
 21-1547 .          case:
 21-1548 .             X = Y + Z;
 21-1549 .          default:
 21-1550 .             SwError;
 21-1551 .       } 
 21-1552 .    }
 21-1553 .    case two:
 21-1554 .    {
 21-1555 .       run_this;
 21-1556 .       break;
 21-1557 .    }
 21-1558 .    default:
 21-1559 .    {
 21-1560 .       SwError;
 21-1561 .    }
 21-1562 . }
 21-1563 . 
 21-1564 . 
 21-1565 . if (A eq B)
 21-1566 . {
 21-1567 .    A = B + C;
 21-1568 .    D = E + F;
 21-1569 . }
 21-1570 . 
 21-1571 . A = B*C;
 21-1572 . A = B*C;
 21-1573 . A = B+C;
 21-1574 . A = B+C;
 21-1575 . A = B*C;
 21-1576 . A = B*C;
 21-1577 . A = B*C;
 21-1578 . // max LOC 43
 21-1579 . 
 21-1580 . }
 21-1581 . 
 21-1582 . 
 21-1583 . /*
 21-1584 . -----------------------------------------------------------------------------
 21-1585 . --| NAME:   fdp.6.11
 21-1586 . --|
 21-1587 . --| ABSTRACT:
 21-1588 . --|   This function does fdp stuff.
 21-1589 . --|
 21-1590 . --| RETURNS:
 21-1591 . --|   NONE.
 21-1592 . --|
 21-1593 . ----------------------------------------------------------------------------
 21-1594 . */
 21-1595 . static void fdp.6.11(void)
 21-1596 . {
 21-1597 . 
 21-1598 . if (A eq B)
 21-1599 . {
 21-1600 .    A = B + C;
 21-1601 .    D = E + F;
 21-1602 . }
 21-1603 . 
 21-1604 . A = B*C;
 21-1605 . A = B/C;
 21-1606 . A = B*C;
 21-1607 . A = B/C;
 21-1608 . 
 21-1609 . if (A < = B)
 21-1610 . {
 21-1611 .    A = B + C;
 21-1612 .    D = E + F;
 21-1613 . }
 21-1614 . 
 21-1615 . 
 21-1616 . if (A gt B)
 21-1617 . {
 21-1618 .    A = B + C;
 21-1619 .    D = E + F;
 21-1620 . }
 21-1621 . 
 21-1622 . A = B/C;
 21-1623 . A = B+C;
 21-1624 . 
 21-1625 . if (A <  B)
 21-1626 . {
 21-1627 .    A = B + C;
 21-1628 .    D = E + F;
 21-1629 . }
 21-1630 . 
 21-1631 . 
 21-1632 . switch (fdp stuff)
 21-1633 . {
 21-1634 .    case one:
 21-1635 .    {
 21-1636 .       run_this; 
 21-1637 .       break;
 21-1638 .    }
 21-1639 .    case two:
 21-1640 .    {
 21-1641 .       run_this;
 21-1642 .       break;
 21-1643 .    }
 21-1644 .    default:
 21-1645 .    {
 21-1646 .        SwError;
 21-1647 .    }
 21-1648 . }
 21-1649 . 
 21-1650 . 
 21-1651 . if (A != B)
 21-1652 . {
 21-1653 .    A = B + C;
 21-1654 .    D = E + F;
 21-1655 . }
 21-1656 . 
 21-1657 . 
 21-1658 . switch (fdp stuff)
 21-1659 . {
 21-1660 .    case one:
 21-1661 .    {
 21-1662 .       run_this;
 21-1663 .       break;
 21-1664 .    }
 21-1665 .    case two:
 21-1666 .    {
 21-1667 .       run_this;
 21-1668 .       break;
 21-1669 .    }
 21-1670 .    // missing default
 21-1671 . }
 21-1672 . 
 21-1673 . 
 21-1674 . if (A != B)
 21-1675 . {
 21-1676 .    A = B + C;
 21-1677 .    D = E + F;
 21-1678 . }
 21-1679 . 
 21-1680 . A = B*C;
 21-1681 . 
 21-1682 . if (A > = B)
 21-1683 . {
 21-1684 .    A = B + C;
 21-1685 .    D = E + F;
 21-1686 . }
 21-1687 . 
 21-1688 . 
 21-1689 . if (A <  B)
 21-1690 . {
 21-1691 .    A = B + C;
 21-1692 .    D = E + F;
 21-1693 . }
 21-1694 . 
 21-1695 . 
 21-1696 . if (A ge B)
 21-1697 . {
 21-1698 .    A = B + C;
 21-1699 .    D = E + F;
 21-1700 . }
 21-1701 . 
 21-1702 . A = B+C;
 21-1703 . A = B/C;
 21-1704 . A = B*C;
 21-1705 . A = B+C;
 21-1706 . A = B+C;
 21-1707 . 
 21-1708 . switch (fdp stuff)
 21-1709 . {
 21-1710 .    case one:
 21-1711 .    {
 21-1712 .       run_this; 
 21-1713 .       break;
 21-1714 .    }
 21-1715 .    case two:
 21-1716 .    {
 21-1717 .       run_this;
 21-1718 .       break;
 21-1719 .    }
 21-1720 .    default:
 21-1721 .    {
 21-1722 .        SwError;
 21-1723 .    }
 21-1724 . }
 21-1725 . 
 21-1726 . A = B/C;
 21-1727 . A = B+C;
 21-1728 . A = B/C;
 21-1729 . A = B+C;
 21-1730 . 
 21-1731 . if (A eq B)
 21-1732 . {
 21-1733 .    A = B + C;
 21-1734 .    D = E + F;
 21-1735 . }
 21-1736 . 
 21-1737 . A = B*C;
 21-1738 . 
 21-1739 . if (A >  B)
 21-1740 . {
 21-1741 .    A = B + C;
 21-1742 .    D = E + F;
 21-1743 . }
 21-1744 . 
 21-1745 . A = B+C;
 21-1746 . 
 21-1747 . if (A <  B)
 21-1748 . {
 21-1749 .    A = B + C;
 21-1750 .    D = E + F;
 21-1751 . }
 21-1752 . 
 21-1753 . A = B/C;
 21-1754 . A = B-C;
 21-1755 . 
 21-1756 . if (A >  B)
 21-1757 . {
 21-1758 .    A = B + C;
 21-1759 .    D = E + F;
 21-1760 . }
 21-1761 . 
 21-1762 . A = B+C;
 21-1763 . 
 21-1764 . if (A >  B)
 21-1765 . {
 21-1766 .    A = B + C;
 21-1767 .    D = E + F;
 21-1768 . }
 21-1769 . 
 21-1770 . A = B*C;
 21-1771 . A = B+C;
 21-1772 . 
 21-1773 . if (A == B)
 21-1774 . {
 21-1775 .    A = B + C;
 21-1776 .    D = E + F;
 21-1777 . }
 21-1778 . 
 21-1779 . 
 21-1780 . switch (fdp stuff)
 21-1781 . {
 21-1782 .    case one:
 21-1783 .    {
 21-1784 .       run_this; 
 21-1785 .       break;
 21-1786 .    }
 21-1787 .    case two:
 21-1788 .    {
 21-1789 .       run_this;
 21-1790 .       break;
 21-1791 .    }
 21-1792 .    default:
 21-1793 .    {
 21-1794 .        SwError;
 21-1795 .    }
 21-1796 . }
 21-1797 . 
 21-1798 . A = B-C;
 21-1799 . A = B*C;
 21-1800 . A = B-C;
 21-1801 . A = B-C;
 21-1802 . 
 21-1803 . if (A >  B)
 21-1804 . {
 21-1805 .    A = B + C;
 21-1806 .    D = E + F;
 21-1807 . }
 21-1808 . 
 21-1809 . A = B+C;
 21-1810 . rcv_buffer = (U16 *) alloc(size+1);
 21-1811 . 
 21-1812 . if (A ne B)
 21-1813 . {
 21-1814 .    A = B + C;
 21-1815 .    D = E + F;
 21-1816 . }
 21-1817 . 
 21-1818 . A = B-C;
 21-1819 . A = B/C;
 21-1820 . 
 21-1821 . switch (fdp stuff)
 21-1822 . {
 21-1823 .    case one:
 21-1824 .    {
 21-1825 .       run_this; 
 21-1826 .       break;
 21-1827 .    }
 21-1828 .    case two:
 21-1829 .    {
 21-1830 .       run_this;
 21-1831 .       break;
 21-1832 .    }
 21-1833 .    default:
 21-1834 .    {
 21-1835 .        SwError;
 21-1836 .    }
 21-1837 . }
 21-1838 . 
 21-1839 . A = B-C;
 21-1840 . do forever;
 21-1841 . 
 21-1842 . if (A eq B)
 21-1843 . {
 21-1844 .    A = B + C;
 21-1845 .    D = E + F;
 21-1846 . }
 21-1847 . 
 21-1848 . // max LOC 53
 21-1849 . 
 21-1850 . }
 21-1851 . 
 21-1852 . 
 21-1853 . /*
 21-1854 . -----------------------------------------------------------------------------
 21-1855 . --| NAME:   fdp.6.12
 21-1856 . --|
 21-1857 . --| ABSTRACT:
 21-1858 . --|   This function does fdp stuff.
 21-1859 . --|
 21-1860 . --| RETURNS:
 21-1861 . --|   NONE.
 21-1862 . --|
 21-1863 . ----------------------------------------------------------------------------
 21-1864 . */
 21-1865 . static void fdp.6.12(void)
 21-1866 . {
 21-1867 . A = B*C;
 21-1868 . A = B+C;
 21-1869 . A = B/C;
 21-1870 . A = B*C;
 21-1871 . A = B-C;
 21-1872 . A = B/C;
 21-1873 . A = B+C;
 21-1874 . 
 21-1875 . if (A > = B)
 21-1876 . {
 21-1877 .    A = B + C;
 21-1878 .    D = E + F;
 21-1879 . }
 21-1880 . 
 21-1881 . A = B*C;
 21-1882 . A = B*C;
 21-1883 . 
 21-1884 . if (A >  B)
 21-1885 . {
 21-1886 .    A = B + C;
 21-1887 .    D = E + F;
 21-1888 . }
 21-1889 . 
 21-1890 . A = B/C;
 21-1891 . A = B*C;
 21-1892 . 
 21-1893 . if (A >  B)
 21-1894 . {
 21-1895 .    A = B + C;
 21-1896 .    D = E + F;
 21-1897 . }
 21-1898 . 
 21-1899 . A = B+C;
 21-1900 . 
 21-1901 . if (A gt B)
 21-1902 . {
 21-1903 .    A = B + C;
 21-1904 .    D = E + F;
 21-1905 . }
 21-1906 . 
 21-1907 . A = B/C;
 21-1908 . 
 21-1909 . if (A eq B)
 21-1910 . {
 21-1911 .    A = B + C;
 21-1912 .    D = E + F;
 21-1913 . }
 21-1914 . 
 21-1915 . A = B-C;
 21-1916 . A = B*C;
 21-1917 . 
 21-1918 . if (A > = B)
 21-1919 . {
 21-1920 .    A = B + C;
 21-1921 .    D = E + F;
 21-1922 . }
 21-1923 . 
 21-1924 . 
 21-1925 . if (A eq B)
 21-1926 . {
 21-1927 .    A = B + C;
 21-1928 .    D = E + F;
 21-1929 . }
 21-1930 . 
 21-1931 . A = B/C;
 21-1932 . A = B+C;
 21-1933 . A = B*C;
 21-1934 . A = B*C;
 21-1935 . A = B-C;
 21-1936 . A = B+C;
 21-1937 . A = B*C;
 21-1938 . A = B*C;
 21-1939 . 
 21-1940 . if (A gt B)
 21-1941 . {
 21-1942 .    A = B + C;
 21-1943 .    D = E + F;
 21-1944 . }
 21-1945 . 
 21-1946 . 
 21-1947 . if (A < = B)
 21-1948 . {
 21-1949 .    A = B + C;
 21-1950 .    D = E + F;
 21-1951 . }
 21-1952 . 
 21-1953 . A = B/C;
 21-1954 . A = B/C;
 21-1955 . A = B-C;
 21-1956 . A = B-C;
 21-1957 . A = B-C;
 21-1958 . A = B+C;
 21-1959 . A = B*C;
 21-1960 . A = B*C;
 21-1961 . 
 21-1962 . if (A <  B)
 21-1963 . {
 21-1964 .    A = B + C;
 21-1965 .    D = E + F;
 21-1966 . }
 21-1967 . 
 21-1968 . A = B/C;
 21-1969 . A = B/C;
 21-1970 . 
 21-1971 . /* dead_code = B + C; 
 21-1972 . dead_code = D + E; 
 21-1973 . dead_code = F + G; */
 21-1974 . 
 21-1975 . A = B-C;
 21-1976 . 
 21-1977 . if (A == B)
 21-1978 . {
 21-1979 .    A = B + C;
 21-1980 .    D = E + F;
 21-1981 . }
 21-1982 . 
 21-1983 . 
 21-1984 . if (A <  B)
 21-1985 . {
 21-1986 .    A = B + C;
 21-1987 .    D = E + F;
 21-1988 . }
 21-1989 . 
 21-1990 . 
 21-1991 . if (A != B)
 21-1992 . {
 21-1993 .    A = B + C;
 21-1994 .    D = E + F;
 21-1995 . }
 21-1996 . 
 21-1997 . A = B+C;
 21-1998 . A = B*C;
 21-1999 . A = B+C;
 21-2000 . 
 21-2001 . if (A ge B)
 21-2002 . {
 21-2003 .    A = B + C;
 21-2004 .    D = E + F;
 21-2005 . }
 21-2006 . 
 21-2007 . 
 21-2008 . if (A >  B)
 21-2009 . {
 21-2010 .    A = B + C;
 21-2011 .    D = E + F;
 21-2012 . }
 21-2013 . 
 21-2014 . 
 21-2015 . /* dead_code = B + C; 
 21-2016 . dead_code = D + E; 
 21-2017 . dead_code = F + G; */
 21-2018 . 
 21-2019 . A = B*C;
 21-2020 . 
 21-2021 . if (A != B)
 21-2022 . {
 21-2023 .    A = B + C;
 21-2024 .    D = E + F;
 21-2025 . }
 21-2026 . 
 21-2027 . A = B-C;
 21-2028 . 
 21-2029 . switch (fdp stuff)
 21-2030 . {
 21-2031 .    case one:
 21-2032 .    {
 21-2033 .       run_this; 
 21-2034 .       break;
 21-2035 .    }
 21-2036 .    case two:
 21-2037 .    {
 21-2038 .       run_this;
 21-2039 .       break;
 21-2040 .    }
 21-2041 .    default:
 21-2042 .    {
 21-2043 .        SwError;
 21-2044 .    }
 21-2045 . }
 21-2046 . 
 21-2047 . A = B*C;
 21-2048 . A = B+C;
 21-2049 . A = B/C;
 21-2050 . A = B*C;
 21-2051 . A = B*C;
 21-2052 . A = B-C;
 21-2053 . A = B/C;
 21-2054 . 
 21-2055 . if (A < = B)
 21-2056 . {
 21-2057 .    A = B + C;
 21-2058 .    D = E + F;
 21-2059 . }
 21-2060 . 
 21-2061 . 
 21-2062 . if (A lt B)
 21-2063 . {
 21-2064 .    A = B + C;
 21-2065 .    D = E + F;
 21-2066 . }
 21-2067 . 
 21-2068 . A = B*C;
 21-2069 . 
 21-2070 . if (A lt B)
 21-2071 . {
 21-2072 .    A = B + C;
 21-2073 .    D = E + F;
 21-2074 . }
 21-2075 . 
 21-2076 . A = B-C;
 21-2077 . 
 21-2078 . switch (fdp stuff)
 21-2079 . {
 21-2080 .    case one:
 21-2081 .    {
 21-2082 .       switch (nested)
 21-2083 .       {
 21-2084 .          case:
 21-2085 .             X = Y + Z;
 21-2086 .          case:
 21-2087 .             X = Y + Z;
 21-2088 .          default:
 21-2089 .             SwError;
 21-2090 .       } 
 21-2091 .    }
 21-2092 .    case two:
 21-2093 .    {
 21-2094 .       run_this;
 21-2095 .       break;
 21-2096 .    }
 21-2097 .    default:
 21-2098 .    {
 21-2099 .       SwError;
 21-2100 .    }
 21-2101 . }
 21-2102 . 
 21-2103 . A = B-C;
 21-2104 . goto error;
 21-2105 . A = B/C;
 21-2106 . 
 21-2107 . if (A ge B)
 21-2108 . {
 21-2109 .    A = B + C;
 21-2110 .    D = E + F;
 21-2111 . }
 21-2112 . 
 21-2113 . A = B-C;
 21-2114 . A = B*C;
 21-2115 . A = B*C;
 21-2116 . A = B/C;
 21-2117 . A = B+C;
 21-2118 . A = B/C;
 21-2119 . A = B+C;
 21-2120 . A = B-C;
 21-2121 . // max LOC 79
 21-2122 . 
 21-2123 . }
 21-2124 . 

21 21 Result: result/source/ft-app/ft-app-B1.1/fdp/p_fdp-06.c


22 22 Source: source/ft-app/ft-app-B1.1/fpcp/fpcp-01.c
 22-0 . /*
 22-1 . ----------------------------------------------------------------------------
 22-2 . --| BEGIN PROLOGUE
 22-3 . --|
 22-4 . --| CLASSIFICATION: UNCLASSIFIED
 22-5 . --|
 22-6 . --| FILE NAME:      fpcp-01.c
 22-7 . --|
 22-8 . --| ABSTRACT:
 22-9 . --|   This file contains the 2 functions that do file fpcp stuff.
 22-10 . --|
 22-11 . --| HISTORY:
 22-12 . --|   CCCQ_NAME:
 22-13 . --|   CCCQ_VER: 
 22-14 . --|
 22-15 . --| END PROLOGUE
 22-16 . ----------------------------------------------------------------------------
 22-17 . */
 22-18 . 
 22-19 . #include D;
 22-20 . char D;
 22-21 . char D;
 22-22 . int A;
 22-23 . double C;
 22-24 . #include A;
 22-25 . #define C;
 22-26 . 
 22-27 . 
 22-28 . 
 22-29 . /*
 22-30 . -----------------------------------------------------------------------------
 22-31 . --| NAME:   fpcp.1.1
 22-32 . --|
 22-33 . --| ABSTRACT:
 22-34 . --|   This function does fpcp stuff.
 22-35 . --|
 22-36 . --| RETURNS:
 22-37 . --|   NONE.
 22-38 . --|
 22-39 . ----------------------------------------------------------------------------
 22-40 . */
 22-41 . static void fpcp.1.1(void)
 22-42 . {
 22-43 . 
 22-44 . #ifdef LAZY
 22-45 .    // this is not nice
 22-46 .    A = B + C;
 22-47 .    A = B + C;
 22-48 . #endif
 22-49 . 
 22-50 . A = B*C;
 22-51 . 
 22-52 . if (A <  B)
 22-53 . {
 22-54 .    A = B + C;
 22-55 .    D = E + F;
 22-56 . }
 22-57 . 
 22-58 . /* LE SV TOC-1601 this is a fpcp-01.1.3 req to transform*/
 22-59 . A = B*C;
 22-60 . A = B*C;
 22-61 . A = B-C;
 22-62 . /* LE SV TOC-1602 this is a fpcp-01.1.6 req to validate*/
 22-63 . A = B-C;
 22-64 . A = B+C;
 22-65 . 
 22-66 . if (A < = B)
 22-67 . {
 22-68 .    A = B + C;
 22-69 .    D = E + F;
 22-70 . }
 22-71 . 
 22-72 . 
 22-73 . if (A eq B)
 22-74 . {
 22-75 .    A = B + C;
 22-76 .    D = E + F;
 22-77 . }
 22-78 . 
 22-79 . /* LE SV TOC-1603 this is a fpcp-01.1.10 req to translate*/
 22-80 . A = B/C;
 22-81 . A = B/C;
 22-82 . A = B/C;
 22-83 . 
 22-84 . if (A ne B)
 22-85 . {
 22-86 .    A = B + C;
 22-87 .    D = E + F;
 22-88 . }
 22-89 . 
 22-90 . A = B/C;
 22-91 . A = B+C;
 22-92 . A = B/C;
 22-93 . 
 22-94 . if (A lt B)
 22-95 . {
 22-96 .    A = B + C;
 22-97 .    D = E + F;
 22-98 . }
 22-99 . 
 22-100 . A = B*C;
 22-101 . A = B+C;
 22-102 . 
 22-103 . if (A lt B)
 22-104 . {
 22-105 .    A = B + C;
 22-106 .    D = E + F;
 22-107 . }
 22-108 . 
 22-109 . A = B+C;
 22-110 . 
 22-111 . if (A >  B)
 22-112 . {
 22-113 .    A = B + C;
 22-114 .    D = E + F;
 22-115 . }
 22-116 . 
 22-117 . A = B*C;
 22-118 . A = B/C;
 22-119 . A = B+C;
 22-120 . A = B/C;
 22-121 . A = B/C;
 22-122 . 
 22-123 . if (A < = B)
 22-124 . {
 22-125 .    A = B + C;
 22-126 .    D = E + F;
 22-127 . }
 22-128 . 
 22-129 . 
 22-130 . if (A ne B)
 22-131 . {
 22-132 .    A = B + C;
 22-133 .    D = E + F;
 22-134 . }
 22-135 . 
 22-136 . A = B/C;
 22-137 . A = B-C;
 22-138 . 
 22-139 . switch (fpcp stuff)
 22-140 . {
 22-141 .    case one:
 22-142 .    {
 22-143 .       run_this; 
 22-144 .       break;
 22-145 .    }
 22-146 .    case two:
 22-147 .    {
 22-148 .       run_this;
 22-149 .       break;
 22-150 .    }
 22-151 .    default:
 22-152 .    {
 22-153 .        SwError;
 22-154 .    }
 22-155 . }
 22-156 . 
 22-157 . A = B/C;
 22-158 . A = B-C;
 22-159 . A = 0x0006;
 22-160 . A = B*C;
 22-161 . A = B*C;
 22-162 . 
 22-163 . if ($fpcp stuff >  $otherfpcp stuff) 
 22-164 . /* LE SV TOC-008 we really should log all error calls */
 22-165 . {
 22-166 .    A = B + C;
 22-167 . }
 22-168 . 
 22-169 . 
 22-170 . if (A gt B)
 22-171 . {
 22-172 .    A = B + C;
 22-173 .    D = E + F;
 22-174 . }
 22-175 . 
 22-176 . A = B-C;
 22-177 . 
 22-178 . if (A > = B)
 22-179 . {
 22-180 .    A = B + C;
 22-181 .    D = E + F;
 22-182 . }
 22-183 . 
 22-184 . A = B-C;
 22-185 . A = B/C;
 22-186 . /* LE SV TOC-1604 this is a fpcp-01.1.42 req to set Real Time Clock*/
 22-187 . A = B/C;
 22-188 . 
 22-189 . if (A != B)
 22-190 . {
 22-191 .    A = B + C;
 22-192 .    D = E + F;
 22-193 . }
 22-194 . 
 22-195 . /* LE SV TOC-1605 this is a fpcp-01.1.44 req to inhibit*/
 22-196 . 
 22-197 . if (A le B)
 22-198 . {
 22-199 .    A = B + C;
 22-200 .    D = E + F;
 22-201 . }
 22-202 . 
 22-203 . 
 22-204 . if (A <  B)
 22-205 . {
 22-206 .    A = B + C;
 22-207 .    D = E + F;
 22-208 . }
 22-209 . 
 22-210 . A = B*C;
 22-211 . A = B*C;
 22-212 . A = B-C;
 22-213 . A = B*C;
 22-214 . A = B*C;
 22-215 . A = B-C;
 22-216 . A = B-C;
 22-217 . /* LE SV TOC-1606 this is a fpcp-01.1.53 req to enable*/
 22-218 . A = B*C;
 22-219 . 
 22-220 . if (A ne B)
 22-221 . {
 22-222 .    A = B + C;
 22-223 .    D = E + F;
 22-224 . }
 22-225 . 
 22-226 . 
 22-227 . if (A eq B)
 22-228 . {
 22-229 .    A = B + C;
 22-230 .    D = E + F;
 22-231 . }
 22-232 . 
 22-233 . 
 22-234 . if (A le B)
 22-235 . {
 22-236 .    A = B + C;
 22-237 .    D = E + F;
 22-238 . }
 22-239 . 
 22-240 . A = B-C;
 22-241 . // max LOC 57
 22-242 . 
 22-243 . }
 22-244 . 
 22-245 . 
 22-246 . /*
 22-247 . -----------------------------------------------------------------------------
 22-248 . --| NAME:   fpcp.1.2
 22-249 . --|
 22-250 . --| ABSTRACT:
 22-251 . --|   This function does fpcp stuff.
 22-252 . --|
 22-253 . --| RETURNS:
 22-254 . --|   NONE.
 22-255 . --|
 22-256 . ----------------------------------------------------------------------------
 22-257 . */
 22-258 . static void fpcp.1.2(void)
 22-259 . {
 22-260 . A = B+C;
 22-261 . A = B/C;
 22-262 . 
 22-263 . if (A > = B)
 22-264 . {
 22-265 .    A = B + C;
 22-266 .    D = E + F;
 22-267 . }
 22-268 . 
 22-269 . A = B+C;
 22-270 . A = B/C;
 22-271 . A = B/C;
 22-272 . 
 22-273 . if (A > = B)
 22-274 . {
 22-275 .    A = B + C;
 22-276 .    D = E + F;
 22-277 . }
 22-278 . 
 22-279 . 
 22-280 . if (A <  B)
 22-281 . {
 22-282 .    A = B + C;
 22-283 .    D = E + F;
 22-284 . }
 22-285 . 
 22-286 . 
 22-287 . if (A le B)
 22-288 . {
 22-289 .    A = B + C;
 22-290 .    D = E + F;
 22-291 . }
 22-292 . 
 22-293 . 
 22-294 . if (A != B)
 22-295 . {
 22-296 .    A = B + C;
 22-297 .    D = E + F;
 22-298 . }
 22-299 . 
 22-300 . A = B-C;
 22-301 . A = B-C;
 22-302 . A = B-C;
 22-303 . 
 22-304 . switch (fpcp stuff)
 22-305 . {
 22-306 .    case one:
 22-307 .    {
 22-308 .       run_this; 
 22-309 .       break;
 22-310 .    }
 22-311 .    case two:
 22-312 .    {
 22-313 .       run_this;
 22-314 .       break;
 22-315 .    }
 22-316 .    default:
 22-317 .    {
 22-318 .        SwError;
 22-319 .    }
 22-320 . }
 22-321 . 
 22-322 . A = B/C;
 22-323 . 
 22-324 . if (A lt B)
 22-325 . {
 22-326 .    A = B + C;
 22-327 .    D = E + F;
 22-328 . }
 22-329 . 
 22-330 . A = B+C;
 22-331 . 
 22-332 . if (A eq B)
 22-333 . {
 22-334 .    A = B + C;
 22-335 .    D = E + F;
 22-336 . }
 22-337 . 
 22-338 . 
 22-339 . if (A eq B)
 22-340 . {
 22-341 .    A = B + C;
 22-342 .    D = E + F;
 22-343 . }
 22-344 . 
 22-345 . 
 22-346 . if (A == B)
 22-347 . {
 22-348 .    A = B + C;
 22-349 .    D = E + F;
 22-350 . }
 22-351 . 
 22-352 . 
 22-353 . if (A >  B)
 22-354 . {
 22-355 .    A = B + C;
 22-356 .    D = E + F;
 22-357 . }
 22-358 . 
 22-359 . A = B*C;
 22-360 . 
 22-361 . if (A eq B)
 22-362 . {
 22-363 .    A = B + C;
 22-364 .    D = E + F;
 22-365 . }
 22-366 . 
 22-367 . A = B*C;
 22-368 . A = B/C;
 22-369 . A = B*C;
 22-370 . A = B-C;
 22-371 . A = B+C;
 22-372 . A = B*C;
 22-373 . A = B+C;
 22-374 . A = B+C;
 22-375 . 
 22-376 . if (A == B)
 22-377 . {
 22-378 .    A = B + C;
 22-379 .    D = E + F;
 22-380 . }
 22-381 . 
 22-382 . 
 22-383 . if (A le B)
 22-384 . {
 22-385 .    A = B + C;
 22-386 .    D = E + F;
 22-387 . }
 22-388 . 
 22-389 . A = B/C;
 22-390 . A = B*C;
 22-391 . A = B+C;
 22-392 . A = B+C;
 22-393 . /* LE SV TOC-1607 this is a fpcp-01.2.38 req to call admin*/
 22-394 . // TBS - I need to figure this out
 22-395 . 
 22-396 . switch (fpcp stuff)
 22-397 . {
 22-398 .    case one:
 22-399 .    {
 22-400 .       run_this; 
 22-401 .       break;
 22-402 .    }
 22-403 .    case two:
 22-404 .    {
 22-405 .       run_this;
 22-406 .       break;
 22-407 .    }
 22-408 .    default:
 22-409 .    {
 22-410 .        SwError;
 22-411 .    }
 22-412 . }
 22-413 . 
 22-414 . A = B+C;
 22-415 . 
 22-416 . if (A ge B)
 22-417 . {
 22-418 .    A = B + C;
 22-419 .    D = E + F;
 22-420 . }
 22-421 . 
 22-422 . A = B+C;
 22-423 . 
 22-424 . if (A <  B)
 22-425 . {
 22-426 .    A = B + C;
 22-427 .    D = E + F;
 22-428 . }
 22-429 . 
 22-430 . 
 22-431 . if (A != B)
 22-432 . {
 22-433 .    A = B + C;
 22-434 .    D = E + F;
 22-435 . }
 22-436 . 
 22-437 . A = B-C;
 22-438 . A = B/C;
 22-439 . 
 22-440 . if (A >  B)
 22-441 . {
 22-442 .    A = B + C;
 22-443 .    D = E + F;
 22-444 . }
 22-445 . 
 22-446 . 
 22-447 . if (A lt B)
 22-448 . {
 22-449 .    A = B + C;
 22-450 .    D = E + F;
 22-451 . }
 22-452 . 
 22-453 . A = B/C;
 22-454 . A = B*C;
 22-455 . A = B/C;
 22-456 . A = B-C;
 22-457 . 
 22-458 . if (A > = B)
 22-459 . {
 22-460 .    A = B + C;
 22-461 .    D = E + F;
 22-462 . }
 22-463 . 
 22-464 . A = B*C;
 22-465 . A = B-C;
 22-466 . A = B*C;
 22-467 . // max LOC 55
 22-468 . 
 22-469 . }
 22-470 . 

22 22 Result: result/source/ft-app/ft-app-B1.1/fpcp/fpcp-01.c


23 23 Source: source/ft-app/ft-app-B1.1/fpcp/fpcp-02.c
 23-0 . /*
 23-1 . ----------------------------------------------------------------------------
 23-2 . --| BEGIN PROLOGUE
 23-3 . --|
 23-4 . --| CLASSIFICATION: UNCLASSIFIED
 23-5 . --|
 23-6 . --| FILE NAME:      fpcp-02.c
 23-7 . --|
 23-8 . --| ABSTRACT:
 23-9 . --|   This file contains the 14 functions that do file fpcp stuff.
 23-10 . --|
 23-11 . --| HISTORY:
 23-12 . --|   CCCQ_NAME:
 23-13 . --|   CCCQ_VER: 
 23-14 . --|
 23-15 . --| END PROLOGUE
 23-16 . ----------------------------------------------------------------------------
 23-17 . */
 23-18 . 
 23-19 . #define C;
 23-20 . float B;
 23-21 . char D;
 23-22 . char D;
 23-23 . float B;
 23-24 . #include D;
 23-25 . #include A;
 23-26 . 
 23-27 . 
 23-28 . 
 23-29 . /*
 23-30 . -----------------------------------------------------------------------------
 23-31 . --| NAME:   fpcp.2.1
 23-32 . --|
 23-33 . --| ABSTRACT:
 23-34 . --|   This function does fpcp stuff.
 23-35 . --|
 23-36 . --| RETURNS:
 23-37 . --|   NONE.
 23-38 . --|
 23-39 . ----------------------------------------------------------------------------
 23-40 . */
 23-41 . static void fpcp.2.1(void)
 23-42 . {
 23-43 . A = B-C;
 23-44 . A = B/C;
 23-45 . A = B+C;
 23-46 . /* LE SV TOC-1608 this is a fpcp-02.1.4 req to process*/
 23-47 . A = B*C;
 23-48 . 
 23-49 . if (A == B)
 23-50 . {
 23-51 .    A = B + C;
 23-52 .    D = E + F;
 23-53 . }
 23-54 . 
 23-55 . A = B+C;
 23-56 . A = B+C;
 23-57 . 
 23-58 . if (A != B)
 23-59 . {
 23-60 .    A = B + C;
 23-61 .    D = E + F;
 23-62 . }
 23-63 . 
 23-64 . 
 23-65 . if (A ge B)
 23-66 . {
 23-67 .    A = B + C;
 23-68 .    D = E + F;
 23-69 . }
 23-70 . 
 23-71 . 
 23-72 . switch (fpcp stuff)
 23-73 . {
 23-74 .    case one:
 23-75 .    {
 23-76 .       run_this; 
 23-77 .       // missing break
 23-78 .    }
 23-79 .    case two:
 23-80 .    {
 23-81 .       run_this;
 23-82 .       break;
 23-83 .    }
 23-84 .    default:
 23-85 .    {
 23-86 .       SwError;
 23-87 .    }
 23-88 . }
 23-89 . 
 23-90 . A = B-C;
 23-91 . A = B+C;
 23-92 . A = B*C;
 23-93 . A = B*C;
 23-94 . A = B*C;
 23-95 . 
 23-96 . if (A le B)
 23-97 . {
 23-98 .    A = B + C;
 23-99 .    D = E + F;
 23-100 . }
 23-101 . 
 23-102 . A = B-C;
 23-103 . A = B+C;
 23-104 . A = B/C;
 23-105 . A = B+C;
 23-106 . A = B-C;
 23-107 . A = B-C;
 23-108 . A = B-C;
 23-109 . A = B/C;
 23-110 . A = B-C;
 23-111 . A = B*C;
 23-112 . A = B/C;
 23-113 . A = B+C;
 23-114 . A = B+C;
 23-115 . A = B*C;
 23-116 . 
 23-117 . if (A lt B)
 23-118 . {
 23-119 .    A = B + C;
 23-120 .    D = E + F;
 23-121 . }
 23-122 . 
 23-123 . A = B*C;
 23-124 . A = B-C;
 23-125 . A = B-C;
 23-126 . A = B*C;
 23-127 . A = B/C;
 23-128 . A = B+C;
 23-129 . A = B*C;
 23-130 . A = B+C;
 23-131 . A = B*C;
 23-132 . A = B+C;
 23-133 . A = B-C;
 23-134 . A = B-C;
 23-135 . 
 23-136 . if (A != B)
 23-137 . {
 23-138 .    A = B + C;
 23-139 .    D = E + F;
 23-140 . }
 23-141 . 
 23-142 . A = B+C;
 23-143 . 
 23-144 . switch (fpcp stuff)
 23-145 . {
 23-146 .    case one:
 23-147 .    {
 23-148 .       switch (nested)
 23-149 .       {
 23-150 .          case:
 23-151 .             X = Y + Z;
 23-152 .          case:
 23-153 .             X = Y + Z;
 23-154 .          default:
 23-155 .             SwError;
 23-156 .       } 
 23-157 .    }
 23-158 .    case two:
 23-159 .    {
 23-160 .       run_this;
 23-161 .       break;
 23-162 .    }
 23-163 .    default:
 23-164 .    {
 23-165 .       SwError;
 23-166 .    }
 23-167 . }
 23-168 . 
 23-169 . A = B/C;
 23-170 . A = B-C;
 23-171 . /* LE SV TOC-1609 this is a fpcp-02.1.47 req to set Real Time Clock*/
 23-172 . A = B+C;
 23-173 . 
 23-174 . if (A != B)
 23-175 . {
 23-176 .    A = B + C;
 23-177 .    D = E + F;
 23-178 . }
 23-179 . 
 23-180 . A = B+C;
 23-181 . 
 23-182 . if (A > = B)
 23-183 . {
 23-184 .    A = B + C;
 23-185 .    D = E + F;
 23-186 . }
 23-187 . 
 23-188 . 
 23-189 . if (veg)
 23-190 .    // missing curly brace
 23-191 .    variable = orange;
 23-192 . 
 23-193 . A = B-C;
 23-194 . /* LE SV TOC-1610 this is a fpcp-02.1.52 req to detect error*/
 23-195 . A = B*C;
 23-196 . 
 23-197 . if (A >  B)
 23-198 . {
 23-199 .    A = B + C;
 23-200 .    D = E + F;
 23-201 . }
 23-202 . 
 23-203 . A = B*C;
 23-204 . A = B*C;
 23-205 . A = (long)B + C;
 23-206 . 
 23-207 . if (A >  B)
 23-208 . {
 23-209 .    A = B + C;
 23-210 .    D = E + F;
 23-211 . }
 23-212 . 
 23-213 . 
 23-214 . if (A ge B)
 23-215 . {
 23-216 .    A = B + C;
 23-217 .    D = E + F;
 23-218 . }
 23-219 . 
 23-220 . A = B-C;
 23-221 . A = B-C;
 23-222 . // max LOC 59
 23-223 . 
 23-224 . }
 23-225 . 
 23-226 . 
 23-227 . /*
 23-228 . -----------------------------------------------------------------------------
 23-229 . --| NAME:   fpcp.2.2
 23-230 . --|
 23-231 . --| ABSTRACT:
 23-232 . --|   This function does fpcp stuff.
 23-233 . --|
 23-234 . --| RETURNS:
 23-235 . --|   NONE.
 23-236 . --|
 23-237 . ----------------------------------------------------------------------------
 23-238 . */
 23-239 . static void fpcp.2.2(void)
 23-240 . {
 23-241 . 
 23-242 . if (A >  B)
 23-243 . {
 23-244 .    A = B + C;
 23-245 .    D = E + F;
 23-246 . }
 23-247 . 
 23-248 . A = B*C;
 23-249 . A = B-C;
 23-250 . A = B/C;
 23-251 . 
 23-252 . if (A ne B)
 23-253 . {
 23-254 .    A = B + C;
 23-255 .    D = E + F;
 23-256 . }
 23-257 . 
 23-258 . 
 23-259 . if (A ne B)
 23-260 . {
 23-261 .    A = B + C;
 23-262 .    D = E + F;
 23-263 . }
 23-264 . 
 23-265 . A = B-C;
 23-266 . A = B/C;
 23-267 . A = B-C;
 23-268 . A = B-C;
 23-269 . A = B*C;
 23-270 . // max LOC 11
 23-271 . 
 23-272 . }
 23-273 . 
 23-274 . 
 23-275 . /*
 23-276 . -----------------------------------------------------------------------------
 23-277 . --| NAME:   fpcp.2.3
 23-278 . --|
 23-279 . --| ABSTRACT:
 23-280 . --|   This function does fpcp stuff.
 23-281 . --|
 23-282 . --| RETURNS:
 23-283 . --|   NONE.
 23-284 . --|
 23-285 . ----------------------------------------------------------------------------
 23-286 . */
 23-287 . static void fpcp.2.3(void)
 23-288 . {
 23-289 . A = B+C;
 23-290 . A = B/C;
 23-291 . A = B/C;
 23-292 . A = B*C;
 23-293 . 
 23-294 . if (A != B)
 23-295 . {
 23-296 .    A = B + C;
 23-297 .    D = E + F;
 23-298 . }
 23-299 . 
 23-300 . 
 23-301 . switch (fpcp stuff)
 23-302 . {
 23-303 .    case one:
 23-304 .    {
 23-305 .       run_this; 
 23-306 .       // missing break
 23-307 .    }
 23-308 .    case two:
 23-309 .    {
 23-310 .       run_this;
 23-311 .       break;
 23-312 .    }
 23-313 .    default:
 23-314 .    {
 23-315 .       SwError;
 23-316 .    }
 23-317 . }
 23-318 . 
 23-319 . A = B+C;
 23-320 . 
 23-321 . switch (fpcp stuff)
 23-322 . {
 23-323 .    case one:
 23-324 .    {
 23-325 .       run_this; 
 23-326 .       break;
 23-327 .    }
 23-328 .    case two:
 23-329 .    {
 23-330 .       run_this;
 23-331 .       break;
 23-332 .    }
 23-333 .    default:
 23-334 .    {
 23-335 .        SwError;
 23-336 .    }
 23-337 . }
 23-338 . 
 23-339 . // max LOC 7
 23-340 . 
 23-341 . }
 23-342 . 
 23-343 . 
 23-344 . /*
 23-345 . -----------------------------------------------------------------------------
 23-346 . --| NAME:   fpcp.2.4
 23-347 . --|
 23-348 . --| ABSTRACT:
 23-349 . --|   This function does fpcp stuff.
 23-350 . --|
 23-351 . --| RETURNS:
 23-352 . --|   NONE.
 23-353 . --|
 23-354 . ----------------------------------------------------------------------------
 23-355 . */
 23-356 . static void fpcp.2.4(void)
 23-357 . {
 23-358 . 
 23-359 . if (veg)
 23-360 .    // missing curly brace
 23-361 .    variable = orange;
 23-362 . 
 23-363 . 
 23-364 . if (A ne B)
 23-365 . {
 23-366 .    A = B + C;
 23-367 .    D = E + F;
 23-368 . }
 23-369 . 
 23-370 . A = 0x0006;
 23-371 . 
 23-372 . if (A lt B)
 23-373 . {
 23-374 .    A = B + C;
 23-375 .    D = E + F;
 23-376 . }
 23-377 . 
 23-378 . A = B/C;
 23-379 . A = 0x0007;
 23-380 . A = B/C;
 23-381 . A = B+C;
 23-382 . A = B-C;
 23-383 . 
 23-384 . if (A > = B)
 23-385 . {
 23-386 .    A = B + C;
 23-387 .    D = E + F;
 23-388 . }
 23-389 . 
 23-390 . A = B*C;
 23-391 . A = B/C;
 23-392 . A = B*C;
 23-393 . 
 23-394 . switch (fpcp stuff)
 23-395 . {
 23-396 .    case one:
 23-397 .    {
 23-398 .       run_this; 
 23-399 .       break;
 23-400 .    }
 23-401 .    case two:
 23-402 .    {
 23-403 .       run_this;
 23-404 .       break;
 23-405 .    }
 23-406 .    default:
 23-407 .    {
 23-408 .        SwError;
 23-409 .    }
 23-410 . }
 23-411 . 
 23-412 . A = B/C;
 23-413 . A = B*C;
 23-414 . A = B/C;
 23-415 . A = 0x0002;
 23-416 . 
 23-417 . if (A == B)
 23-418 . {
 23-419 .    A = B + C;
 23-420 .    D = E + F;
 23-421 . }
 23-422 . 
 23-423 . A = 0x0006;
 23-424 . A = B-C;
 23-425 . 
 23-426 . if (A ne B)
 23-427 . {
 23-428 .    A = B + C;
 23-429 .    D = E + F;
 23-430 . }
 23-431 . 
 23-432 . 
 23-433 . if (A != B)
 23-434 . {
 23-435 .    A = B + C;
 23-436 .    D = E + F;
 23-437 . }
 23-438 . 
 23-439 . 
 23-440 . if (A != B)
 23-441 . {
 23-442 .    A = B + C;
 23-443 .    D = E + F;
 23-444 . }
 23-445 . 
 23-446 . A = B*C;
 23-447 . A = B*C;
 23-448 . A = B+C;
 23-449 . A = 0x0002;
 23-450 . 
 23-451 . switch (fpcp stuff)
 23-452 . {
 23-453 .    case one:
 23-454 .    {
 23-455 .       run_this; 
 23-456 .       // missing break
 23-457 .    }
 23-458 .    case two:
 23-459 .    {
 23-460 .       run_this;
 23-461 .       break;
 23-462 .    }
 23-463 .    default:
 23-464 .    {
 23-465 .       SwError;
 23-466 .    }
 23-467 . }
 23-468 . 
 23-469 . A = B+C;
 23-470 . A = B/C;
 23-471 . A = B/C;
 23-472 . 
 23-473 . if (A <  B)
 23-474 . {
 23-475 .    A = B + C;
 23-476 .    D = E + F;
 23-477 . }
 23-478 . 
 23-479 . A = B+C;
 23-480 . 
 23-481 . if (A gt B)
 23-482 . {
 23-483 .    A = B + C;
 23-484 .    D = E + F;
 23-485 . }
 23-486 . 
 23-487 . A = B-C;
 23-488 . A = B/C;
 23-489 . A = B*C;
 23-490 . A = B*C;
 23-491 . A = B+C;
 23-492 . A = B/C;
 23-493 . 
 23-494 . if (A != B)
 23-495 . {
 23-496 .    A = B + C;
 23-497 .    D = E + F;
 23-498 . }
 23-499 . 
 23-500 . A = B*C;
 23-501 . 
 23-502 . if (A ge B)
 23-503 . {
 23-504 .    A = B + C;
 23-505 .    D = E + F;
 23-506 . }
 23-507 . 
 23-508 . A = B*C;
 23-509 . A = B+C;
 23-510 . 
 23-511 . switch (fpcp stuff)
 23-512 . {
 23-513 .    case one:
 23-514 .    {
 23-515 .       run_this; 
 23-516 .       break;
 23-517 .    }
 23-518 .    case two:
 23-519 .    {
 23-520 .       run_this;
 23-521 .       break;
 23-522 .    }
 23-523 .    default:
 23-524 .    {
 23-525 .        SwError;
 23-526 .    }
 23-527 . }
 23-528 . 
 23-529 . A = B-C;
 23-530 . A = B+C;
 23-531 . A = B*C;
 23-532 . /* LE SV TOC-1611 this is a fpcp-02.4.44 req to check unix*/
 23-533 . do forever;
 23-534 . 
 23-535 . if (A >  B)
 23-536 . {
 23-537 .    A = B + C;
 23-538 .    D = E + F;
 23-539 . }
 23-540 . 
 23-541 . A = B/C;
 23-542 . A = B/C;
 23-543 . A = B*C;
 23-544 . 
 23-545 . if (A == B)
 23-546 . {
 23-547 .    A = B + C;
 23-548 .    D = E + F;
 23-549 . }
 23-550 . 
 23-551 . A = B/C;
 23-552 . A = B+C;
 23-553 . A = B*C;
 23-554 . A = B-C;
 23-555 . A = B*C;
 23-556 . 
 23-557 . if (A != B)
 23-558 . {
 23-559 .    A = B + C;
 23-560 .    D = E + F;
 23-561 . }
 23-562 . 
 23-563 . 
 23-564 . if (A == B)
 23-565 . {
 23-566 .    A = B + C;
 23-567 .    D = E + F;
 23-568 . }
 23-569 . 
 23-570 . A = B+C;
 23-571 . /* LE SV TOC-1612 this is a fpcp-02.4.57 req to check unix*/
 23-572 . A = B+C;
 23-573 . A = B+C;
 23-574 . A = B-C;
 23-575 . A = B*C;
 23-576 . 
 23-577 . switch (fpcp stuff)
 23-578 . {
 23-579 .    case one:
 23-580 .    {
 23-581 .       run_this; 
 23-582 .       break;
 23-583 .    }
 23-584 .    case two:
 23-585 .    {
 23-586 .       run_this;
 23-587 .       break;
 23-588 .    }
 23-589 .    default:
 23-590 .    {
 23-591 .        SwError;
 23-592 .    }
 23-593 . }
 23-594 . 
 23-595 . A = B+C;
 23-596 . 
 23-597 . if (A eq B)
 23-598 . {
 23-599 .    A = B + C;
 23-600 .    D = E + F;
 23-601 . }
 23-602 . 
 23-603 . 
 23-604 . if (A le B)
 23-605 . {
 23-606 .    A = B + C;
 23-607 .    D = E + F;
 23-608 . }
 23-609 . 
 23-610 . A = B/C;
 23-611 . A = B/C;
 23-612 . A = B*C;
 23-613 . 
 23-614 . if (A == B)
 23-615 . {
 23-616 .    A = B + C;
 23-617 .    D = E + F;
 23-618 . }
 23-619 . 
 23-620 . A = B+C;
 23-621 . A = B-C;
 23-622 . // max LOC 70
 23-623 . 
 23-624 . }
 23-625 . 
 23-626 . 
 23-627 . /*
 23-628 . -----------------------------------------------------------------------------
 23-629 . --| NAME:   fpcp.2.5
 23-630 . --|
 23-631 . --| ABSTRACT:
 23-632 . --|   This function does fpcp stuff.
 23-633 . --|
 23-634 . --| RETURNS:
 23-635 . --|   NONE.
 23-636 . --|
 23-637 . ----------------------------------------------------------------------------
 23-638 . */
 23-639 . static void fpcp.2.5(void)
 23-640 . {
 23-641 . 
 23-642 . if (A eq B)
 23-643 . {
 23-644 .    A = B + C;
 23-645 .    D = E + F;
 23-646 . }
 23-647 . 
 23-648 . 
 23-649 . #ifdef LAZY
 23-650 .    // this is not nice
 23-651 .    A = B + C;
 23-652 .    A = B + C;
 23-653 . #endif
 23-654 . 
 23-655 . 
 23-656 . if (A le B)
 23-657 . {
 23-658 .    A = B + C;
 23-659 .    D = E + F;
 23-660 . }
 23-661 . 
 23-662 . 
 23-663 . /* 
 23-664 . dead_code = B - C; 
 23-665 . dead_code = D - E; 
 23-666 . dead_code = F - G;
 23-667 . */
 23-668 . 
 23-669 . 
 23-670 . if (A ge B)
 23-671 . {
 23-672 .    A = B + C;
 23-673 .    D = E + F;
 23-674 . }
 23-675 . 
 23-676 . 
 23-677 . if (A ge B)
 23-678 . {
 23-679 .    A = B + C;
 23-680 .    D = E + F;
 23-681 . }
 23-682 . 
 23-683 . FreePtr = HmiStringPtr;
 23-684 . A = B-C;
 23-685 . // ??? go see ws
 23-686 . A = B+C;
 23-687 . A = B*C;
 23-688 . A = B*C;
 23-689 . A = B+C;
 23-690 . A = B+C;
 23-691 . A = B+C;
 23-692 . A = B+C;
 23-693 . // max LOC 12
 23-694 . 
 23-695 . }
 23-696 . 
 23-697 . 
 23-698 . /*
 23-699 . -----------------------------------------------------------------------------
 23-700 . --| NAME:   fpcp.2.6
 23-701 . --|
 23-702 . --| ABSTRACT:
 23-703 . --|   This function does fpcp stuff.
 23-704 . --|
 23-705 . --| RETURNS:
 23-706 . --|   NONE.
 23-707 . --|
 23-708 . ----------------------------------------------------------------------------
 23-709 . */
 23-710 . static void fpcp.2.6(void)
 23-711 . {
 23-712 . A = B+C;
 23-713 . A = B+C;
 23-714 . A = B/C;
 23-715 . A = B-C;
 23-716 . A = B+C;
 23-717 . A = B-C;
 23-718 . A = B/C;
 23-719 . /* LE SV TOC-1613 this is a fpcp-02.6.8 req to verify*/
 23-720 . A = B-C;
 23-721 . A = B+C;
 23-722 . A = B/C;
 23-723 . 
 23-724 . if (A == B)
 23-725 . {
 23-726 .    A = B + C;
 23-727 .    D = E + F;
 23-728 . }
 23-729 . 
 23-730 . 
 23-731 . if (A > = B)
 23-732 . {
 23-733 .    A = B + C;
 23-734 .    D = E + F;
 23-735 . }
 23-736 . 
 23-737 . 
 23-738 . if (A != B)
 23-739 . {
 23-740 .    A = B + C;
 23-741 .    D = E + F;
 23-742 . }
 23-743 . 
 23-744 . 
 23-745 . if (A ne B)
 23-746 . {
 23-747 .    A = B + C;
 23-748 .    D = E + F;
 23-749 . }
 23-750 . 
 23-751 . /* LE SV TOC-1614 this is a fpcp-02.6.15 req to reject*/
 23-752 . 
 23-753 . if (A <  B)
 23-754 . {
 23-755 .    A = B + C;
 23-756 .    D = E + F;
 23-757 . }
 23-758 . 
 23-759 . A = B*C;
 23-760 . 
 23-761 . if (A == B)
 23-762 . {
 23-763 .    A = B + C;
 23-764 .    D = E + F;
 23-765 . }
 23-766 . 
 23-767 . A = B/C;
 23-768 . A = B/C;
 23-769 . A = B*C;
 23-770 . 
 23-771 . switch (fpcp stuff)
 23-772 . {
 23-773 .    case one:
 23-774 .    {
 23-775 .       run_this; 
 23-776 .       break;
 23-777 .    }
 23-778 .    case two:
 23-779 .    {
 23-780 .       run_this;
 23-781 .       break;
 23-782 .    }
 23-783 .    default:
 23-784 .    {
 23-785 .        SwError;
 23-786 .    }
 23-787 . }
 23-788 . 
 23-789 . A = B+C;
 23-790 . A = B-C;
 23-791 . A = B-C;
 23-792 . A = B*C;
 23-793 . 
 23-794 . if (A > = B)
 23-795 . {
 23-796 .    A = B + C;
 23-797 .    D = E + F;
 23-798 . }
 23-799 . 
 23-800 . A = B*C;
 23-801 . A = B/C;
 23-802 . A = B+C;
 23-803 . 
 23-804 . switch (fpcp stuff)
 23-805 . {
 23-806 .    case one:
 23-807 .    {
 23-808 .       run_this; 
 23-809 .       break;
 23-810 .    }
 23-811 .    case two:
 23-812 .    {
 23-813 .       run_this;
 23-814 .       break;
 23-815 .    }
 23-816 .    default:
 23-817 .    {
 23-818 .        SwError;
 23-819 .    }
 23-820 . }
 23-821 . 
 23-822 . A = B+C;
 23-823 . A = B-C;
 23-824 . /* LE SV TOC-1615 this is a fpcp-02.6.33 req to increment*/
 23-825 . A = B-C;
 23-826 . A = B*C;
 23-827 . A = B*C;
 23-828 . 
 23-829 . if (A le B)
 23-830 . {
 23-831 .    A = B + C;
 23-832 .    D = E + F;
 23-833 . }
 23-834 . 
 23-835 . A = B*C;
 23-836 . A = B+C;
 23-837 . A = B+C;
 23-838 . 
 23-839 . if (A ne B)
 23-840 . {
 23-841 .    A = B + C;
 23-842 .    D = E + F;
 23-843 . }
 23-844 . 
 23-845 . A = B*C;
 23-846 . 
 23-847 . if (A == B)
 23-848 . {
 23-849 .    A = B + C;
 23-850 .    D = E + F;
 23-851 . }
 23-852 . 
 23-853 . A = B/C;
 23-854 . 
 23-855 . if (A > = B)
 23-856 . {
 23-857 .    A = B + C;
 23-858 .    D = E + F;
 23-859 . }
 23-860 . 
 23-861 . A = B*C;
 23-862 . A = B-C;
 23-863 . A = B/C;
 23-864 . 
 23-865 . switch (fpcp stuff)
 23-866 . {
 23-867 .    case one:
 23-868 .    {
 23-869 .       switch (nested)
 23-870 .       {
 23-871 .          case:
 23-872 .             X = Y + Z;
 23-873 .          case:
 23-874 .             X = Y + Z;
 23-875 .          default:
 23-876 .             SwError;
 23-877 .       } 
 23-878 .    }
 23-879 .    case two:
 23-880 .    {
 23-881 .       run_this;
 23-882 .       break;
 23-883 .    }
 23-884 .    default:
 23-885 .    {
 23-886 .       SwError;
 23-887 .    }
 23-888 . }
 23-889 . 
 23-890 . A = B*C;
 23-891 . A = B-C;
 23-892 . 
 23-893 . if (A <  B)
 23-894 . {
 23-895 .    A = B + C;
 23-896 .    D = E + F;
 23-897 . }
 23-898 . 
 23-899 . A = B+C;
 23-900 . 
 23-901 . if (A eq B)
 23-902 . {
 23-903 .    A = B + C;
 23-904 .    D = E + F;
 23-905 . }
 23-906 . 
 23-907 . A = B*C;
 23-908 . A = B-C;
 23-909 . A = B+C;
 23-910 . A = 0x0002;
 23-911 . 
 23-912 . if (A ne B)
 23-913 . {
 23-914 .    A = B + C;
 23-915 .    D = E + F;
 23-916 . }
 23-917 . 
 23-918 . A = B*C;
 23-919 . /* LE SV TOC-1616 this is a fpcp-02.6.58 req to compare*/
 23-920 . 
 23-921 . if (A ge B)
 23-922 . {
 23-923 .    A = B + C;
 23-924 .    D = E + F;
 23-925 . }
 23-926 . 
 23-927 . 
 23-928 . if (A != B)
 23-929 . {
 23-930 .    A = B + C;
 23-931 .    D = E + F;
 23-932 . }
 23-933 . 
 23-934 . A = B-C;
 23-935 . A = B-C;
 23-936 . A = B+C;
 23-937 . A = B-C;
 23-938 . A = B/C;
 23-939 . A = B/C;
 23-940 . /* LE SV TOC-1617 this is a fpcp-02.6.66 req to detect error*/
 23-941 . 
 23-942 . if (A eq B)
 23-943 . {
 23-944 .    A = B + C;
 23-945 .    D = E + F;
 23-946 . }
 23-947 . 
 23-948 . // max LOC 66
 23-949 . 
 23-950 . }
 23-951 . 
 23-952 . 
 23-953 . /*
 23-954 . -----------------------------------------------------------------------------
 23-955 . --| NAME:   fpcp.2.7
 23-956 . --|
 23-957 . --| ABSTRACT:
 23-958 . --|   This function does fpcp stuff.
 23-959 . --|
 23-960 . --| RETURNS:
 23-961 . --|   NONE.
 23-962 . --|
 23-963 . ----------------------------------------------------------------------------
 23-964 . */
 23-965 . static void fpcp.2.7(void)
 23-966 . {
 23-967 . A = B-C;
 23-968 . A = B/C;
 23-969 . A = B-C;
 23-970 . 
 23-971 . if (A >  B)
 23-972 . {
 23-973 .    A = B + C;
 23-974 .    D = E + F;
 23-975 . }
 23-976 . 
 23-977 . 
 23-978 . if (A != B)
 23-979 . {
 23-980 .    A = B + C;
 23-981 .    D = E + F;
 23-982 . }
 23-983 . 
 23-984 . A = B/C;
 23-985 . 
 23-986 . if (A > = B)
 23-987 . {
 23-988 .    A = B + C;
 23-989 .    D = E + F;
 23-990 . }
 23-991 . 
 23-992 . A = B*C;
 23-993 . A = B*C;
 23-994 . A = B/C;
 23-995 . 
 23-996 . if (A lt B)
 23-997 . {
 23-998 .    A = B + C;
 23-999 .    D = E + F;
 23-1000 . }
 23-1001 . 
 23-1002 . A = B+C;
 23-1003 . 
 23-1004 . if (A >  B)
 23-1005 . {
 23-1006 .    A = B + C;
 23-1007 .    D = E + F;
 23-1008 . }
 23-1009 . 
 23-1010 . A = B+C;
 23-1011 . A = B/C;
 23-1012 . A = B*C;
 23-1013 . // max LOC 16
 23-1014 . 
 23-1015 . }
 23-1016 . 
 23-1017 . 
 23-1018 . /*
 23-1019 . -----------------------------------------------------------------------------
 23-1020 . --| NAME:   fpcp.2.8
 23-1021 . --|
 23-1022 . --| ABSTRACT:
 23-1023 . --|   This function does fpcp stuff.
 23-1024 . --|
 23-1025 . --| RETURNS:
 23-1026 . --|   NONE.
 23-1027 . --|
 23-1028 . ----------------------------------------------------------------------------
 23-1029 . */
 23-1030 . static void fpcp.2.8(void)
 23-1031 . {
 23-1032 . A = B*C;
 23-1033 . A = B/C;
 23-1034 . A = B/C;
 23-1035 . A = B/C;
 23-1036 . 
 23-1037 . if (A > = B)
 23-1038 . {
 23-1039 .    A = B + C;
 23-1040 .    D = E + F;
 23-1041 . }
 23-1042 . 
 23-1043 . 
 23-1044 . if (A lt B)
 23-1045 . {
 23-1046 .    A = B + C;
 23-1047 .    D = E + F;
 23-1048 . }
 23-1049 . 
 23-1050 . A = B*C;
 23-1051 . // max LOC 7
 23-1052 . 
 23-1053 . }
 23-1054 . 
 23-1055 . 
 23-1056 . /*
 23-1057 . -----------------------------------------------------------------------------
 23-1058 . --| NAME:   fpcp.2.9
 23-1059 . --|
 23-1060 . --| ABSTRACT:
 23-1061 . --|   This function does fpcp stuff.
 23-1062 . --|
 23-1063 . --| RETURNS:
 23-1064 . --|   NONE.
 23-1065 . --|
 23-1066 . ----------------------------------------------------------------------------
 23-1067 . */
 23-1068 . static void fpcp.2.9(void)
 23-1069 . {
 23-1070 . A = B/C;
 23-1071 . A = (long)B + C;
 23-1072 . 
 23-1073 . if (A <  B)
 23-1074 . {
 23-1075 .    A = B + C;
 23-1076 .    D = E + F;
 23-1077 . }
 23-1078 . 
 23-1079 . A = B+C;
 23-1080 . A = B/C;
 23-1081 . /* LE SV TOC-1618 this is a fpcp-02.9.5 req to inhibit*/
 23-1082 . A = B*C;
 23-1083 . A = B*C;
 23-1084 . /* LE SV TOC-1619 this is a fpcp-02.9.7 req to call admin*/
 23-1085 . A = B+C;
 23-1086 . A = B/C;
 23-1087 . /* LE SV TOC-1620 this is a fpcp-02.9.9 req to set Real Time Clock*/
 23-1088 . 
 23-1089 . if {
 23-1090 .    X = Y + Z;
 23-1091 . }
 23-1092 . else {
 23-1093 .    halt;
 23-1094 . }
 23-1095 . 
 23-1096 . A = B/C;
 23-1097 . A = B*C;
 23-1098 . A = B-C;
 23-1099 . /* LE SV TOC-1621 this is a fpcp-02.9.12 req to fail*/
 23-1100 . 
 23-1101 . switch (fpcp stuff)
 23-1102 . {
 23-1103 .    case one:
 23-1104 .    {
 23-1105 .       run_this; 
 23-1106 .       break;
 23-1107 .    }
 23-1108 .    case two:
 23-1109 .    {
 23-1110 .       run_this;
 23-1111 .       break;
 23-1112 .    }
 23-1113 .    default:
 23-1114 .    {
 23-1115 .        SwError;
 23-1116 .    }
 23-1117 . }
 23-1118 . 
 23-1119 . A = B+C;
 23-1120 . 
 23-1121 . if (A == B)
 23-1122 . {
 23-1123 .    A = B + C;
 23-1124 .    D = E + F;
 23-1125 . }
 23-1126 . 
 23-1127 . /* LE SV TOC-1622 this is a fpcp-02.9.15 req to update*/
 23-1128 . A = B*C;
 23-1129 . 
 23-1130 . if (A != B)
 23-1131 . {
 23-1132 .    A = B + C;
 23-1133 .    D = E + F;
 23-1134 . }
 23-1135 . 
 23-1136 . A = B-C;
 23-1137 . A = B/C;
 23-1138 . A = B+C;
 23-1139 . A = B*C;
 23-1140 . 
 23-1141 . switch (fpcp stuff)
 23-1142 . {
 23-1143 .    case one:
 23-1144 .    {
 23-1145 .       run_this; 
 23-1146 .       break;
 23-1147 .    }
 23-1148 .    case two:
 23-1149 .    {
 23-1150 .       run_this;
 23-1151 .       break;
 23-1152 .    }
 23-1153 .    default:
 23-1154 .    {
 23-1155 .        SwError;
 23-1156 .    }
 23-1157 . }
 23-1158 . 
 23-1159 . A = B+C;
 23-1160 . A = B+C;
 23-1161 . A = B+C;
 23-1162 . 
 23-1163 . if (A > = B)
 23-1164 . {
 23-1165 .    A = B + C;
 23-1166 .    D = E + F;
 23-1167 . }
 23-1168 . 
 23-1169 . /* LE SV TOC-1623 this is a fpcp-02.9.26 req to reject*/
 23-1170 . 
 23-1171 . if (A ne B)
 23-1172 . {
 23-1173 .    A = B + C;
 23-1174 .    D = E + F;
 23-1175 . }
 23-1176 . 
 23-1177 . // max LOC 26
 23-1178 . 
 23-1179 . }
 23-1180 . 
 23-1181 . 
 23-1182 . /*
 23-1183 . -----------------------------------------------------------------------------
 23-1184 . --| NAME:   fpcp.2.10
 23-1185 . --|
 23-1186 . --| ABSTRACT:
 23-1187 . --|   This function does fpcp stuff.
 23-1188 . --|
 23-1189 . --| RETURNS:
 23-1190 . --|   NONE.
 23-1191 . --|
 23-1192 . ----------------------------------------------------------------------------
 23-1193 . */
 23-1194 . static void fpcp.2.10(void)
 23-1195 . {
 23-1196 . A = B-C;
 23-1197 . 
 23-1198 . if (A eq B)
 23-1199 . {
 23-1200 .    A = B + C;
 23-1201 .    D = E + F;
 23-1202 . }
 23-1203 . 
 23-1204 . A = B*C;
 23-1205 . A = B/C;
 23-1206 . 
 23-1207 . if (A ne B)
 23-1208 . {
 23-1209 .    A = B + C;
 23-1210 .    D = E + F;
 23-1211 . }
 23-1212 . 
 23-1213 . 
 23-1214 . if (A le B)
 23-1215 . {
 23-1216 .    A = B + C;
 23-1217 .    D = E + F;
 23-1218 . }
 23-1219 . 
 23-1220 . A = B*C;
 23-1221 . // max LOC 7
 23-1222 . 
 23-1223 . }
 23-1224 . 
 23-1225 . 
 23-1226 . /*
 23-1227 . -----------------------------------------------------------------------------
 23-1228 . --| NAME:   fpcp.2.11
 23-1229 . --|
 23-1230 . --| ABSTRACT:
 23-1231 . --|   This function does fpcp stuff.
 23-1232 . --|
 23-1233 . --| RETURNS:
 23-1234 . --|   NONE.
 23-1235 . --|
 23-1236 . ----------------------------------------------------------------------------
 23-1237 . */
 23-1238 . static void fpcp.2.11(void)
 23-1239 . {
 23-1240 . A = B+C;
 23-1241 . A = B-C;
 23-1242 . A = B+C;
 23-1243 . 
 23-1244 . if (A le B)
 23-1245 . {
 23-1246 .    A = B + C;
 23-1247 .    D = E + F;
 23-1248 . }
 23-1249 . 
 23-1250 . A = B*C;
 23-1251 . /* LE SV TOC-1624 this is a fpcp-02.11.6 req to audit*/
 23-1252 . 
 23-1253 . if (A > = B)
 23-1254 . {
 23-1255 .    A = B + C;
 23-1256 .    D = E + F;
 23-1257 . }
 23-1258 . 
 23-1259 . A = B+C;
 23-1260 . A = B+C;
 23-1261 . A = B/C;
 23-1262 . /* LE SV TOC-1625 this is a fpcp-02.11.10 req to translate*/
 23-1263 . A = B+C;
 23-1264 . A = B*C;
 23-1265 . 
 23-1266 . if (A gt B)
 23-1267 . {
 23-1268 .    A = B + C;
 23-1269 .    D = E + F;
 23-1270 . }
 23-1271 . 
 23-1272 . A = B-C;
 23-1273 . 
 23-1274 . if (A lt B)
 23-1275 . {
 23-1276 .    A = B + C;
 23-1277 .    D = E + F;
 23-1278 . }
 23-1279 . 
 23-1280 . A = B*C;
 23-1281 . 
 23-1282 . if (A >  B)
 23-1283 . {
 23-1284 .    A = B + C;
 23-1285 .    D = E + F;
 23-1286 . }
 23-1287 . 
 23-1288 . 
 23-1289 . if (A <  B)
 23-1290 . {
 23-1291 .    A = B + C;
 23-1292 .    D = E + F;
 23-1293 . }
 23-1294 . 
 23-1295 . A = B/C;
 23-1296 . A = B/C;
 23-1297 . A = B-C;
 23-1298 . A = B-C;
 23-1299 . 
 23-1300 . if (A >  B)
 23-1301 . {
 23-1302 .    A = B + C;
 23-1303 .    D = E + F;
 23-1304 . }
 23-1305 . 
 23-1306 . A = B*C;
 23-1307 . 
 23-1308 . if (A > = B)
 23-1309 . {
 23-1310 .    A = B + C;
 23-1311 .    D = E + F;
 23-1312 . }
 23-1313 . 
 23-1314 . 
 23-1315 . if (A lt B)
 23-1316 . {
 23-1317 .    A = B + C;
 23-1318 .    D = E + F;
 23-1319 . }
 23-1320 . 
 23-1321 . A = B+C;
 23-1322 . A = B-C;
 23-1323 . A = B*C;
 23-1324 . A = B/C;
 23-1325 . 
 23-1326 . if (A > = B)
 23-1327 . {
 23-1328 .    A = B + C;
 23-1329 .    D = E + F;
 23-1330 . }
 23-1331 . 
 23-1332 . A = B+C;
 23-1333 . A = B+C;
 23-1334 . A = B+C;
 23-1335 . A = B+C;
 23-1336 . A = B+C;
 23-1337 . A = B-C;
 23-1338 . A = B*C;
 23-1339 . A = B-C;
 23-1340 . A = B+C;
 23-1341 . A = B/C;
 23-1342 . 
 23-1343 . if (A ge B)
 23-1344 . {
 23-1345 .    A = B + C;
 23-1346 .    D = E + F;
 23-1347 . }
 23-1348 . 
 23-1349 . 
 23-1350 . if (A < = B)
 23-1351 . {
 23-1352 .    A = B + C;
 23-1353 .    D = E + F;
 23-1354 . }
 23-1355 . 
 23-1356 . A = B*C;
 23-1357 . // max LOC 43
 23-1358 . 
 23-1359 . }
 23-1360 . 
 23-1361 . 
 23-1362 . /*
 23-1363 . -----------------------------------------------------------------------------
 23-1364 . --| NAME:   fpcp.2.12
 23-1365 . --|
 23-1366 . --| ABSTRACT:
 23-1367 . --|   This function does fpcp stuff.
 23-1368 . --|
 23-1369 . --| RETURNS:
 23-1370 . --|   NONE.
 23-1371 . --|
 23-1372 . ----------------------------------------------------------------------------
 23-1373 . */
 23-1374 . static void fpcp.2.12(void)
 23-1375 . {
 23-1376 . 
 23-1377 . if (A < = B)
 23-1378 . {
 23-1379 .    A = B + C;
 23-1380 .    D = E + F;
 23-1381 . }
 23-1382 . 
 23-1383 . A = B*C;
 23-1384 . 
 23-1385 . if (A == B)
 23-1386 . {
 23-1387 .    A = B + C;
 23-1388 .    D = E + F;
 23-1389 . }
 23-1390 . 
 23-1391 . A = B+C;
 23-1392 . A = B/C;
 23-1393 . A = B*C;
 23-1394 . A = B-C;
 23-1395 . A = B/C;
 23-1396 . A = B-C;
 23-1397 . /* LE SV TOC-1626 this is a fpcp-02.12.10 req to call admin*/
 23-1398 . A = B*C;
 23-1399 . /* LE SV TOC-1627 this is a fpcp-02.12.11 req to check pSOS*/
 23-1400 . A = B/C;
 23-1401 . 
 23-1402 . if (A <  B)
 23-1403 . {
 23-1404 .    A = B + C;
 23-1405 .    D = E + F;
 23-1406 . }
 23-1407 . 
 23-1408 . A = B+C;
 23-1409 . 
 23-1410 . if (A == B)
 23-1411 . {
 23-1412 .    A = B + C;
 23-1413 .    D = E + F;
 23-1414 . }
 23-1415 . 
 23-1416 . A = B-C;
 23-1417 . A = B*C;
 23-1418 . A = B-C;
 23-1419 . 
 23-1420 . if (A != B)
 23-1421 . {
 23-1422 .    A = B + C;
 23-1423 .    D = E + F;
 23-1424 . }
 23-1425 . 
 23-1426 . A = B+C;
 23-1427 . /* LE SV TOC-1628 this is a fpcp-02.12.20 req to check pSOS*/
 23-1428 . 
 23-1429 . if (A eq B)
 23-1430 . {
 23-1431 .    A = B + C;
 23-1432 .    D = E + F;
 23-1433 . }
 23-1434 . 
 23-1435 . rcv_buffer = (U16 *) alloc(size+1);
 23-1436 . A = B/C;
 23-1437 . A = B-C;
 23-1438 . A = B-C;
 23-1439 . A = B-C;
 23-1440 . 
 23-1441 . if (A <  B)
 23-1442 . {
 23-1443 .    A = B + C;
 23-1444 .    D = E + F;
 23-1445 . }
 23-1446 . 
 23-1447 . /* LE SV TOC-1629 this is a fpcp-02.12.26 req to call isr*/
 23-1448 . 
 23-1449 . if (A <  B)
 23-1450 . {
 23-1451 .    A = B + C;
 23-1452 .    D = E + F;
 23-1453 . }
 23-1454 . 
 23-1455 . // max LOC 26
 23-1456 . 
 23-1457 . }
 23-1458 . 
 23-1459 . 
 23-1460 . /*
 23-1461 . -----------------------------------------------------------------------------
 23-1462 . --| NAME:   fpcp.2.13
 23-1463 . --|
 23-1464 . --| ABSTRACT:
 23-1465 . --|   This function does fpcp stuff.
 23-1466 . --|
 23-1467 . --| RETURNS:
 23-1468 . --|   NONE.
 23-1469 . --|
 23-1470 . ----------------------------------------------------------------------------
 23-1471 . */
 23-1472 . static void fpcp.2.13(void)
 23-1473 . {
 23-1474 . 
 23-1475 . if (A le B)
 23-1476 . {
 23-1477 .    A = B + C;
 23-1478 .    D = E + F;
 23-1479 . }
 23-1480 . 
 23-1481 . A = B-C;
 23-1482 . A = B/C;
 23-1483 . goto error;
 23-1484 . 
 23-1485 . if (A eq B)
 23-1486 . {
 23-1487 .    A = B + C;
 23-1488 .    D = E + F;
 23-1489 . }
 23-1490 . 
 23-1491 . /* LE SV TOC-1630 this is a fpcp-02.13.5 req to compare*/
 23-1492 . A = B+C;
 23-1493 . A = B*C;
 23-1494 . A = B/C;
 23-1495 . 
 23-1496 . switch (fpcp stuff)
 23-1497 . {
 23-1498 .    case one:
 23-1499 .    {
 23-1500 .       switch (nested)
 23-1501 .       {
 23-1502 .          case:
 23-1503 .             X = Y + Z;
 23-1504 .          case:
 23-1505 .             X = Y + Z;
 23-1506 .          default:
 23-1507 .             SwError;
 23-1508 .       } 
 23-1509 .    }
 23-1510 .    case two:
 23-1511 .    {
 23-1512 .       run_this;
 23-1513 .       break;
 23-1514 .    }
 23-1515 .    default:
 23-1516 .    {
 23-1517 .       SwError;
 23-1518 .    }
 23-1519 . }
 23-1520 . 
 23-1521 . 
 23-1522 . if (A <  B)
 23-1523 . {
 23-1524 .    A = B + C;
 23-1525 .    D = E + F;
 23-1526 . }
 23-1527 . 
 23-1528 . 
 23-1529 . if (A == B)
 23-1530 . {
 23-1531 .    A = B + C;
 23-1532 .    D = E + F;
 23-1533 . }
 23-1534 . 
 23-1535 . 
 23-1536 . if (A lt B)
 23-1537 . {
 23-1538 .    A = B + C;
 23-1539 .    D = E + F;
 23-1540 . }
 23-1541 . 
 23-1542 . A = B+C;
 23-1543 . A = B-C;
 23-1544 . /* LE SV TOC-1631 this is a fpcp-02.13.13 req to transform*/
 23-1545 . 
 23-1546 . if (A == B)
 23-1547 . {
 23-1548 .    A = B + C;
 23-1549 .    D = E + F;
 23-1550 . }
 23-1551 . 
 23-1552 . 
 23-1553 . switch (fpcp stuff)
 23-1554 . {
 23-1555 .    case one:
 23-1556 .    {
 23-1557 .       run_this;
 23-1558 .       break;
 23-1559 .    }
 23-1560 .    case two:
 23-1561 .    {
 23-1562 .       run_this;
 23-1563 .       break;
 23-1564 .    }
 23-1565 .    // missing default
 23-1566 . }
 23-1567 . 
 23-1568 . 
 23-1569 . if (A le B)
 23-1570 . {
 23-1571 .    A = B + C;
 23-1572 .    D = E + F;
 23-1573 . }
 23-1574 . 
 23-1575 . A = B-C;
 23-1576 . A = B*C;
 23-1577 . A = B/C;
 23-1578 . 
 23-1579 . if (A ne B)
 23-1580 . {
 23-1581 .    A = B + C;
 23-1582 .    D = E + F;
 23-1583 . }
 23-1584 . 
 23-1585 . A = B*C;
 23-1586 . A = B*C;
 23-1587 . A = B/C;
 23-1588 . A = 0x0003;
 23-1589 . A = B-C;
 23-1590 . A = B*C;
 23-1591 . 
 23-1592 . switch (fpcp stuff)
 23-1593 . {
 23-1594 .    case one:
 23-1595 .    {
 23-1596 .       switch (nested)
 23-1597 .       {
 23-1598 .          case:
 23-1599 .             X = Y + Z;
 23-1600 .          case:
 23-1601 .             X = Y + Z;
 23-1602 .          default:
 23-1603 .             SwError;
 23-1604 .       } 
 23-1605 .    }
 23-1606 .    case two:
 23-1607 .    {
 23-1608 .       run_this;
 23-1609 .       break;
 23-1610 .    }
 23-1611 .    default:
 23-1612 .    {
 23-1613 .       SwError;
 23-1614 .    }
 23-1615 . }
 23-1616 . 
 23-1617 . 
 23-1618 . if (A > = B)
 23-1619 . {
 23-1620 .    A = B + C;
 23-1621 .    D = E + F;
 23-1622 . }
 23-1623 . 
 23-1624 . 
 23-1625 . if (A ne B)
 23-1626 . {
 23-1627 .    A = B + C;
 23-1628 .    D = E + F;
 23-1629 . }
 23-1630 . 
 23-1631 . A = B-C;
 23-1632 . A = B/C;
 23-1633 . A = B/C;
 23-1634 . A = B/C;
 23-1635 . A = B-C;
 23-1636 . A = B*C;
 23-1637 . A = B*C;
 23-1638 . A = B+C;
 23-1639 . A = B*C;
 23-1640 . A = B+C;
 23-1641 . 
 23-1642 . if (A != B)
 23-1643 . {
 23-1644 .    A = B + C;
 23-1645 .    D = E + F;
 23-1646 . }
 23-1647 . 
 23-1648 . A = B*C;
 23-1649 . A = B-C;
 23-1650 . A = B/C;
 23-1651 . A = B-C;
 23-1652 . A = B+C;
 23-1653 . 
 23-1654 . if (A gt B)
 23-1655 . {
 23-1656 .    A = B + C;
 23-1657 .    D = E + F;
 23-1658 . }
 23-1659 . 
 23-1660 . A = 0x0001;
 23-1661 . 
 23-1662 . if (A != B)
 23-1663 . {
 23-1664 .    A = B + C;
 23-1665 .    D = E + F;
 23-1666 . }
 23-1667 . 
 23-1668 . A = B+C;
 23-1669 . 
 23-1670 . if (A != B)
 23-1671 . {
 23-1672 .    A = B + C;
 23-1673 .    D = E + F;
 23-1674 . }
 23-1675 . 
 23-1676 . /* LE SV TOC-1632 this is a fpcp-02.13.46 req to reject*/
 23-1677 . 
 23-1678 . if (A gt B)
 23-1679 . {
 23-1680 .    A = B + C;
 23-1681 .    D = E + F;
 23-1682 . }
 23-1683 . 
 23-1684 . A = B+C;
 23-1685 . A = B*C;
 23-1686 . /* LE SV TOC-1633 this is a fpcp-02.13.49 req to set Real Time Clock*/
 23-1687 . A = B*C;
 23-1688 . A = B+C;
 23-1689 . 
 23-1690 . if (A < = B)
 23-1691 . {
 23-1692 .    A = B + C;
 23-1693 .    D = E + F;
 23-1694 . }
 23-1695 . 
 23-1696 . A = B*C;
 23-1697 . /* LE SV TOC-1634 this is a fpcp-02.13.53 req to reject*/
 23-1698 . A = B*C;
 23-1699 . A = B-C;
 23-1700 . A = B+C;
 23-1701 . 
 23-1702 . if (A == B)
 23-1703 . {
 23-1704 .    A = B + C;
 23-1705 .    D = E + F;
 23-1706 . }
 23-1707 . 
 23-1708 . 
 23-1709 . if (A gt B)
 23-1710 . {
 23-1711 .    A = B + C;
 23-1712 .    D = E + F;
 23-1713 . }
 23-1714 . 
 23-1715 . A = B+C;
 23-1716 . 
 23-1717 . if (A < = B)
 23-1718 . {
 23-1719 .    A = B + C;
 23-1720 .    D = E + F;
 23-1721 . }
 23-1722 . 
 23-1723 . 
 23-1724 . if (A <  B)
 23-1725 . {
 23-1726 .    A = B + C;
 23-1727 .    D = E + F;
 23-1728 . }
 23-1729 . 
 23-1730 . A = B*C;
 23-1731 . A = B+C;
 23-1732 . A = B/C;
 23-1733 . A = B*C;
 23-1734 . A = B+C;
 23-1735 . A = B*C;
 23-1736 . 
 23-1737 . if (A < = B)
 23-1738 . {
 23-1739 .    A = B + C;
 23-1740 .    D = E + F;
 23-1741 . }
 23-1742 . 
 23-1743 . A = B/C;
 23-1744 . // max LOC 68
 23-1745 . 
 23-1746 . }
 23-1747 . 
 23-1748 . 
 23-1749 . /*
 23-1750 . -----------------------------------------------------------------------------
 23-1751 . --| NAME:   fpcp.2.14
 23-1752 . --|
 23-1753 . --| ABSTRACT:
 23-1754 . --|   This function does fpcp stuff.
 23-1755 . --|
 23-1756 . --| RETURNS:
 23-1757 . --|   NONE.
 23-1758 . --|
 23-1759 . ----------------------------------------------------------------------------
 23-1760 . */
 23-1761 . static void fpcp.2.14(void)
 23-1762 . {
 23-1763 . A = B+C;
 23-1764 . 
 23-1765 . if (A < = B)
 23-1766 . {
 23-1767 .    A = B + C;
 23-1768 .    D = E + F;
 23-1769 . }
 23-1770 . 
 23-1771 . A = B/C;
 23-1772 . 
 23-1773 . if (A <  B)
 23-1774 . {
 23-1775 .    A = B + C;
 23-1776 .    D = E + F;
 23-1777 . }
 23-1778 . 
 23-1779 . A = B*C;
 23-1780 . A = B+C;
 23-1781 . 
 23-1782 . if (A > = B)
 23-1783 . {
 23-1784 .    A = B + C;
 23-1785 .    D = E + F;
 23-1786 . }
 23-1787 . 
 23-1788 . A = B+C;
 23-1789 . 
 23-1790 . if (A == B)
 23-1791 . {
 23-1792 .    A = B + C;
 23-1793 .    D = E + F;
 23-1794 . }
 23-1795 . 
 23-1796 . free(FreePtr);
 23-1797 . A = B*C;
 23-1798 . A = B+C;
 23-1799 . A = B/C;
 23-1800 . A = B/C;
 23-1801 . 
 23-1802 . if (A >  B)
 23-1803 . {
 23-1804 .    A = B + C;
 23-1805 .    D = E + F;
 23-1806 . }
 23-1807 . 
 23-1808 . 
 23-1809 . switch (fpcp stuff)
 23-1810 . {
 23-1811 .    case one:
 23-1812 .    {
 23-1813 .       run_this; 
 23-1814 .       break;
 23-1815 .    }
 23-1816 .    case two:
 23-1817 .    {
 23-1818 .       run_this;
 23-1819 .       break;
 23-1820 .    }
 23-1821 .    default:
 23-1822 .    {
 23-1823 .        SwError;
 23-1824 .    }
 23-1825 . }
 23-1826 . 
 23-1827 . 
 23-1828 . if (A == B)
 23-1829 . {
 23-1830 .    A = B + C;
 23-1831 .    D = E + F;
 23-1832 . }
 23-1833 . 
 23-1834 . A = B-C;
 23-1835 . A = B*C;
 23-1836 . 
 23-1837 . if (A ne B)
 23-1838 . {
 23-1839 .    A = B + C;
 23-1840 .    D = E + F;
 23-1841 . }
 23-1842 . 
 23-1843 . A = B+C;
 23-1844 . A = B-C;
 23-1845 . 
 23-1846 . if (A != B)
 23-1847 . {
 23-1848 .    A = B + C;
 23-1849 .    D = E + F;
 23-1850 . }
 23-1851 . 
 23-1852 . A = B*C;
 23-1853 . A = B/C;
 23-1854 . A = B+C;
 23-1855 . A = B-C;
 23-1856 . 
 23-1857 . switch (fpcp stuff)
 23-1858 . {
 23-1859 .    case one:
 23-1860 .    {
 23-1861 .       run_this; 
 23-1862 .       break;
 23-1863 .    }
 23-1864 .    case two:
 23-1865 .    {
 23-1866 .       run_this;
 23-1867 .       break;
 23-1868 .    }
 23-1869 .    default:
 23-1870 .    {
 23-1871 .        SwError;
 23-1872 .    }
 23-1873 . }
 23-1874 . 
 23-1875 . A = B/C;
 23-1876 . 
 23-1877 . #ifdef LAZY
 23-1878 .    // this is not nice
 23-1879 .    A = B + C;
 23-1880 .    A = B + C;
 23-1881 . #endif
 23-1882 . 
 23-1883 . 
 23-1884 . if (A != B)
 23-1885 . {
 23-1886 .    A = B + C;
 23-1887 .    D = E + F;
 23-1888 . }
 23-1889 . 
 23-1890 . A = B/C;
 23-1891 . A = B-C;
 23-1892 . 
 23-1893 . if (A lt B)
 23-1894 . {
 23-1895 .    A = B + C;
 23-1896 .    D = E + F;
 23-1897 . }
 23-1898 . 
 23-1899 . A = 0x0006;
 23-1900 . 
 23-1901 . if (A >  B)
 23-1902 . {
 23-1903 .    A = B + C;
 23-1904 .    D = E + F;
 23-1905 . }
 23-1906 . 
 23-1907 . 
 23-1908 . if (A eq B)
 23-1909 . {
 23-1910 .    A = B + C;
 23-1911 .    D = E + F;
 23-1912 . }
 23-1913 . 
 23-1914 . A = B+C;
 23-1915 . 
 23-1916 . if (A < = B)
 23-1917 . {
 23-1918 .    A = B + C;
 23-1919 .    D = E + F;
 23-1920 . }
 23-1921 . 
 23-1922 . A = B-C;
 23-1923 . A = B+C;
 23-1924 . A = B+C;
 23-1925 . 
 23-1926 . if (A eq B)
 23-1927 . {
 23-1928 .    A = B + C;
 23-1929 .    D = E + F;
 23-1930 . }
 23-1931 . 
 23-1932 . A = B/C;
 23-1933 . A = 0x0002;
 23-1934 . A = B*C;
 23-1935 . 
 23-1936 . if (A lt B)
 23-1937 . {
 23-1938 .    A = B + C;
 23-1939 .    D = E + F;
 23-1940 . }
 23-1941 . 
 23-1942 . 
 23-1943 . if (A ne B)
 23-1944 . {
 23-1945 .    A = B + C;
 23-1946 .    D = E + F;
 23-1947 . }
 23-1948 . 
 23-1949 . 
 23-1950 . if (A <  B)
 23-1951 . {
 23-1952 .    A = B + C;
 23-1953 .    D = E + F;
 23-1954 . }
 23-1955 . 
 23-1956 . // max LOC 45
 23-1957 . 
 23-1958 . }
 23-1959 . 

23 23 Result: result/source/ft-app/ft-app-B1.1/fpcp/fpcp-02.c


24 24 Source: source/ft-app/ft-app-B1.1/hmi/hmi-01.c
 24-0 . /*
 24-1 . ----------------------------------------------------------------------------
 24-2 . --| BEGIN PROLOGUE
 24-3 . --|
 24-4 . --| CLASSIFICATION: UNCLASSIFIED
 24-5 . --|
 24-6 . --| FILE NAME:      hmi-01.c
 24-7 . --|
 24-8 . --| ABSTRACT:
 24-9 . --|   This file contains the 9 functions that do file hmi stuff.
 24-10 . --|
 24-11 . --| HISTORY:
 24-12 . --|   CCCQ_NAME:
 24-13 . --|   CCCQ_VER: 
 24-14 . --|
 24-15 . --| END PROLOGUE
 24-16 . ----------------------------------------------------------------------------
 24-17 . */
 24-18 . 
 24-19 . char D;
 24-20 . #define B;
 24-21 . #define B;
 24-22 . int A;
 24-23 . #include C;
 24-24 . #define C;
 24-25 . #define A;
 24-26 . 
 24-27 . 
 24-28 . 
 24-29 . /*
 24-30 . -----------------------------------------------------------------------------
 24-31 . --| NAME:   hmi.1.1
 24-32 . --|
 24-33 . --| ABSTRACT:
 24-34 . --|   This function does hmi stuff.
 24-35 . --|
 24-36 . --| RETURNS:
 24-37 . --|   NONE.
 24-38 . --|
 24-39 . ----------------------------------------------------------------------------
 24-40 . */
 24-41 . static void hmi.1.1(void)
 24-42 . {
 24-43 . 
 24-44 . if (A <  B)
 24-45 . {
 24-46 .    A = B + C;
 24-47 .    D = E + F;
 24-48 . }
 24-49 . 
 24-50 . A = B+C;
 24-51 . A = B/C;
 24-52 . A = B*C;
 24-53 . A = B*C;
 24-54 . A = B-C;
 24-55 . 
 24-56 . if (A le B)
 24-57 . {
 24-58 .    A = B + C;
 24-59 .    D = E + F;
 24-60 . }
 24-61 . 
 24-62 . /* LE SV TOC-1801 this is a hmi-01.1.8 req to audit*/
 24-63 . A = B/C;
 24-64 . A = 0x0004;
 24-65 . A = B*C;
 24-66 . A = B+C;
 24-67 . A = 0x0006;
 24-68 . 
 24-69 . if (A ge B)
 24-70 . {
 24-71 .    A = B + C;
 24-72 .    D = E + F;
 24-73 . }
 24-74 . 
 24-75 . 
 24-76 . /* dead_block = C * D; 
 24-77 . dead_block = E * F; */
 24-78 . 
 24-79 . A = B+C;
 24-80 . A = B*C;
 24-81 . A = B-C;
 24-82 . 
 24-83 . if (A < = B)
 24-84 . {
 24-85 .    A = B + C;
 24-86 .    D = E + F;
 24-87 . }
 24-88 . 
 24-89 . A = B*C;
 24-90 . A = B+C;
 24-91 . A = B+C;
 24-92 . A = B+C;
 24-93 . A = B*C;
 24-94 . A = B-C;
 24-95 . A = B*C;
 24-96 . 
 24-97 . if (A <  B)
 24-98 . {
 24-99 .    A = B + C;
 24-100 .    D = E + F;
 24-101 . }
 24-102 . 
 24-103 . A = B-C;
 24-104 . A = B/C;
 24-105 . // max LOC 25
 24-106 . 
 24-107 . }
 24-108 . 
 24-109 . 
 24-110 . /*
 24-111 . -----------------------------------------------------------------------------
 24-112 . --| NAME:   hmi.1.2
 24-113 . --|
 24-114 . --| ABSTRACT:
 24-115 . --|   This function does hmi stuff.
 24-116 . --|
 24-117 . --| RETURNS:
 24-118 . --|   NONE.
 24-119 . --|
 24-120 . ----------------------------------------------------------------------------
 24-121 . */
 24-122 . static void hmi.1.2(void)
 24-123 . {
 24-124 . 
 24-125 . if (A > = B)
 24-126 . {
 24-127 .    A = B + C;
 24-128 .    D = E + F;
 24-129 . }
 24-130 . 
 24-131 . 
 24-132 . if (A != B)
 24-133 . {
 24-134 .    A = B + C;
 24-135 .    D = E + F;
 24-136 . }
 24-137 . 
 24-138 . A = B/C;
 24-139 . A = B/C;
 24-140 . 
 24-141 . if (A < = B)
 24-142 . {
 24-143 .    A = B + C;
 24-144 .    D = E + F;
 24-145 . }
 24-146 . 
 24-147 . 
 24-148 . if (A gt B)
 24-149 . {
 24-150 .    A = B + C;
 24-151 .    D = E + F;
 24-152 . }
 24-153 . 
 24-154 . A = B+C;
 24-155 . 
 24-156 . if (A lt B)
 24-157 . {
 24-158 .    A = B + C;
 24-159 .    D = E + F;
 24-160 . }
 24-161 . 
 24-162 . A = B-C;
 24-163 . A = B*C;
 24-164 . A = B*C;
 24-165 . A = B*C;
 24-166 . A = B-C;
 24-167 . A = B/C;
 24-168 . A = B*C;
 24-169 . A = B-C;
 24-170 . A = B-C;
 24-171 . 
 24-172 . if (A ge B)
 24-173 . {
 24-174 .    A = B + C;
 24-175 .    D = E + F;
 24-176 . }
 24-177 . 
 24-178 . A = B*C;
 24-179 . A = B*C;
 24-180 . A = B/C;
 24-181 . A = B+C;
 24-182 . 
 24-183 . if (veg)
 24-184 .    // missing curly brace
 24-185 .    variable = orange;
 24-186 . 
 24-187 . 
 24-188 . if (A lt B)
 24-189 . {
 24-190 .    A = B + C;
 24-191 .    D = E + F;
 24-192 . }
 24-193 . 
 24-194 . A = B*C;
 24-195 . 
 24-196 . if (A <  B)
 24-197 . {
 24-198 .    A = B + C;
 24-199 .    D = E + F;
 24-200 . }
 24-201 . 
 24-202 . A = B*C;
 24-203 . A = B/C;
 24-204 . A = B-C;
 24-205 . 
 24-206 . if (A le B)
 24-207 . {
 24-208 .    A = B + C;
 24-209 .    D = E + F;
 24-210 . }
 24-211 . 
 24-212 . A = B*C;
 24-213 . A = B*C;
 24-214 . A = B-C;
 24-215 . A = B*C;
 24-216 . A = B-C;
 24-217 . A = B/C;
 24-218 . A = B+C;
 24-219 . 
 24-220 . if (A lt B)
 24-221 . {
 24-222 .    A = B + C;
 24-223 .    D = E + F;
 24-224 . }
 24-225 . 
 24-226 . 
 24-227 . if (A ge B)
 24-228 . {
 24-229 .    A = B + C;
 24-230 .    D = E + F;
 24-231 . }
 24-232 . 
 24-233 . 
 24-234 . if (A != B)
 24-235 . {
 24-236 .    A = B + C;
 24-237 .    D = E + F;
 24-238 . }
 24-239 . 
 24-240 . A = B+C;
 24-241 . A = B+C;
 24-242 . 
 24-243 . if (A gt B)
 24-244 . {
 24-245 .    A = B + C;
 24-246 .    D = E + F;
 24-247 . }
 24-248 . 
 24-249 . A = B*C;
 24-250 . A = B+C;
 24-251 . A = 0x0004;
 24-252 . 
 24-253 . if (A > = B)
 24-254 . {
 24-255 .    A = B + C;
 24-256 .    D = E + F;
 24-257 . }
 24-258 . 
 24-259 . 
 24-260 . if (A <  B)
 24-261 . {
 24-262 .    A = B + C;
 24-263 .    D = E + F;
 24-264 . }
 24-265 . 
 24-266 . A = B-C;
 24-267 . A = B*C;
 24-268 . 
 24-269 . if (A != B)
 24-270 . {
 24-271 .    A = B + C;
 24-272 .    D = E + F;
 24-273 . }
 24-274 . 
 24-275 . 
 24-276 . switch (hmi stuff)
 24-277 . {
 24-278 .    case one:
 24-279 .    {
 24-280 .       run_this; 
 24-281 .       break;
 24-282 .    }
 24-283 .    case two:
 24-284 .    {
 24-285 .       run_this;
 24-286 .       break;
 24-287 .    }
 24-288 .    default:
 24-289 .    {
 24-290 .        SwError;
 24-291 .    }
 24-292 . }
 24-293 . 
 24-294 . 
 24-295 . if (A != B)
 24-296 . {
 24-297 .    A = B + C;
 24-298 .    D = E + F;
 24-299 . }
 24-300 . 
 24-301 . A = 0x0008;
 24-302 . A = B/C;
 24-303 . A = B*C;
 24-304 . A = B*C;
 24-305 . A = B/C;
 24-306 . 
 24-307 . switch (hmi stuff)
 24-308 . {
 24-309 .    case one:
 24-310 .    {
 24-311 .       run_this; 
 24-312 .       break;
 24-313 .    }
 24-314 .    case two:
 24-315 .    {
 24-316 .       run_this;
 24-317 .       break;
 24-318 .    }
 24-319 .    default:
 24-320 .    {
 24-321 .        SwError;
 24-322 .    }
 24-323 . }
 24-324 . 
 24-325 . A = B+C;
 24-326 . A = B*C;
 24-327 . A = B/C;
 24-328 . A = B/C;
 24-329 . A = B/C;
 24-330 . 
 24-331 . if (A != B)
 24-332 . {
 24-333 .    A = B + C;
 24-334 .    D = E + F;
 24-335 . }
 24-336 . 
 24-337 . A = B/C;
 24-338 . A = B/C;
 24-339 . 
 24-340 . if (A le B)
 24-341 . {
 24-342 .    A = B + C;
 24-343 .    D = E + F;
 24-344 . }
 24-345 . 
 24-346 . A = 0x0009;
 24-347 . 
 24-348 . if (A == B)
 24-349 . {
 24-350 .    A = B + C;
 24-351 .    D = E + F;
 24-352 . }
 24-353 . 
 24-354 . 
 24-355 . if ($hmi stuff >  $otherhmi stuff) 
 24-356 . /* LE SV TOC-008 we really should log all error calls */
 24-357 . {
 24-358 .    A = B + C;
 24-359 . }
 24-360 . 
 24-361 . A = B-C;
 24-362 . 
 24-363 . if (A == B)
 24-364 . {
 24-365 .    A = B + C;
 24-366 .    D = E + F;
 24-367 . }
 24-368 . 
 24-369 . 
 24-370 . if (A < = B)
 24-371 . {
 24-372 .    A = B + C;
 24-373 .    D = E + F;
 24-374 . }
 24-375 . 
 24-376 . A = B+C;
 24-377 . 
 24-378 . if (A eq B)
 24-379 . {
 24-380 .    A = B + C;
 24-381 .    D = E + F;
 24-382 . }
 24-383 . 
 24-384 . A = B-C;
 24-385 . A = B/C;
 24-386 . A = B+C;
 24-387 . // max LOC 74
 24-388 . 
 24-389 . }
 24-390 . 
 24-391 . 
 24-392 . /*
 24-393 . -----------------------------------------------------------------------------
 24-394 . --| NAME:   hmi.1.3
 24-395 . --|
 24-396 . --| ABSTRACT:
 24-397 . --|   This function does hmi stuff.
 24-398 . --|
 24-399 . --| RETURNS:
 24-400 . --|   NONE.
 24-401 . --|
 24-402 . ----------------------------------------------------------------------------
 24-403 . */
 24-404 . static void hmi.1.3(void)
 24-405 . {
 24-406 . A = B*C;
 24-407 . A = B+C;
 24-408 . A = B*C;
 24-409 . A = B-C;
 24-410 . 
 24-411 . if (A ge B)
 24-412 . {
 24-413 .    A = B + C;
 24-414 .    D = E + F;
 24-415 . }
 24-416 . 
 24-417 . A = B+C;
 24-418 . A = B-C;
 24-419 . A = B+C;
 24-420 . 
 24-421 . if (A < = B)
 24-422 . {
 24-423 .    A = B + C;
 24-424 .    D = E + F;
 24-425 . }
 24-426 . 
 24-427 . 
 24-428 . if (A le B)
 24-429 . {
 24-430 .    A = B + C;
 24-431 .    D = E + F;
 24-432 . }
 24-433 . 
 24-434 . /* LE SV TOC-1802 this is a hmi-01.3.11 req to set RTC*/
 24-435 . 
 24-436 . switch (hmi stuff)
 24-437 . {
 24-438 .    case one:
 24-439 .    {
 24-440 .       run_this; 
 24-441 .       break;
 24-442 .    }
 24-443 .    case two:
 24-444 .    {
 24-445 .       run_this;
 24-446 .       break;
 24-447 .    }
 24-448 .    default:
 24-449 .    {
 24-450 .        SwError;
 24-451 .    }
 24-452 . }
 24-453 . 
 24-454 . /* LE SV TOC-1803 this is a hmi-01.3.12 req to fail*/
 24-455 . 
 24-456 . if (A lt B)
 24-457 . {
 24-458 .    A = B + C;
 24-459 .    D = E + F;
 24-460 . }
 24-461 . 
 24-462 . A = B*C;
 24-463 . A = B/C;
 24-464 . A = B*C;
 24-465 . A = B+C;
 24-466 . A = B/C;
 24-467 . A = B/C;
 24-468 . 
 24-469 . if (A != B)
 24-470 . {
 24-471 .    A = B + C;
 24-472 .    D = E + F;
 24-473 . }
 24-474 . 
 24-475 . A = 0x0007;
 24-476 . A = (int)B + C;
 24-477 . A = B-C;
 24-478 . 
 24-479 . if (A lt B)
 24-480 . {
 24-481 .    A = B + C;
 24-482 .    D = E + F;
 24-483 . }
 24-484 . 
 24-485 . A = B+C;
 24-486 . /* LE SV TOC-1804 this is a hmi-01.3.23 req to set RTC*/
 24-487 . A = B+C;
 24-488 . 
 24-489 . if (A eq B)
 24-490 . {
 24-491 .    A = B + C;
 24-492 .    D = E + F;
 24-493 . }
 24-494 . 
 24-495 . 
 24-496 . if (A le B)
 24-497 . {
 24-498 .    A = B + C;
 24-499 .    D = E + F;
 24-500 . }
 24-501 . 
 24-502 . A = B*C;
 24-503 . 
 24-504 . switch (hmi stuff)
 24-505 . {
 24-506 .    case one:
 24-507 .    {
 24-508 .       run_this; 
 24-509 .       break;
 24-510 .    }
 24-511 .    case two:
 24-512 .    {
 24-513 .       run_this;
 24-514 .       break;
 24-515 .    }
 24-516 .    default:
 24-517 .    {
 24-518 .        SwError;
 24-519 .    }
 24-520 . }
 24-521 . 
 24-522 . A = B*C;
 24-523 . A = B*C;
 24-524 . A = B*C;
 24-525 . 
 24-526 . if (A >  B)
 24-527 . {
 24-528 .    A = B + C;
 24-529 .    D = E + F;
 24-530 . }
 24-531 . 
 24-532 . 
 24-533 . if (A ne B)
 24-534 . {
 24-535 .    A = B + C;
 24-536 .    D = E + F;
 24-537 . }
 24-538 . 
 24-539 . A = B/C;
 24-540 . 
 24-541 . if (A gt B)
 24-542 . {
 24-543 .    A = B + C;
 24-544 .    D = E + F;
 24-545 . }
 24-546 . 
 24-547 . A = B*C;
 24-548 . A = B/C;
 24-549 . A = B-C;
 24-550 . A = B+C;
 24-551 . rcv_buffer = (U16 *) alloc(size+1);
 24-552 . A = B*C;
 24-553 . A = B/C;
 24-554 . 
 24-555 . if (A <  B)
 24-556 . {
 24-557 .    A = B + C;
 24-558 .    D = E + F;
 24-559 . }
 24-560 . 
 24-561 . A = B/C;
 24-562 . 
 24-563 . if (A > = B)
 24-564 . {
 24-565 .    A = B + C;
 24-566 .    D = E + F;
 24-567 . }
 24-568 . 
 24-569 . A = B/C;
 24-570 . A = B-C;
 24-571 . 
 24-572 . if (A ne B)
 24-573 . {
 24-574 .    A = B + C;
 24-575 .    D = E + F;
 24-576 . }
 24-577 . 
 24-578 . A = B-C;
 24-579 . A = B+C;
 24-580 . 
 24-581 . if (A lt B)
 24-582 . {
 24-583 .    A = B + C;
 24-584 .    D = E + F;
 24-585 . }
 24-586 . 
 24-587 . 
 24-588 . switch (hmi stuff)
 24-589 . {
 24-590 .    case one:
 24-591 .    {
 24-592 .       run_this; 
 24-593 .       break;
 24-594 .    }
 24-595 .    case two:
 24-596 .    {
 24-597 .       run_this;
 24-598 .       break;
 24-599 .    }
 24-600 .    default:
 24-601 .    {
 24-602 .        SwError;
 24-603 .    }
 24-604 . }
 24-605 . 
 24-606 . 
 24-607 . switch (hmi stuff)
 24-608 . {
 24-609 .    case one:
 24-610 .    {
 24-611 .       run_this; 
 24-612 .       break;
 24-613 .    }
 24-614 .    case two:
 24-615 .    {
 24-616 .       run_this;
 24-617 .       break;
 24-618 .    }
 24-619 .    default:
 24-620 .    {
 24-621 .        SwError;
 24-622 .    }
 24-623 . }
 24-624 . 
 24-625 . 
 24-626 . if (A ge B)
 24-627 . {
 24-628 .    A = B + C;
 24-629 .    D = E + F;
 24-630 . }
 24-631 . 
 24-632 . // max LOC 52
 24-633 . 
 24-634 . }
 24-635 . 
 24-636 . 
 24-637 . /*
 24-638 . -----------------------------------------------------------------------------
 24-639 . --| NAME:   hmi.1.4
 24-640 . --|
 24-641 . --| ABSTRACT:
 24-642 . --|   This function does hmi stuff.
 24-643 . --|
 24-644 . --| RETURNS:
 24-645 . --|   NONE.
 24-646 . --|
 24-647 . ----------------------------------------------------------------------------
 24-648 . */
 24-649 . static void hmi.1.4(void)
 24-650 . {
 24-651 . A = B+C;
 24-652 . A = B*C;
 24-653 . /* LE SV TOC-1805 this is a hmi-01.4.3 req to increment*/
 24-654 . A = B+C;
 24-655 . A = (long)B + C;
 24-656 . 
 24-657 . if (A > = B)
 24-658 . {
 24-659 .    A = B + C;
 24-660 .    D = E + F;
 24-661 . }
 24-662 . 
 24-663 . A = B-C;
 24-664 . A = B/C;
 24-665 . 
 24-666 . if (A > = B)
 24-667 . {
 24-668 .    A = B + C;
 24-669 .    D = E + F;
 24-670 . }
 24-671 . 
 24-672 . 
 24-673 . if (A > = B)
 24-674 . {
 24-675 .    A = B + C;
 24-676 .    D = E + F;
 24-677 . }
 24-678 . 
 24-679 . A = B-C;
 24-680 . A = B/C;
 24-681 . A = B-C;
 24-682 . A = B-C;
 24-683 . A = B+C;
 24-684 . A = B*C;
 24-685 . 
 24-686 . if (A lt B)
 24-687 . {
 24-688 .    A = B + C;
 24-689 .    D = E + F;
 24-690 . }
 24-691 . 
 24-692 . 
 24-693 . if (A <  B)
 24-694 . {
 24-695 .    A = B + C;
 24-696 .    D = E + F;
 24-697 . }
 24-698 . 
 24-699 . A = B/C;
 24-700 . A = B/C;
 24-701 . A = B/C;
 24-702 . /* LE SV TOC-1806 this is a hmi-01.4.20 req to enable*/
 24-703 . A = B+C;
 24-704 . 
 24-705 . if (A != B)
 24-706 . {
 24-707 .    A = B + C;
 24-708 .    D = E + F;
 24-709 . }
 24-710 . 
 24-711 . A = B/C;
 24-712 . A = B*C;
 24-713 . A = B+C;
 24-714 . 
 24-715 . if (A < = B)
 24-716 . {
 24-717 .    A = B + C;
 24-718 .    D = E + F;
 24-719 . }
 24-720 . 
 24-721 . A = B*C;
 24-722 . A = B*C;
 24-723 . A = B+C;
 24-724 . 
 24-725 . if (A >  B)
 24-726 . {
 24-727 .    A = B + C;
 24-728 .    D = E + F;
 24-729 . }
 24-730 . 
 24-731 . 
 24-732 . if (A <  B)
 24-733 . {
 24-734 .    A = B + C;
 24-735 .    D = E + F;
 24-736 . }
 24-737 . 
 24-738 . A = B-C;
 24-739 . 
 24-740 . if (A ge B)
 24-741 . {
 24-742 .    A = B + C;
 24-743 .    D = E + F;
 24-744 . }
 24-745 . 
 24-746 . A = B*C;
 24-747 . A = B+C;
 24-748 . A = B-C;
 24-749 . 
 24-750 . if (A != B)
 24-751 . {
 24-752 .    A = B + C;
 24-753 .    D = E + F;
 24-754 . }
 24-755 . 
 24-756 . A = B-C;
 24-757 . A = B-C;
 24-758 . 
 24-759 . if {
 24-760 .    X = Y + Z;
 24-761 . }
 24-762 . else {
 24-763 .    halt;
 24-764 . }
 24-765 . 
 24-766 . A = B-C;
 24-767 . 
 24-768 . if (A eq B)
 24-769 . {
 24-770 .    A = B + C;
 24-771 .    D = E + F;
 24-772 . }
 24-773 . 
 24-774 . 
 24-775 . if (A >  B)
 24-776 . {
 24-777 .    A = B + C;
 24-778 .    D = E + F;
 24-779 . }
 24-780 . 
 24-781 . 
 24-782 . if (A != B)
 24-783 . {
 24-784 .    A = B + C;
 24-785 .    D = E + F;
 24-786 . }
 24-787 . 
 24-788 . A = B*C;
 24-789 . 
 24-790 . switch (hmi stuff)
 24-791 . {
 24-792 .    case one:
 24-793 .    {
 24-794 .       switch (nested)
 24-795 .       {
 24-796 .          case:
 24-797 .             X = Y + Z;
 24-798 .          case:
 24-799 .             X = Y + Z;
 24-800 .          default:
 24-801 .             SwError;
 24-802 .       } 
 24-803 .    }
 24-804 .    case two:
 24-805 .    {
 24-806 .       run_this;
 24-807 .       break;
 24-808 .    }
 24-809 .    default:
 24-810 .    {
 24-811 .       SwError;
 24-812 .    }
 24-813 . }
 24-814 . 
 24-815 . 
 24-816 . if (A == B)
 24-817 . {
 24-818 .    A = B + C;
 24-819 .    D = E + F;
 24-820 . }
 24-821 . 
 24-822 . 
 24-823 . switch (hmi stuff)
 24-824 . {
 24-825 .       case one:
 24-826 .    {
 24-827 .       run_this;
 24-828 .       break;
 24-829 .    }
 24-830 .    case two:
 24-831 .    {
 24-832 .       run_this;
 24-833 .       break;
 24-834 .    }
 24-835 .    default:
 24-836 .    {
 24-837 .       // missing error call
 24-838 .    }
 24-839 . }
 24-840 . 
 24-841 . A = B+C;
 24-842 . A = B+C;
 24-843 . A = B-C;
 24-844 . A = B*C;
 24-845 . A = B-C;
 24-846 . A = B*C;
 24-847 . A = B*C;
 24-848 . 
 24-849 . if (A le B)
 24-850 . {
 24-851 .    A = B + C;
 24-852 .    D = E + F;
 24-853 . }
 24-854 . 
 24-855 . A = B+C;
 24-856 . 
 24-857 . if (A gt B)
 24-858 . {
 24-859 .    A = B + C;
 24-860 .    D = E + F;
 24-861 . }
 24-862 . 
 24-863 . A = B*C;
 24-864 . A = B-C;
 24-865 . 
 24-866 . if (A lt B)
 24-867 . {
 24-868 .    A = B + C;
 24-869 .    D = E + F;
 24-870 . }
 24-871 . 
 24-872 . 
 24-873 . if (A ne B)
 24-874 . {
 24-875 .    A = B + C;
 24-876 .    D = E + F;
 24-877 . }
 24-878 . 
 24-879 . 
 24-880 . switch (hmi stuff)
 24-881 . {
 24-882 .    case one:
 24-883 .    {
 24-884 .       run_this;
 24-885 .       break;
 24-886 .    }
 24-887 .    case two:
 24-888 .    {
 24-889 .       run_this;
 24-890 .       break;
 24-891 .    }
 24-892 .    // missing default
 24-893 . }
 24-894 . 
 24-895 . A = B/C;
 24-896 . // ??? go see ws
 24-897 . A = B/C;
 24-898 . 
 24-899 . if (A >  B)
 24-900 . {
 24-901 .    A = B + C;
 24-902 .    D = E + F;
 24-903 . }
 24-904 . 
 24-905 . A = B-C;
 24-906 . A = B*C;
 24-907 . A = B/C;
 24-908 . A = B+C;
 24-909 . A = B/C;
 24-910 . 
 24-911 . if (A le B)
 24-912 . {
 24-913 .    A = B + C;
 24-914 .    D = E + F;
 24-915 . }
 24-916 . 
 24-917 . A = B/C;
 24-918 . A = B*C;
 24-919 . 
 24-920 . if (A ge B)
 24-921 . {
 24-922 .    A = B + C;
 24-923 .    D = E + F;
 24-924 . }
 24-925 . 
 24-926 . // max LOC 70
 24-927 . 
 24-928 . }
 24-929 . 
 24-930 . 
 24-931 . /*
 24-932 . -----------------------------------------------------------------------------
 24-933 . --| NAME:   hmi.1.5
 24-934 . --|
 24-935 . --| ABSTRACT:
 24-936 . --|   This function does hmi stuff.
 24-937 . --|
 24-938 . --| RETURNS:
 24-939 . --|   NONE.
 24-940 . --|
 24-941 . ----------------------------------------------------------------------------
 24-942 . */
 24-943 . static void hmi.1.5(void)
 24-944 . {
 24-945 . A = B-C;
 24-946 . A = B*C;
 24-947 . A = B-C;
 24-948 . /* LE SV TOC-1807 this is a hmi-01.5.4 req to record*/
 24-949 . A = B-C;
 24-950 . A = B-C;
 24-951 . 
 24-952 . if (A gt B)
 24-953 . {
 24-954 .    A = B + C;
 24-955 .    D = E + F;
 24-956 . }
 24-957 . 
 24-958 . A = B*C;
 24-959 . 
 24-960 . if (A < = B)
 24-961 . {
 24-962 .    A = B + C;
 24-963 .    D = E + F;
 24-964 . }
 24-965 . 
 24-966 . A = B/C;
 24-967 . A = B-C;
 24-968 . // max LOC 10
 24-969 . 
 24-970 . }
 24-971 . 
 24-972 . 
 24-973 . /*
 24-974 . -----------------------------------------------------------------------------
 24-975 . --| NAME:   hmi.1.6
 24-976 . --|
 24-977 . --| ABSTRACT:
 24-978 . --|   This function does hmi stuff.
 24-979 . --|
 24-980 . --| RETURNS:
 24-981 . --|   NONE.
 24-982 . --|
 24-983 . ----------------------------------------------------------------------------
 24-984 . */
 24-985 . static void hmi.1.6(void)
 24-986 . {
 24-987 . A = B/C;
 24-988 . 
 24-989 . if (A <  B)
 24-990 . {
 24-991 .    A = B + C;
 24-992 .    D = E + F;
 24-993 . }
 24-994 . 
 24-995 . 
 24-996 . if (A gt B)
 24-997 . {
 24-998 .    A = B + C;
 24-999 .    D = E + F;
 24-1000 . }
 24-1001 . 
 24-1002 . A = B+C;
 24-1003 . A = B-C;
 24-1004 . 
 24-1005 . if (A <  B)
 24-1006 . {
 24-1007 .    A = B + C;
 24-1008 .    D = E + F;
 24-1009 . }
 24-1010 . 
 24-1011 . A = B-C;
 24-1012 . A = B*C;
 24-1013 . A = B/C;
 24-1014 . A = B*C;
 24-1015 . A = B-C;
 24-1016 . 
 24-1017 . if (A eq B)
 24-1018 . {
 24-1019 .    A = B + C;
 24-1020 .    D = E + F;
 24-1021 . }
 24-1022 . 
 24-1023 . 
 24-1024 . if (A ge B)
 24-1025 . {
 24-1026 .    A = B + C;
 24-1027 .    D = E + F;
 24-1028 . }
 24-1029 . 
 24-1030 . 
 24-1031 . if (A <  B)
 24-1032 . {
 24-1033 .    A = B + C;
 24-1034 .    D = E + F;
 24-1035 . }
 24-1036 . 
 24-1037 . // max LOC 14
 24-1038 . 
 24-1039 . }
 24-1040 . 
 24-1041 . 
 24-1042 . /*
 24-1043 . -----------------------------------------------------------------------------
 24-1044 . --| NAME:   hmi.1.7
 24-1045 . --|
 24-1046 . --| ABSTRACT:
 24-1047 . --|   This function does hmi stuff.
 24-1048 . --|
 24-1049 . --| RETURNS:
 24-1050 . --|   NONE.
 24-1051 . --|
 24-1052 . ----------------------------------------------------------------------------
 24-1053 . */
 24-1054 . static void hmi.1.7(void)
 24-1055 . {
 24-1056 . A = B/C;
 24-1057 . A = B*C;
 24-1058 . A = B+C;
 24-1059 . 
 24-1060 . switch (hmi stuff)
 24-1061 . {
 24-1062 .    case one:
 24-1063 .    {
 24-1064 .       run_this; 
 24-1065 .       break;
 24-1066 .    }
 24-1067 .    case two:
 24-1068 .    {
 24-1069 .       run_this;
 24-1070 .       break;
 24-1071 .    }
 24-1072 .    default:
 24-1073 .    {
 24-1074 .        SwError;
 24-1075 .    }
 24-1076 . }
 24-1077 . 
 24-1078 . A = B*C;
 24-1079 . A = B+C;
 24-1080 . A = B-C;
 24-1081 . A = B+C;
 24-1082 . /* LE SV TOC-1808 this is a hmi-01.7.9 req to increment*/
 24-1083 . A = B*C;
 24-1084 . A = B+C;
 24-1085 . A = B/C;
 24-1086 . /* LE SV TOC-1809 this is a hmi-01.7.12 req to check unix*/
 24-1087 . A = B/C;
 24-1088 . A = B/C;
 24-1089 . A = B/C;
 24-1090 . 
 24-1091 . if (A < = B)
 24-1092 . {
 24-1093 .    A = B + C;
 24-1094 .    D = E + F;
 24-1095 . }
 24-1096 . 
 24-1097 . A = B/C;
 24-1098 . A = B+C;
 24-1099 . A = B+C;
 24-1100 . A = B/C;
 24-1101 . 
 24-1102 . switch (hmi stuff)
 24-1103 . {
 24-1104 .    case one:
 24-1105 .    {
 24-1106 .       switch (nested)
 24-1107 .       {
 24-1108 .          case:
 24-1109 .             X = Y + Z;
 24-1110 .          case:
 24-1111 .             X = Y + Z;
 24-1112 .          default:
 24-1113 .             SwError;
 24-1114 .       } 
 24-1115 .    }
 24-1116 .    case two:
 24-1117 .    {
 24-1118 .       run_this;
 24-1119 .       break;
 24-1120 .    }
 24-1121 .    default:
 24-1122 .    {
 24-1123 .       SwError;
 24-1124 .    }
 24-1125 . }
 24-1126 . 
 24-1127 . 
 24-1128 . if (A ge B)
 24-1129 . {
 24-1130 .    A = B + C;
 24-1131 .    D = E + F;
 24-1132 . }
 24-1133 . 
 24-1134 . 
 24-1135 . if (A eq B)
 24-1136 . {
 24-1137 .    A = B + C;
 24-1138 .    D = E + F;
 24-1139 . }
 24-1140 . 
 24-1141 . 
 24-1142 . if (A >  B)
 24-1143 . {
 24-1144 .    A = B + C;
 24-1145 .    D = E + F;
 24-1146 . }
 24-1147 . 
 24-1148 . 
 24-1149 . if (A lt B)
 24-1150 . {
 24-1151 .    A = B + C;
 24-1152 .    D = E + F;
 24-1153 . }
 24-1154 . 
 24-1155 . A = B+C;
 24-1156 . 
 24-1157 . if (A ge B)
 24-1158 . {
 24-1159 .    A = B + C;
 24-1160 .    D = E + F;
 24-1161 . }
 24-1162 . 
 24-1163 . A = B*C;
 24-1164 . A = B-C;
 24-1165 . 
 24-1166 . if (A >  B)
 24-1167 . {
 24-1168 .    A = B + C;
 24-1169 .    D = E + F;
 24-1170 . }
 24-1171 . 
 24-1172 . A = B/C;
 24-1173 . A = B/C;
 24-1174 . A = B*C;
 24-1175 . A = B/C;
 24-1176 . 
 24-1177 . if (A < = B)
 24-1178 . {
 24-1179 .    A = B + C;
 24-1180 .    D = E + F;
 24-1181 . }
 24-1182 . 
 24-1183 . A = B*C;
 24-1184 . 
 24-1185 . if (A gt B)
 24-1186 . {
 24-1187 .    A = B + C;
 24-1188 .    D = E + F;
 24-1189 . }
 24-1190 . 
 24-1191 . 
 24-1192 . if (A ne B)
 24-1193 . {
 24-1194 .    A = B + C;
 24-1195 .    D = E + F;
 24-1196 . }
 24-1197 . 
 24-1198 . 
 24-1199 . if (A ne B)
 24-1200 . {
 24-1201 .    A = B + C;
 24-1202 .    D = E + F;
 24-1203 . }
 24-1204 . 
 24-1205 . A = B*C;
 24-1206 . A = B+C;
 24-1207 . A = B/C;
 24-1208 . A = B+C;
 24-1209 . A = B*C;
 24-1210 . A = 0x0006;
 24-1211 . // TBS - I need to figure this out
 24-1212 . A = B*C;
 24-1213 . A = B/C;
 24-1214 . /* LE SV TOC-1810 this is a hmi-01.7.45 req to translate*/
 24-1215 . A = B+C;
 24-1216 . A = B*C;
 24-1217 . A = B*C;
 24-1218 . A = B*C;
 24-1219 . A = B/C;
 24-1220 . A = B/C;
 24-1221 . A = B+C;
 24-1222 . 
 24-1223 . if (A >  B)
 24-1224 . {
 24-1225 .    A = B + C;
 24-1226 .    D = E + F;
 24-1227 . }
 24-1228 . 
 24-1229 . A = B/C;
 24-1230 . A = B/C;
 24-1231 . A = B/C;
 24-1232 . A = B-C;
 24-1233 . 
 24-1234 . switch (hmi stuff)
 24-1235 . {
 24-1236 .    case one:
 24-1237 .    {
 24-1238 .       run_this; 
 24-1239 .       // missing break
 24-1240 .    }
 24-1241 .    case two:
 24-1242 .    {
 24-1243 .       run_this;
 24-1244 .       break;
 24-1245 .    }
 24-1246 .    default:
 24-1247 .    {
 24-1248 .       SwError;
 24-1249 .    }
 24-1250 . }
 24-1251 . 
 24-1252 . A = B/C;
 24-1253 . 
 24-1254 . if (A ne B)
 24-1255 . {
 24-1256 .    A = B + C;
 24-1257 .    D = E + F;
 24-1258 . }
 24-1259 . 
 24-1260 . A = B-C;
 24-1261 . 
 24-1262 . /* 
 24-1263 . dead_code = B - C; 
 24-1264 . dead_code = D - E; 
 24-1265 . dead_code = F - G;
 24-1266 . */
 24-1267 . 
 24-1268 . A = B*C;
 24-1269 . A = B*C;
 24-1270 . A = B/C;
 24-1271 . A = B/C;
 24-1272 . A = B+C;
 24-1273 . A = B*C;
 24-1274 . // max LOC 65
 24-1275 . 
 24-1276 . }
 24-1277 . 
 24-1278 . 
 24-1279 . /*
 24-1280 . -----------------------------------------------------------------------------
 24-1281 . --| NAME:   hmi.1.8
 24-1282 . --|
 24-1283 . --| ABSTRACT:
 24-1284 . --|   This function does hmi stuff.
 24-1285 . --|
 24-1286 . --| RETURNS:
 24-1287 . --|   NONE.
 24-1288 . --|
 24-1289 . ----------------------------------------------------------------------------
 24-1290 . */
 24-1291 . static void hmi.1.8(void)
 24-1292 . {
 24-1293 . 
 24-1294 . if (A ge B)
 24-1295 . {
 24-1296 .    A = B + C;
 24-1297 .    D = E + F;
 24-1298 . }
 24-1299 . 
 24-1300 . A = B-C;
 24-1301 . A = B*C;
 24-1302 . A = B+C;
 24-1303 . A = B-C;
 24-1304 . /* LE SV TOC-1811 this is a hmi-01.8.6 req to detect error*/
 24-1305 . A = B/C;
 24-1306 . A = (float)B + C;
 24-1307 . A = B/C;
 24-1308 . A = B/C;
 24-1309 . 
 24-1310 . if (A >  B)
 24-1311 . {
 24-1312 .    A = B + C;
 24-1313 .    D = E + F;
 24-1314 . }
 24-1315 . 
 24-1316 . A = B-C;
 24-1317 . A = B*C;
 24-1318 . A = B+C;
 24-1319 . 
 24-1320 . if (A ge B)
 24-1321 . {
 24-1322 .    A = B + C;
 24-1323 .    D = E + F;
 24-1324 . }
 24-1325 . 
 24-1326 . A = B*C;
 24-1327 . 
 24-1328 . if (A < = B)
 24-1329 . {
 24-1330 .    A = B + C;
 24-1331 .    D = E + F;
 24-1332 . }
 24-1333 . 
 24-1334 . A = B*C;
 24-1335 . /* LE SV TOC-1812 this is a hmi-01.8.17 req to call admin*/
 24-1336 . A = B/C;
 24-1337 . /* LE SV TOC-1813 this is a hmi-01.8.18 req to enable*/
 24-1338 . A = B/C;
 24-1339 . 
 24-1340 . if (A > = B)
 24-1341 . {
 24-1342 .    A = B + C;
 24-1343 .    D = E + F;
 24-1344 . }
 24-1345 . 
 24-1346 . A = B/C;
 24-1347 . 
 24-1348 . if (A < = B)
 24-1349 . {
 24-1350 .    A = B + C;
 24-1351 .    D = E + F;
 24-1352 . }
 24-1353 . 
 24-1354 . A = B*C;
 24-1355 . // TBS - I need to figure this out
 24-1356 . A = B-C;
 24-1357 . A = B/C;
 24-1358 . A = 0x0008;
 24-1359 . A = B-C;
 24-1360 . A = B/C;
 24-1361 . A = B+C;
 24-1362 . A = B+C;
 24-1363 . A = B+C;
 24-1364 . A = B+C;
 24-1365 . 
 24-1366 . if (A == B)
 24-1367 . {
 24-1368 .    A = B + C;
 24-1369 .    D = E + F;
 24-1370 . }
 24-1371 . 
 24-1372 . A = B+C;
 24-1373 . A = B*C;
 24-1374 . 
 24-1375 . if (A ge B)
 24-1376 . {
 24-1377 .    A = B + C;
 24-1378 .    D = E + F;
 24-1379 . }
 24-1380 . 
 24-1381 . // max LOC 34
 24-1382 . 
 24-1383 . }
 24-1384 . 
 24-1385 . 
 24-1386 . /*
 24-1387 . -----------------------------------------------------------------------------
 24-1388 . --| NAME:   hmi.1.9
 24-1389 . --|
 24-1390 . --| ABSTRACT:
 24-1391 . --|   This function does hmi stuff.
 24-1392 . --|
 24-1393 . --| RETURNS:
 24-1394 . --|   NONE.
 24-1395 . --|
 24-1396 . ----------------------------------------------------------------------------
 24-1397 . */
 24-1398 . static void hmi.1.9(void)
 24-1399 . {
 24-1400 . A = B+C;
 24-1401 . 
 24-1402 . if (A == B)
 24-1403 . {
 24-1404 .    A = B + C;
 24-1405 .    D = E + F;
 24-1406 . }
 24-1407 . 
 24-1408 . A = B-C;
 24-1409 . A = B-C;
 24-1410 . A = B/C;
 24-1411 . A = (float)B + C;
 24-1412 . 
 24-1413 . if (A <  B)
 24-1414 . {
 24-1415 .    A = B + C;
 24-1416 .    D = E + F;
 24-1417 . }
 24-1418 . 
 24-1419 . A = B/C;
 24-1420 . A = B*C;
 24-1421 . 
 24-1422 . if (A gt B)
 24-1423 . {
 24-1424 .    A = B + C;
 24-1425 .    D = E + F;
 24-1426 . }
 24-1427 . 
 24-1428 . // max LOC 9
 24-1429 . 
 24-1430 . }
 24-1431 . 

24 24 Result: result/source/ft-app/ft-app-B1.1/hmi/hmi-01.c


more s_cpc-listing-c025.html