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